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,
  AgFieldSet: () => AgFieldSet,
  AgFieldSetSelector: () => AgFieldSetSelector,
  AgFilterButtonSelector: () => AgFilterButtonSelector,
  AgInputDateField: () => AgInputDateField,
  AgInputNumberField: () => AgInputNumberField,
  AgInputNumberFieldSelector: () => AgInputNumberFieldSelector,
  AgInputTextArea: () => AgInputTextArea,
  AgInputTextAreaSelector: () => AgInputTextAreaSelector,
  AgInputTextField: () => AgInputTextField,
  AgInputTextFieldSelector: () => AgInputTextFieldSelector,
  AgPickerField: () => AgPickerField,
  AgPromise: () => import_ag_stack203.AgPromise,
  AgProvidedColumnGroup: () => AgProvidedColumnGroup,
  AgRadioButton: () => AgRadioButton,
  AgRadioButtonSelector: () => AgRadioButtonSelector,
  AgSelect: () => AgSelect,
  AgSelectSelector: () => AgSelectSelector,
  AgToggleButton: () => AgToggleButton,
  AgToggleButtonSelector: () => AgToggleButtonSelector,
  AlignedGridsModule: () => AlignedGridsModule,
  AllCommunityModule: () => AllCommunityModule,
  AutoGenerateColumnsModule: () => AutoGenerateColumnsModule,
  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,
  Component: () => Component,
  CsvExportModule: () => CsvExportModule,
  CustomEditorModule: () => CustomEditorModule,
  CustomFilterModule: () => CustomFilterModule,
  DETAIL_ROW_ID_PREFIX: () => DETAIL_ROW_ID_PREFIX,
  DateEditorModule: () => DateEditorModule,
  DateFilterModule: () => DateFilterModule,
  DragAndDropModule: () => DragAndDropModule,
  DragSourceType: () => DragSourceType,
  EventApiModule: () => EventApiModule,
  ExternalFilterModule: () => ExternalFilterModule,
  FakeHScrollComp: () => FakeHScrollComp,
  FakeVScrollComp: () => FakeVScrollComp,
  FileInputOverlayModule: () => FileInputOverlayModule,
  FilterButtonComp: () => FilterButtonComp,
  FilterComp: () => FilterComp,
  FilterWrapperComp: () => FilterWrapperComp,
  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,
  GridCoreCreator: () => GridCoreCreator,
  GridCtrl: () => GridCtrl,
  GridHeaderCtrl: () => GridHeaderCtrl,
  GridStateModule: () => GridStateModule,
  HeaderRowContainerCtrl: () => HeaderRowContainerCtrl,
  HighlightChangesModule: () => HighlightChangesModule,
  InfiniteRowModelModule: () => InfiniteRowModelModule,
  KeyCode: () => import_ag_stack203.KeyCode,
  LargeTextEditorModule: () => LargeTextEditorModule,
  LocaleModule: () => LocaleModule,
  LocaleService: () => LocaleService,
  ManagedFocusFeature: () => ManagedFocusFeature,
  ModuleRegistry: () => ModuleRegistry,
  NumberEditorModule: () => NumberEditorModule,
  NumberFilterModule: () => NumberFilterModule,
  PaginationModule: () => PaginationModule,
  PinnedRowModel: () => PinnedRowModel,
  PinnedRowModule: () => PinnedRowModule,
  PositionableFeature: () => PositionableFeature,
  ProvidedFilter: () => ProvidedFilter,
  QuickFilterModule: () => QuickFilterModule,
  ROOT_NODE_ID: () => ROOT_NODE_ID,
  ROW_NUMBERS_COLUMN_ID: () => ROW_NUMBERS_COLUMN_ID,
  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,
  TabGuardComp: () => TabGuardComp,
  TabGuardCtrl: () => TabGuardCtrl,
  TabGuardFeature: () => TabGuardFeature,
  TextEditorModule: () => TextEditorModule,
  TextFilterModule: () => TextFilterModule,
  TooltipModule: () => TooltipModule,
  TouchListener: () => TouchListener,
  UndoRedoEditModule: () => UndoRedoEditModule,
  ValidationModule: () => ValidationModule,
  ValueCacheModule: () => ValueCacheModule,
  VanillaFrameworkOverrides: () => VanillaFrameworkOverrides,
  _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: () => createGrid,
  createPart: () => import_ag_stack204.createPart,
  createTheme: () => createTheme,
  dispatchColumnVisibleEvent: () => dispatchColumnVisibleEvent,
  enableDevValidations: () => enableDevValidations,
  forEachColDef: () => forEachColDef,
  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/entities/agColumn.ts
var import_ag_stack7 = require("ag-stack");

// packages/ag-grid-community/src/entities/defaultColumnTypes.ts
var DefaultColumnTypes = {
  numericColumn: {
    headerClass: "ag-right-aligned-header",
    cellClass: "ag-right-aligned-cell"
  },
  rightAligned: {
    headerClass: "ag-right-aligned-header",
    cellClass: "ag-right-aligned-cell"
  }
};

