@mortenbrudvik/waveui 0.15.0 → 0.17.0

package/dist/components/table/DataGrid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"DataGrid.mjs","names":["useId","useId$1","React","DEFAULT_SELECT_ALL_LABEL","DEFAULT_SELECTION_HEADER_LABEL","createSelectionStore","selected","initial","registered","disabled","enabledCount","selectedEnabled","selectAll","singleMode","initialSingleMode","singleId","rowListeners","selectAllListeners","notify","listener","listeners","getSingleId","first","rowId","onRegistrationChange","previous","updateSelectAll","next","isEnabled","changeRow","wasEnabled","nowEnabled","step","count","counts","subscribeTo","done","items","item","single","createHeaderSlotRegistry","slots","update","nextCell","slot","getCell","cell","DataGridContext","DataGridSortContext","DataGridSectionContext","DataGridHeaderSlotsContext","DataGridHeaderRowHintContext","DataGridItemsContext","DataGridRowIdContext","DataGridRowContext","INERT_CONTEXT","INERT_SORT_CONTEXT","INERT_ROW_CONTEXT","useDataGridContext","reportMissingContext","component","useDataGridRowContext","useDataGridSortContext","EMPTY_ITEMS","toItems","keys","sameItems","a","b","index","renderFlatChild","node","key","columnIdOf","resolveDeprecatedProp","column","warnDuplicateRowId","cellBase","BODY_ROW_CLASSES","isSelectionCellElement","getTablePartKind","DataGridRoot","sortProp","sortColumnProp","sortDirectionProp","selectedItemsProp","rest","props","hasItems","usesSortApi","defaultSort","legacySort","objectMode","setObjectMode","objectCallbacks","legacySortControlled","warnDeprecated","defaultSortColumn","defaultSortDirection","deprecatedSortProps","mixedSortApi","ignoredSortProps","warnOnce","legacyHalves","setLegacyHalves","legacyControlledSort","legacyDefaultSort","controlledSort","initialSort","sortDetailsRef","sort","setSort","useControllable","onSortChange","requestSort","columnId","sortContext","onSelectionChange","legacySelected","selectedKeys","legacyDefaultSelected","defaultSelectedKeys","controlledSelected","defaultSelected","defaultSelectedItems","selectionDetailsRef","setSelectedValue","onSelectedItemsChange","setSelected","selectionMode","store","toggleRow","event","effective","selectedCount","toggleAll","all","enabled","radioName","selectAllLabel","labels","selectionHeaderLabel","context","selectOnRowClick","selectionAppearance","subtleSelection","useGridNavigation","mergedRef","useMergedRefs","ref","gridRef","itemRows","getRowId","sortColumnId","sortDirection","sortCompare","columns","sortedRows","compare","renderColumnsRow","cellKeys","DataGridRow","DataGridCell","itemsContext","columnWithoutId","content","children","flatChildren","flattenChildren","hasChild","isElementOfType","part","generatedHeader","DataGridHeader","DataGridHeaderCell","generatedBody","DataGridBody","isCaption","others","child","footerIndex","bodyIndex","containerClassName","containerLabel","containerLabelledBy","containerRest","containerProps","containerHasRole","droppedContainerName","cn","dataGridClassNames","className","composeEventHandlers","onKeyDown","gridProps","onFocus","onBlur","DataGridSelectionHeaderCell","state","ariaLabel","ariaLabelledBy","ariaDescribedBy","cellProps","checked","stableClassName","dataGridHeaderClassNames","SELECTION_CELL_CLASSES","focusRingInset","TableSelectionControl","controlRef","INERT_HEADER_SLOTS","DataGridSelectionHeaderSlot","cellRef","getIsFirst","initialFirst","getServerIsFirst","isFirst","_disabled","_invisible","_controlRef","_ariaLabel","_ariaLabelledBy","_ariaDescribedBy","withSelectionHeaderSlots","visit","nodes","cells","thead","setThead","isDev","selectionCells","row","sortable","sortedDirection","sortOnButtonClick","button","dataGridHeaderCellClassNames","onClick","TableSortButton","DataGridItemRow","render","rows","renderWithoutItems","renderRows","dataGridBodyClassNames","rowIdProp","itemRowId","section","firstHeaderRowHint","inHeader","selectable","labelId","ownCellProps","hasSelectionCell","selectionDisabled","selectionCellProps","selectionInvisible","ownLabelledBy","ownLabel","selectionLabel","getSelected","isSelected","unregister","unlabelled","handleKeyDown","target","handleClick","isForeignEvent","element","endsTextSelection","labelledBy","idCellIndex","firstCellIndex","firstCell","needsLabel","controlLabelledBy","controlLabel","rowContext","selectionCellElement","DataGridBodySelectionCell","dataGridRowClassNames","forcedColors","DataGridSelectionCell","notSelectable","unseen","rowProps","dataGridSelectionCellClassNames","invisible","markTablePart","dataGridCellClassNames","DataGrid"],"sources":["../../../src/components/table/DataGrid.tsx"],"sourcesContent":["import * as React from 'react';\nimport { cn } from '../../lib/cn';\nimport {\n  dataGridBodyClassNames,\n  dataGridCellClassNames,\n  dataGridClassNames,\n  dataGridHeaderCellClassNames,\n  dataGridHeaderClassNames,\n  dataGridRowClassNames,\n  dataGridSelectionCellClassNames,\n} from '../../lib/classNames';\nimport { flattenChildren, isElementOfType } from '../../lib/children';\nimport { composeEventHandlers } from '../../lib/composeEventHandlers';\nimport {\n  isDev,\n  reportMissingContext,\n  resolveDeprecatedProp,\n  warnDeprecated,\n  warnOnce,\n} from '../../lib/dev';\nimport { endsTextSelection, isForeignEvent } from '../../lib/events';\nimport type { Slot } from '../../lib/slot';\nimport { focusRingInset, forcedColors } from '../../lib/styles';\nimport type { SelectionMode } from '../../lib/types';\nimport { useControllable } from '../../hooks/useControllable';\nimport { useId } from '../../hooks/useId';\nimport { useMergedRefs } from '../../hooks/useMergedRefs';\nimport {\n  SELECTION_CELL_CLASSES,\n  TableSelectionControl,\n  TableSortButton,\n  getTablePartKind,\n  markTablePart,\n} from './Table.shared';\nimport type { SortDirection } from './Table.shared';\nimport { useGridNavigation } from './useGridNavigation';\n\nexport type { SortDirection };\n\n/** The sort state of a DataGrid: the sorted column and its direction. */\nexport interface DataGridSort {\n  /** The `columnId` of the sorted column. */\n  columnId: string;\n  /** The sort direction. */\n  direction: SortDirection;\n}\n\n/** Second argument of `onSortChange` (the `DataGridSort` form): the event behind the sort. */\nexport interface DataGridSortChangeDetails {\n  /** The DOM event behind the sort: the click of the sort button (Enter and Space click it). */\n  event: Event;\n}\n\n/** Second argument of `onSelectedItemsChange`: the event behind the change. */\nexport interface DataGridSelectedItemsChangeDetails {\n  /**\n   * The DOM event behind the change: the click of a selection control (the select-all checkbox\n   * included), or the key press of Space on a row.\n   */\n  event: Event;\n}\n\n/**\n * Defines a column of the DataGrid, typed by the grid's items (`T`): the header cell it renders\n * and, with `items`, the cell of each row. `createTableColumn` builds one with `sortable` resolved.\n * A column with functions (`compare`, `renderCell`, `renderHeaderCell`) cannot be passed from a\n * Server Component to the DataGrid, since functions are not serializable: define such columns in a\n * client component.\n */\nexport interface DataGridColumn<T = unknown> {\n  /**\n   * Unique identifier of the column: the `columnId` of its header cell (and of the grid's sort) and\n   * the React key of its cells. Required in practice: a column without it (and without the\n   * deprecated `id`) cannot sort, with a development warning.\n   */\n  columnId?: string;\n  /**\n   * @deprecated Use `columnId`. Read only when `columnId` is not given, with a development\n   * warning.\n   */\n  id?: string;\n  /** The header content (text or any React node), unless `renderHeaderCell` is given. */\n  label: React.ReactNode;\n  /**\n   * Orders two items of the column, as for `Array.prototype.sort` (negative: `a` first). A column\n   * with `compare` is sortable unless `sortable` is `false`. While the grid's sort names the column\n   * (its own sort, or a controlled `sort`), a grid with `items` renders its rows in this order: a\n   * stable sort of a copy of `items`, so items that compare equal keep their order in `items`,\n   * in both directions (descending negates `compare`). Without `compare` the grid never reorders\n   * the rows: leave it out when the rows arrive sorted (a server-sorted grid).\n   */\n  compare?: (a: T, b: T) => number;\n  /**\n   * Renders the content of the column's cell for one item (rows rendered from `items`). Without\n   * it, the column's cells are empty.\n   */\n  renderCell?: (item: T) => React.ReactNode;\n  /** Renders the header content, in place of `label`. */\n  renderHeaderCell?: () => React.ReactNode;\n  /**\n   * Whether the column's header is a sort button (the header cell carries `aria-sort`).\n   * @default compare !== undefined\n   */\n  sortable?: boolean;\n}\n\n/** The built-in text of a DataGrid, for localization (see `DataGridBaseProps.labels`). */\nexport interface DataGridLabels {\n  /** Accessible name of the select-all checkbox in the header (`selectionMode=\"multiple\"`).\n   * @default 'Select all rows'\n   */\n  selectAll?: string;\n  /**\n   * Visually hidden text of the selection column's header cell (`selectionMode=\"single\"`), which\n   * names that column.\n   * @default 'Selection'\n   */\n  selectionHeader?: string;\n}\n\nconst DEFAULT_SELECT_ALL_LABEL = 'Select all rows';\nconst DEFAULT_SELECTION_HEADER_LABEL = 'Selection';\n\n/**\n * How a selected row of a DataGrid is filled (`selectionAppearance`): `'brand'` with the selected\n * token, `'neutral'` with the subtle selected token, `'none'` not at all.\n */\nexport type DataGridSelectionAppearance = 'brand' | 'neutral' | 'none';\n\n/**\n * The props of a row's selection cell (`DataGrid.Row` `selectionCellProps`), the automatic cell or\n * a `DataGrid.SelectionCell` child (whose own props win).\n */\nexport interface DataGridRowSelectionCellProps {\n  /**\n   * Disables the row's selection control natively. The control is then no focus target of the grid\n   * (the cell takes focus), and neither a row click (`selectOnRowClick`), Space on a cell nor\n   * select-all changes the row's selection: select-all skips it, keeps it as it is, and tells its\n   * state from the other rows. In a header row it disables the select-all checkbox.\n   * @default false\n   */\n  disabled?: boolean;\n  /**\n   * Hides the selection control (it keeps its space and cannot be focused). The row is still\n   * selected by a row click and Space, and tells its state with `aria-selected`.\n   * @default false\n   */\n  invisible?: boolean;\n  /** Class of the selection cell (`<td>`, or the `<th>` of a header row). */\n  className?: string;\n  /**\n   * Accessible name of the selection control, in place of `selectionLabel` and the name taken from\n   * the row's first cell; in a header row, the name of the select-all checkbox.\n   */\n  'aria-label'?: string;\n}\n\n/** Properties for the DataGridSelectionCell sub-component. */\nexport interface DataGridSelectionCellProps\n  extends\n    Omit<React.TdHTMLAttributes<HTMLTableCellElement>, 'children'>,\n    DataGridRowSelectionCellProps {\n  /**\n   * The cell holds no content of its own: the grid renders the selection control (or, in a\n   * single-mode header row, the hidden \"Selection\" header text).\n   */\n  children?: never;\n  /**\n   * Accessible name of the control, in place of `aria-label` and the row's `selectionLabel`.\n   * Routed to the control, as `aria-label` and `aria-describedby` are.\n   */\n  'aria-labelledby'?: string;\n  /** Ref to the selection control (`<input type=\"checkbox\">` or `<input type=\"radio\">`). */\n  controlRef?: React.Ref<HTMLInputElement>;\n  /** Ref to the cell element (`<td>`, or the `<th>` of a header row's select-all). */\n  ref?: React.Ref<HTMLTableCellElement>;\n}\n\n/**\n * The `items` prop of a DataGrid that renders its rows from data, part of every sort form of\n * `DataGridProps` but the 0.4 one. `T` is the type of the items.\n */\nexport interface DataGridItemsProps<T = unknown> {\n  /**\n   * The grid's data, one body row per item, in this order unless the sorted column has `compare`\n   * (see `DataGridColumn.compare`). With `columns` and no `DataGrid.Body` child (or one without\n   * children), the grid renders the rows and cells from the columns; a `DataGrid.Body` whose child\n   * is a render function renders the row of each item. Each row's `rowId` comes from `getRowId`.\n   * The grid reads the array and never changes it. With `items`, `onSortChange` receives a\n   * `DataGridSort` object and `details`, never the 0.4 arguments. `items` may not be `undefined`\n   * unless `sort` or `defaultSort` is given; pass `items={data ?? []}` while loading.\n   */\n  items?: readonly T[];\n}\n\n/** Props of every DataGrid, whatever sort API it uses. `T` is the type of its `items`. */\nexport interface DataGridBaseProps<T = unknown> extends React.HTMLAttributes<HTMLTableElement> {\n  /**\n   * The row id of an item: the `rowId` of its row (for selection), for rows rendered from `items`.\n   * A row's own `rowId` wins. Ids must be unique (a duplicate warns in development).\n   * @default the item's index in `items`, as a string\n   */\n  getRowId?: (item: T) => string;\n  /**\n   * Column definitions. When given and no `DataGrid.Header` child is present, the header row\n   * (including the selection column) is rendered from them: `columnId` becomes the header cell's\n   * `columnId`, `renderHeaderCell()` (else `label`) its content, and `sortable` (by default, having\n   * `compare`) makes it a sort button. With `items` and no `DataGrid.Body` child, the body rows are\n   * rendered from them too: one `DataGrid.Cell` per column, filled by `renderCell`. Those rows\n   * render again whenever the array changes, so keep it stable (defined outside the component, or\n   * memoised).\n   */\n  columns?: readonly DataGridColumn<T>[];\n  /**\n   * Row selection mode. `'multiple'` adds a checkbox column with a \"Select all rows\" header\n   * checkbox; `'single'` adds a radio column (its header reads \"Selection\" to assistive\n   * technology). `labels` localizes both texts.\n   * @default 'none'\n   */\n  selectionMode?: 'none' | SelectionMode;\n  /**\n   * The name of the select-all checkbox and the header text of the selection column, for\n   * localization. Unset members keep their English defaults. Rows are named with their own\n   * `selectionLabel`.\n   */\n  labels?: DataGridLabels;\n  /**\n   * Whether a click on a body row toggles its selection in a selectable grid (single mode: selects\n   * the row alone, or clears it). The row's own `onClick` runs first; calling `preventDefault()`\n   * in it keeps the selection. A click never toggles when it lands on an interactive element in\n   * the row (a link, a button, an input, a label, an element with `tabindex` or a widget role, the\n   * selection control included), comes from a popup portaled from the row (a Menu, a Popover), or\n   * ends a text selection in the row (a drag across its text); nor does a click on a header row\n   * or on a row whose selection is disabled (`selectionCellProps.disabled`). Space on a cell\n   * toggles the row either way.\n   * @default false\n   */\n  selectOnRowClick?: boolean;\n  /**\n   * How a selected row is filled: `'brand'` with the selected token, `'neutral'` with the subtle\n   * selected token, `'none'` not at all (the selection control, `aria-selected` and, in forced\n   * colors, the row's outline still show it). Rendered as `data-selection-appearance` on the grid.\n   * @default 'brand'\n   */\n  selectionAppearance?: DataGridSelectionAppearance;\n  /**\n   * Subtle selection controls: a row's control is transparent while the row is not selected, until\n   * the row is hovered or holds focus, and the select-all checkbox while no row is selected, until\n   * the grid is hovered or holds focus. Forced colors and a coarse pointer (touch) always draw\n   * them; they stay focusable and named. Rendered as `data-subtle-selection` on the grid.\n   * @default false\n   */\n  subtleSelection?: boolean;\n  /**\n   * Controlled selected row ids (`DataGrid.Row` `rowId`). In single mode pass at most one id: with\n   * several, only the first one whose row is rendered is selected (a development warning says so).\n   */\n  selectedItems?: readonly string[];\n  /** Initially selected row ids (uncontrolled). In single mode, at most one (see `selectedItems`). */\n  defaultSelectedItems?: readonly string[];\n  /**\n   * Called with the new selected row ids when the selection changes, then `details` (`{ event }`,\n   * the click or key press behind the change). Ids of rows that are not rendered are left out of\n   * the reported selection and of the select-all state, so the next change drops them. Until that\n   * change an uncontrolled grid still holds such an id: a row re-added with the same `rowId` before\n   * then is shown selected again.\n   */\n  onSelectedItemsChange?: (\n    selectedItems: string[],\n    details?: DataGridSelectedItemsChangeDetails,\n  ) => void;\n  /** @deprecated Use `selectedItems` (an array). A `Set` or an array is accepted. */\n  selectedKeys?: ReadonlySet<string> | readonly string[];\n  /** @deprecated Use `defaultSelectedItems` (an array). A `Set` or an array is accepted. */\n  defaultSelectedKeys?: ReadonlySet<string> | readonly string[];\n  /** @deprecated Use `onSelectedItemsChange`, which receives an array. Both are called. */\n  onSelectionChange?: (keys: Set<string>) => void;\n  /**\n   * Props for the wrapper `<div>` around the `<table>`: a horizontally scrollable container\n   * (`overflow-x-auto`). Use it for its className, style (e.g. a max height) or ref. The wrapper\n   * is not a tab stop (the grid's own cell tab stop scrolls it) and has no role, so its\n   * `aria-label`/`aria-labelledby` are applied only together with a `role` (e.g. `'region'`);\n   * without one they are dropped with a development warning. Name the grid with `aria-label`.\n   */\n  containerProps?: Omit<React.ComponentPropsWithRef<'div'>, 'children'>;\n  /**\n   * DataGrid header, body, and row elements. Optional when `items` and `columns` render the grid;\n   * a generated body is placed after the header and before a `<tfoot>` child.\n   */\n  children?: React.ReactNode;\n  /** Ref to the `<table role=\"grid\">` element. */\n  ref?: React.Ref<HTMLTableElement>;\n}\n\ninterface NoDeprecatedSortProps {\n  sortColumn?: never;\n  defaultSortColumn?: never;\n  sortDirection?: never;\n  defaultSortDirection?: never;\n}\n\n/** The 0.5 sort API, controlled: `sort` + `onSortChange(sort, details)`. */\nexport interface DataGridControlledSortProps extends NoDeprecatedSortProps {\n  /** The controlled sort, or `null` for an unsorted grid. */\n  sort: DataGridSort | null;\n  /** Initial sort while `sort` is not given yet. */\n  defaultSort?: DataGridSort | null;\n  /**\n   * Called with the new sort when a sortable header is activated, then `details` (`{ event }`).\n   * With `items`, the grid orders its rows by the sorted column's `compare` (see\n   * `DataGridColumn.compare`), also while `sort` is controlled; otherwise the consumer orders them.\n   */\n  onSortChange?: (sort: DataGridSort, details?: DataGridSortChangeDetails) => void;\n}\n\n/** The 0.5 sort API, uncontrolled: `defaultSort` (`null` for none) + `onSortChange(sort, details)`. */\nexport interface DataGridUncontrolledSortProps extends NoDeprecatedSortProps {\n  sort?: undefined;\n  /** The initial sort, or `null` for an initially unsorted grid. */\n  defaultSort: DataGridSort | null;\n  /**\n   * Called with the new sort when a sortable header is activated, then `details` (`{ event }`).\n   * With `items`, the grid orders its rows by the sorted column's `compare` (see\n   * `DataGridColumn.compare`); otherwise the consumer orders them.\n   */\n  onSortChange?: (sort: DataGridSort, details?: DataGridSortChangeDetails) => void;\n}\n\n/**\n * The sort props of a grid with `items`: the 0.5 sort API, whether or not `sort` or `defaultSort`\n * is given (unsorted at first without them). The 0.4 positional `onSortChange` and the deprecated\n * sort props do not apply to such a grid.\n */\nexport interface DataGridItemsSortProps<T = unknown>\n  extends DataGridItemsProps<T>, NoDeprecatedSortProps {\n  /** The grid's data (see `DataGridItemsProps.items`). */\n  items: readonly T[];\n  /** The controlled sort, or `null` for an unsorted grid; `undefined` leaves the sort to the grid. */\n  sort?: DataGridSort | null;\n  /** The initial sort while `sort` is not given. */\n  defaultSort?: DataGridSort | null;\n  /**\n   * Called with the new sort when a sortable header is activated, then `details` (`{ event }`).\n   * The grid orders its rows by the sorted column's `compare` (see `DataGridColumn.compare`).\n   */\n  onSortChange?: (sort: DataGridSort, details?: DataGridSortChangeDetails) => void;\n}\n\n/**\n * The 0.4 sort API: `onSortChange(columnId, direction)` and the deprecated `sortColumn`/\n * `sortDirection` props. It applies whenever none of `items`, `sort` and `defaultSort` is given.\n * As in 0.4, the column and the direction can be controlled independently: the half that is not\n * controlled is kept internally and follows every sort request (mixed control, warned in\n * development).\n */\nexport interface DataGridLegacySortProps {\n  /** A grid with `items` uses the 0.5 sort API (`DataGridItemsSortProps`). */\n  items?: undefined;\n  sort?: undefined;\n  defaultSort?: undefined;\n  /**\n   * @deprecated Use `sort` (`{ columnId, direction }` or `null`). Without `sortDirection`, the\n   * direction is kept internally (it toggles on repeated clicks).\n   */\n  sortColumn?: string;\n  /** @deprecated Use `defaultSort`. */\n  defaultSortColumn?: string;\n  /**\n   * @deprecated Use `sort`. Without `sortColumn`, the column is kept internally (it follows the\n   * clicked header, starting from `defaultSortColumn`).\n   */\n  sortDirection?: SortDirection;\n  /** @deprecated Use `defaultSort`. */\n  defaultSortDirection?: SortDirection;\n  /**\n   * Called when a sortable header is activated, with the 0.4 arguments. Pass `items`, `sort` or\n   * `defaultSort` to receive a `DataGridSort` object (and `details`) instead:\n   * `defaultSort={null}` turns the object form on for an initially unsorted grid. A `sort` that is\n   * still `undefined` (e.g. while data loads) does not: pass `sort={sort ?? null}`.\n   *\n   * @example\n   * <DataGrid defaultSort={null} onSortChange={(sort) => setSort(sort)}>…</DataGrid>\n   */\n  onSortChange?: (columnId: string, direction: SortDirection) => void;\n}\n\n/**\n * Properties for the DataGrid component, whose `items` are of type `T`. The sort props form a\n * union: `sort`/`defaultSort` with `onSortChange(sort, details)` (0.5, also the form of every grid\n * with `items`), or the 0.4 form `onSortChange(columnId, direction)` with the deprecated\n * `sortColumn`/`sortDirection`/`defaultSortColumn`/`defaultSortDirection`, for a grid without\n * `items`. The two cannot be mixed.\n */\nexport type DataGridProps<T = unknown> = DataGridBaseProps<T> &\n  (\n    | (DataGridItemsProps<T> & DataGridControlledSortProps)\n    | (DataGridItemsProps<T> & DataGridUncontrolledSortProps)\n    | DataGridItemsSortProps<T>\n    | DataGridLegacySortProps\n  );\n\n/** Properties for the DataGridHeader sub-component. */\nexport interface DataGridHeaderProps extends React.HTMLAttributes<HTMLTableSectionElement> {\n  /**\n   * Header row elements. Each `<tr>` child (also inside a Fragment) gets the selection column's\n   * header cell prepended when the grid is selectable, unless the row holds a\n   * `DataGrid.SelectionCell` (which then is that cell, where it stands); a header row rendered by\n   * another component should be a `DataGrid.Row`, which adds the cell itself. With several header\n   * rows (a grouped header), only the first one gets the \"Select all rows\" control; later rows get\n   * an empty cell.\n   */\n  children: React.ReactNode;\n  /** Ref to the `<thead>` element. */\n  ref?: React.Ref<HTMLTableSectionElement>;\n}\n\n/** Properties for the DataGridHeaderCell sub-component. */\nexport interface DataGridHeaderCellProps extends React.ThHTMLAttributes<HTMLTableCellElement> {\n  /** Column ID used for sort tracking. Required for `sortable`. */\n  columnId?: string;\n  /**\n   * Whether this column can be sorted. The content is rendered inside a `<button>`; the header\n   * cell carries `aria-sort`. Ignored (with a development warning) without `columnId`.\n   * @default false\n   */\n  sortable?: boolean;\n  /**\n   * The glyph a sortable header shows after its content while its column is sorted, in place of\n   * the default arrow (up for ascending, down for descending). It is decorative (`aria-hidden`:\n   * `aria-sort` on the header tells the direction) and carries `data-direction` (`ascending` or\n   * `descending`), so one glyph can be turned by a selector on it. `null` and `undefined` keep the\n   * arrow; `false`, or any value that renders nothing, shows no glyph. A `<button>` or `Button`\n   * element (or a slot object whose `as` is one) is not nested in the sort button: its children\n   * become the glyph and its props are dropped, with a development warning.\n   */\n  sortIcon?: Slot<'span'>;\n  /** Header cell content. */\n  children: React.ReactNode;\n  /** Ref to the `<th>` element. */\n  ref?: React.Ref<HTMLTableCellElement>;\n}\n\n/** Properties for the DataGridBody sub-component, in a grid whose `items` are of type `T`. */\nexport interface DataGridBodyProps<T = unknown> extends Omit<\n  React.HTMLAttributes<HTMLTableSectionElement>,\n  'children'\n> {\n  /**\n   * The body rows: `DataGrid.Row` elements, or a render function called with each item of the\n   * grid's `items` (in the grid's sort order) and the item's index in `items` (its position there,\n   * whatever the sort), which returns the item's `DataGrid.Row`. The grid keys each returned row\n   * by its row id and gives it that id as `rowId` (from `getRowId`), and renders it again only\n   * when its item, its index or the function change (a sort moves the rows). Type the function\n   * by annotating its item parameter (`(person: Person) => …`) or with `DataGrid.Body<Person>`.\n   * Without children, a grid with `items` and `columns` renders the rows from the columns; empty\n   * children are no rows.\n   */\n  children?: React.ReactNode | ((item: T, index: number) => React.ReactNode);\n  /** Ref to the `<tbody>` element. */\n  ref?: React.Ref<HTMLTableSectionElement>;\n}\n\n/** Properties for the DataGridRow sub-component. */\nexport interface DataGridRowProps extends React.HTMLAttributes<HTMLTableRowElement> {\n  /**\n   * Unique identifier for this row, used for selection (rows that share one are selected together;\n   * a duplicate warns in development). A selectable grid renders no selection control (and warns\n   * in development) for a row without it. A row rendered from the grid's `items` (by\n   * `DataGrid.Body`'s render function or from `columns`) defaults to the item's row id\n   * (`getRowId`).\n   */\n  rowId?: string;\n  /**\n   * Accessible name of the row's selection control. Defaults to the row's first child that is a\n   * `DataGrid.Cell`, `<td>` or `<th>` element (`aria-labelledby`); a cell that another component\n   * renders is not seen, so pass `selectionLabel` when the row's first cell is one. Without such a\n   * child the control is named \"Select row\" (with a development warning). The selection cell's\n   * `aria-label` (`selectionCellProps`, or a `DataGrid.SelectionCell` child's) wins over it.\n   */\n  selectionLabel?: string;\n  /**\n   * Props of the row's selection cell (`disabled`, `invisible`, `className`, `aria-label`): the\n   * cell the row adds first in a selectable grid, or a `DataGrid.SelectionCell` child, whose own\n   * props win (their classes are merged). In a header row they apply to the select-all cell.\n   */\n  selectionCellProps?: DataGridRowSelectionCellProps;\n  /**\n   * DataGrid cell elements. A `DataGrid.SelectionCell` child (also inside a Fragment) is the row's\n   * selection cell, where it stands: the row then adds none.\n   */\n  children: React.ReactNode;\n  /** Ref to the `<tr>` element. */\n  ref?: React.Ref<HTMLTableRowElement>;\n}\n\n/** Properties for the DataGridCell sub-component. */\nexport interface DataGridCellProps extends React.TdHTMLAttributes<HTMLTableCellElement> {\n  /** Cell content. */\n  children: React.ReactNode;\n  /** Ref to the `<td>` element. */\n  ref?: React.Ref<HTMLTableCellElement>;\n}\n\n// ---------------------------------------------------------------------------\n// Selection store\n// ---------------------------------------------------------------------------\n\ntype SelectAllState = 'all' | 'some' | 'none';\n\n/**\n * Selection state shared with the rows through `useSyncExternalStore`, so toggling one row\n * re-renders only that row (and the select-all header cell). The root pushes the committed\n * selection in a layout effect; rows register their ids. The effective selection is always\n * `selected ∩ registered`, derived on read (no pruning effect).\n *\n * @internal Not exported from the package (exported for its unit tests).\n */\nexport interface SelectionStore {\n  /**\n   * Row subscription: notified only when the selection changes. Rows registering or unregistering\n   * notify no row, so adding or removing k of n rows costs O(k), not O(k·n); the one exception is\n   * single mode with several selected ids, where a row registering can move the selected row.\n   */\n  subscribe(listener: () => void): () => void;\n  /**\n   * Select-all subscription: notified only when {@link getSelectAllState} changes (through the\n   * selection or through rows registering and unregistering).\n   */\n  subscribeSelectAll(listener: () => void): () => void;\n  /** Registers a rendered row id; returns the unregister function. */\n  register(rowId: string): () => void;\n  /**\n   * Marks a row's selection disabled (`selectionCellProps.disabled`): select-all skips it and its\n   * state counts only the other rows. Returns the function that undoes it. A row id is disabled\n   * while any row registered with it is.\n   */\n  disable(rowId: string): () => void;\n  /** Whether the row's selection is disabled (see {@link disable}). */\n  isDisabled(rowId: string): boolean;\n  /** How many rendered rows are registered with `rowId` (more than one: a duplicate). */\n  countRegistrations(rowId: string): number;\n  /** Sets the committed selection (layout effect of the root). */\n  setSelected(items: readonly string[]): void;\n  /**\n   * Sets whether the grid is in single mode (layout effect of the root). Only then do rows\n   * registering or unregistering re-check the one selected row of single mode and notify the rows.\n   */\n  setSingleMode(single: boolean): void;\n  /**\n   * Whether the row is selected. With `single`, only one row is: the first selected id (in\n   * selection order) whose row is registered, else the first selected id (before any row\n   * registered: the server render and the first client render).\n   */\n  isSelected(rowId: string, single?: boolean): boolean;\n  /**\n   * Whether all, some or none of the registered rows whose selection is not disabled are selected\n   * (`'none'` without such rows). O(1).\n   */\n  getSelectAllState(): SelectAllState;\n  /** Registered row ids in registration order. */\n  getRegistered(): string[];\n  /** `items` restricted to registered rows (order of `items`). */\n  prune(items: readonly string[]): string[];\n}\n\n/**\n * Creates the {@link SelectionStore} of one DataGrid.\n *\n * @internal Not exported from the package (exported for its unit tests).\n */\nexport function createSelectionStore(\n  initial: readonly string[],\n  initialSingleMode = false,\n): SelectionStore {\n  let selected: ReadonlySet<string> = new Set(initial);\n  /** Registered row id -> number of rows registered with it. */\n  const registered = new Map<string, number>();\n  /** Row id -> number of `disable` calls in effect for it. */\n  const disabled = new Map<string, number>();\n  /** Registered row ids whose selection is not disabled: the rows select-all changes. */\n  let enabledCount = 0;\n  /** How many of those are selected (kept up to date, so select-all is O(1)). */\n  let selectedEnabled = 0;\n  let selectAll: SelectAllState = 'none';\n  let singleMode = initialSingleMode;\n  /** The one selected row of single mode (see `isSelected`); `undefined`: not computed yet. */\n  let singleId: string | null | undefined;\n  const rowListeners = new Set<() => void>();\n  const selectAllListeners = new Set<() => void>();\n\n  const notify = (listeners: Set<() => void>) => {\n    for (const listener of Array.from(listeners)) listener();\n  };\n\n  /** Computed on read: O(selected ids) once per change, and only in single mode. */\n  const getSingleId = (): string | null => {\n    if (singleId !== undefined) return singleId;\n    let first: string | null = null;\n    for (const rowId of selected) {\n      if (registered.has(rowId)) {\n        first = rowId;\n        break;\n      }\n      first ??= rowId;\n    }\n    singleId = first;\n    return first;\n  };\n\n  /**\n   * A row id registered or unregistered. With several selected ids, the one selected row of\n   * single mode can move: in single mode it is re-checked and the rows are notified if it moved.\n   */\n  const onRegistrationChange = (rowId: string) => {\n    if (selected.size < 2 || !selected.has(rowId)) return;\n    const previous = singleId;\n    singleId = undefined;\n    if (singleMode && getSingleId() !== previous) notify(rowListeners);\n  };\n\n  const updateSelectAll = () => {\n    const next: SelectAllState =\n      selectedEnabled === 0 ? 'none' : selectedEnabled === enabledCount ? 'all' : 'some';\n    if (next === selectAll) return;\n    selectAll = next;\n    notify(selectAllListeners);\n  };\n\n  const isEnabled = (rowId: string) => registered.has(rowId) && !disabled.has(rowId);\n\n  /**\n   * Runs `change` (a registration or a `disable` of `rowId`) and keeps the counts of select-all in\n   * step with whether the row is enabled before and after it.\n   */\n  const changeRow = (rowId: string, change: () => void) => {\n    const wasEnabled = isEnabled(rowId);\n    change();\n    const nowEnabled = isEnabled(rowId);\n    if (wasEnabled === nowEnabled) return;\n    const step = nowEnabled ? 1 : -1;\n    enabledCount += step;\n    if (selected.has(rowId)) selectedEnabled += step;\n  };\n\n  /** Adds `step` to the count of `rowId` in `counts`, deleting it at zero. */\n  const count = (counts: Map<string, number>, rowId: string, step: 1 | -1) => {\n    const next = (counts.get(rowId) ?? 0) + step;\n    if (next > 0) counts.set(rowId, next);\n    else counts.delete(rowId);\n  };\n\n  const subscribeTo = (listeners: Set<() => void>) => (listener: () => void) => {\n    listeners.add(listener);\n    return () => {\n      listeners.delete(listener);\n    };\n  };\n\n  return {\n    subscribe: subscribeTo(rowListeners),\n    subscribeSelectAll: subscribeTo(selectAllListeners),\n    register(rowId) {\n      const first = !registered.has(rowId);\n      changeRow(rowId, () => count(registered, rowId, 1));\n      updateSelectAll();\n      if (first) onRegistrationChange(rowId);\n      let done = false;\n      return () => {\n        if (done) return;\n        done = true;\n        changeRow(rowId, () => count(registered, rowId, -1));\n        if (registered.has(rowId)) return;\n        updateSelectAll();\n        onRegistrationChange(rowId);\n      };\n    },\n    disable(rowId) {\n      changeRow(rowId, () => count(disabled, rowId, 1));\n      updateSelectAll();\n      let done = false;\n      return () => {\n        if (done) return;\n        done = true;\n        changeRow(rowId, () => count(disabled, rowId, -1));\n        updateSelectAll();\n      };\n    },\n    isDisabled(rowId) {\n      return disabled.has(rowId);\n    },\n    setSelected(items) {\n      const next = new Set(items);\n      if (next.size === selected.size && items.every((item) => selected.has(item))) return;\n      selected = next;\n      singleId = undefined;\n      selectedEnabled = 0;\n      for (const rowId of next) if (isEnabled(rowId)) selectedEnabled += 1;\n      notify(rowListeners);\n      updateSelectAll();\n    },\n    setSingleMode(single) {\n      singleMode = single;\n    },\n    isSelected(rowId, single = false) {\n      return single ? getSingleId() === rowId : selected.has(rowId);\n    },\n    countRegistrations(rowId) {\n      return registered.get(rowId) ?? 0;\n    },\n    getSelectAllState() {\n      return selectAll;\n    },\n    getRegistered() {\n      return Array.from(registered.keys());\n    },\n    prune(items) {\n      return items.filter((item) => registered.has(item));\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Header selection slots\n// ---------------------------------------------------------------------------\n\n/**\n * The selection column's header slots of one `DataGrid.Header`, one per header row. Only the first\n * slot in document order renders the \"Select all rows\" control (the \"Selection\" text in single\n * mode); the others render an empty cell, so a grouped header (several header rows) has one control\n * and every header row keeps the selection column.\n */\ninterface HeaderSlotRegistry {\n  subscribe(listener: () => void): () => void;\n  /** Registers a slot and a getter for its current cell; returns the unregister function. */\n  register(slot: object, getCell: () => Element | null): () => void;\n  /** The first slot in document order, or `null` while no slot is registered. */\n  getFirst(): object | null;\n  /** Re-checks the order: header rows can move without a slot mounting or unmounting. */\n  refresh(): void;\n}\n\nfunction createHeaderSlotRegistry(): HeaderSlotRegistry {\n  const slots = new Map<object, () => Element | null>();\n  const listeners = new Set<() => void>();\n  let first: object | null = null;\n\n  const update = () => {\n    let next: object | null = null;\n    let nextCell: Element | null = null;\n    for (const [slot, getCell] of slots) {\n      const cell = getCell();\n      if (!cell) {\n        // A slot whose cell is being replaced (control <-> empty cell): keep the current order\n        // until the next registration or header commit sees every cell again.\n        if (first !== null && slots.has(first)) return;\n        continue;\n      }\n      if (!nextCell || cell.compareDocumentPosition(nextCell) & Node.DOCUMENT_POSITION_FOLLOWING) {\n        next = slot;\n        nextCell = cell;\n      }\n    }\n    if (next === null) next = slots.keys().next().value ?? null;\n    if (next === first) return;\n    first = next;\n    for (const listener of Array.from(listeners)) listener();\n  };\n\n  return {\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    register(slot, getCell) {\n      slots.set(slot, getCell);\n      update();\n      return () => {\n        slots.delete(slot);\n        update();\n      };\n    },\n    getFirst: () => first,\n    refresh: update,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Contexts\n// ---------------------------------------------------------------------------\n\ninterface DataGridContextValue {\n  selectionMode: 'none' | SelectionMode;\n  store: SelectionStore;\n  /** Toggles one row (single mode: selects it alone, or clears it); `event` goes to `details`. */\n  toggleRow: (rowId: string, event: Event) => void;\n  /** Selects every rendered row, or clears the selection when all are selected. */\n  toggleAll: (event: Event) => void;\n  /** Shared `name` of the single-mode radios (they are kept out of any form with `form=\"\"`). */\n  radioName: string;\n  /** Name of the select-all checkbox (multiple mode). */\n  selectAllLabel: string;\n  /** Hidden header text of the selection column (single mode). */\n  selectionHeaderLabel: string;\n  /** `selectOnRowClick` of the grid. */\n  selectOnRowClick: boolean;\n  /** `selectionAppearance` of the grid. */\n  selectionAppearance: DataGridSelectionAppearance;\n  /** `subtleSelection` of the grid. */\n  subtleSelection: boolean;\n}\n\n/** What a row tells its selection cell, the automatic one or a `DataGrid.SelectionCell` child. */\ninterface DataGridRowContextValue {\n  /** The row's `selectionCellProps`. */\n  selectionCellProps: DataGridRowSelectionCellProps | undefined;\n  /** Whether a `DataGrid.SelectionCell` child was seen (then the row adds no cell of its own). */\n  hasSelectionCell: boolean;\n  /** The row's id; `undefined` for a header row, or a body row without one (no control). */\n  rowId: string | undefined;\n  isSelected: boolean;\n  /** Resolved from the cell's own props and `selectionCellProps`. */\n  disabled: boolean;\n  /** Resolved from the cell's own props and `selectionCellProps`. */\n  invisible: boolean;\n  /** The control's `aria-label`. */\n  ariaLabel: string | undefined;\n  /** The control's `aria-labelledby`. */\n  ariaLabelledBy: string | undefined;\n}\n\ninterface DataGridSortContextValue {\n  sort: DataGridSort | null;\n  /** Sorts by the column (toggling its direction); `event` goes to `details`. */\n  requestSort: (columnId: string, event: Event) => void;\n}\n\ntype DataGridSection = 'header' | 'body';\n\nconst DataGridContext = React.createContext<DataGridContextValue | null>(null);\nconst DataGridSortContext = React.createContext<DataGridSortContextValue | null>(null);\n/** Whether a row is rendered in the header or the body (rows in a header get a header cell). */\nconst DataGridSectionContext = React.createContext<DataGridSection>('body');\n/** The header's selection slots (see {@link HeaderSlotRegistry}). */\nconst DataGridHeaderSlotsContext = React.createContext<HeaderSlotRegistry | null>(null);\n/**\n * Whether the header row below is the header's first row, as far as the header can tell from its\n * children. Only the initial (and server) render uses it; the slots then follow the DOM order.\n */\nconst DataGridHeaderRowHintContext = React.createContext(true);\n\n/** Renders the row of one item of `items` (a `DataGrid.Body` render function, or from `columns`). */\ntype DataGridRenderRow = (item: unknown, index: number) => React.ReactNode;\n\n/** One row of the grid's `items`. */\ninterface DataGridItemRowData {\n  item: unknown;\n  /** The item's index in `items`. */\n  index: number;\n  rowId: string;\n  /** The row's React key: its row id, made unique when the id repeats. */\n  key: string;\n}\n\ninterface DataGridItemsContextValue {\n  /** The rows of `items`, in the order they are rendered; `null` without `items`. */\n  rows: readonly DataGridItemRowData[] | null;\n  /** Renders a row from `columns`; `null` without `items` and `columns`. */\n  renderColumnsRow: DataGridRenderRow | null;\n}\n\n/** The grid's `items`, for `DataGrid.Body` (optional: a body of JSX rows needs none). */\nconst DataGridItemsContext = React.createContext<DataGridItemsContextValue | null>(null);\n/**\n * The row id of the item a body row is rendered for, the default `rowId` of `DataGrid.Row`. The\n * grid resets it, so the rows of a grid nested in a cell do not take the outer row's id.\n */\nconst DataGridRowIdContext = React.createContext<string | null>(null);\n/** The row around a selection cell (see {@link DataGridRowContextValue}). */\nconst DataGridRowContext = React.createContext<DataGridRowContextValue | null>(null);\n\nconst INERT_STORE = createSelectionStore([]);\nconst INERT_CONTEXT: DataGridContextValue = {\n  selectionMode: 'none',\n  store: INERT_STORE,\n  toggleRow: () => {},\n  toggleAll: () => {},\n  radioName: '',\n  selectAllLabel: DEFAULT_SELECT_ALL_LABEL,\n  selectionHeaderLabel: DEFAULT_SELECTION_HEADER_LABEL,\n  selectOnRowClick: false,\n  selectionAppearance: 'brand',\n  subtleSelection: false,\n};\nconst INERT_SORT_CONTEXT: DataGridSortContextValue = { sort: null, requestSort: () => {} };\nconst INERT_ROW_CONTEXT: DataGridRowContextValue = {\n  selectionCellProps: undefined,\n  hasSelectionCell: true,\n  rowId: undefined,\n  isSelected: false,\n  disabled: false,\n  invisible: false,\n  ariaLabel: undefined,\n  ariaLabelledBy: undefined,\n};\n\nfunction useDataGridContext(component: string): DataGridContextValue {\n  const ctx = React.useContext(DataGridContext);\n  if (ctx) return ctx;\n  reportMissingContext(component, 'DataGrid');\n  return INERT_CONTEXT;\n}\n\nfunction useDataGridRowContext(component: string): DataGridRowContextValue {\n  const ctx = React.useContext(DataGridRowContext);\n  if (ctx) return ctx;\n  reportMissingContext(component, 'DataGrid.Row');\n  return INERT_ROW_CONTEXT;\n}\n\nfunction useDataGridSortContext(component: string): DataGridSortContextValue {\n  const ctx = React.useContext(DataGridSortContext);\n  if (ctx) return ctx;\n  reportMissingContext(component, 'DataGrid');\n  return INERT_SORT_CONTEXT;\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nconst EMPTY_ITEMS: readonly string[] = [];\n\nfunction toItems(\n  keys: ReadonlySet<string> | readonly string[] | undefined,\n): readonly string[] | undefined {\n  return keys === undefined ? undefined : Array.from(keys);\n}\n\nfunction sameItems(a: readonly string[], b: readonly string[]): boolean {\n  return a.length === b.length && a.every((item, index) => item === b[index]);\n}\n\n/** A child of {@link flattenChildren} under its flattened key (unique across the flattened list). */\nfunction renderFlatChild({ key, node }: { key: string; node: React.ReactNode }): React.ReactNode {\n  return <React.Fragment key={key}>{node}</React.Fragment>;\n}\n\n/** A column's id: `columnId`, else the deprecated `id` (warned once). */\nfunction columnIdOf<T>(column: DataGridColumn<T>): string | undefined {\n  return resolveDeprecatedProp(\n    'DataGrid',\n    column.columnId,\n    column.id,\n    'columns[].id',\n    'columns[].columnId',\n  );\n}\n\nfunction warnDuplicateRowId(rowId: string): void {\n  warnOnce(\n    `DataGrid:duplicate-rowId:${rowId}`,\n    `DataGrid: several rows share the rowId \"${rowId}\". Row ids must be unique within a ` +\n      'DataGrid; rows with the same rowId are selected and deselected together.',\n  );\n}\n\nconst cellBase = 'px-4 py-3 border-b border-border';\n\n/** A body row: its hover and, per `selectionAppearance`, the fill of a selected row. */\nconst BODY_ROW_CLASSES: Record<DataGridSelectionAppearance, string> = {\n  brand:\n    'hover:bg-subtle-hover data-[selected]:bg-selected transition-colors motion-reduce:transition-none',\n  neutral:\n    'hover:bg-subtle-hover data-[selected]:bg-subtle-selected transition-colors motion-reduce:transition-none',\n  none: 'hover:bg-subtle-hover transition-colors motion-reduce:transition-none',\n};\n\n/** Whether `node` is an element of `DataGrid.SelectionCell` (lazy client references too). */\nfunction isSelectionCellElement(\n  node: React.ReactNode,\n): node is React.ReactElement<DataGridSelectionCellProps> {\n  return getTablePartKind(node) === 'dataGridSelectionCell';\n}\n\n// ---------------------------------------------------------------------------\n// DataGrid\n// ---------------------------------------------------------------------------\n\n// The component-level JSDoc sits on the exported `DataGrid` below.\n//\n// Two call signatures. The first takes only a grid with `items` (`DataGridItemsSortProps`), so an\n// inline `onSortChange={(sort, details) => …}` next to `items` has one contextual type: in the\n// union of the second, `items` cannot tell the members apart while `T` is still being inferred\n// from it. Every other grid, a generic wrapper's `DataGridProps<T>` included, takes the second.\nfunction DataGridRoot<T>(\n  props: DataGridBaseProps<T> & DataGridItemsSortProps<T>,\n): React.JSX.Element;\nfunction DataGridRoot<T = unknown>(props: DataGridProps<T>): React.JSX.Element;\nfunction DataGridRoot<T>(props: DataGridProps<T>) {\n  const {\n    items,\n    getRowId,\n    sort: sortProp,\n    defaultSort,\n    sortColumn: sortColumnProp,\n    defaultSortColumn,\n    sortDirection: sortDirectionProp,\n    defaultSortDirection,\n    onSortChange,\n    selectionMode = 'none',\n    selectedItems: selectedItemsProp,\n    defaultSelectedItems,\n    onSelectedItemsChange,\n    selectedKeys,\n    defaultSelectedKeys,\n    onSelectionChange,\n    labels,\n    selectOnRowClick = false,\n    selectionAppearance = 'brand',\n    subtleSelection = false,\n    columns,\n    containerProps,\n    children,\n    className,\n    onKeyDown,\n    onFocus,\n    onBlur,\n    ref,\n    ...rest\n  } = props;\n\n  // --- sort -----------------------------------------------------------------\n  const hasItems = items !== undefined;\n  /** The 0.5 sort props, which win over the deprecated ones. */\n  const usesSortApi = sortProp !== undefined || defaultSort !== undefined;\n  /**\n   * The 0.4 rules (the deprecated sort props, the positional callback) apply without `items`,\n   * `sort` and `defaultSort`.\n   */\n  const legacySort = !usesSortApi && !hasItems;\n  /** `onSortChange(sort, details)`; sticky, so the form never changes under the consumer. */\n  const [objectMode, setObjectMode] = React.useState(!legacySort);\n  if (!legacySort && !objectMode) setObjectMode(true);\n  const objectCallbacks = objectMode || !legacySort;\n\n  const legacySortControlled = sortColumnProp !== undefined || sortDirectionProp !== undefined;\n  if (sortColumnProp !== undefined) warnDeprecated('DataGrid', 'sortColumn', 'sort');\n  if (sortDirectionProp !== undefined) warnDeprecated('DataGrid', 'sortDirection', 'sort');\n  if (defaultSortColumn !== undefined) {\n    warnDeprecated('DataGrid', 'defaultSortColumn', 'defaultSort');\n  }\n  if (defaultSortDirection !== undefined) {\n    warnDeprecated('DataGrid', 'defaultSortDirection', 'defaultSort');\n  }\n  const deprecatedSortProps =\n    legacySortControlled || defaultSortColumn !== undefined || defaultSortDirection !== undefined;\n  const mixedSortApi = usesSortApi && deprecatedSortProps;\n  /** A grid with `items` (and no `sort`/`defaultSort`) ignores the deprecated sort props. */\n  const ignoredSortProps = !legacySort && !usesSortApi && deprecatedSortProps;\n\n  React.useEffect(() => {\n    if (mixedSortApi) {\n      warnOnce(\n        'DataGrid:mixed-sort',\n        'DataGrid: do not mix `sort`/`defaultSort` with the deprecated `sortColumn`/`sortDirection`/' +\n          '`defaultSortColumn`/`defaultSortDirection`. `sort`/`defaultSort` win.',\n      );\n    } else if (ignoredSortProps) {\n      warnOnce(\n        'DataGrid:items-deprecated-sort',\n        'DataGrid: the deprecated `sortColumn`/`sortDirection`/`defaultSortColumn`/' +\n          '`defaultSortDirection` do not apply to a grid with `items` and are ignored. Pass `sort` ' +\n          'or `defaultSort`.',\n      );\n    }\n  }, [mixedSortApi, ignoredSortProps]);\n  // 0.4 mixed control: `sortColumn` and `sortDirection` are controlled independently. The half the\n  // parent does not control is kept here (seeded from its default) and follows every sort request,\n  // as 0.4 did, so repeated clicks still alternate and aria-sort shows what was reported.\n  React.useEffect(() => {\n    if (!legacySort) return;\n    if (sortColumnProp !== undefined && sortDirectionProp === undefined) {\n      warnOnce(\n        'DataGrid:sortColumn-without-sortDirection',\n        'DataGrid: `sortColumn` is controlled but `sortDirection` is not (mixed control). The ' +\n          'direction is kept internally and toggles on repeated clicks, as in 0.4. Pass `sort` ' +\n          '(`{ columnId, direction }`) to control both.',\n      );\n    } else if (sortDirectionProp !== undefined && sortColumnProp === undefined) {\n      warnOnce(\n        'DataGrid:sortDirection-without-sortColumn',\n        'DataGrid: `sortDirection` is controlled but `sortColumn` is not (mixed control). The ' +\n          'column is kept internally and follows the clicked header, as in 0.4. Pass `sort` ' +\n          '(`{ columnId, direction }`) to control both.',\n      );\n    }\n  }, [legacySort, sortColumnProp, sortDirectionProp]);\n\n  /** The uncontrolled halves of the 0.4 sort props (used while the other half is controlled). */\n  const [legacyHalves, setLegacyHalves] = React.useState<{\n    column: string;\n    direction: SortDirection;\n  }>(() => ({\n    column: defaultSortColumn ?? '',\n    direction: defaultSortDirection ?? 'ascending',\n  }));\n\n  const legacyControlledSort = React.useMemo<DataGridSort | null | undefined>(() => {\n    if (sortColumnProp === undefined && sortDirectionProp === undefined) return undefined;\n    const column = sortColumnProp ?? legacyHalves.column;\n    return column === ''\n      ? null\n      : { columnId: column, direction: sortDirectionProp ?? legacyHalves.direction };\n  }, [sortColumnProp, sortDirectionProp, legacyHalves]);\n\n  const legacyDefaultSort = React.useMemo<DataGridSort | null>(\n    () =>\n      defaultSortColumn\n        ? { columnId: defaultSortColumn, direction: defaultSortDirection ?? 'ascending' }\n        : null,\n    [defaultSortColumn, defaultSortDirection],\n  );\n\n  const controlledSort = legacySort ? legacyControlledSort : sortProp;\n  // A grid with `items` and no `defaultSort` starts unsorted: the deprecated defaults are ignored.\n  let initialSort = legacyDefaultSort;\n  if (defaultSort !== undefined) initialSort = defaultSort;\n  else if (ignoredSortProps) initialSort = null;\n\n  // The details of the sort being requested, set around the setter: useControllable calls its\n  // onChange synchronously inside it, and only on change (the useCheckedValues pattern).\n  const sortDetailsRef = React.useRef<DataGridSortChangeDetails | undefined>(undefined);\n\n  const emitSortChange = (next: DataGridSort | null) => {\n    if (!next) return;\n    if (legacySort) {\n      setLegacyHalves((previous) =>\n        previous.column === next.columnId && previous.direction === next.direction\n          ? previous\n          : { column: next.columnId, direction: next.direction },\n      );\n    }\n    if (!onSortChange) return;\n    if (objectCallbacks) {\n      const objectForm = onSortChange as NonNullable<DataGridItemsSortProps['onSortChange']>;\n      objectForm(next, sortDetailsRef.current);\n    } else {\n      const legacy = onSortChange as (columnId: string, direction: SortDirection) => void;\n      legacy(next.columnId, next.direction);\n    }\n  };\n\n  const [sort, setSort] = useControllable<DataGridSort | null>(\n    controlledSort,\n    initialSort,\n    emitSortChange,\n  );\n\n  const requestSort = React.useCallback(\n    (columnId: string, event: Event) => {\n      sortDetailsRef.current = { event };\n      try {\n        setSort((previous) => ({\n          columnId,\n          direction:\n            previous?.columnId === columnId && previous.direction === 'ascending'\n              ? 'descending'\n              : 'ascending',\n        }));\n      } finally {\n        sortDetailsRef.current = undefined;\n      }\n    },\n    [setSort],\n  );\n\n  const sortContext = React.useMemo<DataGridSortContextValue>(\n    () => ({ sort, requestSort }),\n    [sort, requestSort],\n  );\n\n  // --- selection ------------------------------------------------------------\n  if (onSelectionChange !== undefined) {\n    warnDeprecated('DataGrid', 'onSelectionChange', 'onSelectedItemsChange');\n  }\n  const legacySelected = React.useMemo(() => toItems(selectedKeys), [selectedKeys]);\n  const legacyDefaultSelected = React.useMemo(\n    () => toItems(defaultSelectedKeys),\n    [defaultSelectedKeys],\n  );\n  const controlledSelected = resolveDeprecatedProp(\n    'DataGrid',\n    selectedItemsProp,\n    legacySelected,\n    'selectedKeys',\n    'selectedItems',\n  );\n  const defaultSelected =\n    resolveDeprecatedProp(\n      'DataGrid',\n      defaultSelectedItems,\n      legacyDefaultSelected,\n      'defaultSelectedKeys',\n      'defaultSelectedItems',\n    ) ?? EMPTY_ITEMS;\n\n  // The details of the change being made, set around the setter (as `sortDetailsRef`).\n  const selectionDetailsRef = React.useRef<DataGridSelectedItemsChangeDetails | undefined>(\n    undefined,\n  );\n\n  const emitSelectionChange = (next: readonly string[]) => {\n    onSelectedItemsChange?.([...next], selectionDetailsRef.current);\n    onSelectionChange?.(new Set(next));\n  };\n\n  const [selected, setSelectedValue] = useControllable<readonly string[]>(\n    controlledSelected,\n    defaultSelected,\n    emitSelectionChange,\n  );\n\n  const setSelected = React.useCallback(\n    (event: Event, update: (previous: readonly string[]) => readonly string[]) => {\n      selectionDetailsRef.current = { event };\n      try {\n        setSelectedValue(update);\n      } finally {\n        selectionDetailsRef.current = undefined;\n      }\n    },\n    [setSelectedValue],\n  );\n\n  const single = selectionMode === 'single';\n  const [store] = React.useState(() => createSelectionStore(selected, single));\n  React.useLayoutEffect(() => {\n    store.setSelected(selected);\n  }, [store, selected]);\n  React.useLayoutEffect(() => {\n    store.setSingleMode(single);\n  }, [store, single]);\n\n  const toggleRow = React.useCallback(\n    (rowId: string, event: Event) => {\n      setSelected(event, (previous) => {\n        const effective = store.prune(previous);\n        let next: string[];\n        if (single) {\n          // Single mode shows the first selected row that is rendered (see the store).\n          next = effective[0] === rowId ? [] : [rowId];\n        } else {\n          next = effective.includes(rowId)\n            ? effective.filter((item) => item !== rowId)\n            : [...effective, rowId];\n        }\n        return sameItems(next, previous) ? previous : next;\n      });\n    },\n    [single, setSelected, store],\n  );\n\n  const selectedCount = selected.length;\n  React.useEffect(() => {\n    if (single && selectedCount > 1) {\n      warnOnce(\n        'DataGrid:single-several-selected',\n        `DataGrid: a single-selection grid (selectionMode \"single\") has ${selectedCount} selected row ids; only the first one that is rendered is selected. Pass at most one id in \\`selectedItems\\`/\\`defaultSelectedItems\\`, or use selectionMode=\"multiple\".`,\n      );\n    }\n  }, [single, selectedCount]);\n\n  // Rows whose selection is disabled keep their state: select-all selects (or clears) the others.\n  const toggleAll = React.useCallback(\n    (event: Event) => {\n      setSelected(event, (previous) => {\n        const effective = new Set(store.prune(previous));\n        const all = store.getRegistered();\n        const enabled = all.filter((rowId) => !store.isDisabled(rowId));\n        const allSelected = enabled.length > 0 && enabled.every((rowId) => effective.has(rowId));\n        const next = allSelected\n          ? all.filter((rowId) => store.isDisabled(rowId) && effective.has(rowId))\n          : all.filter((rowId) => !store.isDisabled(rowId) || effective.has(rowId));\n        return sameItems(next, previous) ? previous : next;\n      });\n    },\n    [setSelected, store],\n  );\n\n  const radioName = useId('wave-datagrid-selection');\n  const selectAllLabel = labels?.selectAll ?? DEFAULT_SELECT_ALL_LABEL;\n  const selectionHeaderLabel = labels?.selectionHeader ?? DEFAULT_SELECTION_HEADER_LABEL;\n\n  const context = React.useMemo<DataGridContextValue>(\n    () => ({\n      selectionMode,\n      store,\n      toggleRow,\n      toggleAll,\n      radioName,\n      selectAllLabel,\n      selectionHeaderLabel,\n      selectOnRowClick,\n      selectionAppearance,\n      subtleSelection,\n    }),\n    [\n      selectionMode,\n      store,\n      toggleRow,\n      toggleAll,\n      radioName,\n      selectAllLabel,\n      selectionHeaderLabel,\n      selectOnRowClick,\n      selectionAppearance,\n      subtleSelection,\n    ],\n  );\n\n  // --- keyboard -------------------------------------------------------------\n  const { gridRef, gridProps } = useGridNavigation();\n  const mergedRef = useMergedRefs<HTMLTableElement>(ref, gridRef);\n\n  // --- items ------------------------------------------------------------------\n  const itemRows = React.useMemo<readonly DataGridItemRowData[] | null>(() => {\n    if (items === undefined) return null;\n    const keys = new Set<string>();\n    return items.map((item, index) => {\n      const rowId = getRowId ? getRowId(item) : String(index);\n      // A repeated id (the selection store warns about it) still gets a key of its own.\n      const key = keys.has(rowId) ? `${rowId}\\u0000${index}` : rowId;\n      keys.add(key);\n      return { item, index, rowId, key };\n    });\n  }, [items, getRowId]);\n\n  // Built-in sorting: by the `compare` of the sorted column (controlled `sort` included).\n  const sortColumnId = sort?.columnId;\n  const sortDirection = sort?.direction;\n  const sortCompare = React.useMemo(() => {\n    if (!hasItems || sortColumnId === undefined || !columns) return undefined;\n    return columns.find((column) => columnIdOf(column) === sortColumnId)?.compare;\n  }, [hasItems, sortColumnId, columns]);\n\n  const sortedRows = React.useMemo(() => {\n    if (itemRows === null || !sortCompare) return itemRows;\n    // The rows hold the items as `unknown`; `compare` takes the grid's `T`.\n    const compare = sortCompare as (a: unknown, b: unknown) => number;\n    // A stable sort of a copy (never in place, never reversed): items that compare equal keep\n    // their order in `items` in both directions, since descending negates `compare`.\n    return itemRows\n      .slice()\n      .sort(\n        sortDirection === 'descending'\n          ? (a, b) => -compare(a.item, b.item)\n          : (a, b) => compare(a.item, b.item),\n      );\n  }, [itemRows, sortCompare, sortDirection]);\n\n  // Built only with `items`: the column ids are read (and the deprecated `id` warned) when used.\n  const renderColumnsRow = React.useMemo<DataGridRenderRow | null>(() => {\n    if (!columns || !hasItems) return null;\n    const cellKeys = columns.map((column, index) => columnIdOf(column) ?? index);\n    return (item) => (\n      <DataGridRow>\n        {columns.map((column, index) => (\n          <DataGridCell key={cellKeys[index]}>{column.renderCell?.(item as T)}</DataGridCell>\n        ))}\n      </DataGridRow>\n    );\n  }, [columns, hasItems]);\n\n  const itemsContext = React.useMemo<DataGridItemsContextValue>(\n    () => ({ rows: sortedRows, renderColumnsRow }),\n    [sortedRows, renderColumnsRow],\n  );\n\n  const columnWithoutId =\n    columns?.some((column) => column.columnId === undefined && column.id === undefined) ?? false;\n  React.useEffect(() => {\n    if (columnWithoutId) {\n      warnOnce(\n        'DataGrid:column-without-columnId',\n        'DataGrid: a column in `columns` has no `columnId` (nor the deprecated `id`), so its ' +\n          'header cannot sort. Give every column a unique `columnId`.',\n      );\n    }\n  }, [columnWithoutId]);\n\n  // --- header and body from columns -------------------------------------------\n  let content: React.ReactNode = children;\n  const flatChildren = columns ? flattenChildren(children) : [];\n  const hasChild = (part: unknown) => flatChildren.some(({ node }) => isElementOfType(node, part));\n  const generatedHeader =\n    columns && !hasChild(DataGridHeader) ? (\n      <DataGridHeader key=\"wave-generated-header\">\n        <tr>\n          {columns.map((column, index) => {\n            const columnId = columnIdOf(column);\n            return (\n              <DataGridHeaderCell\n                key={columnId ?? index}\n                columnId={columnId}\n                sortable={column.sortable ?? column.compare !== undefined}\n              >\n                {column.renderHeaderCell ? column.renderHeaderCell() : column.label}\n              </DataGridHeaderCell>\n            );\n          })}\n        </tr>\n      </DataGridHeader>\n    ) : null;\n  // Without children, the body renders the rows from `columns` (see DataGrid.Body).\n  const generatedBody =\n    columns && hasItems && !hasChild(DataGridBody) ? (\n      <DataGridBody key=\"wave-generated-body\" />\n    ) : null;\n  if (generatedHeader || generatedBody) {\n    // A `<caption>` stays the table's first child, before the generated header; a generated body\n    // goes before a `<tfoot>`, which ends the table.\n    const isCaption = ({ node }: { node: React.ReactNode }) => isElementOfType(node, 'caption');\n    const others = flatChildren.filter((child) => !isCaption(child));\n    const footerIndex = generatedBody\n      ? others.findIndex(({ node }) => isElementOfType(node, 'tfoot'))\n      : -1;\n    const bodyIndex = footerIndex >= 0 ? footerIndex : others.length;\n    content = [\n      ...flatChildren.filter(isCaption).map(renderFlatChild),\n      generatedHeader,\n      ...others.slice(0, bodyIndex).map(renderFlatChild),\n      generatedBody,\n      ...others.slice(bodyIndex).map(renderFlatChild),\n    ];\n  }\n\n  const {\n    className: containerClassName,\n    'aria-label': containerLabel,\n    'aria-labelledby': containerLabelledBy,\n    ...containerRest\n  } = containerProps ?? {};\n  // The wrapper has no role of its own, and a name is prohibited on a role-less `<div>`: the\n  // consumer's name is kept only together with a role.\n  const containerHasRole = containerRest.role !== undefined;\n  const droppedContainerName =\n    !containerHasRole && (containerLabel !== undefined || containerLabelledBy !== undefined);\n\n  React.useEffect(() => {\n    if (droppedContainerName) {\n      warnOnce(\n        'DataGrid:container-name-without-role',\n        'DataGrid: `containerProps[\"aria-label\"]`/`[\"aria-labelledby\"]` is ignored because the ' +\n          'wrapper has no role. Name the grid itself (`aria-label` on DataGrid), or pass a ' +\n          '`role` (e.g. \"region\") in `containerProps` too.',\n      );\n    }\n  }, [droppedContainerName]);\n\n  return (\n    <DataGridContext.Provider value={context}>\n      <DataGridSortContext.Provider value={sortContext}>\n        <DataGridItemsContext.Provider value={itemsContext}>\n          {/* Reset for a grid nested in a cell: its rows are not the outer row. */}\n          <DataGridRowContext.Provider value={null}>\n            <DataGridRowIdContext.Provider value={null}>\n              <div\n                {...containerRest}\n                aria-label={containerHasRole ? containerLabel : undefined}\n                aria-labelledby={containerHasRole ? containerLabelledBy : undefined}\n                className={cn(\n                  dataGridClassNames.container,\n                  'overflow-x-auto rounded-md border border-border',\n                  containerClassName,\n                )}\n              >\n                <table\n                  ref={mergedRef}\n                  role=\"grid\"\n                  aria-multiselectable={selectionMode === 'multiple' || undefined}\n                  data-selection-appearance={selectionAppearance}\n                  data-subtle-selection={subtleSelection ? '' : undefined}\n                  className={cn(\n                    dataGridClassNames.root,\n                    'w-full border-separate border-spacing-0',\n                    // The group whose hover or focus draws the subtle select-all checkbox.\n                    subtleSelection && 'group/grid',\n                    className,\n                  )}\n                  {...rest}\n                  onKeyDown={composeEventHandlers(onKeyDown, gridProps.onKeyDown)}\n                  onFocus={composeEventHandlers(onFocus, gridProps.onFocus, {\n                    checkDefaultPrevented: false,\n                  })}\n                  onBlur={composeEventHandlers(onBlur, gridProps.onBlur, {\n                    checkDefaultPrevented: false,\n                  })}\n                >\n                  {content}\n                </table>\n              </div>\n            </DataGridRowIdContext.Provider>\n          </DataGridRowContext.Provider>\n        </DataGridItemsContext.Provider>\n      </DataGridSortContext.Provider>\n    </DataGridContext.Provider>\n  );\n}\nDataGridRoot.displayName = 'DataGrid';\n\n// ---------------------------------------------------------------------------\n// Selection header cell (internal)\n// ---------------------------------------------------------------------------\n\n/**\n * The props of a header row's selection cell: the row's `selectionCellProps`, merged with a\n * `DataGrid.SelectionCell`'s own (whose `ref` is passed as `cellRef`).\n */\ntype HeaderSelectionCellProps = Omit<DataGridSelectionCellProps, 'ref'>;\n\ninterface DataGridSelectionHeaderCellProps {\n  selectionMode: SelectionMode;\n  /** The root class of `DataGrid.SelectionCell`, when the cell is one. */\n  stableClassName?: string;\n  cellProps?: HeaderSelectionCellProps;\n  ref?: React.Ref<HTMLTableCellElement>;\n}\n\nfunction DataGridSelectionHeaderCell({\n  selectionMode,\n  stableClassName,\n  cellProps,\n  ref,\n}: DataGridSelectionHeaderCellProps) {\n  const { store, toggleAll, selectAllLabel, selectionHeaderLabel, subtleSelection } =\n    useDataGridContext('DataGrid.Header');\n  const state = React.useSyncExternalStore(\n    store.subscribeSelectAll,\n    store.getSelectAllState,\n    store.getSelectAllState,\n  );\n  const {\n    className,\n    disabled,\n    invisible,\n    controlRef,\n    'aria-label': ariaLabel,\n    'aria-labelledby': ariaLabelledBy,\n    'aria-describedby': ariaDescribedBy,\n    ...rest\n  } = cellProps ?? {};\n\n  let checked: boolean | 'mixed' = false;\n  if (state === 'all') checked = true;\n  else if (state === 'some') checked = 'mixed';\n\n  return (\n    <th\n      scope=\"col\"\n      {...rest}\n      ref={ref}\n      data-selection-cell=\"\"\n      className={cn(\n        stableClassName,\n        dataGridHeaderClassNames.selectionCell,\n        SELECTION_CELL_CLASSES,\n        'text-start',\n        focusRingInset,\n        className,\n      )}\n    >\n      {selectionMode === 'multiple' ? (\n        <TableSelectionControl\n          ref={controlRef}\n          type=\"checkbox\"\n          aria-label={ariaLabel ?? (ariaLabelledBy === undefined ? selectAllLabel : undefined)}\n          aria-labelledby={ariaLabelledBy}\n          aria-describedby={ariaDescribedBy}\n          checked={checked}\n          disabled={disabled}\n          invisible={invisible}\n          subtle={subtleSelection}\n          reveal=\"grid\"\n          onChange={(event) => toggleAll(event.nativeEvent)}\n          className={dataGridHeaderClassNames.selectAllCheckbox}\n        />\n      ) : (\n        <span className=\"sr-only\">{selectionHeaderLabel}</span>\n      )}\n    </th>\n  );\n}\n\nconst INERT_HEADER_SLOTS: HeaderSlotRegistry = {\n  subscribe: () => () => {},\n  register: () => () => {},\n  getFirst: () => null,\n  refresh: () => {},\n};\n\n/**\n * The selection column's cell of one header row: the select-all header cell in the header's first\n * row (document order), an empty cell in every later row. `initialFirst` is the header's guess from\n * its children, used until the slots are registered (the initial and the server render).\n */\nfunction DataGridSelectionHeaderSlot({\n  selectionMode,\n  initialFirst,\n  stableClassName,\n  cellProps,\n  ref,\n}: DataGridSelectionHeaderCellProps & { initialFirst: boolean }) {\n  const slots = React.useContext(DataGridHeaderSlotsContext) ?? INERT_HEADER_SLOTS;\n  const [slot] = React.useState(() => ({}));\n  const cellRef = React.useRef<HTMLTableCellElement | null>(null);\n  const mergedRef = useMergedRefs<HTMLTableCellElement>(cellRef, ref);\n\n  const getIsFirst = React.useCallback(() => {\n    const first = slots.getFirst();\n    return first === null ? initialFirst : first === slot;\n  }, [slots, slot, initialFirst]);\n  const getServerIsFirst = React.useCallback(() => initialFirst, [initialFirst]);\n  const isFirst = React.useSyncExternalStore(slots.subscribe, getIsFirst, getServerIsFirst);\n\n  React.useLayoutEffect(() => slots.register(slot, () => cellRef.current), [slots, slot]);\n\n  if (isFirst) {\n    return (\n      <DataGridSelectionHeaderCell\n        ref={mergedRef}\n        selectionMode={selectionMode}\n        stableClassName={stableClassName}\n        cellProps={cellProps}\n      />\n    );\n  }\n  // A later header row's cell: none of the control's props apply.\n  const {\n    className,\n    disabled: _disabled,\n    invisible: _invisible,\n    controlRef: _controlRef,\n    'aria-label': _ariaLabel,\n    'aria-labelledby': _ariaLabelledBy,\n    'aria-describedby': _ariaDescribedBy,\n    ...rest\n  } = cellProps ?? {};\n  return (\n    <td\n      {...rest}\n      ref={mergedRef}\n      data-selection-cell=\"\"\n      className={cn(\n        stableClassName,\n        dataGridHeaderClassNames.selectionCell,\n        SELECTION_CELL_CLASSES,\n        focusRingInset,\n        className,\n      )}\n    />\n  );\n}\n\n// ---------------------------------------------------------------------------\n// Sub-components\n// ---------------------------------------------------------------------------\n\n/**\n * Prepends the selection column's header slot (or `null`) to every `<tr>` in `children`, looking\n * inside Fragments, unless the row holds a `DataGrid.SelectionCell` (that cell is the slot), and\n * tells every row whether it is the header's first row: the cells of a `<tr>` and every other\n * element child (a `DataGrid.Row`, or a component that renders one). Every row gets the same child\n * shape in every selection mode, so switching `selectionMode` does not remount the header cells.\n */\nfunction withSelectionHeaderSlots(\n  children: React.ReactNode,\n  selectionMode: 'none' | SelectionMode,\n): React.ReactNode {\n  let first = true;\n  const visit = (nodes: React.ReactNode): React.ReactNode =>\n    React.Children.map(nodes, (child) => {\n      if (isElementOfType<{ children?: React.ReactNode }>(child, React.Fragment)) {\n        return React.cloneElement(child, undefined, visit(child.props.children));\n      }\n      if (!React.isValidElement(child)) return child;\n      const isFirst = first;\n      first = false;\n      if (isElementOfType<{ children?: React.ReactNode }>(child, 'tr')) {\n        const cells = child.props.children;\n        const slot =\n          selectionMode === 'none' ||\n          flattenChildren(cells).some(({ node }) => isSelectionCellElement(node)) ? null : (\n            <DataGridSelectionHeaderSlot selectionMode={selectionMode} initialFirst={isFirst} />\n          );\n        return React.cloneElement(\n          child,\n          undefined,\n          slot,\n          <DataGridHeaderRowHintContext.Provider value={isFirst}>\n            {cells}\n          </DataGridHeaderRowHintContext.Provider>,\n        );\n      }\n      return (\n        <DataGridHeaderRowHintContext.Provider value={isFirst}>\n          {child}\n        </DataGridHeaderRowHintContext.Provider>\n      );\n    });\n  return visit(children);\n}\n\n/**\n * The grid's `<thead>`. When the grid is selectable, it prepends the selection column's header\n * cell to each `<tr>` child, also inside a Fragment, unless the row holds a\n * `DataGrid.SelectionCell`: the first header row gets the \"Select all rows\" checkbox (multiple\n * mode) or the \"Selection\" header (single mode; DataGrid's `labels` localizes both), later rows of\n * a grouped header an empty cell. A header row rendered by another component cannot get it (a\n * development warning says so): use `DataGrid.Row` for such a row, which adds the cell itself.\n */\nconst DataGridHeader = ({ children, className, ref, ...rest }: DataGridHeaderProps) => {\n  const { selectionMode } = useDataGridContext('DataGrid.Header');\n  const [thead, setThead] = React.useState<HTMLTableSectionElement | null>(null);\n  const mergedRef = useMergedRefs<HTMLTableSectionElement>(ref, setThead);\n  const [slots] = React.useState(createHeaderSlotRegistry);\n  const content = withSelectionHeaderSlots(children, selectionMode);\n\n  // Every commit, after the rows' slots registered: header rows can move without a slot mounting.\n  React.useLayoutEffect(() => {\n    slots.refresh();\n  });\n\n  // Every commit: header rows can come from components the header cannot see into.\n  React.useEffect(() => {\n    if (!isDev || !thead || selectionMode === 'none') return;\n    const selectionCells = Array.from(thead.rows, (row) =>\n      Array.from(row.cells).filter((cell) => cell.hasAttribute('data-selection-cell')),\n    );\n    if (\n      selectionCells.some(\n        (cells, index) => cells.length === 0 && thead.rows[index].cells.length > 0,\n      )\n    ) {\n      warnOnce(\n        'DataGrid.Header:missing-selection-cell',\n        'DataGrid.Header: a header row has no selection column header cell, so the header has one ' +\n          'column fewer than the selectable rows. Render header rows as `<tr>` children of ' +\n          'DataGrid.Header (a Fragment is fine), or use `DataGrid.Row` for a header row that ' +\n          'another component renders.',\n      );\n    }\n    if (selectionCells.some((cells) => cells.length > 1)) {\n      warnOnce(\n        'DataGrid.Header:several-selection-cells',\n        'DataGrid.Header: a header row has more than one selection cell. A DataGrid.SelectionCell ' +\n          'rendered by another component is not seen, so the row also gets the automatic cell: ' +\n          'render DataGrid.SelectionCell as a child of the row (a Fragment is fine).',\n      );\n    }\n  });\n\n  return (\n    <DataGridSectionContext.Provider value=\"header\">\n      <DataGridHeaderSlotsContext.Provider value={slots}>\n        <thead\n          ref={mergedRef}\n          className={cn(dataGridHeaderClassNames.root, 'bg-card', className)}\n          {...rest}\n        >\n          {content}\n        </thead>\n      </DataGridHeaderSlotsContext.Provider>\n    </DataGridSectionContext.Provider>\n  );\n};\nDataGridHeader.displayName = 'DataGridHeader';\n\n/**\n * A column header cell. A `sortable` header (with a `columnId`) renders its content inside a\n * `<button type=\"button\">` that toggles the sort, followed by the direction glyph (`sortIcon`)\n * while its column is sorted; the `<th>` carries `aria-sort`. A consumer `onClick` (on the `<th>`)\n * runs before the sort, and calling `preventDefault()` in it cancels the sort (also for\n * Enter/Space on the button, which click it).\n */\nconst DataGridHeaderCell = ({\n  columnId,\n  sortable = false,\n  sortIcon,\n  children,\n  className,\n  onClick,\n  ref,\n  ...rest\n}: DataGridHeaderCellProps) => {\n  const { sort, requestSort } = useDataGridSortContext('DataGrid.HeaderCell');\n  /** The column this header sorts, or `undefined` when it is not sortable. */\n  const sortColumnId = sortable && columnId ? columnId : undefined;\n  const sortedDirection =\n    sortColumnId !== undefined && sort?.columnId === sortColumnId ? sort.direction : null;\n\n  // The sort runs from the `<th>` once the button's click bubbled up to it, composed after the\n  // consumer's `onClick` (C-COMPOSE): the consumer runs first and can cancel with preventDefault().\n  // The sort button is the `<th>`'s only child; clicks elsewhere in the cell do not sort.\n  const sortOnButtonClick = (event: React.MouseEvent<HTMLTableCellElement>) => {\n    const button = event.currentTarget.firstElementChild;\n    if (\n      sortColumnId !== undefined &&\n      button?.localName === 'button' &&\n      button.contains(event.target as Node)\n    ) {\n      requestSort(sortColumnId, event.nativeEvent);\n    }\n  };\n\n  React.useEffect(() => {\n    if (sortable && !columnId) {\n      warnOnce(\n        'DataGrid.HeaderCell:sortable-without-columnId',\n        'DataGrid.HeaderCell: `sortable` needs a `columnId`; the header is rendered as not sortable.',\n      );\n    }\n  }, [sortable, columnId]);\n\n  return (\n    <th\n      ref={ref}\n      scope=\"col\"\n      aria-sort={sortColumnId !== undefined ? (sortedDirection ?? 'none') : undefined}\n      className={cn(\n        dataGridHeaderCellClassNames.root,\n        cellBase,\n        'text-start align-middle font-semibold text-caption-1 uppercase tracking-wider',\n        focusRingInset,\n        sortColumnId !== undefined && 'p-0 hover:bg-subtle-hover',\n        className,\n      )}\n      {...rest}\n      onClick={\n        sortColumnId !== undefined ? composeEventHandlers(onClick, sortOnButtonClick) : onClick\n      }\n    >\n      {sortColumnId !== undefined ? (\n        <TableSortButton\n          component=\"DataGrid.HeaderCell\"\n          direction={sortedDirection}\n          sortIcon={sortIcon}\n          className={dataGridHeaderCellClassNames.button}\n          iconClassName={dataGridHeaderCellClassNames.sortIcon}\n        >\n          {children}\n        </TableSortButton>\n      ) : (\n        <span className=\"inline-flex items-center gap-1\">{children}</span>\n      )}\n    </th>\n  );\n};\nDataGridHeaderCell.displayName = 'DataGridHeaderCell';\n\n/**\n * The row of one item of `items`, under its row id. Memoised, so a grid that renders again (a\n * sort, a parent update) renders the row again only when its item, its index or the render\n * function change.\n */\nconst DataGridItemRow = React.memo(function DataGridItemRow({\n  item,\n  index,\n  rowId,\n  render,\n}: {\n  item: unknown;\n  index: number;\n  rowId: string;\n  render: DataGridRenderRow;\n}) {\n  return (\n    <DataGridRowIdContext.Provider value={rowId}>\n      {render(item, index)}\n    </DataGridRowIdContext.Provider>\n  );\n});\n\n/**\n * The grid's `<tbody>`. Its child can also be a render function, called with each item of the\n * grid's `items` (and its index there) to render the item's row; without children, a grid with\n * `items` and `columns` renders the rows from the columns.\n */\nconst DataGridBody = <T,>({ children, className, ref, ...rest }: DataGridBodyProps<T>) => {\n  const itemsContext = React.useContext(DataGridItemsContext);\n  const rows = itemsContext?.rows ?? null;\n  const hasRenderFunction = typeof children === 'function';\n\n  const renderWithoutItems = hasRenderFunction && rows === null;\n  React.useEffect(() => {\n    if (renderWithoutItems) {\n      warnOnce(\n        'DataGrid.Body:render-without-items',\n        \"DataGrid.Body: a render function child renders one row per item of the DataGrid's \" +\n          '`items`, which is not set, so the body has no rows.',\n      );\n    }\n  }, [renderWithoutItems]);\n\n  const renderRows = (render: DataGridRenderRow | null) =>\n    render &&\n    rows?.map((row) => (\n      <DataGridItemRow\n        key={row.key}\n        item={row.item}\n        index={row.index}\n        rowId={row.rowId}\n        render={render}\n      />\n    ));\n\n  let content: React.ReactNode;\n  if (typeof children === 'function') {\n    // The items are the grid's `T`, which the body cannot see: its own `T` types the function.\n    content = renderRows(children as DataGridRenderRow);\n  } else if (children === undefined) {\n    content = renderRows(itemsContext?.renderColumnsRow ?? null);\n  } else {\n    content = children;\n  }\n\n  return (\n    <DataGridSectionContext.Provider value=\"body\">\n      <tbody ref={ref} className={cn(dataGridBodyClassNames.root, className)} {...rest}>\n        {content}\n      </tbody>\n    </DataGridSectionContext.Provider>\n  );\n};\nDataGridBody.displayName = 'DataGridBody';\n\n/**\n * A grid row. In a selectable grid it starts with a selection cell (checkbox or radio) named\n * after the row's first cell (or `selectionLabel`), unless a `DataGrid.SelectionCell` child is\n * its selection cell; Space on one of its cells toggles the row, and so does a click on the row\n * with the grid's `selectOnRowClick`.\n *\n * The row is the `group/table-row` group whose hover or focus draws a subtle selection control\n * (`subtleSelection`) and the `Table.CellActions` of its cells. A group is matched by any\n * ancestor, so the rows of a grid nested in a cell\n * share it: hovering the outer row also draws the subtle controls of the nested grid (a limit of\n * CSS groups). A Tree in a cell keeps its own rows' group.\n */\nconst DataGridRow = ({\n  rowId: rowIdProp,\n  selectionLabel,\n  selectionCellProps,\n  children,\n  className,\n  onClick,\n  onKeyDown,\n  ref,\n  ...rest\n}: DataGridRowProps) => {\n  const { selectionMode, store, toggleRow, selectOnRowClick, selectionAppearance } =\n    useDataGridContext('DataGrid.Row');\n  // A row rendered for an item of `items` defaults to the item's row id.\n  const itemRowId = React.useContext(DataGridRowIdContext);\n  const rowId = rowIdProp ?? itemRowId ?? undefined;\n  const section = React.useContext(DataGridSectionContext);\n  const firstHeaderRowHint = React.useContext(DataGridHeaderRowHintContext);\n  const inHeader = section === 'header';\n  const selectable = selectionMode !== 'none' && !inHeader;\n  const labelId = useId('wave-datagrid-row-label');\n\n  // The children are always flattened (Fragments too) and rendered under their flattened keys,\n  // whatever the mode, so the keys stay the same when `selectionMode`, `selectionLabel` or `rowId`\n  // change and the cells are not remounted.\n  const flatChildren = flattenChildren(children);\n  // A DataGrid.SelectionCell child is the row's selection cell; its own props win.\n  let ownCellProps: DataGridSelectionCellProps | undefined;\n  for (const { node } of flatChildren) {\n    if (isSelectionCellElement(node)) {\n      ownCellProps = node.props;\n      break;\n    }\n  }\n  const hasSelectionCell = ownCellProps !== undefined;\n  const selectionDisabled = ownCellProps?.disabled ?? selectionCellProps?.disabled ?? false;\n  const selectionInvisible = ownCellProps?.invisible ?? selectionCellProps?.invisible ?? false;\n  const ownLabelledBy = ownCellProps?.['aria-labelledby'];\n  const ownLabel =\n    ownCellProps?.['aria-label'] ?? selectionCellProps?.['aria-label'] ?? selectionLabel;\n\n  const single = selectionMode === 'single';\n  const getSelected = React.useCallback(\n    () => rowId !== undefined && store.isSelected(rowId, single),\n    [rowId, store, single],\n  );\n  // Notified only when the selection changes (in multiple mode, rows registering notify no row).\n  const isSelected = React.useSyncExternalStore(store.subscribe, getSelected, getSelected);\n\n  React.useLayoutEffect(() => {\n    if (rowId === undefined || inHeader) return;\n    const unregister = store.register(rowId);\n    if (isDev && store.countRegistrations(rowId) > 1) warnDuplicateRowId(rowId);\n    return unregister;\n  }, [store, rowId, inHeader]);\n\n  // A row whose selection is disabled is left out of select-all.\n  React.useLayoutEffect(() => {\n    if (rowId === undefined || inHeader || !selectionDisabled) return;\n    return store.disable(rowId);\n  }, [store, rowId, inHeader, selectionDisabled]);\n\n  React.useEffect(() => {\n    if (selectable && rowId === undefined) {\n      warnOnce(\n        'DataGrid.Row:missing-rowId',\n        'DataGrid.Row: a selectable grid needs a `rowId` on every row; this row has no selection control.',\n      );\n    }\n  }, [selectable, rowId]);\n\n  const unlabelled =\n    selectable && rowId !== undefined && ownLabel === undefined && ownLabelledBy === undefined;\n\n  const handleKeyDown = (event: React.KeyboardEvent<HTMLTableRowElement>) => {\n    if (!selectable || rowId === undefined || event.key !== ' ') return;\n    const target = event.target as Element;\n    // Only keys pressed on the row itself or on one of its own cells, never on a nested widget.\n    if (target !== event.currentTarget && target.parentElement !== event.currentTarget) return;\n    // A row whose selection is disabled takes the key too (no page scroll), and stays as it is.\n    event.preventDefault();\n    if (!selectionDisabled) toggleRow(rowId, event.nativeEvent);\n  };\n\n  const handleClick = (event: React.MouseEvent<HTMLTableRowElement>) => {\n    if (!selectOnRowClick || !selectable || rowId === undefined || selectionDisabled) return;\n    const row = event.currentTarget;\n    // The row's own cells carry the grid's tabindex; they are not widgets nested in the row.\n    const nested = isForeignEvent(event, { isOwnPart: (element) => element.parentElement === row });\n    if (nested || endsTextSelection(event)) return;\n    toggleRow(rowId, event.nativeEvent);\n  };\n\n  // Name the selection control after the first cell (its own id, or a generated one).\n  let labelledBy: string | undefined;\n  let idCellIndex = -1;\n  if (unlabelled) {\n    const firstCellIndex = flatChildren.findIndex(({ node }) =>\n      isElementOfType(node, DataGridCell, 'td', 'th'),\n    );\n    if (firstCellIndex >= 0) {\n      const firstCell = flatChildren[firstCellIndex].node as React.ReactElement<{ id?: string }>;\n      labelledBy = firstCell.props.id ?? labelId;\n      if (firstCell.props.id === undefined) idCellIndex = firstCellIndex;\n    }\n  }\n  const content = flatChildren.map(({ key, node }, index) =>\n    renderFlatChild({\n      key,\n      node:\n        index === idCellIndex\n          ? React.cloneElement(node as React.ReactElement<{ id?: string }>, { id: labelId })\n          : node,\n    }),\n  );\n\n  const needsLabel = unlabelled && labelledBy === undefined;\n  React.useEffect(() => {\n    if (needsLabel) {\n      warnOnce(\n        'DataGrid.Row:selection-label',\n        'DataGrid.Row: no child is a `DataGrid.Cell`, `<td>` or `<th>` element, so the row selection control is named \"Select row\". Pass `selectionLabel` (a cell rendered by another component is not seen).',\n      );\n    }\n  }, [needsLabel]);\n\n  // The selection control's name: the cell's own, else the row's first cell, else \"Select row\".\n  const controlLabelledBy = ownLabelledBy ?? labelledBy;\n  const controlLabel = ownLabel ?? (controlLabelledBy === undefined ? 'Select row' : undefined);\n\n  const rowContext = React.useMemo<DataGridRowContextValue>(\n    () => ({\n      selectionCellProps,\n      hasSelectionCell,\n      rowId: selectable ? rowId : undefined,\n      isSelected,\n      disabled: selectionDisabled,\n      invisible: selectionInvisible,\n      ariaLabel: controlLabel,\n      ariaLabelledBy: controlLabelledBy,\n    }),\n    [\n      selectionCellProps,\n      hasSelectionCell,\n      selectable,\n      rowId,\n      isSelected,\n      selectionDisabled,\n      selectionInvisible,\n      controlLabel,\n      controlLabelledBy,\n    ],\n  );\n\n  // The automatic selection cell, first; a DataGrid.SelectionCell child renders it where it stands.\n  let selectionCellElement: React.ReactNode = null;\n  if (!hasSelectionCell && inHeader && selectionMode !== 'none') {\n    selectionCellElement = (\n      <DataGridSelectionHeaderSlot\n        selectionMode={selectionMode}\n        initialFirst={firstHeaderRowHint}\n        cellProps={selectionCellProps}\n      />\n    );\n  } else if (!hasSelectionCell && selectable) {\n    selectionCellElement = <DataGridBodySelectionCell component=\"DataGrid.Row\" />;\n  }\n\n  return (\n    <DataGridRowContext.Provider value={rowContext}>\n      <tr\n        ref={ref}\n        className={cn(\n          dataGridRowClassNames.root,\n          // The group whose hover or focus draws a subtle selection control (its own name: a\n          // Tree in a cell keys its actions on its rows' `group/row`).\n          'group/table-row',\n          !inHeader && BODY_ROW_CLASSES[selectionAppearance],\n          selectable && isSelected && forcedColors.selectedContainer,\n          className,\n        )}\n        aria-selected={selectable ? isSelected : undefined}\n        data-selected={selectable && isSelected ? '' : undefined}\n        {...rest}\n        onClick={composeEventHandlers(onClick, handleClick)}\n        onKeyDown={composeEventHandlers(onKeyDown, handleKeyDown)}\n      >\n        {selectionCellElement}\n        {content}\n      </tr>\n    </DataGridRowContext.Provider>\n  );\n};\nDataGridRow.displayName = 'DataGridRow';\n\n/** Props of {@link DataGridBodySelectionCell}: the cell's own, without what the row resolved. */\ninterface DataGridBodySelectionCellProps extends Omit<\n  DataGridSelectionCellProps,\n  'disabled' | 'invisible' | 'aria-label' | 'aria-labelledby'\n> {\n  /** The public name of the part that renders the cell, for the context errors. */\n  component: string;\n  /** The root class of `DataGrid.SelectionCell`, when the cell is one. */\n  stableClassName?: string;\n}\n\n/**\n * The selection cell of a body row (internal): the row's checkbox (multiple mode) or radio (single\n * mode), the automatic first cell or a `DataGrid.SelectionCell`. Its state, `disabled`,\n * `invisible` and name come from the row.\n */\nfunction DataGridBodySelectionCell({\n  component,\n  stableClassName,\n  className,\n  controlRef,\n  'aria-describedby': ariaDescribedBy,\n  ref,\n  ...rest\n}: DataGridBodySelectionCellProps) {\n  const { selectionMode, toggleRow, radioName, subtleSelection } = useDataGridContext(component);\n  const row = useDataGridRowContext(component);\n  const { rowId } = row;\n  const single = selectionMode === 'single';\n  return (\n    <td\n      role=\"gridcell\"\n      {...rest}\n      ref={ref}\n      data-selection-cell=\"\"\n      className={cn(\n        stableClassName,\n        dataGridRowClassNames.selectionCell,\n        SELECTION_CELL_CLASSES,\n        focusRingInset,\n        row.selectionCellProps?.className,\n        className,\n      )}\n    >\n      {rowId !== undefined && selectionMode !== 'none' && (\n        <TableSelectionControl\n          ref={controlRef}\n          type={single ? 'radio' : 'checkbox'}\n          name={single ? radioName : undefined}\n          // The shared name groups the radios. `form=\"\"` matches no form, so they have no form\n          // owner (still one group: same name, both ownerless) and never add a generated field\n          // to an enclosing form's submission.\n          form={single ? '' : undefined}\n          checked={row.isSelected}\n          disabled={row.disabled}\n          invisible={row.invisible}\n          subtle={subtleSelection}\n          onChange={(event) => toggleRow(rowId, event.nativeEvent)}\n          aria-label={row.ariaLabel}\n          aria-labelledby={row.ariaLabelledBy}\n          aria-describedby={ariaDescribedBy}\n          className={dataGridRowClassNames.selectionControl}\n        />\n      )}\n    </td>\n  );\n}\n\n/**\n * The selection cell of a row, rendered where it stands among the row's cells (the row and the\n * header then add none of their own). In a header row it is the select-all checkbox (multiple\n * mode; the \"Selection\" header text in single mode), the first header row's only, as the\n * automatic cell; in a body row (a `DataGrid.Row`) the row's checkbox or radio. It takes the\n * selection cell props of its row (`selectionCellProps`), its own winning. `aria-label`,\n * `aria-labelledby` and `aria-describedby` go to the control; the other props, `className` and\n * `ref` to the cell. In a grid without selection it renders nothing (with a development warning).\n */\nconst DataGridSelectionCell = ({\n  disabled,\n  invisible,\n  className,\n  'aria-label': ariaLabel,\n  'aria-labelledby': ariaLabelledBy,\n  'aria-describedby': ariaDescribedBy,\n  controlRef,\n  ref,\n  ...rest\n}: DataGridSelectionCellProps) => {\n  const { selectionMode } = useDataGridContext('DataGrid.SelectionCell');\n  const section = React.useContext(DataGridSectionContext);\n  const firstHeaderRowHint = React.useContext(DataGridHeaderRowHintContext);\n  const row = React.useContext(DataGridRowContext);\n  const notSelectable = selectionMode === 'none';\n  // A DataGrid.Row that did not see this cell among its children added its own cell too.\n  const unseen = !notSelectable && row !== null && !row.hasSelectionCell;\n\n  React.useEffect(() => {\n    if (notSelectable) {\n      warnOnce(\n        'DataGrid.SelectionCell:not-selectable',\n        'DataGrid.SelectionCell: the grid has no row selection (`selectionMode` is \"none\"), so the ' +\n          'cell renders nothing. Set `selectionMode` on the DataGrid, or remove the cell.',\n      );\n    }\n  }, [notSelectable]);\n\n  React.useEffect(() => {\n    if (unseen) {\n      warnOnce(\n        'DataGrid.SelectionCell:unseen',\n        'DataGrid.SelectionCell: rendered by another component, so its DataGrid.Row did not see ' +\n          'it and added its own selection cell. Render DataGrid.SelectionCell as a child of ' +\n          'DataGrid.Row (a Fragment is fine).',\n      );\n    }\n  }, [unseen]);\n\n  if (notSelectable) return null;\n  if (section === 'header') {\n    const rowProps = row?.selectionCellProps;\n    return (\n      <DataGridSelectionHeaderSlot\n        ref={ref}\n        selectionMode={selectionMode}\n        initialFirst={firstHeaderRowHint}\n        stableClassName={dataGridSelectionCellClassNames.root}\n        cellProps={{\n          ...rest,\n          className: cn(rowProps?.className, className),\n          disabled: disabled ?? rowProps?.disabled,\n          invisible: invisible ?? rowProps?.invisible,\n          'aria-label': ariaLabel ?? rowProps?.['aria-label'],\n          'aria-labelledby': ariaLabelledBy,\n          'aria-describedby': ariaDescribedBy,\n          controlRef,\n        }}\n      />\n    );\n  }\n  return (\n    <DataGridBodySelectionCell\n      {...rest}\n      ref={ref}\n      component=\"DataGrid.SelectionCell\"\n      stableClassName={dataGridSelectionCellClassNames.root}\n      className={className}\n      controlRef={controlRef}\n      aria-describedby={ariaDescribedBy}\n    />\n  );\n};\nDataGridSelectionCell.displayName = 'DataGridSelectionCell';\nmarkTablePart(DataGridSelectionCell, 'dataGridSelectionCell');\n\n/**\n * A grid cell (`<td>`), focusable through the grid's keyboard navigation. It is the positioning\n * box of a `Table.CellActions` inside it.\n */\nconst DataGridCell = ({ children, className, ref, ...rest }: DataGridCellProps) => (\n  <td\n    ref={ref}\n    role=\"gridcell\"\n    className={cn(\n      dataGridCellClassNames.root,\n      cellBase,\n      'relative text-body-1',\n      focusRingInset,\n      className,\n    )}\n    {...rest}\n  >\n    {children}\n  </td>\n);\nDataGridCell.displayName = 'DataGridCell';\n\nexport {\n  DataGridHeader,\n  DataGridHeaderCell,\n  DataGridBody,\n  DataGridRow,\n  DataGridCell,\n  DataGridSelectionCell,\n};\n\n/**\n * An interactive data table (`role=\"grid\"`) following the APG Grid pattern: one tab stop,\n * arrow-key navigation between cells (Home/End, Ctrl+Home/Ctrl+End, PageUp/PageDown; Up/Down keep\n * the visual column, so a grouped header with spanning cells works), Enter/F2 to interact with a\n * cell's widgets and Escape to return to the cell. A composite widget in a cell (a Toolbar,\n * RadioGroup, TabList, …) is entered with Enter/F2 like a text field; it manages its own tab\n * indexes, so it keeps its own Tab stop. Supports sortable columns (`onSortChange` reports the new\n * sort; a grid with `items` orders its rows by the sorted column's `compare`, otherwise the consumer\n * orders them) and single or multiple row selection with a select-all header checkbox.\n *\n * Selection is made with the row's control, Space on a cell, and, with `selectOnRowClick`, a\n * click on the row. `selectionAppearance` picks the fill of a selected row, `subtleSelection`\n * hides the unchecked controls until their row (or, for select-all, the grid) is hovered or holds\n * focus, and a row's `selectionCellProps` disables, hides or names its control. The selection\n * column comes first; a `DataGrid.SelectionCell` places it elsewhere in a row.\n *\n * The grid is composed from its parts, or rendered from data: with `items` and typed `columns`\n * (`DataGridColumn<T>`, see `createTableColumn`) it renders the header, the rows and the cells\n * itself, and `DataGrid.Body` also takes a render function that returns each item's row. Rows\n * rendered from `items` take their `rowId` from `getRowId` (by default the item's index).\n *\n * Sub-components are available as `DataGrid.Header`, `DataGrid.HeaderCell`, `DataGrid.Body`,\n * `DataGrid.Row`, `DataGrid.Cell` and `DataGrid.SelectionCell` in client components, and as the\n * flat exports `DataGridHeader`, `DataGridHeaderCell`, `DataGridBody`, `DataGridRow`,\n * `DataGridCell` and `DataGridSelectionCell` (the form React Server Components can import).\n */\nexport const DataGrid = /* @__PURE__ */ Object.assign(DataGridRoot, {\n  Header: DataGridHeader,\n  HeaderCell: DataGridHeaderCell,\n  Body: DataGridBody,\n  Row: DataGridRow,\n  Cell: DataGridCell,\n  SelectionCell: DataGridSelectionCell,\n});\n"],"mappings":";;;;;;;;;;;;;;;;AAwHA,IAAMG,IAA2B,mBAC3BC,IAAiC;AAicvC,SAAgBC,EACd,GACA,IAAoB,IACJ;CAChB,IAAIC,IAAgC,IAAI,IAAIC,CAAO,GAE7CC,oBAAa,IAAI,IAAoB,GAErCC,oBAAW,IAAI,IAAoB,GAErCC,IAAe,GAEfC,IAAkB,GAClBC,IAA4B,QAC5BC,IAAaC,GAEbC,GACEC,oBAAe,IAAI,IAAgB,GACnCC,oBAAqB,IAAI,IAAgB,GAEzCC,KAAU,MAA+B;EAC7C,KAAK,IAAMC,KAAY,MAAM,KAAKC,CAAS,GAAG,EAAS;CACzD,GAGMC,UAAmC;EACvC,IAAIN,MAAa,KAAA,GAAW,OAAOA;EACnC,IAAIO,IAAuB;EAC3B,KAAK,IAAMC,KAASjB,GAAU;GAC5B,IAAIE,EAAW,IAAIe,CAAK,GAAG;IACzB,IAAQA;IACR;GACF;GACA,MAAUA;EACZ;EAEA,OADA,IAAWD,GACJA;CACT,GAMME,KAAwB,MAAkB;EAC9C,IAAIlB,EAAS,OAAO,KAAK,CAACA,EAAS,IAAIiB,CAAK,GAAG;EAC/C,IAAME,IAAWV;EAEjB,AADA,IAAW,KAAA,GACPF,KAAcQ,EAAY,MAAMI,KAAUP,EAAOF,CAAY;CACnE,GAEMU,UAAwB;EAC5B,IAAMC,IACJhB,MAAoB,IAAI,SAASA,MAAoBD,IAAe,QAAQ;EAC9E,AAAIiB,MAASf,MACb,IAAYe,GACZT,EAAOD,CAAkB;CAC3B,GAEMW,KAAa,MAAkBpB,EAAW,IAAIe,CAAK,KAAK,CAACd,EAAS,IAAIc,CAAK,GAM3EM,KAAa,GAAe,MAAuB;EACvD,IAAMC,IAAaF,EAAUL,CAAK;EAClC,EAAO;EACP,IAAMQ,IAAaH,EAAUL,CAAK;EAClC,IAAIO,MAAeC,GAAY;EAC/B,IAAMC,IAAOD,IAAa,IAAI;EAE9B,AADA,KAAgBC,GACZ1B,EAAS,IAAIiB,CAAK,MAAG,KAAmBS;CAC9C,GAGMC,KAAS,GAA6B,GAAe,MAAiB;EAC1E,IAAMN,KAAQO,EAAO,IAAIX,CAAK,KAAK,KAAKS;EACxC,AAAIL,IAAO,IAAGO,EAAO,IAAIX,GAAOI,CAAI,IAC/BO,EAAO,OAAOX,CAAK;CAC1B,GAEMY,KAAe,OAAgC,OACnDf,EAAU,IAAID,CAAQ,SACT;EACX,EAAU,OAAOA,CAAQ;CAC3B;CAGF,OAAO;EACL,WAAWgB,EAAYnB,CAAY;EACnC,oBAAoBmB,EAAYlB,CAAkB;EAClD,SAAS,GAAO;GACd,IAAMK,IAAQ,CAACd,EAAW,IAAIe,CAAK;GAGnC,AAFAM,EAAUN,SAAaU,EAAMzB,GAAYe,GAAO,CAAC,CAAC,GAClDG,EAAgB,GACZJ,KAAOE,EAAqBD,CAAK;GACrC,IAAIa,IAAO;GACX,aAAa;IACX,AAAIA,MACJ,IAAO,IACPP,EAAUN,SAAaU,EAAMzB,GAAYe,GAAO,EAAE,CAAC,GAC/C,GAAW,IAAIA,CAAK,MACxBG,EAAgB,GAChBF,EAAqBD,CAAK;GAC5B;EACF;EACA,QAAQ,GAAO;GAEb,AADAM,EAAUN,SAAaU,EAAMxB,GAAUc,GAAO,CAAC,CAAC,GAChDG,EAAgB;GAChB,IAAIU,IAAO;GACX,aAAa;IACX,AAAIA,MACJ,IAAO,IACPP,EAAUN,SAAaU,EAAMxB,GAAUc,GAAO,EAAE,CAAC,GACjDG,EAAgB;GAClB;EACF;EACA,WAAW,GAAO;GAChB,OAAOjB,EAAS,IAAIc,CAAK;EAC3B;EACA,YAAY,GAAO;GACjB,IAAMI,IAAO,IAAI,IAAIU,CAAK;GAC1B,IAAI,IAAK,SAAS/B,EAAS,QAAQ+B,EAAM,OAAO,MAAS/B,EAAS,IAAIgC,CAAI,CAAC,IAG3E;IAFA,IAAWX,GACX,IAAW,KAAA,GACX,IAAkB;IAClB,KAAK,IAAMJ,KAASI,GAAM,AAAIC,EAAUL,CAAK,MAAG,KAAmB;IAEnE,AADAL,EAAOF,CAAY,GACnBU,EAAgB;GAHE;EAIpB;EACA,cAAc,GAAQ;GACpB,IAAaa;EACf;EACA,WAAW,GAAO,IAAS,IAAO;GAChC,OAAOA,IAASlB,EAAY,MAAME,IAAQjB,EAAS,IAAIiB,CAAK;EAC9D;EACA,mBAAmB,GAAO;GACxB,OAAOf,EAAW,IAAIe,CAAK,KAAK;EAClC;EACA,oBAAoB;GAClB,OAAOX;EACT;EACA,gBAAgB;GACd,OAAO,MAAM,KAAKJ,EAAW,KAAK,CAAC;EACrC;EACA,MAAM,GAAO;GACX,OAAO6B,EAAM,QAAQ,MAAS7B,EAAW,IAAI8B,CAAI,CAAC;EACpD;CACF;AACF;AAsBA,SAASE,IAA+C;CACtD,IAAMC,oBAAQ,IAAI,IAAkC,GAC9CrB,oBAAY,IAAI,IAAgB,GAClCE,IAAuB,MAErBoB,UAAe;EACnB,IAAIf,IAAsB,MACtBgB,IAA2B;EAC/B,KAAK,IAAM,CAACC,GAAMC,MAAYJ,GAAO;GACnC,IAAMK,IAAOD,EAAQ;GACrB,IAAI,CAACC,GAAM;IAGT,IAAIxB,MAAU,QAAQmB,EAAM,IAAInB,CAAK,GAAG;IACxC;GACF;GACA,CAAI,CAACqB,KAAYG,EAAK,wBAAwBH,CAAQ,IAAI,KAAK,iCAC7D,IAAOC,GACP,IAAWE;EAEf;EAEA,IADInB,MAAS,SAAM,IAAOc,EAAM,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS,OACnDd,MAASL,GACb;OAAQK;GACR,KAAK,IAAMR,KAAY,MAAM,KAAKC,CAAS,GAAG,EAAS;EAD/C;CAEV;CAEA,OAAO;EACL,UAAU,GAAU;GAElB,OADAA,EAAU,IAAID,CAAQ,SACT;IACX,EAAU,OAAOA,CAAQ;GAC3B;EACF;EACA,SAAS,GAAM,GAAS;GAGtB,OAFAsB,EAAM,IAAIG,GAAMC,CAAO,GACvBH,EAAO,SACM;IAEX,AADAD,EAAM,OAAOG,CAAI,GACjBF,EAAO;GACT;EACF;EACA,gBAAgBpB;EAChB,SAASoB;CACX;AACF;AAsDA,IAAMK,IAAkB7C,EAAM,cAA2C,IAAI,GACvE8C,IAAsB9C,EAAM,cAA+C,IAAI,GAE/E+C,IAAyB/C,EAAM,cAA+B,MAAM,GAEpEgD,IAA6BhD,EAAM,cAAyC,IAAI,GAKhFiD,IAA+BjD,EAAM,cAAc,EAAI,GAuBvDkD,KAAuBlD,EAAM,cAAgD,IAAI,GAKjFmD,KAAuBnD,EAAM,cAA6B,IAAI,GAE9DoD,KAAqBpD,EAAM,cAA8C,IAAI,GAG7EqD,KAAsC;CAC1C,eAAe;CACf,OAHkBlD,EAAqB,CAAC,CAGjC;CACP,iBAAiB,CAAC;CAClB,iBAAiB,CAAC;CAClB,WAAW;CACX,gBAAgBF;CAChB,sBAAsBC;CACtB,kBAAkB;CAClB,qBAAqB;CACrB,iBAAiB;AACnB,GACMoD,IAA+C;CAAE,MAAM;CAAM,mBAAmB,CAAC;AAAE,GACnFC,IAA6C;CACjD,oBAAoB,KAAA;CACpB,kBAAkB;CAClB,OAAO,KAAA;CACP,YAAY;CACZ,UAAU;CACV,WAAW;CACX,WAAW,KAAA;CACX,gBAAgB,KAAA;AAClB;AAEA,SAASC,EAAmB,GAAyC;CAInE,OAHYxD,EAAM,WAAW6C,CACzB,MACJY,EAAqBC,GAAW,UAAU,GACnCL;AACT;AAEA,SAASM,GAAsB,GAA4C;CAIzE,OAHY3D,EAAM,WAAWoD,EACzB,MACJK,EAAqBC,GAAW,cAAc,GACvCH;AACT;AAEA,SAASK,EAAuB,GAA6C;CAI3E,OAHY5D,EAAM,WAAW8C,CACzB,MACJW,EAAqBC,GAAW,UAAU,GACnCJ;AACT;AAMA,IAAMO,KAAiC,CAAC;AAExC,SAASC,GACP,GAC+B;CAC/B,OAAOC,MAAS,KAAA,IAAY,KAAA,IAAY,MAAM,KAAKA,CAAI;AACzD;AAEA,SAASC,GAAU,GAAsB,GAA+B;CACtE,OAAOC,EAAE,WAAWC,EAAE,UAAUD,EAAE,OAAO,GAAM,MAAU7B,MAAS8B,EAAEC,EAAM;AAC5E;AAGA,SAASC,GAAgB,EAAE,QAAK,WAAiE;CAC/F,OAAO,kBAACpE,EAAM,UAAP,EAAA,UAA2BqE,EAAqB,GAA3BC,CAA2B;AACzD;AAGA,SAASC,EAAc,GAA+C;CACpE,OAAOC,EACL,YACAC,EAAO,UACPA,EAAO,IACP,gBACA,oBACF;AACF;AAEA,SAASC,GAAmB,GAAqB;CAC/C,EACE,4BAA4BrD,KAC5B,2CAA2CA,EAAM,4GAEnD;AACF;AAEA,IAAMsD,IAAW,oCAGXC,IAAgE;CACpE,OACE;CACF,SACE;CACF,MAAM;AACR;AAGA,SAASC,EACP,GACwD;CACxD,OAAOC,GAAiBT,CAAI,MAAM;AACpC;AAgBA,SAASU,EAAgB,GAAyB;CAChD,IAAM,EACJ,UACA,aACA,MAAMC,GACN,gBACA,YAAYC,GACZ,sBACA,eAAeC,GACf,yBACA,iBACA,mBAAgB,QAChB,eAAeC,IACf,yBACA,2BACA,iBACA,yBACA,uBACA,YACA,sBAAmB,IACnB,yBAAsB,SACtB,qBAAkB,IAClB,YACA,oBACA,aACA,cACA,cACA,aACA,WACA,SACA,GAAGC,MACDC,GAGEC,IAAWnD,MAAU,KAAA,GAErBoD,IAAcP,MAAa,KAAA,KAAaQ,MAAgB,KAAA,GAKxDC,IAAa,CAACF,KAAe,CAACD,GAE9B,CAACI,GAAYC,KAAiB3F,EAAM,SAAS,CAACyF,CAAU;CAC9D,AAAI,CAACA,KAAc,CAACC,KAAYC,EAAc,EAAI;CAClD,IAAMC,KAAkBF,KAAc,CAACD,GAEjCI,KAAuBZ,MAAmB,KAAA,KAAaC,MAAsB,KAAA;CAMnF,AALID,MAAmB,KAAA,KAAWa,EAAe,YAAY,cAAc,MAAM,GAC7EZ,MAAsB,KAAA,KAAWY,EAAe,YAAY,iBAAiB,MAAM,GACnFC,MAAsB,KAAA,KACxBD,EAAe,YAAY,qBAAqB,aAAa,GAE3DE,MAAyB,KAAA,KAC3BF,EAAe,YAAY,wBAAwB,aAAa;CAElE,IAAMG,KACJJ,MAAwBE,MAAsB,KAAA,KAAaC,MAAyB,KAAA,GAChFE,KAAeX,KAAeU,IAE9BE,IAAmB,CAACV,KAAc,CAACF,KAAeU;CAqBxD,AAnBAjG,EAAM,gBAAgB;EACpB,AAAIkG,KACFE,EACE,uBACA,kKAEF,IACSD,KACTC,EACE,kCACA,qLAGF;CAEJ,GAAG,CAACF,IAAcC,CAAgB,CAAC,GAInCnG,EAAM,gBAAgB;EACpB,AAAKyF,MACDR,MAAmB,KAAA,KAAaC,MAAsB,KAAA,IACxDkB,EACE,6CACA,uNAGF,IACSlB,MAAsB,KAAA,KAAaD,MAAmB,KAAA,KAC/DmB,EACE,6CACA,oNAGF;CAEJ,GAAG;EAACX;EAAYR;EAAgBC;CAAiB,CAAC;CAGlD,IAAM,CAACmB,IAAcC,MAAmBtG,EAAM,gBAGpC;EACR,QAAQ+F,KAAqB;EAC7B,WAAWC,KAAwB;CACrC,EAAE,GAEIO,KAAuBvG,EAAM,cAA+C;EAChF,IAAIiF,MAAmB,KAAA,KAAaC,MAAsB,KAAA,GAAW;EACrE,IAAMT,IAASQ,KAAkBoB,GAAa;EAC9C,OAAO5B,MAAW,KACd,OACA;GAAE,UAAUA;GAAQ,WAAWS,KAAqBmB,GAAa;EAAU;CACjF,GAAG;EAACpB;EAAgBC;EAAmBmB;CAAY,CAAC,GAE9CG,KAAoBxG,EAAM,cAE5B+F,IACI;EAAE,UAAUA;EAAmB,WAAWC,KAAwB;CAAY,IAC9E,MACN,CAACD,GAAmBC,CAAoB,CAC1C,GAEMS,KAAiBhB,IAAac,KAAuBvB,GAEvD0B,KAAcF;CAClB,AAAIhB,MAAgB,KAAA,IACXW,MAAkB,KAAc,QADV,KAAcX;CAK7C,IAAMmB,KAAiB3G,EAAM,OAA8C,KAAA,CAAS,GAqB9E,CAAC4G,IAAMC,MAAWC,EACtBL,IACAC,KArBsB,MAA8B;EACpD,AAAKjF,MACDgE,KACFa,IAAiB,MACf/E,EAAS,WAAWE,EAAK,YAAYF,EAAS,cAAcE,EAAK,YAC7DF,IACA;GAAE,QAAQE,EAAK;GAAU,WAAWA,EAAK;EAAU,CACzD,GAEGsF,MACDnB,KAEFmB,EAAWtF,GAAMkF,GAAe,OAAO,IAGvCI,EAAOtF,EAAK,UAAUA,EAAK,SAAS;CAExC,CAMA,GAEMuF,KAAchH,EAAM,aACvB,GAAkB,MAAiB;EAClC,GAAe,UAAU,EAAE,SAAM;EACjC,IAAI;GACF,IAAS,OAAc;IACrB;IACA,WACEuB,GAAU,aAAa0F,KAAY1F,EAAS,cAAc,cACtD,eACA;GACR,EAAE;EACJ,UAAU;GACR,GAAe,UAAU,KAAA;EAC3B;CACF,GACA,CAACsF,EAAO,CACV,GAEMK,KAAclH,EAAM,eACjB;EAAE;EAAM;CAAY,IAC3B,CAAC4G,IAAMI,EAAW,CACpB;CAGA,AAAIG,OAAsB,KAAA,KACxBrB,EAAe,YAAY,qBAAqB,uBAAuB;CAEzE,IAAMsB,KAAiBpH,EAAM,cAAc8D,GAAQuD,CAAY,GAAG,CAACA,CAAY,CAAC,GAC1EC,KAAwBtH,EAAM,cAC5B8D,GAAQyD,EAAmB,GACjC,CAACA,EAAmB,CACtB,GACMC,KAAqBhD,EACzB,YACAW,IACAiC,IACA,gBACA,eACF,GACMK,KACJjD,EACE,YACAkD,GACAJ,IACA,uBACA,sBACF,KAAKzD,IAGD8D,KAAsB3H,EAAM,OAChC,KAAA,CACF,GAOM,CAACI,IAAUwH,MAAoBd,EACnCU,IACAC,KAP2B,MAA4B;EAEvD,AADAI,KAAwB,CAAC,GAAGpG,CAAI,GAAGkG,GAAoB,OAAO,GAC9DR,KAAoB,IAAI,IAAI1F,CAAI,CAAC;CACnC,CAMA,GAEMqG,KAAc9H,EAAM,aACvB,GAAc,MAA+D;EAC5E,GAAoB,UAAU,EAAE,SAAM;EACtC,IAAI;GACF,GAAiBwC,CAAM;EACzB,UAAU;GACR,GAAoB,UAAU,KAAA;EAChC;CACF,GACA,CAACoF,EAAgB,CACnB,GAEMvF,IAAS0F,MAAkB,UAC3B,CAACC,KAAShI,EAAM,eAAeG,EAAqBC,IAAUiC,CAAM,CAAC;CAI3E,AAHArC,EAAM,sBAAsB;EAC1B,EAAM,YAAYI,EAAQ;CAC5B,GAAG,CAAC4H,GAAO5H,EAAQ,CAAC,GACpBJ,EAAM,sBAAsB;EAC1B,EAAM,cAAcqC,CAAM;CAC5B,GAAG,CAAC2F,GAAO3F,CAAM,CAAC;CAElB,IAAM4F,KAAYjI,EAAM,aACrB,GAAe,MAAiB;EAC/B,GAAYkI,IAAQ,MAAa;GAC/B,IAAMC,IAAYH,EAAM,MAAMzG,CAAQ,GAClCE;GASJ,OARA,AAIEA,IAJEY,IAEK8F,EAAU,OAAO9G,IAAQ,CAAC,IAAI,CAACA,CAAK,IAEpC8G,EAAU,SAAS9G,CAAK,IAC3B8G,EAAU,QAAQ,MAAS/F,MAASf,CAAK,IACzC,CAAC,GAAG8G,GAAW9G,CAAK,GAEnB2C,GAAUvC,GAAMF,CAAQ,IAAIA,IAAWE;EAChD,CAAC;CACH,GACA;EAACY;EAAQyF;EAAaE;CAAK,CAC7B,GAEMI,KAAgBhI,GAAS;CAC/B,EAAM,gBAAgB;EACpB,AAAIiC,KAAU+F,KAAgB,KAC5BhC,EACE,oCACA,kEAAkEgC,GAAc,wKAClF;CAEJ,GAAG,CAAC/F,GAAQ+F,EAAa,CAAC;CAG1B,IAAMC,KAAYrI,EAAM,aACrB,MAAiB;EAChB,GAAYkI,IAAQ,MAAa;GAC/B,IAAMC,IAAY,IAAI,IAAIH,EAAM,MAAMzG,CAAQ,CAAC,GACzC+G,IAAMN,EAAM,cAAc,GAC1BO,IAAUD,EAAI,QAAQ,MAAU,CAACN,EAAM,WAAW3G,CAAK,CAAC,GAExDI,IADc8G,EAAQ,SAAS,KAAKA,EAAQ,OAAO,MAAUJ,EAAU,IAAI9G,CAAK,CAAC,IAEnFiH,EAAI,QAAQ,MAAUN,EAAM,WAAW3G,CAAK,KAAK8G,EAAU,IAAI9G,CAAK,CAAC,IACrEiH,EAAI,QAAQ,MAAU,CAACN,EAAM,WAAW3G,CAAK,KAAK8G,EAAU,IAAI9G,CAAK,CAAC;GAC1E,OAAO2C,GAAUvC,GAAMF,CAAQ,IAAIA,IAAWE;EAChD,CAAC;CACH,GACA,CAACqG,IAAaE,CAAK,CACrB,GAEMQ,KAAY1I,EAAM,yBAAyB,GAC3C2I,KAAiBC,IAAQ,aAAazI,GACtC0I,KAAuBD,IAAQ,mBAAmBxI,GAElD0I,KAAU5I,EAAM,eACb;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF,IACA;EACE+H;EACAC;EACAC;EACAI;EACAG;EACAC;EACAE;EACAE;EACAC;EACAC;CACF,CACF,GAGM,EAAE,aAAS,kBAAcC,EAAkB,GAC3CC,KAAYC,EAAgCC,IAAKC,EAAO,GAGxDC,KAAWrJ,EAAM,cAAqD;EAC1E,IAAImC,MAAU,KAAA,GAAW,OAAO;EAChC,IAAM4B,oBAAO,IAAI,IAAY;EAC7B,OAAO5B,EAAM,KAAK,GAAM,MAAU;GAChC,IAAMd,IAAQiI,IAAWA,EAASlH,CAAI,IAAI,OAAO+B,CAAK,GAEhDG,IAAMP,EAAK,IAAI1C,CAAK,IAAI,GAAGA,EAAM,QAAQ8C,MAAU9C;GAEzD,OADA0C,EAAK,IAAIO,CAAG,GACL;IAAE;IAAM;IAAO;IAAO;GAAI;EACnC,CAAC;CACH,GAAG,CAACnC,GAAOmH,CAAQ,CAAC,GAGdC,KAAe3C,IAAM,UACrB4C,KAAgB5C,IAAM,WACtB6C,KAAczJ,EAAM,cAAc;EACtC,IAAKsF,KAAYiE,OAAiB,KAAA,KAAcG,GAChD,OAAOA,EAAQ,MAAM,MAAWnF,EAAWE,CAAM,MAAM8E,EAAY,CAAC,EAAE;CACxE,GAAG;EAACjE;EAAUiE;EAAcG;CAAO,CAAC,GAE9BC,KAAa3J,EAAM,cAAc;EACrC,IAAIqJ,OAAa,QAAQ,CAACI,IAAa,OAAOJ;EAE9C,IAAMO,IAAUH;EAGhB,OAAOJ,GACJ,MAAM,CAAC,CACP,KACCG,OAAkB,gBACb,GAAG,MAAM,CAACI,EAAQ3F,EAAE,MAAMC,EAAE,IAAI,KAChC,GAAG,MAAM0F,EAAQ3F,EAAE,MAAMC,EAAE,IAAI,CACtC;CACJ,GAAG;EAACmF;EAAUI;EAAaD;CAAa,CAAC,GAGnCK,KAAmB7J,EAAM,cAAwC;EACrE,IAAI,CAAC0J,KAAW,CAACpE,GAAU,OAAO;EAClC,IAAMwE,IAAWJ,EAAQ,KAAK,GAAQ,MAAUnF,EAAWE,CAAM,KAAKN,CAAK;EAC3E,QAAQ,MACN,kBAAC4F,IAAD,EAAA,UACGL,EAAQ,KAAK,GAAQ,MACpB,kBAACM,GAAD,EAAA,UAAqCvF,EAAO,aAAarC,CAAS,EAAgB,GAA/D0H,EAAS3F,EAAsD,CACnF,EACU,CAAA;CAEjB,GAAG,CAACuF,GAASpE,CAAQ,CAAC,GAEhB2E,KAAejK,EAAM,eAClB;EAAE,MAAM2J;EAAY;CAAiB,IAC5C,CAACA,IAAYE,EAAgB,CAC/B,GAEMK,KACJR,GAAS,MAAM,MAAWjF,EAAO,aAAa,KAAA,KAAaA,EAAO,OAAO,KAAA,CAAS,KAAK;CACzF,EAAM,gBAAgB;EACpB,AAAIyF,MACF9D,EACE,oCACA,gJAEF;CAEJ,GAAG,CAAC8D,EAAe,CAAC;CAGpB,IAAIC,KAA2BC,GACzBC,KAAeX,IAAUY,EAAgBF,CAAQ,IAAI,CAAC,GACtDG,MAAY,MAAkBF,GAAa,MAAM,EAAE,cAAWG,EAAgBnG,GAAMoG,CAAI,CAAC,GACzFC,KACJhB,KAAW,CAACa,GAASI,CAAc,IACjC,kBAACA,GAAD,EAAA,UACE,kBAAC,MAAD,EAAA,UACGjB,EAAQ,KAAK,GAAQ,MAAU;EAC9B,IAAMzC,IAAW1C,EAAWE,CAAM;EAClC,OACE,kBAACmG,GAAD;GAEY;GACV,UAAUnG,EAAO,YAAYA,EAAO,YAAY,KAAA;GAE/C,UAAAA,EAAO,mBAAmBA,EAAO,iBAAiB,IAAIA,EAAO;EAC5C,GALbwC,KAAY9C,CAKC;CAExB,CAAC,EACC,CAAA,EACU,GAfI,uBAeJ,IACd,MAEA0G,KACJnB,KAAWpE,KAAY,CAACiF,GAASO,CAAY,IAC3C,kBAACA,GAAD,CAAyC,GAAvB,qBAAuB,IACvC;CACN,IAAIJ,MAAmBG,IAAe;EAGpC,IAAME,KAAa,EAAE,cAAsCP,EAAgBnG,GAAM,SAAS,GACpF2G,IAASX,GAAa,QAAQ,MAAU,CAACU,EAAUE,CAAK,CAAC,GACzDC,IAAcL,KAChBG,EAAO,WAAW,EAAE,cAAWR,EAAgBnG,GAAM,OAAO,CAAC,IAC7D,IACE8G,IAAYD,KAAe,IAAIA,IAAcF,EAAO;EAC1D,KAAU;GACR,GAAGX,GAAa,OAAOU,CAAS,CAAC,CAAC,IAAI3G,EAAe;GACrDsG;GACA,GAAGM,EAAO,MAAM,GAAGG,CAAS,CAAC,CAAC,IAAI/G,EAAe;GACjDyG;GACA,GAAGG,EAAO,MAAMG,CAAS,CAAC,CAAC,IAAI/G,EAAe;EAChD;CACF;CAEA,IAAM,EACJ,WAAWgH,IACX,cAAcC,IACd,mBAAmBC,IACnB,GAAGC,OACDC,MAAkB,CAAC,GAGjBC,KAAmBF,GAAc,SAAS,KAAA,GAC1CG,KACJ,CAACD,OAAqBJ,OAAmB,KAAA,KAAaC,OAAwB,KAAA;CAahF,OAXAtL,EAAM,gBAAgB;EACpB,AAAI0L,MACFtF,EACE,wCACA,6NAGF;CAEJ,GAAG,CAACsF,EAAoB,CAAC,GAGvB,kBAAC7I,EAAgB,UAAjB;EAA0B,OAAO+F;EAC/B,UAAA,kBAAC9F,EAAoB,UAArB;GAA8B,OAAOoE;GACnC,UAAA,kBAAChE,GAAqB,UAAtB;IAA+B,OAAO+G;IAEpC,UAAA,kBAAC7G,GAAmB,UAApB;KAA6B,OAAO;KAClC,UAAA,kBAACD,GAAqB,UAAtB;MAA+B,OAAO;MACpC,UAAA,kBAAC,OAAD;OACE,GAAIoI;OACJ,cAAYE,KAAmBJ,KAAiB,KAAA;OAChD,mBAAiBI,KAAmBH,KAAsB,KAAA;OAC1D,WAAWK,EACTC,EAAmB,WACnB,mDACAR,EACF;OAEA,UAAA,kBAAC,SAAD;QACE,KAAKnC;QACL,MAAK;QACL,wBAAsBlB,MAAkB,cAAc,KAAA;QACtD,6BAA2Be;QAC3B,yBAAuBC,IAAkB,KAAK,KAAA;QAC9C,WAAW4C,EACTC,EAAmB,MACnB,2CAEA7C,KAAmB,cACnB8C,CACF;QACA,GAAIzG;QACJ,WAAW0G,EAAqBC,GAAWC,GAAU,SAAS;QAC9D,SAASF,EAAqBG,IAASD,GAAU,SAAS,EACxD,uBAAuB,GACzB,CAAC;QACD,QAAQF,EAAqBI,GAAQF,GAAU,QAAQ,EACrD,uBAAuB,GACzB,CAAC;QAEA,UAAA7B;OACI,CAAA;MACJ,CAAA;KACwB,CAAA;IACJ,CAAA;GACA,CAAA;EACH,CAAA;CACN,CAAA;AAE9B;AACA,EAAa,cAAc;AAoB3B,SAASgC,EAA4B,EACnC,kBACA,oBACA,cACA,UACmC;CACnC,IAAM,EAAE,UAAO,cAAW,mBAAgB,yBAAsB,uBAC9D3I,EAAmB,iBAAiB,GAChC4I,IAAQpM,EAAM,qBAClBgI,EAAM,oBACNA,EAAM,mBACNA,EAAM,iBACR,GACM,EACJ,cACA,aACA,cACA,eACA,cAAcqE,GACd,mBAAmBC,GACnB,oBAAoBC,GACpB,GAAGnH,MACDoH,KAAa,CAAC,GAEdC,IAA6B;CAIjC,OAHIL,MAAU,QAAO,IAAU,KACtBA,MAAU,WAAQ,IAAU,UAGnC,kBAAC,MAAD;EACE,OAAM;EACN,GAAIhH;EACC;EACL,uBAAoB;EACpB,WAAWuG,EACTe,GACAC,EAAyB,eACzBC,GACA,cACAC,GACAhB,CACF;EAEC,UAAA9D,MAAkB,aACjB,kBAAC+E,IAAD;GACE,KAAKC;GACL,MAAK;GACL,cAAYV,MAAcC,MAAmB,KAAA,IAAY7D,IAAiB,KAAA;GAC1E,mBAAiB6D;GACjB,oBAAkBC;GACT;GACC;GACC;GACX,QAAQxD;GACR,QAAO;GACP,WAAW,MAAUV,EAAUH,EAAM,WAAW;GAChD,WAAWyE,EAAyB;EACrC,CAAA,IAED,kBAAC,QAAD;GAAM,WAAU;GAAW,UAAAhE;EAA2B,CAAA;CAEtD,CAAA;AAER;AAEA,IAAMqE,IAAyC;CAC7C,uBAAuB,CAAC;CACxB,sBAAsB,CAAC;CACvB,gBAAgB;CAChB,eAAe,CAAC;AAClB;AAOA,SAASC,GAA4B,EACnC,kBACA,iBACA,oBACA,cACA,UAC+D;CAC/D,IAAM1K,IAAQvC,EAAM,WAAWgD,CAA0B,KAAKgK,GACxD,CAACtK,KAAQ1C,EAAM,gBAAgB,CAAC,EAAE,GAClCkN,IAAUlN,EAAM,OAAoC,IAAI,GACxDiJ,IAAYC,EAAoCgE,GAAS/D,CAAG,GAE5DgE,IAAanN,EAAM,kBAAkB;EACzC,IAAMoB,IAAQmB,EAAM,SAAS;EAC7B,OAAOnB,MAAU,OAAOgM,IAAehM,MAAUsB;CACnD,GAAG;EAACH;EAAOG;EAAM0K;CAAY,CAAC,GACxBC,IAAmBrN,EAAM,kBAAkBoN,GAAc,CAACA,CAAY,CAAC,GACvEE,IAAUtN,EAAM,qBAAqBuC,EAAM,WAAW4K,GAAYE,CAAgB;CAIxF,IAFArN,EAAM,sBAAsBuC,EAAM,SAASG,SAAYwK,EAAQ,OAAO,GAAG,CAAC3K,GAAOG,CAAI,CAAC,GAElF4K,GACF,OACE,kBAACnB,GAAD;EACE,KAAKlD;EACU;EACE;EACN;CACZ,CAAA;CAIL,IAAM,EACJ,cACA,UAAUsE,GACV,WAAWC,GACX,YAAYC,GACZ,cAAcC,GACd,mBAAmBC,GACnB,oBAAoBC,GACpB,GAAGxI,OACDoH,KAAa,CAAC;CAClB,OACE,kBAAC,MAAD;EACE,GAAIpH;EACJ,KAAK6D;EACL,uBAAoB;EACpB,WAAW0C,EACTe,GACAC,EAAyB,eACzBC,GACAC,GACAhB,CACF;CACD,CAAA;AAEL;AAaA,SAASgC,GACP,GACA,GACiB;CACjB,IAAIzM,IAAQ,IACN0M,KAAS,MACb9N,EAAM,SAAS,IAAI+N,IAAQ,MAAU;EACnC,IAAIvD,EAAgDS,GAAOjL,EAAM,QAAQ,GACvE,OAAOA,EAAM,aAAaiL,GAAO,KAAA,GAAW6C,EAAM7C,EAAM,MAAM,QAAQ,CAAC;EAEzE,IAAI,CAACjL,EAAM,eAAeiL,CAAK,GAAG,OAAOA;EACzC,IAAMqC,IAAUlM;EAEhB,IADA,IAAQ,IACJoJ,EAAgDS,GAAO,IAAI,GAAG;GAChE,IAAM+C,IAAQ/C,EAAM,MAAM,UACpBvI,IACJqF,MAAkB,UAClBuC,EAAgB0D,CAAK,CAAC,CAAC,MAAM,EAAE,cAAWnJ,EAAuBR,CAAI,CAAC,IAAI,OACxE,kBAAC4I,IAAD;IAA4C;IAAe,cAAcK;GAAU,CAAA;GAEvF,OAAOtN,EAAM,aACXiL,GACA,KAAA,GACAvI,GACA,kBAACO,EAA6B,UAA9B;IAAuC,OAAOqK;IAC3C,UAAAU;GACoC,CAAA,CACzC;EACF;EACA,OACE,kBAAC/K,EAA6B,UAA9B;GAAuC,OAAOqK;GAC3C,UAAArC;EACoC,CAAA;CAE3C,CAAC;CACH,OAAO6C,EAAM1D,CAAQ;AACvB;AAUA,IAAMO,KAAkB,EAAE,aAAU,cAAW,QAAK,GAAGvF,QAAgC;CACrF,IAAM,EAAE,qBAAkB5B,EAAmB,iBAAiB,GACxD,CAACyK,GAAOC,KAAYlO,EAAM,SAAyC,IAAI,GACvEiJ,IAAYC,EAAuCC,GAAK+E,CAAQ,GAChE,CAAC3L,KAASvC,EAAM,SAASsC,CAAwB,GACjD6H,IAAU0D,GAAyBzD,GAAUrC,CAAa;CAoChE,OAjCA/H,EAAM,sBAAsB;EAC1B,EAAM,QAAQ;CAChB,CAAC,GAGDA,EAAM,gBAAgB;EACpB,IAAI,CAACmO,KAAS,CAACF,KAASlG,MAAkB,QAAQ;EAClD,IAAMqG,IAAiB,MAAM,KAAKH,EAAM,OAAO,MAC7C,MAAM,KAAKI,EAAI,KAAK,CAAC,CAAC,QAAQ,MAASzL,EAAK,aAAa,qBAAqB,CAAC,CACjF;EAcA,AAZEwL,EAAe,MACZ,GAAO,MAAUJ,EAAM,WAAW,KAAKC,EAAM,KAAK9J,EAAM,CAAC,MAAM,SAAS,CAC3E,KAEAiC,EACE,0CACA,uRAIF,GAEEgI,EAAe,MAAM,MAAUJ,EAAM,SAAS,CAAC,KACjD5H,EACE,2CACA,wPAGF;CAEJ,CAAC,GAGC,kBAACrD,EAAuB,UAAxB;EAAiC,OAAM;EACrC,UAAA,kBAACC,EAA2B,UAA5B;GAAqC,OAAOT;GAC1C,UAAA,kBAAC,SAAD;IACE,KAAK0G;IACL,WAAW0C,EAAGgB,EAAyB,MAAM,WAAWd,CAAS;IACjE,GAAIzG;IAEH,UAAA+E;GACI,CAAA;EAC4B,CAAA;CACN,CAAA;AAErC;AACA,EAAe,cAAc;AAS7B,IAAMS,KAAsB,EAC1B,aACA,cAAW,IACX,aACA,aACA,cACA,YACA,QACA,GAAGxF,QAC0B;CAC7B,IAAM,EAAE,SAAM,mBAAgBxB,EAAuB,qBAAqB,GAEpE2F,IAAe+E,KAAYrH,IAAWA,IAAW,KAAA,GACjDsH,IACJhF,MAAiB,KAAA,KAAa3C,GAAM,aAAa2C,IAAe3C,EAAK,YAAY,MAK7E4H,KAAqB,MAAkD;EAC3E,IAAMC,IAASvG,EAAM,cAAc;EACnC,AACEqB,MAAiB,KAAA,KACjBkF,GAAQ,cAAc,YACtBA,EAAO,SAASvG,EAAM,MAAc,KAEpClB,EAAYuC,GAAcrB,EAAM,WAAW;CAE/C;CAWA,OATAlI,EAAM,gBAAgB;EACpB,AAAIsO,KAAY,CAACrH,KACfb,EACE,iDACA,6FACF;CAEJ,GAAG,CAACkI,GAAUrH,CAAQ,CAAC,GAGrB,kBAAC,MAAD;EACO;EACL,OAAM;EACN,aAAWsC,MAAiB,KAAA,IAA0C,KAAA,IAA7BgF,KAAmB;EAC5D,WAAW5C,EACT+C,EAA6B,MAC7B/J,GACA,iFACAkI,GACAtD,MAAiB,KAAA,KAAa,6BAC9BsC,CACF;EACA,GAAIzG;EACJ,SACEmE,MAAiB,KAAA,IAA+DoF,IAAnD7C,EAAqB6C,GAASH,CAAiB;EAG7E,UAAAjF,MAAiB,KAAA,IAWhB,kBAAC,QAAD;GAAM,WAAU;GAAkC;EAAe,CAAA,IAVjE,kBAACqF,GAAD;GACE,WAAU;GACV,WAAWL;GACD;GACV,WAAWG,EAA6B;GACxC,eAAeA,EAA6B;GAE3C;EACc,CAAA;CAIjB,CAAA;AAER;AACA,EAAmB,cAAc;AAOjC,IAAMG,KAAkB7O,EAAM,KAAK,SAAyB,EAC1D,SACA,UACA,UACA,aAMC;CACD,OACE,kBAACmD,GAAqB,UAAtB;EAA+B,OAAO9B;EACnC,UAAAyN,EAAO1M,GAAM+B,CAAK;CACU,CAAA;AAEnC,CAAC,GAOK2G,KAAoB,EAAE,aAAU,cAAW,QAAK,GAAG1F,QAAiC;CACxF,IAAM6E,IAAejK,EAAM,WAAWkD,EAAoB,GACpD6L,IAAO9E,GAAc,QAAQ,MAG7B+E,IAFoB,OAAO5E,KAAa,cAEE2E,MAAS;CACzD,EAAM,gBAAgB;EACpB,AAAIC,KACF5I,EACE,sCACA,uIAEF;CAEJ,GAAG,CAAC4I,CAAkB,CAAC;CAEvB,IAAMC,KAAc,MAClBH,KACAC,GAAM,KAAK,MACT,kBAACF,IAAD;EAEE,MAAMR,EAAI;EACV,OAAOA,EAAI;EACX,OAAOA,EAAI;EACH;CACT,GALMA,EAAI,GAKV,CACF,GAEClE;CAUJ,OATA,AAMEA,IANE,OAAOC,KAAa,aAEZ6E,EAAW7E,CAA6B,IACzCA,MAAa,KAAA,IACZ6E,EAAWhF,GAAc,oBAAoB,IAAI,IAEjDG,GAIV,kBAACrH,EAAuB,UAAxB;EAAiC,OAAM;EACrC,UAAA,kBAAC,SAAD;GAAY;GAAK,WAAW4I,EAAGuD,EAAuB,MAAMrD,CAAS;GAAG,GAAIzG;GACzE,UAAA+E;EACI,CAAA;CACwB,CAAA;AAErC;AACA,EAAa,cAAc;AAc3B,IAAMJ,MAAe,EACnB,OAAOoF,GACP,mBACA,uBACA,aACA,cACA,YACA,cACA,QACA,GAAG/J,QACmB;CACtB,IAAM,EAAE,kBAAe,UAAO,cAAW,qBAAkB,2BACzD5B,EAAmB,cAAc,GAE7B4L,KAAYpP,EAAM,WAAWmD,EAAoB,GACjD9B,IAAQ8N,KAAaC,MAAa,KAAA,GAClCC,KAAUrP,EAAM,WAAW+C,CAAsB,GACjDuM,KAAqBtP,EAAM,WAAWiD,CAA4B,GAClEsM,IAAWF,OAAY,UACvBG,IAAazH,MAAkB,UAAU,CAACwH,GAC1CE,IAAU3P,EAAM,yBAAyB,GAKzCuK,IAAeC,EAAgBF,CAAQ,GAEzCsF;CACJ,KAAK,IAAM,EAAE,aAAUrF,GACrB,IAAIxF,EAAuBR,CAAI,GAAG;EAChC,IAAeA,EAAK;EACpB;CACF;CAEF,IAAMsL,IAAmBD,MAAiB,KAAA,GACpCE,IAAoBF,GAAc,YAAYG,GAAoB,YAAY,IAC9EC,KAAqBJ,GAAc,aAAaG,GAAoB,aAAa,IACjFE,KAAgBL,IAAe,oBAC/BM,IACJN,IAAe,iBAAiBG,IAAqB,iBAAiBI,GAElE5N,IAAS0F,MAAkB,UAC3BmI,KAAclQ,EAAM,kBAClBqB,MAAU,KAAA,KAAa2G,EAAM,WAAW3G,GAAOgB,CAAM,GAC3D;EAAChB;EAAO2G;EAAO3F;CAAM,CACvB,GAEM8N,IAAanQ,EAAM,qBAAqBgI,EAAM,WAAWkI,IAAaA,EAAW;CAevF,AAbAlQ,EAAM,sBAAsB;EAC1B,IAAIqB,MAAU,KAAA,KAAakO,GAAU;EACrC,IAAMa,IAAapI,EAAM,SAAS3G,CAAK;EAEvC,OADI8M,KAASnG,EAAM,mBAAmB3G,CAAK,IAAI,KAAGqD,GAAmBrD,CAAK,GACnE+O;CACT,GAAG;EAACpI;EAAO3G;EAAOkO;CAAQ,CAAC,GAG3BvP,EAAM,sBAAsB;EAC1B,IAAIqB,MAAU,KAAA,KAAa,MAAauO,GACxC,OAAO5H,EAAM,QAAQ3G,CAAK;CAC5B,GAAG;EAAC2G;EAAO3G;EAAOkO;EAAUK;CAAiB,CAAC,GAE9C5P,EAAM,gBAAgB;EACpB,AAAIwP,KAAcnO,MAAU,KAAA,KAC1B+E,EACE,8BACA,kGACF;CAEJ,GAAG,CAACoJ,GAAYnO,CAAK,CAAC;CAEtB,IAAMgP,KACJb,KAAcnO,MAAU,KAAA,KAAa2O,MAAa,KAAA,KAAaD,OAAkB,KAAA,GAE7EO,MAAiB,MAAoD;EACzE,IAAI,CAACd,KAAcnO,MAAU,KAAA,KAAa6G,EAAM,QAAQ,KAAK;EAC7D,IAAMqI,IAASrI,EAAM;EAErB,CAAIqI,MAAWrI,EAAM,iBAAiBqI,EAAO,kBAAkBrI,EAAM,mBAErEA,EAAM,eAAe,GAChB0H,KAAmB3H,EAAU5G,GAAO6G,EAAM,WAAW;CAC5D,GAEMsI,MAAe,MAAiD;EACpE,IAAI,CAAC3H,KAAoB,CAAC2G,KAAcnO,MAAU,KAAA,KAAauO,GAAmB;EAClF,IAAMvB,IAAMnG,EAAM;EAGlB,AADeuI,GAAevI,GAAO,EAAE,YAAY,MAAYwI,EAAQ,kBAAkBrC,EAAI,CACzF,KAAUsC,EAAkBzI,CAAK,KACrCD,EAAU5G,GAAO6G,EAAM,WAAW;CACpC,GAGI0I,GACAC,IAAc;CAClB,IAAIR,IAAY;EACd,IAAMS,IAAiBzG,EAAa,WAAW,EAAE,cAC/CG,EAAgBnG,GAAM2F,GAAc,MAAM,IAAI,CAChD;EACA,IAAI8G,KAAkB,GAAG;GACvB,IAAMC,IAAY1G,EAAayG,EAAe,CAAC;GAE/C,AADA,IAAaC,EAAU,MAAM,MAAMtB,GAC/BsB,EAAU,MAAM,OAAO,KAAA,MAAW,IAAcD;EACtD;CACF;CACA,IAAM3G,IAAUE,EAAa,KAAK,EAAE,QAAK,WAAQ,MAC/CjG,GAAgB;EACd;EACA,MACED,MAAU0M,IACN7Q,EAAM,aAAaqE,GAA6C,EAAE,IAAIoL,EAAQ,CAAC,IAC/EpL;CACR,CAAC,CACH,GAEM2M,IAAaX,MAAcO,MAAe,KAAA;CAChD,EAAM,gBAAgB;EACpB,AAAII,KACF5K,EACE,gCACA,wMACF;CAEJ,GAAG,CAAC4K,CAAU,CAAC;CAGf,IAAMC,IAAoBlB,MAAiBa,GACrCM,KAAelB,MAAaiB,MAAsB,KAAA,IAAY,eAAe,KAAA,IAE7EE,IAAanR,EAAM,eAChB;EACL;EACA;EACA,OAAOwP,IAAanO,IAAQ,KAAA;EAC5B;EACA,UAAUuO;EACV,WAAWE;EACX,WAAWoB;EACX,gBAAgBD;CAClB,IACA;EACEpB;EACAF;EACAH;EACAnO;EACA8O;EACAP;EACAE;EACAoB;EACAD;CACF,CACF,GAGIG,IAAwC;CAa5C,OAZI,CAACzB,KAAoBJ,KAAYxH,MAAkB,SACrD,IACE,kBAACkF,IAAD;EACiB;EACf,cAAcqC;EACd,WAAWO;CACZ,CAAA,IAEM,CAACF,KAAoBH,MAC9B,IAAuB,kBAAC6B,IAAD,EAA2B,WAAU,eAAgB,CAAA,IAI5E,kBAACjO,GAAmB,UAApB;EAA6B,OAAO+N;EAClC,UAAA,mBAAC,MAAD;GACO;GACL,WAAWxF,EACT2F,EAAsB,MAGtB,mBACA,CAAC/B,KAAY3K,EAAiBkE,IAC9B0G,KAAcW,KAAcoB,EAAa,mBACzC1F,CACF;GACA,iBAAe2D,IAAaW,IAAa,KAAA;GACzC,iBAAeX,KAAcW,IAAa,KAAK,KAAA;GAC/C,GAAI/K;GACJ,SAAS0G,EAAqB6C,GAAS6B,EAAW;GAClD,WAAW1E,EAAqBC,GAAWuE,EAAa;GAf1D,UAAA,CAiBGc,GACAjH,CACC;;CACuB,CAAA;AAEjC;AACA,GAAY,cAAc;AAkB1B,SAASkH,GAA0B,EACjC,cACA,oBACA,cACA,eACA,oBAAoB9E,GACpB,QACA,GAAGnH,KAC8B;CACjC,IAAM,EAAE,kBAAe,cAAW,cAAW,uBAAoB5B,EAAmBE,CAAS,GACvF2K,IAAM1K,GAAsBD,CAAS,GACrC,EAAE,aAAU2K,GACZhM,IAAS0F,MAAkB;CACjC,OACE,kBAAC,MAAD;EACE,MAAK;EACL,GAAI3C;EACC;EACL,uBAAoB;EACpB,WAAWuG,EACTe,GACA4E,EAAsB,eACtB1E,GACAC,GACAwB,EAAI,oBAAoB,WACxBxC,CACF;EAEC,UAAAxK,MAAU,KAAA,KAAa0G,MAAkB,UACxC,kBAAC+E,IAAD;GACE,KAAKC;GACL,MAAM1K,IAAS,UAAU;GACzB,MAAMA,IAASmG,IAAY,KAAA;GAI3B,MAAMnG,IAAS,KAAK,KAAA;GACpB,SAASgM,EAAI;GACb,UAAUA,EAAI;GACd,WAAWA,EAAI;GACf,QAAQtF;GACR,WAAW,MAAUd,EAAU5G,GAAO6G,EAAM,WAAW;GACvD,cAAYmG,EAAI;GAChB,mBAAiBA,EAAI;GACrB,oBAAkB9B;GAClB,WAAW+E,EAAsB;EAClC,CAAA;CAED,CAAA;AAER;AAWA,IAAME,KAAyB,EAC7B,aACA,cACA,cACA,cAAcnF,GACd,mBAAmBC,GACnB,oBAAoBC,GACpB,eACA,QACA,GAAGnH,QAC6B;CAChC,IAAM,EAAE,qBAAkB5B,EAAmB,wBAAwB,GAC/D6L,IAAUrP,EAAM,WAAW+C,CAAsB,GACjDuM,IAAqBtP,EAAM,WAAWiD,CAA4B,GAClEoL,IAAMrO,EAAM,WAAWoD,EAAkB,GACzCqO,IAAgB1J,MAAkB,QAElC2J,IAAS,CAACD,KAAiBpD,MAAQ,QAAQ,CAACA,EAAI;CAuBtD,IArBArO,EAAM,gBAAgB;EACpB,AAAIyR,KACFrL,EACE,yCACA,4KAEF;CAEJ,GAAG,CAACqL,CAAa,CAAC,GAElBzR,EAAM,gBAAgB;EACpB,AAAI0R,KACFtL,EACE,iCACA,4MAGF;CAEJ,GAAG,CAACsL,CAAM,CAAC,GAEPD,GAAe,OAAO;CAC1B,IAAIpC,MAAY,UAAU;EACxB,IAAMsC,IAAWtD,GAAK;EACtB,OACE,kBAACpB,IAAD;GACO;GACU;GACf,cAAcqC;GACd,iBAAiBsC,EAAgC;GACjD,WAAW;IACT,GAAGxM;IACH,WAAWuG,EAAGgG,GAAU,WAAW9F,CAAS;IAC5C,UAAUtL,KAAYoR,GAAU;IAChC,WAAWE,KAAaF,GAAU;IAClC,cAActF,KAAasF,IAAW;IACtC,mBAAmBrF;IACnB,oBAAoBC;IACpB;GACF;EACD,CAAA;CAEL;CACA,OACE,kBAAC8E,IAAD;EACE,GAAIjM;EACC;EACL,WAAU;EACV,iBAAiBwM,EAAgC;EACtC;EACC;EACZ,oBAAkBrF;CACnB,CAAA;AAEL;AACA,EAAsB,cAAc,yBACpCuF,GAAcN,GAAuB,uBAAuB;AAM5D,IAAMxH,KAAgB,EAAE,aAAU,cAAW,QAAK,GAAG5E,QACnD,kBAAC,MAAD;CACO;CACL,MAAK;CACL,WAAWuG,EACToG,EAAuB,MACvBpN,GACA,wBACAkI,GACAhB,CACF;CACA,GAAIzG;CAEH;AACC,CAAA;AAEN,EAAa,cAAc;AAqC3B,IAAa4M,KAA2B,uBAAO,OAAOjN,GAAc;CAClE,QAAQ4F;CACR,YAAYC;CACZ,MAAME;CACN,KAAKf;CACL,MAAMC;CACN,eAAewH;AACjB,CAAC"}
+{"version":3,"file":"DataGrid.mjs","names":["useId","useId$1","React","EMPTY_ITEMS","NO_COLUMN_IDS","toItems","keys","sameItems","a","b","item","index","toggleAllInUniverse","selectable","previous","current","next","summarizeSelection","clearIds","selectAllIds","inUniverse","universe","id","renderFlatChild","node","key","countHeaderRows","flattenChildren","children","columnIdOf","resolveDeprecatedProp","column","warnDuplicateRowId","rowId","BODY_ROW_CLASSES","DataGridRoot","sortProp","sortColumnProp","sortDirectionProp","selectedItemsProp","rest","props","hasItems","items","usesSortApi","defaultSort","legacySort","objectMode","setObjectMode","objectCallbacks","legacySortControlled","warnDeprecated","defaultSortColumn","defaultSortDirection","deprecatedSortProps","mixedSortApi","ignoredSortProps","warnOnce","legacyHalves","setLegacyHalves","legacyControlledSort","legacyDefaultSort","controlledSort","initialSort","sortDetailsRef","sort","setSort","useControllable","onSortChange","requestSort","columnId","sortContext","onSelectionChange","legacySelected","selectedKeys","legacyDefaultSelected","defaultSelectedKeys","controlledSelected","defaultSelected","defaultSelectedItems","selectionDetailsRef","selected","setSelectedValue","onSelectedItemsChange","setSelected","update","itemRows","getRowId","selectionMode","itemSelectionDisabled","isSelectionDisabled","row","selectionUniverse","disabledIds","single","store","createSelectionStore","toggleRow","event","toggleId","effective","selectedCount","toggleAll","all","enabled","radioName","selectAllLabel","labels","selectionHeaderLabel","context","selectOnRowClick","selectionAppearance","subtleSelection","sortColumnId","sortDirection","sortCompare","columns","sortedRows","compare","renderColumnsRow","cellKeys","DataGridRow","DataGridCell","itemsContext","columnWithoutId","flatChildren","childOf","isElementOfType","part","headerChild","DataGridHeader","bodyChild","DataGridBody","bodyChildren","activeWindow","virtualWindow","windowed","headerRowCount","rowCount","useGridNavigation","getWindowNavigationModel","windowState","useDataGridWindow","mergedRef","useMergedRefs","ref","gridRef","handleFocus","gridProps","handleBlur","sizingRequested","resizableColumns","columnSizingOptions","columnWidths","defaultColumnWidths","sizingIgnored","sizingEnabled","columnIds","sizing","useDataGridColumnSizing","content","generatedHeader","DataGridHeaderCell","generatedBody","isCaption","others","child","footerIndex","bodyIndex","containerClassName","containerLabel","containerLabelledBy","containerRefProp","containerRest","containerProps","containerRef","containerHasRole","droppedContainerName","DataGridContext","DataGridSortContext","DataGridItemsContext","DataGridRowContext","DataGridRowIdContext","DataGridItemSelectionDisabledContext","DataGridResizeContext","DataGridFixedLayoutContext","cn","dataGridClassNames","className","style","composeEventHandlers","onKeyDown","onFocus","onBlur","onPointerDownCapture","DataGridWindowContext","DataGridWindowRowContext","DataGridItemRow","windowRow","position","ariaRowIndex","height","selectionDisabled","render","windowContext","rows","renderWithoutItems","renderRows","renderWindowRows","DataGridSectionContext","dataGridBodyClassNames","rowIdProp","useDataGridContext","itemRowId","section","firstHeaderRowHint","DataGridHeaderRowHintContext","inHeader","labelId","ownCellProps","isSelectionCellElement","hasSelectionCell","cellDisabled","selectionCellProps","selectionInvisible","ownLabelledBy","ownLabel","selectionLabel","getSelected","isSelected","unregister","isDev","disabledMismatch","state","disabled","ownRowIdDiffers","unlabelled","handleKeyDown","target","handleClick","isForeignEvent","element","endsTextSelection","labelledBy","idCellIndex","firstCellIndex","firstCell","needsLabel","controlLabelledBy","controlLabel","rowContext","selectionCellElement","DataGridSelectionHeaderSlot","DataGridBodySelectionCell","dataGridRowClassNames","forcedColors","onClick","ariaDescribedBy","component","useDataGridRowContext","windowedRow","stableClassName","SELECTION_CELL_CLASSES","focusRingInset","TableSelectionControl","controlRef","DataGridSelectionCell","ariaLabel","ariaLabelledBy","notSelectable","unseen","rowProps","dataGridSelectionCellClassNames","invisible","markTablePart","fixedLayout","dataGridCellClassNames","cellBase","DataGrid"],"sources":["../../../src/components/table/DataGrid.tsx"],"sourcesContent":["import * as React from 'react';\nimport { cn } from '../../lib/cn';\nimport {\n  dataGridBodyClassNames,\n  dataGridCellClassNames,\n  dataGridClassNames,\n  dataGridRowClassNames,\n  dataGridSelectionCellClassNames,\n} from '../../lib/classNames';\nimport { flattenChildren, isElementOfType } from '../../lib/children';\nimport { composeEventHandlers } from '../../lib/composeEventHandlers';\nimport { isDev, resolveDeprecatedProp, warnDeprecated, warnOnce } from '../../lib/dev';\nimport type { ColumnSizingOption } from '../../lib/columnSizing';\nimport { endsTextSelection, isForeignEvent } from '../../lib/events';\nimport { clearIds, selectAllIds, summarizeSelection, toggleId } from '../../lib/selection';\nimport type { Slot } from '../../lib/slot';\nimport { focusRingInset, forcedColors } from '../../lib/styles';\nimport type { SelectionMode } from '../../lib/types';\nimport { useControllable } from '../../hooks/useControllable';\nimport { useId } from '../../hooks/useId';\nimport { useMergedRefs } from '../../hooks/useMergedRefs';\nimport type { VirtualWindow } from '../../hooks/useVirtualWindow';\nimport { SELECTION_CELL_CLASSES, TableSelectionControl, markTablePart } from './Table.shared';\nimport type { SortDirection } from './Table.shared';\nimport {\n  DataGridFixedLayoutContext,\n  DataGridResizeContext,\n  useDataGridColumnSizing,\n} from './DataGrid.sizing';\nimport {\n  DataGridWindowContext,\n  DataGridWindowRowContext,\n  getWindowNavigationModel,\n  renderWindowRows,\n  useDataGridWindow,\n  type DataGridWindowRow,\n} from './DataGrid.window';\nimport { useGridNavigation } from './useGridNavigation';\nimport type { TableColumnWidthsChangeDetails } from './useTableColumnSizing';\nimport {\n  DEFAULT_SELECTION_HEADER_LABEL,\n  DEFAULT_SELECT_ALL_LABEL,\n  DataGridContext,\n  DataGridHeaderRowHintContext,\n  DataGridItemSelectionDisabledContext,\n  DataGridItemsContext,\n  DataGridRowContext,\n  DataGridRowIdContext,\n  DataGridSectionContext,\n  DataGridSortContext,\n  useDataGridContext,\n  useDataGridRowContext,\n  type DataGridContextValue,\n  type DataGridItemRowData,\n  type DataGridItemsContextValue,\n  type DataGridRenderRow,\n  type DataGridRowContextValue,\n  type DataGridSortContextValue,\n} from './DataGrid.context';\nimport {\n  DataGridHeader,\n  DataGridHeaderCell,\n  DataGridSelectionHeaderSlot,\n  cellBase,\n  isSelectionCellElement,\n} from './DataGrid.header';\nimport {\n  createSelectionStore,\n  type SelectionStore,\n  type SelectionUniverse,\n} from './DataGrid.store';\n\nexport { createSelectionStore };\nexport type { SelectionStore, SelectionUniverse };\nexport type { SortDirection };\n\n/** The sort state of a DataGrid: the sorted column and its direction. */\nexport interface DataGridSort {\n  /** The `columnId` of the sorted column. */\n  columnId: string;\n  /** The sort direction. */\n  direction: SortDirection;\n}\n\n/** Second argument of `onSortChange` (the `DataGridSort` form): the event behind the sort. */\nexport interface DataGridSortChangeDetails {\n  /** The DOM event behind the sort: the click of the sort button (Enter and Space click it). */\n  event: Event;\n}\n\n/** Second argument of `onSelectedItemsChange`: the event behind the change. */\nexport interface DataGridSelectedItemsChangeDetails {\n  /**\n   * The DOM event behind the change: the click of a selection control (the select-all checkbox\n   * included), or the key press of Space on a row.\n   */\n  event: Event;\n}\n\n/**\n * Defines a column of the DataGrid, typed by the grid's items (`T`): the header cell it renders\n * and, with `items`, the cell of each row. `createTableColumn` builds one with `sortable` resolved.\n * A column with functions (`compare`, `renderCell`, `renderHeaderCell`) cannot be passed from a\n * Server Component to the DataGrid, since functions are not serializable: define such columns in a\n * client component.\n */\nexport interface DataGridColumn<T = unknown> {\n  /**\n   * Unique identifier of the column: the `columnId` of its header cell (and of the grid's sort) and\n   * the React key of its cells. Required in practice: a column without it (and without the\n   * deprecated `id`) cannot sort, with a development warning.\n   */\n  columnId?: string;\n  /**\n   * @deprecated Use `columnId`. Read only when `columnId` is not given, with a development\n   * warning.\n   */\n  id?: string;\n  /** The header content (text or any React node), unless `renderHeaderCell` is given. */\n  label: React.ReactNode;\n  /**\n   * Orders two items of the column, as for `Array.prototype.sort` (negative: `a` first). A column\n   * with `compare` is sortable unless `sortable` is `false`. While the grid's sort names the column\n   * (its own sort, or a controlled `sort`), a grid with `items` renders its rows in this order: a\n   * stable sort of a copy of `items`, so items that compare equal keep their order in `items`,\n   * in both directions (descending negates `compare`). Without `compare` the grid never reorders\n   * the rows: leave it out when the rows arrive sorted (a server-sorted grid).\n   */\n  compare?: (a: T, b: T) => number;\n  /**\n   * Renders the content of the column's cell for one item (rows rendered from `items`). Without\n   * it, the column's cells are empty.\n   */\n  renderCell?: (item: T) => React.ReactNode;\n  /** Renders the header content, in place of `label`. */\n  renderHeaderCell?: () => React.ReactNode;\n  /**\n   * Whether the column's header is a sort button (the header cell carries `aria-sort`).\n   * @default compare !== undefined\n   */\n  sortable?: boolean;\n}\n\n/** The built-in text of a DataGrid, for localization (see `DataGridBaseProps.labels`). */\nexport interface DataGridLabels {\n  /** Accessible name of the select-all checkbox in the header (`selectionMode=\"multiple\"`).\n   * @default 'Select all rows'\n   */\n  selectAll?: string;\n  /**\n   * Visually hidden text of the selection column's header cell (`selectionMode=\"single\"`), which\n   * names that column.\n   * @default 'Selection'\n   */\n  selectionHeader?: string;\n  /**\n   * Accessible name of each column's resize handle (`resizableColumns`).\n   * @default 'Resize column'\n   */\n  resizeColumn?: string;\n  /**\n   * Builds the value text of a resize handle (`aria-valuetext`) from the column's width in pixels.\n   * @default (width) => `${width} pixels`\n   */\n  columnWidth?: (width: number) => string;\n}\n\n/**\n * How a selected row of a DataGrid is filled (`selectionAppearance`): `'brand'` with the selected\n * token, `'neutral'` with the subtle selected token, `'none'` not at all.\n */\nexport type DataGridSelectionAppearance = 'brand' | 'neutral' | 'none';\n\n/**\n * The props of a row's selection cell (`DataGrid.Row` `selectionCellProps`), the automatic cell or\n * a `DataGrid.SelectionCell` child (whose own props win).\n */\nexport interface DataGridRowSelectionCellProps {\n  /**\n   * Disables the row's selection control natively. The control is then no focus target of the grid\n   * (the cell takes focus), and neither a row click (`selectOnRowClick`), Space on a cell nor\n   * select-all changes the row's selection: select-all skips it, keeps it as it is, and tells its\n   * state from the other rows. In a header row it disables the select-all checkbox.\n   * @default false (in a row rendered from `items`: the grid's `isSelectionDisabled` for its item)\n   */\n  disabled?: boolean;\n  /**\n   * Hides the selection control (it keeps its space and cannot be focused). The row is still\n   * selected by a row click and Space, and tells its state with `aria-selected`.\n   * @default false\n   */\n  invisible?: boolean;\n  /** Class of the selection cell (`<td>`, or the `<th>` of a header row). */\n  className?: string;\n  /**\n   * Accessible name of the selection control, in place of `selectionLabel` and the name taken from\n   * the row's first cell; in a header row, the name of the select-all checkbox.\n   */\n  'aria-label'?: string;\n}\n\n/** Properties for the DataGridSelectionCell sub-component. */\nexport interface DataGridSelectionCellProps\n  extends\n    Omit<React.TdHTMLAttributes<HTMLTableCellElement>, 'children'>,\n    DataGridRowSelectionCellProps {\n  /**\n   * The cell holds no content of its own: the grid renders the selection control (or, in a\n   * single-mode header row, the hidden \"Selection\" header text).\n   */\n  children?: never;\n  /**\n   * Accessible name of the control, in place of `aria-label` and the row's `selectionLabel`.\n   * Routed to the control, as `aria-label` and `aria-describedby` are.\n   */\n  'aria-labelledby'?: string;\n  /** Ref to the selection control (`<input type=\"checkbox\">` or `<input type=\"radio\">`). */\n  controlRef?: React.Ref<HTMLInputElement>;\n  /** Ref to the cell element (`<td>`, or the `<th>` of a header row's select-all). */\n  ref?: React.Ref<HTMLTableCellElement>;\n}\n\n/**\n * The `items` prop of a DataGrid that renders its rows from data, part of every sort form of\n * `DataGridProps` but the 0.4 one. `T` is the type of the items.\n */\nexport interface DataGridItemsProps<T = unknown> {\n  /**\n   * The grid's data, one body row per item, in this order unless the sorted column has `compare`\n   * (see `DataGridColumn.compare`). With `columns` and no `DataGrid.Body` child (or one without\n   * children), the grid renders the rows and cells from the columns; a `DataGrid.Body` whose child\n   * is a render function renders the row of each item. Each row's `rowId` comes from `getRowId`.\n   * The grid reads the array and never changes it. With `items`, `onSortChange` receives a\n   * `DataGridSort` object and `details`, never the 0.4 arguments. `items` may not be `undefined`\n   * unless `sort` or `defaultSort` is given; pass `items={data ?? []}` while loading.\n   */\n  items?: readonly T[];\n}\n\n/** Props of every DataGrid, whatever sort API it uses. `T` is the type of its `items`. */\nexport interface DataGridBaseProps<T = unknown> extends React.HTMLAttributes<HTMLTableElement> {\n  /**\n   * The row id of an item: the `rowId` of its row (for selection), for rows rendered from `items`.\n   * Select-all and its checkbox use these ids, whether the rows are rendered or not. A row's own\n   * `rowId` wins for that row, but a row whose own id differs from its item's id is outside\n   * select-all and its state, and select-all selects the item's id, which no row has (a\n   * development warning says so): return the rows' ids here rather than setting `rowId`. Ids must\n   * be unique (a duplicate warns in development). Define it outside the component, or memoise it:\n   * a new function rebuilds the row of every item and the set of ids select-all works on (with a\n   * `virtualWindow`, the component that holds the window renders at every row the view enters).\n   * @default the item's index in `items`, as a string\n   */\n  getRowId?: (item: T) => string;\n  /**\n   * Whether the selection of an item of `items` is disabled (`index` is its index in `items`), so\n   * select-all can skip items whose rows are not rendered. Select-all leaves such an item as it is,\n   * selected or not, and its state counts only the other items. The item's row takes it as the\n   * `disabled` of its selection cell (a disabled control; neither a row click nor Space changes\n   * it), unless the cell sets `disabled` itself: the cell's value then applies to the control, a\n   * value that disagrees warns in development, and select-all skips a row that either disables.\n   * Without it, every item is selectable unless its rendered row disables its selection cell.\n   * Ignored without `items`. Called for every item whenever `items`, `getRowId` or this function\n   * change: define it outside the component, or memoise it.\n   */\n  isSelectionDisabled?: (item: T, index: number) => boolean;\n  /**\n   * Column definitions. When given and no `DataGrid.Header` child is present, the header row\n   * (including the selection column) is rendered from them: `columnId` becomes the header cell's\n   * `columnId`, `renderHeaderCell()` (else `label`) its content, and `sortable` (by default, having\n   * `compare`) makes it a sort button. With `items` and no `DataGrid.Body` child, the body rows are\n   * rendered from them too: one `DataGrid.Cell` per column, filled by `renderCell`. Those rows\n   * render again whenever the array changes, so keep it stable (defined outside the component, or\n   * memoised).\n   */\n  columns?: readonly DataGridColumn<T>[];\n  /**\n   * Gives the header cell of each column (of `columns`, by `columnId`; the last one included, the\n   * selection column not) a resize handle: a focusable `role=\"separator\"` with the column's width\n   * as `aria-valuenow`. A drag (mouse, touch or pen) moves the column's end edge, mirrored in\n   * right-to-left grids. From the keyboard, F2 on a header cell (or on its sort button) moves focus\n   * to its handle, which adds no Tab stop to the grid; there the arrow keys move the edge by 20\n   * pixels (5 with Shift, mirrored in right-to-left grids), Home sets the minimum width, and Enter,\n   * Space or Escape return focus to the header (its sort button, which Enter still activates\n   * directly). A double click sets the column back to its initial width once a width is state.\n   * The grid carries `data-resizing` while a handle drags. Needs `columns` and `items`, as every\n   * column width prop does: without them they are all ignored, with a development warning.\n   * Fluent's `resizableColumns`.\n   * @default false\n   */\n  resizableColumns?: boolean;\n  /**\n   * The sizing of each column, by `columnId`: `minWidth` (`@default 80`), and the width it starts\n   * at, `defaultWidth`, else `idealWidth`, else 150 (never below `minWidth`). With it, or with\n   * `columnWidths` or `defaultColumnWidths`, the grid lays its columns out from these widths\n   * (a `<colgroup>` and a fixed table layout) with or without `resizableColumns`, and its cells\n   * truncate their text with an ellipsis unless a cell's class says otherwise. Until a width is\n   * state the grid is 100% wide and at least as wide as its columns, so a wider container spreads\n   * them (the selection column too); the first change takes the widths the columns are drawn at,\n   * so nothing jumps, and from then on the grid is exactly as wide as its columns (slack shows\n   * after the last one). There is no maximum width and no fitting to the container. Ids that are\n   * not columns are ignored; it may be written inline. Fluent's `columnSizingOptions`.\n   */\n  columnSizingOptions?: Record<string, ColumnSizingOption>;\n  /**\n   * The column widths in pixels (controlled), by `columnId`; a column without an entry has its\n   * initial width (see `columnSizingOptions`), and a width below the column's minimum is held at\n   * it. The grid is exactly as wide as its columns. Pair it with `onColumnWidthsChange`; a parent\n   * that ignores a change leaves the column where it is.\n   */\n  columnWidths?: Record<string, number>;\n  /** The column widths in pixels at first render (uncontrolled; see `columnWidths`). */\n  defaultColumnWidths?: Record<string, number>;\n  /**\n   * Called with the width of every column (by `columnId`) whenever a width changes, at every step\n   * of a drag (at most once per animation frame) or key press, then `details`: `{ columnId,\n   * width, event }`, the resized column, its new width and the event behind it. The grid always\n   * passes `details`; it is typed optional through 0.x, as every `details` argument. Setting the\n   * width a column already has does not call it once a width is state. Fluent's `onColumnResize`,\n   * whose data is in `details`.\n   */\n  onColumnWidthsChange?: (\n    widths: Record<string, number>,\n    details?: TableColumnWidthsChangeDetails,\n  ) => void;\n  /**\n   * Renders only the body rows in view, plus an overscan, of a grid with many `items`: pass the\n   * result of `useVirtualWindow({ itemSize })` (or an object of your own that implements\n   * `VirtualWindow`). The rows that are not rendered are replaced by spacer rows (`aria-hidden`,\n   * `data-virtual-spacer`) of their height. Fluent has no counterpart in its DataGrid.\n   *\n   * The grid's scroll wrapper (the element of `containerProps`) becomes the window's scroller, so\n   * give it a bounded height, a height or a maximum height in `containerProps`: without one the\n   * window measures the whole list and renders every row (a development warning says so). Every\n   * row has the window's `itemSize` as its height: the grid sets it on each body row, drops the\n   * vertical padding of its cells and keeps their text on one line, so a cell's content must fit\n   * in it. The columns are laid out from widths (as with `columnSizingOptions`), so they never\n   * change width as rows come and go. The header stays at the top of the scroller: pass its height\n   * as `scrollPaddingStart` to `useVirtualWindow`, so keyboard moves bring rows into the area below\n   * it. The scroller is no tab stop of its own (`tabIndex` -1, as Firefox would stop on it; a\n   * `tabIndex` in `containerProps` wins), and the browser's scroll anchoring is off on it (the\n   * window lays the rows out).\n   *\n   * The keyboard moves by the data: ArrowUp/ArrowDown, PageUp/PageDown and Ctrl+Home/Ctrl+End\n   * scroll a target row that is not rendered into the window, then focus it, and the focused row\n   * stays rendered when it is scrolled away. When a data change (a sort, new `items`) makes the\n   * browser drop focus from the moved row, focus returns to the same row, or to the row nearest\n   * its place. Sorting, selection, select-all and column sizing work on every item, rendered or\n   * not. The grid carries `aria-rowcount` (the items plus the header rows), every row\n   * `aria-rowindex` (1-based, the header rows first, the body rows in the sorted order) and every\n   * body row `data-row-index` (its 0-based position in the sorted order); a grid without a window\n   * renders none of them.\n   *\n   * Needs `items` and `columns`, with the body rows rendered from them (no `DataGrid.Body` child,\n   * or one whose child is a render function); otherwise it is ignored, with a development warning.\n   * The component that calls `useVirtualWindow` renders again at every row the view enters: keep\n   * `items`, `columns`, `getRowId` and `isSelectionDisabled` stable (defined outside it, or\n   * memoised), or each of those renders rebuilds the rows of every item.\n   */\n  virtualWindow?: VirtualWindow;\n  /**\n   * Row selection mode. `'multiple'` adds a checkbox column with a \"Select all rows\" header\n   * checkbox; `'single'` adds a radio column (its header reads \"Selection\" to assistive\n   * technology). `labels` localizes both texts.\n   * @default 'none'\n   */\n  selectionMode?: 'none' | SelectionMode;\n  /**\n   * The grid's built-in text, for localization: the name of the select-all checkbox\n   * (`selectAll`), the header text of the selection column (`selectionHeader`), and, with\n   * `resizableColumns`, the name of the resize handles (`resizeColumn`) and their value text\n   * (`columnWidth`). Unset members keep their English defaults. Rows are named with their own\n   * `selectionLabel`.\n   */\n  labels?: DataGridLabels;\n  /**\n   * Whether a click on a body row toggles its selection in a selectable grid (single mode: selects\n   * the row alone, or clears it). The row's own `onClick` runs first; calling `preventDefault()`\n   * in it keeps the selection. A click never toggles when it lands on an interactive element in\n   * the row (a link, a button, an input, a label, an element with `tabindex` or a widget role, the\n   * selection control included), comes from a popup portaled from the row (a Menu, a Popover), or\n   * ends a text selection in the row (a drag across its text); nor does a click on a header row\n   * or on a row whose selection is disabled (`selectionCellProps.disabled`). Space on a cell\n   * toggles the row either way.\n   * @default false\n   */\n  selectOnRowClick?: boolean;\n  /**\n   * How a selected row is filled: `'brand'` with the selected token, `'neutral'` with the subtle\n   * selected token, `'none'` not at all (the selection control, `aria-selected` and, in forced\n   * colors, the row's outline still show it). Rendered as `data-selection-appearance` on the grid.\n   * @default 'brand'\n   */\n  selectionAppearance?: DataGridSelectionAppearance;\n  /**\n   * Subtle selection controls: a row's control is transparent while the row is not selected, until\n   * the row is hovered or holds focus, and the select-all checkbox while no row is selected, until\n   * the grid is hovered or holds focus. Forced colors and a coarse pointer (touch) always draw\n   * them; they stay focusable and named. Rendered as `data-subtle-selection` on the grid.\n   * @default false\n   */\n  subtleSelection?: boolean;\n  /**\n   * Controlled selected row ids (`DataGrid.Row` `rowId`; with `items`, the ids from `getRowId`).\n   * With `items`, every id counts, whether its row is rendered, filtered out or on another page\n   * (see `onSelectedItemsChange`). In single mode pass at most one id: with several, only the\n   * first one is selected (without `items`, the first one whose row is rendered), and a\n   * development warning says so.\n   */\n  selectedItems?: readonly string[];\n  /** Initially selected row ids (uncontrolled). In single mode, at most one (see `selectedItems`). */\n  defaultSelectedItems?: readonly string[];\n  /**\n   * Called with the new selected row ids when the selection changes, then `details` (`{ event }`,\n   * the click or key press behind the change).\n   *\n   * With `items`, the selection follows the data: it reports every selected id, also ids whose\n   * rows are not rendered or not in `items` (filtered out, on another page, restored by id), and no\n   * change drops them. Select-all selects every item of `items` whose selection is not disabled\n   * (`isSelectionDisabled`, or the selection cell of its rendered row) and keeps every other id;\n   * when all of them are selected it removes only their ids. The select-all checkbox shows the\n   * state of those items. Both use the ids from `getRowId` (by default the item's index): a row\n   * that sets its own, different `rowId` (or a `DataGrid.Row` child whose `rowId` is no item's\n   * id) is outside them, and select-all then selects ids that no row has, with a development\n   * warning. Pass a `getRowId` that returns the rows' ids.\n   *\n   * Without `items` (rows written as `DataGrid.Row` children), ids of rows that are not rendered\n   * are left out of the reported selection and of the select-all state, so the next change drops\n   * them. Until that change an uncontrolled grid still holds such an id: a row re-added with the\n   * same `rowId` before then is shown selected again.\n   */\n  onSelectedItemsChange?: (\n    selectedItems: string[],\n    details?: DataGridSelectedItemsChangeDetails,\n  ) => void;\n  /** @deprecated Use `selectedItems` (an array). A `Set` or an array is accepted. */\n  selectedKeys?: ReadonlySet<string> | readonly string[];\n  /** @deprecated Use `defaultSelectedItems` (an array). A `Set` or an array is accepted. */\n  defaultSelectedKeys?: ReadonlySet<string> | readonly string[];\n  /** @deprecated Use `onSelectedItemsChange`, which receives an array. Both are called. */\n  onSelectionChange?: (keys: Set<string>) => void;\n  /**\n   * Props for the wrapper `<div>` around the `<table>`: a horizontally scrollable container\n   * (`overflow-x-auto`). Use it for its className, style (e.g. a max height) or ref. With a\n   * `virtualWindow` it is the window's scroller, which needs a bounded height. The wrapper\n   * is not a tab stop (the grid's own cell tab stop scrolls it) and has no role, so its\n   * `aria-label`/`aria-labelledby` are applied only together with a `role` (e.g. `'region'`);\n   * without one they are dropped with a development warning. Name the grid with `aria-label`.\n   */\n  containerProps?: Omit<React.ComponentPropsWithRef<'div'>, 'children'>;\n  /**\n   * DataGrid header, body, and row elements. Optional when `items` and `columns` render the grid;\n   * a generated body is placed after the header and before a `<tfoot>` child.\n   */\n  children?: React.ReactNode;\n  /** Ref to the `<table role=\"grid\">` element. */\n  ref?: React.Ref<HTMLTableElement>;\n}\n\ninterface NoDeprecatedSortProps {\n  sortColumn?: never;\n  defaultSortColumn?: never;\n  sortDirection?: never;\n  defaultSortDirection?: never;\n}\n\n/** The 0.5 sort API, controlled: `sort` + `onSortChange(sort, details)`. */\nexport interface DataGridControlledSortProps extends NoDeprecatedSortProps {\n  /** The controlled sort, or `null` for an unsorted grid. */\n  sort: DataGridSort | null;\n  /** Initial sort while `sort` is not given yet. */\n  defaultSort?: DataGridSort | null;\n  /**\n   * Called with the new sort when a sortable header is activated, then `details` (`{ event }`).\n   * With `items`, the grid orders its rows by the sorted column's `compare` (see\n   * `DataGridColumn.compare`), also while `sort` is controlled; otherwise the consumer orders them.\n   */\n  onSortChange?: (sort: DataGridSort, details?: DataGridSortChangeDetails) => void;\n}\n\n/** The 0.5 sort API, uncontrolled: `defaultSort` (`null` for none) + `onSortChange(sort, details)`. */\nexport interface DataGridUncontrolledSortProps extends NoDeprecatedSortProps {\n  sort?: undefined;\n  /** The initial sort, or `null` for an initially unsorted grid. */\n  defaultSort: DataGridSort | null;\n  /**\n   * Called with the new sort when a sortable header is activated, then `details` (`{ event }`).\n   * With `items`, the grid orders its rows by the sorted column's `compare` (see\n   * `DataGridColumn.compare`); otherwise the consumer orders them.\n   */\n  onSortChange?: (sort: DataGridSort, details?: DataGridSortChangeDetails) => void;\n}\n\n/**\n * The sort props of a grid with `items`: the 0.5 sort API, whether or not `sort` or `defaultSort`\n * is given (unsorted at first without them). The 0.4 positional `onSortChange` and the deprecated\n * sort props do not apply to such a grid.\n */\nexport interface DataGridItemsSortProps<T = unknown>\n  extends DataGridItemsProps<T>, NoDeprecatedSortProps {\n  /** The grid's data (see `DataGridItemsProps.items`). */\n  items: readonly T[];\n  /** The controlled sort, or `null` for an unsorted grid; `undefined` leaves the sort to the grid. */\n  sort?: DataGridSort | null;\n  /** The initial sort while `sort` is not given. */\n  defaultSort?: DataGridSort | null;\n  /**\n   * Called with the new sort when a sortable header is activated, then `details` (`{ event }`).\n   * The grid orders its rows by the sorted column's `compare` (see `DataGridColumn.compare`).\n   */\n  onSortChange?: (sort: DataGridSort, details?: DataGridSortChangeDetails) => void;\n}\n\n/**\n * The 0.4 sort API: `onSortChange(columnId, direction)` and the deprecated `sortColumn`/\n * `sortDirection` props. It applies whenever none of `items`, `sort` and `defaultSort` is given.\n * As in 0.4, the column and the direction can be controlled independently: the half that is not\n * controlled is kept internally and follows every sort request (mixed control, warned in\n * development).\n */\nexport interface DataGridLegacySortProps {\n  /** A grid with `items` uses the 0.5 sort API (`DataGridItemsSortProps`). */\n  items?: undefined;\n  sort?: undefined;\n  defaultSort?: undefined;\n  /**\n   * @deprecated Use `sort` (`{ columnId, direction }` or `null`). Without `sortDirection`, the\n   * direction is kept internally (it toggles on repeated clicks).\n   */\n  sortColumn?: string;\n  /** @deprecated Use `defaultSort`. */\n  defaultSortColumn?: string;\n  /**\n   * @deprecated Use `sort`. Without `sortColumn`, the column is kept internally (it follows the\n   * clicked header, starting from `defaultSortColumn`).\n   */\n  sortDirection?: SortDirection;\n  /** @deprecated Use `defaultSort`. */\n  defaultSortDirection?: SortDirection;\n  /**\n   * Called when a sortable header is activated, with the 0.4 arguments. Pass `items`, `sort` or\n   * `defaultSort` to receive a `DataGridSort` object (and `details`) instead:\n   * `defaultSort={null}` turns the object form on for an initially unsorted grid. A `sort` that is\n   * still `undefined` (e.g. while data loads) does not: pass `sort={sort ?? null}`.\n   *\n   * @example\n   * <DataGrid defaultSort={null} onSortChange={(sort) => setSort(sort)}>…</DataGrid>\n   */\n  onSortChange?: (columnId: string, direction: SortDirection) => void;\n}\n\n/**\n * Properties for the DataGrid component, whose `items` are of type `T`. The sort props form a\n * union: `sort`/`defaultSort` with `onSortChange(sort, details)` (0.5, also the form of every grid\n * with `items`), or the 0.4 form `onSortChange(columnId, direction)` with the deprecated\n * `sortColumn`/`sortDirection`/`defaultSortColumn`/`defaultSortDirection`, for a grid without\n * `items`. The two cannot be mixed.\n */\nexport type DataGridProps<T = unknown> = DataGridBaseProps<T> &\n  (\n    | (DataGridItemsProps<T> & DataGridControlledSortProps)\n    | (DataGridItemsProps<T> & DataGridUncontrolledSortProps)\n    | DataGridItemsSortProps<T>\n    | DataGridLegacySortProps\n  );\n\n/** Properties for the DataGridHeader sub-component. */\nexport interface DataGridHeaderProps extends React.HTMLAttributes<HTMLTableSectionElement> {\n  /**\n   * Header row elements. Each `<tr>` child (also inside a Fragment) gets the selection column's\n   * header cell prepended when the grid is selectable, unless the row holds a\n   * `DataGrid.SelectionCell` (which then is that cell, where it stands); a header row rendered by\n   * another component should be a `DataGrid.Row`, which adds the cell itself. With several header\n   * rows (a grouped header), only the first one gets the \"Select all rows\" control; later rows get\n   * an empty cell.\n   */\n  children: React.ReactNode;\n  /** Ref to the `<thead>` element. */\n  ref?: React.Ref<HTMLTableSectionElement>;\n}\n\n/** Properties for the DataGridHeaderCell sub-component. */\nexport interface DataGridHeaderCellProps extends React.ThHTMLAttributes<HTMLTableCellElement> {\n  /** Column ID used for sort tracking. Required for `sortable`. */\n  columnId?: string;\n  /**\n   * Whether this column can be sorted. The content is rendered inside a `<button>`; the header\n   * cell carries `aria-sort`. Ignored (with a development warning) without `columnId`.\n   * @default false\n   */\n  sortable?: boolean;\n  /**\n   * The glyph a sortable header shows after its content while its column is sorted, in place of\n   * the default arrow (up for ascending, down for descending). It is decorative (`aria-hidden`:\n   * `aria-sort` on the header tells the direction) and carries `data-direction` (`ascending` or\n   * `descending`), so one glyph can be turned by a selector on it. `null` and `undefined` keep the\n   * arrow; `false`, or any value that renders nothing, shows no glyph. A `<button>` or `Button`\n   * element (or a slot object whose `as` is one) is not nested in the sort button: its children\n   * become the glyph and its props are dropped, with a development warning.\n   */\n  sortIcon?: Slot<'span'>;\n  /** Header cell content. */\n  children: React.ReactNode;\n  /** Ref to the `<th>` element. */\n  ref?: React.Ref<HTMLTableCellElement>;\n}\n\n/** Properties for the DataGridBody sub-component, in a grid whose `items` are of type `T`. */\nexport interface DataGridBodyProps<T = unknown> extends Omit<\n  React.HTMLAttributes<HTMLTableSectionElement>,\n  'children'\n> {\n  /**\n   * The body rows: `DataGrid.Row` elements, or a render function called with each item of the\n   * grid's `items` (in the grid's sort order) and the item's index in `items` (its position there,\n   * whatever the sort), which returns the item's `DataGrid.Row`. The grid keys each returned row\n   * by its row id and gives it that id as `rowId` (from `getRowId`), and renders it again only\n   * when its item, its index or the function change (a sort moves the rows). Type the function\n   * by annotating its item parameter (`(person: Person) => …`) or with `DataGrid.Body<Person>`.\n   * Without children, a grid with `items` and `columns` renders the rows from the columns; empty\n   * children are no rows.\n   */\n  children?: React.ReactNode | ((item: T, index: number) => React.ReactNode);\n  /** Ref to the `<tbody>` element. */\n  ref?: React.Ref<HTMLTableSectionElement>;\n}\n\n/** Properties for the DataGridRow sub-component. */\nexport interface DataGridRowProps extends React.HTMLAttributes<HTMLTableRowElement> {\n  /**\n   * Unique identifier for this row, used for selection (rows that share one are selected together;\n   * a duplicate warns in development). A selectable grid renders no selection control (and warns\n   * in development) for a row without it. A row rendered from the grid's `items` (by\n   * `DataGrid.Body`'s render function or from `columns`) defaults to the item's row id\n   * (`getRowId`). In a grid with `items`, select-all uses the ids from `getRowId`: a row whose\n   * `rowId` differs from its item's id, or is no item's id, is outside it (a development warning\n   * says so), so set `getRowId` rather than a different `rowId`.\n   */\n  rowId?: string;\n  /**\n   * Accessible name of the row's selection control. Defaults to the row's first child that is a\n   * `DataGrid.Cell`, `<td>` or `<th>` element (`aria-labelledby`); a cell that another component\n   * renders is not seen, so pass `selectionLabel` when the row's first cell is one. Without such a\n   * child the control is named \"Select row\" (with a development warning). The selection cell's\n   * `aria-label` (`selectionCellProps`, or a `DataGrid.SelectionCell` child's) wins over it.\n   */\n  selectionLabel?: string;\n  /**\n   * Props of the row's selection cell (`disabled`, `invisible`, `className`, `aria-label`): the\n   * cell the row adds first in a selectable grid, or a `DataGrid.SelectionCell` child, whose own\n   * props win (their classes are merged). In a header row they apply to the select-all cell.\n   */\n  selectionCellProps?: DataGridRowSelectionCellProps;\n  /**\n   * DataGrid cell elements. A `DataGrid.SelectionCell` child (also inside a Fragment) is the row's\n   * selection cell, where it stands: the row then adds none.\n   */\n  children: React.ReactNode;\n  /** Ref to the `<tr>` element. */\n  ref?: React.Ref<HTMLTableRowElement>;\n}\n\n/** Properties for the DataGridCell sub-component. */\nexport interface DataGridCellProps extends React.TdHTMLAttributes<HTMLTableCellElement> {\n  /** Cell content. */\n  children: React.ReactNode;\n  /** Ref to the `<td>` element. */\n  ref?: React.Ref<HTMLTableCellElement>;\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nconst EMPTY_ITEMS: readonly string[] = [];\nconst NO_COLUMN_IDS: readonly (string | undefined)[] = [];\n\nfunction toItems(\n  keys: ReadonlySet<string> | readonly string[] | undefined,\n): readonly string[] | undefined {\n  return keys === undefined ? undefined : Array.from(keys);\n}\n\nfunction sameItems(a: readonly string[], b: readonly string[]): boolean {\n  return a.length === b.length && a.every((item, index) => item === b[index]);\n}\n\n/**\n * Select-all of a grid with `items`: adds every selectable id of the universe, or removes them\n * when all are selected; every other id (a selected disabled row, ids outside `items`) keeps its\n * state. The ids outside the universe come first, in their order, then the universe's in its own.\n */\nfunction toggleAllInUniverse(\n  previous: readonly string[],\n  universe: readonly string[],\n  selectable: readonly string[],\n): readonly string[] {\n  if (selectable.length === 0) return previous;\n  const current = new Set(previous);\n  // The state counts the selectable ids only, as the select-all checkbox shows it.\n  const next = summarizeSelection(current, selectable).all\n    ? clearIds(current, selectable)\n    : selectAllIds(current, selectable);\n  const inUniverse = new Set(universe);\n  return [\n    ...Array.from(next).filter((id) => !inUniverse.has(id)),\n    ...universe.filter((id) => next.has(id)),\n  ];\n}\n\n/** A child of {@link flattenChildren} under its flattened key (unique across the flattened list). */\nfunction renderFlatChild({ key, node }: { key: string; node: React.ReactNode }): React.ReactNode {\n  return <React.Fragment key={key}>{node}</React.Fragment>;\n}\n\n/**\n * The rows of a `DataGrid.Header`'s children as the header sees them: every element child, also\n * inside a Fragment (a `<tr>`, a `DataGrid.Row`, or a component that renders one row).\n */\nfunction countHeaderRows(children: React.ReactNode): number {\n  return flattenChildren(children).filter(({ node }) => React.isValidElement(node)).length;\n}\n\n/** A column's id: `columnId`, else the deprecated `id` (warned once). */\nfunction columnIdOf<T>(column: DataGridColumn<T>): string | undefined {\n  return resolveDeprecatedProp(\n    'DataGrid',\n    column.columnId,\n    column.id,\n    'columns[].id',\n    'columns[].columnId',\n  );\n}\n\nfunction warnDuplicateRowId(rowId: string): void {\n  warnOnce(\n    `DataGrid:duplicate-rowId:${rowId}`,\n    `DataGrid: several rows share the rowId \"${rowId}\". Row ids must be unique within a ` +\n      'DataGrid; rows with the same rowId are selected and deselected together.',\n  );\n}\n\n/** A body row: its hover and, per `selectionAppearance`, the fill of a selected row. */\nconst BODY_ROW_CLASSES: Record<DataGridSelectionAppearance, string> = {\n  brand:\n    'hover:bg-subtle-hover data-[selected]:bg-selected transition-colors motion-reduce:transition-none',\n  neutral:\n    'hover:bg-subtle-hover data-[selected]:bg-subtle-selected transition-colors motion-reduce:transition-none',\n  none: 'hover:bg-subtle-hover transition-colors motion-reduce:transition-none',\n};\n\n// ---------------------------------------------------------------------------\n// DataGrid\n// ---------------------------------------------------------------------------\n\n// The component-level JSDoc sits on the exported `DataGrid` below.\n//\n// Two call signatures. The first takes only a grid with `items` (`DataGridItemsSortProps`), so an\n// inline `onSortChange={(sort, details) => …}` next to `items` has one contextual type: in the\n// union of the second, `items` cannot tell the members apart while `T` is still being inferred\n// from it. Every other grid, a generic wrapper's `DataGridProps<T>` included, takes the second.\nfunction DataGridRoot<T>(\n  props: DataGridBaseProps<T> & DataGridItemsSortProps<T>,\n): React.JSX.Element;\nfunction DataGridRoot<T = unknown>(props: DataGridProps<T>): React.JSX.Element;\nfunction DataGridRoot<T>(props: DataGridProps<T>) {\n  const {\n    items,\n    getRowId,\n    isSelectionDisabled,\n    sort: sortProp,\n    defaultSort,\n    sortColumn: sortColumnProp,\n    defaultSortColumn,\n    sortDirection: sortDirectionProp,\n    defaultSortDirection,\n    onSortChange,\n    selectionMode = 'none',\n    selectedItems: selectedItemsProp,\n    defaultSelectedItems,\n    onSelectedItemsChange,\n    selectedKeys,\n    defaultSelectedKeys,\n    onSelectionChange,\n    labels,\n    selectOnRowClick = false,\n    selectionAppearance = 'brand',\n    subtleSelection = false,\n    columns,\n    resizableColumns = false,\n    columnSizingOptions,\n    columnWidths,\n    defaultColumnWidths,\n    onColumnWidthsChange,\n    virtualWindow,\n    containerProps,\n    children,\n    className,\n    style,\n    onKeyDown,\n    onFocus,\n    onBlur,\n    onPointerDownCapture,\n    ref,\n    ...rest\n  } = props;\n\n  // --- sort -----------------------------------------------------------------\n  const hasItems = items !== undefined;\n  /** The 0.5 sort props, which win over the deprecated ones. */\n  const usesSortApi = sortProp !== undefined || defaultSort !== undefined;\n  /**\n   * The 0.4 rules (the deprecated sort props, the positional callback) apply without `items`,\n   * `sort` and `defaultSort`.\n   */\n  const legacySort = !usesSortApi && !hasItems;\n  /** `onSortChange(sort, details)`; sticky, so the form never changes under the consumer. */\n  const [objectMode, setObjectMode] = React.useState(!legacySort);\n  if (!legacySort && !objectMode) setObjectMode(true);\n  const objectCallbacks = objectMode || !legacySort;\n\n  const legacySortControlled = sortColumnProp !== undefined || sortDirectionProp !== undefined;\n  if (sortColumnProp !== undefined) warnDeprecated('DataGrid', 'sortColumn', 'sort');\n  if (sortDirectionProp !== undefined) warnDeprecated('DataGrid', 'sortDirection', 'sort');\n  if (defaultSortColumn !== undefined) {\n    warnDeprecated('DataGrid', 'defaultSortColumn', 'defaultSort');\n  }\n  if (defaultSortDirection !== undefined) {\n    warnDeprecated('DataGrid', 'defaultSortDirection', 'defaultSort');\n  }\n  const deprecatedSortProps =\n    legacySortControlled || defaultSortColumn !== undefined || defaultSortDirection !== undefined;\n  const mixedSortApi = usesSortApi && deprecatedSortProps;\n  /** A grid with `items` (and no `sort`/`defaultSort`) ignores the deprecated sort props. */\n  const ignoredSortProps = !legacySort && !usesSortApi && deprecatedSortProps;\n\n  React.useEffect(() => {\n    if (mixedSortApi) {\n      warnOnce(\n        'DataGrid:mixed-sort',\n        'DataGrid: do not mix `sort`/`defaultSort` with the deprecated `sortColumn`/`sortDirection`/' +\n          '`defaultSortColumn`/`defaultSortDirection`. `sort`/`defaultSort` win.',\n      );\n    } else if (ignoredSortProps) {\n      warnOnce(\n        'DataGrid:items-deprecated-sort',\n        'DataGrid: the deprecated `sortColumn`/`sortDirection`/`defaultSortColumn`/' +\n          '`defaultSortDirection` do not apply to a grid with `items` and are ignored. Pass `sort` ' +\n          'or `defaultSort`.',\n      );\n    }\n  }, [mixedSortApi, ignoredSortProps]);\n  // 0.4 mixed control: `sortColumn` and `sortDirection` are controlled independently. The half the\n  // parent does not control is kept here (seeded from its default) and follows every sort request,\n  // as 0.4 did, so repeated clicks still alternate and aria-sort shows what was reported.\n  React.useEffect(() => {\n    if (!legacySort) return;\n    if (sortColumnProp !== undefined && sortDirectionProp === undefined) {\n      warnOnce(\n        'DataGrid:sortColumn-without-sortDirection',\n        'DataGrid: `sortColumn` is controlled but `sortDirection` is not (mixed control). The ' +\n          'direction is kept internally and toggles on repeated clicks, as in 0.4. Pass `sort` ' +\n          '(`{ columnId, direction }`) to control both.',\n      );\n    } else if (sortDirectionProp !== undefined && sortColumnProp === undefined) {\n      warnOnce(\n        'DataGrid:sortDirection-without-sortColumn',\n        'DataGrid: `sortDirection` is controlled but `sortColumn` is not (mixed control). The ' +\n          'column is kept internally and follows the clicked header, as in 0.4. Pass `sort` ' +\n          '(`{ columnId, direction }`) to control both.',\n      );\n    }\n  }, [legacySort, sortColumnProp, sortDirectionProp]);\n\n  /** The uncontrolled halves of the 0.4 sort props (used while the other half is controlled). */\n  const [legacyHalves, setLegacyHalves] = React.useState<{\n    column: string;\n    direction: SortDirection;\n  }>(() => ({\n    column: defaultSortColumn ?? '',\n    direction: defaultSortDirection ?? 'ascending',\n  }));\n\n  const legacyControlledSort = React.useMemo<DataGridSort | null | undefined>(() => {\n    if (sortColumnProp === undefined && sortDirectionProp === undefined) return undefined;\n    const column = sortColumnProp ?? legacyHalves.column;\n    return column === ''\n      ? null\n      : { columnId: column, direction: sortDirectionProp ?? legacyHalves.direction };\n  }, [sortColumnProp, sortDirectionProp, legacyHalves]);\n\n  const legacyDefaultSort = React.useMemo<DataGridSort | null>(\n    () =>\n      defaultSortColumn\n        ? { columnId: defaultSortColumn, direction: defaultSortDirection ?? 'ascending' }\n        : null,\n    [defaultSortColumn, defaultSortDirection],\n  );\n\n  const controlledSort = legacySort ? legacyControlledSort : sortProp;\n  // A grid with `items` and no `defaultSort` starts unsorted: the deprecated defaults are ignored.\n  let initialSort = legacyDefaultSort;\n  if (defaultSort !== undefined) initialSort = defaultSort;\n  else if (ignoredSortProps) initialSort = null;\n\n  // The details of the sort being requested, set around the setter: useControllable calls its\n  // onChange synchronously inside it, and only on change (the useCheckedValues pattern).\n  const sortDetailsRef = React.useRef<DataGridSortChangeDetails | undefined>(undefined);\n\n  const emitSortChange = (next: DataGridSort | null) => {\n    if (!next) return;\n    if (legacySort) {\n      setLegacyHalves((previous) =>\n        previous.column === next.columnId && previous.direction === next.direction\n          ? previous\n          : { column: next.columnId, direction: next.direction },\n      );\n    }\n    if (!onSortChange) return;\n    if (objectCallbacks) {\n      const objectForm = onSortChange as NonNullable<DataGridItemsSortProps['onSortChange']>;\n      objectForm(next, sortDetailsRef.current);\n    } else {\n      const legacy = onSortChange as (columnId: string, direction: SortDirection) => void;\n      legacy(next.columnId, next.direction);\n    }\n  };\n\n  const [sort, setSort] = useControllable<DataGridSort | null>(\n    controlledSort,\n    initialSort,\n    emitSortChange,\n  );\n\n  const requestSort = React.useCallback(\n    (columnId: string, event: Event) => {\n      sortDetailsRef.current = { event };\n      try {\n        setSort((previous) => ({\n          columnId,\n          direction:\n            previous?.columnId === columnId && previous.direction === 'ascending'\n              ? 'descending'\n              : 'ascending',\n        }));\n      } finally {\n        sortDetailsRef.current = undefined;\n      }\n    },\n    [setSort],\n  );\n\n  const sortContext = React.useMemo<DataGridSortContextValue>(\n    () => ({ sort, requestSort }),\n    [sort, requestSort],\n  );\n\n  // --- selection ------------------------------------------------------------\n  if (onSelectionChange !== undefined) {\n    warnDeprecated('DataGrid', 'onSelectionChange', 'onSelectedItemsChange');\n  }\n  const legacySelected = React.useMemo(() => toItems(selectedKeys), [selectedKeys]);\n  const legacyDefaultSelected = React.useMemo(\n    () => toItems(defaultSelectedKeys),\n    [defaultSelectedKeys],\n  );\n  const controlledSelected = resolveDeprecatedProp(\n    'DataGrid',\n    selectedItemsProp,\n    legacySelected,\n    'selectedKeys',\n    'selectedItems',\n  );\n  const defaultSelected =\n    resolveDeprecatedProp(\n      'DataGrid',\n      defaultSelectedItems,\n      legacyDefaultSelected,\n      'defaultSelectedKeys',\n      'defaultSelectedItems',\n    ) ?? EMPTY_ITEMS;\n\n  // The details of the change being made, set around the setter (as `sortDetailsRef`).\n  const selectionDetailsRef = React.useRef<DataGridSelectedItemsChangeDetails | undefined>(\n    undefined,\n  );\n\n  const emitSelectionChange = (next: readonly string[]) => {\n    onSelectedItemsChange?.([...next], selectionDetailsRef.current);\n    onSelectionChange?.(new Set(next));\n  };\n\n  const [selected, setSelectedValue] = useControllable<readonly string[]>(\n    controlledSelected,\n    defaultSelected,\n    emitSelectionChange,\n  );\n\n  const setSelected = React.useCallback(\n    (event: Event, update: (previous: readonly string[]) => readonly string[]) => {\n      selectionDetailsRef.current = { event };\n      try {\n        setSelectedValue(update);\n      } finally {\n        selectionDetailsRef.current = undefined;\n      }\n    },\n    [setSelectedValue],\n  );\n\n  // The rows of `items` (with `items` the selection follows them, rendered or not).\n  const itemRows = React.useMemo<readonly DataGridItemRowData[] | null>(() => {\n    if (items === undefined) return null;\n    const keys = new Set<string>();\n    return items.map((item, index) => {\n      const rowId = getRowId ? getRowId(item) : String(index);\n      // A repeated id (the selection store warns about it) still gets a key of its own.\n      const key = keys.has(rowId) ? `${rowId}\\u0000${index}` : rowId;\n      keys.add(key);\n      return { item, index, rowId, key };\n    });\n  }, [items, getRowId]);\n\n  // A grid without selection reads no item's selection state: nothing per item at data scale.\n  const selectable = selectionMode !== 'none';\n  const itemSelectionDisabled = React.useMemo<readonly boolean[] | null>(() => {\n    if (itemRows === null || !isSelectionDisabled || !selectable) return null;\n    // The rows hold the items as `unknown`; `isSelectionDisabled` takes the grid's `T`.\n    return itemRows.map((row) => isSelectionDisabled(row.item as T, row.index));\n  }, [itemRows, isSelectionDisabled, selectable]);\n\n  // Select-all covers every row id of `items`, rendered or not, but those `isSelectionDisabled`\n  // disables (a rendered row's own `disabled` is added by the row).\n  const selectionUniverse = React.useMemo<SelectionUniverse | null>(() => {\n    if (itemRows === null || !selectable) return null;\n    const disabledIds = new Set<string>();\n    if (itemSelectionDisabled) {\n      for (const row of itemRows) if (itemSelectionDisabled[row.index]) disabledIds.add(row.rowId);\n    }\n    return { ids: itemRows.map((row) => row.rowId), disabled: disabledIds };\n  }, [itemRows, itemSelectionDisabled, selectable]);\n\n  const single = selectionMode === 'single';\n  const [store] = React.useState(() => createSelectionStore(selected, single, selectionUniverse));\n  React.useLayoutEffect(() => {\n    store.setUniverse(selectionUniverse);\n  }, [store, selectionUniverse]);\n  React.useLayoutEffect(() => {\n    store.setSelected(selected);\n  }, [store, selected]);\n  React.useLayoutEffect(() => {\n    store.setSingleMode(single);\n  }, [store, single]);\n\n  const toggleRow = React.useCallback(\n    (rowId: string, event: Event) => {\n      setSelected(event, (previous) => {\n        let next: readonly string[];\n        if (hasItems) {\n          // With `items` a row changes its own id and keeps every other one, rendered or not.\n          // Single mode toggles the one selected id, the first (see the store), and clears it.\n          const current = new Set(single ? previous.slice(0, 1) : previous);\n          next = Array.from(\n            toggleId(current, rowId, single ? 'single' : 'multiple', { allowEmpty: true }),\n          );\n        } else {\n          const effective = store.prune(previous);\n          if (single) {\n            // Single mode shows the first selected row that is rendered (see the store).\n            next = effective[0] === rowId ? [] : [rowId];\n          } else {\n            next = effective.includes(rowId)\n              ? effective.filter((item) => item !== rowId)\n              : [...effective, rowId];\n          }\n        }\n        return sameItems(next, previous) ? previous : next;\n      });\n    },\n    [hasItems, single, setSelected, store],\n  );\n\n  const selectedCount = selected.length;\n  React.useEffect(() => {\n    if (single && selectedCount > 1) {\n      const which = hasItems ? 'the first one' : 'the first one that is rendered';\n      warnOnce(\n        'DataGrid:single-several-selected',\n        `DataGrid: a single-selection grid (selectionMode \"single\") has ${selectedCount} selected row ids; only ${which} is selected. Pass at most one id in \\`selectedItems\\`/\\`defaultSelectedItems\\`, or use selectionMode=\"multiple\".`,\n      );\n    }\n  }, [single, selectedCount, hasItems]);\n\n  // Rows whose selection is disabled keep their state: select-all selects (or clears) the others.\n  const toggleAll = React.useCallback(\n    (event: Event) => {\n      setSelected(event, (previous) => {\n        let next: readonly string[];\n        if (hasItems) {\n          next = toggleAllInUniverse(previous, store.getUniverseIds(), store.getSelectableIds());\n        } else {\n          const effective = new Set(store.prune(previous));\n          const all = store.getRegistered();\n          const enabled = all.filter((rowId) => !store.isDisabled(rowId));\n          const allSelected = enabled.length > 0 && enabled.every((rowId) => effective.has(rowId));\n          next = allSelected\n            ? all.filter((rowId) => store.isDisabled(rowId) && effective.has(rowId))\n            : all.filter((rowId) => !store.isDisabled(rowId) || effective.has(rowId));\n        }\n        return sameItems(next, previous) ? previous : next;\n      });\n    },\n    [hasItems, setSelected, store],\n  );\n\n  const radioName = useId('wave-datagrid-selection');\n  const selectAllLabel = labels?.selectAll ?? DEFAULT_SELECT_ALL_LABEL;\n  const selectionHeaderLabel = labels?.selectionHeader ?? DEFAULT_SELECTION_HEADER_LABEL;\n\n  const context = React.useMemo<DataGridContextValue>(\n    () => ({\n      selectionMode,\n      store,\n      toggleRow,\n      toggleAll,\n      radioName,\n      selectAllLabel,\n      selectionHeaderLabel,\n      selectOnRowClick,\n      selectionAppearance,\n      subtleSelection,\n    }),\n    [\n      selectionMode,\n      store,\n      toggleRow,\n      toggleAll,\n      radioName,\n      selectAllLabel,\n      selectionHeaderLabel,\n      selectOnRowClick,\n      selectionAppearance,\n      subtleSelection,\n    ],\n  );\n\n  // --- items (the rows of `items` are built with the selection above) -------------\n  // Built-in sorting: by the `compare` of the sorted column (controlled `sort` included).\n  const sortColumnId = sort?.columnId;\n  const sortDirection = sort?.direction;\n  const sortCompare = React.useMemo(() => {\n    if (!hasItems || sortColumnId === undefined || !columns) return undefined;\n    return columns.find((column) => columnIdOf(column) === sortColumnId)?.compare;\n  }, [hasItems, sortColumnId, columns]);\n\n  const sortedRows = React.useMemo(() => {\n    if (itemRows === null || !sortCompare) return itemRows;\n    // The rows hold the items as `unknown`; `compare` takes the grid's `T`.\n    const compare = sortCompare as (a: unknown, b: unknown) => number;\n    // A stable sort of a copy (never in place, never reversed): items that compare equal keep\n    // their order in `items` in both directions, since descending negates `compare`.\n    return itemRows\n      .slice()\n      .sort(\n        sortDirection === 'descending'\n          ? (a, b) => -compare(a.item, b.item)\n          : (a, b) => compare(a.item, b.item),\n      );\n  }, [itemRows, sortCompare, sortDirection]);\n\n  // Built only with `items`: the column ids are read (and the deprecated `id` warned) when used.\n  const renderColumnsRow = React.useMemo<DataGridRenderRow | null>(() => {\n    if (!columns || !hasItems) return null;\n    const cellKeys = columns.map((column, index) => columnIdOf(column) ?? index);\n    return (item) => (\n      <DataGridRow>\n        {columns.map((column, index) => (\n          <DataGridCell key={cellKeys[index]}>{column.renderCell?.(item as T)}</DataGridCell>\n        ))}\n      </DataGridRow>\n    );\n  }, [columns, hasItems]);\n\n  const itemsContext = React.useMemo<DataGridItemsContextValue>(\n    () => ({ rows: sortedRows, renderColumnsRow, selectionDisabled: itemSelectionDisabled }),\n    [sortedRows, renderColumnsRow, itemSelectionDisabled],\n  );\n\n  const columnWithoutId =\n    columns?.some((column) => column.columnId === undefined && column.id === undefined) ?? false;\n  React.useEffect(() => {\n    if (columnWithoutId) {\n      warnOnce(\n        'DataGrid:column-without-columnId',\n        'DataGrid: a column in `columns` has no `columnId` (nor the deprecated `id`), so its ' +\n          'header cannot sort. Give every column a unique `columnId`.',\n      );\n    }\n  }, [columnWithoutId]);\n\n  // --- window (with `items`, `columns` and the body rows rendered from them) -------\n  const flatChildren = columns ? flattenChildren(children) : [];\n  const childOf = (part: unknown) =>\n    flatChildren.find(({ node }) => isElementOfType(node, part))?.node;\n  const headerChild = childOf(DataGridHeader);\n  const bodyChild = childOf(DataGridBody);\n  const bodyChildren = isElementOfType<DataGridBodyProps>(bodyChild, DataGridBody)\n    ? bodyChild.props.children\n    : undefined;\n  /** The window while it applies: the body rows are rendered from `items` (columns, a function). */\n  const activeWindow =\n    virtualWindow !== undefined &&\n    hasItems &&\n    columns !== undefined &&\n    (bodyChildren === undefined || typeof bodyChildren === 'function')\n      ? virtualWindow\n      : null;\n  const windowed = activeWindow !== null;\n  // A grid with `columns` has one generated header row unless a `DataGrid.Header` child is given.\n  const headerRowCount = isElementOfType<DataGridHeaderProps>(headerChild, DataGridHeader)\n    ? countHeaderRows(headerChild.props.children)\n    : 1;\n  const rowCount = items?.length ?? 0;\n\n  // --- keyboard -------------------------------------------------------------\n  // A windowed grid moves by the rows of the data: an unmounted target is scrolled in first.\n  const { gridRef, gridProps, activeRowIndex, pendingRowIndex } = useGridNavigation({\n    model: getWindowNavigationModel(activeWindow, rowCount, headerRowCount),\n  });\n  const windowState = useDataGridWindow({\n    virtualWindow: activeWindow,\n    ignored: virtualWindow !== undefined && !windowed,\n    rows: sortedRows,\n    headerRowCount,\n    columnCount: (columns?.length ?? 0) + (selectable ? 1 : 0),\n    activeRowIndex,\n    pendingRowIndex,\n  });\n  const mergedRef = useMergedRefs<HTMLTableElement>(ref, gridRef, windowState.tableRef);\n  const handleFocus = (event: React.FocusEvent<HTMLTableElement>) => {\n    gridProps.onFocus(event);\n    windowState.onFocus(event);\n  };\n  const handleBlur = (event: React.FocusEvent<HTMLTableElement>) => {\n    gridProps.onBlur(event);\n    windowState.onBlur(event);\n  };\n\n  // --- column widths (with `columns` and `items`) --------------------------------\n  const sizingRequested =\n    resizableColumns ||\n    columnSizingOptions !== undefined ||\n    columnWidths !== undefined ||\n    defaultColumnWidths !== undefined;\n  const sizingIgnored = sizingRequested && !(columns && hasItems);\n  React.useEffect(() => {\n    if (sizingIgnored) {\n      warnOnce(\n        'DataGrid:resizable-columns-require-columns',\n        'DataGrid: `resizableColumns`, `columnSizingOptions`, `columnWidths` and ' +\n          '`defaultColumnWidths` need the `columns` prop together with `items`, and are ignored ' +\n          'without them. Render the grid from `items` and `columns`.',\n      );\n    }\n  }, [sizingIgnored]);\n  // A windowed grid is laid out from widths too: its columns never follow the rendered rows.\n  const sizingEnabled = (sizingRequested && !sizingIgnored) || windowed;\n  // Read (and the deprecated `id` warned) only when the widths are used.\n  const columnIds = React.useMemo(\n    () => (sizingEnabled && columns ? columns.map(columnIdOf) : NO_COLUMN_IDS),\n    [sizingEnabled, columns],\n  );\n  const sizing = useDataGridColumnSizing({\n    enabled: sizingEnabled,\n    resizable: resizableColumns,\n    columnIds,\n    selectionColumn: selectionMode !== 'none',\n    columnSizingOptions,\n    columnWidths,\n    defaultColumnWidths,\n    onColumnWidthsChange,\n    resizeColumnLabel: labels?.resizeColumn,\n    columnWidthText: labels?.columnWidth,\n  });\n\n  // --- header and body from columns -------------------------------------------\n  let content: React.ReactNode = children;\n  const generatedHeader =\n    columns && headerChild === undefined ? (\n      <DataGridHeader key=\"wave-generated-header\">\n        <tr>\n          {columns.map((column, index) => {\n            const columnId = columnIdOf(column);\n            return (\n              <DataGridHeaderCell\n                key={columnId ?? index}\n                columnId={columnId}\n                sortable={column.sortable ?? column.compare !== undefined}\n              >\n                {column.renderHeaderCell ? column.renderHeaderCell() : column.label}\n              </DataGridHeaderCell>\n            );\n          })}\n        </tr>\n      </DataGridHeader>\n    ) : null;\n  // Without children, the body renders the rows from `columns` (see DataGrid.Body).\n  const generatedBody =\n    columns && hasItems && bodyChild === undefined ? (\n      <DataGridBody key=\"wave-generated-body\" />\n    ) : null;\n  if (generatedHeader || generatedBody || sizing.colgroup) {\n    // A `<caption>` stays the table's first child, before the column widths and the generated\n    // header; a generated body goes before a `<tfoot>`, which ends the table.\n    const isCaption = ({ node }: { node: React.ReactNode }) => isElementOfType(node, 'caption');\n    const others = flatChildren.filter((child) => !isCaption(child));\n    const footerIndex = generatedBody\n      ? others.findIndex(({ node }) => isElementOfType(node, 'tfoot'))\n      : -1;\n    const bodyIndex = footerIndex >= 0 ? footerIndex : others.length;\n    content = [\n      ...flatChildren.filter(isCaption).map(renderFlatChild),\n      sizing.colgroup,\n      generatedHeader,\n      ...others.slice(0, bodyIndex).map(renderFlatChild),\n      generatedBody,\n      ...others.slice(bodyIndex).map(renderFlatChild),\n    ];\n  }\n\n  const {\n    className: containerClassName,\n    'aria-label': containerLabel,\n    'aria-labelledby': containerLabelledBy,\n    ref: containerRefProp,\n    ...containerRest\n  } = containerProps ?? {};\n  // With a window, the wrapper is its scroller.\n  const containerRef = useMergedRefs<HTMLDivElement>(\n    containerRefProp,\n    windowState.scrollerRef,\n    activeWindow?.scrollRef,\n  );\n  // The wrapper has no role of its own, and a name is prohibited on a role-less `<div>`: the\n  // consumer's name is kept only together with a role.\n  const containerHasRole = containerRest.role !== undefined;\n  const droppedContainerName =\n    !containerHasRole && (containerLabel !== undefined || containerLabelledBy !== undefined);\n\n  React.useEffect(() => {\n    if (droppedContainerName) {\n      warnOnce(\n        'DataGrid:container-name-without-role',\n        'DataGrid: `containerProps[\"aria-label\"]`/`[\"aria-labelledby\"]` is ignored because the ' +\n          'wrapper has no role. Name the grid itself (`aria-label` on DataGrid), or pass a ' +\n          '`role` (e.g. \"region\") in `containerProps` too.',\n      );\n    }\n  }, [droppedContainerName]);\n\n  return (\n    <DataGridContext.Provider value={context}>\n      <DataGridSortContext.Provider value={sortContext}>\n        <DataGridItemsContext.Provider value={itemsContext}>\n          {/* Reset for a grid nested in a cell: its rows are not the outer row. */}\n          <DataGridRowContext.Provider value={null}>\n            <DataGridRowIdContext.Provider value={null}>\n              <DataGridItemSelectionDisabledContext.Provider value={undefined}>\n                <DataGridResizeContext.Provider value={sizing.resizeContext}>\n                  <DataGridFixedLayoutContext.Provider value={sizing.colgroup !== null}>\n                    <div\n                      // A windowed grid's tab stop is its cell: the scroller is none of its own\n                      // (Firefox makes a scroller a tab stop). `containerProps.tabIndex` wins.\n                      tabIndex={windowed ? -1 : undefined}\n                      {...containerRest}\n                      ref={containerRef}\n                      aria-label={containerHasRole ? containerLabel : undefined}\n                      aria-labelledby={containerHasRole ? containerLabelledBy : undefined}\n                      className={cn(\n                        dataGridClassNames.container,\n                        'overflow-x-auto rounded-md border border-border',\n                        // The window lays the rows out: the browser's scroll anchoring only\n                        // fights it.\n                        windowed && '[overflow-anchor:none]',\n                        containerClassName,\n                      )}\n                    >\n                      <table\n                        ref={mergedRef}\n                        role=\"grid\"\n                        aria-multiselectable={selectionMode === 'multiple' || undefined}\n                        // With a window: every row of the data, rendered or not, and the header.\n                        aria-rowcount={windowed ? rowCount + headerRowCount : undefined}\n                        data-selection-appearance={selectionAppearance}\n                        data-subtle-selection={subtleSelection ? '' : undefined}\n                        data-resizing={sizing.resizing ? '' : undefined}\n                        className={cn(\n                          dataGridClassNames.root,\n                          'w-full border-separate border-spacing-0',\n                          // The group whose hover or focus draws the subtle select-all checkbox.\n                          subtleSelection && 'group/grid',\n                          className,\n                        )}\n                        // The widths are runtime data: the layout and the width are inline.\n                        style={sizing.tableStyle ? { ...sizing.tableStyle, ...style } : style}\n                        {...rest}\n                        onKeyDown={composeEventHandlers(onKeyDown, gridProps.onKeyDown)}\n                        onFocus={composeEventHandlers(onFocus, handleFocus, {\n                          checkDefaultPrevented: false,\n                        })}\n                        onBlur={composeEventHandlers(onBlur, handleBlur, {\n                          checkDefaultPrevented: false,\n                        })}\n                        onPointerDownCapture={composeEventHandlers(\n                          onPointerDownCapture,\n                          windowState.onPointerDownCapture,\n                        )}\n                      >\n                        <DataGridWindowContext.Provider value={windowState.context}>\n                          <DataGridWindowRowContext.Provider value={null}>\n                            {content}\n                          </DataGridWindowRowContext.Provider>\n                        </DataGridWindowContext.Provider>\n                      </table>\n                    </div>\n                  </DataGridFixedLayoutContext.Provider>\n                </DataGridResizeContext.Provider>\n              </DataGridItemSelectionDisabledContext.Provider>\n            </DataGridRowIdContext.Provider>\n          </DataGridRowContext.Provider>\n        </DataGridItemsContext.Provider>\n      </DataGridSortContext.Provider>\n    </DataGridContext.Provider>\n  );\n}\nDataGridRoot.displayName = 'DataGrid';\n\n/**\n * The row of one item of `items`, under its row id. Memoised, so a grid that renders again (a\n * sort, a parent update) renders the row again only when its item, its index, its\n * `isSelectionDisabled`, the render function or, in a windowed grid, its place change.\n */\nconst DataGridItemRow = React.memo(function DataGridItemRow({\n  item,\n  index,\n  rowId,\n  selectionDisabled,\n  render,\n  position,\n  ariaRowIndex,\n  height,\n}: {\n  item: unknown;\n  index: number;\n  rowId: string;\n  /** `isSelectionDisabled` of the item; `undefined` without it. */\n  selectionDisabled: boolean | undefined;\n  render: DataGridRenderRow;\n  /** In a windowed grid: the row's position in the sorted order (`undefined` without a window). */\n  position?: number;\n  /** In a windowed grid: the row's `aria-rowindex`. */\n  ariaRowIndex?: number;\n  /** In a windowed grid: the row's height (the window's `itemSize`). */\n  height?: number;\n}) {\n  const windowRow = React.useMemo<DataGridWindowRow | null>(\n    () =>\n      position === undefined || ariaRowIndex === undefined\n        ? null\n        : { index: position, ariaRowIndex, height },\n    [position, ariaRowIndex, height],\n  );\n  return (\n    <DataGridRowIdContext.Provider value={rowId}>\n      <DataGridItemSelectionDisabledContext.Provider value={selectionDisabled}>\n        <DataGridWindowRowContext.Provider value={windowRow}>\n          {render(item, index)}\n        </DataGridWindowRowContext.Provider>\n      </DataGridItemSelectionDisabledContext.Provider>\n    </DataGridRowIdContext.Provider>\n  );\n});\n\n/**\n * The grid's `<tbody>`. Its child can also be a render function, called with each item of the\n * grid's `items` (and its index there) to render the item's row; without children, a grid with\n * `items` and `columns` renders the rows from the columns. In a grid with a `virtualWindow` it\n * renders the rows of the window, the function being called for those rows only, and a spacer\n * row for each run of rows it leaves out.\n */\nconst DataGridBody = <T,>({ children, className, ref, ...rest }: DataGridBodyProps<T>) => {\n  const itemsContext = React.useContext(DataGridItemsContext);\n  const windowContext = React.useContext(DataGridWindowContext);\n  const rows = itemsContext?.rows ?? null;\n  const hasRenderFunction = typeof children === 'function';\n\n  const renderWithoutItems = hasRenderFunction && rows === null;\n  React.useEffect(() => {\n    if (renderWithoutItems) {\n      warnOnce(\n        'DataGrid.Body:render-without-items',\n        \"DataGrid.Body: a render function child renders one row per item of the DataGrid's \" +\n          '`items`, which is not set, so the body has no rows.',\n      );\n    }\n  }, [renderWithoutItems]);\n\n  const selectionDisabled = itemsContext?.selectionDisabled ?? null;\n  const renderRows = (render: DataGridRenderRow | null) => {\n    if (!render || !rows) return null;\n    if (windowContext) {\n      // The rows of the window, at their place in the sorted order (after the header rows).\n      const { headerRowCount, virtualWindow } = windowContext;\n      return renderWindowRows(windowContext, rows.length, (position) => {\n        const row = rows[position];\n        return (\n          <DataGridItemRow\n            key={`row:${row.key}`}\n            item={row.item}\n            index={row.index}\n            rowId={row.rowId}\n            selectionDisabled={selectionDisabled?.[row.index]}\n            render={render}\n            position={position}\n            ariaRowIndex={position + headerRowCount + 1}\n            height={virtualWindow.itemSize}\n          />\n        );\n      });\n    }\n    return rows.map((row) => (\n      <DataGridItemRow\n        key={row.key}\n        item={row.item}\n        index={row.index}\n        rowId={row.rowId}\n        selectionDisabled={selectionDisabled?.[row.index]}\n        render={render}\n      />\n    ));\n  };\n\n  let content: React.ReactNode;\n  if (typeof children === 'function') {\n    // The items are the grid's `T`, which the body cannot see: its own `T` types the function.\n    content = renderRows(children as DataGridRenderRow);\n  } else if (children === undefined) {\n    content = renderRows(itemsContext?.renderColumnsRow ?? null);\n  } else {\n    content = children;\n  }\n\n  return (\n    <DataGridSectionContext.Provider value=\"body\">\n      <tbody ref={ref} className={cn(dataGridBodyClassNames.root, className)} {...rest}>\n        {content}\n      </tbody>\n    </DataGridSectionContext.Provider>\n  );\n};\nDataGridBody.displayName = 'DataGridBody';\n\n/**\n * A grid row. In a selectable grid it starts with a selection cell (checkbox or radio) named\n * after the row's first cell (or `selectionLabel`), unless a `DataGrid.SelectionCell` child is\n * its selection cell; Space on one of its cells toggles the row, and so does a click on the row\n * with the grid's `selectOnRowClick`.\n *\n * The row is the `group/table-row` group whose hover or focus draws a subtle selection control\n * (`subtleSelection`) and the `Table.CellActions` of its cells. A group is matched by any\n * ancestor, so the rows of a grid nested in a cell\n * share it: hovering the outer row also draws the subtle controls of the nested grid (a limit of\n * CSS groups). A Tree in a cell keeps its own rows' group.\n *\n * In a grid with a `virtualWindow`, a row rendered for an item has the window's `itemSize` as its\n * height (its own `style` height loses) and carries `aria-rowindex` and `data-row-index`; a header\n * row carries `aria-rowindex`.\n */\nconst DataGridRow = ({\n  rowId: rowIdProp,\n  selectionLabel,\n  selectionCellProps,\n  children,\n  className,\n  style,\n  onClick,\n  onKeyDown,\n  ref,\n  ...rest\n}: DataGridRowProps) => {\n  const { selectionMode, store, toggleRow, selectOnRowClick, selectionAppearance } =\n    useDataGridContext('DataGrid.Row');\n  // In a windowed grid: the row's place (and, for a body row, its fixed height).\n  const windowRow = React.useContext(DataGridWindowRowContext);\n  // A row rendered for an item of `items` defaults to the item's row id.\n  const itemRowId = React.useContext(DataGridRowIdContext);\n  const rowId = rowIdProp ?? itemRowId ?? undefined;\n  const section = React.useContext(DataGridSectionContext);\n  const firstHeaderRowHint = React.useContext(DataGridHeaderRowHintContext);\n  const inHeader = section === 'header';\n  const selectable = selectionMode !== 'none' && !inHeader;\n  const labelId = useId('wave-datagrid-row-label');\n\n  // The children are always flattened (Fragments too) and rendered under their flattened keys,\n  // whatever the mode, so the keys stay the same when `selectionMode`, `selectionLabel` or `rowId`\n  // change and the cells are not remounted.\n  const flatChildren = flattenChildren(children);\n  // A DataGrid.SelectionCell child is the row's selection cell; its own props win.\n  let ownCellProps: DataGridSelectionCellProps | undefined;\n  for (const { node } of flatChildren) {\n    if (isSelectionCellElement(node)) {\n      ownCellProps = node.props;\n      break;\n    }\n  }\n  const hasSelectionCell = ownCellProps !== undefined;\n  // A row rendered for an item takes `isSelectionDisabled` of the item, unless its cell says.\n  const itemSelectionDisabled = React.useContext(DataGridItemSelectionDisabledContext);\n  const cellDisabled = ownCellProps?.disabled ?? selectionCellProps?.disabled;\n  const selectionDisabled = cellDisabled ?? itemSelectionDisabled ?? false;\n  const selectionInvisible = ownCellProps?.invisible ?? selectionCellProps?.invisible ?? false;\n  const ownLabelledBy = ownCellProps?.['aria-labelledby'];\n  const ownLabel =\n    ownCellProps?.['aria-label'] ?? selectionCellProps?.['aria-label'] ?? selectionLabel;\n\n  const single = selectionMode === 'single';\n  const getSelected = React.useCallback(\n    () => rowId !== undefined && store.isSelected(rowId, single),\n    [rowId, store, single],\n  );\n  // Notified only when the selection changes (in multiple mode, rows registering notify no row).\n  const isSelected = React.useSyncExternalStore(store.subscribe, getSelected, getSelected);\n\n  React.useLayoutEffect(() => {\n    if (rowId === undefined || inHeader) return;\n    const unregister = store.register(rowId);\n    if (isDev && store.countRegistrations(rowId) > 1) warnDuplicateRowId(rowId);\n    return unregister;\n  }, [store, rowId, inHeader]);\n\n  // A row whose selection is disabled is left out of select-all.\n  React.useLayoutEffect(() => {\n    if (rowId === undefined || inHeader || !selectionDisabled) return;\n    return store.disable(rowId);\n  }, [store, rowId, inHeader, selectionDisabled]);\n\n  React.useEffect(() => {\n    if (selectable && rowId === undefined) {\n      warnOnce(\n        'DataGrid.Row:missing-rowId',\n        'DataGrid.Row: a selectable grid needs a `rowId` on every row; this row has no selection control.',\n      );\n    }\n  }, [selectable, rowId]);\n\n  const disabledMismatch =\n    selectable &&\n    rowId !== undefined &&\n    itemSelectionDisabled !== undefined &&\n    cellDisabled !== undefined &&\n    cellDisabled !== itemSelectionDisabled;\n  React.useEffect(() => {\n    if (!disabledMismatch) return;\n    const state = (disabled: boolean) => (disabled ? 'disabled' : 'enabled');\n    warnOnce(\n      'DataGrid:selection-disabled-mismatch',\n      `DataGrid: the selection cell of row \"${rowId}\" is ${state(selectionDisabled)} (\\`DataGrid.SelectionCell disabled\\` or \\`selectionCellProps.disabled\\`), but \\`isSelectionDisabled\\` says its item is ${state(!selectionDisabled)}. Select-all skips a row that either one disables, and the row's control follows its cell: make them agree, or leave the cell's \\`disabled\\` unset to take it from \\`isSelectionDisabled\\`.`,\n    );\n  }, [disabledMismatch, rowId, selectionDisabled]);\n\n  // With `items`, select-all uses the ids from `getRowId`: a row with another id is outside it.\n  const ownRowIdDiffers =\n    selectable && rowIdProp !== undefined && itemRowId !== null && rowIdProp !== itemRowId;\n  React.useEffect(() => {\n    if (ownRowIdDiffers) {\n      warnOnce(\n        'DataGrid.Row:row-id-mismatch',\n        \"DataGrid.Row: a row rendered from the grid's `items` sets its own `rowId`, which differs from its item's id (`getRowId`, by default the item's index). Select-all and its checkbox use the ids from `getRowId`, so the row is outside them and select-all selects ids that no row has. Pass a `getRowId` that returns the row's id, and leave out `rowId`.\",\n      );\n    } else if (\n      selectable &&\n      rowId !== undefined &&\n      itemRowId === null &&\n      store.isOutsideUniverse(rowId)\n    ) {\n      // A `DataGrid.Row` child of a grid with `items` (not rendered for an item).\n      warnOnce(\n        'DataGrid.Row:row-id-outside-items',\n        \"DataGrid.Row: a selectable row in a grid with `items` has a `rowId` that is no item's id (`getRowId`, by default the item's index). Select-all and its checkbox use the ids of `items`, so the row is outside them. Render the rows from `items` (a `DataGrid.Body` render function, or `columns`) with a `getRowId` that returns their ids.\",\n      );\n    }\n  }, [ownRowIdDiffers, selectable, rowId, itemRowId, store]);\n\n  const unlabelled =\n    selectable && rowId !== undefined && ownLabel === undefined && ownLabelledBy === undefined;\n\n  const handleKeyDown = (event: React.KeyboardEvent<HTMLTableRowElement>) => {\n    if (!selectable || rowId === undefined || event.key !== ' ') return;\n    const target = event.target as Element;\n    // Only keys pressed on the row itself or on one of its own cells, never on a nested widget.\n    if (target !== event.currentTarget && target.parentElement !== event.currentTarget) return;\n    // A row whose selection is disabled takes the key too (no page scroll), and stays as it is.\n    event.preventDefault();\n    if (!selectionDisabled) toggleRow(rowId, event.nativeEvent);\n  };\n\n  const handleClick = (event: React.MouseEvent<HTMLTableRowElement>) => {\n    if (!selectOnRowClick || !selectable || rowId === undefined || selectionDisabled) return;\n    const row = event.currentTarget;\n    // The row's own cells carry the grid's tabindex; they are not widgets nested in the row.\n    const nested = isForeignEvent(event, { isOwnPart: (element) => element.parentElement === row });\n    if (nested || endsTextSelection(event)) return;\n    toggleRow(rowId, event.nativeEvent);\n  };\n\n  // Name the selection control after the first cell (its own id, or a generated one).\n  let labelledBy: string | undefined;\n  let idCellIndex = -1;\n  if (unlabelled) {\n    const firstCellIndex = flatChildren.findIndex(({ node }) =>\n      isElementOfType(node, DataGridCell, 'td', 'th'),\n    );\n    if (firstCellIndex >= 0) {\n      const firstCell = flatChildren[firstCellIndex].node as React.ReactElement<{ id?: string }>;\n      labelledBy = firstCell.props.id ?? labelId;\n      if (firstCell.props.id === undefined) idCellIndex = firstCellIndex;\n    }\n  }\n  const content = flatChildren.map(({ key, node }, index) =>\n    renderFlatChild({\n      key,\n      node:\n        index === idCellIndex\n          ? React.cloneElement(node as React.ReactElement<{ id?: string }>, { id: labelId })\n          : node,\n    }),\n  );\n\n  const needsLabel = unlabelled && labelledBy === undefined;\n  React.useEffect(() => {\n    if (needsLabel) {\n      warnOnce(\n        'DataGrid.Row:selection-label',\n        'DataGrid.Row: no child is a `DataGrid.Cell`, `<td>` or `<th>` element, so the row selection control is named \"Select row\". Pass `selectionLabel` (a cell rendered by another component is not seen).',\n      );\n    }\n  }, [needsLabel]);\n\n  // The selection control's name: the cell's own, else the row's first cell, else \"Select row\".\n  const controlLabelledBy = ownLabelledBy ?? labelledBy;\n  const controlLabel = ownLabel ?? (controlLabelledBy === undefined ? 'Select row' : undefined);\n\n  const rowContext = React.useMemo<DataGridRowContextValue>(\n    () => ({\n      selectionCellProps,\n      hasSelectionCell,\n      rowId: selectable ? rowId : undefined,\n      isSelected,\n      disabled: selectionDisabled,\n      invisible: selectionInvisible,\n      ariaLabel: controlLabel,\n      ariaLabelledBy: controlLabelledBy,\n    }),\n    [\n      selectionCellProps,\n      hasSelectionCell,\n      selectable,\n      rowId,\n      isSelected,\n      selectionDisabled,\n      selectionInvisible,\n      controlLabel,\n      controlLabelledBy,\n    ],\n  );\n\n  // The automatic selection cell, first; a DataGrid.SelectionCell child renders it where it stands.\n  let selectionCellElement: React.ReactNode = null;\n  if (!hasSelectionCell && inHeader && selectionMode !== 'none') {\n    selectionCellElement = (\n      <DataGridSelectionHeaderSlot\n        selectionMode={selectionMode}\n        initialFirst={firstHeaderRowHint}\n        cellProps={selectionCellProps}\n      />\n    );\n  } else if (!hasSelectionCell && selectable) {\n    selectionCellElement = <DataGridBodySelectionCell component=\"DataGrid.Row\" />;\n  }\n\n  return (\n    <DataGridRowContext.Provider value={rowContext}>\n      <tr\n        ref={ref}\n        className={cn(\n          dataGridRowClassNames.root,\n          // The group whose hover or focus draws a subtle selection control (its own name: a\n          // Tree in a cell keys its actions on its rows' `group/row`).\n          'group/table-row',\n          !inHeader && BODY_ROW_CLASSES[selectionAppearance],\n          selectable && isSelected && forcedColors.selectedContainer,\n          className,\n        )}\n        aria-selected={selectable ? isSelected : undefined}\n        data-selected={selectable && isSelected ? '' : undefined}\n        {...rest}\n        // The window lays the rows out at its row height and finds them by their index.\n        style={windowRow?.height === undefined ? style : { ...style, height: windowRow.height }}\n        {...(windowRow && {\n          'aria-rowindex': windowRow.ariaRowIndex,\n          'data-row-index': windowRow.index,\n        })}\n        onClick={composeEventHandlers(onClick, handleClick)}\n        onKeyDown={composeEventHandlers(onKeyDown, handleKeyDown)}\n      >\n        {selectionCellElement}\n        {content}\n      </tr>\n    </DataGridRowContext.Provider>\n  );\n};\nDataGridRow.displayName = 'DataGridRow';\n\n/** Props of {@link DataGridBodySelectionCell}: the cell's own, without what the row resolved. */\ninterface DataGridBodySelectionCellProps extends Omit<\n  DataGridSelectionCellProps,\n  'disabled' | 'invisible' | 'aria-label' | 'aria-labelledby'\n> {\n  /** The public name of the part that renders the cell, for the context errors. */\n  component: string;\n  /** The root class of `DataGrid.SelectionCell`, when the cell is one. */\n  stableClassName?: string;\n}\n\n/**\n * The selection cell of a body row (internal): the row's checkbox (multiple mode) or radio (single\n * mode), the automatic first cell or a `DataGrid.SelectionCell`. Its state, `disabled`,\n * `invisible` and name come from the row.\n */\nfunction DataGridBodySelectionCell({\n  component,\n  stableClassName,\n  className,\n  controlRef,\n  'aria-describedby': ariaDescribedBy,\n  ref,\n  ...rest\n}: DataGridBodySelectionCellProps) {\n  const { selectionMode, toggleRow, radioName, subtleSelection } = useDataGridContext(component);\n  const row = useDataGridRowContext(component);\n  // A body row of a windowed grid has the window's height: no block padding, the control centred.\n  const windowedRow = React.useContext(DataGridWindowRowContext)?.index !== undefined;\n  const { rowId } = row;\n  const single = selectionMode === 'single';\n  return (\n    <td\n      role=\"gridcell\"\n      {...rest}\n      ref={ref}\n      data-selection-cell=\"\"\n      className={cn(\n        stableClassName,\n        dataGridRowClassNames.selectionCell,\n        SELECTION_CELL_CLASSES,\n        windowedRow && 'py-0 align-middle',\n        focusRingInset,\n        row.selectionCellProps?.className,\n        className,\n      )}\n    >\n      {rowId !== undefined && selectionMode !== 'none' && (\n        <TableSelectionControl\n          ref={controlRef}\n          type={single ? 'radio' : 'checkbox'}\n          name={single ? radioName : undefined}\n          // The shared name groups the radios. `form=\"\"` matches no form, so they have no form\n          // owner (still one group: same name, both ownerless) and never add a generated field\n          // to an enclosing form's submission.\n          form={single ? '' : undefined}\n          checked={row.isSelected}\n          disabled={row.disabled}\n          invisible={row.invisible}\n          subtle={subtleSelection}\n          onChange={(event) => toggleRow(rowId, event.nativeEvent)}\n          aria-label={row.ariaLabel}\n          aria-labelledby={row.ariaLabelledBy}\n          aria-describedby={ariaDescribedBy}\n          className={dataGridRowClassNames.selectionControl}\n        />\n      )}\n    </td>\n  );\n}\n\n/**\n * The selection cell of a row, rendered where it stands among the row's cells (the row and the\n * header then add none of their own). In a header row it is the select-all checkbox (multiple\n * mode; the \"Selection\" header text in single mode), the first header row's only, as the\n * automatic cell; in a body row (a `DataGrid.Row`) the row's checkbox or radio. It takes the\n * selection cell props of its row (`selectionCellProps`), its own winning. `aria-label`,\n * `aria-labelledby` and `aria-describedby` go to the control; the other props, `className` and\n * `ref` to the cell. In a grid without selection it renders nothing (with a development warning).\n * In a body row of a grid with a `virtualWindow` it has no vertical padding (the row has the\n * window's height) and its control is centred.\n */\nconst DataGridSelectionCell = ({\n  disabled,\n  invisible,\n  className,\n  'aria-label': ariaLabel,\n  'aria-labelledby': ariaLabelledBy,\n  'aria-describedby': ariaDescribedBy,\n  controlRef,\n  ref,\n  ...rest\n}: DataGridSelectionCellProps) => {\n  const { selectionMode } = useDataGridContext('DataGrid.SelectionCell');\n  const section = React.useContext(DataGridSectionContext);\n  const firstHeaderRowHint = React.useContext(DataGridHeaderRowHintContext);\n  const row = React.useContext(DataGridRowContext);\n  const notSelectable = selectionMode === 'none';\n  // A DataGrid.Row that did not see this cell among its children added its own cell too.\n  const unseen = !notSelectable && row !== null && !row.hasSelectionCell;\n\n  React.useEffect(() => {\n    if (notSelectable) {\n      warnOnce(\n        'DataGrid.SelectionCell:not-selectable',\n        'DataGrid.SelectionCell: the grid has no row selection (`selectionMode` is \"none\"), so the ' +\n          'cell renders nothing. Set `selectionMode` on the DataGrid, or remove the cell.',\n      );\n    }\n  }, [notSelectable]);\n\n  React.useEffect(() => {\n    if (unseen) {\n      warnOnce(\n        'DataGrid.SelectionCell:unseen',\n        'DataGrid.SelectionCell: rendered by another component, so its DataGrid.Row did not see ' +\n          'it and added its own selection cell. Render DataGrid.SelectionCell as a child of ' +\n          'DataGrid.Row (a Fragment is fine).',\n      );\n    }\n  }, [unseen]);\n\n  if (notSelectable) return null;\n  if (section === 'header') {\n    const rowProps = row?.selectionCellProps;\n    return (\n      <DataGridSelectionHeaderSlot\n        ref={ref}\n        selectionMode={selectionMode}\n        initialFirst={firstHeaderRowHint}\n        stableClassName={dataGridSelectionCellClassNames.root}\n        cellProps={{\n          ...rest,\n          className: cn(rowProps?.className, className),\n          disabled: disabled ?? rowProps?.disabled,\n          invisible: invisible ?? rowProps?.invisible,\n          'aria-label': ariaLabel ?? rowProps?.['aria-label'],\n          'aria-labelledby': ariaLabelledBy,\n          'aria-describedby': ariaDescribedBy,\n          controlRef,\n        }}\n      />\n    );\n  }\n  return (\n    <DataGridBodySelectionCell\n      {...rest}\n      ref={ref}\n      component=\"DataGrid.SelectionCell\"\n      stableClassName={dataGridSelectionCellClassNames.root}\n      className={className}\n      controlRef={controlRef}\n      aria-describedby={ariaDescribedBy}\n    />\n  );\n};\nDataGridSelectionCell.displayName = 'DataGridSelectionCell';\nmarkTablePart(DataGridSelectionCell, 'dataGridSelectionCell');\n\n/**\n * A grid cell (`<td>`), focusable through the grid's keyboard navigation. It is the positioning\n * box of a `Table.CellActions` inside it. In a grid that lays its columns out from widths (column\n * sizing, a `virtualWindow`), its text stays on one line and is truncated with an ellipsis, unless\n * its class says otherwise. In a body row of a grid with a `virtualWindow` it has no vertical\n * padding: the row has the window's height, which its content must fit in.\n */\nconst DataGridCell = ({ children, className, ref, ...rest }: DataGridCellProps) => {\n  const fixedLayout = React.useContext(DataGridFixedLayoutContext);\n  // A body row of a windowed grid has the window's height: its cells add no vertical padding.\n  const windowedRow = React.useContext(DataGridWindowRowContext)?.index !== undefined;\n  return (\n    <td\n      ref={ref}\n      role=\"gridcell\"\n      className={cn(\n        dataGridCellClassNames.root,\n        cellBase,\n        'relative text-body-1',\n        (fixedLayout || windowedRow) && 'overflow-hidden text-ellipsis whitespace-nowrap',\n        windowedRow && 'py-0 align-middle',\n        focusRingInset,\n        className,\n      )}\n      {...rest}\n    >\n      {children}\n    </td>\n  );\n};\nDataGridCell.displayName = 'DataGridCell';\n\nexport {\n  DataGridHeader,\n  DataGridHeaderCell,\n  DataGridBody,\n  DataGridRow,\n  DataGridCell,\n  DataGridSelectionCell,\n};\n\n/**\n * An interactive data table (`role=\"grid\"`) following the APG Grid pattern: one tab stop,\n * arrow-key navigation between cells (Home/End, Ctrl+Home/Ctrl+End, PageUp/PageDown; Up/Down keep\n * the visual column, so a grouped header with spanning cells works), Enter/F2 to interact with a\n * cell's widgets and Escape to return to the cell. A composite widget in a cell (a Toolbar,\n * RadioGroup, TabList, …) is entered with Enter/F2 like a text field; it manages its own tab\n * indexes, so it keeps its own Tab stop. Supports sortable columns (`onSortChange` reports the new\n * sort; a grid with `items` orders its rows by the sorted column's `compare`, otherwise the consumer\n * orders them) and single or multiple row selection with a select-all header checkbox.\n *\n * Selection is made with the row's control, Space on a cell, and, with `selectOnRowClick`, a\n * click on the row. `selectionAppearance` picks the fill of a selected row, `subtleSelection`\n * hides the unchecked controls until their row (or, for select-all, the grid) is hovered or holds\n * focus, and a row's `selectionCellProps` disables, hides or names its control. The selection\n * column comes first; a `DataGrid.SelectionCell` places it elsewhere in a row.\n *\n * The grid is composed from its parts, or rendered from data: with `items` and typed `columns`\n * (`DataGridColumn<T>`, see `createTableColumn`) it renders the header, the rows and the cells\n * itself, and `DataGrid.Body` also takes a render function that returns each item's row. Rows\n * rendered from `items` take their `rowId` from `getRowId` (by default the item's index).\n *\n * With `items`, selection follows the data rather than the rendered rows: select-all and its\n * checkbox cover every item (`isSelectionDisabled` leaves items out), and ids of rows that are\n * filtered out, on another page or not rendered stay selected through row clicks, select-all and\n * sorting, and are reported by `onSelectedItemsChange`.\n *\n * With `items` and `columns`, the columns can be sized: `resizableColumns` gives each column\n * header a resize handle (a separator that a pointer drags and the arrow keys move, mirrored in\n * right-to-left grids; F2 on a column header moves focus to it, and Enter, Space or Escape back),\n * `columnSizingOptions` sets each column's initial and minimum width, and `columnWidths` or\n * `defaultColumnWidths` with `onColumnWidthsChange(widths, details)` hold the widths, for\n * instance to persist them (Fluent's `resizableColumns`, `columnSizingOptions` and\n * `onColumnResize`, whose data is in `details`). The grid then lays its columns out from the\n * widths and truncates its cells' text.\n *\n * With `items` and `columns`, a `virtualWindow` (from `useVirtualWindow`) renders only the rows in\n * view of a long list, with spacer rows for the others: the scroll wrapper (`containerProps`)\n * needs a bounded height, and every row has the window's fixed row height. The header stays at\n * the top of the wrapper, the keyboard moves by the data (a row that is not rendered is scrolled\n * in before it gets focus), the focused row stays rendered, and selection, select-all, sorting\n * and column sizing still cover every item. The grid then carries `aria-rowcount` and its rows\n * `aria-rowindex`, so assistive technology reads each row's place in the whole list. Fluent's\n * DataGrid has no built-in counterpart.\n *\n * Sub-components are available as `DataGrid.Header`, `DataGrid.HeaderCell`, `DataGrid.Body`,\n * `DataGrid.Row`, `DataGrid.Cell` and `DataGrid.SelectionCell` in client components, and as the\n * flat exports `DataGridHeader`, `DataGridHeaderCell`, `DataGridBody`, `DataGridRow`,\n * `DataGridCell` and `DataGridSelectionCell` (the form React Server Components can import).\n */\nexport const DataGrid = /* @__PURE__ */ Object.assign(DataGridRoot, {\n  Header: DataGridHeader,\n  HeaderCell: DataGridHeaderCell,\n  Body: DataGridBody,\n  Row: DataGridRow,\n  Cell: DataGridCell,\n  SelectionCell: DataGridSelectionCell,\n});\n"],"mappings":"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"}