@open-grid/primitives 0.1.0

package/dist/index.js

@@ -0,0 +1,2084 @@
+// src/index.ts
+var GRID_DENSITIES = ["compact", "standard", "comfortable"];
+var GRID_PREFERENCES_VERSION = 1;
+var DEFAULT_PAGINATION_PAGE_SIZE_OPTIONS = [25, 50, 100];
+var HEADER_ACTION_MENU_ENABLED_ITEM_SELECTOR = '[role="menuitem"]:not(:disabled):not([aria-disabled="true"])';
+var HEADER_ACTION_MENU_TRIGGER_TEXT = "...";
+var GROUPING_PANEL_EMPTY_MESSAGE = "Drag column headers here to group";
+var GRID_FOCUSED_CELL_SELECTOR = '[role="gridcell"][data-focused="true"]';
+var GRID_INTERACTIVE_KEYBOARD_TARGET_SELECTOR = "button, input, select, textarea, a[href], [contenteditable]:not([contenteditable='false']), [role='button'], [role='menuitem'], [role='separator'], [role='slider'], [role='textbox'], [role='combobox'], [role='searchbox'], [role='spinbutton']";
+function getGridProps(grid, options = {}) {
+  const headerRowCount = getGridHeaderRowCount(grid, options);
+  const rowCount = grid.getOptions().manualPagination ? -1 : headerRowCount + Math.max(1, grid.getPrePaginationRowModel().rows.length);
+  const columnCount = grid.getVisibleLeafColumns().length;
+  return {
+    role: "grid",
+    "aria-label": options.ariaLabel,
+    "aria-rowcount": rowCount,
+    "aria-colcount": columnCount,
+    "aria-busy": options.loading && !options.error || void 0,
+    "data-error": options.error || void 0,
+    "data-open-grid": true,
+    tabIndex: 0
+  };
+}
+function getGridHeaderProps() {
+  return {
+    role: "rowgroup"
+  };
+}
+function getGridLoadingOverlayProps() {
+  return {
+    role: "status",
+    "aria-live": "polite",
+    "aria-label": "Loading rows"
+  };
+}
+function getGridLoadingText() {
+  return "Loading rows...";
+}
+function getGridErrorOverlayProps() {
+  return {
+    role: "alert",
+    "aria-live": "assertive",
+    "aria-atomic": true,
+    "aria-label": "Grid error"
+  };
+}
+function getGridErrorText() {
+  return "Unable to load rows.";
+}
+function getGridErrorRetryButtonProps() {
+  return {
+    type: "button",
+    "aria-label": "Retry loading rows"
+  };
+}
+function getGridErrorRetryButtonText() {
+  return "Retry";
+}
+function getGridHeaderRowProps(options = {}) {
+  return {
+    role: "row",
+    "aria-rowindex": (options.rowIndex ?? 0) + 1,
+    "data-column-virtualized": options.columnVirtualized || void 0
+  };
+}
+function getGridHeaderRowCount(grid, options = {}) {
+  const headerRowCount = Number.isFinite(options.headerRowCount) ? Math.max(0, Math.floor(options.headerRowCount ?? 0)) : grid.getHeaderGroups().length;
+  const additionalHeaderRowCount = Number.isFinite(options.additionalHeaderRowCount) ? Math.max(0, Math.floor(options.additionalHeaderRowCount ?? 0)) : 0;
+  return headerRowCount + additionalHeaderRowCount;
+}
+function getGridBodyRowIndexOffset(grid, options = {}) {
+  const { pageIndex, pageSize } = grid.getState().pagination;
+  return getGridHeaderRowCount(grid, options) + pageIndex * pageSize;
+}
+function getColumnFilterCellProps(column, options) {
+  const pinned = options.pinned ?? column.getIsPinned();
+  return {
+    role: "gridcell",
+    "aria-colindex": options.columnIndex + 1,
+    "data-column-id": column.id,
+    "data-pinned": pinned || void 0,
+    "data-pinned-edge": options.pinnedEdge
+  };
+}
+function getColumnFilterInputProps(column, options) {
+  return {
+    type: "search",
+    value: options.value == null ? "" : String(options.value),
+    placeholder: "Filter",
+    "aria-label": `Filter ${options.label}`,
+    "data-column-id": column.id,
+    autoComplete: "off"
+  };
+}
+function getColumnFilterText(filters, columnId) {
+  const value = filters.find((filter) => filter.id === columnId)?.value;
+  return value == null ? "" : String(value);
+}
+function getQuickFilterProps() {
+  return {
+    role: "search",
+    "aria-label": "Search grid rows"
+  };
+}
+function getQuickFilterInputProps(options) {
+  return {
+    type: "search",
+    value: options.value,
+    placeholder: "Search rows",
+    "aria-label": "Search all rows",
+    autoComplete: "off"
+  };
+}
+function getQuickFilterClearButtonProps(value) {
+  return {
+    type: "button",
+    "aria-label": "Clear row search",
+    disabled: value.length === 0 || void 0
+  };
+}
+function getQuickFilterClearButtonText() {
+  return "Clear";
+}
+function getRowSelectionControlsProps() {
+  return {
+    role: "group",
+    "aria-label": "Row selection"
+  };
+}
+function getRowSelectionCheckboxProps(options = {}) {
+  return {
+    type: "checkbox",
+    checked: options.allSelected || false,
+    disabled: options.disabled || void 0,
+    "aria-checked": options.someSelected ? "mixed" : options.allSelected || false,
+    "aria-label": "Select all rows on current page"
+  };
+}
+function getRowSelectionCheckboxText() {
+  return "Select page";
+}
+function getRowSelectionStatusProps() {
+  return {
+    role: "status",
+    "aria-live": "polite",
+    "aria-atomic": true
+  };
+}
+function getRowSelectionStatusText(selectedCount) {
+  const count = Number.isFinite(selectedCount) ? Math.max(0, Math.floor(selectedCount)) : 0;
+  return `${count} ${count === 1 ? "row" : "rows"} selected`;
+}
+function getRowSelectionClearButtonProps(disabled = false) {
+  return {
+    type: "button",
+    disabled: disabled || void 0,
+    "aria-label": "Clear row selection"
+  };
+}
+function getRowSelectionClearButtonText() {
+  return "Clear selection";
+}
+function setCheckboxIndeterminate(target, indeterminate) {
+  if (!target || typeof target !== "object" || !("indeterminate" in target)) {
+    return false;
+  }
+  target.indeterminate = indeterminate;
+  return true;
+}
+function getColumnVisibilityControlsProps() {
+  return {
+    "aria-label": "Grid columns"
+  };
+}
+function getColumnVisibilitySummaryProps(visibleCount, totalCount) {
+  return {
+    "aria-label": `Manage columns, ${getColumnVisibilityStatusText(visibleCount, totalCount)}`
+  };
+}
+function getColumnVisibilitySummaryText(visibleCount, totalCount) {
+  const { visible, total } = normalizeColumnVisibilityCounts(visibleCount, totalCount);
+  return `Columns ${visible}/${total}`;
+}
+function getColumnVisibilitySearchInputProps(value) {
+  return {
+    type: "search",
+    value,
+    placeholder: "Find columns",
+    "aria-label": "Find columns",
+    autoComplete: "off"
+  };
+}
+function getColumnVisibilityListProps() {
+  return {
+    role: "group",
+    "aria-label": "Column visibility"
+  };
+}
+function getColumnVisibilityCheckboxProps(options) {
+  const isFinalVisibleColumn = options.visible && Number.isFinite(options.visibleCount) && Math.max(0, Math.floor(options.visibleCount ?? 0)) <= 1;
+  return {
+    type: "checkbox",
+    checked: options.visible,
+    disabled: options.disabled || isFinalVisibleColumn || void 0,
+    "aria-label": options.label,
+    "data-column-id": options.columnId
+  };
+}
+function getColumnVisibilityStatusProps() {
+  return {
+    role: "status",
+    "aria-live": "polite",
+    "aria-atomic": true
+  };
+}
+function getColumnVisibilityStatusText(visibleCount, totalCount) {
+  const { visible, total } = normalizeColumnVisibilityCounts(visibleCount, totalCount);
+  return `${visible} of ${total} columns visible`;
+}
+function getColumnVisibilityEmptyText() {
+  return "No columns found";
+}
+function getColumnVisibilityResetButtonProps(hiddenCount) {
+  return {
+    type: "button",
+    disabled: !Number.isFinite(hiddenCount) || hiddenCount <= 0 || void 0,
+    "aria-label": "Show all columns"
+  };
+}
+function getColumnVisibilityResetButtonText() {
+  return "Show all";
+}
+function normalizeGridDensity(value, fallback = "standard") {
+  return GRID_DENSITIES.includes(value) ? value : fallback;
+}
+function getGridPreferenceRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function getGridPreferenceColumnIds(value, validColumnIds) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const validIds = validColumnIds ? new Set(validColumnIds) : null;
+  const seen = /* @__PURE__ */ new Set();
+  return value.filter((columnId) => {
+    if (typeof columnId !== "string" || seen.has(columnId) || validIds && !validIds.has(columnId)) {
+      return false;
+    }
+    seen.add(columnId);
+    return true;
+  });
+}
+function createGridPreferences(state = {}, density = "standard", options = {}) {
+  const validIds = options.validColumnIds ? new Set(options.validColumnIds) : null;
+  const columnVisibility = Object.fromEntries(
+    Object.entries(state.columnVisibility ?? {}).filter(([columnId, visible]) => typeof visible === "boolean" && (!validIds || validIds.has(columnId)))
+  );
+  const columnSizing = Object.fromEntries(
+    Object.entries(state.columnSizing ?? {}).filter(([columnId, size]) => typeof size === "number" && Number.isFinite(size) && size > 0 && (!validIds || validIds.has(columnId)))
+  );
+  const columnOrder = getGridPreferenceColumnIds(state.columnOrder, options.validColumnIds);
+  const left = getGridPreferenceColumnIds(state.columnPinning?.left, options.validColumnIds);
+  const leftIds = new Set(left);
+  const right = getGridPreferenceColumnIds(state.columnPinning?.right, options.validColumnIds).filter((columnId) => !leftIds.has(columnId));
+  if (options.validColumnIds?.length && options.validColumnIds.every((columnId) => columnVisibility[columnId] === false)) {
+    delete columnVisibility[options.validColumnIds[0]];
+  }
+  return {
+    version: GRID_PREFERENCES_VERSION,
+    density: normalizeGridDensity(density),
+    state: {
+      columnVisibility,
+      columnSizing,
+      columnOrder,
+      columnPinning: { left, right }
+    }
+  };
+}
+function serializeGridPreferences(preferences, options = {}) {
+  return JSON.stringify(createGridPreferences(preferences.state, preferences.density, options));
+}
+function parseGridPreferences(value, options = {}) {
+  try {
+    const parsed = getGridPreferenceRecord(JSON.parse(value));
+    if (!parsed || parsed.version !== GRID_PREFERENCES_VERSION) {
+      return null;
+    }
+    const state = getGridPreferenceRecord(parsed.state);
+    if (!state) {
+      return null;
+    }
+    const columnPinning = getGridPreferenceRecord(state.columnPinning);
+    return createGridPreferences({
+      columnVisibility: getGridPreferenceRecord(state.columnVisibility) ?? {},
+      columnSizing: getGridPreferenceRecord(state.columnSizing) ?? {},
+      columnOrder: Array.isArray(state.columnOrder) ? state.columnOrder : [],
+      columnPinning: {
+        left: Array.isArray(columnPinning?.left) ? columnPinning.left : [],
+        right: Array.isArray(columnPinning?.right) ? columnPinning.right : []
+      }
+    }, normalizeGridDensity(parsed.density), options);
+  } catch {
+    return null;
+  }
+}
+function getBrowserGridPreferencesStorage(environment = globalThis) {
+  try {
+    return environment?.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+function readGridPreferences(storage, key, options = {}) {
+  if (!storage) {
+    return null;
+  }
+  try {
+    const value = storage.getItem(key);
+    return value === null ? null : parseGridPreferences(value, options);
+  } catch {
+    return null;
+  }
+}
+function writeGridPreferences(storage, key, state, density, options = {}) {
+  if (!storage) {
+    return false;
+  }
+  try {
+    storage.setItem(key, serializeGridPreferences(createGridPreferences(state, density, options), options));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeGridPreferences(storage, key) {
+  if (!storage) {
+    return false;
+  }
+  try {
+    storage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGridDensityProps(density) {
+  return {
+    "data-density": normalizeGridDensity(density)
+  };
+}
+function getGridDensityRowHeight(density) {
+  const heights = {
+    compact: 32,
+    standard: 40,
+    comfortable: 48
+  };
+  return heights[normalizeGridDensity(density)];
+}
+function getDensityControlsProps() {
+  return {
+    role: "group",
+    "aria-label": "Row density"
+  };
+}
+function getDensityButtonProps(density, currentDensity) {
+  const normalizedDensity = normalizeGridDensity(density);
+  return {
+    type: "button",
+    "aria-label": `Use ${normalizedDensity} density`,
+    "aria-pressed": normalizedDensity === normalizeGridDensity(currentDensity),
+    "data-density": normalizedDensity
+  };
+}
+function getDensityButtonText(density) {
+  const labels = {
+    compact: "Compact",
+    standard: "Standard",
+    comfortable: "Comfortable"
+  };
+  return labels[normalizeGridDensity(density)];
+}
+function getFilteredColumnVisibilityColumns(columns, query) {
+  const normalizedQuery = query.trim().toLocaleLowerCase();
+  if (!normalizedQuery) {
+    return [...columns];
+  }
+  return columns.filter(
+    (column) => `${getColumnHeaderText(column)} ${column.id}`.toLocaleLowerCase().includes(normalizedQuery)
+  );
+}
+function normalizeColumnVisibilityCounts(visibleCount, totalCount) {
+  const normalizedTotal = Number.isFinite(totalCount) ? Math.max(0, Math.floor(totalCount)) : 0;
+  const normalizedVisible = Number.isFinite(visibleCount) ? Math.max(0, Math.floor(visibleCount)) : 0;
+  return {
+    visible: Math.min(normalizedVisible, normalizedTotal),
+    total: normalizedTotal
+  };
+}
+function getNextColumnFilters(filters, columnId, value) {
+  const existingIndex = filters.findIndex((filter) => filter.id === columnId);
+  if (value === "") {
+    return existingIndex < 0 ? filters : filters.filter((filter) => filter.id !== columnId);
+  }
+  if (existingIndex < 0) {
+    return [...filters, { id: columnId, value }];
+  }
+  return filters.map((filter, index) => index === existingIndex ? { id: columnId, value } : filter);
+}
+function getPaginationProps() {
+  return {
+    role: "navigation",
+    "aria-label": "Pagination"
+  };
+}
+function getPaginationButtonProps(options) {
+  const labels = {
+    first: "First page",
+    previous: "Previous page",
+    next: "Next page",
+    last: "Last page"
+  };
+  return {
+    type: "button",
+    "aria-label": labels[options.action],
+    disabled: options.disabled || void 0
+  };
+}
+function getPaginationButtonText(action) {
+  const text = {
+    first: "|<",
+    previous: "<",
+    next: ">",
+    last: ">|"
+  };
+  return text[action];
+}
+function getPaginationStatusProps() {
+  return {
+    role: "status",
+    "aria-live": "polite"
+  };
+}
+function getPaginationPageText(grid) {
+  const pageCount = grid.getPageCount();
+  const rawPageIndex = grid.getState().pagination.pageIndex;
+  const pageIndex = Math.min(
+    Number.isFinite(rawPageIndex) ? Math.max(0, Math.floor(rawPageIndex)) : 0,
+    pageCount - 1
+  );
+  return `Page ${pageIndex + 1} of ${pageCount}`;
+}
+function getPaginationPageSizeSelectProps(pageSize) {
+  return {
+    "aria-label": "Rows per page",
+    value: Number.isFinite(pageSize) && pageSize > 0 ? Math.max(1, Math.floor(pageSize)) : 1
+  };
+}
+function getPaginationPageSizeOptions(options = DEFAULT_PAGINATION_PAGE_SIZE_OPTIONS, currentPageSize) {
+  const normalized = options.flatMap(
+    (value) => Number.isFinite(value) && value > 0 ? [Math.max(1, Math.floor(value))] : []
+  );
+  const current = Number.isFinite(currentPageSize) && (currentPageSize ?? 0) > 0 ? Math.max(1, Math.floor(currentPageSize ?? 1)) : null;
+  return Array.from(new Set(current === null ? normalized : [...normalized, current])).sort((left, right) => left - right);
+}
+function getPaginationPageSizeOptionText(pageSize) {
+  return `${pageSize} rows`;
+}
+function getGridBodyProps(options = {}) {
+  return {
+    role: "rowgroup",
+    "data-virtualized": options.virtualized || void 0,
+    "data-column-order": options.columnOrder?.join(",")
+  };
+}
+function getGridEmptyRowProps(options = {}) {
+  return {
+    role: "row",
+    "aria-rowindex": (options.rowIndexOffset ?? 0) + 1
+  };
+}
+function getGridEmptyCellProps(options = {}) {
+  return {
+    role: "gridcell",
+    "aria-colindex": 1,
+    "aria-colspan": Math.max(1, options.columnCount ?? 1)
+  };
+}
+function getColumnSpacerProps() {
+  return {
+    "aria-hidden": true
+  };
+}
+function getHeaderCellProps(grid, column, columnIndex, options = {}) {
+  const sortDirection = grid.getColumnSortDirection(column.id);
+  const pinned = options.pinned ?? column.getIsPinned();
+  return {
+    role: "columnheader",
+    "aria-colindex": columnIndex + 1,
+    "aria-sort": sortDirection === "asc" ? "ascending" : sortDirection === "desc" ? "descending" : "none",
+    "data-column-id": column.id,
+    "data-pinned": pinned || void 0,
+    "data-sort": sortDirection || void 0
+  };
+}
+function getHeaderPlaceholderCellProps(column) {
+  return {
+    role: "presentation",
+    "aria-hidden": true,
+    "data-column-id": column.id
+  };
+}
+function getHeaderCellLayoutProps(options = {}) {
+  return {
+    "aria-colspan": options.placeholder ? void 0 : options.colSpan,
+    "aria-rowspan": options.placeholder ? void 0 : options.rowSpan,
+    "data-grouped": options.grouped || void 0,
+    "data-placeholder": options.placeholder || void 0,
+    "data-pinned-edge": options.pinnedEdge,
+    "data-column-draggable": options.draggable || void 0
+  };
+}
+function getHeaderButtonProps(options = {}) {
+  return {
+    type: "button",
+    disabled: options.disabled || void 0,
+    tabIndex: options.placeholder ? -1 : void 0
+  };
+}
+function getHeaderSortIndicatorProps() {
+  return {
+    "aria-hidden": true
+  };
+}
+function getHeaderSortIndicatorText(sortDirection, options = {}) {
+  if (!options.visible) {
+    return "";
+  }
+  if (sortDirection === "asc") {
+    return "\u25B2";
+  }
+  if (sortDirection === "desc") {
+    return "\u25BC";
+  }
+  return "";
+}
+function getHeaderKeyboardMoveDirection(event) {
+  if (!event.altKey || !event.shiftKey) {
+    return null;
+  }
+  if (event.key === "ArrowLeft") {
+    return "left";
+  }
+  if (event.key === "ArrowRight") {
+    return "right";
+  }
+  return null;
+}
+function getHeaderActionMenuTriggerFocusPosition(event) {
+  if (event.key === "ArrowDown") {
+    return "first";
+  }
+  if (event.key === "ArrowUp") {
+    return "last";
+  }
+  return null;
+}
+function getHeaderActionMenuKeyboardAction(event) {
+  if (event.key === "Escape") {
+    return { type: "close" };
+  }
+  if (event.key === "ArrowDown") {
+    return { type: "focus", position: "next" };
+  }
+  if (event.key === "ArrowUp") {
+    return { type: "focus", position: "previous" };
+  }
+  if (event.key === "Home") {
+    return { type: "focus", position: "first" };
+  }
+  if (event.key === "End") {
+    return { type: "focus", position: "last" };
+  }
+  if (event.key === "Tab") {
+    return { type: "tab-close" };
+  }
+  return null;
+}
+function isHeaderActionMenuCloseAction(action) {
+  return action?.type === "close";
+}
+function isHeaderActionMenuFocusAction(action) {
+  return action?.type === "focus";
+}
+function isHeaderActionMenuTabCloseAction(action) {
+  return action?.type === "tab-close";
+}
+function getGridKeyboardShortcutAction(event) {
+  const key = event.key.toLowerCase();
+  if ((event.ctrlKey || event.metaKey) && !event.altKey) {
+    if (!event.shiftKey && key === "c") {
+      return "copy";
+    }
+    if (!event.shiftKey && key === "v") {
+      return "paste";
+    }
+    if (key === "z") {
+      return event.shiftKey ? "redo-edit" : "undo-edit";
+    }
+    if (!event.shiftKey && key === "y") {
+      return "redo-edit";
+    }
+  }
+  if (!event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && (event.key === " " || event.key === "Spacebar")) {
+    return "row-selection";
+  }
+  return null;
+}
+function getGridKeyboardEditAction(event) {
+  if (event.key === "Enter") {
+    return "start-edit";
+  }
+  if (event.key === "Escape") {
+    return "cancel-edit";
+  }
+  return null;
+}
+function getCellEditorKeyboardAction(event) {
+  if (event.key === "Enter") {
+    return "commit-edit";
+  }
+  if (event.key === "Escape") {
+    return "cancel-edit";
+  }
+  return null;
+}
+function getGridKeyboardFocusMove(event) {
+  const options = event.shiftKey ? { extendSelection: true } : {};
+  if (event.key === "ArrowUp") {
+    return { direction: "up", options };
+  }
+  if (event.key === "ArrowDown") {
+    return { direction: "down", options };
+  }
+  if (event.key === "ArrowLeft") {
+    return { direction: "left", options };
+  }
+  if (event.key === "ArrowRight") {
+    return { direction: "right", options };
+  }
+  if (event.key === "Home") {
+    return { direction: event.ctrlKey || event.metaKey ? "grid-start" : "home", options };
+  }
+  if (event.key === "End") {
+    return { direction: event.ctrlKey || event.metaKey ? "grid-end" : "end", options };
+  }
+  if (event.key === "PageUp") {
+    return { direction: "page-up", options };
+  }
+  if (event.key === "PageDown") {
+    return { direction: "page-down", options };
+  }
+  return null;
+}
+function getColumnResizeHandleProps(column, options = {}) {
+  return {
+    role: "separator",
+    "aria-orientation": "vertical",
+    "aria-label": `Resize ${column.id} column`,
+    "aria-valuenow": options.valueNow ?? column.getSize(),
+    "aria-valuemin": column.columnDef.minSize,
+    "aria-valuemax": column.columnDef.maxSize,
+    "data-column-id": column.id,
+    "data-resize-handle": true,
+    tabIndex: 0
+  };
+}
+function getColumnResizeStartSize(grid, column) {
+  return grid.getColumnSize(column.id) ?? column.getSize();
+}
+function getColumnResizeKeyboardSize(column, startSize, event, options = {}) {
+  const defaultStep = options.defaultStep ?? 10;
+  const largeStep = options.largeStep ?? 50;
+  const step = event.shiftKey ? largeStep : defaultStep;
+  if (event.key === "ArrowLeft") {
+    return startSize - step;
+  }
+  if (event.key === "ArrowRight") {
+    return startSize + step;
+  }
+  if (event.key === "Home" && typeof column.columnDef.minSize === "number") {
+    return column.columnDef.minSize;
+  }
+  if (event.key === "End" && typeof column.columnDef.maxSize === "number") {
+    return column.columnDef.maxSize;
+  }
+  return null;
+}
+function getColumnResizePointerSize(startSize, startX, event) {
+  return startSize + event.clientX - startX;
+}
+function getCanStartColumnResize(event) {
+  return !event.defaultPrevented;
+}
+function getCanApplyColumnResize(event) {
+  return !event.defaultPrevented;
+}
+function getColumnResizeFinalSize(startSize, event) {
+  return event.defaultPrevented ? startSize : event.size;
+}
+function isPointerCaptureTarget(target) {
+  return typeof target === "object" && target !== null && "setPointerCapture" in target && "releasePointerCapture" in target && typeof target.setPointerCapture === "function" && typeof target.releasePointerCapture === "function";
+}
+function getPointerCaptureTarget(event) {
+  return event.currentTarget;
+}
+function getCanUseDefaultPointerGlobalListenerTarget() {
+  if (typeof globalThis.addEventListener !== "function" || typeof globalThis.removeEventListener !== "function") {
+    return false;
+  }
+  return true;
+}
+function addDefaultPointerGlobalListener(type, listener) {
+  globalThis.addEventListener(type, listener);
+}
+function removeDefaultPointerGlobalListener(type, listener) {
+  globalThis.removeEventListener(type, listener);
+}
+function getDefaultPointerMoveUpListenerTarget() {
+  return getCanUseDefaultPointerGlobalListenerTarget() ? {
+    addEventListener: addDefaultPointerGlobalListener,
+    removeEventListener: removeDefaultPointerGlobalListener
+  } : null;
+}
+function getDefaultPointerUpCancelListenerTarget() {
+  return getCanUseDefaultPointerGlobalListenerTarget() ? {
+    addEventListener: addDefaultPointerGlobalListener,
+    removeEventListener: removeDefaultPointerGlobalListener
+  } : null;
+}
+function getDefaultPointerMoveUpCancelListenerTarget() {
+  return getCanUseDefaultPointerGlobalListenerTarget() ? {
+    addEventListener: addDefaultPointerGlobalListener,
+    removeEventListener: removeDefaultPointerGlobalListener
+  } : null;
+}
+function trySetPointerCapture(target, pointerId) {
+  if (!isPointerCaptureTarget(target)) {
+    return false;
+  }
+  try {
+    target.setPointerCapture(pointerId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tryReleasePointerCapture(target, pointerId) {
+  if (!isPointerCaptureTarget(target)) {
+    return false;
+  }
+  try {
+    target.releasePointerCapture(pointerId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function addPointerMoveUpListeners(listeners, target = getDefaultPointerMoveUpListenerTarget()) {
+  if (!target) {
+    return () => void 0;
+  }
+  target.addEventListener("pointermove", listeners.move);
+  target.addEventListener("pointerup", listeners.up);
+  return () => {
+    target.removeEventListener("pointermove", listeners.move);
+    target.removeEventListener("pointerup", listeners.up);
+  };
+}
+function addPointerUpCancelListeners(listeners, target = getDefaultPointerUpCancelListenerTarget()) {
+  if (!target) {
+    return () => void 0;
+  }
+  target.addEventListener("pointerup", listeners.up);
+  target.addEventListener("pointercancel", listeners.cancel);
+  return () => {
+    target.removeEventListener("pointerup", listeners.up);
+    target.removeEventListener("pointercancel", listeners.cancel);
+  };
+}
+function addPointerMoveUpCancelListeners(listeners, target = getDefaultPointerMoveUpCancelListenerTarget()) {
+  if (!target) {
+    return () => void 0;
+  }
+  target.addEventListener("pointermove", listeners.move);
+  target.addEventListener("pointerup", listeners.up);
+  target.addEventListener("pointercancel", listeners.cancel);
+  return () => {
+    target.removeEventListener("pointermove", listeners.move);
+    target.removeEventListener("pointerup", listeners.up);
+    target.removeEventListener("pointercancel", listeners.cancel);
+  };
+}
+function addPassiveScrollListener(listener, target) {
+  target.addEventListener("scroll", listener, { passive: true });
+  return () => {
+    target.removeEventListener("scroll", listener);
+  };
+}
+function getColumnPinningControlsProps(column) {
+  return {
+    "aria-label": `${column.id} column pinning`
+  };
+}
+function getColumnPinningButtonText(position) {
+  if (position === "left") {
+    return "L";
+  }
+  if (position === "right") {
+    return "R";
+  }
+  return "-";
+}
+function getColumnPinningButtonProps(column, options) {
+  const label = options.position === "left" ? `Pin ${column.id} left` : options.position === "right" ? `Pin ${column.id} right` : `Unpin ${column.id}`;
+  return {
+    type: "button",
+    "aria-label": label,
+    "aria-pressed": options.active,
+    disabled: options.active
+  };
+}
+function getHeaderActionMenuTriggerProps(column, options) {
+  return {
+    type: "button",
+    "aria-label": `Open ${column.id} column menu`,
+    "aria-expanded": options.expanded,
+    "aria-haspopup": "menu",
+    "aria-controls": options.expanded ? options.controls : void 0
+  };
+}
+function getHeaderActionMenuId(columnId) {
+  return `og-grid-header-menu-${columnId.replace(/[^a-zA-Z0-9_-]+/g, "-")}`;
+}
+function getHeaderActionMenuTriggerId(columnId) {
+  return `${getHeaderActionMenuId(columnId)}-trigger`;
+}
+function getHeaderActionMenuProps(column) {
+  return {
+    role: "menu",
+    "aria-label": `${column.id} column menu`,
+    tabIndex: -1
+  };
+}
+function getHeaderActionMenuDefaultItemLabel(itemId, options = {}) {
+  if (itemId === "sort-asc") {
+    return "Sort ascending";
+  }
+  if (itemId === "sort-desc") {
+    return "Sort descending";
+  }
+  if (itemId === "clear-sort") {
+    return "Clear sort";
+  }
+  if (itemId === "move-left") {
+    return "Move left";
+  }
+  if (itemId === "move-right") {
+    return "Move right";
+  }
+  if (itemId === "pin-left") {
+    return "Pin left";
+  }
+  if (itemId === "unpin") {
+    return "Unpin";
+  }
+  if (itemId === "pin-right") {
+    return "Pin right";
+  }
+  return options.grouped ? "Ungroup column" : "Group by column";
+}
+function getHeaderActionMenuDefaultItemDescriptors(options) {
+  const descriptors = [
+    {
+      id: "sort-asc",
+      label: getHeaderActionMenuDefaultItemLabel("sort-asc")
+    },
+    {
+      id: "sort-desc",
+      label: getHeaderActionMenuDefaultItemLabel("sort-desc")
+    },
+    {
+      id: "clear-sort",
+      label: getHeaderActionMenuDefaultItemLabel("clear-sort"),
+      disabled: !options.sortDirection
+    },
+    {
+      id: "move-left",
+      label: getHeaderActionMenuDefaultItemLabel("move-left"),
+      disabled: !options.canMoveLeft
+    },
+    {
+      id: "move-right",
+      label: getHeaderActionMenuDefaultItemLabel("move-right"),
+      disabled: !options.canMoveRight
+    },
+    {
+      id: "pin-left",
+      label: getHeaderActionMenuDefaultItemLabel("pin-left"),
+      disabled: options.pinningPosition === "left"
+    },
+    {
+      id: "unpin",
+      label: getHeaderActionMenuDefaultItemLabel("unpin"),
+      disabled: options.pinningPosition === false
+    },
+    {
+      id: "pin-right",
+      label: getHeaderActionMenuDefaultItemLabel("pin-right"),
+      disabled: options.pinningPosition === "right"
+    }
+  ];
+  if (options.canGroup) {
+    descriptors.push({
+      id: "toggle-group",
+      label: getHeaderActionMenuDefaultItemLabel("toggle-group", { grouped: options.isGrouped })
+    });
+  }
+  return descriptors;
+}
+function getHeaderActionMenuItemProps(options = {}) {
+  return {
+    type: "button",
+    role: "menuitem",
+    disabled: options.disabled || void 0
+  };
+}
+function getHeaderActionMenuCustomItemProps(options = {}) {
+  return {
+    role: "presentation",
+    "aria-label": options.label
+  };
+}
+function getHeaderActionMenuLabelProps() {
+  return {
+    role: "presentation"
+  };
+}
+function getHeaderActionMenuSeparatorProps(options = {}) {
+  return {
+    role: "separator",
+    "aria-label": options.label
+  };
+}
+function isHeaderActionMenuItem(item) {
+  return Boolean(item);
+}
+function isHeaderActionMenuActionItem(item) {
+  return item !== null && item !== false && item !== void 0 && (item.type === void 0 || item.type === "action");
+}
+function isHeaderActionMenuCustomItem(item) {
+  return item !== null && item !== false && item !== void 0 && item.type === "custom";
+}
+function isHeaderActionMenuLabelItem(item) {
+  return item !== null && item !== false && item !== void 0 && item.type === "label";
+}
+function isHeaderActionMenuSeparatorItem(item) {
+  return item !== null && item !== false && item !== void 0 && item.type === "separator";
+}
+function getHeaderActionMenuCustomItemUserProps(item) {
+  return item ? item.props ?? {} : {};
+}
+function getGroupingPanelProps(options = {}) {
+  return {
+    "aria-label": "Column grouping",
+    "data-empty": options.empty || void 0
+  };
+}
+function getGroupingPanelPlaceholderProps() {
+  return {
+    "data-empty-placeholder": true
+  };
+}
+function getGroupingPanelChipProps(column) {
+  return {
+    "data-column-id": column.id
+  };
+}
+function getGroupingPanelMoveButtonProps(column, options) {
+  return {
+    type: "button",
+    "aria-label": `Move ${column.id} grouping ${options.direction}`,
+    disabled: options.disabled || false
+  };
+}
+function getGroupingPanelRemoveButtonProps(column) {
+  return {
+    type: "button",
+    "aria-label": `Remove ${column.id} grouping`
+  };
+}
+function getIsGroupLabelCell(row, column, visibleColumns) {
+  const firstVisibleColumnId = visibleColumns[0]?.id;
+  if (!row.getIsGrouped()) {
+    if (row.getIsGroupFooter()) {
+      return column.id === firstVisibleColumnId;
+    }
+    return (row.depth > 0 || row.getCanExpand()) && column.id === firstVisibleColumnId;
+  }
+  return column.id === row.groupingColumnId || !visibleColumns.some((candidate) => candidate.id === row.groupingColumnId) && column.id === firstVisibleColumnId;
+}
+function getGroupValueText(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return value == null ? "(blank)" : String(value);
+}
+function getGroupRowLabel(row, column, options = {}) {
+  if (row.getIsGroupFooter()) {
+    return row.groupFooterLabel ?? "Total";
+  }
+  if (row.groupingColumnId) {
+    return `${row.groupingColumnId}: ${getGroupValueText(row.groupingValue)}`;
+  }
+  return options.fallback ?? getGroupValueText(row.getValue(column.id));
+}
+function getGroupCellIndent(row, options = {}) {
+  const depthSize = options.depthSize ?? 16;
+  const footerOffset = options.footerOffset ?? 8;
+  const offset = row.getIsGroupFooter() ? footerOffset : 0;
+  return row.depth * depthSize - offset;
+}
+function getGroupCellIndentStyle(row, options = {}) {
+  return {
+    paddingLeft: getGroupCellIndent(row, options)
+  };
+}
+function getGroupCellIndentStyleText(row, options = {}) {
+  return `padding-left: ${getGroupCellIndent(row, options)}px`;
+}
+function getGroupRowCountText(row) {
+  return row.getIsGrouped() ? String(row.leafRows.length) : void 0;
+}
+function getRowProps(row, rowIndex, options = {}) {
+  return {
+    role: "row",
+    "aria-rowindex": (options.rowIndexOffset ?? 0) + rowIndex + 1,
+    "aria-selected": options.selected || void 0,
+    "data-row-id": row.id,
+    "data-selected": options.selected || void 0
+  };
+}
+function getRowLayoutProps(row, options = {}) {
+  return {
+    "data-grouped-row": row.getIsGrouped() || void 0,
+    "data-group-footer-row": row.getIsGroupFooter() || void 0,
+    "data-expanded": row.getCanExpand() ? options.expanded : void 0,
+    "data-virtual-index": options.virtualIndex,
+    "data-column-virtualized": options.columnVirtualized || void 0
+  };
+}
+function getRowExpansionToggleProps(row, options) {
+  return {
+    type: "button",
+    "aria-label": `${options.expanded ? "Collapse" : "Expand"} ${options.label}`,
+    "aria-expanded": options.expanded,
+    "data-row-id": row.id,
+    "data-expanded": options.expanded
+  };
+}
+function getRowExpansionToggleText(expanded) {
+  return expanded ? "\u2212" : "+";
+}
+function getRowExpansionSpacerProps() {
+  return {
+    "aria-hidden": true
+  };
+}
+function getCellProps(row, column, _rowIndex, columnIndex, options = {}) {
+  const focused = isFocusedCell(options.focusedCell ?? null, row.id, column.id);
+  return {
+    role: "gridcell",
+    "aria-colindex": columnIndex + 1,
+    "data-row-id": row.id,
+    "data-column-id": column.id,
+    "data-pinned": column.getIsPinned() || void 0,
+    tabIndex: focused ? 0 : -1,
+    "data-focused": focused || void 0,
+    "data-editing": options.editing || void 0,
+    "aria-selected": options.rangeSelected || void 0,
+    "data-range-selected": options.rangeSelected || void 0
+  };
+}
+function getCellLayoutProps(options = {}) {
+  return {
+    "data-validation-invalid": options.invalid || void 0,
+    "data-pinned-edge": options.pinnedEdge
+  };
+}
+function getCellFillHandleProps() {
+  return {
+    "aria-hidden": true,
+    "data-fill-handle": true
+  };
+}
+function getCanStartCellEdit(row, column) {
+  return !row.getIsGrouped() && !row.getIsGroupFooter() && column.getCanEdit();
+}
+function getCanStartFocusedCellEdit(focusedCell, editingCell) {
+  return Boolean(focusedCell) && !editingCell;
+}
+function getCanRestoreFocusedCell(options) {
+  return options.shouldRestore && options.focusedCell != null && options.scroller != null && options.inProgress !== true;
+}
+function getShouldCancelFocusedCellRestoreOnFrameSync(options = {}) {
+  return options.inProgress !== true;
+}
+function getCanCancelCellEdit(editingCell) {
+  return Boolean(editingCell);
+}
+function getCanRunGridKeyboardShortcut(editingCell) {
+  return !editingCell;
+}
+function getFocusedRowSelectionTarget(rows, focusedCell) {
+  if (!focusedCell) {
+    return null;
+  }
+  const rowIndex = rows.findIndex((row2) => row2.id === focusedCell.rowId);
+  const row = rowIndex >= 0 ? rows[rowIndex] : void 0;
+  return row ? { row, rowIndex } : null;
+}
+function getCanToggleRowSelection(event) {
+  return !event.defaultPrevented;
+}
+function getCellEditText(value) {
+  return value == null ? "" : String(value);
+}
+function getCellEditorTargetValue(target) {
+  return target && typeof target === "object" && "value" in target ? target.value : void 0;
+}
+function getCellEditorEventValue(event) {
+  const value = getCellEditorTargetValue(event.currentTarget) ?? getCellEditorTargetValue(event.target);
+  return typeof value === "string" ? value : "";
+}
+function parseCellEditValue(grid, row, column, value) {
+  return column.columnDef.editValueParser ? column.columnDef.editValueParser(value, {
+    grid,
+    row,
+    column,
+    previousValue: row.getValue(column.id)
+  }) : value;
+}
+function getCellEditValidationMessage(event) {
+  return event?.validation?.valid === false ? event.validation.message ?? "Invalid value" : null;
+}
+function getDefaultClipboardTextEnvironment() {
+  const clipboardDocument = typeof document === "undefined" ? void 0 : {
+    body: document.body ? {
+      appendChild: (element) => document.body?.appendChild(element),
+      removeChild: (element) => document.body?.removeChild(element)
+    } : void 0,
+    documentElement: {
+      appendChild: (element) => document.documentElement.appendChild(element),
+      removeChild: (element) => document.documentElement.removeChild(element)
+    },
+    createElement: () => document.createElement("textarea"),
+    execCommand: (command) => document.execCommand(command)
+  };
+  return {
+    document: clipboardDocument,
+    navigator: typeof navigator === "undefined" ? void 0 : navigator
+  };
+}
+function getDefaultBrowserDownloadEnvironment() {
+  const downloadDocument = typeof document === "undefined" ? void 0 : {
+    body: document.body ? {
+      appendChild: (element) => document.body?.appendChild(element),
+      removeChild: (element) => document.body?.removeChild(element)
+    } : void 0,
+    documentElement: {
+      appendChild: (element) => document.documentElement.appendChild(element),
+      removeChild: (element) => document.documentElement.removeChild(element)
+    },
+    createElement: () => document.createElement("a")
+  };
+  const BrowserBlob = typeof Blob === "undefined" ? void 0 : Blob;
+  return {
+    blob: BrowserBlob ? /* @__PURE__ */ (() => {
+      const BlobConstructor = BrowserBlob;
+      return class {
+        constructor(blobParts, options) {
+          return new BlobConstructor([...blobParts], options);
+        }
+      };
+    })() : void 0,
+    document: downloadDocument,
+    url: typeof URL === "undefined" ? void 0 : {
+      createObjectURL: (blob) => URL.createObjectURL(blob),
+      revokeObjectURL: (url) => URL.revokeObjectURL(url)
+    }
+  };
+}
+async function writeClipboardText(text, environment = getDefaultClipboardTextEnvironment()) {
+  if (environment.navigator?.clipboard?.writeText) {
+    try {
+      await environment.navigator.clipboard.writeText(text);
+      return true;
+    } catch {
+    }
+  }
+  if (!environment.document) {
+    return false;
+  }
+  const textarea = environment.document.createElement("textarea");
+  textarea.value = text;
+  textarea.setAttribute("readonly", "");
+  textarea.style.position = "fixed";
+  textarea.style.top = "-9999px";
+  textarea.style.left = "-9999px";
+  const parent = environment.document.body ?? environment.document.documentElement;
+  parent.appendChild(textarea);
+  textarea.select();
+  try {
+    return environment.document.execCommand("copy");
+  } finally {
+    parent.removeChild(textarea);
+  }
+}
+async function readClipboardText(environment = getDefaultClipboardTextEnvironment()) {
+  if (!environment.navigator?.clipboard?.readText) {
+    return "";
+  }
+  try {
+    return await environment.navigator.clipboard.readText();
+  } catch {
+    return "";
+  }
+}
+function downloadBrowserExportFile(file, environment = getDefaultBrowserDownloadEnvironment()) {
+  if (!environment.document || !environment.blob || !environment.url) {
+    return false;
+  }
+  const blob = new environment.blob([file.text], { type: file.mimeType });
+  const url = environment.url.createObjectURL(blob);
+  const anchor = environment.document.createElement("a");
+  anchor.href = url;
+  anchor.download = file.filename;
+  anchor.style.display = "none";
+  const parent = environment.document.body ?? environment.document.documentElement;
+  let appended = false;
+  try {
+    parent.appendChild(anchor);
+    appended = true;
+    anchor.click();
+    return true;
+  } finally {
+    if (appended) {
+      parent.removeChild(anchor);
+    }
+    environment.url.revokeObjectURL(url);
+  }
+}
+function getCellDisplayText(value) {
+  return value == null ? "" : String(value);
+}
+function escapeGridHtml(value) {
+  return value.replace(/[&<"]/g, (character) => `&#${character.charCodeAt(0)};`);
+}
+function getColumnHeaderText(column) {
+  const header = column.columnDef.header;
+  return typeof header === "string" ? header : column.id;
+}
+function getCellFillHandleVisible(row, column, options) {
+  return !row.getIsGrouped() && !row.getIsGroupFooter() && Boolean(options.rangeSelected) && !options.editing && !options.activeEditing && isCellCoordinateEqual(options.fillHandleCoordinate, { rowId: row.id, columnId: column.id });
+}
+function getCanStartCellPointerDrag(event, editingCell) {
+  return isPrimaryPointerButton(event) && !editingCell;
+}
+function getCellEditorProps(column, options = {}) {
+  return {
+    "aria-label": `Edit ${column.id}`,
+    "aria-invalid": options.invalid || void 0
+  };
+}
+function getCellEditorOptionProps(option) {
+  return {
+    value: option.value,
+    disabled: option.disabled || void 0
+  };
+}
+function getCellEditorOptionText(option) {
+  return option.label ?? option.value;
+}
+function getCellValidationMessageProps() {
+  return {
+    role: "alert"
+  };
+}
+function isFocusableElement(target) {
+  return !!target && typeof target === "object" && "focus" in target && typeof target.focus === "function";
+}
+function getEnabledHeaderActionMenuItems(menu) {
+  if (!menu) {
+    return [];
+  }
+  const items = [];
+  for (const item of Array.from(menu.querySelectorAll(HEADER_ACTION_MENU_ENABLED_ITEM_SELECTOR))) {
+    if (isFocusableElement(item)) {
+      items.push(item);
+    }
+  }
+  return items;
+}
+function getHeaderActionMenuActiveElement(menu, fallbackDocument = typeof document === "undefined" ? void 0 : document) {
+  return menu?.ownerDocument?.activeElement ?? fallbackDocument?.activeElement ?? null;
+}
+function focusHeaderActionMenuItem(menu, position) {
+  if (!menu) {
+    return false;
+  }
+  const items = getEnabledHeaderActionMenuItems(menu);
+  if (items.length === 0) {
+    menu.focus();
+    return true;
+  }
+  const activeElement = getHeaderActionMenuActiveElement(menu);
+  const activeIndex = items.findIndex((item) => item === activeElement);
+  if (position === "first") {
+    items[0]?.focus();
+  } else if (position === "last") {
+    items[items.length - 1]?.focus();
+  } else if (position === "next") {
+    items[(activeIndex + 1 + items.length) % items.length]?.focus();
+  } else {
+    items[(activeIndex - 1 + items.length) % items.length]?.focus();
+  }
+  return true;
+}
+function isHeaderActionMenuFocusTarget(target) {
+  return !!target && typeof target === "object" && "focus" in target && typeof target.focus === "function" && "querySelectorAll" in target && typeof target.querySelectorAll === "function";
+}
+function getHeaderActionMenuFocusTarget(event) {
+  return isHeaderActionMenuFocusTarget(event.currentTarget) ? event.currentTarget : null;
+}
+function focusElement(element) {
+  if (!isFocusableElement(element)) {
+    return false;
+  }
+  element.focus();
+  return true;
+}
+function focusCellEditorElement(element) {
+  if (!element) {
+    return false;
+  }
+  element.focus();
+  element.select?.();
+  return true;
+}
+function focusElementById(lookup, id) {
+  return focusElement(lookup.getElementById(id));
+}
+function focusHeaderActionMenuTrigger(element) {
+  return focusElement(element);
+}
+function focusHeaderActionMenuTriggerById(lookup, id) {
+  return focusHeaderActionMenuTrigger(lookup.getElementById(id));
+}
+function focusHeaderActionMenuItemById(lookup, id, position) {
+  return focusHeaderActionMenuItem(lookup.getElementById(id), position);
+}
+function focusFocusedCellInGrid(container) {
+  return focusElement(container?.querySelector(GRID_FOCUSED_CELL_SELECTOR));
+}
+function scrollElementToPosition(element, position) {
+  if (!element || !position) {
+    return false;
+  }
+  element.scrollLeft = position.scrollLeft;
+  element.scrollTop = position.scrollTop;
+  return true;
+}
+function getScrollFrameOptionsFromElement(element, options = {}) {
+  return {
+    scrollTop: options.scrollTop ?? element.scrollTop,
+    scrollLeft: options.scrollLeft ?? element.scrollLeft,
+    viewportHeight: element.clientHeight,
+    viewportWidth: element.clientWidth,
+    stickyTopOffset: options.stickyTopOffset ?? 0
+  };
+}
+function getFocusedCellScrollOptionsFromElement(element, options) {
+  return {
+    ...options,
+    currentScrollLeft: element.scrollLeft,
+    currentScrollTop: element.scrollTop,
+    viewportWidth: element.clientWidth,
+    viewportHeight: element.clientHeight
+  };
+}
+function isGridInteractiveKeyboardTarget(target, currentTarget) {
+  if (!target || target === currentTarget || !("closest" in target) || typeof target.closest !== "function") {
+    return false;
+  }
+  return Boolean(target.closest(GRID_INTERACTIVE_KEYBOARD_TARGET_SELECTOR));
+}
+function isGridInteractiveKeyboardEventTarget(event) {
+  return isGridInteractiveKeyboardTarget(event.target, event.currentTarget);
+}
+function getShouldPreventEventDefault(event) {
+  return event.defaultPrevented;
+}
+function preventDefaultAndStopPropagation(event) {
+  event.preventDefault();
+  event.stopPropagation();
+}
+function preventEventDefault(event) {
+  event.preventDefault();
+}
+function stopEventPropagation(event) {
+  event.stopPropagation();
+}
+function createClickSuppressionController() {
+  let suppressed = false;
+  return {
+    suppress() {
+      suppressed = true;
+    },
+    consume(event) {
+      if (!suppressed) {
+        return false;
+      }
+      suppressed = false;
+      if (event) {
+        preventDefaultAndStopPropagation(event);
+      }
+      return true;
+    }
+  };
+}
+function isPointerInsideElement(event, element) {
+  if (!element) {
+    return false;
+  }
+  const rect = element.getBoundingClientRect();
+  return event.clientX >= rect.left && event.clientX <= rect.right && event.clientY >= rect.top && event.clientY <= rect.bottom;
+}
+function hasPointerMovedPastDragThreshold(event, start, threshold = 4) {
+  return Math.abs(event.clientX - start.startX) > threshold || Math.abs(event.clientY - start.startY) > threshold;
+}
+function updatePointerDragDidMovePastThreshold(drag, event, threshold = 4) {
+  if (!drag.didDrag && hasPointerMovedPastDragThreshold(event, drag, threshold)) {
+    drag.didDrag = true;
+  }
+  return Boolean(drag.didDrag);
+}
+function isPrimaryPointerButton(event) {
+  return event.button === 0;
+}
+function isPrimaryPointerDragActive(event) {
+  return (event.buttons & 1) === 1;
+}
+function getCanContinuePointerDrag(drag, event) {
+  return drag != null && drag.pointerId === event.pointerId && isPrimaryPointerDragActive(event);
+}
+function getCanEndPointerDrag(drag, event) {
+  return drag != null && drag.pointerId === event.pointerId;
+}
+function getHeaderDragEndAction(drag, options) {
+  if (!drag.didDrag) {
+    return null;
+  }
+  const droppedOnGroupingPanel = options.groupingPanel && isPointerInsideElement(options.event, options.groupingPanelElement);
+  const sourceColumn = options.columns.find((column) => column.id === drag.sourceColumnId);
+  if (droppedOnGroupingPanel && sourceColumn?.getCanGroup()) {
+    return {
+      type: "group",
+      columnId: drag.sourceColumnId
+    };
+  }
+  return {
+    type: "move",
+    sourceColumnId: drag.sourceColumnId,
+    targetColumnId: drag.targetColumnId
+  };
+}
+function isHeaderDragGroupAction(action) {
+  return action?.type === "group";
+}
+function isHeaderDragMoveAction(action) {
+  return action?.type === "move";
+}
+function getMeasuredElementBlockSize(element, fallbackSize) {
+  return Math.max(fallbackSize, element.scrollHeight);
+}
+function isMeasuredBlockElement(target) {
+  return typeof target === "object" && target !== null && "scrollHeight" in target && typeof target.scrollHeight === "number";
+}
+function isMeasuredBlockRectElement(target) {
+  return isMeasuredBlockElement(target) && "getBoundingClientRect" in target && typeof target.getBoundingClientRect === "function";
+}
+function isMeasuredBlockRectElementTarget(target) {
+  return typeof Element !== "undefined" && target instanceof Element && isMeasuredBlockRectElement(target);
+}
+function isMeasuredInlineElement(target) {
+  return typeof target === "object" && target !== null && "getBoundingClientRect" in target && typeof target.getBoundingClientRect === "function";
+}
+function isMeasuredInlineDatasetElementTarget(target) {
+  return typeof Element !== "undefined" && target instanceof Element && isMeasuredInlineElement(target) && "dataset" in target && typeof target.dataset === "object" && target.dataset !== null;
+}
+function getMeasuredElementBlockSizeFromTarget(target, fallbackSize) {
+  return isMeasuredBlockElement(target) ? getMeasuredElementBlockSize(target, fallbackSize) : fallbackSize;
+}
+function getMeasuredElementBlockSizeFromRect(element) {
+  return getMeasuredElementBlockSize(element, element.getBoundingClientRect().height);
+}
+function getMeasuredElementInlineSize(element) {
+  return element.getBoundingClientRect().width;
+}
+function getElementOffsetBlockSize(element, fallbackSize) {
+  return element?.offsetHeight ?? fallbackSize;
+}
+function getResizeObserverEntryBlockSize(entry) {
+  const borderBoxSize = Array.isArray(entry.borderBoxSize) ? entry.borderBoxSize[0] : entry.borderBoxSize;
+  return getMeasuredElementBlockSizeFromTarget(entry.target, borderBoxSize?.blockSize ?? entry.contentRect.height);
+}
+function getResizeObserverEntryInlineSize(entry) {
+  const borderBoxSize = Array.isArray(entry.borderBoxSize) ? entry.borderBoxSize[0] : entry.borderBoxSize;
+  return borderBoxSize?.inlineSize ?? entry.contentRect.width;
+}
+function isResizeObserverDatasetTarget(target) {
+  if (typeof target !== "object" || target === null) {
+    return false;
+  }
+  if (!("dataset" in target)) {
+    return true;
+  }
+  return typeof target.dataset === "object" && target.dataset !== null;
+}
+function getResizeObserverEntryDatasetId(entry, key) {
+  const value = isResizeObserverDatasetTarget(entry.target) ? entry.target.dataset?.[key] : void 0;
+  return value || null;
+}
+function setElementDatasetId(element, key, value) {
+  element.dataset[key] = value;
+}
+function createResizeObserver(callback, ResizeObserverConstructor = typeof ResizeObserver === "undefined" ? void 0 : ResizeObserver) {
+  return ResizeObserverConstructor ? new ResizeObserverConstructor(callback) : null;
+}
+function observeElements(observer, elements) {
+  for (const element of elements) {
+    observer.observe(element);
+  }
+}
+function disconnectResizeObserver(observer) {
+  observer?.disconnect();
+}
+function removeObservedElement(observer, elements, id) {
+  const previous = elements.get(id);
+  if (previous) {
+    observer?.unobserve(previous);
+    elements.delete(id);
+  }
+}
+function replaceObservedElement(observer, elements, id, element) {
+  const previous = elements.get(id);
+  if (previous && previous !== element) {
+    observer?.unobserve(previous);
+    elements.delete(id);
+  }
+  elements.set(id, element);
+  observer?.observe(element);
+}
+function applyResizeObserverMeasuredSizes(entries, options) {
+  let changed = false;
+  for (const entry of entries) {
+    const id = getResizeObserverEntryDatasetId(entry, options.datasetKey);
+    if (!id) {
+      continue;
+    }
+    changed = options.cache.set(id, options.getSize(entry)) || changed;
+  }
+  return changed;
+}
+function getSizeOffset(index, getSize) {
+  let offset = 0;
+  for (let currentIndex = 0; currentIndex < index; currentIndex += 1) {
+    offset += getSize(currentIndex);
+  }
+  return offset;
+}
+function getColumnLayoutTotalWidth(layout) {
+  return layout.reduce((total, item) => Math.max(total, item.end), 0);
+}
+function getColumnLayoutById(layout) {
+  return new Map(layout.map((item) => [item.id, item]));
+}
+function getColumnById(columnId, columns) {
+  return columns.find((column) => column.id === columnId);
+}
+function getColumnIndexById(columnId, columns) {
+  return columns.findIndex((column) => column.id === columnId);
+}
+function getRowById(rowId, rows) {
+  return rows.find((row) => row.id === rowId);
+}
+function moveVisibleColumn(grid, columnId, direction) {
+  const columns = grid.getVisibleLeafColumns();
+  const columnIndex = columns.findIndex((column) => column.id === columnId);
+  const targetColumn = columns[direction === "left" ? columnIndex - 1 : columnIndex + 1];
+  if (columnIndex < 0 || !targetColumn) {
+    return false;
+  }
+  grid.moveColumn(columnId, targetColumn.id, direction === "left" ? "before" : "after");
+  return true;
+}
+function moveColumnToTarget(grid, sourceColumnId, targetColumnId) {
+  if (sourceColumnId === targetColumnId) {
+    return false;
+  }
+  const columns = grid.getVisibleLeafColumns();
+  const sourceIndex = columns.findIndex((column) => column.id === sourceColumnId);
+  const targetIndex = columns.findIndex((column) => column.id === targetColumnId);
+  if (sourceIndex < 0 || targetIndex < 0) {
+    return false;
+  }
+  grid.moveColumn(sourceColumnId, targetColumnId, sourceIndex < targetIndex ? "after" : "before");
+  return true;
+}
+function moveGroupedColumn(grid, groupingColumns, columnId, direction) {
+  const columnIndex = groupingColumns.findIndex((column) => column.id === columnId);
+  const targetColumn = groupingColumns[direction === "left" ? columnIndex - 1 : columnIndex + 1];
+  if (columnIndex < 0 || !targetColumn) {
+    return false;
+  }
+  grid.moveGroupingColumn(columnId, targetColumn.id, direction === "left" ? "before" : "after");
+  return true;
+}
+function resolveRowVirtualizationOptions(rowVirtualization) {
+  if (rowVirtualization === true) {
+    return {
+      enabled: true,
+      estimateRowHeight: 40,
+      measureRowHeight: true,
+      overscan: 6
+    };
+  }
+  if (!rowVirtualization) {
+    return {
+      enabled: false,
+      estimateRowHeight: 40,
+      measureRowHeight: true,
+      overscan: 6
+    };
+  }
+  return {
+    enabled: rowVirtualization.enabled ?? true,
+    estimateRowHeight: rowVirtualization.estimateRowHeight ?? 40,
+    measureRowHeight: rowVirtualization.measureRowHeight ?? true,
+    overscan: rowVirtualization.overscan ?? 6
+  };
+}
+function resolveColumnVirtualizationOptions(columnVirtualization) {
+  if (columnVirtualization === true) {
+    return {
+      enabled: true,
+      measureColumnWidth: true,
+      overscan: 2
+    };
+  }
+  if (!columnVirtualization) {
+    return {
+      enabled: false,
+      measureColumnWidth: true,
+      overscan: 2
+    };
+  }
+  return {
+    enabled: columnVirtualization.enabled ?? true,
+    measureColumnWidth: columnVirtualization.measureColumnWidth ?? true,
+    overscan: columnVirtualization.overscan ?? 2
+  };
+}
+function getScrollForFocusedCell(options) {
+  const {
+    focusedCell,
+    layout,
+    rows,
+    currentScrollLeft,
+    currentScrollTop,
+    viewportWidth,
+    viewportHeight,
+    headerHeight,
+    getRowSize,
+    rowVirtualOptions,
+    columnVirtualOptions
+  } = options;
+  let scrollLeft = currentScrollLeft;
+  let scrollTop = currentScrollTop;
+  if (columnVirtualOptions.enabled) {
+    const columnLayout = layout.find((item) => item.id === focusedCell.columnId);
+    if (columnLayout && columnLayout.pinned === false) {
+      const leftPinnedWidth = layout.filter((item) => item.pinned === "left").reduce((total, item) => total + item.size, 0);
+      const rightPinnedWidth = layout.filter((item) => item.pinned === "right").reduce((total, item) => total + item.size, 0);
+      const visibleLeft = currentScrollLeft + leftPinnedWidth;
+      const visibleRight = currentScrollLeft + viewportWidth - rightPinnedWidth;
+      if (columnLayout.start < visibleLeft) {
+        scrollLeft = Math.max(0, columnLayout.start - leftPinnedWidth);
+      } else if (columnLayout.end > visibleRight) {
+        scrollLeft = Math.max(0, columnLayout.end - viewportWidth + rightPinnedWidth);
+      }
+    }
+  }
+  if (rowVirtualOptions.enabled) {
+    const rowIndex = rows.findIndex((row) => row.id === focusedCell.rowId);
+    if (rowIndex >= 0) {
+      const rowStart = headerHeight + getSizeOffset(rowIndex, getRowSize);
+      const rowEnd = rowStart + getRowSize(rowIndex);
+      const visibleTop = currentScrollTop;
+      const visibleBottom = currentScrollTop + viewportHeight;
+      if (rowStart < visibleTop) {
+        scrollTop = Math.max(0, rowStart);
+      } else if (rowEnd > visibleBottom) {
+        scrollTop = Math.max(0, rowEnd - viewportHeight);
+      }
+    }
+  }
+  if (scrollLeft === currentScrollLeft && scrollTop === currentScrollTop) {
+    return null;
+  }
+  return {
+    scrollLeft,
+    scrollTop
+  };
+}
+function getVirtualRowStyle(virtualItem) {
+  if (!virtualItem) {
+    return void 0;
+  }
+  return {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    height: virtualItem.size,
+    transform: `translateY(${virtualItem.start}px)`
+  };
+}
+function getVirtualRowStyleText(virtualItem) {
+  const style = getVirtualRowStyle(virtualItem);
+  if (!style) {
+    return void 0;
+  }
+  return [
+    `position: ${style.position}`,
+    `top: ${style.top}`,
+    `left: ${style.left}`,
+    `right: ${style.right}`,
+    `height: ${style.height}px`,
+    `transform: ${style.transform}`
+  ].join("; ");
+}
+function getVirtualBodyStyle(virtualRange) {
+  if (!virtualRange) {
+    return void 0;
+  }
+  return {
+    height: virtualRange.totalSize
+  };
+}
+function getVirtualBodyStyleText(virtualRange) {
+  const style = getVirtualBodyStyle(virtualRange);
+  if (!style) {
+    return void 0;
+  }
+  return `height: ${style.height}px`;
+}
+function getInlineSizeStyle(size) {
+  return {
+    width: size
+  };
+}
+function getInlineSizeStyleText(size) {
+  return `width: ${size}px`;
+}
+function getVirtualizedInlineSizeStyle(size, enabled) {
+  if (!enabled) {
+    return void 0;
+  }
+  return {
+    width: size,
+    minWidth: size
+  };
+}
+function getVirtualizedInlineSizeStyleText(size, enabled) {
+  const style = getVirtualizedInlineSizeStyle(size, enabled);
+  if (!style) {
+    return void 0;
+  }
+  return `width: ${style.width}px; min-width: ${style.minWidth}px`;
+}
+function getPinnedColumnOffsetStyle(layout) {
+  if (layout?.pinned === "left") {
+    return {
+      position: "sticky",
+      left: layout.pinnedStart ?? 0
+    };
+  }
+  if (layout?.pinned === "right") {
+    return {
+      position: "sticky",
+      right: layout.pinnedStart ?? 0
+    };
+  }
+  return void 0;
+}
+function getPinnedColumnOffsetStyleText(layout) {
+  const style = getPinnedColumnOffsetStyle(layout);
+  if (!style) {
+    return void 0;
+  }
+  if ("left" in style) {
+    return `position: sticky; left: ${style.left}px`;
+  }
+  return `position: sticky; right: ${style.right}px`;
+}
+function isCellCoordinateEqual(left, right) {
+  return !!left && !!right && left.rowId === right.rowId && left.columnId === right.columnId;
+}
+function isFocusedCell(focusedCell, rowId, columnId) {
+  return isCellCoordinateEqual(focusedCell, { rowId, columnId });
+}
+export {
+  DEFAULT_PAGINATION_PAGE_SIZE_OPTIONS,
+  GRID_DENSITIES,
+  GRID_FOCUSED_CELL_SELECTOR,
+  GRID_INTERACTIVE_KEYBOARD_TARGET_SELECTOR,
+  GRID_PREFERENCES_VERSION,
+  GROUPING_PANEL_EMPTY_MESSAGE,
+  HEADER_ACTION_MENU_ENABLED_ITEM_SELECTOR,
+  HEADER_ACTION_MENU_TRIGGER_TEXT,
+  addPassiveScrollListener,
+  addPointerMoveUpCancelListeners,
+  addPointerMoveUpListeners,
+  addPointerUpCancelListeners,
+  applyResizeObserverMeasuredSizes,
+  createClickSuppressionController,
+  createGridPreferences,
+  createResizeObserver,
+  disconnectResizeObserver,
+  downloadBrowserExportFile,
+  escapeGridHtml,
+  focusCellEditorElement,
+  focusElement,
+  focusElementById,
+  focusFocusedCellInGrid,
+  focusHeaderActionMenuItem,
+  focusHeaderActionMenuItemById,
+  focusHeaderActionMenuTrigger,
+  focusHeaderActionMenuTriggerById,
+  getBrowserGridPreferencesStorage,
+  getCanApplyColumnResize,
+  getCanCancelCellEdit,
+  getCanContinuePointerDrag,
+  getCanEndPointerDrag,
+  getCanRestoreFocusedCell,
+  getCanRunGridKeyboardShortcut,
+  getCanStartCellEdit,
+  getCanStartCellPointerDrag,
+  getCanStartColumnResize,
+  getCanStartFocusedCellEdit,
+  getCanToggleRowSelection,
+  getCellDisplayText,
+  getCellEditText,
+  getCellEditValidationMessage,
+  getCellEditorEventValue,
+  getCellEditorKeyboardAction,
+  getCellEditorOptionProps,
+  getCellEditorOptionText,
+  getCellEditorProps,
+  getCellEditorTargetValue,
+  getCellFillHandleProps,
+  getCellFillHandleVisible,
+  getCellLayoutProps,
+  getCellProps,
+  getCellValidationMessageProps,
+  getColumnById,
+  getColumnFilterCellProps,
+  getColumnFilterInputProps,
+  getColumnFilterText,
+  getColumnHeaderText,
+  getColumnIndexById,
+  getColumnLayoutById,
+  getColumnLayoutTotalWidth,
+  getColumnPinningButtonProps,
+  getColumnPinningButtonText,
+  getColumnPinningControlsProps,
+  getColumnResizeFinalSize,
+  getColumnResizeHandleProps,
+  getColumnResizeKeyboardSize,
+  getColumnResizePointerSize,
+  getColumnResizeStartSize,
+  getColumnSpacerProps,
+  getColumnVisibilityCheckboxProps,
+  getColumnVisibilityControlsProps,
+  getColumnVisibilityEmptyText,
+  getColumnVisibilityListProps,
+  getColumnVisibilityResetButtonProps,
+  getColumnVisibilityResetButtonText,
+  getColumnVisibilitySearchInputProps,
+  getColumnVisibilityStatusProps,
+  getColumnVisibilityStatusText,
+  getColumnVisibilitySummaryProps,
+  getColumnVisibilitySummaryText,
+  getDefaultBrowserDownloadEnvironment,
+  getDefaultClipboardTextEnvironment,
+  getDefaultPointerMoveUpCancelListenerTarget,
+  getDefaultPointerMoveUpListenerTarget,
+  getDefaultPointerUpCancelListenerTarget,
+  getDensityButtonProps,
+  getDensityButtonText,
+  getDensityControlsProps,
+  getElementOffsetBlockSize,
+  getEnabledHeaderActionMenuItems,
+  getFilteredColumnVisibilityColumns,
+  getFocusedCellScrollOptionsFromElement,
+  getFocusedRowSelectionTarget,
+  getGridBodyProps,
+  getGridBodyRowIndexOffset,
+  getGridDensityProps,
+  getGridDensityRowHeight,
+  getGridEmptyCellProps,
+  getGridEmptyRowProps,
+  getGridErrorOverlayProps,
+  getGridErrorRetryButtonProps,
+  getGridErrorRetryButtonText,
+  getGridErrorText,
+  getGridHeaderProps,
+  getGridHeaderRowCount,
+  getGridHeaderRowProps,
+  getGridKeyboardEditAction,
+  getGridKeyboardFocusMove,
+  getGridKeyboardShortcutAction,
+  getGridLoadingOverlayProps,
+  getGridLoadingText,
+  getGridProps,
+  getGroupCellIndent,
+  getGroupCellIndentStyle,
+  getGroupCellIndentStyleText,
+  getGroupRowCountText,
+  getGroupRowLabel,
+  getGroupValueText,
+  getGroupingPanelChipProps,
+  getGroupingPanelMoveButtonProps,
+  getGroupingPanelPlaceholderProps,
+  getGroupingPanelProps,
+  getGroupingPanelRemoveButtonProps,
+  getHeaderActionMenuActiveElement,
+  getHeaderActionMenuCustomItemProps,
+  getHeaderActionMenuCustomItemUserProps,
+  getHeaderActionMenuDefaultItemDescriptors,
+  getHeaderActionMenuDefaultItemLabel,
+  getHeaderActionMenuFocusTarget,
+  getHeaderActionMenuId,
+  getHeaderActionMenuItemProps,
+  getHeaderActionMenuKeyboardAction,
+  getHeaderActionMenuLabelProps,
+  getHeaderActionMenuProps,
+  getHeaderActionMenuSeparatorProps,
+  getHeaderActionMenuTriggerFocusPosition,
+  getHeaderActionMenuTriggerId,
+  getHeaderActionMenuTriggerProps,
+  getHeaderButtonProps,
+  getHeaderCellLayoutProps,
+  getHeaderCellProps,
+  getHeaderDragEndAction,
+  getHeaderKeyboardMoveDirection,
+  getHeaderPlaceholderCellProps,
+  getHeaderSortIndicatorProps,
+  getHeaderSortIndicatorText,
+  getInlineSizeStyle,
+  getInlineSizeStyleText,
+  getIsGroupLabelCell,
+  getMeasuredElementBlockSize,
+  getMeasuredElementBlockSizeFromRect,
+  getMeasuredElementBlockSizeFromTarget,
+  getMeasuredElementInlineSize,
+  getNextColumnFilters,
+  getPaginationButtonProps,
+  getPaginationButtonText,
+  getPaginationPageSizeOptionText,
+  getPaginationPageSizeOptions,
+  getPaginationPageSizeSelectProps,
+  getPaginationPageText,
+  getPaginationProps,
+  getPaginationStatusProps,
+  getPinnedColumnOffsetStyle,
+  getPinnedColumnOffsetStyleText,
+  getPointerCaptureTarget,
+  getQuickFilterClearButtonProps,
+  getQuickFilterClearButtonText,
+  getQuickFilterInputProps,
+  getQuickFilterProps,
+  getResizeObserverEntryBlockSize,
+  getResizeObserverEntryDatasetId,
+  getResizeObserverEntryInlineSize,
+  getRowById,
+  getRowExpansionSpacerProps,
+  getRowExpansionToggleProps,
+  getRowExpansionToggleText,
+  getRowLayoutProps,
+  getRowProps,
+  getRowSelectionCheckboxProps,
+  getRowSelectionCheckboxText,
+  getRowSelectionClearButtonProps,
+  getRowSelectionClearButtonText,
+  getRowSelectionControlsProps,
+  getRowSelectionStatusProps,
+  getRowSelectionStatusText,
+  getScrollForFocusedCell,
+  getScrollFrameOptionsFromElement,
+  getShouldCancelFocusedCellRestoreOnFrameSync,
+  getShouldPreventEventDefault,
+  getSizeOffset,
+  getVirtualBodyStyle,
+  getVirtualBodyStyleText,
+  getVirtualRowStyle,
+  getVirtualRowStyleText,
+  getVirtualizedInlineSizeStyle,
+  getVirtualizedInlineSizeStyleText,
+  hasPointerMovedPastDragThreshold,
+  isCellCoordinateEqual,
+  isFocusableElement,
+  isFocusedCell,
+  isGridInteractiveKeyboardEventTarget,
+  isGridInteractiveKeyboardTarget,
+  isHeaderActionMenuActionItem,
+  isHeaderActionMenuCloseAction,
+  isHeaderActionMenuCustomItem,
+  isHeaderActionMenuFocusAction,
+  isHeaderActionMenuFocusTarget,
+  isHeaderActionMenuItem,
+  isHeaderActionMenuLabelItem,
+  isHeaderActionMenuSeparatorItem,
+  isHeaderActionMenuTabCloseAction,
+  isHeaderDragGroupAction,
+  isHeaderDragMoveAction,
+  isMeasuredBlockElement,
+  isMeasuredBlockRectElement,
+  isMeasuredBlockRectElementTarget,
+  isMeasuredInlineDatasetElementTarget,
+  isMeasuredInlineElement,
+  isPointerCaptureTarget,
+  isPointerInsideElement,
+  isPrimaryPointerButton,
+  isPrimaryPointerDragActive,
+  isResizeObserverDatasetTarget,
+  moveColumnToTarget,
+  moveGroupedColumn,
+  moveVisibleColumn,
+  normalizeGridDensity,
+  observeElements,
+  parseCellEditValue,
+  parseGridPreferences,
+  preventDefaultAndStopPropagation,
+  preventEventDefault,
+  readClipboardText,
+  readGridPreferences,
+  removeGridPreferences,
+  removeObservedElement,
+  replaceObservedElement,
+  resolveColumnVirtualizationOptions,
+  resolveRowVirtualizationOptions,
+  scrollElementToPosition,
+  serializeGridPreferences,
+  setCheckboxIndeterminate,
+  setElementDatasetId,
+  stopEventPropagation,
+  tryReleasePointerCapture,
+  trySetPointerCapture,
+  updatePointerDragDidMovePastThreshold,
+  writeClipboardText,
+  writeGridPreferences
+};