ag-grid-community/dist/package/main.cjs.js

Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);

// packages/ag-grid-community/src/main.ts
var main_exports = {};
__export(main_exports, {
  ALWAYS_SYNC_GLOBAL_EVENTS: () => ALWAYS_SYNC_GLOBAL_EVENTS,
  AgAbstractCellEditor: () => AgAbstractCellEditor,
  AgAbstractInputField: () => AgAbstractInputField,
  AgAbstractLabel: () => AgAbstractLabel,
  AgCheckbox: () => AgCheckbox,
  AgCheckboxSelector: () => AgCheckboxSelector,
  AgColumn: () => AgColumn,
  AgColumnGroup: () => AgColumnGroup,
  AgContentEditableField: () => AgContentEditableField,
  AgContentEditableFieldSelector: () => AgContentEditableFieldSelector,
  AgFilterButtonSelector: () => AgFilterButtonSelector,
  AgInputDateField: () => AgInputDateField,
  AgInputNumberField: () => AgInputNumberField,
  AgInputNumberFieldSelector: () => AgInputNumberFieldSelector,
  AgInputTextArea: () => AgInputTextArea,
  AgInputTextField: () => AgInputTextField,
  AgInputTextFieldSelector: () => AgInputTextFieldSelector,
  AgPickerField: () => AgPickerField,
  AgPopupComponent: () => AgPopupComponent,
  AgPromise: () => AgPromise,
  AgProvidedColumnGroup: () => AgProvidedColumnGroup,
  AgRadioButton: () => AgRadioButton,
  AgRadioButtonSelector: () => AgRadioButtonSelector,
  AgSelect: () => AgSelect,
  AgSelectSelector: () => AgSelectSelector,
  AgToggleButton: () => AgToggleButton,
  AgToggleButtonSelector: () => AgToggleButtonSelector,
  AlignedGridsModule: () => AlignedGridsModule,
  AllCommunityModule: () => AllCommunityModule,
  AutoScrollService: () => AutoScrollService,
  BaseColsService: () => BaseColsService,
  BaseComponentWrapper: () => BaseComponentWrapper,
  BaseCreator: () => BaseCreator,
  BaseGridSerializingSession: () => BaseGridSerializingSession,
  BaseSelectionService: () => BaseSelectionService,
  BeanStub: () => BeanStub,
  BigIntFilterModule: () => BigIntFilterModule,
  CellApiModule: () => CellApiModule,
  CellRangeType: () => CellRangeType,
  CellSpanModule: () => CellSpanModule,
  CellStyleModule: () => CellStyleModule,
  CheckboxEditorModule: () => CheckboxEditorModule,
  ClientSideRowModelApiModule: () => ClientSideRowModelApiModule,
  ClientSideRowModelModule: () => ClientSideRowModelModule,
  ColumnApiModule: () => ColumnApiModule,
  ColumnAutoSizeModule: () => ColumnAutoSizeModule,
  ColumnHoverModule: () => ColumnHoverModule,
  ColumnKeyCreator: () => ColumnKeyCreator,
  Component: () => Component,
  CssClassManager: () => CssClassManager,
  CsvExportModule: () => CsvExportModule,
  CustomEditorModule: () => CustomEditorModule,
  CustomFilterModule: () => CustomFilterModule,
  DateEditorModule: () => DateEditorModule,
  DateFilterModule: () => DateFilterModule,
  Direction: () => Direction,
  DragAndDropModule: () => DragAndDropModule,
  DragSourceType: () => DragSourceType,
  EventApiModule: () => EventApiModule,
  ExternalFilterModule: () => ExternalFilterModule,
  FakeHScrollComp: () => FakeHScrollComp,
  FakeVScrollComp: () => FakeVScrollComp,
  FilterButtonComp: () => FilterButtonComp,
  FilterComp: () => FilterComp,
  FilterWrapperComp: () => FilterWrapperComp,
  GROUP_AUTO_COLUMN_ID: () => GROUP_AUTO_COLUMN_ID,
  GROUP_HIERARCHY_COLUMN_ID_PREFIX: () => GROUP_HIERARCHY_COLUMN_ID_PREFIX,
  GridBodyCtrl: () => GridBodyCtrl,
  GridCoreCreator: () => GridCoreCreator,
  GridCtrl: () => GridCtrl,
  GridHeaderCtrl: () => GridHeaderCtrl,
  GridStateModule: () => GridStateModule,
  GroupInstanceIdCreator: () => GroupInstanceIdCreator,
  HeaderRowContainerCtrl: () => HeaderRowContainerCtrl,
  HighlightChangesModule: () => HighlightChangesModule,
  InfiniteRowModelModule: () => InfiniteRowModelModule,
  KeyCode: () => KeyCode,
  LargeTextEditorModule: () => LargeTextEditorModule,
  LocalEventService: () => LocalEventService,
  LocaleModule: () => LocaleModule,
  LocaleService: () => LocaleService,
  ManagedFocusFeature: () => ManagedFocusFeature,
  ModuleRegistry: () => ModuleRegistry,
  NumberEditorModule: () => NumberEditorModule,
  NumberFilterModule: () => NumberFilterModule,
  PaginationModule: () => PaginationModule,
  PinnedRowModel: () => PinnedRowModel,
  PinnedRowModule: () => PinnedRowModule,
  PositionableFeature: () => PositionableFeature,
  ProvidedFilter: () => ProvidedFilter,
  QuickFilterModule: () => QuickFilterModule,
  ROW_NUMBERS_COLUMN_ID: () => ROW_NUMBERS_COLUMN_ID,
  RefPlaceholder: () => RefPlaceholder,
  RenderApiModule: () => RenderApiModule,
  RowApiModule: () => RowApiModule,
  RowAutoHeightModule: () => RowAutoHeightModule,
  RowContainerCtrl: () => RowContainerCtrl,
  RowDragModule: () => RowDragModule,
  RowNode: () => RowNode,
  RowSelectionModule: () => RowSelectionModule,
  RowStyleModule: () => RowStyleModule,
  SELECTION_COLUMN_ID: () => SELECTION_COLUMN_ID,
  STRUCTURED_SCHEMA_FEATURES: () => STRUCTURED_SCHEMA_FEATURES,
  ScrollApiModule: () => ScrollApiModule,
  SelectEditorModule: () => SelectEditorModule,
  ServerSideTransactionResultStatus: () => ServerSideTransactionResultStatus,
  TabGuardClassNames: () => TabGuardClassNames,
  TabGuardComp: () => TabGuardComp,
  TabGuardCtrl: () => TabGuardCtrl,
  TabGuardFeature: () => TabGuardFeature,
  TextEditorModule: () => TextEditorModule,
  TextFilterModule: () => TextFilterModule,
  TooltipModule: () => TooltipModule,
  TouchListener: () => TouchListener,
  UndoRedoEditModule: () => UndoRedoEditModule,
  ValidationModule: () => ValidationModule,
  ValueCacheModule: () => ValueCacheModule,
  VanillaFrameworkOverrides: () => VanillaFrameworkOverrides,
  _AgBeanStub: () => AgBeanStub,
  _AgComponentStub: () => AgComponentStub,
  _AgContext: () => AgContext,
  _AgPositionableFeature: () => AgPositionableFeature,
  _AgTabGuardComp: () => AgTabGuardComp,
  _AgTabGuardFeature: () => AgTabGuardFeature,
  _AgTooltipComponent: () => AgTooltipComponent,
  _AgTooltipFeature: () => AgTooltipFeature,
  _BOOLEAN_MIXED_GRID_OPTIONS: () => _BOOLEAN_MIXED_GRID_OPTIONS,
  _BaseDragAndDropService: () => BaseDragAndDropService,
  _BaseDragService: () => BaseDragService,
  _BaseEnvironment: () => BaseEnvironment,
  _BaseEventService: () => BaseEventService,
  _BasePopupService: () => BasePopupService,
  _BaseRegistry: () => BaseRegistry,
  _BaseTooltipStateManager: () => BaseTooltipStateManager,
  _ChangedRowNodes: () => ChangedRowNodes,
  _ColumnFilterModule: () => ColumnFilterModule,
  _ColumnGroupModule: () => ColumnGroupModule,
  _ColumnMoveModule: () => ColumnMoveModule,
  _CsrmSsrmSharedApiModule: () => CsrmSsrmSharedApiModule,
  _DragModule: () => DragModule,
  _EditCoreModule: () => EditCoreModule,
  _EmptyBean: () => EmptyBean,
  _FOCUS_MANAGED_CLASS: () => FOCUS_MANAGED_CLASS,
  _FilterCoreModule: () => FilterCoreModule,
  _FilterValueModule: () => FilterValueModule,
  _GET_ALL_EVENTS: () => _GET_ALL_EVENTS,
  _GET_ALL_GRID_OPTIONS: () => _GET_ALL_GRID_OPTIONS,
  _GET_SHALLOW_GRID_OPTIONS: () => _GET_SHALLOW_GRID_OPTIONS,
  _HeaderComp: () => HeaderComp,
  _HorizontalResizeModule: () => HorizontalResizeModule,
  _KeyboardNavigationModule: () => KeyboardNavigationModule,
  _MONTHS: () => MONTHS,
  _PUBLIC_EVENTS: () => _PUBLIC_EVENTS,
  _PUBLIC_EVENT_HANDLERS_MAP: () => _PUBLIC_EVENT_HANDLERS_MAP,
  _PopupModule: () => PopupModule,
  _ROW_ID_PREFIX_BOTTOM_PINNED: () => ROW_ID_PREFIX_BOTTOM_PINNED,
  _ROW_ID_PREFIX_ROW_GROUP: () => ROW_ID_PREFIX_ROW_GROUP,
  _ROW_ID_PREFIX_TOP_PINNED: () => ROW_ID_PREFIX_TOP_PINNED,
  _RowModelSharedApiModule: () => RowModelSharedApiModule,
  _STOP_PROPAGATION_CALLBACKS: () => STOP_PROPAGATION_CALLBACKS,
  _SharedDragAndDropModule: () => SharedDragAndDropModule,
  _SharedExportModule: () => SharedExportModule,
  _SharedMenuModule: () => SharedMenuModule,
  _SharedRowSelectionModule: () => SharedRowSelectionModule,
  _SortModule: () => SortModule,
  _SsrmInfiniteSharedApiModule: () => SsrmInfiniteSharedApiModule,
  _addAdditionalCss: () => _addAdditionalCss,
  _addColumnDefaultAndTypes: () => _addColumnDefaultAndTypes,
  _addFocusableContainerListener: () => _addFocusableContainerListener,
  _addGridCommonParams: () => _addGridCommonParams,
  _addOrRemoveAttribute: () => _addOrRemoveAttribute,
  _anchorElementToMouseMoveEvent: () => _anchorElementToMouseMoveEvent,
  _applyColumnState: () => _applyColumnState,
  _areCellsEqual: () => _areCellsEqual,
  _areColIdsEqual: () => _areColIdsEqual,
  _areEqual: () => _areEqual,
  _areSortDefsEqual: () => _areSortDefsEqual,
  _asThemeImpl: () => _asThemeImpl,
  _attemptToRestoreCellFocus: () => _attemptToRestoreCellFocus,
  _batchCall: () => _batchCall,
  _camelCaseToHumanText: () => _camelCaseToHumanText,
  _canSkipShowingRowGroup: () => _canSkipShowingRowGroup,
  _clearElement: () => _clearElement,
  _columnsMatch: () => _columnsMatch,
  _combineAttributesAndGridOptions: () => _combineAttributesAndGridOptions,
  _consoleError: () => _consoleError,
  _convertColumnEventSourceType: () => _convertColumnEventSourceType,
  _coreThemeDefaults: () => coreDefaults,
  _createAgElement: () => _createAgElement,
  _createCellId: () => _createCellId,
  _createColumnTree: () => _createColumnTree,
  _createColumnTreeWithIds: () => _createColumnTreeWithIds,
  _createElement: () => _createElement,
  _createGlobalRowEvent: () => _createGlobalRowEvent,
  _createIcon: () => _createIcon,
  _createIconNoSpan: () => _createIconNoSpan,
  _createRowNodeSibling: () => _createRowNodeSibling,
  _createSharedTheme: () => createSharedTheme,
  _csrmFirstLeaf: () => _csrmFirstLeaf,
  _csrmReorderAllLeafs: () => _csrmReorderAllLeafs,
  _debounce: () => _debounce,
  _defaultComparator: () => _defaultComparator,
  _destroyColumnTree: () => _destroyColumnTree,
  _doOnce: () => _doOnce,
  _downloadFile: () => _downloadFile,
  _errMsg: () => _errMsg,
  _error: () => _error,
  _escapeString: () => _escapeString,
  _exists: () => _exists,
  _findEnterpriseCoreModule: () => _findEnterpriseCoreModule,
  _findFocusableElements: () => _findFocusableElements,
  _findNextFocusableElement: () => _findNextFocusableElement,
  _findTabbableParent: () => _findTabbableParent,
  _flatten: () => _flatten,
  _focusGridInnerElement: () => _focusGridInnerElement,
  _focusInto: () => _focusInto,
  _focusNextGridCoreContainer: () => _focusNextGridCoreContainer,
  _forEachChangedGroupDepthFirst: () => _forEachChangedGroupDepthFirst,
  _formatNumberCommas: () => _formatNumberCommas,
  _fuzzySuggestions: () => _fuzzySuggestions,
  _getAbsoluteHeight: () => _getAbsoluteHeight,
  _getAbsoluteRowIndex: () => _getAbsoluteRowIndex,
  _getAbsoluteWidth: () => _getAbsoluteWidth,
  _getActiveDomElement: () => _getActiveDomElement,
  _getAriaPosInSet: () => _getAriaPosInSet,
  _getCallbackForEvent: () => _getCallbackForEvent,
  _getCellByPosition: () => _getCellByPosition,
  _getCellCtrlForEventTarget: () => _getCellCtrlForEventTarget,
  _getCellPositionForEvent: () => _getCellPositionForEvent,
  _getCellRendererDetails: () => _getCellRendererDetails,
  _getCheckboxLocation: () => _getCheckboxLocation,
  _getCheckboxes: () => _getCheckboxes,
  _getClientSideRowModel: () => _getClientSideRowModel,
  _getColumnState: () => _getColumnState,
  _getColumnStateFromColDef: () => _getColumnStateFromColDef,
  _getColumnsFromTree: () => _getColumnsFromTree,
  _getDateParts: () => _getDateParts,
  _getDefaultFloatingFilterType: () => _getDefaultFloatingFilterType,
  _getDefaultSimpleFilter: () => _getDefaultSimpleFilter,
  _getDisplaySortForColumn: () => _getDisplaySortForColumn,
  _getDocument: () => _getDocument,
  _getEditorRendererDetails: () => _getEditorRendererDetails,
  _getEnableColumnSelection: () => _getEnableColumnSelection,
  _getFillHandle: () => _getFillHandle,
  _getFilterDetails: () => _getFilterDetails,
  _getFilterModel: () => _getFilterModel,
  _getFilterParamsForDataType: () => _getFilterParamsForDataType,
  _getFirstRow: () => _getFirstRow,
  _getFloatingFilterCompDetails: () => _getFloatingFilterCompDetails,
  _getFloatingFiltersHeight: () => getFloatingFiltersHeight,
  _getGlobalGridOption: () => _getGlobalGridOption,
  _getGrandTotalRow: () => _getGrandTotalRow,
  _getGridOption: () => _getGridOption,
  _getGridRegisteredModules: () => _getGridRegisteredModules,
  _getGroupAggFiltering: () => _getGroupAggFiltering,
  _getGroupSelection: () => _getGroupSelection,
  _getGroupSelectsDescendants: () => _getGroupSelectsDescendants,
  _getGroupTotalRowCallback: () => _getGroupTotalRowCallback,
  _getHeaderCheckbox: () => _getHeaderCheckbox,
  _getHeaderClassesFromColDef: () => _getHeaderClassesFromColDef,
  _getHeaderRowCount: () => getHeaderRowCount,
  _getInnerCellRendererDetails: () => _getInnerCellRendererDetails,
  _getInnerHeight: () => _getInnerHeight,
  _getInnerWidth: () => _getInnerWidth,
  _getIsRowSelectable: () => _getIsRowSelectable,
  _getLastRow: () => _getLastRow,
  _getLocaleTextFromFunc: () => _getLocaleTextFromFunc,
  _getLocaleTextFromMap: () => _getLocaleTextFromMap,
  _getLocaleTextFunc: () => _getLocaleTextFunc,
  _getMaxConcurrentDatasourceRequests: () => _getMaxConcurrentDatasourceRequests,
  _getNormalisedMousePosition: () => _getNormalisedMousePosition,
  _getPageBody: () => _getPageBody,
  _getParamType: () => getParamType,
  _getRootNode: () => _getRootNode,
  _getRowAbove: () => _getRowAbove,
  _getRowBelow: () => _getRowBelow,
  _getRowContainerClass: () => _getRowContainerClass,
  _getRowContainerOptions: () => _getRowContainerOptions,
  _getRowCtrlForEventTarget: () => _getRowCtrlForEventTarget,
  _getRowHeightAsNumber: () => _getRowHeightAsNumber,
  _getRowHeightForNode: () => _getRowHeightForNode,
  _getRowIdCallback: () => _getRowIdCallback,
  _getRowNode: () => _getRowNode,
  _getRowSelectionMode: () => _getRowSelectionMode,
  _getRowSpanContainerClass: () => _getRowSpanContainerClass,
  _getRowViewportClass: () => _getRowViewportClass,
  _getServerSideRowModel: () => _getServerSideRowModel,
  _getShouldDisplayTooltip: () => _getShouldDisplayTooltip,
  _getSortDefFromColDef: () => _getSortDefFromColDef,
  _getSortDefFromInput: () => _getSortDefFromInput,
  _getSuppressMultiRanges: () => _getSuppressMultiRanges,
  _getToolPanelClassesFromColDef: () => _getToolPanelClassesFromColDef,
  _getViewportRowModel: () => _getViewportRowModel,
  _getWindow: () => _getWindow,
  _interpretAsRightClick: () => _interpretAsRightClick,
  _isAnimateRows: () => _isAnimateRows,
  _isBrowserFirefox: () => _isBrowserFirefox,
  _isBrowserSafari: () => _isBrowserSafari,
  _isCellSelectionEnabled: () => _isCellSelectionEnabled,
  _isClientSideRowModel: () => _isClientSideRowModel,
  _isColumnMenuAnchoringEnabled: () => _isColumnMenuAnchoringEnabled,
  _isColumnsSortingCoupledToGroup: () => _isColumnsSortingCoupledToGroup,
  _isComponent: () => _isComponent,
  _isDomLayout: () => _isDomLayout,
  _isElementInEventPath: () => _isElementInEventPath,
  _isElementOverflowingCallback: () => _isElementOverflowingCallback,
  _isEventFromPrintableCharacter: () => _isEventFromPrintableCharacter,
  _isExpressionString: () => _isExpressionString,
  _isFocusableFormField: () => _isFocusableFormField,
  _isFullWidthGroupRow: () => _isFullWidthGroupRow,
  _isGetRowHeightFunction: () => _isGetRowHeightFunction,
  _isGroupHideColumnsUntilExpanded: () => _isGroupHideColumnsUntilExpanded,
  _isGroupMultiAutoColumn: () => _isGroupMultiAutoColumn,
  _isGroupRowsSticky: () => _isGroupRowsSticky,
  _isGroupUseEntireRow: () => _isGroupUseEntireRow,
  _isIOSUserAgent: () => _isIOSUserAgent,
  _isKeyboardMode: () => _isKeyboardMode,
  _isLegacyMenuEnabled: () => _isLegacyMenuEnabled,
  _isMultiRowSelection: () => _isMultiRowSelection,
  _isNodeOrElement: () => _isNodeOrElement,
  _isNothingFocused: () => _isNothingFocused,
  _isPromise: () => _isPromise,
  _isRowBefore: () => _isRowBefore,
  _isRowNumbers: () => _isRowNumbers,
  _isRowSelection: () => _isRowSelection,
  _isSameRow: () => _isSameRow,
  _isServerSideRowModel: () => _isServerSideRowModel,
  _isSetFilterByDefault: () => _isSetFilterByDefault,
  _isShowTooltipWhenTruncated: () => _isShowTooltipWhenTruncated,
  _isSortDirectionValid: () => _isSortDirectionValid,
  _isSortTypeValid: () => _isSortTypeValid,
  _isStopPropagationForAgGrid: () => _isStopPropagationForAgGrid,
  _isUseApplyButton: () => _isUseApplyButton,
  _isUsingNewCellSelectionAPI: () => _isUsingNewCellSelectionAPI,
  _isUsingNewRowSelectionAPI: () => _isUsingNewRowSelectionAPI,
  _isVisible: () => _isVisible,
  _jsonEquals: () => _jsonEquals,
  _last: () => _last,
  _loadTemplate: () => _loadTemplate,
  _logPreInitWarn: () => _logPreInitWarn,
  _makeNull: () => _makeNull,
  _mergeDeep: () => _mergeDeep,
  _missing: () => _missing,
  _normalizeSortDirection: () => _normalizeSortDirection,
  _normalizeSortType: () => _normalizeSortType,
  _observeResize: () => _observeResize,
  _paramToVariableName: () => paramToVariableName,
  _paramValueToCss: () => paramValueToCss,
  _parseBigIntOrNull: () => _parseBigIntOrNull,
  _parseDateTimeFromString: () => _parseDateTimeFromString,
  _placeCaretAtEnd: () => _placeCaretAtEnd,
  _preInitErrMsg: () => _preInitErrMsg,
  _prevOrNextDisplayedRow: () => _prevOrNextDisplayedRow,
  _processOnChange: () => _processOnChange,
  _radioCssClass: () => _radioCssClass,
  _refreshFilterUi: () => _refreshFilterUi,
  _refreshHandlerAndUi: () => _refreshHandlerAndUi,
  _registerModule: () => _registerModule,
  _removeAllFromArray: () => _removeAllFromArray,
  _removeAriaExpanded: () => _removeAriaExpanded,
  _removeAriaSort: () => _removeAriaSort,
  _removeFromArray: () => _removeFromArray,
  _removeFromParent: () => _removeFromParent,
  _requestAnimationFrame: () => _requestAnimationFrame,
  _resetColumnState: () => _resetColumnState,
  _selectAllCells: () => _selectAllCells,
  _serialiseDate: () => _serialiseDate,
  _setAriaActiveDescendant: () => _setAriaActiveDescendant,
  _setAriaChecked: () => _setAriaChecked,
  _setAriaColCount: () => _setAriaColCount,
  _setAriaColIndex: () => _setAriaColIndex,
  _setAriaColSpan: () => _setAriaColSpan,
  _setAriaControls: () => _setAriaControls,
  _setAriaControlsAndLabel: () => _setAriaControlsAndLabel,
  _setAriaDescribedBy: () => _setAriaDescribedBy,
  _setAriaDisabled: () => _setAriaDisabled,
  _setAriaExpanded: () => _setAriaExpanded,
  _setAriaHasPopup: () => _setAriaHasPopup,
  _setAriaHidden: () => _setAriaHidden,
  _setAriaInvalid: () => _setAriaInvalid,
  _setAriaLabel: () => _setAriaLabel,
  _setAriaLabelledBy: () => _setAriaLabelledBy,
  _setAriaLevel: () => _setAriaLevel,
  _setAriaOrientation: () => _setAriaOrientation,
  _setAriaPosInSet: () => _setAriaPosInSet,
  _setAriaRole: () => _setAriaRole,
  _setAriaRowCount: () => _setAriaRowCount,
  _setAriaRowIndex: () => _setAriaRowIndex,
  _setAriaSelected: () => _setAriaSelected,
  _setAriaSetSize: () => _setAriaSetSize,
  _setAriaSort: () => _setAriaSort,
  _setColMenuVisible: () => _setColMenuVisible,
  _setDisabled: () => _setDisabled,
  _setDisplayed: () => _setDisplayed,
  _setFixedWidth: () => _setFixedWidth,
  _setScrollLeft: () => _setScrollLeft,
  _setUmd: () => _setUmd,
  _setVisible: () => _setVisible,
  _sharedThemeDefaults: () => sharedDefaults,
  _shouldUpdateColVisibilityAfterGroup: () => _shouldUpdateColVisibilityAfterGroup,
  _skipFocusableContainerListenerForAgGrid: () => _skipFocusableContainerListenerForAgGrid,
  _stopPropagationForAgGrid: () => _stopPropagationForAgGrid,
  _suppressCellMouseEvent: () => _suppressCellMouseEvent,
  _themeAlpineParams: () => themeAlpineParams,
  _themeBalhamParams: () => themeBalhamParams,
  _themeMaterialParams: () => themeMaterialParams,
  _themeQuartzParams: () => themeQuartzParams,
  _toString: () => _toString,
  _toStringOrNull: () => _toStringOrNull,
  _translate: () => _translate,
  _translateForFilter: () => translateForFilter,
  _unwrapUserComp: () => _unwrapUserComp,
  _updateColsMap: () => _updateColsMap,
  _updateColumnState: () => _updateColumnState,
  _updateFilterModel: () => _updateFilterModel,
  _waitUntil: () => _waitUntil,
  _warn: () => _warn,
  _warnOnce: () => _warnOnce,
  agTestIdFor: () => agTestIdFor,
  buttonStyleAlpine: () => buttonStyleAlpine,
  buttonStyleBalham: () => buttonStyleBalham,
  buttonStyleBase: () => buttonStyleBase,
  buttonStyleQuartz: () => buttonStyleQuartz,
  checkboxStyleDefault: () => checkboxStyleDefault,
  colorSchemeDark: () => colorSchemeDark,
  colorSchemeDarkBlue: () => colorSchemeDarkBlue,
  colorSchemeDarkWarm: () => colorSchemeDarkWarm,
  colorSchemeLight: () => colorSchemeLight,
  colorSchemeLightCold: () => colorSchemeLightCold,
  colorSchemeLightWarm: () => colorSchemeLightWarm,
  colorSchemeVariable: () => colorSchemeVariable,
  columnDropStyleBordered: () => columnDropStyleBordered,
  columnDropStylePlain: () => columnDropStylePlain,
  convertColumnGroupState: () => convertColumnGroupState,
  convertColumnState: () => convertColumnState,
  createGrid: () => createGrid,
  createPart: () => createPart,
  createTheme: () => createTheme,
  getGridApi: () => getGridApi,
  getGridElement: () => getGridElement,
  iconOverrides: () => iconOverrides,
  iconSetAlpine: () => iconSetAlpine,
  iconSetBalham: () => iconSetBalham,
  iconSetMaterial: () => iconSetMaterial,
  iconSetQuartz: () => iconSetQuartz,
  iconSetQuartzBold: () => iconSetQuartzBold,
  iconSetQuartzLight: () => iconSetQuartzLight,
  iconSetQuartzRegular: () => iconSetQuartzRegular,
  inputStyleBase: () => inputStyleBase,
  inputStyleBordered: () => inputStyleBordered,
  inputStyleUnderlined: () => inputStyleUnderlined,
  isColumn: () => isColumn,
  isColumnGroup: () => isColumnGroup,
  isColumnGroupAutoCol: () => isColumnGroupAutoCol,
  isColumnSelectionCol: () => isColumnSelectionCol,
  isCombinedFilterModel: () => isCombinedFilterModel,
  isProvidedColumnGroup: () => isProvidedColumnGroup,
  isRowNumberCol: () => isRowNumberCol,
  isSpecialCol: () => isSpecialCol,
  onRowHeightChanged: () => onRowHeightChanged,
  provideGlobalGridOptions: () => provideGlobalGridOptions,
  resetRowHeights: () => resetRowHeights,
  setupAgTestIds: () => setupAgTestIds,
  styleMaterial: () => styleMaterial,
  tabStyleAlpine: () => tabStyleAlpine,
  tabStyleBase: () => tabStyleBase,
  tabStyleMaterial: () => tabStyleMaterial,
  tabStyleQuartz: () => tabStyleQuartz,
  tabStyleRolodex: () => tabStyleRolodex,
  themeAlpine: () => themeAlpine,
  themeBalham: () => themeBalham,
  themeMaterial: () => themeMaterial,
  themeQuartz: () => themeQuartz,
  wrapAgTestIdFor: () => wrapAgTestIdFor
});
module.exports = __toCommonJS(main_exports);