// packages/ag-grid-community/src/gridOptionsUtils.ts
var import_ag_stack3 = require("ag-stack");

// packages/ag-grid-community/src/utils/mergeDeep.ts
var import_ag_stack = require("ag-stack");
var _isProtoPollutionKey = (key) => key === "__proto__" || key === "constructor" || key === "prototype";
var isPlainProto = (value) => {
  const proto = Object.getPrototypeOf(value);
  return proto === Object.prototype || proto === null;
};
var _isPlainObject = (value) => value !== null && typeof value === "object" && isPlainProto(value);
var setKey = (out, key, value, copyUndef, simpleObjects) => {
  let destValue = out[key];
  if (destValue === value) {
    return;
  }
  if (value === null || typeof value !== "object") {
    if (copyUndef || value !== void 0) {
      out[key] = value;
    }
    return;
  }
  if (simpleObjects && destValue == null && isPlainProto(value)) {
    destValue = {};
    out[key] = destValue;
  }
  if (destValue !== null && typeof destValue === "object" && !Array.isArray(destValue)) {
    _mergeDeep(destValue, value, copyUndef, simpleObjects);
  } else {
    out[key] = value;
  }
};
var _mergeDeep = (dest, source, copyUndefined = true, makeCopyOfSimpleObjects = false) => {
  if (source == null || source === "") {
    return;
  }
  if (Array.isArray(source)) {
    for (let i = 0, len = source.length; i < len; ++i) {
      setKey(dest, i, source[i], copyUndefined, makeCopyOfSimpleObjects);
    }
    return;
  }
  for (const key of Object.keys(source)) {
    if (!_isProtoPollutionKey(key)) {
      setKey(dest, key, source[key], copyUndefined, makeCopyOfSimpleObjects);
    }
  }
};
var _mergedEqual = (a, b, topLevelSkipKey) => {
  if (a === b) {
    return true;
  }
  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
    return false;
  }
  const aIsArr = Array.isArray(a);
  if (aIsArr !== Array.isArray(b)) {
    return false;
  }
  if (aIsArr) {
    return (0, import_ag_stack._areEqual)(a, b);
  }
  if (!isPlainProto(a) || !isPlainProto(b)) {
    return false;
  }
  const aKeys = Object.keys(a);
  const bKeys = Object.keys(b);
  const aLen = aKeys.length;
  const bLen = bKeys.length;
  if (topLevelSkipKey === void 0) {
    if (aLen !== bLen) {
      return false;
    }
    for (let i = 0; i < aLen; ++i) {
      const k = aKeys[i];
      if (!(k in b) || !_mergedEqual(a[k], b[k])) {
        return false;
      }
    }
    return true;
  }
  let aSkip = 0;
  for (let i = 0; i < aLen; ++i) {
    const k = aKeys[i];
    if (aSkip === 0 && k === topLevelSkipKey) {
      aSkip = 1;
      continue;
    }
    if (!(k in b) || !_mergedEqual(a[k], b[k])) {
      return false;
    }
  }
  const bSkip = topLevelSkipKey in b ? 1 : 0;
  return aLen - aSkip === bLen - bSkip;
};

// packages/ag-grid-community/src/globalGridOptions.ts
var _GlobalGridOptions = class _GlobalGridOptions {
  /**
   * @param providedOptions
   * @returns Shallow copy of the provided options with global options merged in.
   */
  static applyGlobalGridOptions(providedOptions) {
    if (!_GlobalGridOptions.gridOptions) {
      return { ...providedOptions };
    }
    let mergedGridOps = {};
    _mergeDeep(mergedGridOps, _GlobalGridOptions.gridOptions, true, true);
    if (_GlobalGridOptions.mergeStrategy === "deep") {
      _mergeDeep(mergedGridOps, providedOptions, true, true);
    } else {
      mergedGridOps = { ...mergedGridOps, ...providedOptions };
    }
    if (_GlobalGridOptions.gridOptions.context) {
      mergedGridOps.context = _GlobalGridOptions.gridOptions.context;
    }
    if (providedOptions.context) {
      if (_GlobalGridOptions.mergeStrategy === "deep" && mergedGridOps.context) {
        _mergeDeep(providedOptions.context, mergedGridOps.context, true, true);
      }
      mergedGridOps.context = providedOptions.context;
    }
    return mergedGridOps;
  }
  /**
   * Apply global grid option for a specific option key.
   * If the merge strategy is 'deep' and both global and provided values are objects, they will be merged deeply.
   * Otherwise, the provided value is returned as is.
   * @param optionKey - The key of the grid option to apply.
   * @param providedValue - The value provided to the grid instance.
   * @returns The merged value if applicable, otherwise the provided value.
   */
  static applyGlobalGridOption(optionKey, providedValue) {
    if (_GlobalGridOptions.mergeStrategy === "deep") {
      const globalValue = _getGlobalGridOption(optionKey);
      if (globalValue && typeof globalValue === "object" && typeof providedValue === "object") {
        return _GlobalGridOptions.applyGlobalGridOptions({ [optionKey]: providedValue })[optionKey];
      }
    }
    return providedValue;
  }
};
// eslint-disable-next-line no-restricted-syntax
_GlobalGridOptions.gridOptions = void 0;
// eslint-disable-next-line no-restricted-syntax
_GlobalGridOptions.mergeStrategy = "shallow";
var GlobalGridOptions = _GlobalGridOptions;
function provideGlobalGridOptions(gridOptions, mergeStrategy = "shallow") {
  GlobalGridOptions.gridOptions = gridOptions;
  GlobalGridOptions.mergeStrategy = mergeStrategy;
}
function _getGlobalGridOption(gridOption) {
  return GlobalGridOptions.gridOptions?.[gridOption];
}

