ag-grid-enterprise/dist/ag-grid-enterprise.noStyle.js

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

(function(g,f){if(typeof exports=="object"&&typeof module<"u"){module.exports=f()}else if("function"==typeof define && define.amd){define("agGrid",f)}else {g["agGrid"]=f()}}(typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : this,function(){var exports={};var __exports=exports;var module={exports};
if (typeof require === 'undefined') {
    function require(name) {
        
        throw new Error('Unknown module: ' + name);
    }
}
        
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-enterprise/src/main-umd-noStyles.ts
var main_umd_noStyles_exports = {};
__export(main_umd_noStyles_exports, {
  ALWAYS_SYNC_GLOBAL_EVENTS: () => ALWAYS_SYNC_GLOBAL_EVENTS,
  AdvancedFilterModule: () => AdvancedFilterModule,
  AgAbstractCellEditor: () => AgAbstractCellEditor,
  AgAbstractInputField: () => AgAbstractInputField,
  AgAbstractLabel: () => AgAbstractLabel,
  AgCheckbox: () => AgCheckbox,
  AgCheckboxSelector: () => AgCheckboxSelector,
  AgColumn: () => AgColumn,
  AgColumnGroup: () => AgColumnGroup,
  AgContentEditableField: () => AgContentEditableField,
  AgContentEditableFieldSelector: () => AgContentEditableFieldSelector,
  AgFieldSet: () => AgFieldSet,
  AgFieldSetSelector: () => AgFieldSetSelector,
  AgFilterButtonSelector: () => AgFilterButtonSelector,
  AgInputDateField: () => AgInputDateField,
  AgInputNumberField: () => AgInputNumberField,
  AgInputNumberFieldSelector: () => AgInputNumberFieldSelector,
  AgInputTextArea: () => AgInputTextArea,
  AgInputTextAreaSelector: () => AgInputTextAreaSelector,
  AgInputTextField: () => AgInputTextField,
  AgInputTextFieldSelector: () => AgInputTextFieldSelector,
  AgPickerField: () => AgPickerField,
  AgPromise: () => AgPromise,
  AgProvidedColumnGroup: () => AgProvidedColumnGroup,
  AgRadioButton: () => AgRadioButton,
  AgRadioButtonSelector: () => AgRadioButtonSelector,
  AgSelect: () => AgSelect,
  AgSelectSelector: () => AgSelectSelector,
  AgToggleButton: () => AgToggleButton,
  AgToggleButtonSelector: () => AgToggleButtonSelector,
  AggregationModule: () => AggregationModule,
  AiToolkitModule: () => AiToolkitModule,
  AlignedGridsModule: () => AlignedGridsModule,
  AllCommunityModule: () => AllCommunityModule,
  AllEnterpriseModule: () => AllEnterpriseModule,
  AutoGenerateColumnsModule: () => AutoGenerateColumnsModule,
  BaseComponentWrapper: () => BaseComponentWrapper,
  BaseCreator: () => BaseCreator,
  BaseGridSerializingSession: () => BaseGridSerializingSession,
  BaseSelectionService: () => BaseSelectionService,
  BatchEditModule: () => BatchEditModule,
  BeanStub: () => BeanStub,
  BigIntFilterModule: () => BigIntFilterModule,
  CalculatedColumnsModule: () => CalculatedColumnsModule,
  CellApiModule: () => CellApiModule,
  CellRangeType: () => CellRangeType,
  CellSelectionModule: () => CellSelectionModule,
  CellSpanModule: () => CellSpanModule,
  CellStyleModule: () => CellStyleModule,
  CheckboxEditorModule: () => CheckboxEditorModule,
  ClientSideRowModelApiModule: () => ClientSideRowModelApiModule,
  ClientSideRowModelModule: () => ClientSideRowModelModule,
  ClipboardModule: () => ClipboardModule,
  ColumnApiModule: () => ColumnApiModule,
  ColumnAutoSizeModule: () => ColumnAutoSizeModule,
  ColumnHoverModule: () => ColumnHoverModule,
  ColumnMenuModule: () => ColumnMenuModule,
  ColumnsToolPanelModule: () => ColumnsToolPanelModule,
  Component: () => Component,
  ContextMenuModule: () => ContextMenuModule,
  CsvExportModule: () => CsvExportModule,
  CustomEditorModule: () => CustomEditorModule,
  CustomFilterModule: () => CustomFilterModule,
  DETAIL_ROW_ID_PREFIX: () => DETAIL_ROW_ID_PREFIX,
  DateEditorModule: () => DateEditorModule,
  DateFilterModule: () => DateFilterModule,
  DragAndDropModule: () => DragAndDropModule,
  DragSourceType: () => DragSourceType,
  EventApiModule: () => EventApiModule,
  ExcelExportModule: () => ExcelExportModule,
  ExternalFilterModule: () => ExternalFilterModule,
  FakeHScrollComp: () => FakeHScrollComp,
  FakeVScrollComp: () => FakeVScrollComp,
  FileInputOverlayModule: () => FileInputOverlayModule,
  FilterButtonComp: () => FilterButtonComp,
  FilterComp: () => FilterComp,
  FilterWrapperComp: () => FilterWrapperComp,
  FiltersToolPanelModule: () => FiltersToolPanelModule,
  FindModule: () => FindModule,
  FormulaModule: () => FormulaModule,
  GRAND_TOTAL_ROW_ID: () => GRAND_TOTAL_ROW_ID,
  GROUP_AUTO_COLUMN_ID: () => GROUP_AUTO_COLUMN_ID,
  GROUP_HIERARCHY_COLUMN_ID_PREFIX: () => GROUP_HIERARCHY_COLUMN_ID_PREFIX,
  GROUP_TOTAL_ROW_ID_PREFIX: () => GROUP_TOTAL_ROW_ID_PREFIX,
  GridBodyCtrl: () => GridBodyCtrl,
  GridChartsModule: () => GridChartsModule,
  GridCoreCreator: () => GridCoreCreator,
  GridCtrl: () => GridCtrl,
  GridHeaderCtrl: () => GridHeaderCtrl,
  GridStateModule: () => GridStateModule,
  GroupFilterModule: () => GroupFilterModule,
  HeaderRowContainerCtrl: () => HeaderRowContainerCtrl,
  HighlightChangesModule: () => HighlightChangesModule,
  InfiniteRowModelModule: () => InfiniteRowModelModule,
  IntegratedChartsModule: () => IntegratedChartsModule,
  KeyCode: () => KeyCode,
  LargeTextEditorModule: () => LargeTextEditorModule,
  LicenseManager: () => GridLicenseManager,
  LocaleModule: () => LocaleModule,
  LocaleService: () => LocaleService,
  ManagedFocusFeature: () => ManagedFocusFeature,
  MasterDetailModule: () => MasterDetailModule,
  MenuModule: () => MenuModule,
  ModuleRegistry: () => ModuleRegistry,
  MultiFilterModule: () => MultiFilterModule,
  NewFiltersToolPanelModule: () => NewFiltersToolPanelModule,
  NotesModule: () => NotesModule,
  NumberEditorModule: () => NumberEditorModule,
  NumberFilterModule: () => NumberFilterModule,
  PaginationModule: () => PaginationModule,
  PinnedRowModel: () => PinnedRowModel,
  PinnedRowModule: () => PinnedRowModule,
  PivotModule: () => PivotModule,
  PositionableFeature: () => PositionableFeature,
  ProvidedFilter: () => ProvidedFilter,
  QuickFilterModule: () => QuickFilterModule,
  ROOT_NODE_ID: () => ROOT_NODE_ID,
  ROW_NUMBERS_COLUMN_ID: () => ROW_NUMBERS_COLUMN_ID,
  RangeSelectionModule: () => RangeSelectionModule,
  RenderApiModule: () => RenderApiModule,
  RichSelectModule: () => RichSelectModule,
  RowApiModule: () => RowApiModule,
  RowAutoHeightModule: () => RowAutoHeightModule,
  RowContainerCtrl: () => RowContainerCtrl,
  RowDragModule: () => RowDragModule,
  RowGroupingEditModule: () => RowGroupingEditModule,
  RowGroupingModule: () => RowGroupingModule,
  RowGroupingPanelModule: () => RowGroupingPanelModule,
  RowNode: () => RowNode,
  RowNumbersModule: () => RowNumbersModule,
  RowSelectionModule: () => RowSelectionModule,
  RowStyleModule: () => RowStyleModule,
  SELECTION_COLUMN_ID: () => SELECTION_COLUMN_ID,
  STRUCTURED_SCHEMA_FEATURES: () => STRUCTURED_SCHEMA_FEATURES,
  ScrollApiModule: () => ScrollApiModule,
  SelectEditorModule: () => SelectEditorModule,
  ServerSideRowModelApiModule: () => ServerSideRowModelApiModule,
  ServerSideRowModelModule: () => ServerSideRowModelModule,
  ServerSideTransactionResultStatus: () => ServerSideTransactionResultStatus,
  SetFilterModule: () => SetFilterModule,
  ShowValuesAsModule: () => ShowValuesAsModule,
  SideBarModule: () => SideBarModule,
  SparklinesModule: () => SparklinesModule,
  StatusBarModule: () => StatusBarModule,
  TabGuardComp: () => TabGuardComp,
  TabGuardCtrl: () => TabGuardCtrl,
  TabGuardFeature: () => TabGuardFeature,
  TextEditorModule: () => TextEditorModule,
  TextFilterModule: () => TextFilterModule,
  ToolbarModule: () => ToolbarModule,
  TooltipModule: () => TooltipModule,
  TouchListener: () => TouchListener,
  TreeDataModule: () => TreeDataModule,
  UndoRedoEditModule: () => UndoRedoEditModule,
  ValidationModule: () => ValidationModule,
  ValueCacheModule: () => ValueCacheModule,
  VanillaFrameworkOverrides: () => VanillaFrameworkOverrides,
  ViewportRowModelModule: () => ViewportRowModelModule,
  _AgColorPicker: () => AgColorPicker,
  _AgColorPickerSelector: () => AgColorPickerSelector,
  _AgContextMenuService: () => AgContextMenuService,
  _AgDialog: () => AgDialog,
  _AgGroupComponent: () => AgGroupComponent,
  _AgGroupComponentSelector: () => AgGroupComponentSelector,
  _AgInputRange: () => AgInputRange,
  _AgInputRangeSelector: () => AgInputRangeSelector,
  _AgMenuItemComponent: () => AgMenuItemComponent,
  _AgMenuItemRenderer: () => AgMenuItemRenderer,
  _AgMenuList: () => AgMenuList,
  _AgPanel: () => AgPanel,
  _AgSlider: () => AgSlider,
  _AgSliderSelector: () => AgSliderSelector,
  _AgTabbedLayout: () => AgTabbedLayout,
  _AgVirtualList: () => AgVirtualList,
  _AgVirtualListDragFeature: () => AgVirtualListDragFeature,
  _BOOLEAN_MIXED_GRID_OPTIONS: () => _BOOLEAN_MIXED_GRID_OPTIONS,
  _BaseSingleColService: () => BaseSingleColService,
  _ChangedRowNodes: () => ChangedRowNodes,
  _ColumnFilterModule: () => ColumnFilterModule,
  _ColumnGroupModule: () => ColumnGroupModule,
  _ColumnMoveModule: () => ColumnMoveModule,
  _CsrmSsrmSharedApiModule: () => CsrmSsrmSharedApiModule,
  _DATA_TYPE_DERIVED_COL_DEF_PROPERTIES: () => DATA_TYPE_DERIVED_COL_DEF_PROPERTIES,
  _DragModule: () => DragModule,
  _EditCoreModule: () => EditCoreModule,
  _EmptyBean: () => EmptyBean,
  _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: () => AgColumnHeader,
  _HorizontalResizeModule: () => HorizontalResizeModule,
  _KeyboardNavigationModule: () => KeyboardNavigationModule,
  _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,
  _applyColumnState: () => _applyColumnState,
  _applyHeaderWrapperHidden: () => applyHeaderWrapperHidden,
  _applyHeaderWrapperMaxHeight: () => applyHeaderWrapperMaxHeight,
  _areCellsEqual: () => _areCellsEqual,
  _attemptToRestoreCellFocus: () => _attemptToRestoreCellFocus,
  _buildColumnTree: () => _buildColumnTree,
  _canSkipShowingRowGroup: () => _canSkipShowingRowGroup,
  _clamp: () => _clamp,
  _combineAttributesAndGridOptions: () => _combineAttributesAndGridOptions,
  _consoleError: () => _consoleError,
  _convertColumnEventSourceType: () => _convertColumnEventSourceType,
  _coreThemeDefaults: () => coreDefaults,
  _createCellId: () => _createCellId,
  _createElement: () => _createElement,
  _createGlobalRowEvent: () => _createGlobalRowEvent,
  _createIcon: () => _createIcon,
  _createIconNoSpan: () => _createIconNoSpan,
  _createRowNodeSibling: () => _createRowNodeSibling,
  _createUserColumn: () => _createUserColumn,
  _csrmFirstLeaf: () => _csrmFirstLeaf,
  _csrmReorderAllLeafs: () => _csrmReorderAllLeafs,
  _destroyColumnTreeAll: () => _destroyColumnTreeAll,
  _destroyColumnTreeUnused: () => _destroyColumnTreeUnused,
  _dispatchColumnChangedEvent: () => _dispatchColumnChangedEvent,
  _doDeltaSort: () => doDeltaSort,
  _errMsg: () => _errMsg,
  _error: () => _error,
  _findEnterpriseCoreModule: () => _findEnterpriseCoreModule,
  _focusGridInnerElement: () => _focusGridInnerElement,
  _focusNextGridCoreContainer: () => _focusNextGridCoreContainer,
  _forEachChangedGroupDepthFirst: () => _forEachChangedGroupDepthFirst,
  _formatNumberCommas: () => _formatNumberCommas,
  _getAbsoluteRowIndex: () => _getAbsoluteRowIndex,
  _getCallbackForEvent: () => _getCallbackForEvent,
  _getCellByPosition: () => _getCellByPosition,
  _getCellCtrlForEventTarget: () => _getCellCtrlForEventTarget,
  _getCellPositionForEvent: () => _getCellPositionForEvent,
  _getCellRendererDetails: () => _getCellRendererDetails,
  _getCheckboxLocation: () => _getCheckboxLocation,
  _getCheckboxes: () => _getCheckboxes,
  _getClientSideRowModel: () => _getClientSideRowModel,
  _getColumnStateFromColDef: () => _getColumnStateFromColDef,
  _getDefaultFloatingFilterType: () => _getDefaultFloatingFilterType,
  _getDefaultSimpleFilter: () => _getDefaultSimpleFilter,
  _getDisplaySortForColumn: () => _getDisplaySortForColumn,
  _getEditorRendererDetails: () => _getEditorRendererDetails,
  _getEnableColumnSelection: () => _getEnableColumnSelection,
  _getFillHandle: () => _getFillHandle,
  _getFilterDetails: () => _getFilterDetails,
  _getFilterModel: () => _getFilterModel,
  _getFilterParamsForDataType: () => _getFilterParamsForDataType,
  _getFirstRow: () => _getFirstRow,
  _getFloatingFilterCompDetails: () => _getFloatingFilterCompDetails,
  _getFloatingFiltersHeight: () => getFloatingFiltersHeight,
  _getGlobalGridOption: () => _getGlobalGridOption,
  _getGrandTotalPinnedFloat: () => _getGrandTotalPinnedFloat,
  _getGrandTotalRow: () => _getGrandTotalRow,
  _getGridOption: () => _getGridOption,
  _getGridRegisteredModules: () => _getGridRegisteredModules,
  _getGroupAggFiltering: () => _getGroupAggFiltering,
  _getGroupSelection: () => _getGroupSelection,
  _getGroupSelectsDescendants: () => _getGroupSelectsDescendants,
  _getGroupTotalRowCallback: () => _getGroupTotalRowCallback,
  _getHeaderCheckbox: () => _getHeaderCheckbox,
  _getHeaderClassesFromColDef: () => _getHeaderClassesFromColDef,
  _getHeaderRowCount: () => getHeaderRowCount,
  _getInnerCellRendererDetails: () => _getInnerCellRendererDetails,
  _getIsRowSelectable: () => _getIsRowSelectable,
  _getLastRow: () => _getLastRow,
  _getMaxConcurrentDatasourceRequests: () => _getMaxConcurrentDatasourceRequests,
  _getNormalisedMousePosition: () => _getNormalisedMousePosition,
  _getPinnedSectionWidths: () => getPinnedSectionWidths,
  _getRowAbove: () => _getRowAbove,
  _getRowBelow: () => _getRowBelow,
  _getRowContainerClass: () => _getRowContainerClass,
  _getRowContainerOptions: () => _getRowContainerOptions,
  _getRowCtrlForEventTarget: () => _getRowCtrlForEventTarget,
  _getRowHeightAsNumber: () => _getRowHeightAsNumber,
  _getRowHeightForNode: () => _getRowHeightForNode,
  _getRowIdCallback: () => _getRowIdCallback,
  _getRowNode: () => _getRowNode,
  _getRowSelectionMode: () => _getRowSelectionMode,
  _getRowSpanContainerClass: () => _getRowSpanContainerClass,
  _getServerSideRowModel: () => _getServerSideRowModel,
  _getShouldDisplayTooltip: () => _getShouldDisplayTooltip,
  _getSortModel: () => _getSortModel,
  _getSuppressMultiRanges: () => _getSuppressMultiRanges,
  _getToolPanelClassesFromColDef: () => _getToolPanelClassesFromColDef,
  _getValueUsingDotPath: () => _getValueUsingDotPath,
  _getViewportRowModel: () => _getViewportRowModel,
  _interpretAsRightClick: () => _interpretAsRightClick,
  _isAnimateRows: () => _isAnimateRows,
  _isCalculatedColumnsEnabled: () => _isCalculatedColumnsEnabled,
  _isCellSelectionEnabled: () => _isCellSelectionEnabled,
  _isClientSideRowModel: () => _isClientSideRowModel,
  _isColumnMenuAnchoringEnabled: () => _isColumnMenuAnchoringEnabled,
  _isColumnsSortingCoupledToGroup: () => _isColumnsSortingCoupledToGroup,
  _isDomLayout: () => _isDomLayout,
  _isFiniteNumber: () => _isFiniteNumber,
  _isFullWidthGroupRow: () => _isFullWidthGroupRow,
  _isGetRowHeightFunction: () => _isGetRowHeightFunction,
  _isGroupHideColumnsUntilExpanded: () => _isGroupHideColumnsUntilExpanded,
  _isGroupMultiAutoColumn: () => _isGroupMultiAutoColumn,
  _isGroupRowsSticky: () => _isGroupRowsSticky,
  _isGroupUseEntireRow: () => _isGroupUseEntireRow,
  _isHeaderFocusSuppressed: () => _isHeaderFocusSuppressed,
  _isLegacyMenuEnabled: () => _isLegacyMenuEnabled,
  _isMultiRowSelection: () => _isMultiRowSelection,
  _isProtoPollutionKey: () => _isProtoPollutionKey,
  _isRowBefore: () => _isRowBefore,
  _isRowNumbers: () => _isRowNumbers,
  _isRowSelection: () => _isRowSelection,
  _isSameRow: () => _isSameRow,
  _isServerSideRowModel: () => _isServerSideRowModel,
  _isSetFilterByDefault: () => _isSetFilterByDefault,
  _isShowTooltipWhenTruncated: () => _isShowTooltipWhenTruncated,
  _isStopPropagationForAgGrid: () => _isStopPropagationForAgGrid,
  _isUseApplyButton: () => _isUseApplyButton,
  _isUsingNewCellSelectionAPI: () => _isUsingNewCellSelectionAPI,
  _isUsingNewRowSelectionAPI: () => _isUsingNewRowSelectionAPI,
  _logPreInitWarn: () => _logPreInitWarn,
  _mergeDeep: () => _mergeDeep,
  _mergedEqual: () => _mergedEqual,
  _normaliseCalculatedExpression: () => _normaliseCalculatedExpression,
  _normalizeSortType: () => _normalizeSortType,
  _partitionByPinned: () => partitionByPinned,
  _preInitErrMsg: () => _preInitErrMsg,
  _prevOrNextDisplayedRow: () => _prevOrNextDisplayedRow,
  _processOnChange: () => _processOnChange,
  _refreshFilterUi: () => _refreshFilterUi,
  _refreshHandlerAndUi: () => _refreshHandlerAndUi,
  _registerModule: () => _registerModule,
  _resetColumnState: () => _resetColumnState,
  _resolvePivotColumnForRow: () => _resolvePivotColumnForRow,
  _resolveSortOptions: () => _resolveSortOptions,
  _selectAllCells: () => _selectAllCells,
  _setColMenuVisible: () => _setColMenuVisible,
  _setColsVisible: () => _setColsVisible,
  _setUmd: () => _setUmd,
  _shouldUpdateColVisibilityAfterGroup: () => _shouldUpdateColVisibilityAfterGroup,
  _skipFocusableContainerListenerForAgGrid: () => _skipFocusableContainerListenerForAgGrid,
  _stopPropagationForAgGrid: () => _stopPropagationForAgGrid,
  _suppressCellMouseEvent: () => _suppressCellMouseEvent,
  _themeAlpineParams: () => themeAlpineParams,
  _themeBalhamParams: () => themeBalhamParams,
  _themeMaterialParams: () => themeMaterialParams,
  _themeQuartzParams: () => themeQuartzParams,
  _toFiniteNumber: () => _toFiniteNumber,
  _translateForFilter: () => translateForFilter,
  _unwrapUserComp: () => _unwrapUserComp,
  _updateFilterModel: () => _updateFilterModel,
  _updatePinnedSectionWidths: () => updatePinnedSectionWidths,
  _updateRowNodeAfterSort: () => updateRowNodeAfterSort,
  _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: () => createGrid2,
  createPart: () => createPart,
  createTheme: () => createTheme,
  dispatchColumnVisibleEvent: () => dispatchColumnVisibleEvent,
  distributeGroupValue: () => distributeGroupValue,
  enableDevValidations: () => enableDevValidations,
  exportMultipleSheetsAsExcel: () => exportMultipleSheetsAsExcel,
  forEachColDef: () => forEachColDef,
  getGridApi: () => getGridApi,
  getGridElement: () => getGridElement,
  getMultipleSheetsAsExcel: () => getMultipleSheetsAsExcel,
  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_umd_noStyles_exports);

// packages/ag-stack/src/constants/keyCode.ts
var KeyCode = {
  BACKSPACE: "Backspace",
  TAB: "Tab",
  ENTER: "Enter",
  ESCAPE: "Escape",
  SPACE: " ",
  LEFT: "ArrowLeft",
  UP: "ArrowUp",
  RIGHT: "ArrowRight",
  DOWN: "ArrowDown",
  DELETE: "Delete",
  F2: "F2",
  PAGE_UP: "PageUp",
  PAGE_DOWN: "PageDown",
  PAGE_HOME: "Home",
  PAGE_END: "End",
  // these should be used with `event.code` instead of `event.key`
  // as `event.key` changes when non-latin keyboards are used
  A: "KeyA",
  C: "KeyC",
  D: "KeyD",
  V: "KeyV",
  X: "KeyX",
  Y: "KeyY",
  Z: "KeyZ"
};
var A_KEYCODE = 65;
var C_KEYCODE = 67;
var V_KEYCODE = 86;
var D_KEYCODE = 68;
var Z_KEYCODE = 90;
var Y_KEYCODE = 89;
function _normaliseQwertyAzerty(keyboardEvent) {
  const { keyCode } = keyboardEvent;
  let code;
  switch (keyCode) {
    case A_KEYCODE:
      code = KeyCode.A;
      break;
    case C_KEYCODE:
      code = KeyCode.C;
      break;
    case V_KEYCODE:
      code = KeyCode.V;
      break;
    case D_KEYCODE:
      code = KeyCode.D;
      break;
    case Z_KEYCODE:
      code = KeyCode.Z;
      break;
    case Y_KEYCODE:
      code = KeyCode.Y;
      break;
    default:
      code = keyboardEvent.code;
  }
  return code;
}

// packages/ag-stack/src/version.ts
var VERSION = "36.0.0";

// packages/ag-stack/src/theming/shared/shared.css
var shared_default = ':where([class^=ag-]),:where([class^=ag-]):after,:where([class^=ag-]):before{box-sizing:border-box}:where([class^=ag-]):where(button){color:inherit}:where([class^=ag-]):where(input:not([type]),input[type=text],input[type=number],input[type=tel],input[type=date],input[type=datetime-local],textarea){font-family:inherit;font-size:inherit;line-height:inherit;padding:0}:where([class^=ag-]):where(div,span,label):focus-visible{box-shadow:inset var(--ag-focus-shadow);outline:none;&:where(.invalid){box-shadow:inset var(--ag-focus-error-shadow)}}:where([class^=ag-]) ::-ms-clear{display:none}.ag-hidden{display:none!important}.ag-invisible{visibility:hidden!important}.ag-tab-guard{display:block;height:0;position:absolute;width:0}.ag-tab-guard-top{top:1px}.ag-tab-guard-bottom{bottom:1px}.ag-measurement-container{height:0;overflow:hidden;visibility:hidden;width:0}.ag-measurement-element-border{display:inline-block}.ag-measurement-element-border:before{border-left:var(--ag-internal-measurement-border);content:"";display:block}.ag-popup{background-color:var(--ag-wrapper-background-color)}.ag-popup-child{top:0;z-index:5}.ag-popup-child:where(:not(.ag-tooltip-custom)){box-shadow:var(--ag-popup-shadow)}.ag-input-wrapper,.ag-picker-field-wrapper{align-items:center;display:flex;flex:1 1 auto;line-height:normal;position:relative}.ag-input-field{align-items:center;display:flex;flex-direction:row}.ag-input-field-input:where(:not([type=checkbox],[type=radio])){flex:1 1 auto;min-width:0;width:100%}.ag-styled-root{cursor:default;display:contents;line-height:normal;white-space:normal;-webkit-font-smoothing:antialiased;color:var(--ag-text-color);color-scheme:var(--ag-browser-color-scheme);font-family:var(--ag-font-family);font-size:var(--ag-font-size);font-weight:var(--ag-font-weight);--ag-indentation-level:0}:where(.ag-icon):before{align-items:center;background-color:currentcolor;color:inherit;content:"";display:flex;font-family:inherit;font-size:var(--ag-icon-size);font-style:normal;font-variant:normal;height:var(--ag-icon-size);justify-content:center;line-height:var(--ag-icon-size);-webkit-mask-size:contain;mask-size:contain;text-transform:none;width:var(--ag-icon-size)}.ag-icon{background-position:50%;background-repeat:no-repeat;background-size:contain;color:var(--ag-icon-color);display:block;height:var(--ag-icon-size);position:relative;-webkit-user-select:none;-moz-user-select:none;user-select:none;width:var(--ag-icon-size)}.ag-disabled .ag-icon,[disabled] .ag-icon{opacity:.5}.ag-icon-grip.ag-disabled,.ag-icon-grip[disabled]{opacity:.35}.ag-icon-loading{animation-duration:1s;animation-iteration-count:infinite;animation-name:spin;animation-timing-function:linear}@keyframes spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}.ag-resizer{pointer-events:none;position:absolute;-webkit-user-select:none;-moz-user-select:none;user-select:none;z-index:1}:where(.ag-resizer){&.ag-resizer-topLeft{cursor:nwse-resize;height:5px;left:0;top:0;width:5px}&.ag-resizer-top{cursor:ns-resize;height:5px;left:5px;right:5px;top:0}&.ag-resizer-topRight{cursor:nesw-resize;height:5px;right:0;top:0;width:5px}&.ag-resizer-right{bottom:5px;cursor:ew-resize;right:0;top:5px;width:5px}&.ag-resizer-bottomRight{bottom:0;cursor:nwse-resize;height:5px;right:0;width:5px}&.ag-resizer-bottom{bottom:0;cursor:ns-resize;height:5px;left:5px;right:5px}&.ag-resizer-bottomLeft{bottom:0;cursor:nesw-resize;height:5px;left:0;width:5px}&.ag-resizer-left{bottom:5px;cursor:ew-resize;left:0;top:5px;width:5px}}.ag-menu{background-color:var(--ag-menu-background-color);border:var(--ag-menu-border);border-radius:var(--ag-border-radius);box-shadow:var(--ag-menu-shadow);color:var(--ag-menu-text-color);max-height:100%;overflow-y:auto;position:absolute;-webkit-user-select:none;-moz-user-select:none;user-select:none}';

// packages/ag-stack/src/theming/inject.ts
var IS_SSR = typeof window !== "object" || !window?.document?.fonts?.forEach;
var FORCE_LEGACY_THEMES = false;
var _injectGlobalCSS = (rawCss, styleContainer, debugId, layer, priority, nonce, isParams = false) => {
  if (IS_SSR || FORCE_LEGACY_THEMES) {
    return;
  }
  let injectedCss = rawCss;
  if (layer) {
    injectedCss = `@layer ${CSS.escape(layer).replaceAll("\\.", ".")} { ${rawCss} }`;
  }
  let injections = injectionState.map.get(styleContainer);
  if (!injections) {
    injections = [];
    injectionState.map.set(styleContainer, injections);
  }
  if (injections.some((i) => i.injectedCss === injectedCss)) {
    return;
  }
  const el = document.createElement("style");
  if (nonce) {
    el.setAttribute("nonce", nonce);
  }
  el.dataset.agCss = debugId;
  el.dataset.agCssVersion = VERSION;
  el.textContent = injectedCss;
  const newInjection = { rawCss, injectedCss, el, priority, isParams };
  let insertAfter;
  for (const injection of injections) {
    if (injection.priority > priority) {
      break;
    }
    insertAfter = injection;
  }
  if (insertAfter) {
    insertAfter.el.after(el);
    const index = injections.indexOf(insertAfter);
    injections.splice(index + 1, 0, newInjection);
  } else {
    if (styleContainer.nodeName === "STYLE") {
      styleContainer.after(el);
    } else {
      styleContainer.insertBefore(el, styleContainer.querySelector(":not(title, meta)"));
    }
    injections.push(newInjection);
  }
};
var _injectCoreAndModuleCSS = (styleContainer, layer, nonce, moduleCss) => {
  _injectGlobalCSS(shared_default, styleContainer, "shared", layer, 0, nonce);
  moduleCss?.forEach(
    (css, debugId) => css.forEach((singleCss) => _injectGlobalCSS(singleCss, styleContainer, debugId, layer, 0, nonce))
  );
};
var _useParamsCss = (environment, paramsCss, paramsDebugId, styleContainer, layer, nonce) => {
  if (IS_SSR || FORCE_LEGACY_THEMES) {
    return;
  }
  const gridState = injectionState.grids.get(environment);
  if (!gridState) {
    injectionState.grids.set(environment, { styleContainer, paramsCss });
  } else {
    gridState.paramsCss = paramsCss;
  }
  removeStaleParamsCss(styleContainer);
  if (paramsCss && paramsDebugId) {
    _injectGlobalCSS(paramsCss, styleContainer, paramsDebugId, layer, 2, nonce, true);
  }
};
var _unregisterInstanceUsingThemingAPI = (environment) => {
  const styleContainer = injectionState.grids.get(environment)?.styleContainer;
  if (!styleContainer) {
    return;
  }
  injectionState.grids.delete(environment);
  const containerStillInUse = Array.from(injectionState.grids.values()).some(
    (gs) => gs.styleContainer === styleContainer
  );
  if (containerStillInUse) {
    removeStaleParamsCss(styleContainer);
  } else {
    removeStaleParamsCss(styleContainer, true);
    injectionState.map.delete(styleContainer);
  }
};
var removeStaleParamsCss = (styleContainer, deleteAll = false) => {
  const neededCss = /* @__PURE__ */ new Set();
  for (const gs of injectionState.grids.values()) {
    if (gs.styleContainer === styleContainer) {
      neededCss.add(gs.paramsCss);
    }
  }
  const injections = injectionState.map.get(styleContainer) ?? [];
  for (let i = injections.length - 1; i >= 0; i--) {
    if (deleteAll || injections[i].isParams && !neededCss.has(injections[i].rawCss)) {
      injections[i].el.remove();
      injections.splice(i, 1);
    }
  }
};
var getInjectionState = () => {
  const versionMap = globalThis.agStyleInjectionVersions ?? (globalThis.agStyleInjectionVersions = /* @__PURE__ */ new Map());
  let state = versionMap.get(VERSION);
  if (!state) {
    state = {
      map: /* @__PURE__ */ new WeakMap(),
      grids: /* @__PURE__ */ new Map(),
      paramsId: 0
    };
    versionMap.set(VERSION, state);
  }
  return state;
};
var injectionState = getInjectionState();

// packages/ag-stack/src/theming/partImpl.ts
var createPart = (args) => {
  return new PartImpl(args);
};
var defaultModeName = "$default";
var partCounter = 0;
var PartImpl = class {
  constructor({ feature, params, modeParams = {}, css, cssImports }) {
    this.feature = feature;
    this.css = css;
    this.cssImports = cssImports;
    this.modeParams = {
      // NOTE: it's important that default is defined first, putting it
      // first in iteration order, because when merging params the default
      // params override any prior modal params, so modal params in this
      // part need to come after default params to prevent them from being
      // immediately overridden.
      [defaultModeName]: {
        ...modeParams[defaultModeName] ?? {},
        ...params ?? {}
      },
      ...modeParams
    };
  }
  use(styleContainer, layer, nonce) {
    let inject = this._inject;
    if (inject == null) {
      let { css } = this;
      if (css) {
        const className = `ag-theme-${this.feature ?? "part"}-${++partCounter}`;
        if (typeof css === "function") {
          css = css();
        }
        css = `:where(.${className}) {
${css}
}
`;
        for (const cssImport of this.cssImports ?? []) {
          css = `@import url(${JSON.stringify(cssImport)});
${css}`;
        }
        inject = { css, class: className };
      } else {
        inject = false;
      }
      this._inject = inject;
    }
    if (inject && styleContainer) {
      _injectGlobalCSS(inject.css, styleContainer, inject.class, layer, 1, nonce);
    }
    return inject ? inject.class : false;
  }
};

// packages/ag-stack/src/utils/promise.ts
function _isPromise(fn) {
  return typeof fn.then === "function";
}
function _wrapInterval(action, timeout) {
  return new AgPromise((resolve) => {
    resolve(window.setInterval(action, timeout));
  });
}
var AgPromise = class _AgPromise {
  constructor(callback) {
    this.status = 0 /* IN_PROGRESS */;
    this.resolution = null;
    this.waiters = [];
    callback(
      (value) => this.onDone(value),
      (params) => this.onReject(params)
    );
  }
  static all(promises) {
    return promises.length ? new _AgPromise((resolve) => {
      let remainingToResolve = promises.length;
      const combinedValues = new Array(remainingToResolve);
      promises.forEach((promise, index) => {
        promise.then((value) => {
          combinedValues[index] = value;
          remainingToResolve--;
          if (remainingToResolve === 0) {
            resolve(combinedValues);
          }
        });
      });
    }) : _AgPromise.resolve();
  }
  static resolve(value = null) {
    return new _AgPromise((resolve) => resolve(value));
  }
  then(func) {
    return new _AgPromise((resolve) => {
      if (this.status === 1 /* RESOLVED */) {
        resolve(func(this.resolution));
      } else {
        this.waiters.push((value) => resolve(func(value)));
      }
    });
  }
  onDone(value) {
    this.status = 1 /* RESOLVED */;
    this.resolution = value;
    for (const waiter of this.waiters) {
      waiter(value);
    }
  }
  onReject(_) {
  }
};

// packages/ag-stack/src/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-stack/src/utils/array.ts
function _last(arr) {
  const len = arr?.length;
  return len ? arr[len - 1] : void 0;
}
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;
  }
  if (comparator) {
    for (let i = 0; i < len; ++i) {
      const valueA = a[i];
      const valueB = b[i];
      if (valueA !== valueB && !comparator(valueA, valueB)) {
        return false;
      }
    }
    return true;
  }
  for (let i = 0; i < len; ++i) {
    if (a[i] !== b[i]) {
      return false;
    }
  }
  return true;
}
function _reuseArrayIfEqual(prev, current) {
  if (!current) {
    return [];
  }
  const len = current.length;
  if (prev && prev !== current && prev.length === len) {
    for (let i = 0; i < len; ++i) {
      if (prev[i] !== current[i]) {
        return current.slice();
      }
    }
    return prev;
  }
  return current.slice();
}
function _removeFromArray(array, object) {
  const index = array.indexOf(object);
  if (index >= 0) {
    array.splice(index, 1);
  }
}
function _removeAllFromArray(array, elementsToRemove) {
  const len = array.length;
  const removeLen = elementsToRemove.length;
  if (!len || !removeLen) {
    return;
  }
  let j = 0;
  const removeSet = new Set(elementsToRemove);
  for (let i = 0; i < len; ++i) {
    const value = array[i];
    if (!removeSet.has(value)) {
      if (i !== j) {
        array[j] = value;
      }
      ++j;
    }
  }
  if (j < len) {
    array.length = j;
  }
}
function _moveInArray(array, objectsToMove, toIndex) {
  const objectsToMoveLen = objectsToMove.length;
  for (let i = 0; i < objectsToMoveLen; ++i) {
    _removeFromArray(array, objectsToMove[i]);
  }
  for (let i = objectsToMoveLen - 1; i >= 0; i--) {
    array.splice(toIndex, 0, objectsToMove[i]);
  }
}
function _flatten(arrays) {
  return [].concat.apply([], arrays);
}
function _symmetricDiff(a, b) {
  if (a === b) {
    return [];
  }
  const leftLen = a?.length;
  const rightLen = b?.length;
  if (!leftLen) {
    return b ? b.slice() : [];
  }
  if (!rightLen) {
    return a ? a.slice() : [];
  }
  const diff = new Set(a);
  for (let i = 0; i < rightLen; ++i) {
    const item = b[i];
    if (!diff.delete(item)) {
      diff.add(item);
    }
  }
  return Array.from(diff);
}
function _pushToMapArray(map, key, value) {
  const bucket = map.get(key);
  if (bucket === void 0) {
    map.set(key, [value]);
    return;
  }
  bucket.push(value);
}
function _indexMap(arr) {
  const map = /* @__PURE__ */ new Map();
  if (arr) {
    for (let i = 0, len = arr.length; i < len; ++i) {
      map.set(arr[i], i);
    }
  }
  return map;
}

// packages/ag-stack/src/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 (typeof valueA === "object" && valueA !== null && typeof valueA.toNumber === "function") {
    valueA = valueA.toNumber();
  }
  if (typeof valueB === "object" && valueB !== null && typeof valueB.toNumber === "function") {
    valueB = valueB.toNumber();
  }
  if (valueA == null) {
    return valueB == null ? 0 : -1;
  }
  if (valueB == null) {
    return 1;
  }
  if (!accentedCompare || typeof valueA !== "string") {
    if (valueA > valueB) {
      return 1;
    }
    if (valueA < valueB) {
      return -1;
    }
    return 0;
  }
  return valueA.localeCompare(valueB);
};

// packages/ag-stack/src/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;
  try {
    rootNode = _getDocument(beans).fullscreenElement;
  } catch {
  } 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-stack/src/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 _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 _setAriaAutoComplete(element, autoComplete) {
  _setAriaAttribute(element, "autocomplete", autoComplete);
}
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");
}

// packages/ag-stack/src/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 } = o