// packages/ag-grid-community/src/agStack/utils/array.ts
function _last(arr) {
  if (!arr?.length) {
    return;
  }
  return arr[arr.length - 1];
}
function _areEqual(a, b, comparator) {
  if (a === b) {
    return true;
  }
  if (!a || !b) {
    return a == null && b == null;
  }
  const len = a.length;
  if (len !== b.length) {
    return false;
  }
  for (let i = 0; i < len; i++) {
    if (a[i] !== b[i] && !comparator?.(a[i], b[i])) {
      return false;
    }
  }
  return true;
}
function _forAll(array, callback) {
  if (!array) {
    return;
  }
  for (const value of array) {
    if (callback(value)) {
      return true;
    }
  }
}
function _removeFromArray(array, object) {
  const index = array.indexOf(object);
  if (index >= 0) {
    array.splice(index, 1);
  }
}
function _removeAllFromArray(array, elementsToRemove) {
  let i = 0;
  let j = 0;
  for (; i < array.length; i++) {
    if (!elementsToRemove.includes(array[i])) {
      array[j] = array[i];
      j++;
    }
  }
  while (j < array.length) {
    array.pop();
  }
}
function _moveInArray(array, objectsToMove, toIndex) {
  for (let i = 0; i < objectsToMove.length; i++) {
    _removeFromArray(array, objectsToMove[i]);
  }
  for (let i = objectsToMove.length - 1; i >= 0; i--) {
    array.splice(toIndex, 0, objectsToMove[i]);
  }
}
function _flatten(arrays) {
  return [].concat.apply([], arrays);
}