// packages/ag-grid-community/src/gridOptionsDefault.ts
var GRID_OPTION_DEFAULTS = {
  suppressContextMenu: false,
  preventDefaultOnContextMenu: false,
  allowContextMenuWithControlKey: false,
  suppressMenuHide: true,
  enableBrowserTooltips: false,
  tooltipTrigger: "hover",
  tooltipShowDelay: 2e3,
  tooltipSwitchShowDelay: 200,
  tooltipHideDelay: 1e4,
  noteTrigger: "hover",
  noteShowDelay: 180,
  noteHideDelay: 220,
  tooltipMouseTrack: false,
  tooltipShowMode: "standard",
  tooltipInteraction: false,
  copyHeadersToClipboard: false,
  copyGroupHeadersToClipboard: false,
  clipboardDelimiter: "	",
  suppressCopyRowsToClipboard: false,
  suppressCopySingleCellRanges: false,
  suppressLastEmptyLineOnPaste: false,
  suppressClipboardPaste: false,
  suppressClipboardApi: false,
  suppressCutToClipboard: false,
  maintainColumnOrder: false,
  enableStrictPivotColumnOrder: false,
  suppressFieldDotNotation: false,
  allowDragFromColumnsToolPanel: false,
  suppressMovableColumns: false,
  suppressColumnMoveAnimation: false,
  suppressMoveWhenColumnDragging: false,
  suppressDragLeaveHidesColumns: false,
  suppressRowGroupHidesColumns: false,
  suppressAutoSize: false,
  autoSizePadding: 20,
  skipHeaderOnAutoSize: false,
  singleClickEdit: false,
  suppressClickEdit: false,
  readOnlyEdit: false,
  stopEditingWhenCellsLoseFocus: false,
  enterNavigatesVertically: false,
  enterNavigatesVerticallyAfterEdit: false,
  enableCellEditingOnBackspace: false,
  undoRedoCellEditing: false,
  undoRedoCellEditingLimit: 10,
  suppressCsvExport: false,
  suppressExcelExport: false,
  cacheQuickFilter: false,
  includeHiddenColumnsInQuickFilter: false,
  excludeChildrenWhenTreeDataFiltering: false,
  enableAdvancedFilter: false,
  includeHiddenColumnsInAdvancedFilter: false,
  enableCharts: false,
  masterDetail: false,
  keepDetailRows: false,
  keepDetailRowsCount: 10,
  detailRowAutoHeight: false,
  tabIndex: 0,
  rowBuffer: 10,
  valueCache: false,
  valueCacheNeverExpires: false,
  enableCellExpressions: false,
  suppressTouch: false,
  suppressFocusAfterRefresh: false,
  suppressBrowserResizeObserver: false,
  suppressPropertyNamesCheck: false,
  suppressChangeDetection: false,
  debug: false,
  suppressLoadingOverlay: false,
  suppressNoRowsOverlay: false,
  pagination: false,
  paginationPageSize: 100,
  paginationPageSizeSelector: true,
  paginationAutoPageSize: false,
  paginateChildRows: false,
  suppressPaginationPanel: false,
  pivotMode: false,
  pivotPanelShow: "never",
  pivotDefaultExpanded: 0,
  pivotSuppressAutoColumn: false,
  suppressExpandablePivotGroups: false,
  functionsReadOnly: false,
  suppressAggFuncInHeader: false,
  alwaysAggregateAtRootLevel: false,
  aggregateOnlyChangedColumns: false,
  suppressAggFilteredOnly: false,
  removePivotHeaderRowWhenSingleValueColumn: false,
  animateRows: true,
  cellFlashDuration: 500,
  cellFadeDuration: 1e3,
  allowShowChangeAfterFilter: false,
  domLayout: "normal",
  ensureDomOrder: false,
  enableRtl: false,
  suppressColumnVirtualisation: false,
  suppressMaxRenderedRowRestriction: false,
  suppressRowVirtualisation: false,
  rowDragManaged: false,
  refreshAfterGroupEdit: false,
  rowDragInsertDelay: 500,
  suppressRowDrag: false,
  suppressMoveWhenRowDragging: false,
  rowDragEntireRow: false,
  rowDragMultiRow: false,
  embedFullWidthRows: false,
  groupDisplayType: "singleColumn",
  groupDefaultExpanded: 0,
  groupMaintainOrder: false,
  groupSelectsChildren: false,
  groupSuppressBlankHeader: false,
  groupSelectsFiltered: false,
  showOpenedGroup: false,
  groupRemoveSingleChildren: false,
  groupRemoveLowestSingleChildren: false,
  groupHideOpenParents: false,
  groupHideColumnsUntilExpanded: false,
  groupAllowUnbalanced: false,
  rowGroupPanelShow: "never",
  suppressMakeColumnVisibleAfterUnGroup: false,
  treeData: false,
  rowGroupPanelSuppressSort: false,
  suppressGroupRowsSticky: false,
  rowModelType: "clientSide",
  asyncTransactionWaitMillis: 50,
  suppressModelUpdateAfterUpdateTransaction: false,
  cacheOverflowSize: 1,
  infiniteInitialRowCount: 1,
  serverSideInitialRowCount: 1,
  cacheBlockSize: 100,
  maxBlocksInCache: -1,
  maxConcurrentDatasourceRequests: 2,
  blockLoadDebounceMillis: 0,
  purgeClosedRowNodes: false,
  serverSideSortAllLevels: false,
  serverSideOnlyRefreshFilteredGroups: false,
  serverSidePivotResultFieldSeparator: "_",
  viewportRowModelPageSize: 5,
  viewportRowModelBufferSize: 5,
  alwaysShowHorizontalScroll: false,
  alwaysShowVerticalScroll: false,
  debounceVerticalScrollbar: false,
  suppressHorizontalScroll: false,
  suppressScrollOnNewData: false,
  suppressScrollWhenPopupsAreOpen: false,
  suppressAnimationFrame: false,
  suppressMiddleClickScrolls: false,
  suppressPreventDefaultOnMouseWheel: false,
  rowMultiSelectWithClick: false,
  suppressRowDeselection: false,
  suppressRowClickSelection: false,
  suppressCellFocus: false,
  suppressHeaderFocus: false,
  suppressMultiRangeSelection: false,
  enableCellTextSelection: false,
  enableRangeSelection: false,
  enableRangeHandle: false,
  enableFillHandle: false,
  fillHandleDirection: "xy",
  suppressClearOnFillReduction: false,
  accentedSort: false,
  unSortIcon: false,
  suppressMultiSort: false,
  alwaysMultiSort: false,
  suppressMaintainUnsortedOrder: false,
  suppressRowHoverHighlight: false,
  suppressRowTransform: false,
  suppressContentVisibilityAuto: true,
  columnHoverHighlight: false,
  deltaSort: false,
  enableGroupEdit: false,
  groupLockGroupColumns: 0,
  serverSideEnableClientSideSort: false,
  suppressServerSideFullWidthLoadingRow: false,
  pivotMaxGeneratedColumns: -1,
  columnMenu: "new",
  reactiveCustomComponents: true,
  suppressSetFilterByDefault: false,
  enableFilterHandlers: false
};

