@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/renderer/components/st-table/st-table.component.mjs

@@ -0,0 +1,1246 @@
+import { Component, Input, Output, EventEmitter, ViewChild, ElementRef, HostListener } from '@angular/core';
+import { Cell } from '../../models/cell.class';
+import { TableState } from '../../models/table-state.class';
+import { mergeTableConfig } from '../../../models/table-config.interface';
+import { EditMode } from '../../../models/cell-types';
+import { BehaviorSubject } from 'rxjs';
+import { map, distinctUntilChanged } from 'rxjs/operators';
+import { TableZIndex } from '../../models/z-index.enum';
+import { SortDirection } from '../../models/table-types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/json-schema-validator.service";
+import * as i2 from "../../../services/validation-logger.service";
+import * as i3 from "../../../services/virtual-scroll.service";
+import * as i4 from "../st-pagination/st-pagination.component";
+import * as i5 from "../st-column-menu/st-column-menu.component";
+import * as i6 from "../st-row-actions-dropdown/st-row-actions-dropdown.component";
+import * as i7 from "../st-column-editor-modal/st-column-editor-modal.component";
+import * as i8 from "../st-header/st-header.component";
+import * as i9 from "../st-table-actions/st-table-actions.component";
+import * as i10 from "../st-cell/st-cell.component";
+import * as i11 from "@angular/common";
+import * as i12 from "../../directives/st-keyboard-navigation.directive";
+import * as i13 from "../../directives/st-column-resize.directive";
+export class StTableComponent {
+    constructor(schemaValidator, logger, virtualScrollService) {
+        this.schemaValidator = schemaValidator;
+        this.logger = logger;
+        this.virtualScrollService = virtualScrollService;
+        // Z-Index constants for template use
+        this.ZIndex = TableZIndex;
+        // DEPRECATED: Use tableConfig instead
+        this.enableSorting = true;
+        this.enableFiltering = true;
+        // NEW: State change output
+        this.stateChange = new EventEmitter();
+        // NEW: Data change output (for async data updates)
+        this.dataChange = new EventEmitter();
+        // EXISTING: Cell and column events
+        this.cellEdit = new EventEmitter();
+        this.cellSave = new EventEmitter();
+        this.cellCancel = new EventEmitter();
+        this.cellChange = new EventEmitter();
+        this.columnResized = new EventEmitter();
+        this.columnMoved = new EventEmitter();
+        // NEW: Configuration validation output
+        this.configValidationErrors = new EventEmitter();
+        // NEW: Column management output
+        this.columnAdded = new EventEmitter();
+        // NEW: Row action output
+        this.rowAction = new EventEmitter();
+        // NEW: Validation state change output
+        this.validationStateChange = new EventEmitter();
+        // NEW: Optional validation flag
+        this.validateConfig = false;
+        this.internalData$ = new BehaviorSubject([]);
+        this.previousData = [];
+        // Modal state
+        this.showColumnModal = false;
+        // Cached visible columns and cell grid to prevent re-creation on every change detection
+        this.visibleColumns = [];
+        this.visibleCellGrid = [];
+        // Row actions dropdown state
+        this.dropdownState = {
+            isOpen: false,
+            position: { x: 0, y: 0 },
+            context: null
+        };
+        // Column menu dropdown state
+        this.columnMenuState = {
+            isOpen: false,
+            position: { x: 0, y: 0 },
+            context: null
+        };
+        this.virtualScrollState$ = new BehaviorSubject(null);
+        // Observable streams derived from virtual scroll state
+        this.virtualScrollTotalHeight$ = this.virtualScrollState$.pipe(map(state => state?.totalHeight ?? 0), distinctUntilChanged());
+        this.virtualScrollOffsetY$ = this.virtualScrollState$.pipe(map(state => state?.offsetY ?? 0), distinctUntilChanged());
+        this.virtualScrollOffsetYNeg$ = this.virtualScrollState$.pipe(map(state => Number(state?.offsetY ?? 0) * -1), distinctUntilChanged());
+        this.visibleRows$ = this.virtualScrollState$.pipe(map(state => {
+            if (!state)
+                return this.visibleCellGrid;
+            const { startIndex, endIndex } = state;
+            return this.visibleCellGrid.slice(startIndex, endIndex);
+        }));
+        /**
+         * TrackBy function for better performance
+         */
+        this.trackByRowIndex = (index, row) => {
+            return this.getAbsoluteRowIndex(index);
+        };
+    }
+    ngOnInit() {
+        // Validate that at least tableConfig or columns is provided
+        if (!this.tableConfig) {
+            throw new Error('Either tableConfig or columns must be provided');
+        }
+        // Merge config with defaults
+        if (this.tableConfig) {
+            this.mergedConfig = mergeTableConfig(this.tableConfig);
+            // Validate configuration if enabled
+            if (this.validateConfig) {
+                this.validateConfiguration(this.mergedConfig);
+            }
+        }
+        // Create or use TableState
+        if (!this.tableState) {
+            this.createInternalTableState();
+        }
+        else {
+            // Subscribe to external tableState changes
+            this.subscribeToExternalTableState();
+        }
+        // Setup data source (sync or async)
+        this.setupDataSource();
+        // Calculate sticky offsets
+        const rowNumberWidth = this.mergedConfig.showRowNumber ? 30 : 0;
+        const settingsColumnWidth = this.hasRowActions() ? 28 : 0; // Settings column is ~32px wide when visible
+        this.getActiveTableState().calculateStickyOffsets(rowNumberWidth, settingsColumnWidth);
+        // Initialize visible columns and cell grid
+        this.updateVisibleData();
+        // Initialize virtual scroll if enabled
+        if (this.isVirtualScrollEnabled()) {
+            this.initializeVirtualScroll();
+        }
+        // Initialize keyboard navigation if enabled
+        if (this.isKeyboardNavigationEnabled()) {
+            this.initializeKeyboardNavigation();
+        }
+        this.skeletonColumns = Array.from({ length: this.mergedConfig.tableSkeleton?.columns ?? 10 }, (_, i) => i);
+        this.skeletonRows = Array.from({ length: this.mergedConfig.tableSkeleton?.rows ?? 10 }, (_, i) => i);
+    }
+    ngAfterViewInit() {
+        // Setup virtual scroll after view is ready
+        if (this.isVirtualScrollEnabled() && this.scrollViewport) {
+            this.setupVirtualScrollListener();
+        }
+    }
+    ngOnChanges(changes) {
+        // Validate configuration when tableConfig changes
+        if (changes['tableConfig'] && !changes['tableConfig'].firstChange && this.tableConfig) {
+            this.mergedConfig = mergeTableConfig(this.tableConfig);
+            // Validate configuration if enabled
+            if (this.validateConfig) {
+                this.validateConfiguration(this.mergedConfig);
+            }
+            // Update internal table state with new columns if using internal state
+            if (this.internalTableState) {
+                this.internalTableState.updateColumns(this.mergedConfig.columns);
+            }
+            // Update visible columns and cell grid
+            this.updateVisibleData();
+        }
+        // Recreate cell grid when data changes (only if not using data$ Observable)
+        if (changes['data'] && !changes['data'].firstChange && this.data && !this.data$) {
+            this.handleSyncDataChange(changes['data'].previousValue || []);
+        }
+        // Handle data$ Observable input changes
+        if (changes['data$'] && !changes['data$'].firstChange) {
+            this.setupDataSource();
+        }
+        // Recreate cell grid when cellGrid changes
+        if (changes['cellGrid'] && !changes['cellGrid'].firstChange) {
+            // Cell grid was updated externally, no need to recreate
+            // Just recalculate sticky offsets if needed
+            if (this.getActiveTableState()) {
+                const rowNumberWidth = this.mergedConfig.showRowNumber ? 30 : 0;
+                const settingsColumnWidth = this.hasRowActions() ? 32 : 0;
+                this.getActiveTableState().calculateStickyOffsets(rowNumberWidth, settingsColumnWidth);
+            }
+            // Update visible columns and cell grid
+            this.updateVisibleData();
+        }
+        // Recalculate virtual scroll when data changes
+        if ((changes['data'] || changes['cellGrid']) && !changes['data']?.firstChange) {
+            if (this.isVirtualScrollEnabled()) {
+                const currentState = this.virtualScrollState$.value;
+                if (currentState) {
+                    const newState = this.virtualScrollService.calculateVisibleRange({
+                        scrollTop: currentState.scrollTop,
+                        viewportHeight: this.getVirtualScrollViewportHeight(),
+                        totalItems: this.visibleCellGrid.length,
+                        itemSize: this.getVirtualScrollItemSize(),
+                        bufferSize: this.getVirtualScrollBufferSize()
+                    });
+                    this.virtualScrollState$.next(newState);
+                }
+            }
+            // Update keyboard navigation dimensions if enabled
+            if (this.isKeyboardNavigationEnabled() && (changes['data'] || changes['cellGrid'])) {
+                this.getActiveTableState().setDimensions(this.visibleCellGrid.length, this.visibleColumns.length);
+            }
+        }
+    }
+    /**
+     * Create internal TableState from config
+     */
+    createInternalTableState() {
+        const columns = this.getActiveColumns();
+        this.internalTableState = new TableState(columns, {
+            pageSize: this.mergedConfig.pagination?.pageSize,
+            initialPage: this.mergedConfig.initialState?.page
+        });
+        // Set total items if provided in config (for server-side pagination)
+        if (this.mergedConfig.pagination?.totalItems !== undefined) {
+            this.internalTableState.setTotalItems(this.mergedConfig.pagination.totalItems);
+        }
+        // Apply initial sort if provided
+        if (this.mergedConfig.initialState?.sortBy) {
+            this.mergedConfig.initialState.sortBy.forEach(sort => {
+                this.internalTableState.addSortToColumn(sort.key, sort.direction);
+            });
+        }
+        // Apply initial filters if provided
+        if (this.mergedConfig.initialState?.filters) {
+            this.mergedConfig.initialState.filters.forEach(filter => {
+                this.internalTableState.setFilterOnColumn(filter.key, filter.operator, filter.value);
+            });
+        }
+        // Subscribe to internal state changes and re-emit
+        this.stateSubscription = this.internalTableState.stateChange$
+            .subscribe(event => {
+            this.stateChange.emit(event);
+            // Update visible columns and cell grid on visibility changes
+            if (event.type === 'column-visibility' || event.type === 'column-config') {
+                this.updateVisibleData();
+            }
+        });
+        // Subscribe to validation state changes and re-emit
+        this.validationSubscription = this.internalTableState.tableValidationState$
+            .subscribe(state => {
+            this.validationStateChange.emit(state);
+        });
+    }
+    /**
+     * Subscribe to external TableState changes
+     */
+    subscribeToExternalTableState() {
+        if (!this.tableState)
+            return;
+        this.stateSubscription = this.tableState.stateChange$
+            .subscribe(event => {
+            this.stateChange.emit(event);
+            // Update visible columns and cell grid on visibility changes
+            if (event.type === 'column-visibility' || event.type === 'column-config') {
+                this.updateVisibleData();
+            }
+        });
+        // Subscribe to validation state changes and re-emit
+        this.validationSubscription = this.tableState.tableValidationState$
+            .subscribe(state => {
+            this.validationStateChange.emit(state);
+        });
+    }
+    /**
+     * Create cell grid from raw data
+     */
+    createCellGridFromData() {
+        if (!this.data)
+            return;
+        const columns = this.getActiveColumns();
+        this.internalCellGrid = this.data.map((rowData, rowIndex) => columns.map(column => new Cell(column, rowData[column.key], rowData, rowIndex)));
+    }
+    /**
+     * Setup data source - either sync array or async Observable
+     * Handles initialization and subscription to data changes
+     */
+    setupDataSource() {
+        // Warn if both data and data$ are provided
+        if (this.data && this.data$) {
+            console.warn('StTableComponent: Both data and data$ inputs are provided. Using data$ (Observable) and ignoring data array.');
+        }
+        // Clean up existing subscription
+        this.dataSubscription?.unsubscribe();
+        // Priority: data$ takes precedence over data
+        if (this.data$) {
+            this.subscribeToDataChanges();
+        }
+        else if (this.data) {
+            // For sync data, emit once through internal observable
+            this.previousData = [];
+            this.internalData$.next(this.data);
+            this.subscribeToDataChanges();
+        }
+        else {
+            // No data provided, emit empty array
+            this.previousData = [];
+            this.internalData$.next([]);
+            this.subscribeToDataChanges();
+        }
+    }
+    /**
+     * Subscribe to data changes (either from data$ input or internal BehaviorSubject)
+     */
+    subscribeToDataChanges() {
+        const dataSource$ = this.data$ || this.internalData$.asObservable();
+        this.dataSubscription = dataSource$.subscribe(newData => {
+            this.handleDataChange(newData);
+        });
+    }
+    /**
+     * Handle data change from Observable emission
+     */
+    handleDataChange(newData) {
+        const timestamp = Date.now();
+        const source = this.data$ ? 'async' : 'sync';
+        // Emit data change event
+        this.dataChange.emit({
+            previousData: this.previousData,
+            currentData: newData,
+            timestamp,
+            source
+        });
+        // Update data reference
+        this.data = newData;
+        this.previousData = [...newData];
+        // Recreate cell grid
+        this.createCellGridFromData();
+        // Update visible data
+        this.updateVisibleData();
+        // Recalculate virtual scroll if enabled
+        if (this.isVirtualScrollEnabled()) {
+            const currentState = this.virtualScrollState$.value;
+            if (currentState) {
+                const newState = this.virtualScrollService.calculateVisibleRange({
+                    scrollTop: currentState.scrollTop,
+                    viewportHeight: this.getVirtualScrollViewportHeight(),
+                    totalItems: this.visibleCellGrid.length,
+                    itemSize: this.getVirtualScrollItemSize(),
+                    bufferSize: this.getVirtualScrollBufferSize()
+                });
+                this.virtualScrollState$.next(newState);
+            }
+        }
+        // Update keyboard navigation dimensions if enabled
+        if (this.isKeyboardNavigationEnabled()) {
+            this.getActiveTableState().setDimensions(this.visibleCellGrid.length, this.visibleColumns.length);
+        }
+    }
+    /**
+     * Handle sync data change (from @Input() data changes)
+     */
+    handleSyncDataChange(previousData) {
+        this.previousData = previousData;
+        this.internalData$.next(this.data || []);
+    }
+    /**
+     * Get active TableState (provided or internal)
+     */
+    getActiveTableState() {
+        return this.tableState || this.internalTableState;
+    }
+    /**
+     * Get active cell grid (provided or internal)
+     */
+    getActiveCellGrid() {
+        return this.internalCellGrid || [];
+    }
+    /**
+     * Get visible cell grid (filtered to only include visible columns)
+     */
+    getVisibleCellGrid() {
+        const allColumns = this.getActiveColumns();
+        const visibleColumns = this.getVisibleColumns();
+        const visibleColumnKeys = new Set(visibleColumns.map(col => col.key));
+        // Get column indices for visible columns
+        const visibleIndices = allColumns
+            .map((col, index) => visibleColumnKeys.has(col.key) ? index : -1)
+            .filter(index => index !== -1);
+        const fullGrid = this.getActiveCellGrid();
+        return fullGrid.map(row => visibleIndices.map(index => row[index]).filter(cell => cell !== undefined));
+    }
+    /**
+     * Update the visible cell grid based on current visibility and column order
+     * Called when data, visibility, or column order changes
+     *
+     * This method properly handles column reordering by mapping cells based on
+     * column keys rather than indices, ensuring cells follow their columns.
+     */
+    updateVisibleCellGrid() {
+        const fullGrid = this.getActiveCellGrid();
+        // Handle empty grid
+        if (!fullGrid || fullGrid.length === 0) {
+            this.visibleCellGrid = [];
+            return;
+        }
+        // Build a map of columnKey → cellIndex for the current grid structure
+        // This allows us to find cells by column key regardless of their current position
+        const keyToIndexMap = new Map();
+        fullGrid[0]?.forEach((cell, index) => {
+            if (cell) {
+                const columnConfig = cell.getColumnConfig();
+                keyToIndexMap.set(columnConfig.key, index);
+            }
+        });
+        // Reorder cells to match the visibleColumns order
+        // This ensures that when columns are moved, the cell data follows
+        this.visibleCellGrid = fullGrid.map(row => {
+            return this.visibleColumns
+                .map(col => {
+                const cellIndex = keyToIndexMap.get(col.key);
+                return cellIndex !== undefined ? row[cellIndex] : undefined;
+            })
+                .filter((cell) => cell !== undefined);
+        });
+    }
+    /**
+     * Update the visible columns based on current visibility
+     * Called only when visibility actually changes
+     */
+    updateVisibleColumns() {
+        const allColumns = this.getActiveColumns();
+        this.visibleColumns = allColumns.filter(col => col.visible !== false);
+        // Recalculate sticky offsets for visible columns only
+        this.recalculateVisibleStickyOffsets(this.visibleColumns);
+    }
+    /**
+     * Update both visible columns and cell grid
+     * Call this whenever data or visibility changes
+     */
+    updateVisibleData() {
+        this.updateVisibleColumns();
+        this.updateVisibleCellGrid();
+    }
+    /**
+     * Get active columns (from config or legacy input)
+     */
+    getActiveColumns() {
+        return this.mergedConfig.columns;
+    }
+    /**
+     * Get visible columns (filtered by visibility property)
+     * Also recalculates sticky offsets based on visible columns only
+     */
+    getVisibleColumns() {
+        const allColumns = this.getActiveColumns();
+        const visibleColumns = allColumns.filter(col => col.visible !== false); // Default to true if not set
+        // Recalculate sticky offsets for visible columns only
+        this.recalculateVisibleStickyOffsets(visibleColumns);
+        return visibleColumns;
+    }
+    /**
+     * Recalculate sticky offsets based on visible columns only
+     * This ensures correct positioning when columns are hidden
+     */
+    recalculateVisibleStickyOffsets(visibleColumns) {
+        // Calculate left sticky offsets
+        // Account for row number column width if shown
+        let leftOffset = this.mergedConfig.showRowNumber ? 30 : 0;
+        visibleColumns.forEach(col => {
+            if (col.sticky === 'left') {
+                col.stickyOffset = leftOffset;
+                leftOffset += col.width || 100;
+            }
+        });
+        // Calculate right sticky offsets
+        let rightOffset = 0;
+        for (let i = visibleColumns.length - 1; i >= 0; i--) {
+            const col = visibleColumns[i];
+            if (col.sticky === 'right') {
+                col.stickyOffset = rightOffset;
+                rightOffset += col.width || 100;
+            }
+        }
+    }
+    onCellChange(event) {
+        this.cellChange.emit(event);
+    }
+    onColumnResized(event) {
+        // Recalculate sticky offsets after resize
+        const rowNumberWidth = this.mergedConfig.showRowNumber ? 30 : 0;
+        const settingsColumnWidth = this.hasRowActions() ? 32 : 0;
+        this.getActiveTableState().calculateStickyOffsets(rowNumberWidth, settingsColumnWidth);
+        // Emit to parent
+        this.columnResized.emit(event);
+    }
+    onColumnMoved(event) {
+        const columns = this.getActiveColumns();
+        const currentIndex = columns.findIndex(c => c.key === event.columnKey);
+        if (currentIndex === -1)
+            return;
+        // Calculate target index
+        const targetIndex = event.direction === 'left'
+            ? currentIndex - 1
+            : currentIndex + 1;
+        // Check bounds
+        if (targetIndex < 0 || targetIndex >= columns.length) {
+            return;
+        }
+        // Swap columns
+        [columns[currentIndex], columns[targetIndex]] =
+            [columns[targetIndex], columns[currentIndex]];
+        // Update TableState with new column order
+        this.getActiveTableState().updateColumns(columns);
+        this.columnMoved.emit({
+            columnKey: event.columnKey,
+            direction: event.direction,
+            oldIndex: currentIndex,
+            newIndex: targetIndex,
+            column: columns[currentIndex]
+        });
+        // Force virtual scroll to re-render by re-emitting current state
+        // This ensures visibleRows$ picks up the updated visibleCellGrid
+        if (this.isVirtualScrollEnabled()) {
+            const currentState = this.virtualScrollState$.value;
+            if (currentState) {
+                this.virtualScrollState$.next({ ...currentState });
+            }
+        }
+    }
+    /**
+     * Move column to position just before right sticky columns (used when pinning right)
+     */
+    moveColumnToEnd(columnKey) {
+        const columns = this.getActiveColumns();
+        const currentIndex = columns.findIndex(c => c.key === columnKey);
+        if (currentIndex === -1)
+            return;
+        // Find the index of the first right-sticky column
+        const firstRightStickyIndex = columns.findIndex(c => c.sticky === 'right');
+        // Determine target index: just before first right-sticky, or at end if none exist
+        const targetIndex = firstRightStickyIndex !== -1 ? firstRightStickyIndex : columns.length;
+        // If already at target position, no need to move
+        if (currentIndex === targetIndex || currentIndex === targetIndex - 1)
+            return;
+        // Remove column from current position
+        const [column] = columns.splice(currentIndex, 1);
+        // Adjust target index if we removed an element before it
+        const adjustedTargetIndex = currentIndex < targetIndex ? targetIndex - 1 : targetIndex;
+        // Insert at target position (before first right-sticky column, or at end)
+        columns.splice(adjustedTargetIndex, 0, column);
+        // Update TableState with new column order
+        this.getActiveTableState().updateColumns(columns);
+        // Force virtual scroll to re-render
+        if (this.isVirtualScrollEnabled()) {
+            const currentState = this.virtualScrollState$.value;
+            if (currentState) {
+                this.virtualScrollState$.next({ ...currentState });
+            }
+        }
+    }
+    /**
+     * Get cumulative left offset for a sticky column on the left side
+     */
+    getStickyLeftOffset(columnKey) {
+        const columns = this.getActiveColumns();
+        let offset = 0;
+        for (const col of columns) {
+            if (col.key === columnKey)
+                break;
+            if (col.sticky === 'left') {
+                offset += col.width || 100;
+            }
+        }
+        return offset;
+    }
+    /**
+     * Get cumulative right offset for a sticky column on the right side
+     */
+    getStickyRightOffset(columnKey) {
+        const columns = this.getActiveColumns();
+        let offset = 0;
+        const colIndex = columns.findIndex(c => c.key === columnKey);
+        for (let i = colIndex + 1; i < columns.length; i++) {
+            const col = columns[i];
+            if (col.sticky === 'right') {
+                offset += col.width || 100;
+            }
+        }
+        return offset;
+    }
+    /**
+     * Check if top pagination should be shown
+     */
+    showTopPagination() {
+        return this.mergedConfig.pagination?.enabled == true &&
+            this.mergedConfig.pagination?.showTopControls === true;
+    }
+    /**
+     * Check if bottom pagination should be shown
+     */
+    showBottomPagination() {
+        return this.mergedConfig.pagination?.enabled == true &&
+            (this.mergedConfig.pagination?.showBottomControls ?? true);
+    }
+    /**
+     * Validate table configuration
+     * @param config Table configuration to validate
+     */
+    validateConfiguration(config) {
+        const result = this.schemaValidator.validate(config, true, false); // Disable logging here, we'll log manually with context
+        if (!result.valid && result.errors.length > 0) {
+            // Emit validation errors
+            this.configValidationErrors.emit(result.errors);
+            // Log validation errors with context
+            const configSnippet = JSON.stringify(config, null, 2).substring(0, 500); // First 500 chars of config
+            this.logger.logValidationErrors(result.errors, 'renderer', {
+                configSnippet: configSnippet
+            });
+            // Log warnings to console (don't break rendering)
+            console.warn('Smart Table: Configuration validation errors detected:', result.errors);
+            result.errors.forEach(error => {
+                console.warn(`  - ${error.field || error.path}: ${error.message}`);
+            });
+        }
+    }
+    /**
+     * Handle add column button click
+     */
+    onAddColumnClick() {
+        this.showColumnModal = true;
+    }
+    /**
+     * Handle column created from modal
+     */
+    onColumnCreated(column) {
+        const columns = this.getActiveColumns();
+        const addEvent = {
+            column: column,
+            index: columns.length,
+            totalColumns: columns.length + 1
+        };
+        // Emit the new column to parent component
+        this.columnAdded.emit(addEvent);
+        // Close the modal
+        this.showColumnModal = false;
+    }
+    /**
+     * Handle modal cancelled
+     */
+    onModalCancelled() {
+        this.showColumnModal = false;
+    }
+    /**
+     * Check if virtual scroll is enabled
+     */
+    isVirtualScrollEnabled() {
+        return this.mergedConfig.display?.virtualScroll?.enabled ?? false;
+    }
+    /**
+     * Check if column is the first sticky-right column (for shadow styling)
+     */
+    isFirstStickyRight(columnKey) {
+        const stickyRightColumns = this.visibleColumns.filter(col => col.sticky === 'right' && !col.key.includes('settings'));
+        return stickyRightColumns.length > 0 && stickyRightColumns[0].key === columnKey;
+    }
+    /**
+     * Get virtual scroll item size
+     */
+    getVirtualScrollItemSize() {
+        return this.mergedConfig.display?.virtualScroll?.itemSize ?? 48;
+    }
+    /**
+     * Get viewport height
+     */
+    getVirtualScrollViewportHeight() {
+        return this.mergedConfig.display?.virtualScroll?.viewportHeight ?? 600;
+    }
+    /**
+     * Get buffer size
+     */
+    getVirtualScrollBufferSize() {
+        return this.mergedConfig.display?.virtualScroll?.bufferSize ?? 5;
+    }
+    /**
+     * Initialize virtual scroll state
+     */
+    initializeVirtualScroll() {
+        const newState = this.virtualScrollService.calculateVisibleRange({
+            scrollTop: 0,
+            viewportHeight: this.getVirtualScrollViewportHeight(),
+            totalItems: this.visibleCellGrid.length,
+            itemSize: this.getVirtualScrollItemSize(),
+            bufferSize: this.getVirtualScrollBufferSize()
+        });
+        this.virtualScrollState$.next(newState);
+    }
+    /**
+     * Setup scroll event listener
+     */
+    setupVirtualScrollListener() {
+        if (!this.scrollViewport)
+            return;
+        const element = this.scrollViewport.nativeElement;
+        this.scrollContainer = element;
+        this.scrollSubscription = this.virtualScrollService
+            .createScrollObservable(element)
+            .subscribe(scrollTop => this.onVirtualScroll(scrollTop));
+    }
+    /**
+     * Handle virtual scroll event
+     */
+    onVirtualScroll(scrollTop) {
+        const newState = this.virtualScrollService.calculateVisibleRange({
+            scrollTop,
+            viewportHeight: this.getVirtualScrollViewportHeight(),
+            totalItems: this.visibleCellGrid.length,
+            itemSize: this.getVirtualScrollItemSize(),
+            bufferSize: this.getVirtualScrollBufferSize()
+        });
+        this.virtualScrollState$.next(newState);
+    }
+    /**
+     * Get row index for tracking
+     */
+    getAbsoluteRowIndex(relativeIndex) {
+        const currentState = this.virtualScrollState$.value;
+        if (!currentState)
+            return relativeIndex;
+        return currentState.startIndex + relativeIndex;
+    }
+    /**
+     * Scroll to specific row programmatically
+     */
+    scrollToRow(index) {
+        if (!this.scrollContainer || !this.isVirtualScrollEnabled())
+            return;
+        const scrollTop = index * this.getVirtualScrollItemSize();
+        this.scrollContainer.scrollTop = scrollTop;
+    }
+    /**
+     * Check if row actions are enabled
+     */
+    hasRowActions() {
+        return !!(this.mergedConfig.features?.rowManagement?.actions &&
+            this.mergedConfig.features.rowManagement.actions.length > 0);
+    }
+    /**
+     * Get row actions from config
+     */
+    getRowActions() {
+        return this.mergedConfig.features?.rowManagement?.actions || [];
+    }
+    /**
+     * Get row data from cell grid
+     */
+    getRowData(rowIndex) {
+        const cellGrid = this.getActiveCellGrid();
+        if (!cellGrid || rowIndex < 0 || rowIndex >= cellGrid.length) {
+            return null;
+        }
+        const row = cellGrid[rowIndex];
+        if (!row || row.length === 0) {
+            return null;
+        }
+        // Get raw data from first cell (all cells in a row share the same rowData)
+        return row[0]?.getRowData() || null;
+    }
+    /**
+     * Open row actions dropdown
+     */
+    openRowActionsDropdown(event, rowData, rowIndex) {
+        event.preventDefault();
+        event.stopPropagation();
+        const target = event.currentTarget;
+        const rect = target.getBoundingClientRect();
+        // Calculate position (below the button by default)
+        const position = {
+            x: rect.left,
+            y: rect.bottom + 4 // 4px gap
+        };
+        // Create context
+        const context = {
+            rowData,
+            rowIndex,
+            actions: this.getRowActions()
+        };
+        // Update dropdown state
+        this.dropdownState = {
+            isOpen: true,
+            position,
+            context
+        };
+        // Disable body scroll
+        document.body.style.overflow = 'hidden';
+        // If virtual scroll is enabled, add scroll listener to close dropdown
+        if (this.isVirtualScrollEnabled() && this.scrollContainer) {
+            const scrollListener = () => {
+                this.closeRowActionsDropdown();
+                this.scrollContainer?.removeEventListener('scroll', scrollListener);
+            };
+            this.scrollContainer.addEventListener('scroll', scrollListener, { once: true });
+        }
+    }
+    /**
+     * Close row actions dropdown
+     */
+    closeRowActionsDropdown() {
+        this.dropdownState = {
+            isOpen: false,
+            position: { x: 0, y: 0 },
+            context: null
+        };
+        // Re-enable body scroll
+        document.body.style.overflow = '';
+    }
+    /**
+     * Handle row action clicked
+     */
+    onRowActionClicked(event) {
+        // Execute action callback if provided
+        if (event.action.action) {
+            event.action.action(event.rowData, event.rowIndex);
+        }
+        // Emit event to parent
+        this.rowAction.emit(event);
+        // Close dropdown
+        this.closeRowActionsDropdown();
+    }
+    // ============================================================================
+    // COLUMN MENU ACTIONS
+    // ============================================================================
+    /**
+     * Open column menu dropdown
+     */
+    openColumnMenu(event, column, columnIndex, isFirst, isLast) {
+        event.preventDefault();
+        event.stopPropagation();
+        const target = event.currentTarget;
+        const rect = target.getBoundingClientRect();
+        // Calculate position (below the button by default)
+        const position = {
+            x: rect.left,
+            y: rect.bottom + 4 // 4px gap
+        };
+        // Create context
+        const context = {
+            column,
+            columnIndex,
+            isFirstColumn: isFirst,
+            isLastColumn: isLast,
+            tableState: this.getActiveTableState(),
+            actions: this.getColumnActions(column, columnIndex, isFirst, isLast)
+        };
+        // Update column menu state
+        this.columnMenuState = {
+            isOpen: true,
+            position,
+            context
+        };
+        // Disable body scroll
+        document.body.style.overflow = 'hidden';
+        // If virtual scroll is enabled, add scroll listener to close dropdown
+        if (this.isVirtualScrollEnabled() && this.scrollContainer) {
+            const scrollListener = () => {
+                this.closeColumnMenu();
+                this.scrollContainer?.removeEventListener('scroll', scrollListener);
+            };
+            this.scrollContainer.addEventListener('scroll', scrollListener, { once: true });
+        }
+    }
+    /**
+     * Close column menu dropdown
+     */
+    closeColumnMenu() {
+        this.columnMenuState = {
+            isOpen: false,
+            position: { x: 0, y: 0 },
+            context: null
+        };
+        // Re-enable body scroll
+        document.body.style.overflow = '';
+    }
+    /**
+     * Handle column action clicked
+     */
+    onColumnActionClicked(event) {
+        // Execute action callback if provided
+        if (event.action.action) {
+            event.action.action(event.column, event.columnIndex);
+        }
+        // Don't close menu if it's a filter action (filter needs menu to stay open)
+        if (event.action.id === 'filter') {
+            return;
+        }
+        // Close dropdown for other actions
+        this.closeColumnMenu();
+    }
+    /**
+     * Get column actions (built-in + custom)
+     */
+    getColumnActions(column, columnIndex, isFirst, isLast) {
+        const actions = [];
+        // Add built-in actions if enabled (default: true)
+        const includeBuiltIn = column.includeBuiltInActions ?? true;
+        if (includeBuiltIn) {
+            actions.push(...this.getBuiltInColumnActions(column, columnIndex, isFirst, isLast));
+        }
+        // Add custom column actions from config
+        if (column.columnActions && column.columnActions.length > 0) {
+            actions.push(...column.columnActions);
+        }
+        return actions;
+    }
+    /**
+     * Get built-in column actions (sort, filter, pin, move)
+     */
+    getBuiltInColumnActions(column, columnIndex, isFirst, isLast) {
+        const tableState = this.getActiveTableState();
+        const actions = [];
+        // Sort ascending
+        if (column.sortable !== false) {
+            actions.push({
+                id: 'sort-asc',
+                label: this.getSortLabel(column, 'asc'),
+                icon: '↑',
+                action: (col) => {
+                    tableState.addSortToColumn(col.key, SortDirection.ASC);
+                }
+            });
+        }
+        // Sort descending
+        if (column.sortable !== false) {
+            actions.push({
+                id: 'sort-desc',
+                label: this.getSortLabel(column, 'desc'),
+                icon: '↓',
+                action: (col) => {
+                    tableState.addSortToColumn(col.key, SortDirection.DESC);
+                }
+            });
+        }
+        // Clear sort (only show if currently sorted)
+        if (column.sortable !== false && column.sortDirection && column.sortDirection !== SortDirection.NONE) {
+            actions.push({
+                id: 'clear-sort',
+                label: 'Clear Sort',
+                icon: '✕',
+                action: (col) => {
+                    tableState.addSortToColumn(col.key, SortDirection.NONE);
+                }
+            });
+        }
+        // Filter
+        if (column.filterable !== false) {
+            actions.push({
+                id: 'filter',
+                label: 'Filter',
+                icon: '⚑',
+                action: () => {
+                    // Filter action handled by column menu component
+                }
+            });
+        }
+        // Pin Left (if not already pinned)
+        if (column.pinnable !== false && column.sticky !== 'left' && column.sticky !== 'right') {
+            actions.push({
+                id: 'pin-left',
+                label: 'Pin Left',
+                icon: '📌',
+                action: (col) => {
+                    tableState.setStickyColumn(col.key, 'left');
+                }
+            });
+        }
+        // Pin Right (if not already pinned)
+        if (column.pinnable !== false && column.sticky !== 'left' && column.sticky !== 'right') {
+            actions.push({
+                id: 'pin-right',
+                label: 'Pin Right',
+                icon: '📌',
+                action: (col) => {
+                    this.moveColumnToEnd(col.key);
+                    tableState.setStickyColumn(col.key, 'right');
+                }
+            });
+        }
+        // Unpin (if currently pinned)
+        if (column.pinnable !== false && (column.sticky === 'left' || column.sticky === 'right')) {
+            actions.push({
+                id: 'unpin',
+                label: 'Unpin',
+                icon: '📍',
+                action: (col) => {
+                    tableState.setStickyColumn(col.key, false);
+                }
+            });
+        }
+        // Move left (only if movable and not pinned)
+        if (!isFirst && column.movable !== false && !column.sticky) {
+            actions.push({
+                id: 'move-left',
+                label: 'Move Left',
+                icon: '←',
+                action: (col) => {
+                    this.onColumnMoved({
+                        columnKey: col.key,
+                        direction: 'left'
+                    });
+                }
+            });
+        }
+        // Move right (only if movable and not pinned)
+        if (!isLast && column.movable !== false && !column.sticky) {
+            actions.push({
+                id: 'move-right',
+                label: 'Move Right',
+                icon: '→',
+                action: (col) => {
+                    this.onColumnMoved({
+                        columnKey: col.key,
+                        direction: 'right'
+                    });
+                }
+            });
+        }
+        return actions;
+    }
+    /**
+     * Get sort label based on column data type
+     */
+    getSortLabel(column, direction) {
+        const dataType = column.dataType;
+        if (dataType === 'number') {
+            return direction === 'asc' ? 'Sort 0→9' : 'Sort 9→0';
+        }
+        else if (dataType === 'date') {
+            return direction === 'asc' ? 'Sort Oldest First' : 'Sort Newest First';
+        }
+        else {
+            return direction === 'asc' ? 'Sort A→Z' : 'Sort Z→A';
+        }
+    }
+    // ============================================================================
+    // KEYBOARD NAVIGATION
+    // ============================================================================
+    /**
+     * Initialize keyboard navigation
+     */
+    initializeKeyboardNavigation() {
+        const tableState = this.getActiveTableState();
+        tableState.setDimensions(this.visibleCellGrid.length, this.visibleColumns.length);
+        // Subscribe to focus position changes
+        this.focusSubscription = tableState.focusedCellPosition$.subscribe(position => {
+            this.updateCellFocusStates(position);
+        });
+        // Auto-focus first cell to enable keyboard navigation
+        if (this.visibleCellGrid.length > 0 && this.visibleColumns.length > 0) {
+            setTimeout(() => {
+                tableState.focusCell(0, 0);
+            }, 0);
+        }
+    }
+    /**
+     * Update focus state in all cells
+     */
+    updateCellFocusStates(position) {
+        if (!this.visibleCellGrid)
+            return;
+        for (let rowIndex = 0; rowIndex < this.visibleCellGrid.length; rowIndex++) {
+            const row = this.visibleCellGrid[rowIndex];
+            for (let colIndex = 0; colIndex < row.length; colIndex++) {
+                const cell = row[colIndex];
+                if (!cell)
+                    continue;
+                const shouldFocus = position &&
+                    position.rowIndex === rowIndex &&
+                    position.columnIndex === colIndex;
+                if (shouldFocus) {
+                    cell.focus();
+                    // Focus the actual DOM element
+                    this.focusTdElement(rowIndex, colIndex);
+                }
+                else {
+                    cell.blur();
+                }
+            }
+        }
+    }
+    /**
+     * Focus the TD element in the DOM
+     */
+    focusTdElement(rowIndex, colIndex) {
+        // Use setTimeout to ensure DOM has updated
+        setTimeout(() => {
+            // More robust: find the td by data attributes
+            const tr = document.querySelector(`tr[data-row-index="${rowIndex}"]`);
+            if (tr) {
+                const cells = tr.querySelectorAll('td:not(.settings-column)');
+                const targetCell = cells[colIndex];
+                if (targetCell) {
+                    targetCell.focus({ preventScroll: false });
+                }
+            }
+        }, 0);
+    }
+    /**
+     * Handle cell click
+     */
+    onCellClick(rowIndex, columnIndex) {
+        if (!this.isKeyboardNavigationEnabled())
+            return;
+        this.getActiveTableState().focusCell(rowIndex, columnIndex);
+    }
+    /**
+     * Handle cell entering edit mode
+     */
+    onCellEdit(event) {
+        this.cellEdit.emit(event);
+        if (this.isKeyboardNavigationEnabled()) {
+            const rowIndex = event.cell.getRowIndex();
+            const columnKey = event.columnKey;
+            const columnIndex = this.visibleColumns.findIndex(col => col.key === columnKey);
+            if (rowIndex !== undefined && columnIndex >= 0) {
+                this.getActiveTableState().setEditingCell(rowIndex, columnIndex);
+            }
+        }
+    }
+    /**
+     * Handle cell save
+     */
+    onCellSave(event) {
+        this.cellSave.emit(event);
+        if (this.isKeyboardNavigationEnabled()) {
+            this.getActiveTableState().clearEditingCell();
+        }
+    }
+    /**
+     * Handle cell cancel
+     */
+    onCellCancel(event) {
+        this.cellCancel.emit(event);
+        if (this.isKeyboardNavigationEnabled()) {
+            this.getActiveTableState().clearEditingCell();
+        }
+    }
+    /**
+     * Handle cell save with navigation (Excel-like behavior)
+     */
+    onCellSaveAndNavigate(event) {
+        // Navigation is already handled by the directive after save
+        // Just ensure editing state is cleared
+        if (this.isKeyboardNavigationEnabled()) {
+            this.getActiveTableState().clearEditingCell();
+            // Move focus in the specified direction
+            setTimeout(() => {
+                this.getActiveTableState().moveFocus(event.direction);
+            }, 0);
+        }
+    }
+    /**
+     * Handle focus on table container - focus first cell if no cell is focused
+     */
+    onTableContainerFocus(event) {
+        if (!this.isKeyboardNavigationEnabled())
+            return;
+        const tableState = this.getActiveTableState();
+        const currentFocus = tableState.getFocusedPosition();
+        // If no cell is focused, focus the first cell
+        if (!currentFocus && this.visibleCellGrid.length > 0 && this.visibleColumns.length > 0) {
+            tableState.focusCell(0, 0);
+        }
+    }
+    /**
+     * Check if keyboard navigation is enabled
+     */
+    isKeyboardNavigationEnabled() {
+        return this.mergedConfig.features?.keyboardNavigation?.enabled ?? false;
+    }
+    /**
+     * Get EditMode enum value for cells
+     * For Excel-like tables with keyboard navigation, use ENTER mode
+     * which allows arrow key navigation without triggering edit.
+     * Double-click will still work to start editing.
+     */
+    getEditModeForCells() {
+        // If keyboard navigation is enabled, use ENTER mode for Excel-like behavior
+        // Otherwise use CLICK mode for immediate editing
+        if (this.isKeyboardNavigationEnabled()) {
+            return EditMode.ENTER;
+        }
+        return EditMode.CLICK;
+    }
+    /**
+     * Clear focus when clicking outside table
+     */
+    onDocumentClick(event) {
+        if (!this.isKeyboardNavigationEnabled())
+            return;
+        const target = event.target;
+        const tableElement = target.closest('.st-table');
+        if (!tableElement) {
+            this.getActiveTableState().clearFocus();
+            this.getActiveTableState().clearEditingCell();
+        }
+    }
+    ngOnDestroy() {
+        this.stateSubscription?.unsubscribe();
+        this.scrollSubscription?.unsubscribe();
+        this.focusSubscription?.unsubscribe();
+        this.validationSubscription?.unsubscribe();
+        this.dataSubscription?.unsubscribe();
+        this.virtualScrollState$.complete();
+        this.internalData$.complete();
+    }
+}
+StTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StTableComponent, deps: [{ token: i1.JsonSchemaValidatorService }, { token: i2.ValidationLoggerService }, { token: i3.VirtualScrollService }], target: i0.ɵɵFactoryTarget.Component });
+StTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: StTableComponent, selector: "st-table", inputs: { tableConfig: "tableConfig", data: "data", data$: "data$", tableState: "tableState", enableSorting: "enableSorting", enableFiltering: "enableFiltering", validateConfig: "validateConfig" }, outputs: { stateChange: "stateChange", dataChange: "dataChange", cellEdit: "cellEdit", cellSave: "cellSave", cellCancel: "cellCancel", cellChange: "cellChange", columnResized: "columnResized", columnMoved: "columnMoved", configValidationErrors: "configValidationErrors", columnAdded: "columnAdded", rowAction: "rowAction", validationStateChange: "validationStateChange" }, host: { listeners: { "document:click": "onDocumentClick($event)" } }, viewQueries: [{ propertyName: "scrollViewport", first: true, predicate: ["scrollViewport"], descendants: true, read: ElementRef }], usesOnChanges: true, ngImport: i0, template: "<!-- Top pagination controls -->\n<st-pagination \n  *ngIf=\"showTopPagination() && !(mergedConfig.tableSkeleton?.enabled | async)\" \n  [tableState]=\"getActiveTableState()\"\n  [tableConfig]=\"mergedConfig\"\n  position=\"top\">\n</st-pagination>\n\n<div class=\"st-table\" *ngIf=\"!(mergedConfig.tableSkeleton?.enabled | async)\" \n  [ngClass]=\"{\n    'virtual-scroll-enabled': isVirtualScrollEnabled(),\n    'keyboard-navigation-enabled': isKeyboardNavigationEnabled()\n  }\"\n  [ngStyle]=\"{\n    'max-height.px': !isVirtualScrollEnabled() ? mergedConfig.display?.maxHeight : null\n  }\"\n  stKeyboardNavigation\n  [tableState]=\"getActiveTableState()\" \n  [attr.tabindex]=\"isKeyboardNavigationEnabled() ? 0 : -1\"\n  (focus)=\"onTableContainerFocus($event)\"\n  [attr.title]=\"isKeyboardNavigationEnabled() ? 'Click a cell or press Tab to start keyboard navigation' : null\">\n  <!-- Unified Table Actions Menu -->\n\n  <!-- Virtual scroll viewport wrapper -->\n  <div class=\"st-scroll-viewport\" #scrollViewport *ngIf=\"isVirtualScrollEnabled()\"\n    [ngStyle]=\"{ 'height.px': getVirtualScrollViewportHeight() }\">\n\n    <!-- Spacer to create scrollable area -->\n    <div class=\"st-scroll-spacer\" [ngStyle]=\"{ 'height.px': virtualScrollTotalHeight$ | async }\">\n    </div>\n\n    <!-- Table positioner with transform (instead of tbody) -->\n    <div class=\"st-table-positioner\" [ngStyle]=\"{ transform: 'translateY(' + (virtualScrollOffsetY$ | async) + 'px)' }\">\n      <!-- Table with only visible rows -->\n      <ng-container *ngTemplateOutlet=\"tableTemplate; context: { \n        mode: 'virtual',\n        theadStyle: { top: (virtualScrollOffsetYNeg$ | async) + 'px' }\n      }\"></ng-container>\n    </div>\n  </div>\n  \n  <!-- Standard table (when virtual scroll disabled) -->\n  <ng-container *ngIf=\"!isVirtualScrollEnabled()\">\n    <ng-container *ngTemplateOutlet=\"tableTemplate; context: { \n      mode: 'standard',\n      theadStyle: null\n    }\"></ng-container>\n  </ng-container>\n\n  <!-- Shared Column Menu Dropdown -->\n  <st-column-menu-dropdown \n  [isOpen]=\"columnMenuState.isOpen\"\n  [position]=\"columnMenuState.position\"\n  [context]=\"columnMenuState.context\"\n  (actionClicked)=\"onColumnActionClicked($event)\"\n  (closed)=\"closeColumnMenu()\">\n  </st-column-menu-dropdown>\n</div>\n\n<ng-container *ngIf=\"(mergedConfig.tableSkeleton?.enabled | async)\">\n  <ng-container *ngTemplateOutlet=\"skeletonLoader\"></ng-container>\n</ng-container>\n\n<!-- Shared Row Actions Dropdown -->\n<st-row-actions-dropdown [isOpen]=\"dropdownState.isOpen\" [position]=\"dropdownState.position\"\n  [context]=\"dropdownState.context\" (actionClicked)=\"onRowActionClicked($event)\" (closed)=\"closeRowActionsDropdown()\">\n</st-row-actions-dropdown>\n\n\n<!-- Bottom pagination controls -->\n<st-pagination \n  *ngIf=\"showBottomPagination() && !(mergedConfig.tableSkeleton?.enabled | async)\" \n  [tableState]=\"getActiveTableState()\"\n  [tableConfig]=\"mergedConfig\"\n  position=\"bottom\">\n</st-pagination>\n\n<!-- Add Column Modal -->\n<st-column-editor-modal *ngIf=\"showColumnModal\" (columnCreated)=\"onColumnCreated($event)\"\n  (cancelled)=\"onModalCancelled()\">\n</st-column-editor-modal>\n\n  <!-- ========================================== -->\n  <!-- REUSABLE TABLE TEMPLATE -->\n  <!-- ========================================== -->\n  <ng-template #tableTemplate let-mode=\"mode\" let-theadStyle=\"theadStyle\">\n    <table class=\"st-table-element\">\n      <!-- TABLE HEADER -->\n      <thead [ngClass]=\"{ 'sticky': mergedConfig.display?.stickyHeader }\" [ngStyle]=\"theadStyle\">\n        <tr>\n          <!-- Row Number Header -->\n          <th *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-header header-cell sticky-left\"\n              [ngStyle]=\"{\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_HEADER_CELL,\n                'width.px': 30\n              }\">\n            #\n          </th>\n          <!-- Column Headers -->\n          <th \n            *ngFor=\"let column of visibleColumns; let colIndex = index; let isFirst = first; let isLast = last\"\n            [ngClass]=\"{\n              'header-cell': mode === 'standard',\n              'sticky-left': column.sticky === 'left',\n              'sticky-right': column.sticky === 'right',\n              'sticky-right-first': column.sticky === 'right' && isFirstStickyRight(column.key),\n              'resizable': column.resizable !== false\n            }\"\n            [ngStyle]=\"{\n              position: column.sticky ? 'sticky' : null,\n              'left.px': column.sticky === 'left' ? (column.stickyOffset || 0) : null,\n              'right.px': column.sticky === 'right' ? (column.stickyOffset || 0) : null,\n              'z-index': column.sticky ? ZIndex.STICKY_HEADER_CELL : null,\n              'width.px': column.width\n            }\">\n            \n            <st-header \n              [column]=\"column\"\n              [columnIndex]=\"colIndex\"\n              [isFirstColumn]=\"isFirst\"\n              [isLastColumn]=\"isLast\"\n              [tableState]=\"getActiveTableState()\"\n              [enableSorting]=\"mergedConfig.sorting?.enabled ?? enableSorting\"\n              [enableFiltering]=\"mergedConfig.filtering?.enabled ?? enableFiltering\"\n              (columnMoved)=\"onColumnMoved($event)\"\n              (menuClick)=\"openColumnMenu($event, column, colIndex, isFirst, isLast)\">\n            </st-header>\n\n            <div \n              class=\"resize-handle\" \n              stColumnResize\n              [column]=\"column\"\n              (columnResized)=\"onColumnResized($event)\"\n              *ngIf=\"column.resizable !== false\">\n            </div>\n          </th>\n          \n          <!-- Settings Column Header -->\n          <th \n            class=\"settings-column sticky-right\"\n            [ngClass]=\"{ 'header-cell': mode === 'standard' }\"\n            [ngStyle]=\"{ 'z-index': ZIndex.STICKY_HEADER_CELL }\">\n            <div [ngClass]=\"{ 'flex-center': mode === 'virtual', 'header-content': mode === 'standard' }\">\n              <st-table-actions \n                [tableState]=\"getActiveTableState()\"\n                [allowAddColumn]=\"mergedConfig.features?.columnManagement?.allowAdd || false\"\n                (addColumnClicked)=\"onAddColumnClick()\">\n              </st-table-actions>\n            </div>\n          </th>\n        </tr>\n      </thead>\n\n      <!-- TABLE BODY -->\n      <tbody>\n        <!-- Virtual Scroll Rows -->\n        <ng-container *ngIf=\"mode === 'virtual'\">\n          <tr *ngFor=\"let row of visibleRows$ | async; let relativeIndex = index; trackBy: trackByRowIndex\"\n            [attr.data-row-index]=\"getAbsoluteRowIndex(relativeIndex)\">\n            <!-- Row Number Cell -->\n            <td *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-cell\" \n              [ngClass]=\"{ 'sticky-left': 'left' }\"\n              [ngStyle]=\"{\n                'width.px': 30,\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_BODY_CELL,\n                'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n              }\">\n              {{getAbsoluteRowIndex(relativeIndex) + 1}}\n            </td>\n            <ng-container *ngTemplateOutlet=\"bodyCellTemplate; context: { \n              row: row,\n              rowIndex: getAbsoluteRowIndex(relativeIndex),\n              mode: 'virtual',\n              relativeIndex: relativeIndex\n            }\"></ng-container>\n          </tr>\n        </ng-container>\n\n        <!-- Standard Rows -->\n        <ng-container *ngIf=\"mode === 'standard'\">\n          <tr *ngFor=\"let row of visibleCellGrid; let rowIndex = index\" [attr.data-row-index]=\"rowIndex\">\n            <!-- Row Number Cell -->\n            <td *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-cell\" \n              [ngClass]=\"{ 'sticky-left': 'left' }\"\n              [ngStyle]=\"{\n                'width.px': 30,\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_BODY_CELL,\n                'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n              }\">\n              {{rowIndex + 1}}\n            </td>\n            <ng-container *ngTemplateOutlet=\"bodyCellTemplate; context: { \n              row: row,\n              rowIndex: rowIndex,\n              mode: 'standard'\n            }\"></ng-container>\n          </tr>\n        </ng-container>\n      </tbody>\n    </table>\n  </ng-template>\n\n    <!-- ========================================== -->\n  <!-- REUSABLE BODY CELL TEMPLATE -->\n  <!-- ========================================== -->\n  <ng-template #bodyCellTemplate let-row=\"row\" let-rowIndex=\"rowIndex\" let-mode=\"mode\" let-relativeIndex=\"relativeIndex\">\n    <!-- Data Cells -->\n    <td \n      *ngFor=\"let cell of row; let colIndex = index\"\n      [ngClass]=\"{\n        'sticky-left': visibleColumns[colIndex]?.sticky === 'left',\n        'sticky-right': visibleColumns[colIndex]?.sticky === 'right',\n        'sticky-right-first': visibleColumns[colIndex]?.sticky === 'right' && visibleColumns[colIndex]?.key && isFirstStickyRight(visibleColumns[colIndex].key),\n        'align-center': visibleColumns[colIndex]?.alignment === 'center',\n        'align-right': visibleColumns[colIndex]?.alignment === 'right',\n        'cell-focused': cell.isFocused()\n      }\"\n      [ngStyle]=\"{\n        position: visibleColumns[colIndex]?.sticky ? 'sticky' : null,\n        'left.px': visibleColumns[colIndex]?.sticky === 'left' ? (visibleColumns[colIndex]?.stickyOffset || 0) : null,\n        'right.px': visibleColumns[colIndex]?.sticky === 'right' ? (visibleColumns[colIndex]?.stickyOffset || 0) : null,\n        'z-index': visibleColumns[colIndex]?.sticky ? ZIndex.STICKY_BODY_CELL : null,\n        'width.px': visibleColumns[colIndex]?.width,\n        'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n      }\"\n      (click)=\"isKeyboardNavigationEnabled() ? onCellClick(rowIndex, colIndex) : null\">\n      \n      <!-- Virtual Scroll Cell -->\n      <st-cell \n        *ngIf=\"mode === 'virtual'\"\n        [cell]=\"cell\" \n        [attr.tabindex]=\"cell.isFocused() ? 0 : -1\" \n        [editMode]=\"getEditModeForCells()\"\n        [tableState]=\"getActiveTableState()\"\n        [tableConfig]=\"mergedConfig\"\n        [columnIndex]=\"colIndex\"\n        (cellEdit)=\"onCellEdit($event)\" \n        (cellSave)=\"onCellSave($event)\"\n        (cellSaveAndNavigate)=\"onCellSaveAndNavigate($event)\" \n        (cellCancel)=\"onCellCancel($event)\"\n        (cellChange)=\"cellChange.emit($event)\">\n      </st-cell>\n\n      <!-- Standard Cell -->\n      <st-cell \n        *ngIf=\"mode === 'standard'\"\n        [cell]=\"cell\"  \n        [attr.tabindex]=\"cell.isFocused() ? 0 : -1\"\n        [tableState]=\"getActiveTableState()\"\n        [tableConfig]=\"mergedConfig\"\n        [columnIndex]=\"colIndex\"\n        (cellSave)=\"onCellSave($event)\"\n        (cellChange)=\"cellChange.emit($event)\">\n      </st-cell>\n    </td>\n    \n    <!-- Row Actions Cell -->\n    <td class=\"settings-column\"\n      [ngClass]=\"{\n        'has-actions': hasRowActions()\n      }\"\n      [ngStyle]=\"{\n        position: hasRowActions() ? 'sticky' : null,\n        'right.px': hasRowActions() ? 0 : null,\n        'z-index': hasRowActions() ? ZIndex.STICKY_BODY_CELL : null\n      }\">\n      <button \n        *ngIf=\"hasRowActions()\"\n        class=\"settings-trigger\"\n        (click)=\"openRowActionsDropdown($event, getRowData(rowIndex), rowIndex)\"\n        type=\"button\" \n        aria-label=\"Row actions\">\n        \u22EF\n      </button>\n    </td>\n  </ng-template>\n\n<ng-template #skeletonLoader>\n  <div class=\"list-row\" *ngIf=\"(mergedConfig.tableSkeleton?.enabled | async)\">\n    <div *ngFor=\"let i of skeletonColumns\" class=\"list-content\">\n      <nile-skeleton-loader variant=\"text\" width=\"90%\" height=\"18\" *ngFor=\"let j of skeletonRows\"></nile-skeleton-loader>\n    </div>\n  </div>\n</ng-template>", styles: [".st-table{width:100%;overflow:auto;position:relative;height:100%;max-height:30rem;border-radius:4px;border:1px solid #E6E9EB}.st-table st-table-actions{position:sticky;right:0}.st-table.keyboard-navigation-enabled{cursor:pointer}.st-table.keyboard-navigation-enabled:focus{outline:none;box-shadow:0 0 0 2px #3b82f64d}.st-table.keyboard-navigation-enabled td.cell-focused{outline:2px solid #4299e1;outline-offset:-1px;position:relative;box-shadow:0 0 0 3px #3182ce1a}.st-table.keyboard-navigation-enabled td.cell-focused:focus{outline:2px solid #4299e1;outline-offset:-1px;box-shadow:0 0 0 3px #3182ce1a}.st-table.keyboard-navigation-enabled td.cell-focused:has(.st-cell.editing){box-shadow:0 0 0 4px #2563eb26}.st-table.virtual-scroll-enabled{overflow-x:visible;margin:0;border:1px solid #E6E9EB;border-collapse:collapse}.st-table.virtual-scroll-enabled .st-scroll-viewport{position:relative;overflow-y:auto;overflow-x:auto;scroll-behavior:smooth}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-scroll-spacer{position:absolute;top:0;left:0;width:1px;pointer-events:none;z-index:-1}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-positioner{position:absolute;top:0;left:0;right:0;will-change:transform}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element{position:relative;width:100%;border-collapse:collapse;border-spacing:0;background-color:#fff;table-layout:fixed}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead{background-color:#fff;border-bottom:1px solid #E6E9EB}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead.sticky{position:sticky;top:0;z-index:3;background-color:#fff;will-change:top;backface-visibility:hidden}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead.sticky:after{content:\"\";position:absolute;bottom:-2px;left:0;right:0;height:2px;background:linear-gradient(to bottom,rgba(0,0,0,.1),transparent)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th{padding:0;vertical-align:middle;position:relative;border:none;background-color:#fff;will-change:top;border-right:1px solid #E6E9EB}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-left{position:sticky;left:0;background-color:#fff;border-right:1px solid #E6E9EB!important}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-right{position:sticky;right:0;background-color:#fff}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.settings-column{width:2rem;text-align:center;font-weight:600;font-size:12px}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle{position:absolute;top:0;right:0;bottom:0;width:8px;cursor:col-resize;z-index:4;pointer-events:auto}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle:after{content:\"\";position:absolute;top:50%;right:3px;transform:translateY(-50%);width:2px;height:20px;background-color:#cbd5e0;opacity:0;transition:opacity .2s}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle:hover:after,.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle:active:after{opacity:1}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.row-number-header{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-right-first:not(.settings-column):before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody{will-change:transform;position:relative;z-index:1}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr{border-bottom:1px solid #E6E9EB;transition:background-color .15s;height:2rem;box-sizing:border-box}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr:last-child{border-bottom:none}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td{padding:0;vertical-align:middle;box-sizing:border-box;height:2rem;border:1px solid #E6E9EB;border-left:none;background-color:#fff}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.align-center{text-align:center}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.align-right{text-align:right}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-left{position:sticky;z-index:2;border-right:1px solid #E6E9EB!important}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-right{position:sticky;z-index:2}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.settings-column{width:2rem;text-align:center}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.settings-column .settings-trigger{background:none;border:none;font-size:1rem;line-height:1;cursor:pointer;border-radius:4px;transition:all .15s ease}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.settings-column .settings-trigger:focus{outline:2px solid #4299e1;outline-offset:2px}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.row-number-cell{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-right-first:before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element{width:100%;height:100%;overflow:auto;border-collapse:collapse;table-layout:fixed}.st-table:not(.virtual-scroll-enabled) .st-table-element thead{background-color:#fff;border-bottom:1px solid #E6E9EB}.st-table:not(.virtual-scroll-enabled) .st-table-element thead.sticky{position:sticky;top:0;z-index:3;background-color:#fff;will-change:top;backface-visibility:hidden}.st-table:not(.virtual-scroll-enabled) .st-table-element thead.sticky:after{content:\"\";position:absolute;bottom:-2px;left:0;right:0;height:2px;background:linear-gradient(to bottom,rgba(0,0,0,.1),transparent)}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th{padding:0;vertical-align:middle;position:relative;background-color:#fff;border-right:1px solid #E6E9EB}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-left{position:sticky;left:0;border-right:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-right{position:sticky;right:0;border-left:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-right-first:not(.settings-column){box-shadow:-2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.settings-column{width:2rem;text-align:center;font-weight:600;font-size:12px;border-right:none;position:sticky;right:0}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle{position:absolute;top:0;right:0;bottom:0;width:8px;cursor:col-resize;z-index:4;pointer-events:auto}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle:after{content:\"\";position:absolute;top:50%;right:3px;transform:translateY(-50%);width:2px;height:20px;background-color:#cbd5e0;opacity:0;transition:opacity .2s}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle:hover:after,.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle:active:after{opacity:1}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.row-number-header{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-right-first:not(.settings-column):before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody{will-change:transform;position:relative;z-index:1}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr{height:2rem;box-sizing:border-box}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr:last-child{border-bottom:none}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td{padding:0;vertical-align:middle;height:2rem;background-color:#fff;border:1px solid #E6E9EB;border-left:none}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.row-number-cell{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.align-center{text-align:center}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.align-right{text-align:right}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-left{position:sticky;z-index:2;border-right:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-right{position:sticky;z-index:2;border-left:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-right-first:not(.settings-column){box-shadow:-2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.settings-column{position:sticky;right:0;width:2rem;text-align:center;border-right:none}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.settings-column .settings-trigger{background:none;border:none;font-size:1rem;line-height:1;cursor:pointer;border-radius:4px;transition:all .15s ease}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-right-first:before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element .header-content{display:flex;height:2rem;align-items:center}.st-table:not(.virtual-scroll-enabled) .st-table-element .header-content .table-header-text{flex-grow:1;padding-left:4px}.st-table:not(.virtual-scroll-enabled) .st-table-element .settings-column>.header-content{display:flex;align-items:center;justify-content:center}.flex-center{display:flex;align-items:center;justify-content:center}.list-row{padding:1rem}.list-row .list-content{display:flex;justify-content:space-evenly;gap:4px;margin-bottom:1rem}\n"], components: [{ type: i4.StPaginationComponent, selector: "st-pagination", inputs: ["tableState", "tableConfig", "position"] }, { type: i5.StColumnMenuDropdownComponent, selector: "st-column-menu-dropdown", inputs: ["isOpen", "position", "context"], outputs: ["actionClicked", "closed"] }, { type: i6.StRowActionsDropdownComponent, selector: "st-row-actions-dropdown", inputs: ["isOpen", "position", "context"], outputs: ["actionClicked", "closed"] }, { type: i7.StColumnEditorModalComponent, selector: "st-column-editor-modal", outputs: ["columnCreated", "cancelled"] }, { type: i8.StHeaderComponent, selector: "st-header", inputs: ["column", "columnIndex", "isFirstColumn", "isLastColumn", "tableState", "enableSorting", "enableFiltering"], outputs: ["sortToggle", "filterChange", "columnMoved", "menuClick"] }, { type: i9.StTableActionsComponent, selector: "st-table-actions", inputs: ["tableState", "allowAddColumn"], outputs: ["addColumnClicked"] }, { type: i10.StCellComponent, selector: "st-cell", inputs: ["cell", "editMode", "tableState", "tableConfig", "columnIndex"], outputs: ["cellChange", "cellEdit", "cellSave", "cellCancel", "cellSaveAndNavigate"] }], directives: [{ type: i11.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i12.StKeyboardNavigationDirective, selector: "[stKeyboardNavigation]", inputs: ["tableState"] }, { type: i11.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i11.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i11.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i11.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i13.StColumnResizeDirective, selector: "[stColumnResize]", inputs: ["column"], outputs: ["columnResized"] }], pipes: { "async": i11.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'st-table', template: "<!-- Top pagination controls -->\n<st-pagination \n  *ngIf=\"showTopPagination() && !(mergedConfig.tableSkeleton?.enabled | async)\" \n  [tableState]=\"getActiveTableState()\"\n  [tableConfig]=\"mergedConfig\"\n  position=\"top\">\n</st-pagination>\n\n<div class=\"st-table\" *ngIf=\"!(mergedConfig.tableSkeleton?.enabled | async)\" \n  [ngClass]=\"{\n    'virtual-scroll-enabled': isVirtualScrollEnabled(),\n    'keyboard-navigation-enabled': isKeyboardNavigationEnabled()\n  }\"\n  [ngStyle]=\"{\n    'max-height.px': !isVirtualScrollEnabled() ? mergedConfig.display?.maxHeight : null\n  }\"\n  stKeyboardNavigation\n  [tableState]=\"getActiveTableState()\" \n  [attr.tabindex]=\"isKeyboardNavigationEnabled() ? 0 : -1\"\n  (focus)=\"onTableContainerFocus($event)\"\n  [attr.title]=\"isKeyboardNavigationEnabled() ? 'Click a cell or press Tab to start keyboard navigation' : null\">\n  <!-- Unified Table Actions Menu -->\n\n  <!-- Virtual scroll viewport wrapper -->\n  <div class=\"st-scroll-viewport\" #scrollViewport *ngIf=\"isVirtualScrollEnabled()\"\n    [ngStyle]=\"{ 'height.px': getVirtualScrollViewportHeight() }\">\n\n    <!-- Spacer to create scrollable area -->\n    <div class=\"st-scroll-spacer\" [ngStyle]=\"{ 'height.px': virtualScrollTotalHeight$ | async }\">\n    </div>\n\n    <!-- Table positioner with transform (instead of tbody) -->\n    <div class=\"st-table-positioner\" [ngStyle]=\"{ transform: 'translateY(' + (virtualScrollOffsetY$ | async) + 'px)' }\">\n      <!-- Table with only visible rows -->\n      <ng-container *ngTemplateOutlet=\"tableTemplate; context: { \n        mode: 'virtual',\n        theadStyle: { top: (virtualScrollOffsetYNeg$ | async) + 'px' }\n      }\"></ng-container>\n    </div>\n  </div>\n  \n  <!-- Standard table (when virtual scroll disabled) -->\n  <ng-container *ngIf=\"!isVirtualScrollEnabled()\">\n    <ng-container *ngTemplateOutlet=\"tableTemplate; context: { \n      mode: 'standard',\n      theadStyle: null\n    }\"></ng-container>\n  </ng-container>\n\n  <!-- Shared Column Menu Dropdown -->\n  <st-column-menu-dropdown \n  [isOpen]=\"columnMenuState.isOpen\"\n  [position]=\"columnMenuState.position\"\n  [context]=\"columnMenuState.context\"\n  (actionClicked)=\"onColumnActionClicked($event)\"\n  (closed)=\"closeColumnMenu()\">\n  </st-column-menu-dropdown>\n</div>\n\n<ng-container *ngIf=\"(mergedConfig.tableSkeleton?.enabled | async)\">\n  <ng-container *ngTemplateOutlet=\"skeletonLoader\"></ng-container>\n</ng-container>\n\n<!-- Shared Row Actions Dropdown -->\n<st-row-actions-dropdown [isOpen]=\"dropdownState.isOpen\" [position]=\"dropdownState.position\"\n  [context]=\"dropdownState.context\" (actionClicked)=\"onRowActionClicked($event)\" (closed)=\"closeRowActionsDropdown()\">\n</st-row-actions-dropdown>\n\n\n<!-- Bottom pagination controls -->\n<st-pagination \n  *ngIf=\"showBottomPagination() && !(mergedConfig.tableSkeleton?.enabled | async)\" \n  [tableState]=\"getActiveTableState()\"\n  [tableConfig]=\"mergedConfig\"\n  position=\"bottom\">\n</st-pagination>\n\n<!-- Add Column Modal -->\n<st-column-editor-modal *ngIf=\"showColumnModal\" (columnCreated)=\"onColumnCreated($event)\"\n  (cancelled)=\"onModalCancelled()\">\n</st-column-editor-modal>\n\n  <!-- ========================================== -->\n  <!-- REUSABLE TABLE TEMPLATE -->\n  <!-- ========================================== -->\n  <ng-template #tableTemplate let-mode=\"mode\" let-theadStyle=\"theadStyle\">\n    <table class=\"st-table-element\">\n      <!-- TABLE HEADER -->\n      <thead [ngClass]=\"{ 'sticky': mergedConfig.display?.stickyHeader }\" [ngStyle]=\"theadStyle\">\n        <tr>\n          <!-- Row Number Header -->\n          <th *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-header header-cell sticky-left\"\n              [ngStyle]=\"{\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_HEADER_CELL,\n                'width.px': 30\n              }\">\n            #\n          </th>\n          <!-- Column Headers -->\n          <th \n            *ngFor=\"let column of visibleColumns; let colIndex = index; let isFirst = first; let isLast = last\"\n            [ngClass]=\"{\n              'header-cell': mode === 'standard',\n              'sticky-left': column.sticky === 'left',\n              'sticky-right': column.sticky === 'right',\n              'sticky-right-first': column.sticky === 'right' && isFirstStickyRight(column.key),\n              'resizable': column.resizable !== false\n            }\"\n            [ngStyle]=\"{\n              position: column.sticky ? 'sticky' : null,\n              'left.px': column.sticky === 'left' ? (column.stickyOffset || 0) : null,\n              'right.px': column.sticky === 'right' ? (column.stickyOffset || 0) : null,\n              'z-index': column.sticky ? ZIndex.STICKY_HEADER_CELL : null,\n              'width.px': column.width\n            }\">\n            \n            <st-header \n              [column]=\"column\"\n              [columnIndex]=\"colIndex\"\n              [isFirstColumn]=\"isFirst\"\n              [isLastColumn]=\"isLast\"\n              [tableState]=\"getActiveTableState()\"\n              [enableSorting]=\"mergedConfig.sorting?.enabled ?? enableSorting\"\n              [enableFiltering]=\"mergedConfig.filtering?.enabled ?? enableFiltering\"\n              (columnMoved)=\"onColumnMoved($event)\"\n              (menuClick)=\"openColumnMenu($event, column, colIndex, isFirst, isLast)\">\n            </st-header>\n\n            <div \n              class=\"resize-handle\" \n              stColumnResize\n              [column]=\"column\"\n              (columnResized)=\"onColumnResized($event)\"\n              *ngIf=\"column.resizable !== false\">\n            </div>\n          </th>\n          \n          <!-- Settings Column Header -->\n          <th \n            class=\"settings-column sticky-right\"\n            [ngClass]=\"{ 'header-cell': mode === 'standard' }\"\n            [ngStyle]=\"{ 'z-index': ZIndex.STICKY_HEADER_CELL }\">\n            <div [ngClass]=\"{ 'flex-center': mode === 'virtual', 'header-content': mode === 'standard' }\">\n              <st-table-actions \n                [tableState]=\"getActiveTableState()\"\n                [allowAddColumn]=\"mergedConfig.features?.columnManagement?.allowAdd || false\"\n                (addColumnClicked)=\"onAddColumnClick()\">\n              </st-table-actions>\n            </div>\n          </th>\n        </tr>\n      </thead>\n\n      <!-- TABLE BODY -->\n      <tbody>\n        <!-- Virtual Scroll Rows -->\n        <ng-container *ngIf=\"mode === 'virtual'\">\n          <tr *ngFor=\"let row of visibleRows$ | async; let relativeIndex = index; trackBy: trackByRowIndex\"\n            [attr.data-row-index]=\"getAbsoluteRowIndex(relativeIndex)\">\n            <!-- Row Number Cell -->\n            <td *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-cell\" \n              [ngClass]=\"{ 'sticky-left': 'left' }\"\n              [ngStyle]=\"{\n                'width.px': 30,\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_BODY_CELL,\n                'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n              }\">\n              {{getAbsoluteRowIndex(relativeIndex) + 1}}\n            </td>\n            <ng-container *ngTemplateOutlet=\"bodyCellTemplate; context: { \n              row: row,\n              rowIndex: getAbsoluteRowIndex(relativeIndex),\n              mode: 'virtual',\n              relativeIndex: relativeIndex\n            }\"></ng-container>\n          </tr>\n        </ng-container>\n\n        <!-- Standard Rows -->\n        <ng-container *ngIf=\"mode === 'standard'\">\n          <tr *ngFor=\"let row of visibleCellGrid; let rowIndex = index\" [attr.data-row-index]=\"rowIndex\">\n            <!-- Row Number Cell -->\n            <td *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-cell\" \n              [ngClass]=\"{ 'sticky-left': 'left' }\"\n              [ngStyle]=\"{\n                'width.px': 30,\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_BODY_CELL,\n                'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n              }\">\n              {{rowIndex + 1}}\n            </td>\n            <ng-container *ngTemplateOutlet=\"bodyCellTemplate; context: { \n              row: row,\n              rowIndex: rowIndex,\n              mode: 'standard'\n            }\"></ng-container>\n          </tr>\n        </ng-container>\n      </tbody>\n    </table>\n  </ng-template>\n\n    <!-- ========================================== -->\n  <!-- REUSABLE BODY CELL TEMPLATE -->\n  <!-- ========================================== -->\n  <ng-template #bodyCellTemplate let-row=\"row\" let-rowIndex=\"rowIndex\" let-mode=\"mode\" let-relativeIndex=\"relativeIndex\">\n    <!-- Data Cells -->\n    <td \n      *ngFor=\"let cell of row; let colIndex = index\"\n      [ngClass]=\"{\n        'sticky-left': visibleColumns[colIndex]?.sticky === 'left',\n        'sticky-right': visibleColumns[colIndex]?.sticky === 'right',\n        'sticky-right-first': visibleColumns[colIndex]?.sticky === 'right' && visibleColumns[colIndex]?.key && isFirstStickyRight(visibleColumns[colIndex].key),\n        'align-center': visibleColumns[colIndex]?.alignment === 'center',\n        'align-right': visibleColumns[colIndex]?.alignment === 'right',\n        'cell-focused': cell.isFocused()\n      }\"\n      [ngStyle]=\"{\n        position: visibleColumns[colIndex]?.sticky ? 'sticky' : null,\n        'left.px': visibleColumns[colIndex]?.sticky === 'left' ? (visibleColumns[colIndex]?.stickyOffset || 0) : null,\n        'right.px': visibleColumns[colIndex]?.sticky === 'right' ? (visibleColumns[colIndex]?.stickyOffset || 0) : null,\n        'z-index': visibleColumns[colIndex]?.sticky ? ZIndex.STICKY_BODY_CELL : null,\n        'width.px': visibleColumns[colIndex]?.width,\n        'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n      }\"\n      (click)=\"isKeyboardNavigationEnabled() ? onCellClick(rowIndex, colIndex) : null\">\n      \n      <!-- Virtual Scroll Cell -->\n      <st-cell \n        *ngIf=\"mode === 'virtual'\"\n        [cell]=\"cell\" \n        [attr.tabindex]=\"cell.isFocused() ? 0 : -1\" \n        [editMode]=\"getEditModeForCells()\"\n        [tableState]=\"getActiveTableState()\"\n        [tableConfig]=\"mergedConfig\"\n        [columnIndex]=\"colIndex\"\n        (cellEdit)=\"onCellEdit($event)\" \n        (cellSave)=\"onCellSave($event)\"\n        (cellSaveAndNavigate)=\"onCellSaveAndNavigate($event)\" \n        (cellCancel)=\"onCellCancel($event)\"\n        (cellChange)=\"cellChange.emit($event)\">\n      </st-cell>\n\n      <!-- Standard Cell -->\n      <st-cell \n        *ngIf=\"mode === 'standard'\"\n        [cell]=\"cell\"  \n        [attr.tabindex]=\"cell.isFocused() ? 0 : -1\"\n        [tableState]=\"getActiveTableState()\"\n        [tableConfig]=\"mergedConfig\"\n        [columnIndex]=\"colIndex\"\n        (cellSave)=\"onCellSave($event)\"\n        (cellChange)=\"cellChange.emit($event)\">\n      </st-cell>\n    </td>\n    \n    <!-- Row Actions Cell -->\n    <td class=\"settings-column\"\n      [ngClass]=\"{\n        'has-actions': hasRowActions()\n      }\"\n      [ngStyle]=\"{\n        position: hasRowActions() ? 'sticky' : null,\n        'right.px': hasRowActions() ? 0 : null,\n        'z-index': hasRowActions() ? ZIndex.STICKY_BODY_CELL : null\n      }\">\n      <button \n        *ngIf=\"hasRowActions()\"\n        class=\"settings-trigger\"\n        (click)=\"openRowActionsDropdown($event, getRowData(rowIndex), rowIndex)\"\n        type=\"button\" \n        aria-label=\"Row actions\">\n        \u22EF\n      </button>\n    </td>\n  </ng-template>\n\n<ng-template #skeletonLoader>\n  <div class=\"list-row\" *ngIf=\"(mergedConfig.tableSkeleton?.enabled | async)\">\n    <div *ngFor=\"let i of skeletonColumns\" class=\"list-content\">\n      <nile-skeleton-loader variant=\"text\" width=\"90%\" height=\"18\" *ngFor=\"let j of skeletonRows\"></nile-skeleton-loader>\n    </div>\n  </div>\n</ng-template>", styles: [".st-table{width:100%;overflow:auto;position:relative;height:100%;max-height:30rem;border-radius:4px;border:1px solid #E6E9EB}.st-table st-table-actions{position:sticky;right:0}.st-table.keyboard-navigation-enabled{cursor:pointer}.st-table.keyboard-navigation-enabled:focus{outline:none;box-shadow:0 0 0 2px #3b82f64d}.st-table.keyboard-navigation-enabled td.cell-focused{outline:2px solid #4299e1;outline-offset:-1px;position:relative;box-shadow:0 0 0 3px #3182ce1a}.st-table.keyboard-navigation-enabled td.cell-focused:focus{outline:2px solid #4299e1;outline-offset:-1px;box-shadow:0 0 0 3px #3182ce1a}.st-table.keyboard-navigation-enabled td.cell-focused:has(.st-cell.editing){box-shadow:0 0 0 4px #2563eb26}.st-table.virtual-scroll-enabled{overflow-x:visible;margin:0;border:1px solid #E6E9EB;border-collapse:collapse}.st-table.virtual-scroll-enabled .st-scroll-viewport{position:relative;overflow-y:auto;overflow-x:auto;scroll-behavior:smooth}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-scroll-spacer{position:absolute;top:0;left:0;width:1px;pointer-events:none;z-index:-1}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-positioner{position:absolute;top:0;left:0;right:0;will-change:transform}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element{position:relative;width:100%;border-collapse:collapse;border-spacing:0;background-color:#fff;table-layout:fixed}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead{background-color:#fff;border-bottom:1px solid #E6E9EB}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead.sticky{position:sticky;top:0;z-index:3;background-color:#fff;will-change:top;backface-visibility:hidden}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead.sticky:after{content:\"\";position:absolute;bottom:-2px;left:0;right:0;height:2px;background:linear-gradient(to bottom,rgba(0,0,0,.1),transparent)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th{padding:0;vertical-align:middle;position:relative;border:none;background-color:#fff;will-change:top;border-right:1px solid #E6E9EB}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-left{position:sticky;left:0;background-color:#fff;border-right:1px solid #E6E9EB!important}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-right{position:sticky;right:0;background-color:#fff}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.settings-column{width:2rem;text-align:center;font-weight:600;font-size:12px}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle{position:absolute;top:0;right:0;bottom:0;width:8px;cursor:col-resize;z-index:4;pointer-events:auto}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle:after{content:\"\";position:absolute;top:50%;right:3px;transform:translateY(-50%);width:2px;height:20px;background-color:#cbd5e0;opacity:0;transition:opacity .2s}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle:hover:after,.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.resizable .resize-handle:active:after{opacity:1}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.row-number-header{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element thead tr th.sticky-right-first:not(.settings-column):before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody{will-change:transform;position:relative;z-index:1}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr{border-bottom:1px solid #E6E9EB;transition:background-color .15s;height:2rem;box-sizing:border-box}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr:last-child{border-bottom:none}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td{padding:0;vertical-align:middle;box-sizing:border-box;height:2rem;border:1px solid #E6E9EB;border-left:none;background-color:#fff}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.align-center{text-align:center}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.align-right{text-align:right}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-left{position:sticky;z-index:2;border-right:1px solid #E6E9EB!important}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-right{position:sticky;z-index:2}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.settings-column{width:2rem;text-align:center}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.settings-column .settings-trigger{background:none;border:none;font-size:1rem;line-height:1;cursor:pointer;border-radius:4px;transition:all .15s ease}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.settings-column .settings-trigger:focus{outline:2px solid #4299e1;outline-offset:2px}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.row-number-cell{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table.virtual-scroll-enabled .st-scroll-viewport .st-table-element tbody tr td.sticky-right-first:before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element{width:100%;height:100%;overflow:auto;border-collapse:collapse;table-layout:fixed}.st-table:not(.virtual-scroll-enabled) .st-table-element thead{background-color:#fff;border-bottom:1px solid #E6E9EB}.st-table:not(.virtual-scroll-enabled) .st-table-element thead.sticky{position:sticky;top:0;z-index:3;background-color:#fff;will-change:top;backface-visibility:hidden}.st-table:not(.virtual-scroll-enabled) .st-table-element thead.sticky:after{content:\"\";position:absolute;bottom:-2px;left:0;right:0;height:2px;background:linear-gradient(to bottom,rgba(0,0,0,.1),transparent)}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th{padding:0;vertical-align:middle;position:relative;background-color:#fff;border-right:1px solid #E6E9EB}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-left{position:sticky;left:0;border-right:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-right{position:sticky;right:0;border-left:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-right-first:not(.settings-column){box-shadow:-2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.settings-column{width:2rem;text-align:center;font-weight:600;font-size:12px;border-right:none;position:sticky;right:0}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle{position:absolute;top:0;right:0;bottom:0;width:8px;cursor:col-resize;z-index:4;pointer-events:auto}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle:after{content:\"\";position:absolute;top:50%;right:3px;transform:translateY(-50%);width:2px;height:20px;background-color:#cbd5e0;opacity:0;transition:opacity .2s}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle:hover:after,.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.resizable .resize-handle:active:after{opacity:1}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.row-number-header{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-left:not(:has(~ th.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element thead tr th.sticky-right-first:not(.settings-column):before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody{will-change:transform;position:relative;z-index:1}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr{height:2rem;box-sizing:border-box}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr:last-child{border-bottom:none}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td{padding:0;vertical-align:middle;height:2rem;background-color:#fff;border:1px solid #E6E9EB;border-left:none}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.row-number-cell{text-align:center;font-weight:300;font-size:12px;background-color:#f8f8f8}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.align-center{text-align:center}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.align-right{text-align:right}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-left{position:sticky;z-index:2;border-right:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)){box-shadow:2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-right{position:sticky;z-index:2;border-left:1px solid #E6E9EB!important}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-right-first:not(.settings-column){box-shadow:-2px 0 5px -2px #0003}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.settings-column{position:sticky;right:0;width:2rem;text-align:center;border-right:none}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.settings-column .settings-trigger{background:none;border:none;font-size:1rem;line-height:1;cursor:pointer;border-radius:4px;transition:all .15s ease}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-left:not(:has(~ td.sticky-left)):after{content:\"\";position:absolute;right:-6px;top:0;bottom:-1px;width:5px;border-left:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,.08) 0%,rgba(0,0,0,0) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element tbody tr td.sticky-right-first:before{content:\"\";position:absolute;left:-6px;top:0;bottom:-1px;width:5px;border-right:1px solid var(--borderColor);background:linear-gradient(90deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.08) 100%)}.st-table:not(.virtual-scroll-enabled) .st-table-element .header-content{display:flex;height:2rem;align-items:center}.st-table:not(.virtual-scroll-enabled) .st-table-element .header-content .table-header-text{flex-grow:1;padding-left:4px}.st-table:not(.virtual-scroll-enabled) .st-table-element .settings-column>.header-content{display:flex;align-items:center;justify-content:center}.flex-center{display:flex;align-items:center;justify-content:center}.list-row{padding:1rem}.list-row .list-content{display:flex;justify-content:space-evenly;gap:4px;margin-bottom:1rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.JsonSchemaValidatorService }, { type: i2.ValidationLoggerService }, { type: i3.VirtualScrollService }]; }, propDecorators: { tableConfig: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], data$: [{
+                type: Input
+            }], tableState: [{
+                type: Input
+            }], enableSorting: [{
+                type: Input
+            }], enableFiltering: [{
+                type: Input
+            }], stateChange: [{
+                type: Output
+            }], dataChange: [{
+                type: Output
+            }], cellEdit: [{
+                type: Output
+            }], cellSave: [{
+                type: Output
+            }], cellCancel: [{
+                type: Output
+            }], cellChange: [{
+                type: Output
+            }], columnResized: [{
+                type: Output
+            }], columnMoved: [{
+                type: Output
+            }], configValidationErrors: [{
+                type: Output
+            }], columnAdded: [{
+                type: Output
+            }], rowAction: [{
+                type: Output
+            }], validationStateChange: [{
+                type: Output
+            }], validateConfig: [{
+                type: Input
+            }], scrollViewport: [{
+                type: ViewChild,
+                args: ['scrollViewport', { read: ElementRef }]
+            }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st-table.component.js","sourceRoot":"","sources":["../../../../../../../projects/smart-table/src/lib/renderer/components/st-table/st-table.component.ts","../../../../../../../projects/smart-table/src/lib/renderer/components/st-table/st-table.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAA+C,SAAS,EAAE,UAAU,EAAiB,YAAY,EAAE,MAAM,eAAe,CAAC;AAExK,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAe,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAEvF,OAAO,EAAkE,QAAQ,EAAuB,MAAM,4BAA4B,CAAC;AAC3I,OAAO,EAAE,eAAe,EAA4B,MAAM,MAAM,CAAC;AACjE,OAAO,EAAE,GAAG,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAO3D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;;;;;;;;;;;;;;;AAQzD,MAAM,OAAO,gBAAgB;IA0H3B,YACU,eAA2C,EAC3C,MAA+B,EAC/B,oBAA0C;QAF1C,oBAAe,GAAf,eAAe,CAA4B;QAC3C,WAAM,GAAN,MAAM,CAAyB;QAC/B,yBAAoB,GAApB,oBAAoB,CAAsB;QA5HpD,qCAAqC;QAC5B,WAAM,GAAG,WAAW,CAAC;QAa9B,sCAAsC;QAC7B,kBAAa,GAAY,IAAI,CAAC;QAC9B,oBAAe,GAAY,IAAI,CAAC;QAEzC,2BAA2B;QACjB,gBAAW,GAAG,IAAI,YAAY,EAAyB,CAAC;QAElE,mDAAmD;QACzC,eAAU,GAAG,IAAI,YAAY,EAAmB,CAAC;QAE3D,mCAAmC;QACzB,aAAQ,GAAG,IAAI,YAAY,EAAiB,CAAC;QAC7C,aAAQ,GAAG,IAAI,YAAY,EAAiB,CAAC;QAC7C,eAAU,GAAG,IAAI,YAAY,EAAmB,CAAC;QACjD,eAAU,GAAG,IAAI,YAAY,EAAmB,CAAC;QACjD,kBAAa,GAAG,IAAI,YAAY,EAAqB,CAAC;QACtD,gBAAW,GAAG,IAAI,YAAY,EAAmB,CAAC;QAE5D,uCAAuC;QAC7B,2BAAsB,GAAG,IAAI,YAAY,EAA2B,CAAC;QAE/E,gCAAgC;QACtB,gBAAW,GAAG,IAAI,YAAY,EAAkB,CAAC;QAE3D,yBAAyB;QACf,cAAS,GAAG,IAAI,YAAY,EAAkB,CAAC;QAEzD,sCAAsC;QAC5B,0BAAqB,GAAG,IAAI,YAAY,EAAwB,CAAC;QAE3E,gCAAgC;QACvB,mBAAc,GAAY,KAAK,CAAC;QASjC,kBAAa,GAA2B,IAAI,eAAe,CAAQ,EAAE,CAAC,CAAC;QACvE,iBAAY,GAAU,EAAE,CAAC;QAGjC,cAAc;QACP,oBAAe,GAAY,KAAK,CAAC;QAExC,wFAAwF;QACjF,mBAAc,GAAwB,EAAE,CAAC;QACzC,oBAAe,GAAkB,EAAE,CAAC;QAE3C,6BAA6B;QACtB,kBAAa,GAIhB;YACF,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;YACxB,OAAO,EAAE,IAAI;SACd,CAAC;QAKF,6BAA6B;QACtB,oBAAe,GAIlB;YACF,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;YACxB,OAAO,EAAE,IAAI;SACd,CAAC;QAKM,wBAAmB,GAAG,IAAI,eAAe,CAA4B,IAAI,CAAC,CAAC;QAEnF,uDAAuD;QAChD,8BAAyB,GAAuB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAClF,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,IAAI,CAAC,CAAC,EACrC,oBAAoB,EAAE,CACvB,CAAC;QAEK,0BAAqB,GAAuB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAC9E,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,IAAI,CAAC,CAAC,EACjC,oBAAoB,EAAE,CACvB,CAAC;QAEK,6BAAwB,GAAuB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CACjF,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAE,EAC/C,oBAAoB,EAAE,CACvB,CAAC;QAEK,iBAAY,GAA8B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAC5E,GAAG,CAAC,KAAK,CAAC,EAAE;YACV,IAAI,CAAC,KAAK;gBAAE,OAAO,IAAI,CAAC,eAAe,CAAC;YACxC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;YACvC,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAC1D,CAAC,CAAC,CACH,CAAC;QAiuBF;;WAEG;QACH,oBAAe,GAAG,CAAC,KAAa,EAAE,GAAgB,EAAU,EAAE;YAC5D,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QACzC,CAAC,CAAA;IA9tBE,CAAC;IAEJ,QAAQ;QACN,4DAA4D;QAC5D,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;SACnE;QAED,6BAA6B;QAC7B,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,IAAI,CAAC,YAAY,GAAG,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAEvD,oCAAoC;YACpC,IAAI,IAAI,CAAC,cAAc,EAAE;gBACvB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;aAC/C;SACF;QAED,2BAA2B;QAC3B,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,IAAI,CAAC,wBAAwB,EAAE,CAAC;SACjC;aAAM;YACL,2CAA2C;YAC3C,IAAI,CAAC,6BAA6B,EAAE,CAAC;SACtC;QAED,oCAAoC;QACpC,IAAI,CAAC,eAAe,EAAE,CAAC;QAEvB,2BAA2B;QAC3B,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAChE,MAAM,mBAAmB,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,6CAA6C;QACxG,IAAI,CAAC,mBAAmB,EAAE,CAAC,sBAAsB,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;QAEvF,2CAA2C;QAC3C,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEzB,uCAAuC;QACvC,IAAI,IAAI,CAAC,sBAAsB,EAAE,EAAE;YACjC,IAAI,CAAC,uBAAuB,EAAE,CAAC;SAChC;QAED,4CAA4C;QAC5C,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE;YACtC,IAAI,CAAC,4BAA4B,EAAE,CAAC;SACrC;QAED,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,OAAO,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3G,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IACvG,CAAC;IAED,eAAe;QACb,2CAA2C;QAC3C,IAAI,IAAI,CAAC,sBAAsB,EAAE,IAAI,IAAI,CAAC,cAAc,EAAE;YACxD,IAAI,CAAC,0BAA0B,EAAE,CAAC;SACnC;IACH,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,kDAAkD;QAClD,IAAI,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,EAAE;YACrF,IAAI,CAAC,YAAY,GAAG,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAEvD,oCAAoC;YACpC,IAAI,IAAI,CAAC,cAAc,EAAE;gBACvB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;aAC/C;YAED,uEAAuE;YACvE,IAAI,IAAI,CAAC,kBAAkB,EAAE;gBAC3B,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;aAClE;YAED,uCAAuC;YACvC,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC1B;QAED,4EAA4E;QAC5E,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,WAAW,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YAC/E,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC;SAChE;QAED,wCAAwC;QACxC,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE;YACrD,IAAI,CAAC,eAAe,EAAE,CAAC;SACxB;QAED,2CAA2C;QAC3C,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE;YAC3D,wDAAwD;YACxD,4CAA4C;YAC5C,IAAI,IAAI,CAAC,mBAAmB,EAAE,EAAE;gBAC9B,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;gBAChE,MAAM,mBAAmB,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1D,IAAI,CAAC,mBAAmB,EAAE,CAAC,sBAAsB,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;aACxF;YACD,uCAAuC;YACvC,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC1B;QAED,+CAA+C;QAC/C,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE;YAC7E,IAAI,IAAI,CAAC,sBAAsB,EAAE,EAAE;gBACjC,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC;gBACpD,IAAI,YAAY,EAAE;oBAChB,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,qBAAqB,CAAC;wBAC/D,SAAS,EAAE,YAAY,CAAC,SAAS;wBACjC,cAAc,EAAE,IAAI,CAAC,8BAA8B,EAAE;wBACrD,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM;wBACvC,QAAQ,EAAE,IAAI,CAAC,wBAAwB,EAAE;wBACzC,UAAU,EAAE,IAAI,CAAC,0BAA0B,EAAE;qBAC9C,CAAC,CAAC;oBACH,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;iBACzC;aACF;YAED,mDAAmD;YACnD,IAAI,IAAI,CAAC,2BAA2B,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE;gBAClF,IAAI,CAAC,mBAAmB,EAAE,CAAC,aAAa,CACtC,IAAI,CAAC,eAAe,CAAC,MAAM,EAC3B,IAAI,CAAC,cAAc,CAAC,MAAM,CAC3B,CAAC;aACH;SACF;IACH,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxC,IAAI,CAAC,kBAAkB,GAAG,IAAI,UAAU,CAAC,OAAO,EAAE;YAChD,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,QAAQ;YAChD,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,IAAI;SAClD,CAAC,CAAC;QAEH,qEAAqE;QACrE,IAAI,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,UAAU,KAAK,SAAS,EAAE;YAC1D,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;SAChF;QAED,iCAAiC;QACjC,IAAI,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE;YAC1C,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACnD,IAAI,CAAC,kBAAmB,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACrE,CAAC,CAAC,CAAC;SACJ;QAED,oCAAoC;QACpC,IAAI,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,OAAO,EAAE;YAC3C,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBACtD,IAAI,CAAC,kBAAmB,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACxF,CAAC,CAAC,CAAC;SACJ;QAED,kDAAkD;QAClD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY;aAC1D,SAAS,CAAC,KAAK,CAAC,EAAE;YACjB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAE7B,6DAA6D;YAC7D,IAAI,KAAK,CAAC,IAAI,KAAK,mBAAmB,IAAI,KAAK,CAAC,IAAI,KAAK,eAAe,EAAE;gBACxE,IAAI,CAAC,iBAAiB,EAAE,CAAC;aAC1B;QACH,CAAC,CAAC,CAAC;QAEL,oDAAoD;QACpD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,kBAAkB,CAAC,qBAAqB;aACxE,SAAS,CAAC,KAAK,CAAC,EAAE;YACjB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,6BAA6B;QACnC,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAO;QAE7B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY;aAClD,SAAS,CAAC,KAAK,CAAC,EAAE;YACjB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAE7B,6DAA6D;YAC7D,IAAI,KAAK,CAAC,IAAI,KAAK,mBAAmB,IAAI,KAAK,CAAC,IAAI,KAAK,eAAe,EAAE;gBACxE,IAAI,CAAC,iBAAiB,EAAE,CAAC;aAC1B;QACH,CAAC,CAAC,CAAC;QAEL,oDAAoD;QACpD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,UAAU,CAAC,qBAAqB;aAChE,SAAS,CAAC,KAAK,CAAC,EAAE;YACjB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QAEvB,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,CAC1D,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CACnB,IAAI,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,CACzD,CACF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,eAAe;QACrB,2CAA2C;QAC3C,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;YAC3B,OAAO,CAAC,IAAI,CAAC,8GAA8G,CAAC,CAAC;SAC9H;QAED,iCAAiC;QACjC,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,CAAC;QAErC,6CAA6C;QAC7C,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;aAAM,IAAI,IAAI,CAAC,IAAI,EAAE;YACpB,uDAAuD;YACvD,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnC,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;aAAM;YACL,qCAAqC;YACrC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC5B,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;IACH,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;QAEpE,IAAI,CAAC,gBAAgB,GAAG,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE;YACtD,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,OAAc;QACrC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAqB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;QAE/D,yBAAyB;QACzB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,WAAW,EAAE,OAAO;YACpB,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,wBAAwB;QACxB,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;QACpB,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC;QAEjC,qBAAqB;QACrB,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,sBAAsB;QACtB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEzB,wCAAwC;QACxC,IAAI,IAAI,CAAC,sBAAsB,EAAE,EAAE;YACjC,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC;YACpD,IAAI,YAAY,EAAE;gBAChB,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,qBAAqB,CAAC;oBAC/D,SAAS,EAAE,YAAY,CAAC,SAAS;oBACjC,cAAc,EAAE,IAAI,CAAC,8BAA8B,EAAE;oBACrD,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM;oBACvC,QAAQ,EAAE,IAAI,CAAC,wBAAwB,EAAE;oBACzC,UAAU,EAAE,IAAI,CAAC,0BAA0B,EAAE;iBAC9C,CAAC,CAAC;gBACH,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aACzC;SACF;QAED,mDAAmD;QACnD,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE;YACtC,IAAI,CAAC,mBAAmB,EAAE,CAAC,aAAa,CACtC,IAAI,CAAC,eAAe,CAAC,MAAM,EAC3B,IAAI,CAAC,cAAc,CAAC,MAAM,CAC3B,CAAC;SACH;IACH,CAAC;IAED;;OAEG;IACK,oBAAoB,CAAC,YAAmB;QAC9C,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,mBAAmB;QACjB,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,kBAAmB,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,iBAAiB;QACf,OAAO,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,kBAAkB;QAChB,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC3C,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAChD,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAEtE,yCAAyC;QACzC,MAAM,cAAc,GAAG,UAAU;aAC9B,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aAChE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;QAEjC,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC1C,OAAO,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CACxB,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CAC3E,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACK,qBAAqB;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE1C,oBAAoB;QACpB,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;YACtC,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,OAAO;SACR;QAED,sEAAsE;QACtE,kFAAkF;QAClF,MAAM,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;QAChD,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACnC,IAAI,IAAI,EAAE;gBACR,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;gBAC5C,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;aAC5C;QACH,CAAC,CAAC,CAAC;QAEH,kDAAkD;QAClD,kEAAkE;QAClE,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACxC,OAAO,IAAI,CAAC,cAAc;iBACvB,GAAG,CAAC,GAAG,CAAC,EAAE;gBACT,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC7C,OAAO,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC9D,CAAC,CAAC;iBACD,MAAM,CAAC,CAAC,IAAI,EAAqB,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,oBAAoB;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC3C,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC;QAEtE,sDAAsD;QACtD,IAAI,CAAC,+BAA+B,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAC5D,CAAC;IAED;;;OAGG;IACK,iBAAiB;QACvB,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,iBAAiB;QACf,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC3C,MAAM,cAAc,GAAG,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,6BAA6B;QAErG,sDAAsD;QACtD,IAAI,CAAC,+BAA+B,CAAC,cAAc,CAAC,CAAC;QAErD,OAAO,cAAc,CAAC;IACxB,CAAC;IAED;;;OAGG;IACK,+BAA+B,CAAC,cAAmC;QACzE,gCAAgC;QAChC,+CAA+C;QAC/C,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YAC3B,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,EAAE;gBACxB,GAAW,CAAC,YAAY,GAAG,UAAU,CAAC;gBACvC,UAAU,IAAK,GAAG,CAAC,KAAgB,IAAI,GAAG,CAAC;aAC5C;QACH,CAAC,CAAC,CAAC;QAEH,iCAAiC;QACjC,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,KAAK,IAAI,CAAC,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YACnD,MAAM,GAAG,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;YAC9B,IAAI,GAAG,CAAC,MAAM,KAAK,OAAO,EAAE;gBACzB,GAAW,CAAC,YAAY,GAAG,WAAW,CAAC;gBACxC,WAAW,IAAK,GAAG,CAAC,KAAgB,IAAI,GAAG,CAAC;aAC7C;SACF;IACH,CAAC;IAED,YAAY,CAAC,KAAsB;QACjC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,eAAe,CAAC,KAAwB;QACtC,0CAA0C;QAC1C,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAChE,MAAM,mBAAmB,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,IAAI,CAAC,mBAAmB,EAAE,CAAC,sBAAsB,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;QAEvF,iBAAiB;QACjB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,aAAa,CAAC,KAAuD;QACnE,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxC,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;QACvE,IAAI,YAAY,KAAK,CAAC,CAAC;YAAE,OAAO;QAEhC,yBAAyB;QACzB,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,KAAK,MAAM;YAC5C,CAAC,CAAC,YAAY,GAAG,CAAC;YAClB,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC;QAErB,eAAe;QACf,IAAI,WAAW,GAAG,CAAC,IAAI,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE;YACpD,OAAO;SACR;QAED,eAAe;QACf,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;YAC7C,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;QAE9C,0CAA0C;QAC1C,IAAI,CAAC,mBAAmB,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAClD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACpB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,QAAQ,EAAE,YAAY;YACtB,QAAQ,EAAE,WAAW;YACrB,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC;SAC9B,CAAC,CAAC;QACH,iEAAiE;QACjE,iEAAiE;QACjE,IAAI,IAAI,CAAC,sBAAsB,EAAE,EAAE;YACjC,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC;YACpD,IAAI,YAAY,EAAE;gBAChB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAC,GAAG,YAAY,EAAC,CAAC,CAAC;aAClD;SACF;IACH,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,SAAiB;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxC,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;QACjE,IAAI,YAAY,KAAK,CAAC,CAAC;YAAE,OAAO;QAEhC,kDAAkD;QAClD,MAAM,qBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC;QAE3E,kFAAkF;QAClF,MAAM,WAAW,GAAG,qBAAqB,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QAE1F,iDAAiD;QACjD,IAAI,YAAY,KAAK,WAAW,IAAI,YAAY,KAAK,WAAW,GAAG,CAAC;YAAE,OAAO;QAE7E,sCAAsC;QACtC,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;QAEjD,yDAAyD;QACzD,MAAM,mBAAmB,GAAG,YAAY,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QAEvF,0EAA0E;QAC1E,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;QAE/C,0CAA0C;QAC1C,IAAI,CAAC,mBAAmB,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAElD,oCAAoC;QACpC,IAAI,IAAI,CAAC,sBAAsB,EAAE,EAAE;YACjC,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC;YACpD,IAAI,YAAY,EAAE;gBAChB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAC,GAAG,YAAY,EAAC,CAAC,CAAC;aAClD;SACF;IACH,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,SAAiB;QACnC,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxC,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE;YACzB,IAAI,GAAG,CAAC,GAAG,KAAK,SAAS;gBAAE,MAAM;YACjC,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,EAAE;gBACzB,MAAM,IAAK,GAAG,CAAC,KAAgB,IAAI,GAAG,CAAC;aACxC;SACF;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,oBAAoB,CAAC,SAAiB;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxC,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;QAC7D,KAAK,IAAI,CAAC,GAAG,QAAQ,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACvB,IAAI,GAAG,CAAC,MAAM,KAAK,OAAO,EAAE;gBAC1B,MAAM,IAAK,GAAG,CAAC,KAAgB,IAAI,GAAG,CAAC;aACxC;SACF;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,iBAAiB;QACf,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,OAAO,IAAI,IAAI;YAC7C,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,eAAe,KAAK,IAAI,CAAC;IAChE,CAAC;IAED;;OAEG;IACH,oBAAoB;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,OAAO,IAAI,IAAI;YAC7C,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,kBAAkB,IAAI,IAAI,CAAC,CAAC;IACpE,CAAC;IAED;;;OAGG;IACK,qBAAqB,CAAC,MAAmB;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,wDAAwD;QAE3H,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7C,yBAAyB;YACzB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAEhD,qCAAqC;YACrC,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,4BAA4B;YACrG,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE;gBACzD,aAAa,EAAE,aAAa;aAC7B,CAAC,CAAC;YAEH,kDAAkD;YAClD,OAAO,CAAC,IAAI,CAAC,wDAAwD,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACtF,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAC5B,OAAO,CAAC,IAAI,CAAC,OAAO,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACrE,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,MAAoB;QAClC,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxC,MAAM,QAAQ,GAAmB;YAC/B,MAAM,EAAE,MAAM;YACd,KAAK,EAAE,OAAO,CAAC,MAAM;YACrB,YAAY,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC;SACjC,CAAC;QAEF,0CAA0C;QAC1C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEhC,kBAAkB;QAClB,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,sBAAsB;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,IAAI,KAAK,CAAC;IACpE,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,SAAiB;QAClC,MAAM,kBAAkB,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,KAAK,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;QACtH,OAAO,kBAAkB,CAAC,MAAM,GAAG,CAAC,IAAI,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,SAAS,CAAC;IAClF,CAAC;IAED;;OAEG;IACH,wBAAwB;QACtB,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,IAAI,EAAE,CAAC;IAClE,CAAC;IAED;;OAEG;IACH,8BAA8B;QAC5B,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,cAAc,IAAI,GAAG,CAAC;IACzE,CAAC;IAED;;OAEG;IACH,0BAA0B;QACxB,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,IAAI,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,qBAAqB,CAAC;YAC/D,SAAS,EAAE,CAAC;YACZ,cAAc,EAAE,IAAI,CAAC,8BAA8B,EAAE;YACrD,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM;YACvC,QAAQ,EAAE,IAAI,CAAC,wBAAwB,EAAE;YACzC,UAAU,EAAE,IAAI,CAAC,0BAA0B,EAAE;SAC9C,CAAC,CAAC;QAEH,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACK,0BAA0B;QAChC,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAO;QAEjC,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC;QAClD,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC;QAE/B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,oBAAoB;aAChD,sBAAsB,CAAC,OAAO,CAAC;aAC/B,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,SAAiB;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,qBAAqB,CAAC;YAC/D,SAAS;YACT,cAAc,EAAE,IAAI,CAAC,8BAA8B,EAAE;YACrD,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM;YACvC,QAAQ,EAAE,IAAI,CAAC,wBAAwB,EAAE;YACzC,UAAU,EAAE,IAAI,CAAC,0BAA0B,EAAE;SAC9C,CAAC,CAAC;QAEH,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,aAAqB;QACvC,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC;QACpD,IAAI,CAAC,YAAY;YAAE,OAAO,aAAa,CAAC;QACxC,OAAO,YAAY,CAAC,UAAU,GAAG,aAAa,CAAC;IACjD,CAAC;IASD;;OAEG;IACH,WAAW,CAAC,KAAa;QACvB,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE;YAAE,OAAO;QAEpE,MAAM,SAAS,GAAG,KAAK,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAC1D,IAAI,CAAC,eAAe,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO;YAClD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,IAAI,EAAE,CAAC;IAClE,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,QAAgB;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC1C,IAAI,CAAC,QAAQ,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,EAAE;YAC5D,OAAO,IAAI,CAAC;SACb;QAED,MAAM,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC/B,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5B,OAAO,IAAI,CAAC;SACb;QAED,2EAA2E;QAC3E,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,IAAI,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,sBAAsB,CAAC,KAAiB,EAAE,OAAY,EAAE,QAAgB;QACtE,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,MAAM,MAAM,GAAG,KAAK,CAAC,aAA4B,CAAC;QAClD,MAAM,IAAI,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;QAE5C,mDAAmD;QACnD,MAAM,QAAQ,GAAG;YACf,CAAC,EAAE,IAAI,CAAC,IAAI;YACZ,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,UAAU;SAC9B,CAAC;QAEF,iBAAiB;QACjB,MAAM,OAAO,GAAqB;YAChC,OAAO;YACP,QAAQ;YACR,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE;SAC9B,CAAC;QAEF,wBAAwB;QACxB,IAAI,CAAC,aAAa,GAAG;YACnB,MAAM,EAAE,IAAI;YACZ,QAAQ;YACR,OAAO;SACR,CAAC;QAEF,sBAAsB;QACtB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAExC,sEAAsE;QACtE,IAAI,IAAI,CAAC,sBAAsB,EAAE,IAAI,IAAI,CAAC,eAAe,EAAE;YACzD,MAAM,cAAc,GAAG,GAAG,EAAE;gBAC1B,IAAI,CAAC,uBAAuB,EAAE,CAAC;gBAC/B,IAAI,CAAC,eAAe,EAAE,mBAAmB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;YACtE,CAAC,CAAC;YACF,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;SACjF;IACH,CAAC;IAED;;OAEG;IACH,uBAAuB;QACrB,IAAI,CAAC,aAAa,GAAG;YACnB,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;YACxB,OAAO,EAAE,IAAI;SACd,CAAC;QAEF,wBAAwB;QACxB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,EAAE,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,KAAqB;QACtC,sCAAsC;QACtC,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE;YACvB,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;SACpD;QAED,uBAAuB;QACvB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE3B,iBAAiB;QACjB,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAED,+EAA+E;IAC/E,sBAAsB;IACtB,+EAA+E;IAE/E;;OAEG;IACH,cAAc,CAAC,KAAiB,EAAE,MAAyB,EAAE,WAAmB,EAAE,OAAgB,EAAE,MAAe;QACjH,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,MAAM,MAAM,GAAG,KAAK,CAAC,aAA4B,CAAC;QAClD,MAAM,IAAI,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;QAE5C,mDAAmD;QACnD,MAAM,QAAQ,GAAG;YACf,CAAC,EAAE,IAAI,CAAC,IAAI;YACZ,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,UAAU;SAC9B,CAAC;QAEF,iBAAiB;QACjB,MAAM,OAAO,GAAwB;YACnC,MAAM;YACN,WAAW;YACX,aAAa,EAAE,OAAO;YACtB,YAAY,EAAE,MAAM;YACpB,UAAU,EAAE,IAAI,CAAC,mBAAmB,EAAE;YACtC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC;SACrE,CAAC;QAEF,2BAA2B;QAC3B,IAAI,CAAC,eAAe,GAAG;YACrB,MAAM,EAAE,IAAI;YACZ,QAAQ;YACR,OAAO;SACR,CAAC;QAEF,sBAAsB;QACtB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAExC,sEAAsE;QACtE,IAAI,IAAI,CAAC,sBAAsB,EAAE,IAAI,IAAI,CAAC,eAAe,EAAE;YACzD,MAAM,cAAc,GAAG,GAAG,EAAE;gBAC1B,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,IAAI,CAAC,eAAe,EAAE,mBAAmB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;YACtE,CAAC,CAAC;YACF,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;SACjF;IACH,CAAC;IAED;;OAEG;IACH,eAAe;QACb,IAAI,CAAC,eAAe,GAAG;YACrB,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;YACxB,OAAO,EAAE,IAAI;SACd,CAAC;QAEF,wBAAwB;QACxB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,EAAE,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,qBAAqB,CAAC,KAAwB;QAC5C,sCAAsC;QACtC,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE;YACvB,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;SACtD;QAED,4EAA4E;QAC5E,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE;YAChC,OAAO;SACR;QAED,mCAAmC;QACnC,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAED;;OAEG;IACK,gBAAgB,CACtB,MAAyB,EACzB,WAAmB,EACnB,OAAgB,EAChB,MAAe;QAEf,MAAM,OAAO,GAAmB,EAAE,CAAC;QAEnC,kDAAkD;QAClD,MAAM,cAAc,GAAG,MAAM,CAAC,qBAAqB,IAAI,IAAI,CAAC;QAC5D,IAAI,cAAc,EAAE;YAClB,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;SACrF;QAED,wCAAwC;QACxC,IAAI,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3D,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;SACvC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,uBAAuB,CAC7B,MAAyB,EACzB,WAAmB,EACnB,OAAgB,EAChB,MAAe;QAEf,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC9C,MAAM,OAAO,GAAmB,EAAE,CAAC;QAEnC,iBAAiB;QACjB,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,EAAE;YAC7B,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,UAAU;gBACd,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;gBACvC,IAAI,EAAE,GAAG;gBACT,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;gBACzD,CAAC;aACF,CAAC,CAAC;SACJ;QAED,kBAAkB;QAClB,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,EAAE;YAC7B,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,WAAW;gBACf,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC;gBACxC,IAAI,EAAE,GAAG;gBACT,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;gBAC1D,CAAC;aACF,CAAC,CAAC;SACJ;QAED,6CAA6C;QAC7C,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,aAAa,KAAK,aAAa,CAAC,IAAI,EAAE;YACpG,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,YAAY;gBAChB,KAAK,EAAE,YAAY;gBACnB,IAAI,EAAE,GAAG;gBACT,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;gBAC1D,CAAC;aACF,CAAC,CAAC;SACJ;QAED,SAAS;QACT,IAAI,MAAM,CAAC,UAAU,KAAK,KAAK,EAAE;YAC/B,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,QAAQ;gBACZ,KAAK,EAAE,QAAQ;gBACf,IAAI,EAAE,GAAG;gBACT,MAAM,EAAE,GAAG,EAAE;oBACX,iDAAiD;gBACnD,CAAC;aACF,CAAC,CAAC;SACJ;QAED,mCAAmC;QACnC,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,EAAE;YACtF,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,UAAU;gBACd,KAAK,EAAE,UAAU;gBACjB,IAAI,EAAE,IAAI;gBACV,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC9C,CAAC;aACF,CAAC,CAAC;SACJ;QAED,oCAAoC;QACpC,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,EAAE;YACtF,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,WAAW;gBACf,KAAK,EAAE,WAAW;gBAClB,IAAI,EAAE,IAAI;gBACV,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBAC9B,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;gBAC/C,CAAC;aACF,CAAC,CAAC;SACJ;QAED,8BAA8B;QAC9B,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,CAAC,EAAE;YACxF,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,OAAO;gBACX,KAAK,EAAE,OAAO;gBACd,IAAI,EAAE,IAAI;gBACV,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBAC7C,CAAC;aACF,CAAC,CAAC;SACJ;QAED,6CAA6C;QAC7C,IAAI,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAC1D,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,WAAW;gBACf,KAAK,EAAE,WAAW;gBAClB,IAAI,EAAE,GAAG;gBACT,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,IAAI,CAAC,aAAa,CAAC;wBACjB,SAAS,EAAE,GAAG,CAAC,GAAG;wBAClB,SAAS,EAAE,MAAM;qBAClB,CAAC,CAAC;gBACL,CAAC;aACF,CAAC,CAAC;SACJ;QAED,8CAA8C;QAC9C,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YACzD,OAAO,CAAC,IAAI,CAAC;gBACX,EAAE,EAAE,YAAY;gBAChB,KAAK,EAAE,YAAY;gBACnB,IAAI,EAAE,GAAG;gBACT,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;oBACd,IAAI,CAAC,aAAa,CAAC;wBACjB,SAAS,EAAE,GAAG,CAAC,GAAG;wBAClB,SAAS,EAAE,OAAO;qBACnB,CAAC,CAAC;gBACL,CAAC;aACF,CAAC,CAAC;SACJ;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,MAAyB,EAAE,SAAyB;QACvE,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAEjC,IAAI,QAAQ,KAAK,QAAQ,EAAE;YACzB,OAAO,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC;SACtD;aAAM,IAAI,QAAQ,KAAK,MAAM,EAAE;YAC9B,OAAO,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,mBAAmB,CAAC;SACxE;aAAM;YACL,OAAO,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC;SACtD;IACH,CAAC;IAED,+EAA+E;IAC/E,sBAAsB;IACtB,+EAA+E;IAE/E;;OAEG;IACK,4BAA4B;QAClC,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAE9C,UAAU,CAAC,aAAa,CACtB,IAAI,CAAC,eAAe,CAAC,MAAM,EAC3B,IAAI,CAAC,cAAc,CAAC,MAAM,CAC3B,CAAC;QAEF,sCAAsC;QACtC,IAAI,CAAC,iBAAiB,GAAG,UAAU,CAAC,oBAAoB,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;YAC5E,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;QAEH,sDAAsD;QACtD,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE;YACrE,UAAU,CAAC,GAAG,EAAE;gBACd,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAC7B,CAAC,EAAE,CAAC,CAAC,CAAC;SACP;IACH,CAAC;IAED;;OAEG;IACK,qBAAqB,CAAC,QAAkC;QAC9D,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QAElC,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE;YACzE,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;YAC3C,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE;gBACxD,MAAM,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAC3B,IAAI,CAAC,IAAI;oBAAE,SAAS;gBAEpB,MAAM,WAAW,GAAG,QAAQ;oBACT,QAAQ,CAAC,QAAQ,KAAK,QAAQ;oBAC9B,QAAQ,CAAC,WAAW,KAAK,QAAQ,CAAC;gBAErD,IAAI,WAAW,EAAE;oBACf,IAAI,CAAC,KAAK,EAAE,CAAC;oBACb,+BAA+B;oBAC/B,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;iBACzC;qBAAM;oBACL,IAAI,CAAC,IAAI,EAAE,CAAC;iBACb;aACF;SACF;IACH,CAAC;IAED;;OAEG;IACK,cAAc,CAAC,QAAgB,EAAE,QAAgB;QACvD,2CAA2C;QAC3C,UAAU,CAAC,GAAG,EAAE;YACd,8CAA8C;YAC9C,MAAM,EAAE,GAAG,QAAQ,CAAC,aAAa,CAAC,sBAAsB,QAAQ,IAAI,CAAC,CAAC;YACtE,IAAI,EAAE,EAAE;gBACN,MAAM,KAAK,GAAG,EAAE,CAAC,gBAAgB,CAAC,0BAA0B,CAAC,CAAC;gBAC9D,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAgB,CAAC;gBAClD,IAAI,UAAU,EAAE;oBACd,UAAU,CAAC,KAAK,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;iBAC5C;aACF;QACH,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,QAAgB,EAAE,WAAmB;QAC/C,IAAI,CAAC,IAAI,CAAC,2BAA2B,EAAE;YAAE,OAAO;QAChD,IAAI,CAAC,mBAAmB,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAC9D,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,KAAoB;QAC7B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE;YACtC,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YAC1C,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;YAClC,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;YAEhF,IAAI,QAAQ,KAAK,SAAS,IAAI,WAAW,IAAI,CAAC,EAAE;gBAC9C,IAAI,CAAC,mBAAmB,EAAE,CAAC,cAAc,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;aAClE;SACF;IACH,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,KAAoB;QAC7B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE;YACtC,IAAI,CAAC,mBAAmB,EAAE,CAAC,gBAAgB,EAAE,CAAC;SAC/C;IACH,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,KAAsB;QACjC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE5B,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE;YACtC,IAAI,CAAC,mBAAmB,EAAE,CAAC,gBAAgB,EAAE,CAAC;SAC/C;IACH,CAAC;IAED;;OAEG;IACH,qBAAqB,CAAC,KAA6D;QACjF,4DAA4D;QAC5D,uCAAuC;QACvC,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE;YACtC,IAAI,CAAC,mBAAmB,EAAE,CAAC,gBAAgB,EAAE,CAAC;YAC9C,wCAAwC;YACxC,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,mBAAmB,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YACxD,CAAC,EAAE,CAAC,CAAC,CAAC;SACP;IACH,CAAC;IAED;;OAEG;IACH,qBAAqB,CAAC,KAAiB;QACrC,IAAI,CAAC,IAAI,CAAC,2BAA2B,EAAE;YAAE,OAAO;QAEhD,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC9C,MAAM,YAAY,GAAG,UAAU,CAAC,kBAAkB,EAAE,CAAC;QAErD,8CAA8C;QAC9C,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE;YACtF,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;SAC5B;IACH,CAAC;IAED;;OAEG;IACH,2BAA2B;QACzB,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,kBAAkB,EAAE,OAAO,IAAI,KAAK,CAAC;IAC1E,CAAC;IAED;;;;;OAKG;IACH,mBAAmB;QACjB,4EAA4E;QAC5E,iDAAiD;QACjD,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE;YACtC,OAAO,QAAQ,CAAC,KAAK,CAAC;SACvB;QACD,OAAO,QAAQ,CAAC,KAAK,CAAC;IACxB,CAAC;IAED;;OAEG;IAEH,eAAe,CAAC,KAAiB;QAC/B,IAAI,CAAC,IAAI,CAAC,2BAA2B,EAAE;YAAE,OAAO;QAEhD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAqB,CAAC;QAC3C,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAEjD,IAAI,CAAC,YAAY,EAAE;YACjB,IAAI,CAAC,mBAAmB,EAAE,CAAC,UAAU,EAAE,CAAC;YACxC,IAAI,CAAC,mBAAmB,EAAE,CAAC,gBAAgB,EAAE,CAAC;SAC/C;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE,CAAC;QACtC,IAAI,CAAC,kBAAkB,EAAE,WAAW,EAAE,CAAC;QACvC,IAAI,CAAC,iBAAiB,EAAE,WAAW,EAAE,CAAC;QACtC,IAAI,CAAC,sBAAsB,EAAE,WAAW,EAAE,CAAC;QAC3C,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,CAAC;QACrC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,CAAC;QACpC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IAChC,CAAC;;6GAl5CU,gBAAgB;iGAAhB,gBAAgB,8wBAwHU,UAAU,kDChJjD,kiYAiSc;2FDzQD,gBAAgB;kBAL5B,SAAS;+BACE,UAAU;0LASX,WAAW;sBAAnB,KAAK;gBAGG,IAAI;sBAAZ,KAAK;gBAGG,KAAK;sBAAb,KAAK;gBAEG,UAAU;sBAAlB,KAAK;gBAGG,aAAa;sBAArB,KAAK;gBACG,eAAe;sBAAvB,KAAK;gBAGI,WAAW;sBAApB,MAAM;gBAGG,UAAU;sBAAnB,MAAM;gBAGG,QAAQ;sBAAjB,MAAM;gBACG,QAAQ;sBAAjB,MAAM;gBACG,UAAU;sBAAnB,MAAM;gBACG,UAAU;sBAAnB,MAAM;gBACG,aAAa;sBAAtB,MAAM;gBACG,WAAW;sBAApB,MAAM;gBAGG,sBAAsB;sBAA/B,MAAM;gBAGG,WAAW;sBAApB,MAAM;gBAGG,SAAS;sBAAlB,MAAM;gBAGG,qBAAqB;sBAA9B,MAAM;gBAGE,cAAc;sBAAtB,KAAK;gBA0E6C,cAAc;sBAAhE,SAAS;uBAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;gBAswCjD,eAAe;sBADd,YAAY;uBAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import { Component, Input, Output, EventEmitter, OnInit, OnDestroy, OnChanges, SimpleChanges, ViewChild, ElementRef, AfterViewInit, HostListener } from '@angular/core';\nimport { ColumnConfig } from '../../../models/column-config.interface';\nimport { Cell } from '../../models/cell.class';\nimport { TableState } from '../../models/table-state.class';\nimport { TableConfig, mergeTableConfig } from '../../../models/table-config.interface';\nimport { TableStateChangeEvent, ColumnResizeEvent, ColumnAddEvent, ColumnMoveEvent, CellFocusPosition, DataChangeEvent } from '../../models/table-types';\nimport { CellChangeEvent, CellSaveEvent, CellEditEvent, CellCancelEvent, EditMode, NavigationDirection } from '../../../models/cell-types';\nimport { BehaviorSubject, Observable, Subscription } from 'rxjs';\nimport { map, distinctUntilChanged } from 'rxjs/operators';\nimport { JsonSchemaValidatorService } from '../../../services/json-schema-validator.service';\nimport { SchemaValidationError } from '../../../models/schema-validation.interface';\nimport { ValidationLoggerService } from '../../../services/validation-logger.service';\nimport { VirtualScrollService, VirtualScrollState } from '../../../services/virtual-scroll.service';\nimport { RowAction, RowActionContext, RowActionEvent } from '../../../models/row-action.interface';\nimport { ColumnAction, ColumnActionContext, ColumnActionEvent } from '../../../models/column-action.interface';\nimport { TableZIndex } from '../../models/z-index.enum';\nimport { SortDirection } from '../../models/table-types';\nimport { TableValidationState } from '../../models/table-validation-state.interface';\n\n@Component({\n  selector: 'st-table',\n  templateUrl: './st-table.component.html',\n  styleUrls: ['./st-table.component.scss']\n})\nexport class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {\n  // Z-Index constants for template use\n  readonly ZIndex = TableZIndex;\n  \n  // NEW: Primary configuration input\n  @Input() tableConfig!: TableConfig;\n  \n  // NEW: Raw data input (alternative to cellGrid)\n  @Input() data?: any[];\n  \n  // NEW: Observable/BehaviorSubject data input (for reactive data streams)\n  @Input() data$?: Observable<any[]> | BehaviorSubject<any[]>;\n  \n  @Input() tableState?: TableState;\n  \n  // DEPRECATED: Use tableConfig instead\n  @Input() enableSorting: boolean = true;\n  @Input() enableFiltering: boolean = true;\n  \n  // NEW: State change output\n  @Output() stateChange = new EventEmitter<TableStateChangeEvent>();\n  \n  // NEW: Data change output (for async data updates)\n  @Output() dataChange = new EventEmitter<DataChangeEvent>();\n  \n  // EXISTING: Cell and column events\n  @Output() cellEdit = new EventEmitter<CellEditEvent>();\n  @Output() cellSave = new EventEmitter<CellSaveEvent>();\n  @Output() cellCancel = new EventEmitter<CellCancelEvent>();\n  @Output() cellChange = new EventEmitter<CellChangeEvent>();\n  @Output() columnResized = new EventEmitter<ColumnResizeEvent>();\n  @Output() columnMoved = new EventEmitter<ColumnMoveEvent>();\n  \n  // NEW: Configuration validation output\n  @Output() configValidationErrors = new EventEmitter<SchemaValidationError[]>();\n  \n  // NEW: Column management output\n  @Output() columnAdded = new EventEmitter<ColumnAddEvent>();\n  \n  // NEW: Row action output\n  @Output() rowAction = new EventEmitter<RowActionEvent>();\n  \n  // NEW: Validation state change output\n  @Output() validationStateChange = new EventEmitter<TableValidationState>();\n  \n  // NEW: Optional validation flag\n  @Input() validateConfig: boolean = false;\n  \n  // Internal state\n  private internalTableState?: TableState;\n  private internalCellGrid?: Cell<any>[][];\n  private stateSubscription?: Subscription;\n  private focusSubscription?: Subscription;\n  private validationSubscription?: Subscription;\n  private dataSubscription?: Subscription;\n  private internalData$: BehaviorSubject<any[]> = new BehaviorSubject<any[]>([]);\n  private previousData: any[] = [];\n  mergedConfig!: TableConfig;\n  \n  // Modal state\n  public showColumnModal: boolean = false;\n  \n  // Cached visible columns and cell grid to prevent re-creation on every change detection\n  public visibleColumns: ColumnConfig<any>[] = [];\n  public visibleCellGrid: Cell<any>[][] = [];\n  \n  // Row actions dropdown state\n  public dropdownState: {\n    isOpen: boolean;\n    position: { x: number; y: number };\n    context: RowActionContext | null;\n  } = {\n    isOpen: false,\n    position: { x: 0, y: 0 },\n    context: null\n  };\n  \n  public skeletonColumns?: number[];\n  public skeletonRows?: number[];\n\n  // Column menu dropdown state\n  public columnMenuState: {\n    isOpen: boolean;\n    position: { x: number; y: number };\n    context: ColumnActionContext | null;\n  } = {\n    isOpen: false,\n    position: { x: 0, y: 0 },\n    context: null\n  };\n  \n  // Virtual scroll properties\n  private scrollContainer?: HTMLElement;\n  private scrollSubscription?: Subscription;\n  private virtualScrollState$ = new BehaviorSubject<VirtualScrollState | null>(null);\n  \n  // Observable streams derived from virtual scroll state\n  public virtualScrollTotalHeight$: Observable<number> = this.virtualScrollState$.pipe(\n    map(state => state?.totalHeight ?? 0),\n    distinctUntilChanged()\n  );\n  \n  public virtualScrollOffsetY$: Observable<number> = this.virtualScrollState$.pipe(\n    map(state => state?.offsetY ?? 0),\n    distinctUntilChanged()\n  );\n\n  public virtualScrollOffsetYNeg$: Observable<number> = this.virtualScrollState$.pipe(\n    map(state => Number(state?.offsetY ?? 0) * -1 ),\n    distinctUntilChanged()\n  );\n  \n  public visibleRows$: Observable<Cell<any>[][]> = this.virtualScrollState$.pipe(\n    map(state => {\n      if (!state) return this.visibleCellGrid;\n      const { startIndex, endIndex } = state;\n      return this.visibleCellGrid.slice(startIndex, endIndex);\n    })\n  );\n  \n  @ViewChild('scrollViewport', { read: ElementRef }) scrollViewport?: ElementRef<HTMLElement>;\n  \n  constructor(\n    private schemaValidator: JsonSchemaValidatorService,\n    private logger: ValidationLoggerService,\n    private virtualScrollService: VirtualScrollService,\n  ) {}\n\n  ngOnInit(): void {\n    // Validate that at least tableConfig or columns is provided\n    if (!this.tableConfig) {\n      throw new Error('Either tableConfig or columns must be provided');\n    }\n    \n    // Merge config with defaults\n    if (this.tableConfig) {\n      this.mergedConfig = mergeTableConfig(this.tableConfig);\n      \n      // Validate configuration if enabled\n      if (this.validateConfig) {\n        this.validateConfiguration(this.mergedConfig);\n      }\n    }\n    \n    // Create or use TableState\n    if (!this.tableState) {\n      this.createInternalTableState();\n    } else {\n      // Subscribe to external tableState changes\n      this.subscribeToExternalTableState();\n    }\n    \n    // Setup data source (sync or async)\n    this.setupDataSource();\n    \n    // Calculate sticky offsets\n    const rowNumberWidth = this.mergedConfig.showRowNumber ? 30 : 0;\n    const settingsColumnWidth = this.hasRowActions() ? 28 : 0; // Settings column is ~32px wide when visible\n    this.getActiveTableState().calculateStickyOffsets(rowNumberWidth, settingsColumnWidth);\n    \n    // Initialize visible columns and cell grid\n    this.updateVisibleData();\n    \n    // Initialize virtual scroll if enabled\n    if (this.isVirtualScrollEnabled()) {\n      this.initializeVirtualScroll();\n    }\n    \n    // Initialize keyboard navigation if enabled\n    if (this.isKeyboardNavigationEnabled()) {\n      this.initializeKeyboardNavigation();\n    }\n\n    this.skeletonColumns = Array.from({ length: this.mergedConfig.tableSkeleton?.columns ?? 10 }, (_, i) => i);\n    this.skeletonRows = Array.from({ length: this.mergedConfig.tableSkeleton?.rows ?? 10 }, (_, i) => i);\n  }\n  \n  ngAfterViewInit(): void {\n    // Setup virtual scroll after view is ready\n    if (this.isVirtualScrollEnabled() && this.scrollViewport) {\n      this.setupVirtualScrollListener();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // Validate configuration when tableConfig changes\n    if (changes['tableConfig'] && !changes['tableConfig'].firstChange && this.tableConfig) {\n      this.mergedConfig = mergeTableConfig(this.tableConfig);\n      \n      // Validate configuration if enabled\n      if (this.validateConfig) {\n        this.validateConfiguration(this.mergedConfig);\n      }\n      \n      // Update internal table state with new columns if using internal state\n      if (this.internalTableState) {\n        this.internalTableState.updateColumns(this.mergedConfig.columns);\n      }\n      \n      // Update visible columns and cell grid\n      this.updateVisibleData();\n    }\n    \n    // Recreate cell grid when data changes (only if not using data$ Observable)\n    if (changes['data'] && !changes['data'].firstChange && this.data && !this.data$) {\n      this.handleSyncDataChange(changes['data'].previousValue || []);\n    }\n    \n    // Handle data$ Observable input changes\n    if (changes['data$'] && !changes['data$'].firstChange) {\n      this.setupDataSource();\n    }\n    \n    // Recreate cell grid when cellGrid changes\n    if (changes['cellGrid'] && !changes['cellGrid'].firstChange) {\n      // Cell grid was updated externally, no need to recreate\n      // Just recalculate sticky offsets if needed\n      if (this.getActiveTableState()) {\n        const rowNumberWidth = this.mergedConfig.showRowNumber ? 30 : 0;\n        const settingsColumnWidth = this.hasRowActions() ? 32 : 0;\n        this.getActiveTableState().calculateStickyOffsets(rowNumberWidth, settingsColumnWidth);\n      }\n      // Update visible columns and cell grid\n      this.updateVisibleData();\n    }\n    \n    // Recalculate virtual scroll when data changes\n    if ((changes['data'] || changes['cellGrid']) && !changes['data']?.firstChange) {\n      if (this.isVirtualScrollEnabled()) {\n        const currentState = this.virtualScrollState$.value;\n        if (currentState) {\n          const newState = this.virtualScrollService.calculateVisibleRange({\n            scrollTop: currentState.scrollTop,\n            viewportHeight: this.getVirtualScrollViewportHeight(),\n            totalItems: this.visibleCellGrid.length,\n            itemSize: this.getVirtualScrollItemSize(),\n            bufferSize: this.getVirtualScrollBufferSize()\n          });\n          this.virtualScrollState$.next(newState);\n        }\n      }\n      \n      // Update keyboard navigation dimensions if enabled\n      if (this.isKeyboardNavigationEnabled() && (changes['data'] || changes['cellGrid'])) {\n        this.getActiveTableState().setDimensions(\n          this.visibleCellGrid.length,\n          this.visibleColumns.length\n        );\n      }\n    }\n  }\n\n  /**\n   * Create internal TableState from config\n   */\n  private createInternalTableState(): void {\n    const columns = this.getActiveColumns();\n    this.internalTableState = new TableState(columns, {\n      pageSize: this.mergedConfig.pagination?.pageSize,\n      initialPage: this.mergedConfig.initialState?.page\n    });\n    \n    // Set total items if provided in config (for server-side pagination)\n    if (this.mergedConfig.pagination?.totalItems !== undefined) {\n      this.internalTableState.setTotalItems(this.mergedConfig.pagination.totalItems);\n    }\n    \n    // Apply initial sort if provided\n    if (this.mergedConfig.initialState?.sortBy) {\n      this.mergedConfig.initialState.sortBy.forEach(sort => {\n        this.internalTableState!.addSortToColumn(sort.key, sort.direction);\n      });\n    }\n    \n    // Apply initial filters if provided\n    if (this.mergedConfig.initialState?.filters) {\n      this.mergedConfig.initialState.filters.forEach(filter => {\n        this.internalTableState!.setFilterOnColumn(filter.key, filter.operator, filter.value);\n      });\n    }\n    \n    // Subscribe to internal state changes and re-emit\n    this.stateSubscription = this.internalTableState.stateChange$\n      .subscribe(event => {\n        this.stateChange.emit(event);\n        \n        // Update visible columns and cell grid on visibility changes\n        if (event.type === 'column-visibility' || event.type === 'column-config') {\n          this.updateVisibleData();\n        }\n      });\n    \n    // Subscribe to validation state changes and re-emit\n    this.validationSubscription = this.internalTableState.tableValidationState$\n      .subscribe(state => {\n        this.validationStateChange.emit(state);\n      });\n  }\n  \n  /**\n   * Subscribe to external TableState changes\n   */\n  private subscribeToExternalTableState(): void {\n    if (!this.tableState) return;\n    \n    this.stateSubscription = this.tableState.stateChange$\n      .subscribe(event => {\n        this.stateChange.emit(event);\n        \n        // Update visible columns and cell grid on visibility changes\n        if (event.type === 'column-visibility' || event.type === 'column-config') {\n          this.updateVisibleData();\n        }\n      });\n    \n    // Subscribe to validation state changes and re-emit\n    this.validationSubscription = this.tableState.tableValidationState$\n      .subscribe(state => {\n        this.validationStateChange.emit(state);\n      });\n  }\n  \n  /**\n   * Create cell grid from raw data\n   */\n  private createCellGridFromData(): void {\n    if (!this.data) return;\n    \n    const columns = this.getActiveColumns();\n    this.internalCellGrid = this.data.map((rowData, rowIndex) =>\n      columns.map(column => \n        new Cell(column, rowData[column.key], rowData, rowIndex)\n      )\n    );\n  }\n  \n  /**\n   * Setup data source - either sync array or async Observable\n   * Handles initialization and subscription to data changes\n   */\n  private setupDataSource(): void {\n    // Warn if both data and data$ are provided\n    if (this.data && this.data$) {\n      console.warn('StTableComponent: Both data and data$ inputs are provided. Using data$ (Observable) and ignoring data array.');\n    }\n    \n    // Clean up existing subscription\n    this.dataSubscription?.unsubscribe();\n    \n    // Priority: data$ takes precedence over data\n    if (this.data$) {\n      this.subscribeToDataChanges();\n    } else if (this.data) {\n      // For sync data, emit once through internal observable\n      this.previousData = [];\n      this.internalData$.next(this.data);\n      this.subscribeToDataChanges();\n    } else {\n      // No data provided, emit empty array\n      this.previousData = [];\n      this.internalData$.next([]);\n      this.subscribeToDataChanges();\n    }\n  }\n  \n  /**\n   * Subscribe to data changes (either from data$ input or internal BehaviorSubject)\n   */\n  private subscribeToDataChanges(): void {\n    const dataSource$ = this.data$ || this.internalData$.asObservable();\n    \n    this.dataSubscription = dataSource$.subscribe(newData => {\n      this.handleDataChange(newData);\n    });\n  }\n  \n  /**\n   * Handle data change from Observable emission\n   */\n  private handleDataChange(newData: any[]): void {\n    const timestamp = Date.now();\n    const source: 'sync' | 'async' = this.data$ ? 'async' : 'sync';\n    \n    // Emit data change event\n    this.dataChange.emit({\n      previousData: this.previousData,\n      currentData: newData,\n      timestamp,\n      source\n    });\n    \n    // Update data reference\n    this.data = newData;\n    this.previousData = [...newData];\n    \n    // Recreate cell grid\n    this.createCellGridFromData();\n    \n    // Update visible data\n    this.updateVisibleData();\n    \n    // Recalculate virtual scroll if enabled\n    if (this.isVirtualScrollEnabled()) {\n      const currentState = this.virtualScrollState$.value;\n      if (currentState) {\n        const newState = this.virtualScrollService.calculateVisibleRange({\n          scrollTop: currentState.scrollTop,\n          viewportHeight: this.getVirtualScrollViewportHeight(),\n          totalItems: this.visibleCellGrid.length,\n          itemSize: this.getVirtualScrollItemSize(),\n          bufferSize: this.getVirtualScrollBufferSize()\n        });\n        this.virtualScrollState$.next(newState);\n      }\n    }\n    \n    // Update keyboard navigation dimensions if enabled\n    if (this.isKeyboardNavigationEnabled()) {\n      this.getActiveTableState().setDimensions(\n        this.visibleCellGrid.length,\n        this.visibleColumns.length\n      );\n    }\n  }\n  \n  /**\n   * Handle sync data change (from @Input() data changes)\n   */\n  private handleSyncDataChange(previousData: any[]): void {\n    this.previousData = previousData;\n    this.internalData$.next(this.data || []);\n  }\n  \n  /**\n   * Get active TableState (provided or internal)\n   */\n  getActiveTableState(): TableState {\n    return this.tableState || this.internalTableState!;\n  }\n  \n  /**\n   * Get active cell grid (provided or internal)\n   */\n  getActiveCellGrid(): Cell<any>[][] {\n    return this.internalCellGrid || [];\n  }\n\n  /**\n   * Get visible cell grid (filtered to only include visible columns)\n   */\n  getVisibleCellGrid(): Cell<any>[][] {\n    const allColumns = this.getActiveColumns();\n    const visibleColumns = this.getVisibleColumns();\n    const visibleColumnKeys = new Set(visibleColumns.map(col => col.key));\n    \n    // Get column indices for visible columns\n    const visibleIndices = allColumns\n      .map((col, index) => visibleColumnKeys.has(col.key) ? index : -1)\n      .filter(index => index !== -1);\n    \n    const fullGrid = this.getActiveCellGrid();\n    return fullGrid.map(row => \n      visibleIndices.map(index => row[index]).filter(cell => cell !== undefined)\n    );\n  }\n\n  /**\n   * Update the visible cell grid based on current visibility and column order\n   * Called when data, visibility, or column order changes\n   * \n   * This method properly handles column reordering by mapping cells based on\n   * column keys rather than indices, ensuring cells follow their columns.\n   */\n  private updateVisibleCellGrid(): void {\n    const fullGrid = this.getActiveCellGrid();\n    \n    // Handle empty grid\n    if (!fullGrid || fullGrid.length === 0) {\n      this.visibleCellGrid = [];\n      return;\n    }\n    \n    // Build a map of columnKey → cellIndex for the current grid structure\n    // This allows us to find cells by column key regardless of their current position\n    const keyToIndexMap = new Map<string, number>();\n    fullGrid[0]?.forEach((cell, index) => {\n      if (cell) {\n        const columnConfig = cell.getColumnConfig();\n        keyToIndexMap.set(columnConfig.key, index);\n      }\n    });\n    \n    // Reorder cells to match the visibleColumns order\n    // This ensures that when columns are moved, the cell data follows\n    this.visibleCellGrid = fullGrid.map(row => {\n      return this.visibleColumns\n        .map(col => {\n          const cellIndex = keyToIndexMap.get(col.key);\n          return cellIndex !== undefined ? row[cellIndex] : undefined;\n        })\n        .filter((cell): cell is Cell<any> => cell !== undefined);\n    });\n  }\n\n  /**\n   * Update the visible columns based on current visibility\n   * Called only when visibility actually changes\n   */\n  private updateVisibleColumns(): void {\n    const allColumns = this.getActiveColumns();\n    this.visibleColumns = allColumns.filter(col => col.visible !== false);\n    \n    // Recalculate sticky offsets for visible columns only\n    this.recalculateVisibleStickyOffsets(this.visibleColumns);\n  }\n\n  /**\n   * Update both visible columns and cell grid\n   * Call this whenever data or visibility changes\n   */\n  private updateVisibleData(): void {\n    this.updateVisibleColumns();\n    this.updateVisibleCellGrid();\n  }\n  \n  /**\n   * Get active columns (from config or legacy input)\n   */\n  getActiveColumns(): ColumnConfig<any>[] {\n    return this.mergedConfig.columns;\n  }\n\n  /**\n   * Get visible columns (filtered by visibility property)\n   * Also recalculates sticky offsets based on visible columns only\n   */\n  getVisibleColumns(): ColumnConfig<any>[] {\n    const allColumns = this.getActiveColumns();\n    const visibleColumns = allColumns.filter(col => col.visible !== false); // Default to true if not set\n    \n    // Recalculate sticky offsets for visible columns only\n    this.recalculateVisibleStickyOffsets(visibleColumns);\n    \n    return visibleColumns;\n  }\n\n  /**\n   * Recalculate sticky offsets based on visible columns only\n   * This ensures correct positioning when columns are hidden\n   */\n  private recalculateVisibleStickyOffsets(visibleColumns: ColumnConfig<any>[]): void {\n    // Calculate left sticky offsets\n    // Account for row number column width if shown\n    let leftOffset = this.mergedConfig.showRowNumber ? 30 : 0;\n    visibleColumns.forEach(col => {\n      if (col.sticky === 'left') {\n        (col as any).stickyOffset = leftOffset;\n        leftOffset += (col.width as number) || 100;\n      }\n    });\n\n    // Calculate right sticky offsets\n    let rightOffset = 0;\n    for (let i = visibleColumns.length - 1; i >= 0; i--) {\n      const col = visibleColumns[i];\n      if (col.sticky === 'right') {\n        (col as any).stickyOffset = rightOffset;\n        rightOffset += (col.width as number) || 100;\n      }\n    }\n  }\n\n  onCellChange(event: CellChangeEvent): void {\n    this.cellChange.emit(event);\n  }\n\n  onColumnResized(event: ColumnResizeEvent): void {\n    // Recalculate sticky offsets after resize\n    const rowNumberWidth = this.mergedConfig.showRowNumber ? 30 : 0;\n    const settingsColumnWidth = this.hasRowActions() ? 32 : 0;\n    this.getActiveTableState().calculateStickyOffsets(rowNumberWidth, settingsColumnWidth);\n    \n    // Emit to parent\n    this.columnResized.emit(event);\n  }\n\n  onColumnMoved(event: {columnKey: string, direction: 'left' | 'right'}): void {\n    const columns = this.getActiveColumns();\n    const currentIndex = columns.findIndex(c => c.key === event.columnKey);\n    if (currentIndex === -1) return;\n    \n    // Calculate target index\n    const targetIndex = event.direction === 'left' \n      ? currentIndex - 1 \n      : currentIndex + 1;\n    \n    // Check bounds\n    if (targetIndex < 0 || targetIndex >= columns.length) {\n      return;\n    }\n    \n    // Swap columns\n    [columns[currentIndex], columns[targetIndex]] = \n    [columns[targetIndex], columns[currentIndex]];\n    \n    // Update TableState with new column order\n    this.getActiveTableState().updateColumns(columns);\n    this.columnMoved.emit({\n      columnKey: event.columnKey,\n      direction: event.direction,\n      oldIndex: currentIndex,\n      newIndex: targetIndex,\n      column: columns[currentIndex]\n    });\n    // Force virtual scroll to re-render by re-emitting current state\n    // This ensures visibleRows$ picks up the updated visibleCellGrid\n    if (this.isVirtualScrollEnabled()) {\n      const currentState = this.virtualScrollState$.value;\n      if (currentState) {\n        this.virtualScrollState$.next({...currentState});\n      }\n    }\n  }\n\n  /**\n   * Move column to position just before right sticky columns (used when pinning right)\n   */\n  private moveColumnToEnd(columnKey: string): void {\n    const columns = this.getActiveColumns();\n    const currentIndex = columns.findIndex(c => c.key === columnKey);\n    if (currentIndex === -1) return;\n    \n    // Find the index of the first right-sticky column\n    const firstRightStickyIndex = columns.findIndex(c => c.sticky === 'right');\n    \n    // Determine target index: just before first right-sticky, or at end if none exist\n    const targetIndex = firstRightStickyIndex !== -1 ? firstRightStickyIndex : columns.length;\n    \n    // If already at target position, no need to move\n    if (currentIndex === targetIndex || currentIndex === targetIndex - 1) return;\n    \n    // Remove column from current position\n    const [column] = columns.splice(currentIndex, 1);\n    \n    // Adjust target index if we removed an element before it\n    const adjustedTargetIndex = currentIndex < targetIndex ? targetIndex - 1 : targetIndex;\n    \n    // Insert at target position (before first right-sticky column, or at end)\n    columns.splice(adjustedTargetIndex, 0, column);\n    \n    // Update TableState with new column order\n    this.getActiveTableState().updateColumns(columns);\n    \n    // Force virtual scroll to re-render\n    if (this.isVirtualScrollEnabled()) {\n      const currentState = this.virtualScrollState$.value;\n      if (currentState) {\n        this.virtualScrollState$.next({...currentState});\n      }\n    }\n  }\n\n  /**\n   * Get cumulative left offset for a sticky column on the left side\n   */\n  getStickyLeftOffset(columnKey: string): number {\n    const columns = this.getActiveColumns();\n    let offset = 0;\n    for (const col of columns) {\n      if (col.key === columnKey) break;\n      if (col.sticky === 'left') {\n        offset += (col.width as number) || 100;\n      }\n    }\n    return offset;\n  }\n\n  /**\n   * Get cumulative right offset for a sticky column on the right side\n   */\n  getStickyRightOffset(columnKey: string): number {\n    const columns = this.getActiveColumns();\n    let offset = 0;\n    const colIndex = columns.findIndex(c => c.key === columnKey);\n    for (let i = colIndex + 1; i < columns.length; i++) {\n      const col = columns[i];\n      if (col.sticky === 'right') {\n        offset += (col.width as number) || 100;\n      }\n    }\n    return offset;\n  }\n  \n  /**\n   * Check if top pagination should be shown\n   */\n  showTopPagination(): boolean {\n    return this.mergedConfig.pagination?.enabled == true &&\n           this.mergedConfig.pagination?.showTopControls === true;\n  }\n  \n  /**\n   * Check if bottom pagination should be shown\n   */\n  showBottomPagination(): boolean {\n    return this.mergedConfig.pagination?.enabled == true &&\n           (this.mergedConfig.pagination?.showBottomControls ?? true);\n  }\n  \n  /**\n   * Validate table configuration\n   * @param config Table configuration to validate\n   */\n  private validateConfiguration(config: TableConfig): void {\n    const result = this.schemaValidator.validate(config, true, false); // Disable logging here, we'll log manually with context\n    \n    if (!result.valid && result.errors.length > 0) {\n      // Emit validation errors\n      this.configValidationErrors.emit(result.errors);\n      \n      // Log validation errors with context\n      const configSnippet = JSON.stringify(config, null, 2).substring(0, 500); // First 500 chars of config\n      this.logger.logValidationErrors(result.errors, 'renderer', {\n        configSnippet: configSnippet\n      });\n      \n      // Log warnings to console (don't break rendering)\n      console.warn('Smart Table: Configuration validation errors detected:', result.errors);\n      result.errors.forEach(error => {\n        console.warn(`  - ${error.field || error.path}: ${error.message}`);\n      });\n    }\n  }\n  \n  /**\n   * Handle add column button click\n   */\n  onAddColumnClick(): void {\n    this.showColumnModal = true;\n  }\n  \n  /**\n   * Handle column created from modal\n   */\n  onColumnCreated(column: ColumnConfig): void {\n    const columns = this.getActiveColumns();\n    const addEvent: ColumnAddEvent = {\n      column: column,\n      index: columns.length,\n      totalColumns: columns.length + 1\n    };\n    \n    // Emit the new column to parent component\n    this.columnAdded.emit(addEvent);\n    \n    // Close the modal\n    this.showColumnModal = false;\n  }\n  \n  /**\n   * Handle modal cancelled\n   */\n  onModalCancelled(): void {\n    this.showColumnModal = false;\n  }\n\n  /**\n   * Check if virtual scroll is enabled\n   */\n  isVirtualScrollEnabled(): boolean {\n    return this.mergedConfig.display?.virtualScroll?.enabled ?? false;\n  }\n  \n  /**\n   * Check if column is the first sticky-right column (for shadow styling)\n   */\n  isFirstStickyRight(columnKey: string): boolean {\n    const stickyRightColumns = this.visibleColumns.filter(col => col.sticky === 'right' && !col.key.includes('settings'));\n    return stickyRightColumns.length > 0 && stickyRightColumns[0].key === columnKey;\n  }\n  \n  /**\n   * Get virtual scroll item size\n   */\n  getVirtualScrollItemSize(): number {\n    return this.mergedConfig.display?.virtualScroll?.itemSize ?? 48;\n  }\n  \n  /**\n   * Get viewport height\n   */\n  getVirtualScrollViewportHeight(): number {\n    return this.mergedConfig.display?.virtualScroll?.viewportHeight ?? 600;\n  }\n  \n  /**\n   * Get buffer size\n   */\n  getVirtualScrollBufferSize(): number {\n    return this.mergedConfig.display?.virtualScroll?.bufferSize ?? 5;\n  }\n  \n  /**\n   * Initialize virtual scroll state\n   */\n  private initializeVirtualScroll(): void {\n    const newState = this.virtualScrollService.calculateVisibleRange({\n      scrollTop: 0,\n      viewportHeight: this.getVirtualScrollViewportHeight(),\n      totalItems: this.visibleCellGrid.length,\n      itemSize: this.getVirtualScrollItemSize(),\n      bufferSize: this.getVirtualScrollBufferSize()\n    });\n    \n    this.virtualScrollState$.next(newState);\n  }\n  \n  /**\n   * Setup scroll event listener\n   */\n  private setupVirtualScrollListener(): void {\n    if (!this.scrollViewport) return;\n    \n    const element = this.scrollViewport.nativeElement;\n    this.scrollContainer = element;\n    \n    this.scrollSubscription = this.virtualScrollService\n      .createScrollObservable(element)\n      .subscribe(scrollTop => this.onVirtualScroll(scrollTop));\n  }\n  \n  /**\n   * Handle virtual scroll event\n   */\n  private onVirtualScroll(scrollTop: number): void {\n    const newState = this.virtualScrollService.calculateVisibleRange({\n      scrollTop,\n      viewportHeight: this.getVirtualScrollViewportHeight(),\n      totalItems: this.visibleCellGrid.length,\n      itemSize: this.getVirtualScrollItemSize(),\n      bufferSize: this.getVirtualScrollBufferSize()\n    });\n    \n    this.virtualScrollState$.next(newState);\n  }\n  \n  /**\n   * Get row index for tracking\n   */\n  getAbsoluteRowIndex(relativeIndex: number): number {\n    const currentState = this.virtualScrollState$.value;\n    if (!currentState) return relativeIndex;\n    return currentState.startIndex + relativeIndex;\n  }\n  \n  /**\n   * TrackBy function for better performance\n   */\n  trackByRowIndex = (index: number, row: Cell<any>[]): number => {\n    return this.getAbsoluteRowIndex(index);\n  }\n  \n  /**\n   * Scroll to specific row programmatically\n   */\n  scrollToRow(index: number): void {\n    if (!this.scrollContainer || !this.isVirtualScrollEnabled()) return;\n    \n    const scrollTop = index * this.getVirtualScrollItemSize();\n    this.scrollContainer.scrollTop = scrollTop;\n  }\n  \n  /**\n   * Check if row actions are enabled\n   */\n  hasRowActions(): boolean {\n    return !!(this.mergedConfig.features?.rowManagement?.actions && \n              this.mergedConfig.features.rowManagement.actions.length > 0);\n  }\n  \n  /**\n   * Get row actions from config\n   */\n  getRowActions(): RowAction[] {\n    return this.mergedConfig.features?.rowManagement?.actions || [];\n  }\n  \n  /**\n   * Get row data from cell grid\n   */\n  getRowData(rowIndex: number): any {\n    const cellGrid = this.getActiveCellGrid();\n    if (!cellGrid || rowIndex < 0 || rowIndex >= cellGrid.length) {\n      return null;\n    }\n    \n    const row = cellGrid[rowIndex];\n    if (!row || row.length === 0) {\n      return null;\n    }\n    \n    // Get raw data from first cell (all cells in a row share the same rowData)\n    return row[0]?.getRowData() || null;\n  }\n  \n  /**\n   * Open row actions dropdown\n   */\n  openRowActionsDropdown(event: MouseEvent, rowData: any, rowIndex: number): void {\n    event.preventDefault();\n    event.stopPropagation();\n    \n    const target = event.currentTarget as HTMLElement;\n    const rect = target.getBoundingClientRect();\n    \n    // Calculate position (below the button by default)\n    const position = {\n      x: rect.left,\n      y: rect.bottom + 4 // 4px gap\n    };\n    \n    // Create context\n    const context: RowActionContext = {\n      rowData,\n      rowIndex,\n      actions: this.getRowActions()\n    };\n    \n    // Update dropdown state\n    this.dropdownState = {\n      isOpen: true,\n      position,\n      context\n    };\n    \n    // Disable body scroll\n    document.body.style.overflow = 'hidden';\n    \n    // If virtual scroll is enabled, add scroll listener to close dropdown\n    if (this.isVirtualScrollEnabled() && this.scrollContainer) {\n      const scrollListener = () => {\n        this.closeRowActionsDropdown();\n        this.scrollContainer?.removeEventListener('scroll', scrollListener);\n      };\n      this.scrollContainer.addEventListener('scroll', scrollListener, { once: true });\n    }\n  }\n  \n  /**\n   * Close row actions dropdown\n   */\n  closeRowActionsDropdown(): void {\n    this.dropdownState = {\n      isOpen: false,\n      position: { x: 0, y: 0 },\n      context: null\n    };\n    \n    // Re-enable body scroll\n    document.body.style.overflow = '';\n  }\n  \n  /**\n   * Handle row action clicked\n   */\n  onRowActionClicked(event: RowActionEvent): void {\n    // Execute action callback if provided\n    if (event.action.action) {\n      event.action.action(event.rowData, event.rowIndex);\n    }\n    \n    // Emit event to parent\n    this.rowAction.emit(event);\n    \n    // Close dropdown\n    this.closeRowActionsDropdown();\n  }\n\n  // ============================================================================\n  // COLUMN MENU ACTIONS\n  // ============================================================================\n\n  /**\n   * Open column menu dropdown\n   */\n  openColumnMenu(event: MouseEvent, column: ColumnConfig<any>, columnIndex: number, isFirst: boolean, isLast: boolean): void {\n    event.preventDefault();\n    event.stopPropagation();\n\n    const target = event.currentTarget as HTMLElement;\n    const rect = target.getBoundingClientRect();\n\n    // Calculate position (below the button by default)\n    const position = {\n      x: rect.left,\n      y: rect.bottom + 4 // 4px gap\n    };\n\n    // Create context\n    const context: ColumnActionContext = {\n      column,\n      columnIndex,\n      isFirstColumn: isFirst,\n      isLastColumn: isLast,\n      tableState: this.getActiveTableState(),\n      actions: this.getColumnActions(column, columnIndex, isFirst, isLast)\n    };\n\n    // Update column menu state\n    this.columnMenuState = {\n      isOpen: true,\n      position,\n      context\n    };\n\n    // Disable body scroll\n    document.body.style.overflow = 'hidden';\n\n    // If virtual scroll is enabled, add scroll listener to close dropdown\n    if (this.isVirtualScrollEnabled() && this.scrollContainer) {\n      const scrollListener = () => {\n        this.closeColumnMenu();\n        this.scrollContainer?.removeEventListener('scroll', scrollListener);\n      };\n      this.scrollContainer.addEventListener('scroll', scrollListener, { once: true });\n    }\n  }\n\n  /**\n   * Close column menu dropdown\n   */\n  closeColumnMenu(): void {\n    this.columnMenuState = {\n      isOpen: false,\n      position: { x: 0, y: 0 },\n      context: null\n    };\n\n    // Re-enable body scroll\n    document.body.style.overflow = '';\n  }\n\n  /**\n   * Handle column action clicked\n   */\n  onColumnActionClicked(event: ColumnActionEvent): void {\n    // Execute action callback if provided\n    if (event.action.action) {\n      event.action.action(event.column, event.columnIndex);\n    }\n\n    // Don't close menu if it's a filter action (filter needs menu to stay open)\n    if (event.action.id === 'filter') {\n      return;\n    }\n\n    // Close dropdown for other actions\n    this.closeColumnMenu();\n  }\n\n  /**\n   * Get column actions (built-in + custom)\n   */\n  private getColumnActions(\n    column: ColumnConfig<any>, \n    columnIndex: number, \n    isFirst: boolean, \n    isLast: boolean\n  ): ColumnAction[] {\n    const actions: ColumnAction[] = [];\n    \n    // Add built-in actions if enabled (default: true)\n    const includeBuiltIn = column.includeBuiltInActions ?? true;\n    if (includeBuiltIn) {\n      actions.push(...this.getBuiltInColumnActions(column, columnIndex, isFirst, isLast));\n    }\n    \n    // Add custom column actions from config\n    if (column.columnActions && column.columnActions.length > 0) {\n      actions.push(...column.columnActions);\n    }\n    \n    return actions;\n  }\n\n  /**\n   * Get built-in column actions (sort, filter, pin, move)\n   */\n  private getBuiltInColumnActions(\n    column: ColumnConfig<any>,\n    columnIndex: number,\n    isFirst: boolean,\n    isLast: boolean\n  ): ColumnAction[] {\n    const tableState = this.getActiveTableState();\n    const actions: ColumnAction[] = [];\n\n    // Sort ascending\n    if (column.sortable !== false) {\n      actions.push({\n        id: 'sort-asc',\n        label: this.getSortLabel(column, 'asc'),\n        icon: '↑',\n        action: (col) => {\n          tableState.addSortToColumn(col.key, SortDirection.ASC);\n        }\n      });\n    }\n\n    // Sort descending\n    if (column.sortable !== false) {\n      actions.push({\n        id: 'sort-desc',\n        label: this.getSortLabel(column, 'desc'),\n        icon: '↓',\n        action: (col) => {\n          tableState.addSortToColumn(col.key, SortDirection.DESC);\n        }\n      });\n    }\n\n    // Clear sort (only show if currently sorted)\n    if (column.sortable !== false && column.sortDirection && column.sortDirection !== SortDirection.NONE) {\n      actions.push({\n        id: 'clear-sort',\n        label: 'Clear Sort',\n        icon: '✕',\n        action: (col) => {\n          tableState.addSortToColumn(col.key, SortDirection.NONE);\n        }\n      });\n    }\n\n    // Filter\n    if (column.filterable !== false) {\n      actions.push({\n        id: 'filter',\n        label: 'Filter',\n        icon: '⚑',\n        action: () => {\n          // Filter action handled by column menu component\n        }\n      });\n    }\n\n    // Pin Left (if not already pinned)\n    if (column.pinnable !== false && column.sticky !== 'left' && column.sticky !== 'right') {\n      actions.push({\n        id: 'pin-left',\n        label: 'Pin Left',\n        icon: '📌',\n        action: (col) => {\n          tableState.setStickyColumn(col.key, 'left');\n        }\n      });\n    }\n\n    // Pin Right (if not already pinned)\n    if (column.pinnable !== false && column.sticky !== 'left' && column.sticky !== 'right') {\n      actions.push({\n        id: 'pin-right',\n        label: 'Pin Right',\n        icon: '📌',\n        action: (col) => {\n          this.moveColumnToEnd(col.key);\n          tableState.setStickyColumn(col.key, 'right');\n        }\n      });\n    }\n\n    // Unpin (if currently pinned)\n    if (column.pinnable !== false && (column.sticky === 'left' || column.sticky === 'right')) {\n      actions.push({\n        id: 'unpin',\n        label: 'Unpin',\n        icon: '📍',\n        action: (col) => {\n          tableState.setStickyColumn(col.key, false);\n        }\n      });\n    }\n\n    // Move left (only if movable and not pinned)\n    if (!isFirst && column.movable !== false && !column.sticky) {\n      actions.push({\n        id: 'move-left',\n        label: 'Move Left',\n        icon: '←',\n        action: (col) => {\n          this.onColumnMoved({\n            columnKey: col.key,\n            direction: 'left'\n          });\n        }\n      });\n    }\n\n    // Move right (only if movable and not pinned)\n    if (!isLast && column.movable !== false && !column.sticky) {\n      actions.push({\n        id: 'move-right',\n        label: 'Move Right',\n        icon: '→',\n        action: (col) => {\n          this.onColumnMoved({\n            columnKey: col.key,\n            direction: 'right'\n          });\n        }\n      });\n    }\n\n    return actions;\n  }\n\n  /**\n   * Get sort label based on column data type\n   */\n  private getSortLabel(column: ColumnConfig<any>, direction: 'asc' | 'desc'): string {\n    const dataType = column.dataType;\n\n    if (dataType === 'number') {\n      return direction === 'asc' ? 'Sort 0→9' : 'Sort 9→0';\n    } else if (dataType === 'date') {\n      return direction === 'asc' ? 'Sort Oldest First' : 'Sort Newest First';\n    } else {\n      return direction === 'asc' ? 'Sort A→Z' : 'Sort Z→A';\n    }\n  }\n\n  // ============================================================================\n  // KEYBOARD NAVIGATION\n  // ============================================================================\n\n  /**\n   * Initialize keyboard navigation\n   */\n  private initializeKeyboardNavigation(): void {\n    const tableState = this.getActiveTableState();\n    \n    tableState.setDimensions(\n      this.visibleCellGrid.length,\n      this.visibleColumns.length\n    );\n    \n    // Subscribe to focus position changes\n    this.focusSubscription = tableState.focusedCellPosition$.subscribe(position => {\n      this.updateCellFocusStates(position);\n    });\n    \n    // Auto-focus first cell to enable keyboard navigation\n    if (this.visibleCellGrid.length > 0 && this.visibleColumns.length > 0) {\n      setTimeout(() => {\n        tableState.focusCell(0, 0);\n      }, 0);\n    }\n  }\n  \n  /**\n   * Update focus state in all cells\n   */\n  private updateCellFocusStates(position: CellFocusPosition | null): void {\n    if (!this.visibleCellGrid) return;\n    \n    for (let rowIndex = 0; rowIndex < this.visibleCellGrid.length; rowIndex++) {\n      const row = this.visibleCellGrid[rowIndex];\n      for (let colIndex = 0; colIndex < row.length; colIndex++) {\n        const cell = row[colIndex];\n        if (!cell) continue;\n        \n        const shouldFocus = position && \n                           position.rowIndex === rowIndex && \n                           position.columnIndex === colIndex;\n        \n        if (shouldFocus) {\n          cell.focus();\n          // Focus the actual DOM element\n          this.focusTdElement(rowIndex, colIndex);\n        } else {\n          cell.blur();\n        }\n      }\n    }\n  }\n  \n  /**\n   * Focus the TD element in the DOM\n   */\n  private focusTdElement(rowIndex: number, colIndex: number): void {\n    // Use setTimeout to ensure DOM has updated\n    setTimeout(() => {\n      // More robust: find the td by data attributes\n      const tr = document.querySelector(`tr[data-row-index=\"${rowIndex}\"]`);\n      if (tr) {\n        const cells = tr.querySelectorAll('td:not(.settings-column)');\n        const targetCell = cells[colIndex] as HTMLElement;\n        if (targetCell) {\n          targetCell.focus({ preventScroll: false });\n        }\n      }\n    }, 0);\n  }\n  \n  /**\n   * Handle cell click\n   */\n  onCellClick(rowIndex: number, columnIndex: number): void {\n    if (!this.isKeyboardNavigationEnabled()) return;\n    this.getActiveTableState().focusCell(rowIndex, columnIndex);\n  }\n  \n  /**\n   * Handle cell entering edit mode\n   */\n  onCellEdit(event: CellEditEvent): void {\n    this.cellEdit.emit(event);\n    \n    if (this.isKeyboardNavigationEnabled()) {\n      const rowIndex = event.cell.getRowIndex();\n      const columnKey = event.columnKey;\n      const columnIndex = this.visibleColumns.findIndex(col => col.key === columnKey);\n      \n      if (rowIndex !== undefined && columnIndex >= 0) {\n        this.getActiveTableState().setEditingCell(rowIndex, columnIndex);\n      }\n    }\n  }\n  \n  /**\n   * Handle cell save\n   */\n  onCellSave(event: CellSaveEvent): void {\n    this.cellSave.emit(event);\n    \n    if (this.isKeyboardNavigationEnabled()) {\n      this.getActiveTableState().clearEditingCell();\n    }\n  }\n  \n  /**\n   * Handle cell cancel\n   */\n  onCellCancel(event: CellCancelEvent): void {\n    this.cellCancel.emit(event);\n    \n    if (this.isKeyboardNavigationEnabled()) {\n      this.getActiveTableState().clearEditingCell();\n    }\n  }\n  \n  /**\n   * Handle cell save with navigation (Excel-like behavior)\n   */\n  onCellSaveAndNavigate(event: {event: KeyboardEvent, direction: NavigationDirection}): void {\n    // Navigation is already handled by the directive after save\n    // Just ensure editing state is cleared\n    if (this.isKeyboardNavigationEnabled()) {\n      this.getActiveTableState().clearEditingCell();\n      // Move focus in the specified direction\n      setTimeout(() => {\n        this.getActiveTableState().moveFocus(event.direction);\n      }, 0);\n    }\n  }\n  \n  /**\n   * Handle focus on table container - focus first cell if no cell is focused\n   */\n  onTableContainerFocus(event: FocusEvent): void {\n    if (!this.isKeyboardNavigationEnabled()) return;\n    \n    const tableState = this.getActiveTableState();\n    const currentFocus = tableState.getFocusedPosition();\n    \n    // If no cell is focused, focus the first cell\n    if (!currentFocus && this.visibleCellGrid.length > 0 && this.visibleColumns.length > 0) {\n      tableState.focusCell(0, 0);\n    }\n  }\n  \n  /**\n   * Check if keyboard navigation is enabled\n   */\n  isKeyboardNavigationEnabled(): boolean {\n    return this.mergedConfig.features?.keyboardNavigation?.enabled ?? false;\n  }\n  \n  /**\n   * Get EditMode enum value for cells\n   * For Excel-like tables with keyboard navigation, use ENTER mode\n   * which allows arrow key navigation without triggering edit.\n   * Double-click will still work to start editing.\n   */\n  getEditModeForCells(): EditMode {\n    // If keyboard navigation is enabled, use ENTER mode for Excel-like behavior\n    // Otherwise use CLICK mode for immediate editing\n    if (this.isKeyboardNavigationEnabled()) {\n      return EditMode.ENTER;\n    }\n    return EditMode.CLICK;\n  }\n  \n  /**\n   * Clear focus when clicking outside table\n   */\n  @HostListener('document:click', ['$event'])\n  onDocumentClick(event: MouseEvent): void {\n    if (!this.isKeyboardNavigationEnabled()) return;\n    \n    const target = event.target as HTMLElement;\n    const tableElement = target.closest('.st-table');\n    \n    if (!tableElement) {\n      this.getActiveTableState().clearFocus();\n      this.getActiveTableState().clearEditingCell();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.stateSubscription?.unsubscribe();\n    this.scrollSubscription?.unsubscribe();\n    this.focusSubscription?.unsubscribe();\n    this.validationSubscription?.unsubscribe();\n    this.dataSubscription?.unsubscribe();\n    this.virtualScrollState$.complete();\n    this.internalData$.complete();\n  }\n  \n}\n\n","<!-- Top pagination controls -->\n<st-pagination \n  *ngIf=\"showTopPagination() && !(mergedConfig.tableSkeleton?.enabled | async)\" \n  [tableState]=\"getActiveTableState()\"\n  [tableConfig]=\"mergedConfig\"\n  position=\"top\">\n</st-pagination>\n\n<div class=\"st-table\" *ngIf=\"!(mergedConfig.tableSkeleton?.enabled | async)\" \n  [ngClass]=\"{\n    'virtual-scroll-enabled': isVirtualScrollEnabled(),\n    'keyboard-navigation-enabled': isKeyboardNavigationEnabled()\n  }\"\n  [ngStyle]=\"{\n    'max-height.px': !isVirtualScrollEnabled() ? mergedConfig.display?.maxHeight : null\n  }\"\n  stKeyboardNavigation\n  [tableState]=\"getActiveTableState()\" \n  [attr.tabindex]=\"isKeyboardNavigationEnabled() ? 0 : -1\"\n  (focus)=\"onTableContainerFocus($event)\"\n  [attr.title]=\"isKeyboardNavigationEnabled() ? 'Click a cell or press Tab to start keyboard navigation' : null\">\n  <!-- Unified Table Actions Menu -->\n\n  <!-- Virtual scroll viewport wrapper -->\n  <div class=\"st-scroll-viewport\" #scrollViewport *ngIf=\"isVirtualScrollEnabled()\"\n    [ngStyle]=\"{ 'height.px': getVirtualScrollViewportHeight() }\">\n\n    <!-- Spacer to create scrollable area -->\n    <div class=\"st-scroll-spacer\" [ngStyle]=\"{ 'height.px': virtualScrollTotalHeight$ | async }\">\n    </div>\n\n    <!-- Table positioner with transform (instead of tbody) -->\n    <div class=\"st-table-positioner\" [ngStyle]=\"{ transform: 'translateY(' + (virtualScrollOffsetY$ | async) + 'px)' }\">\n      <!-- Table with only visible rows -->\n      <ng-container *ngTemplateOutlet=\"tableTemplate; context: { \n        mode: 'virtual',\n        theadStyle: { top: (virtualScrollOffsetYNeg$ | async) + 'px' }\n      }\"></ng-container>\n    </div>\n  </div>\n  \n  <!-- Standard table (when virtual scroll disabled) -->\n  <ng-container *ngIf=\"!isVirtualScrollEnabled()\">\n    <ng-container *ngTemplateOutlet=\"tableTemplate; context: { \n      mode: 'standard',\n      theadStyle: null\n    }\"></ng-container>\n  </ng-container>\n\n  <!-- Shared Column Menu Dropdown -->\n  <st-column-menu-dropdown \n  [isOpen]=\"columnMenuState.isOpen\"\n  [position]=\"columnMenuState.position\"\n  [context]=\"columnMenuState.context\"\n  (actionClicked)=\"onColumnActionClicked($event)\"\n  (closed)=\"closeColumnMenu()\">\n  </st-column-menu-dropdown>\n</div>\n\n<ng-container *ngIf=\"(mergedConfig.tableSkeleton?.enabled | async)\">\n  <ng-container *ngTemplateOutlet=\"skeletonLoader\"></ng-container>\n</ng-container>\n\n<!-- Shared Row Actions Dropdown -->\n<st-row-actions-dropdown [isOpen]=\"dropdownState.isOpen\" [position]=\"dropdownState.position\"\n  [context]=\"dropdownState.context\" (actionClicked)=\"onRowActionClicked($event)\" (closed)=\"closeRowActionsDropdown()\">\n</st-row-actions-dropdown>\n\n\n<!-- Bottom pagination controls -->\n<st-pagination \n  *ngIf=\"showBottomPagination() && !(mergedConfig.tableSkeleton?.enabled | async)\" \n  [tableState]=\"getActiveTableState()\"\n  [tableConfig]=\"mergedConfig\"\n  position=\"bottom\">\n</st-pagination>\n\n<!-- Add Column Modal -->\n<st-column-editor-modal *ngIf=\"showColumnModal\" (columnCreated)=\"onColumnCreated($event)\"\n  (cancelled)=\"onModalCancelled()\">\n</st-column-editor-modal>\n\n  <!-- ========================================== -->\n  <!-- REUSABLE TABLE TEMPLATE -->\n  <!-- ========================================== -->\n  <ng-template #tableTemplate let-mode=\"mode\" let-theadStyle=\"theadStyle\">\n    <table class=\"st-table-element\">\n      <!-- TABLE HEADER -->\n      <thead [ngClass]=\"{ 'sticky': mergedConfig.display?.stickyHeader }\" [ngStyle]=\"theadStyle\">\n        <tr>\n          <!-- Row Number Header -->\n          <th *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-header header-cell sticky-left\"\n              [ngStyle]=\"{\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_HEADER_CELL,\n                'width.px': 30\n              }\">\n            #\n          </th>\n          <!-- Column Headers -->\n          <th \n            *ngFor=\"let column of visibleColumns; let colIndex = index; let isFirst = first; let isLast = last\"\n            [ngClass]=\"{\n              'header-cell': mode === 'standard',\n              'sticky-left': column.sticky === 'left',\n              'sticky-right': column.sticky === 'right',\n              'sticky-right-first': column.sticky === 'right' && isFirstStickyRight(column.key),\n              'resizable': column.resizable !== false\n            }\"\n            [ngStyle]=\"{\n              position: column.sticky ? 'sticky' : null,\n              'left.px': column.sticky === 'left' ? (column.stickyOffset || 0) : null,\n              'right.px': column.sticky === 'right' ? (column.stickyOffset || 0) : null,\n              'z-index': column.sticky ? ZIndex.STICKY_HEADER_CELL : null,\n              'width.px': column.width\n            }\">\n            \n            <st-header \n              [column]=\"column\"\n              [columnIndex]=\"colIndex\"\n              [isFirstColumn]=\"isFirst\"\n              [isLastColumn]=\"isLast\"\n              [tableState]=\"getActiveTableState()\"\n              [enableSorting]=\"mergedConfig.sorting?.enabled ?? enableSorting\"\n              [enableFiltering]=\"mergedConfig.filtering?.enabled ?? enableFiltering\"\n              (columnMoved)=\"onColumnMoved($event)\"\n              (menuClick)=\"openColumnMenu($event, column, colIndex, isFirst, isLast)\">\n            </st-header>\n\n            <div \n              class=\"resize-handle\" \n              stColumnResize\n              [column]=\"column\"\n              (columnResized)=\"onColumnResized($event)\"\n              *ngIf=\"column.resizable !== false\">\n            </div>\n          </th>\n          \n          <!-- Settings Column Header -->\n          <th \n            class=\"settings-column sticky-right\"\n            [ngClass]=\"{ 'header-cell': mode === 'standard' }\"\n            [ngStyle]=\"{ 'z-index': ZIndex.STICKY_HEADER_CELL }\">\n            <div [ngClass]=\"{ 'flex-center': mode === 'virtual', 'header-content': mode === 'standard' }\">\n              <st-table-actions \n                [tableState]=\"getActiveTableState()\"\n                [allowAddColumn]=\"mergedConfig.features?.columnManagement?.allowAdd || false\"\n                (addColumnClicked)=\"onAddColumnClick()\">\n              </st-table-actions>\n            </div>\n          </th>\n        </tr>\n      </thead>\n\n      <!-- TABLE BODY -->\n      <tbody>\n        <!-- Virtual Scroll Rows -->\n        <ng-container *ngIf=\"mode === 'virtual'\">\n          <tr *ngFor=\"let row of visibleRows$ | async; let relativeIndex = index; trackBy: trackByRowIndex\"\n            [attr.data-row-index]=\"getAbsoluteRowIndex(relativeIndex)\">\n            <!-- Row Number Cell -->\n            <td *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-cell\" \n              [ngClass]=\"{ 'sticky-left': 'left' }\"\n              [ngStyle]=\"{\n                'width.px': 30,\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_BODY_CELL,\n                'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n              }\">\n              {{getAbsoluteRowIndex(relativeIndex) + 1}}\n            </td>\n            <ng-container *ngTemplateOutlet=\"bodyCellTemplate; context: { \n              row: row,\n              rowIndex: getAbsoluteRowIndex(relativeIndex),\n              mode: 'virtual',\n              relativeIndex: relativeIndex\n            }\"></ng-container>\n          </tr>\n        </ng-container>\n\n        <!-- Standard Rows -->\n        <ng-container *ngIf=\"mode === 'standard'\">\n          <tr *ngFor=\"let row of visibleCellGrid; let rowIndex = index\" [attr.data-row-index]=\"rowIndex\">\n            <!-- Row Number Cell -->\n            <td *ngIf=\"mergedConfig.showRowNumber\" class=\"row-number-cell\" \n              [ngClass]=\"{ 'sticky-left': 'left' }\"\n              [ngStyle]=\"{\n                'width.px': 30,\n                position: 'sticky',\n                'left.px': 0,\n                'z-index': ZIndex.STICKY_BODY_CELL,\n                'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n              }\">\n              {{rowIndex + 1}}\n            </td>\n            <ng-container *ngTemplateOutlet=\"bodyCellTemplate; context: { \n              row: row,\n              rowIndex: rowIndex,\n              mode: 'standard'\n            }\"></ng-container>\n          </tr>\n        </ng-container>\n      </tbody>\n    </table>\n  </ng-template>\n\n    <!-- ========================================== -->\n  <!-- REUSABLE BODY CELL TEMPLATE -->\n  <!-- ========================================== -->\n  <ng-template #bodyCellTemplate let-row=\"row\" let-rowIndex=\"rowIndex\" let-mode=\"mode\" let-relativeIndex=\"relativeIndex\">\n    <!-- Data Cells -->\n    <td \n      *ngFor=\"let cell of row; let colIndex = index\"\n      [ngClass]=\"{\n        'sticky-left': visibleColumns[colIndex]?.sticky === 'left',\n        'sticky-right': visibleColumns[colIndex]?.sticky === 'right',\n        'sticky-right-first': visibleColumns[colIndex]?.sticky === 'right' && visibleColumns[colIndex]?.key && isFirstStickyRight(visibleColumns[colIndex].key),\n        'align-center': visibleColumns[colIndex]?.alignment === 'center',\n        'align-right': visibleColumns[colIndex]?.alignment === 'right',\n        'cell-focused': cell.isFocused()\n      }\"\n      [ngStyle]=\"{\n        position: visibleColumns[colIndex]?.sticky ? 'sticky' : null,\n        'left.px': visibleColumns[colIndex]?.sticky === 'left' ? (visibleColumns[colIndex]?.stickyOffset || 0) : null,\n        'right.px': visibleColumns[colIndex]?.sticky === 'right' ? (visibleColumns[colIndex]?.stickyOffset || 0) : null,\n        'z-index': visibleColumns[colIndex]?.sticky ? ZIndex.STICKY_BODY_CELL : null,\n        'width.px': visibleColumns[colIndex]?.width,\n        'height.px': mode === 'virtual' ? getVirtualScrollItemSize() : null\n      }\"\n      (click)=\"isKeyboardNavigationEnabled() ? onCellClick(rowIndex, colIndex) : null\">\n      \n      <!-- Virtual Scroll Cell -->\n      <st-cell \n        *ngIf=\"mode === 'virtual'\"\n        [cell]=\"cell\" \n        [attr.tabindex]=\"cell.isFocused() ? 0 : -1\" \n        [editMode]=\"getEditModeForCells()\"\n        [tableState]=\"getActiveTableState()\"\n        [tableConfig]=\"mergedConfig\"\n        [columnIndex]=\"colIndex\"\n        (cellEdit)=\"onCellEdit($event)\" \n        (cellSave)=\"onCellSave($event)\"\n        (cellSaveAndNavigate)=\"onCellSaveAndNavigate($event)\" \n        (cellCancel)=\"onCellCancel($event)\"\n        (cellChange)=\"cellChange.emit($event)\">\n      </st-cell>\n\n      <!-- Standard Cell -->\n      <st-cell \n        *ngIf=\"mode === 'standard'\"\n        [cell]=\"cell\"  \n        [attr.tabindex]=\"cell.isFocused() ? 0 : -1\"\n        [tableState]=\"getActiveTableState()\"\n        [tableConfig]=\"mergedConfig\"\n        [columnIndex]=\"colIndex\"\n        (cellSave)=\"onCellSave($event)\"\n        (cellChange)=\"cellChange.emit($event)\">\n      </st-cell>\n    </td>\n    \n    <!-- Row Actions Cell -->\n    <td class=\"settings-column\"\n      [ngClass]=\"{\n        'has-actions': hasRowActions()\n      }\"\n      [ngStyle]=\"{\n        position: hasRowActions() ? 'sticky' : null,\n        'right.px': hasRowActions() ? 0 : null,\n        'z-index': hasRowActions() ? ZIndex.STICKY_BODY_CELL : null\n      }\">\n      <button \n        *ngIf=\"hasRowActions()\"\n        class=\"settings-trigger\"\n        (click)=\"openRowActionsDropdown($event, getRowData(rowIndex), rowIndex)\"\n        type=\"button\" \n        aria-label=\"Row actions\">\n        ⋯\n      </button>\n    </td>\n  </ng-template>\n\n<ng-template #skeletonLoader>\n  <div class=\"list-row\" *ngIf=\"(mergedConfig.tableSkeleton?.enabled | async)\">\n    <div *ngFor=\"let i of skeletonColumns\" class=\"list-content\">\n      <nile-skeleton-loader variant=\"text\" width=\"90%\" height=\"18\" *ngFor=\"let j of skeletonRows\"></nile-skeleton-loader>\n    </div>\n  </div>\n</ng-template>"]}