// packages/ag-grid-community/src/agStack/utils/generic.ts
var _makeNull = (value) => {
  if (value == null || value === "") {
    return null;
  }
  return value;
};
function _exists(value) {
  return value != null && value !== "";
}
function _missing(value) {
  return !_exists(value);
}
var _toStringOrNull = (value) => {
  return value != null && typeof value.toString === "function" ? value.toString() : null;
};
var _jsonEquals = (val1, val2) => {
  const val1Json = val1 ? JSON.stringify(val1) : null;
  const val2Json = val2 ? JSON.stringify(val2) : null;
  return val1Json === val2Json;
};
var _defaultComparator = (valueA, valueB, accentedCompare = false) => {
  if (valueA == null) {
    return valueB == null ? 0 : -1;
  }
  if (valueB == null) {
    return 1;
  }
  if (typeof valueA === "object" && valueA.toNumber) {
    valueA = valueA.toNumber();
  }
  if (typeof valueB === "object" && valueB.toNumber) {
    valueB = valueB.toNumber();
  }
  if (!accentedCompare || typeof valueA !== "string") {
    if (valueA > valueB) {
      return 1;
    }
    if (valueA < valueB) {
      return -1;
    }
    return 0;
  }
  return valueA.localeCompare(valueB);
};

// packages/ag-grid-community/src/agStack/events/localEventService.ts
var LocalEventService = class {
  constructor() {
    this.allSyncListeners = /* @__PURE__ */ new Map();
    this.allAsyncListeners = /* @__PURE__ */ new Map();
    this.globalSyncListeners = /* @__PURE__ */ new Set();
    this.globalAsyncListeners = /* @__PURE__ */ new Set();
    this.asyncFunctionsQueue = [];
    this.scheduled = false;
    // using an object performs better than a Set for the number of different events we have
    this.firedEvents = {};
  }
  setFrameworkOverrides(frameworkOverrides) {
    this.frameworkOverrides = frameworkOverrides;
  }
  getListeners(eventType, async, autoCreateListenerCollection) {
    const listenerMap = async ? this.allAsyncListeners : this.allSyncListeners;
    let listeners = listenerMap.get(eventType);
    if (!listeners && autoCreateListenerCollection) {
      listeners = /* @__PURE__ */ new Set();
      listenerMap.set(eventType, listeners);
    }
    return listeners;
  }
  noRegisteredListenersExist() {
    return this.allSyncListeners.size === 0 && this.allAsyncListeners.size === 0 && this.globalSyncListeners.size === 0 && this.globalAsyncListeners.size === 0;
  }
  addEventListener(eventType, listener, async = false) {
    this.getListeners(eventType, async, true).add(listener);
  }
  removeEventListener(eventType, listener, async = false) {
    const listeners = this.getListeners(eventType, async, false);
    if (!listeners) {
      return;
    }
    listeners.delete(listener);
    if (listeners.size === 0) {
      (async ? this.allAsyncListeners : this.allSyncListeners).delete(eventType);
    }
  }
  addGlobalListener(listener, async = false) {
    this.getGlobalListeners(async).add(listener);
  }
  removeGlobalListener(listener, async = false) {
    this.getGlobalListeners(async).delete(listener);
  }
  dispatchEvent(event) {
    this.dispatchToListeners(event, true);
    this.dispatchToListeners(event, false);
    this.firedEvents[event.type] = true;
  }
  dispatchEventOnce(event) {
    if (!this.firedEvents[event.type]) {
      this.dispatchEvent(event);
    }
  }
  dispatchToListeners(event, async) {
    const eventType = event.type;
    if (async && "event" in event) {
      const browserEvent = event.event;
      if (browserEvent instanceof Event) {
        event.eventPath = browserEvent.composedPath();
      }
    }
    const { frameworkOverrides } = this;
    const runCallback = (func) => {
      const callback = frameworkOverrides ? () => frameworkOverrides.wrapIncoming(func) : func;
      if (async) {
        this.dispatchAsync(callback);
      } else {
        callback();
      }
    };
    const originalListeners = this.getListeners(eventType, async, false);
    if ((originalListeners?.size ?? 0) > 0) {
      const listeners = new Set(originalListeners);
      for (const listener of listeners) {
        if (!originalListeners?.has(listener)) {
          continue;
        }
        runCallback(() => listener(event));
      }
    }
    const globalListenersSrc = this.getGlobalListeners(async);
    if (globalListenersSrc.size > 0) {
      const globalListeners = new Set(globalListenersSrc);
      for (const listener of globalListeners) {
        runCallback(() => listener(eventType, event));
      }
    }
  }
  getGlobalListeners(async) {
    return async ? this.globalAsyncListeners : this.globalSyncListeners;
  }
  // this gets called inside the grid's thread, for each event that it
  // wants to set async. the grid then batches the events into one setTimeout()
  // because setTimeout() is an expensive operation. ideally we would have
  // each event in it's own setTimeout(), but we batch for performance.
  dispatchAsync(func) {
    this.asyncFunctionsQueue.push(func);
    if (!this.scheduled) {
      const flush = () => {
        window.setTimeout(this.flushAsyncQueue.bind(this), 0);
      };
      const frameworkOverrides = this.frameworkOverrides;
      if (frameworkOverrides) {
        frameworkOverrides.wrapIncoming(flush);
      } else {
        flush();
      }
      this.scheduled = true;
    }
  }
  // this happens in the next VM turn only, and empties the queue of events
  flushAsyncQueue() {
    this.scheduled = false;
    const queueCopy = this.asyncFunctionsQueue.slice();
    this.asyncFunctionsQueue = [];
    for (const func of queueCopy) {
      func();
    }
  }
};