// packages/ag-grid-community/src/utils/number.ts
function _isFiniteNumber(v) {
  return typeof v === "number" && Number.isFinite(v);
}
function _toFiniteNumber(v) {
  const n = Number(v);
  return Number.isFinite(n) ? n : null;
}
function _clamp(value, min, max) {
  return Math.max(min, Math.min(value, max));
}
function _formatNumberCommas(value, getLocaleTextFunc) {
  if (typeof value !== "number") {
    return "";
  }
  const localeTextFunc = getLocaleTextFunc();
  const thousandSeparator = localeTextFunc("thousandSeparator", ",");
  const decimalSeparator = localeTextFunc("decimalSeparator", ".");
  return value.toString().replace(".", decimalSeparator).replace(/(\d)(?=(\d{3})+(?!\d))/g, `$1${thousandSeparator}`);
}

// packages/ag-grid-community/src/baseUrl.ts
var BASE_URL = "https://www.ag-grid.com";

// packages/ag-grid-community/src/utils/log.ts
var import_ag_stack2 = require("ag-stack");
function _logIfDebug(gos, message, ...args) {
  if (gos.get("debug")) {
    console.log("AG Grid: " + message, ...args);
  }
}
function _warnOnce(msg, ...args) {
  (0, import_ag_stack2._doOnce)(() => _consoleWarn(msg, ...args), msg + args?.join(""));
}
function _errorOnce(msg, ...args) {
  (0, import_ag_stack2._doOnce)(() => _consoleError(msg, ...args), msg + args?.join(""));
}
function _consoleError(msg, ...args) {
  console.error("AG Grid: " + msg, ...args);
}
function _consoleWarn(msg, ...args) {
  console.warn("AG Grid: " + msg, ...args);
}

// packages/ag-grid-community/src/modules/moduleRegistry.ts
var allRegisteredModules = /* @__PURE__ */ new Set();
var globalModulesMap = {};
var gridModulesMap = {};
var currentModuleVersion;
var areGridScopedModules = false;
var isUmd = false;
function isValidModuleVersion(module2) {
  const [moduleMajor, moduleMinor] = module2.version.split(".") || [];
  const [currentModuleMajor, currentModuleMinor] = currentModuleVersion.split(".") || [];
  return moduleMajor === currentModuleMajor && moduleMinor === currentModuleMinor;
}
function runVersionChecks(module2) {
  if (!currentModuleVersion) {
    currentModuleVersion = module2.version;
  }
  const errorMsg = (details) => `You are using incompatible versions of AG Grid modules. Major and minor versions should always match across modules. ${details} Please update all modules to the same version.`;
  if (!module2.version) {
    _errorOnce(errorMsg(`'${module2.moduleName}' is incompatible.`));
  } else if (!isValidModuleVersion(module2)) {
    _errorOnce(
      errorMsg(
        `'${module2.moduleName}' is version ${module2.version} but the other modules are version ${currentModuleVersion}.`
      )
    );
  }
  const result = module2.validate?.();
  if (result && !result.isValid) {
    _errorOnce(`${result.message}`);
  }
}
function _registerModule(module2, gridId) {
  runVersionChecks(module2);
  const rowModels = module2.rowModels ?? ["all"];
  allRegisteredModules.add(module2);
  let moduleStore;
  if (gridId !== void 0) {
    areGridScopedModules = true;
    if (gridModulesMap[gridId] === void 0) {
      gridModulesMap[gridId] = {};
    }
    moduleStore = gridModulesMap[gridId];
  } else {
    moduleStore = globalModulesMap;
  }
  for (const rowModel of rowModels) {
    if (moduleStore[rowModel] === void 0) {
      moduleStore[rowModel] = {};
    }
    moduleStore[rowModel][module2.moduleName] = module2;
  }
  if (module2.dependsOn) {
    for (const dependency of module2.dependsOn) {
      _registerModule(dependency, gridId);
    }
  }
}
function _unRegisterGridModules(gridId) {
  delete gridModulesMap[gridId];
}
function _isModuleRegistered(moduleName, gridId, rowModel) {
  const isRegisteredForRowModel = (model) => !!globalModulesMap[model]?.[moduleName] || !!gridModulesMap[gridId]?.[model]?.[moduleName];
  return isRegisteredForRowModel(rowModel) || isRegisteredForRowModel("all");
}
function _areModulesGridScoped() {
  return areGridScopedModules;
}
function _getRegisteredModules(gridId, rowModel) {
  const gridModules = gridModulesMap[gridId] ?? {};
  return [
    ...Object.values(globalModulesMap["all"] ?? {}),
    ...Object.values(gridModules["all"] ?? {}),
    ...Object.values(globalModulesMap[rowModel] ?? {}),
    ...Object.values(gridModules[rowModel] ?? {})
  ];
}
function _getAllRegisteredModules() {
  return new Set(allRegisteredModules);
}
function _getGridRegisteredModules(gridId, rowModel) {
  const gridModules = gridModulesMap[gridId] ?? {};
  return [...Object.values(gridModules["all"] ?? {}), ...Object.values(gridModules[rowModel] ?? {})];
}
function _isUmd() {
  return isUmd;
}
function _setUmd() {
  isUmd = true;
}
var ModuleRegistry = class {
  /**
   * @deprecated v33 Use `registerModules([module])` instead.
   */
  static register(module2) {
    _registerModule(module2, void 0);
  }
  /**
   * Globally register the given modules for all grids.
   * @param modules - modules to register
   */
  static registerModules(modules) {
    for (const module2 of modules) {
      _registerModule(module2, void 0);
    }
  }
};
function _findEnterpriseCoreModule(modules) {
  for (const module2 of modules) {
    if ("setLicenseKey" in module2) {
      return module2;
    }
    if (module2.dependsOn) {
      const found = _findEnterpriseCoreModule(module2.dependsOn);
      if (found) {
        return found;
      }
    }
  }
  return void 0;
}

// packages/ag-grid-community/src/version.ts
var VERSION = "36.0.2";