// packages/ag-grid-community/src/agStack/utils/string.ts
var reUnescapedHtml = /[&<>"']/g;
var HTML_ESCAPES = {
  "&": "&amp;",
  "<": "&lt;",
  ">": "&gt;",
  '"': "&quot;",
  "'": "&#39;"
};
function _toString(toEscape) {
  return toEscape?.toString().toString() ?? null;
}
function _escapeString(toEscape) {
  return _toString(toEscape)?.replace(reUnescapedHtml, (chr) => HTML_ESCAPES[chr]) ?? null;
}
function _isExpressionString(value) {
  return typeof value === "string" && value.startsWith("=") && value.length > 1;
}
function _camelCaseToHumanText(camelCase) {
  if (!camelCase || camelCase == null) {
    return null;
  }
  const rex = /([a-z])([A-Z])/g;
  const rexCaps = /([A-Z]+)([A-Z])([a-z])/g;
  const words = camelCase.replace(rex, "$1 $2").replace(rexCaps, "$1 $2$3").replace(/\./g, " ").split(" ");
  return words.map((word) => word.substring(0, 1).toUpperCase() + (word.length > 1 ? word.substring(1, word.length) : "")).join(" ");
}

// packages/ag-grid-community/src/agStack/utils/document.ts
function _getRootNode(beans) {
  return beans.eRootDiv.getRootNode();
}
function _getActiveDomElement(beans) {
  return _getRootNode(beans).activeElement;
}
function _getDocument(beans) {
  const { gos, eRootDiv } = beans;
  let result = null;
  const optionsGetDocument = gos.get("getDocument");
  if (optionsGetDocument && _exists(optionsGetDocument)) {
    result = optionsGetDocument();
  } else if (eRootDiv) {
    result = eRootDiv.ownerDocument;
  }
  if (result && _exists(result)) {
    return result;
  }
  return document;
}
function _isNothingFocused(beans) {
  const activeEl = _getActiveDomElement(beans);
  return activeEl === null || activeEl === _getDocument(beans).body;
}
function _getWindow(beans) {
  const eDocument = _getDocument(beans);
  return eDocument.defaultView || window;
}
function _getPageBody(beans) {
  let rootNode = null;
  let targetEl = null;
  try {
    rootNode = _getDocument(beans).fullscreenElement;
  } catch (e) {
  } finally {
    if (!rootNode) {
      rootNode = _getRootNode(beans);
    }
    const body = rootNode.querySelector("body");
    if (body) {
      targetEl = body;
    } else if (rootNode instanceof ShadowRoot) {
      targetEl = rootNode;
    } else if (rootNode instanceof Document) {
      targetEl = rootNode?.documentElement;
    } else {
      targetEl = rootNode;
    }
  }
  return targetEl;
}
function _getBodyWidth(beans) {
  const body = _getPageBody(beans);
  return body?.clientWidth ?? (window.innerWidth || -1);
}
function _getBodyHeight(beans) {
  const body = _getPageBody(beans);
  return body?.clientHeight ?? (window.innerHeight || -1);
}

// packages/ag-grid-community/src/agStack/utils/aria.ts
function _toggleAriaAttribute(element, attribute, value) {
  if (value == null || typeof value === "string" && value == "") {
    _removeAriaAttribute(element, attribute);
  } else {
    _setAriaAttribute(element, attribute, value);
  }
}
function _setAriaAttribute(element, attribute, value) {
  element.setAttribute(_ariaAttributeName(attribute), value.toString());
}
function _removeAriaAttribute(element, attribute) {
  element.removeAttribute(_ariaAttributeName(attribute));
}
function _ariaAttributeName(attribute) {
  return `aria-${attribute}`;
}
function _setAriaRole(element, role) {
  if (role) {
    element.setAttribute("role", role);
  } else {
    element.removeAttribute("role");
  }
}
function _getAriaSortState(directionOrDef) {
  const direction = directionOrDef?.direction;
  if (direction === "asc") {
    return "ascending";
  } else if (direction === "desc") {
    return "descending";
  } else if (direction === "mixed") {
    return "other";
  }
  return "none";
}
function _getAriaPosInSet(element) {
  return Number.parseInt(element.getAttribute("aria-posinset"), 10);
}
function _getAriaLabel(element) {
  return element.getAttribute("aria-label");
}
function _setAriaLabel(element, label) {
  _toggleAriaAttribute(element, "label", label);
}
function _setAriaLabelledBy(element, labelledBy) {
  _toggleAriaAttribute(element, "labelledby", labelledBy);
}
function _setAriaDescribedBy(element, describedby) {
  _toggleAriaAttribute(element, "describedby", describedby);
}
function _setAriaLive(element, live) {
  _toggleAriaAttribute(element, "live", live);
}
function _setAriaAtomic(element, atomic) {
  _toggleAriaAttribute(element, "atomic", atomic);
}
function _setAriaRelevant(element, relevant) {
  _toggleAriaAttribute(element, "relevant", relevant);
}
function _setAriaInvalid(element, invalid) {
  _toggleAriaAttribute(element, "invalid", invalid);
}
function _setAriaLevel(element, level) {
  _toggleAriaAttribute(element, "level", level);
}
function _setAriaDisabled(element, disabled) {
  _toggleAriaAttribute(element, "disabled", disabled);
}
function _setAriaHidden(element, hidden) {
  _toggleAriaAttribute(element, "hidden", hidden);
}
function _setAriaActiveDescendant(element, descendantId) {
  _toggleAriaAttribute(element, "activedescendant", descendantId);
}
function _setAriaExpanded(element, expanded) {
  _setAriaAttribute(element, "expanded", expanded);
}
function _removeAriaExpanded(element) {
  _removeAriaAttribute(element, "expanded");
}
function _setAriaSetSize(element, setsize) {
  _setAriaAttribute(element, "setsize", setsize);
}
function _setAriaPosInSet(element, position) {
  _setAriaAttribute(element, "posinset", position);
}
function _setAriaMultiSelectable(element, multiSelectable) {
  _setAriaAttribute(element, "multiselectable", multiSelectable);
}
function _setAriaRowCount(element, rowCount) {
  _setAriaAttribute(element, "rowcount", rowCount);
}
function _setAriaRowIndex(element, rowIndex) {
  _setAriaAttribute(element, "rowindex", rowIndex);
}
function _setAriaRowSpan(element, spanCount) {
  _setAriaAttribute(element, "rowspan", spanCount);
}
function _setAriaColCount(element, colCount) {
  _setAriaAttribute(element, "colcount", colCount);
}
function _setAriaColIndex(element, colIndex) {
  _setAriaAttribute(element, "colindex", colIndex);
}
function _setAriaColSpan(element, colSpan) {
  _setAriaAttribute(element, "colspan", colSpan);
}
function _setAriaSort(element, sort) {
  _setAriaAttribute(element, "sort", sort);
}
function _removeAriaSort(element) {
  _removeAriaAttribute(element, "sort");
}
function _setAriaSelected(element, selected) {
  _toggleAriaAttribute(element, "selected", selected);
}
function _setAriaChecked(element, checked) {
  _setAriaAttribute(element, "checked", checked === void 0 ? "mixed" : checked);
}
function _setAriaControls(controllerElement, controlledId) {
  _toggleAriaAttribute(controllerElement, "controls", controlledId);
}
function _setAriaControlsAndLabel(controllerElement, controlledElement) {
  _setAriaControls(controllerElement, controlledElement.id);
  _setAriaLabelledBy(controlledElement, controllerElement.id);
}
function _setAriaOwns(ownerElement, ownedId) {
  _toggleAriaAttribute(ownerElement, "owns", ownedId);
}
function _setAriaHasPopup(element, hasPopup) {
  _toggleAriaAttribute(element, "haspopup", hasPopup === false ? null : hasPopup);
}
function _getAriaCheckboxStateName(translate, state) {
  return state === void 0 ? translate("ariaIndeterminate", "indeterminate") : state === true ? translate("ariaChecked", "checked") : translate("ariaUnchecked", "unchecked");
}
function _setAriaOrientation(element, orientation) {
  if (orientation) {
    _setAriaAttribute(element, "orientation", orientation);
  } else {
    _removeAriaAttribute(element, "orientation");
  }
}

// packages/ag-grid-community/src/agStack/utils/dom.ts
function _radioCssClass(element, elementClass, otherElementClass) {
  const parent = element.parentElement;
  let sibling = parent && parent.firstChild;
  while (sibling) {
    if (elementClass) {
      sibling.classList.toggle(elementClass, sibling === element);
    }
    if (otherElementClass) {
      sibling.classList.toggle(otherElementClass, sibling !== element);
    }
    sibling = sibling.nextSibling;
  }
}
var FOCUSABLE_SELECTOR = "[tabindex], input, select, button, textarea, [href]";
var FOCUSABLE_EXCLUDE = "[disabled], .ag-disabled:not(.ag-button), .ag-disabled *";
function _isFocusableFormField(element) {
  if (!element) {
    return false;
  }
  const isFocusable = element.matches("input, select, button, textarea");
  if (!isFocusable) {
    return false;
  }
  const isNotFocusable = element.matches(FOCUSABLE_EXCLUDE);
  if (!isNotFocusable) {
    return false;
  }
  return _isVisible(element);
}
function _setDisplayed(element, displayed, options = {}) {
  const { skipAriaHidden } = options;
  element.classList.toggle("ag-hidden", !displayed);
  if (!skipAriaHidden) {
    _setAriaHidden(element, !displayed);
  }
}
function _setVisible(element, visible, options = {}) {
  const { skipAriaHidden } = options;
  element.classList.toggle("ag-invisible", !visible);
  if (!skipAriaHidden) {
    _setAriaHidden(element, !visible);
  }
}
function _setDisabled(element, disabled) {
  const attributeName = "disabled";
  const addOrRemoveDisabledAttribute = disabled ? (e) => e.setAttribute(attributeName, "") : (e) => e.removeAttribute(attributeName);
  addOrRemoveDisabledAttribute(element);
  const inputs = element.querySelectorAll("input") ?? [];
  for (const input of inputs) {
    addOrRemoveDisabledAttribute(input);
  }
}
function _isElementChildOfClass(element, cls, maxNest) {
  let counter = 0;
  while (element) {
    if (element.classList.contains(cls)) {
      return true;
    }
    element = element.parentElement;
    if (typeof maxNest == "number") {
      if (++counter > maxNest) {
        break;
      }
    } else if (element === maxNest) {
      break;
    }
  }
  return false;
}
function _getElementSize(el) {
  const {
    height,
    width,
    borderTopWidth,
    borderRightWidth,
    borderBottomWidth,
    borderLeftWidth,
    paddingTop,
    paddingRight,
    paddingBottom,
    paddingLeft,
    marginTop,
    marginRight,
    marginBottom,
    marginLeft,
    boxSizing
  } = window.getComputedStyle(el);
  const pf = Number.parseFloat;
  return {
    height: pf(height || "0"),
    width: pf(width || "0"),
    borderTopWidth: pf(borderTopWidth || "0"),
    borderRightWidth: pf(borderRightWidth || "0"),
    borderBottomWidth: pf(borderBottomWidth || "0"),
    borderLeftWidth: pf(borderLeftWidth || "0"),
    paddingTop: pf(paddingTop || "0"),
    paddingRight: pf(paddingRight || "0"),
    paddingBottom: pf(paddingBottom || "0"),
    paddingLeft: pf(paddingLeft || "0"),
    marginTop: pf(marginTop || "0"),
    marginRight: pf(marginRight || "0"),
    marginBottom: pf(marginBottom || "0"),
    marginLeft: pf(marginLeft || "0"),
    boxSizing
  };
}
function _getInnerHeight(el) {
  const size = _getElementSize(el);
  if (size.boxSizing === "border-box") {
    return size.height - size.paddingTop - size.paddingBottom - size.borderTopWidth - size.borderBottomWidth;
  }
  return size.height;
}
function _getInnerWidth(el) {
  const size = _getElementSize(el);
  if (size.boxSizing === "border-box") {
    return size.width - size.paddingLeft - size.paddingRight - size.borderLeftWidth - size.borderRightWidth;
  }
  return size.width;
}
function _getAbsoluteHeight(el) {
  const { height, marginBottom, marginTop } = _getElementSize(el);
  return Math.floor(height + marginBottom + marginTop);
}
function _getAbsoluteWidth(el) {
  const { width, marginLeft, marginRight } = _getElementSize(el);
  return Math.floor(width + marginLeft + marginRight);
}
function _getElementRectWithOffset(el) {
  const offsetElementRect = el.getBoundingClientRect();
  const { borderTopWidth, borderLeftWidth, borderRightWidth, borderBottomWidth } = _getElementSize(el);
  return {
    top: offsetElementRect.top + (borderTopWidth || 0),
    left: offsetElementRect.left + (borderLeftWidth || 0),
    right: offsetElementRect.right + (borderRightWidth || 0),
    bottom: offsetElementRect.bottom + (borderBottomWidth || 0)
  };
}
function _getScrollLeft(element, rtl) {
  let scrollLeft = element.scrollLeft;
  if (rtl) {
    scrollLeft = Math.abs(scrollLeft);
  }
  return scrollLeft;
}
function _setScrollLeft(element, value, rtl) {
  if (rtl) {
    value *= -1;
  }
  element.scrollLeft = value;
}
function _clearElement(el) {
  while (el?.firstChild) {
    el.firstChild.remove();
  }
}
function _removeFromParent(node) {
  if (node?.parentNode) {
    node.remove();
  }
}
function _isInDOM(element) {
  return !!element.offsetParent;
}
function _isVisible(element) {
  if (element.checkVisibility) {
    return element.checkVisibility({ checkVisibilityCSS: true });
  }
  const isHidden = !_isInDOM(element) || window.getComputedStyle(element).visibility !== "visible";
  return !isHidden;
}
function _loadTemplate(template) {
  const tempDiv = document.createElement("div");
  tempDiv.innerHTML = (template || "").trim();
  return tempDiv.firstChild;
}
function _ensureDomOrder(eContainer, eChild, eChildBefore) {
  if (eChildBefore && eChildBefore.nextSibling === eChild) {
    return;
  }
  if (!eContainer.firstChild) {
    eContainer.appendChild(eChild);
  } else if (eChildBefore) {
    if (eChildBefore.nextSibling) {
      eContainer.insertBefore(eChild, eChildBefore.nextSibling);
    } else {
      eContainer.appendChild(eChild);
    }
  } else if (eContainer.firstChild && eContainer.firstChild !== eChild) {
    eContainer.prepend(eChild);
  }
}
function _setDomChildOrder(eContainer, orderedChildren) {
  for (let i = 0; i < orderedChildren.length; i++) {
    const correctCellAtIndex = orderedChildren[i];
    const actualCellAtIndex = eContainer.children[i];
    if (actualCellAtIndex !== correctCellAtIndex) {
      eContainer.insertBefore(correctCellAtIndex, actualCellAtIndex);
    }
  }
}
function _camelCaseToHyphenated(camelCase) {
  return camelCase.replace(/[A-Z]/g, (s) => `-${s.toLocaleLowerCase()}`);
}
function _addStylesToElement(eElement, styles) {
  if (!styles) {
    return;
  }
  for (const key of Object.keys(styles)) {
    const value = styles[key];
    if (!key?.length || value == null) {
      continue;
    }
    const parsedKey = _camelCaseToHyphenated(key);
    const valueAsString = value.toString();
    const parsedValue = valueAsString.replace(/\s*!important/g, "");
    const priority = parsedValue.length != valueAsString.length ? "important" : void 0;
    eElement.style.setProperty(parsedKey, parsedValue, priority);
  }
}
function _isElementOverflowingCallback(getElement2) {
  return () => {
    const element = getElement2();
    if (!element) {
      return true;
    }
    return _isHorizontalScrollShowing(element) || _isVerticalScrollShowing(element);
  };
}
function _isHorizontalScrollShowing(element) {
  return element.clientWidth < element.scrollWidth;
}
function _isVerticalScrollShowing(element) {
  return element.clientHeight < element.scrollHeight;
}
function _setElementWidth(element, width) {
  if (width === "flex") {
    element.style.removeProperty("width");
    element.style.removeProperty("minWidth");
    element.style.removeProperty("maxWidth");
    element.style.flex = "1 1 auto";
  } else {
    _setFixedWidth(element, width);
  }
}
function _setFixedWidth(element, width) {
  width = _formatSize(width);
  element.style.width = width;
  element.style.maxWidth = width;
  element.style.minWidth = width;
}
function _setFixedHeight(element, height) {
  height = _formatSize(height);
  element.style.height = height;
  element.style.maxHeight = height;
  element.style.minHeight = height;
}
function _formatSize(size) {
  return typeof size === "number" ? `${size}px` : size;
}
function _isNodeOrElement(o) {
  return o instanceof Node || o instanceof HTMLElement;
}
function _addOrRemoveAttribute(element, name, value) {
  if (value == null || value === "") {
    element.removeAttribute(name);
  } else {
    element.setAttribute(name, value.toString());
  }
}
function _placeCaretAtEnd(beans, contentElement) {
  if (!contentElement.isContentEditable) {
    return;
  }
  const selection = _getWindow(beans).getSelection();
  if (!selection) {
    return;
  }
  const range = _getDocument(beans).createRange();
  range.selectNodeContents(contentElement);
  range.collapse(false);
  selection.removeAllRanges();
  selection.addRange(range);
}
function _observeResize(beans, element, callback) {
  const win = _getWindow(beans);
  const ResizeObserverImpl = win.ResizeObserver;
  const resizeObserver = ResizeObserverImpl ? new ResizeObserverImpl(callback) : null;
  resizeObserver?.observe(element);
  return () => resizeObserver?.disconnect();
}
function _requestAnimationFrame(beans, callback) {
  const win = _getWindow(beans);
  if (win.requestAnimationFrame) {
    win.requestAnimationFrame(callback);
  } else if (win.webkitRequestAnimationFrame) {
    win.webkitRequestAnimationFrame(callback);
  } else {
    win.setTimeout(callback, 0);
  }
}
var DataRefAttribute = "data-ref";
var whitespaceNode;
function getWhitespaceNode() {
  whitespaceNode ?? (whitespaceNode = document.createTextNode(" "));
  return whitespaceNode.cloneNode();
}
function _createAgElement(params) {
  const { attrs, children, cls, ref, role, tag } = params;
  const element = document.createElement(tag);
  if (cls) {
    element.className = cls;
  }
  if (ref) {
    element.setAttribute(DataRefAttribute, ref);
  }
  if (role) {
    element.setAttribute("role", role);
  }
  if (attrs) {
    for (const key of Object.keys(attrs)) {
      element.setAttribute(key, attrs[key]);
    }
  }
  if (children) {
    if (typeof children === "string") {
      element.textContent = children;
    } else {
      let addFirstWhitespace = true;
      for (const child of children) {
        if (child) {
          if (typeof child === "string") {
            element.appendChild(document.createTextNode(child));
            addFirstWhitespace = false;
          } else if (typeof child === "function") {
            element.appendChild(child());
          } else {
            if (addFirstWhitespace) {
              element.appendChild(getWhitespaceNode());
              addFirstWhitespace = false;
            }
            element.append(_createAgElement(child));
            element.appendChild(getWhitespaceNode());
          }
        }
      }
    }
  }
  return element;
}

// packages/ag-grid-community/src/agStack/utils/event.ts
var PASSIVE_EVENTS = ["touchstart", "touchend", "touchmove", "touchcancel", "scroll"];
var NON_PASSIVE_EVENTS = ["wheel"];
var supports = {};
var _isEventSupported = /* @__PURE__ */ (() => {
  const tags = {
    select: "input",
    change: "input",
    submit: "form",
    reset: "form",
    error: "img",
    load: "img",
    abort: "img"
  };
  const eventChecker = (eventName) => {
    if (typeof supports[eventName] === "boolean") {
      return supports[eventName];
    }
    const el = document.createElement(tags[eventName] || "div");
    eventName = "on" + eventName;
    return supports[eventName] = eventName in el;
  };
  return eventChecker;
})();
function _isElementInEventPath(element, event) {
  if (!event || !element) {
    return false;
  }
  return _getEventPath(event).indexOf(element) >= 0;
}
function _createEventPath(event) {
  const res = [];
  let pointer = event.target;
  while (pointer) {
    res.push(pointer);
    pointer = pointer.parentElement;
  }
  return res;
}
function _getEventPath(event) {
  const eventNoType = event;
  if (eventNoType.path) {
    return eventNoType.path;
  }
  if (eventNoType.composedPath) {
    return eventNoType.composedPath();
  }
  return _createEventPath(eventNoType);
}
function _addSafePassiveEventListener(eElement, event, listener) {
  const passive = getPassiveStateForEvent(event);
  let options;
  if (passive != null) {
    options = { passive };
  }
  eElement.addEventListener(event, listener, options);
}