// packages/ag-grid-community/src/validation/logging.ts
var MAX_URL_LENGTH = 2e3;
var MIN_PARAM_LENGTH = 100;
var VERSION_PARAM_NAME = "_version_";
var getConsoleMessage = null;
var baseDocLink = `${BASE_URL}/javascript-data-grid`;
function provideValidationServiceLogger(logger) {
  getConsoleMessage = logger;
}
function setValidationDocLink(docLink) {
  baseDocLink = docLink;
}
function getErrorParts(id, args, defaultMessage) {
  return getConsoleMessage?.(id, args) ?? [minifiedLog(id, args, defaultMessage)];
}
function getMsgOrDefault(logger, id, args, isWarning, defaultMessage) {
  logger(`${isWarning ? "warning" : "error"} #${id}`, ...getErrorParts(id, args, defaultMessage));
}
function stringifyObject(inputObj) {
  if (!inputObj) {
    return String(inputObj);
  }
  const object = {};
  for (const prop of Object.keys(inputObj)) {
    if (typeof inputObj[prop] !== "object" && typeof inputObj[prop] !== "function") {
      object[prop] = inputObj[prop];
    }
  }
  return JSON.stringify(object);
}
function stringifyValue(value) {
  let output = value;
  if (value instanceof Error) {
    output = value.toString();
  } else if (typeof value === "object") {
    output = stringifyObject(value);
  }
  return output;
}
function toStringWithNullUndefined(str) {
  return str === void 0 ? "undefined" : str === null ? "null" : str;
}
function getParamsUrl(baseUrl, params) {
  return `${baseUrl}?${params.toString()}`;
}
function truncateUrl(baseUrl, params, maxLength) {
  const sortedParams = Array.from(params.entries()).sort((a, b) => b[1].length - a[1].length);
  let url = getParamsUrl(baseUrl, params);
  for (const [key, value] of sortedParams) {
    if (key === VERSION_PARAM_NAME) {
      continue;
    }
    const excessLength = url.length - maxLength;
    if (excessLength <= 0) {
      break;
    }
    const ellipse = "...";
    const truncateAmount = excessLength + ellipse.length;
    const truncatedValue = value.length - truncateAmount > MIN_PARAM_LENGTH ? value.slice(0, value.length - truncateAmount) + ellipse : value.slice(0, MIN_PARAM_LENGTH) + ellipse;
    params.set(key, truncatedValue);
    url = getParamsUrl(baseUrl, params);
  }
  return url;
}
function getErrorLink(errorNum, args) {
  const params = new URLSearchParams();
  params.append(VERSION_PARAM_NAME, VERSION);
  if (args) {
    for (const key of Object.keys(args)) {
      params.append(key, stringifyValue(args[key]));
    }
  }
  const baseUrl = `${baseDocLink}/errors/${errorNum}`;
  const url = getParamsUrl(baseUrl, params);
  return url.length <= MAX_URL_LENGTH ? url : truncateUrl(baseUrl, params, MAX_URL_LENGTH);
}
var minifiedLog = (errorNum, args, defaultMessage) => {
  const errorLink = getErrorLink(errorNum, args);
  const prefix = `${defaultMessage ? defaultMessage + " \n" : ""}Visit ${errorLink}`;
  if (_isUmd()) {
    return prefix;
  }
  return `${prefix}${defaultMessage ? "" : " \n  Alternatively register the ValidationModule to see the full message in the console."}`;
};
function _warn(...args) {
  getMsgOrDefault(_warnOnce, args[0], args[1], true);
}
function _error(...args) {
  getMsgOrDefault(_errorOnce, args[0], args[1], false);
}
function _logPreInitErr(id, args, defaultMessage) {
  getMsgOrDefault(_errorOnce, id, args, false, defaultMessage);
}
function _logPreInitWarn(id, args, defaultMessage) {
  getMsgOrDefault(_warnOnce, id, args, true, defaultMessage);
}
function getErrMsg(defaultMessage, args) {
  const id = args[0];
  return `error #${id} ` + getErrorParts(id, args[1], defaultMessage).join(" ");
}
function _errMsg(...args) {
  return getErrMsg(void 0, args);
}
function _preInitErrMsg(...args) {
  return getErrMsg("\n", args);
}

// packages/ag-grid-community/src/gridOptionsUtils.ts
function isRowModelType(gos, rowModelType) {
  return gos.get("rowModelType") === rowModelType;
}
function _isClientSideRowModel(gos, _rowModel) {
  return isRowModelType(gos, "clientSide");
}
function _isServerSideRowModel(gos, _rowModel) {
  return isRowModelType(gos, "serverSide");
}
function _isDomLayout(gos, domLayout) {
  return gos.get("domLayout") === domLayout;
}
function _isRowSelection(gos) {
  return _getRowSelectionMode(gos) !== void 0;
}
function _isGetRowHeightFunction(gos) {
  return typeof gos.get("getRowHeight") === "function";
}
function _shouldMaintainColumnOrder(gos, isPivotColumns) {
  if (isPivotColumns) {
    return !gos.get("enableStrictPivotColumnOrder");
  }
  return gos.get("maintainColumnOrder");
}
function _isRowNumbers({ gos, formula }) {
  const rowNumbers = gos.get("rowNumbers");
  return rowNumbers || !!formula?.active && rowNumbers !== false;
}
function _getRowHeightForNode(beans, rowNode, allowEstimate = false, defaultRowHeight) {
  const { gos, environment } = beans;
  if (defaultRowHeight == null) {
    defaultRowHeight = environment.getDefaultRowHeight();
  }
  if (_isGetRowHeightFunction(gos)) {
    if (allowEstimate) {
      return { height: defaultRowHeight, estimated: true };
    }
    const params = {
      node: rowNode,
      data: rowNode.data
    };
    const height = gos.getCallback("getRowHeight")(params);
    if (_isFiniteNumber(height)) {
      if (height === 0) {
        _warn(23);
      }
      return { height: Math.max(1, height), estimated: false };
    }
  }
  if (rowNode.detail && gos.get("masterDetail")) {
    return getMasterDetailRowHeight(gos);
  }
  const gridOptionsRowHeight = gos.get("rowHeight");
  const rowHeight = gridOptionsRowHeight && _isFiniteNumber(gridOptionsRowHeight) ? gridOptionsRowHeight : defaultRowHeight;
  return { height: rowHeight, estimated: false };
}
function getMasterDetailRowHeight(gos) {
  if (gos.get("detailRowAutoHeight")) {
    return { height: 1, estimated: false };
  }
  const defaultRowHeight = gos.get("detailRowHeight");
  if (_isFiniteNumber(defaultRowHeight)) {
    return { height: defaultRowHeight, estimated: false };
  }
  return { height: 300, estimated: false };
}
function _getRowHeightAsNumber(beans) {
  const { environment, gos } = beans;
  const gridOptionsRowHeight = gos.get("rowHeight");
  if (!gridOptionsRowHeight || (0, import_ag_stack3._missing)(gridOptionsRowHeight)) {
    return environment.getDefaultRowHeight();
  }
  const rowHeight = environment.refreshRowHeightVariable();
  if (rowHeight !== -1) {
    return rowHeight;
  }
  _warn(24);
  return environment.getDefaultRowHeight();
}
function _getDomData(gos, element, key) {
  const domData = element[gos.getDomDataKey()];
  return domData ? domData[key] : void 0;
}
function _setDomData(gos, element, key, value) {
  const domDataKey = gos.getDomDataKey();
  let domData = element[domDataKey];
  if ((0, import_ag_stack3._missing)(domData)) {
    domData = {};
    element[domDataKey] = domData;
  }
  domData[key] = value;
}
function _isAnimateRows(gos) {
  if (gos.get("ensureDomOrder")) {
    return false;
  }
  return gos.get("animateRows");
}
function _isGroupRowsSticky(gos) {
  return !(gos.get("paginateChildRows") || gos.get("groupHideOpenParents") || _isDomLayout(gos, "print"));
}
function _isColumnsSortingCoupledToGroup(gos) {
  const autoGroupColumnDef = gos.get("autoGroupColumnDef");
  return !autoGroupColumnDef?.comparator && !gos.get("treeData");
}
function _getGroupAggFiltering(gos) {
  const userValue = gos.get("groupAggFiltering");
  if (typeof userValue === "function") {
    return gos.getCallback("groupAggFiltering");
  }
  if (userValue === true) {
    return () => true;
  }
  return void 0;
}
function _getGrandTotalRow(gos) {
  return gos.get("grandTotalRow");
}
function _getGrandTotalPinnedFloat(grandTotalRow) {
  switch (grandTotalRow) {
    case "pinnedTop":
      return "top";
    case "pinnedBottom":
      return "bottom";
    default:
      return null;
  }
}
function _getGroupTotalRowCallback(gos) {
  const userValue = gos.get("groupTotalRow");
  if (typeof userValue === "function") {
    return gos.getCallback("groupTotalRow");
  }
  return () => userValue ?? void 0;
}
function _isGroupMultiAutoColumn(gos) {
  const isHideOpenParents = !!gos.get("groupHideOpenParents");
  if (isHideOpenParents) {
    return true;
  }
  return gos.get("groupDisplayType") === "multipleColumns";
}
function _isGroupHideColumnsUntilExpanded(gos) {
  return _isGroupMultiAutoColumn(gos) && gos.get("groupHideColumnsUntilExpanded") && _isClientSideRowModel(gos);
}
function _isGroupUseEntireRow(gos, pivotMode) {
  if (pivotMode) {
    return false;
  }
  return gos.get("groupDisplayType") === "groupRows";
}
function _isFullWidthGroupRow(gos, node, pivotMode) {
  return !!node.group && !node.footer && _isGroupUseEntireRow(gos, pivotMode);
}
function _getRowIdCallback(gos) {
  const getRowId = gos.getCallback("getRowId");
  if (getRowId === void 0) {
    return getRowId;
  }
  return (params) => {
    let id = getRowId(params);
    if (typeof id !== "string") {
      (0, import_ag_stack3._doOnce)(() => _warn(25, { id }), "getRowIdString");
      id = String(id);
    }
    return id;
  };
}
function _canSkipShowingRowGroup(gos, node) {
  const isSkippingGroups = gos.get("groupHideParentOfSingleChild");
  if (isSkippingGroups === true) {
    return true;
  }
  if (isSkippingGroups === "leafGroupsOnly" && node.leafGroup) {
    return true;
  }
  if (gos.get("groupRemoveSingleChildren")) {
    return true;
  }
  if (gos.get("groupRemoveLowestSingleChildren") && node.leafGroup) {
    return true;
  }
  return false;
}
function _getMaxConcurrentDatasourceRequests(gos) {
  const res = gos.get("maxConcurrentDatasourceRequests");
  return res > 0 ? res : void 0;
}
function _shouldUpdateColVisibilityAfterGroup(gos, isGrouped) {
  const preventVisibilityChanges = gos.get("suppressGroupChangesColumnVisibility");
  if (preventVisibilityChanges === true) {
    return false;
  }
  if (isGrouped && preventVisibilityChanges === "suppressHideOnGroup") {
    return false;
  }
  if (!isGrouped && preventVisibilityChanges === "suppressShowOnUngroup") {
    return false;
  }
  const legacySuppressOnGroup = gos.get("suppressRowGroupHidesColumns");
  if (isGrouped && legacySuppressOnGroup === true) {
    return false;
  }
  const legacySuppressOnUngroup = gos.get("suppressMakeColumnVisibleAfterUnGroup");
  if (!isGrouped && legacySuppressOnUngroup === true) {
    return false;
  }
  return true;
}
function _getCheckboxes(selection) {
  return selection?.checkboxes ?? true;
}
function _getHeaderCheckbox(selection) {
  return selection?.mode === "multiRow" && (selection.headerCheckbox ?? true);
}
function _getCheckboxLocation(rowSelection) {
  if (typeof rowSelection !== "object") {
    return void 0;
  }
  return rowSelection.checkboxLocation ?? "selectionColumn";
}
function _getHideDisabledCheckboxes(selection) {
  return selection?.hideDisabledCheckboxes ?? false;
}
function _isUsingNewRowSelectionAPI(gos) {
  const rowSelection = gos.get("rowSelection");
  return typeof rowSelection !== "string";
}
function _isUsingNewCellSelectionAPI(gos) {
  return gos.get("cellSelection") !== void 0;
}
function _getSuppressMultiRanges(gos) {
  const selection = gos.get("cellSelection");
  const useNewAPI = selection !== void 0;
  if (!useNewAPI) {
    return gos.get("suppressMultiRangeSelection");
  }
  return typeof selection !== "boolean" ? selection?.suppressMultiRanges ?? false : false;
}
function _isCellSelectionEnabled(gos) {
  const selection = gos.get("cellSelection");
  const useNewAPI = selection !== void 0;
  return useNewAPI ? !!selection : gos.get("enableRangeSelection");
}
function _getFillHandle(gos) {
  const selection = gos.get("cellSelection");
  const useNewAPI = selection !== void 0;
  if (!useNewAPI) {
    return {
      mode: "fill",
      setFillValue: gos.get("fillOperation"),
      direction: gos.get("fillHandleDirection"),
      suppressClearOnFillReduction: gos.get("suppressClearOnFillReduction")
    };
  }
  return typeof selection !== "boolean" && selection.handle?.mode === "fill" ? selection.handle : void 0;
}
function _getEnableColumnSelection(gos) {
  const cellSelection = gos.get("cellSelection") ?? false;
  return (typeof cellSelection === "object" && cellSelection.enableColumnSelection) ?? false;
}
function _getEnableClickSelection(gos) {
  const selection = gos.get("rowSelection") ?? "single";
  if (typeof selection === "string") {
    const suppressRowClickSelection = gos.get("suppressRowClickSelection");
    const suppressRowDeselection = gos.get("suppressRowDeselection");
    if (suppressRowClickSelection && suppressRowDeselection) {
      return false;
    } else if (suppressRowClickSelection) {
      return "enableDeselection";
    } else if (suppressRowDeselection) {
      return "enableSelection";
    } else {
      return true;
    }
  }
  return selection.mode === "singleRow" || selection.mode === "multiRow" ? selection.enableClickSelection ?? false : false;
}
function _getEnableSelection(gos) {
  const enableClickSelection = _getEnableClickSelection(gos);
  return enableClickSelection === true || enableClickSelection === "enableSelection";
}
function _getEnableDeselection(gos) {
  const enableClickSelection = _getEnableClickSelection(gos);
  return enableClickSelection === true || enableClickSelection === "enableDeselection";
}
function _getIsRowSelectable(gos) {
  const selection = gos.get("rowSelection");
  if (typeof selection === "string") {
    return gos.get("isRowSelectable");
  }
  return selection?.isRowSelectable;
}
function _getRowSelectionMode(arg) {
  const selection = "beanName" in arg && arg.beanName === "gos" ? arg.get("rowSelection") : arg.rowSelection;
  if (typeof selection === "string") {
    switch (selection) {
      case "multiple":
        return "multiRow";
      case "single":
        return "singleRow";
      default:
        return;
    }
  }
  switch (selection?.mode) {
    case "multiRow":
    case "singleRow":
      return selection.mode;
    default:
      return;
  }
}
function _isMultiRowSelection(arg) {
  const mode = _getRowSelectionMode(arg);
  return mode === "multiRow";
}
function _getEnableSelectionWithoutKeys(gos) {
  const selection = gos.get("rowSelection");
  if (typeof selection === "string") {
    return gos.get("rowMu