@apia/table 0.1.0

package/dist/index.js

@@ -0,0 +1,3267 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import React, { useState, useMemo, forwardRef, useCallback } from 'react';
+import { Box, Button, Input, Link, Spinner } from 'theme-ui';
+import { useBreakpointIndex } from '@theme-ui/match-media';
+import { getVariant } from '@apia/theme';
+import { useThrottleFn, useMount, useUpdateEffect as useUpdateEffect$1, useUnmount } from 'ahooks';
+import { uniqueId } from 'lodash-es';
+import { createSlice, injectReducers, shallowEqual as shallowEqual$1 } from '@apia/store';
+import { addBoundary, AriaLiveEmitter, formatMessage, useLatest, useUpdateEffect, getSpecificParent, isChild, autoDisconnectMutationObserver, getFocusSelector, cantFocusSelector, globalFocus, scrollParentIntoElement, customEvents, debugDispatcher, persistentStorage, EventEmitter, downloadUrl, arrayOrArray, useMount as useMount$1, getDateFormat } from '@apia/util';
+import { shallowEqual } from 'react-redux';
+import { useOtherTagButton, ApiaFilter, IconButton } from '@apia/components';
+import { Icon } from '@apia/icons';
+import { FaSortUp, FaSortDown, FaSort, FaMinusSquare, FaPlusSquare, FaSquare } from '@meronex/icons/fa';
+import dayjs from 'dayjs';
+
+const defaultLabels = {
+  noRegisters: window.FINDER_NO_DATA
+};
+
+function getInitialState$1() {
+  return {
+    allowEdition: false,
+    allowSelection: true,
+    columns: [],
+    expandedRows: [],
+    isEditionMode: false,
+    isFocused: false,
+    filters: [],
+    focusedColumn: 0,
+    focusedRow: 0,
+    hasNonAdditionalFilters: false,
+    isMultiple: true,
+    nonAdditionalColumnsCount: 0,
+    rows: [],
+    selectedRows: [],
+    statesColumns: 0
+  };
+}
+
+function addRowBoundary(newRow, state) {
+  const hasFiltersRow = !!state.filters.find(
+    (current) => !!state.columns.find((search) => search.name === current.column)
+  );
+  return addBoundary({
+    number: newRow,
+    min: hasFiltersRow ? -2 : -1,
+    max: Math.max(0, state.rows.length - 1)
+  });
+}
+function addColumnBoundary(newColumn, state) {
+  return addBoundary({
+    number: newColumn,
+    min: 0,
+    max: state.nonAdditionalColumnsCount + state.statesColumns + (state.hasNonAdditionalFilters ? 1 : 0)
+  });
+}
+function isBasicRow(row) {
+  return typeof row === "object" && !!row && "forbidSelection" in row;
+}
+function filterNonSellectableRows(state, newSelection) {
+  let expandedRowsBefore = 0;
+  return newSelection.filter((selectedRowIndex) => {
+    const row = state.rows[selectedRowIndex + expandedRowsBefore];
+    if (state.expandedRows.includes(selectedRowIndex))
+      expandedRowsBefore += 1;
+    return !(isBasicRow(row) && row.forbidSelection);
+  });
+}
+function setNewFocused(state, {
+  /**
+   * Propiedad proveniente del evento click o keydown.
+   */
+  ctrlKey,
+  /**
+   * Propiedad proveniente del evento click o keydown.
+   */
+  shiftKey,
+  newFocusedColumn,
+  newFocusedRow,
+  /**
+   * Con este método se puede seleccionar cuál celda
+   * va a recibir el foco y la selección, o solamente
+   * el foco si esta propiedad es pasada en false.
+   */
+  shouldSelectNewFocused
+}) {
+  var _a;
+  let actualNewFocusedRow = Math.round(
+    addRowBoundary((_a = newFocusedRow != null ? newFocusedRow : state.focusedRow) != null ? _a : 0, state) * 2
+  ) / 2;
+  const actualNewFocusedColumn = addColumnBoundary(
+    newFocusedColumn != null ? newFocusedColumn : state.focusedColumn,
+    state
+  );
+  state.focusedColumn = actualNewFocusedColumn;
+  state.focusedRow = actualNewFocusedRow;
+  state.isFocused = shouldSelectNewFocused != null ? shouldSelectNewFocused : false;
+  if (shouldSelectNewFocused === false || actualNewFocusedRow < 0)
+    return;
+  if (Math.round(actualNewFocusedRow) - actualNewFocusedRow !== 0)
+    actualNewFocusedRow = Math.floor(actualNewFocusedRow);
+  const isDeselectingWithCtrl = ctrlKey && state.selectedRows.includes(actualNewFocusedRow);
+  if (state.allowSelection !== false) {
+    if (!ctrlKey && !shiftKey || state.isMultiple === false && !isDeselectingWithCtrl)
+      state.selectedRows = filterNonSellectableRows(state, [
+        actualNewFocusedRow
+      ]);
+    else if (ctrlKey && state.isMultiple || isDeselectingWithCtrl) {
+      state.selectedRows = filterNonSellectableRows(
+        state,
+        state.selectedRows.includes(actualNewFocusedRow) ? state.selectedRows.filter(
+          (current) => current !== actualNewFocusedRow
+        ) : [...state.selectedRows, actualNewFocusedRow]
+      );
+    } else if (shiftKey && state.isMultiple) {
+      const sortedSelectedRows = [...state.selectedRows].sort((a, b) => a - b);
+      let minSelectedRow = sortedSelectedRows[0];
+      let maxSelectedRow = sortedSelectedRows[sortedSelectedRows.length - 1];
+      if (minSelectedRow === void 0) {
+        state.selectedRows = filterNonSellectableRows(state, [
+          actualNewFocusedRow
+        ]);
+        return;
+      }
+      if (actualNewFocusedRow < minSelectedRow)
+        minSelectedRow = actualNewFocusedRow;
+      if (actualNewFocusedRow > maxSelectedRow)
+        maxSelectedRow = actualNewFocusedRow;
+      const newSelectedRows = filterNonSellectableRows(
+        state,
+        new Array(maxSelectedRow - minSelectedRow + 1).fill("").map((_, i) => i + (minSelectedRow != null ? minSelectedRow : 0))
+      );
+      state.selectedRows = filterNonSellectableRows(state, newSelectedRows);
+    }
+  }
+}
+
+var __defProp$p = Object.defineProperty;
+var __getOwnPropSymbols$p = Object.getOwnPropertySymbols;
+var __hasOwnProp$p = Object.prototype.hasOwnProperty;
+var __propIsEnum$p = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$p = (obj, key, value) => key in obj ? __defProp$p(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$p = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$p.call(b, prop))
+      __defNormalProp$p(a, prop, b[prop]);
+  if (__getOwnPropSymbols$p)
+    for (var prop of __getOwnPropSymbols$p(b)) {
+      if (__propIsEnum$p.call(b, prop))
+        __defNormalProp$p(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest$d = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$p.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$p)
+    for (var prop of __getOwnPropSymbols$p(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$p.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function willHandleKey(ev, state) {
+  const actualKey = ev.key.toLowerCase();
+  if (state.isEditionMode)
+    return false;
+  if (actualKey === " " && ev.ctrlKey)
+    return true;
+  if (actualKey === "a" && ev.ctrlKey)
+    return true;
+  if (actualKey === "m" && ev.ctrlKey)
+    return true;
+  if (state.draggingRow !== void 0) {
+    return ["Escape", "Enter"].includes(ev.key);
+  }
+  return [
+    "arrowup",
+    "arrowdown",
+    "arrowleft",
+    "arrowright",
+    "end",
+    "enter",
+    "home",
+    "pageup",
+    "pagedown"
+  ].includes(ev.key.toLowerCase());
+}
+function handleKey(state, { ev }) {
+  const {
+    altKey: isAltPressed,
+    ctrlKey: isCtrlPressed,
+    key,
+    shiftKey: isShiftPressed
+  } = ev;
+  if (willHandleKey(ev, state))
+    ev.preventDefault();
+  const actualKey = key.toLowerCase();
+  const setFocus = (_a) => {
+    var _b = _a, {
+      newFocusedColumn,
+      newFocusedRow
+    } = _b, rest = __objRest$d(_b, [
+      "newFocusedColumn",
+      "newFocusedRow"
+    ]);
+    return setNewFocused(state, __spreadValues$p({
+      altKey: isAltPressed,
+      ctrlKey: isCtrlPressed,
+      shiftKey: isShiftPressed,
+      newFocusedColumn,
+      newFocusedRow
+    }, rest));
+  };
+  if (!state.isEditionMode) {
+    if (actualKey === "enter" && (state.allowEdition === true || state.focusedRow < 0))
+      state.isEditionMode = true;
+    else
+      switch (actualKey) {
+        case "arrowup": {
+          let sumRate = state.expandedRows.includes(state.focusedRow - 1) ? 0.6 : 1;
+          if (Math.round(state.focusedRow) - state.focusedRow !== 0)
+            sumRate = 0.5;
+          setFocus({
+            newFocusedRow: state.focusedRow - sumRate,
+            shouldSelectNewFocused: !isCtrlPressed
+          });
+          break;
+        }
+        case "arrowdown": {
+          let sumRate = state.expandedRows.includes(state.focusedRow) ? 0.6 : 1;
+          if (Math.round(state.focusedRow) - state.focusedRow !== 0)
+            sumRate = 0.5;
+          setFocus({
+            newFocusedRow: state.focusedRow + sumRate,
+            shouldSelectNewFocused: !isCtrlPressed
+          });
+          break;
+        }
+        case "arrowleft":
+        case "arrowright": {
+          setFocus({
+            newFocusedColumn: state.focusedColumn + (actualKey === "arrowleft" ? -1 : 1),
+            shouldSelectNewFocused: !isCtrlPressed
+          });
+          break;
+        }
+        case "home": {
+          if (isCtrlPressed)
+            setFocus({ newFocusedColumn: 0, newFocusedRow: 0, ctrlKey: false });
+          else
+            setFocus({ newFocusedColumn: 0 });
+          break;
+        }
+        case "end": {
+          if (isCtrlPressed)
+            setFocus({
+              newFocusedRow: Number.POSITIVE_INFINITY,
+              newFocusedColumn: Number.POSITIVE_INFINITY,
+              ctrlKey: false
+            });
+          else
+            setFocus({
+              newFocusedColumn: Number.POSITIVE_INFINITY
+            });
+          break;
+        }
+        case "pageup": {
+          setFocus({
+            newFocusedRow: state.focusedRow - 5,
+            shouldSelectNewFocused: !isCtrlPressed
+          });
+          break;
+        }
+        case "pagedown": {
+          setFocus({
+            newFocusedRow: state.focusedRow + 5,
+            shouldSelectNewFocused: !isCtrlPressed
+          });
+          break;
+        }
+        case " ": {
+          if (isCtrlPressed)
+            setFocus({
+              newFocusedRow: state.focusedRow
+            });
+          break;
+        }
+        case "a": {
+          if (isCtrlPressed && state.allowSelection)
+            state.selectedRows = state.rows.map((_, i) => i);
+          break;
+        }
+      }
+  } else
+    switch (actualKey) {
+      case "escape":
+      case "enter": {
+        if (state.isEditionMode)
+          state.isEditionMode = false;
+        ev.stopPropagation();
+        break;
+      }
+    }
+}
+
+var __defProp$o = Object.defineProperty;
+var __defProps$k = Object.defineProperties;
+var __getOwnPropDescs$k = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$o = Object.getOwnPropertySymbols;
+var __hasOwnProp$o = Object.prototype.hasOwnProperty;
+var __propIsEnum$o = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$o = (obj, key, value) => key in obj ? __defProp$o(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$o = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$o.call(b, prop))
+      __defNormalProp$o(a, prop, b[prop]);
+  if (__getOwnPropSymbols$o)
+    for (var prop of __getOwnPropSymbols$o(b)) {
+      if (__propIsEnum$o.call(b, prop))
+        __defNormalProp$o(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$k = (a, b) => __defProps$k(a, __getOwnPropDescs$k(b));
+var __objRest$c = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$o.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$o)
+    for (var prop of __getOwnPropSymbols$o(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$o.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function shoutKeyhandlerLive(liveType, additionalData) {
+  var _a;
+  switch (liveType) {
+    case "howToEndDrag":
+      AriaLiveEmitter.emit("live", {
+        type: "assertive",
+        message: window.ARIA_HOW_TO_END_DRAG
+      });
+      break;
+    case "whichIsTheNewIndex":
+      AriaLiveEmitter.emit("live", {
+        type: "assertive",
+        message: formatMessage(window.ARIA_HOW_TO_WHICH_IS_THE_NEW_POSITION, {
+          TOK1: String((_a = additionalData == null ? void 0 : additionalData.newIndex) != null ? _a : 0)
+        })
+      });
+      break;
+    case "reset":
+      AriaLiveEmitter.emit("live", {
+        type: "reset",
+        message: ""
+      });
+      break;
+    default:
+      AriaLiveEmitter.emit("live", {
+        type: "assertive",
+        message: window.ARIA_HOW_TO_START_DRAG
+      });
+  }
+}
+let scrollTimeout;
+function makeKeyHandler(actions, id, config) {
+  return function KeyHandler(_a) {
+    var _b = _a, {
+      children,
+      onChangeSelection,
+      onSelectRows
+    } = _b, props = __objRest$c(_b, [
+      "children",
+      "onChangeSelection",
+      "onSelectRows"
+    ]);
+    var _a2, _b2;
+    const { run: keyHandler } = useThrottleFn((ev) => {
+      if (!["shift", "alt", "control"].includes(ev.key.toLowerCase())) {
+        responsiveTableStore.dispatch(actions.handleKey({ id, ev }));
+      }
+    }, (_a2 = config == null ? void 0 : config.throttleOptions) != null ? _a2 : { wait: 100 });
+    const [ref, setRef] = React.useState(null);
+    const selectedRows = useResponsiveTable(
+      (global) => {
+        var _a3;
+        const state = config.stateSelector(global);
+        return ((_a3 = state == null ? void 0 : state.selectedRows) != null ? _a3 : []).map((current) => ({
+          index: current,
+          row: state.rows[current]
+        }));
+      },
+      (a, b) => shallowEqual(
+        a.map((current) => current.index),
+        b.map((current) => current.index)
+      )
+    );
+    const selectedRowsRef = useLatest(selectedRows);
+    const focusedRow = useResponsiveTable((global) => {
+      var _a3;
+      const state = config.stateSelector(global);
+      return (_a3 = state == null ? void 0 : state.focusedRow) != null ? _a3 : -1;
+    });
+    const { allowKeyboardSorting, focusedCell, isEditionMode, isFocused } = useResponsiveTable((global) => {
+      const state = config.stateSelector(global);
+      return {
+        focusedCell: (state == null ? void 0 : state.focusedRow) !== void 0 ? `${state == null ? void 0 : state.focusedRow}_${state == null ? void 0 : state.focusedColumn}` : void 0,
+        isEditionMode: state == null ? void 0 : state.isEditionMode,
+        rows: state == null ? void 0 : state.rows,
+        isFocused: state == null ? void 0 : state.isFocused,
+        allowKeyboardSorting: state == null ? void 0 : state.allowRowsKeyboardSorting
+      };
+    }, shallowEqual);
+    useUpdateEffect(() => {
+      if (onChangeSelection)
+        onChangeSelection(selectedRows);
+    }, [onChangeSelection, selectedRows]);
+    const handleClick = React.useCallback(
+      (ev) => {
+        var _a3;
+        if (ev.target.closest(".moreInformationButton"))
+          return;
+        if (ev.shiftKey) {
+          (_a3 = document.getSelection()) == null ? void 0 : _a3.removeAllRanges();
+        }
+        const parentRow = getSpecificParent(
+          ev.target,
+          (current) => {
+            if (current.tagName.toLowerCase() === "table")
+              return null;
+            if (current.matches("tr")) {
+              return true;
+            }
+            return false;
+          }
+        );
+        const parentCell = getSpecificParent(
+          ev.target,
+          (current) => {
+            if (current.tagName.toLowerCase() === "table")
+              return null;
+            if (current.matches("td,th")) {
+              return true;
+            }
+            return false;
+          }
+        );
+        if (parentCell && parentRow) {
+          responsiveTableStore.dispatch(
+            actions.updateByClick({
+              altKey: ev.altKey,
+              id,
+              ctrlKey: ev.ctrlKey,
+              ariaColIndex: Number(parentCell.getAttribute("aria-colindex")),
+              rowIndex: Number(parentRow.getAttribute("data-focusindex")),
+              shiftKey: ev.shiftKey
+            })
+          );
+        }
+      },
+      []
+    );
+    const handleDoubleClick = React.useCallback(
+      (ev) => {
+        if (isChild(
+          ev.target,
+          (current) => current.tagName === "THEAD"
+        ))
+          return;
+        ev.preventDefault();
+        if (onSelectRows)
+          onSelectRows(selectedRowsRef.current, focusedRow);
+      },
+      [focusedRow, onSelectRows, selectedRowsRef]
+    );
+    const initialized = React.useRef(true);
+    const running = React.useRef(false);
+    const doFocusThings = React.useCallback(() => {
+      if (!running.current) {
+        running.current = true;
+        if (focusedCell === void 0) {
+          running.current = false;
+          return () => {
+          };
+        }
+        if (ref) {
+          const disconnectObserver = autoDisconnectMutationObserver(
+            ref,
+            () => {
+              scrollTimeout = setTimeout(() => {
+                var _a3;
+                const focusedElement = ref.querySelector(
+                  '[data-focused="true"]'
+                );
+                let tableCellElement = null;
+                let tableCellWidget = null;
+                if (["td", "th"].includes(
+                  (_a3 = focusedElement == null ? void 0 : focusedElement.tagName.toLowerCase()) != null ? _a3 : ""
+                )) {
+                  tableCellElement = focusedElement;
+                  tableCellWidget = focusedElement == null ? void 0 : focusedElement.querySelector(
+                    getFocusSelector(":not(.debug_info__button)")
+                  );
+                }
+                if ((focusedElement == null ? void 0 : focusedElement.tagName.toLowerCase()) === "tr") {
+                  tableCellElement = focusedElement.querySelector("td,th");
+                  tableCellWidget = focusedElement.querySelector(
+                    getFocusSelector(":not(.debug_info__button)")
+                  ) || tableCellElement;
+                }
+                if (tableCellWidget) {
+                  tableCellElement == null ? void 0 : tableCellElement.setAttribute("tabIndex", "-1");
+                  tableCellWidget.setAttribute("tabIndex", "0");
+                } else
+                  tableCellElement == null ? void 0 : tableCellElement.setAttribute("tabIndex", "0");
+                if (!isEditionMode) {
+                  const allFocusableElements = ref == null ? void 0 : ref.querySelectorAll(
+                    getFocusSelector(
+                      `${cantFocusSelector}:not([data-focused="true"])`
+                    )
+                  );
+                  allFocusableElements == null ? void 0 : allFocusableElements.forEach((current) => {
+                    if (current !== tableCellWidget) {
+                      current.setAttribute("tabIndex", "-1");
+                    }
+                    if ((tableCellWidget == null ? void 0 : tableCellWidget.tagName) === "BUTTON")
+                      tableCellWidget.setAttribute("role", "gridcell");
+                  });
+                } else {
+                  const focusableElements = tableCellElement == null ? void 0 : tableCellElement.querySelectorAll('[tabindex="-1"]');
+                  focusableElements == null ? void 0 : focusableElements.forEach(
+                    (current) => current.setAttribute("tabIndex", "0")
+                  );
+                }
+                const focusElement = tableCellWidget != null ? tableCellWidget : tableCellElement;
+                const row = getSpecificParent(
+                  focusElement,
+                  (current) => current.tagName === "TR"
+                );
+                if (focusElement && initialized.current && config.stateSelector(responsiveTableStore.getState()).isFocused) {
+                  globalFocus.focus = focusElement;
+                  focusElement.focus();
+                }
+                if (row) {
+                  scrollParentIntoElement(row, 55, 2, 100, "makeKeyHandler");
+                }
+                if (!initialized.current) {
+                  initialized.current = true;
+                }
+              }, 0);
+            },
+            { timeout: 5e3 }
+          );
+          running.current = false;
+          return () => {
+            disconnectObserver();
+            clearTimeout(scrollTimeout);
+          };
+        }
+        running.current = false;
+      }
+      return () => {
+      };
+    }, [focusedCell, ref, isEditionMode]);
+    React.useLayoutEffect(doFocusThings, [
+      focusedCell,
+      isFocused,
+      isEditionMode
+    ]);
+    React.useEffect(() => {
+      function handleFocus(ev) {
+        const targetTable = getSpecificParent(
+          ev.target,
+          (current) => current.tagName.toLowerCase() === "table"
+        );
+        const relatedTargetTable = getSpecificParent(
+          ev.relatedTarget,
+          (current) => current.tagName.toLowerCase() === "table"
+        );
+        if (!relatedTargetTable || relatedTargetTable !== targetTable)
+          handleClick(ev);
+      }
+      ref == null ? void 0 : ref.addEventListener("dblclick", handleDoubleClick);
+      ref == null ? void 0 : ref.addEventListener("mousedown", handleClick);
+      ref == null ? void 0 : ref.addEventListener("focusin", handleFocus);
+      ref == null ? void 0 : ref.addEventListener(customEvents.focus, handleClick);
+      return () => {
+        ref == null ? void 0 : ref.removeEventListener("mousedown", handleClick);
+        ref == null ? void 0 : ref.removeEventListener("dblclick", handleDoubleClick);
+        ref == null ? void 0 : ref.removeEventListener("focusin", handleFocus);
+        ref == null ? void 0 : ref.removeEventListener(customEvents.focus, handleClick);
+      };
+    }, [ref]);
+    const isDragging = React.useRef(false);
+    const isFocusedRef = React.useRef(false);
+    return /* @__PURE__ */ jsx(
+      Box,
+      __spreadProps$k(__spreadValues$o({
+        ref: setRef
+      }, props), {
+        className: `selection__keyHandler ${(_b2 = props.className) != null ? _b2 : ""}`,
+        onBlur: React.useCallback(
+          (ev) => {
+            if (!ev.relatedTarget || !getSpecificParent(
+              ev.relatedTarget,
+              (current) => current === ref
+            )) {
+              responsiveTableStore.dispatch(
+                actions.selectionStateUpdate({ id, isFocused: false })
+              );
+              shoutKeyhandlerLive("reset");
+              isFocusedRef.current = false;
+            }
+          },
+          [ref]
+        ),
+        onFocus: React.useCallback(() => {
+          if (!isFocusedRef.current)
+            shoutKeyhandlerLive("howToStartDrag");
+          isFocusedRef.current = true;
+        }, []),
+        sx: React.useMemo(
+          () => ({ overflow: "auto", position: "relative" }),
+          []
+        ),
+        onKeyDown: React.useCallback(
+          (ev) => {
+            var _a3;
+            const state = config.stateSelector(responsiveTableStore.getState());
+            if (willHandleKey(
+              ev,
+              config.stateSelector(responsiveTableStore.getState())
+            )) {
+              ev.preventDefault();
+              ev.stopPropagation();
+            }
+            if (actions.swapFocusedRow && isDragging.current && allowKeyboardSorting) {
+              if ((ev.key === "Enter" || ev.key === "Escape") && isDragging.current) {
+                shoutKeyhandlerLive("howToStartDrag");
+                isDragging.current = false;
+                responsiveTableStore.dispatch(
+                  actions.swapFocusedRow({
+                    tableName: id,
+                    newIndex: state.focusedRow
+                  })
+                );
+              } else if (["ArrowDown", "ArrowUp"].includes(ev.key)) {
+                if (ev.key === "ArrowDown") {
+                  responsiveTableStore.dispatch(
+                    actions.swapFocusedRow({
+                      tableName: id,
+                      newIndex: state.focusedRow + 1
+                    })
+                  );
+                } else {
+                  responsiveTableStore.dispatch(
+                    actions.swapFocusedRow({
+                      tableName: id,
+                      newIndex: state.focusedRow - 1
+                    })
+                  );
+                }
+              }
+            } else if (ev.key === "m" && ev.ctrlKey && !isDragging.current && state.focusedRow >= 0 && actions.swapFocusedRow) {
+              isDragging.current = true;
+              shoutKeyhandlerLive("howToEndDrag");
+              responsiveTableStore.dispatch(
+                actions.swapFocusedRow({
+                  tableName: id,
+                  newIndex: state.focusedRow
+                })
+              );
+            } else {
+              const currentSelectedRows = ((_a3 = state == null ? void 0 : state.selectedRows) != null ? _a3 : []).map((current) => ({
+                index: current,
+                row: state.rows[current]
+              }));
+              if (props.onKeyDown)
+                props.onKeyDown(ev);
+              if (ev.key === "Enter" && onSelectRows && state.focusedRow >= 0) {
+                onSelectRows(currentSelectedRows, focusedRow);
+              }
+              keyHandler(ev);
+            }
+          },
+          [allowKeyboardSorting, focusedRow, keyHandler, onSelectRows, props]
+        ),
+        children
+      })
+    );
+  };
+}
+
+var __defProp$n = Object.defineProperty;
+var __defProps$j = Object.defineProperties;
+var __getOwnPropDescs$j = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$n = Object.getOwnPropertySymbols;
+var __hasOwnProp$n = Object.prototype.hasOwnProperty;
+var __propIsEnum$n = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$n = (obj, key, value) => key in obj ? __defProp$n(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$n = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$n.call(b, prop))
+      __defNormalProp$n(a, prop, b[prop]);
+  if (__getOwnPropSymbols$n)
+    for (var prop of __getOwnPropSymbols$n(b)) {
+      if (__propIsEnum$n.call(b, prop))
+        __defNormalProp$n(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$j = (a, b) => __defProps$j(a, __getOwnPropDescs$j(b));
+var __objRest$b = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$n.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$n)
+    for (var prop of __getOwnPropSymbols$n(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$n.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function getReduxActions() {
+  return {
+    handleKey(state, { payload }) {
+      handleKey(state[payload.id], payload);
+    },
+    selectionStateUpdate(state, _a) {
+      var { payload: _b } = _a, _c = _b, { id } = _c, payload = __objRest$b(_c, ["id"]);
+      state[id] = __spreadValues$n(__spreadValues$n({}, state[id]), payload);
+    },
+    setNewFocused(state, _d) {
+      var { payload: _e } = _d, _f = _e, { id } = _f, payload = __objRest$b(_f, ["id"]);
+      setNewFocused(state[id], payload);
+    },
+    updateByClick(state, _g) {
+      var {
+        payload: _h
+      } = _g, _i = _h, {
+        id,
+        colIndex,
+        rowIndex,
+        ariaColIndex,
+        ariaRowIndex,
+        isFocused
+      } = _i, payload = __objRest$b(_i, [
+        "id",
+        "colIndex",
+        "rowIndex",
+        "ariaColIndex",
+        "ariaRowIndex",
+        "isFocused"
+      ]);
+      var _a;
+      const hasFiltersRow = state[id].hasNonAdditionalFilters;
+      state[id].isEditionMode = false;
+      const newFocusedColumn = (_a = colIndex != null ? colIndex : ariaColIndex) != null ? _a : 1;
+      const newFocusedRow = ariaRowIndex !== void 0 ? ariaRowIndex : (rowIndex != null ? rowIndex : 0) - (1 + (hasFiltersRow ? 2 : 1));
+      setNewFocused(state[id], __spreadProps$j(__spreadValues$n({}, payload), {
+        newFocusedColumn,
+        newFocusedRow
+      }));
+      if (isFocused !== void 0)
+        state[id].isFocused = isFocused;
+    }
+  };
+}
+
+var __defProp$m = Object.defineProperty;
+var __defProps$i = Object.defineProperties;
+var __getOwnPropDescs$i = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$m = Object.getOwnPropertySymbols;
+var __hasOwnProp$m = Object.prototype.hasOwnProperty;
+var __propIsEnum$m = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$m = (obj, key, value) => key in obj ? __defProp$m(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$m = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$m.call(b, prop))
+      __defNormalProp$m(a, prop, b[prop]);
+  if (__getOwnPropSymbols$m)
+    for (var prop of __getOwnPropSymbols$m(b)) {
+      if (__propIsEnum$m.call(b, prop))
+        __defNormalProp$m(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$i = (a, b) => __defProps$i(a, __getOwnPropDescs$i(b));
+var __objRest$a = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$m.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$m)
+    for (var prop of __getOwnPropSymbols$m(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$m.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function getInitialState() {
+  const newState = __spreadProps$i(__spreadValues$m({}, getInitialState$1()), {
+    allowSelection: true,
+    allowSorting: true,
+    filters: [],
+    isLoading: false,
+    isMultiple: true,
+    accordionIndexColumns: {},
+    expandedRows: []
+  });
+  return newState;
+}
+const responsiveTableSlice = createSlice({
+  name: "responsiveTableSlice",
+  initialState: {},
+  reducers: __spreadValues$m({
+    update(state, _a) {
+      var {
+        payload: _b
+      } = _a, _c = _b, { tableName } = _c, rest = __objRest$a(_c, ["tableName"]);
+      var _a2, _b2, _c2, _d, _e, _f;
+      if (!state[tableName])
+        state[tableName] = getInitialState();
+      state[tableName] = __spreadValues$m(__spreadValues$m({}, state[tableName]), rest);
+      setNewFocused(state[tableName], {
+        altKey: false,
+        ctrlKey: false,
+        shiftKey: false,
+        shouldSelectNewFocused: (_a2 = rest.isFocused) != null ? _a2 : state[tableName].isFocused
+      });
+      if (rest.columns) {
+        state[tableName].nonAdditionalColumnsCount = rest.columns.filter(
+          (current) => !current.showAsAdditional
+        ).length;
+      }
+      if (rest.rows) {
+        state[tableName].statesColumns = Math.max(
+          (_c2 = (_b2 = state[tableName]) == null ? void 0 : _b2.reserveColumnsForStates) != null ? _c2 : 0,
+          ...(_f = (_e = (_d = state[tableName]) == null ? void 0 : _d.rows) == null ? void 0 : _e.map(
+            (current) => {
+              var _a3, _b3;
+              return (_b3 = (_a3 = current.states) == null ? void 0 : _a3.length) != null ? _b3 : 0;
+            }
+          )) != null ? _f : [0]
+        );
+      }
+      if (rest.filters) {
+        state[tableName].hasNonAdditionalFilters = rest.filters.filter(
+          (current) => {
+            var _a3, _b3;
+            return !current.asAdditional && ((_b3 = (_a3 = rest.columns) != null ? _a3 : state[tableName].columns) == null ? void 0 : _b3.find(
+              (search) => search.name === current.column
+            ));
+          }
+        ).length > 0;
+      }
+    },
+    addRows(state, { payload }) {
+      if (!state[payload.tableName])
+        state[payload.tableName] = getInitialState();
+      state[payload.tableName].rows = state[payload.tableName].rows.concat(
+        ...payload.newRows
+      );
+      setNewFocused(state[payload.tableName], {
+        altKey: false,
+        ctrlKey: false,
+        shiftKey: false,
+        shouldSelectNewFocused: true,
+        newFocusedRow: state[payload.tableName].rows.length
+      });
+    },
+    deleteRows(state, { payload }) {
+      const table = state[payload.tableName];
+      const minIndex = payload.rowIndices.reduce((min, current) => {
+        return current < min ? current : min;
+      }, Infinity);
+      table.rows = table.rows.filter(
+        (_, index) => !payload.rowIndices.includes(index)
+      );
+      setNewFocused(state[payload.tableName], {
+        altKey: false,
+        ctrlKey: false,
+        shiftKey: false,
+        shouldSelectNewFocused: true,
+        newFocusedRow: minIndex
+      });
+      state[payload.tableName].isFocused = false;
+    },
+    destroy(state, { payload: { tableName } }) {
+      delete state[tableName];
+    },
+    swapFocusedRow(state, {
+      payload: { newIndex, tableName }
+    }) {
+      const tableState = state[tableName];
+      const focusedIndex = tableState.focusedRow;
+      if (focusedIndex === void 0 || newIndex < 0 || newIndex >= tableState.rows.length)
+        return;
+      if (focusedIndex === newIndex) {
+        if (tableState.draggingRow === newIndex)
+          tableState.draggingRow = void 0;
+        else
+          tableState.draggingRow = newIndex;
+        return;
+      }
+      shoutKeyhandlerLive("whichIsTheNewIndex", { newIndex });
+      const isSelected = tableState.selectedRows.includes(focusedIndex);
+      if (isSelected) {
+        tableState.selectedRows = [
+          ...tableState.selectedRows.filter(
+            (current) => current !== focusedIndex
+          ),
+          newIndex
+        ];
+      }
+      const aux = tableState.rows[newIndex];
+      tableState.rows[newIndex] = tableState.rows[focusedIndex];
+      tableState.rows[focusedIndex] = aux;
+      tableState.focusedRow = newIndex;
+      tableState.draggingRow = newIndex;
+    }
+  }, getReduxActions())
+});
+const { store: responsiveTableStore, useSelector: useResponsiveTable } = injectReducers({
+  responsiveTableSlice: responsiveTableSlice.reducer
+});
+const responsiveTableActions = responsiveTableSlice.actions;
+
+var __defProp$l = Object.defineProperty;
+var __defProps$h = Object.defineProperties;
+var __getOwnPropDescs$h = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$l = Object.getOwnPropertySymbols;
+var __hasOwnProp$l = Object.prototype.hasOwnProperty;
+var __propIsEnum$l = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$l = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$l.call(b, prop))
+      __defNormalProp$l(a, prop, b[prop]);
+  if (__getOwnPropSymbols$l)
+    for (var prop of __getOwnPropSymbols$l(b)) {
+      if (__propIsEnum$l.call(b, prop))
+        __defNormalProp$l(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$h = (a, b) => __defProps$h(a, __getOwnPropDescs$h(b));
+const ResponsiveTableReactContext = React.createContext({});
+function useResponsiveTableContext() {
+  const context = React.useContext(ResponsiveTableReactContext);
+  if (!context)
+    throw new Error("There is no ResponsiveTableContext");
+  return context;
+}
+const NoMemoResponsiveTableContext = ({
+  allowEdition,
+  allowRowsKeyboardSorting,
+  allowSelection,
+  allowSorting,
+  avoidReparseSelectionOnRowChange,
+  children = /* @__PURE__ */ jsx(ResponsiveTable, {}),
+  className,
+  currentBreakPoint,
+  customLabels,
+  columns,
+  filters,
+  rows,
+  label,
+  isMultiple,
+  name,
+  onChangeSelection,
+  onFilterBlur,
+  onFilterChange,
+  onFilterPressEnter,
+  onSelectRows,
+  onSortChange,
+  reserveColumnsForStates,
+  variant
+}) => {
+  const actualName = React.useMemo(
+    () => name != null ? name : uniqueId("responsiveTable"),
+    [name]
+  );
+  const labels = React.useMemo(
+    () => __spreadValues$l(__spreadValues$l({}, defaultLabels), customLabels),
+    [customLabels]
+  );
+  const contextValue = React.useMemo(
+    () => ({
+      currentBreakPoint,
+      label,
+      labels,
+      name: actualName,
+      onChangeSelection,
+      onFilterBlur,
+      onFilterChange,
+      onFilterPressEnter,
+      onSelectRows,
+      onSortChange
+    }),
+    [
+      actualName,
+      currentBreakPoint,
+      label,
+      labels,
+      onChangeSelection,
+      onFilterBlur,
+      onFilterChange,
+      onFilterPressEnter,
+      onSelectRows,
+      onSortChange
+    ]
+  );
+  useMount(() => {
+    responsiveTableStore.dispatch(
+      responsiveTableActions.update({
+        allowEdition,
+        allowRowsKeyboardSorting,
+        allowSelection,
+        allowSorting,
+        columns,
+        filters: filters != null ? filters : [],
+        rows,
+        isMultiple,
+        tableName: actualName,
+        reserveColumnsForStates
+      })
+    );
+  });
+  useUpdateEffect$1(() => {
+    responsiveTableStore.dispatch(
+      responsiveTableActions.update({
+        tableName: actualName,
+        columns
+      })
+    );
+  }, [columns]);
+  useUpdateEffect$1(() => {
+    responsiveTableStore.dispatch(
+      responsiveTableActions.update({
+        tableName: actualName,
+        rows
+      })
+    );
+    if (avoidReparseSelectionOnRowChange !== true) {
+      const selected = rows.map((current, i) => __spreadProps$h(__spreadValues$l({}, current), { i })).filter((current) => current.initiallySelected);
+      responsiveTableStore.dispatch(
+        responsiveTableActions.update({
+          tableName: actualName,
+          selectedRows: selected.map((current) => current.i)
+        })
+      );
+    }
+  }, [rows]);
+  useUpdateEffect$1(() => {
+    responsiveTableStore.dispatch(
+      responsiveTableActions.update({
+        tableName: actualName,
+        filters
+      })
+    );
+  }, [filters]);
+  useUnmount(() => {
+  });
+  return /* @__PURE__ */ jsx(ResponsiveTableReactContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+    Box,
+    __spreadProps$h(__spreadValues$l({
+      id: name,
+      className: `responsiveTableContext__wrapper ${className != null ? className : ""}`
+    }, variant ? getVariant(variant) : null), {
+      children
+    })
+  ) });
+};
+const ResponsiveTableContext = React.memo(NoMemoResponsiveTableContext);
+
+var __defProp$k = Object.defineProperty;
+var __getOwnPropSymbols$k = Object.getOwnPropertySymbols;
+var __hasOwnProp$k = Object.prototype.hasOwnProperty;
+var __propIsEnum$k = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$k = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$k.call(b, prop))
+      __defNormalProp$k(a, prop, b[prop]);
+  if (__getOwnPropSymbols$k)
+    for (var prop of __getOwnPropSymbols$k(b)) {
+      if (__propIsEnum$k.call(b, prop))
+        __defNormalProp$k(a, prop, b[prop]);
+    }
+  return a;
+};
+const NoMemoKeyHandler = (props) => {
+  const { name, onChangeSelection, onSelectRows } = useResponsiveTableContext();
+  const Handler = React.useMemo(
+    () => makeKeyHandler(responsiveTableActions, name, {
+      throttleOptions: { wait: 50 },
+      stateSelector: (global) => global.responsiveTableSlice[name]
+    }),
+    [name]
+  );
+  return /* @__PURE__ */ jsx(
+    Handler,
+    __spreadValues$k({
+      onChangeSelection,
+      onSelectRows
+    }, props)
+  );
+};
+const KeyHandler = React.memo(NoMemoKeyHandler);
+
+function useDomProps(element, elementProps, stateSelector) {
+  const state = useResponsiveTable((globalState) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const tableState = stateSelector(globalState);
+    const hasNonAdditionalFilters = tableState == null ? void 0 : tableState.hasNonAdditionalFilters;
+    const startDataRowIndex = hasNonAdditionalFilters ? 2 : 1;
+    const statesColumns = (_a = tableState == null ? void 0 : tableState.statesColumns) != null ? _a : 0;
+    let expandedBeforeThisRow = 0;
+    if (element === "tr")
+      expandedBeforeThisRow = tableState == null ? void 0 : tableState.expandedRows.filter(
+        (current) => current < elementProps.rowIndex
+      ).length;
+    let isFocused = false;
+    let isSelected = false;
+    switch (element) {
+      case "filterTd": {
+        const castedProps = elementProps;
+        isFocused = (tableState == null ? void 0 : tableState.focusedRow) === 1 - startDataRowIndex && addBoundary((_b = tableState == null ? void 0 : tableState.focusedColumn) != null ? _b : 0, 0) - statesColumns === castedProps.columnIndex + 1 + (hasNonAdditionalFilters ? 1 : 0);
+        break;
+      }
+      case "tr": {
+        const castedProps = elementProps;
+        isFocused = !tableState ? false : tableState.focusedRow === castedProps.rowIndex && (tableState == null ? void 0 : tableState.focusedColumn) === 0 || Math.floor(tableState == null ? void 0 : tableState.focusedRow) === castedProps.rowIndex && Math.round(tableState == null ? void 0 : tableState.focusedRow) - tableState.focusedRow !== 0 && !!castedProps.isTheExpandedRow;
+        isSelected = !castedProps.isTheExpandedRow && (tableState == null ? void 0 : tableState.selectedRows.includes(castedProps.rowIndex));
+        break;
+      }
+      case "stateCell": {
+        const castedProps = elementProps;
+        isFocused = (tableState == null ? void 0 : tableState.focusedRow) === castedProps.rowIndex && ((_c = tableState == null ? void 0 : tableState.focusedColumn) != null ? _c : 0) === castedProps.columnIndex + 1 + (hasNonAdditionalFilters ? 1 : 0);
+        break;
+      }
+      case "additionalTd": {
+        const castedProps = elementProps;
+        isFocused = (tableState == null ? void 0 : tableState.focusedRow) === castedProps.rowIndex && ((_d = tableState == null ? void 0 : tableState.focusedColumn) != null ? _d : 0) === 1;
+        break;
+      }
+      case "td": {
+        const castedProps = elementProps;
+        isFocused = (tableState == null ? void 0 : tableState.focusedRow) === castedProps.rowIndex && ((_e = tableState == null ? void 0 : tableState.focusedColumn) != null ? _e : 0) - statesColumns === castedProps.columnIndex + 1 + (hasNonAdditionalFilters ? 1 : 0);
+        break;
+      }
+      case "headerStateCell": {
+        const castedProps = elementProps;
+        isFocused = (tableState == null ? void 0 : tableState.focusedRow) === castedProps.rowIndex - 1 - startDataRowIndex && addBoundary(tableState == null ? void 0 : tableState.focusedColumn, 0) === castedProps.columnIndex + 1 + (hasNonAdditionalFilters ? 1 : 0);
+        break;
+      }
+      case "th": {
+        const castedProps = elementProps;
+        isFocused = (tableState == null ? void 0 : tableState.focusedRow) === 0 - startDataRowIndex && addBoundary(((_f = tableState == null ? void 0 : tableState.focusedColumn) != null ? _f : 0) - statesColumns, 0) === castedProps.columnIndex + 1 + (hasNonAdditionalFilters ? 1 : 0);
+        break;
+      }
+      case "separator": {
+        const castedProps = elementProps;
+        isFocused = !tableState ? false : tableState.focusedRow === castedProps.rowIndex;
+        break;
+      }
+    }
+    return {
+      columns: (_g = tableState == null ? void 0 : tableState.columns) != null ? _g : [],
+      expandedBeforeThisRow,
+      isEditionMode: tableState == null ? void 0 : tableState.isEditionMode,
+      hasNonAdditionalFilters,
+      rowsLength: element === "table" ? tableState == null ? void 0 : tableState.rows.length : "",
+      isSelected,
+      isFocused,
+      startDataRowIndex,
+      statesColumns: tableState == null ? void 0 : tableState.statesColumns
+    };
+  }, shallowEqual);
+  let returnObject = React.useMemo(() => ({}), []);
+  switch (element) {
+    case "filterTd": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-colindex": castedProps.columnIndex + 1 + state.statesColumns + (state.hasNonAdditionalFilters ? 1 : 0),
+        "data-editionmode": state.isEditionMode && state.isFocused,
+        "data-focused": state.isFocused,
+        tabIndex: state.isFocused ? 0 : -1,
+        "data-rowindex": 2
+      };
+      break;
+    }
+    case "separator": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-rowindex": castedProps.rowIndex + state.startDataRowIndex + 1 + state.expandedBeforeThisRow,
+        "data-focusindex": castedProps.rowIndex + state.startDataRowIndex + 1,
+        "aria-selected": state.isSelected,
+        "data-focused": state.isFocused,
+        "aria-expanded": false
+      };
+      break;
+    }
+    case "table": {
+      returnObject = {
+        role: "treegrid",
+        "aria-colcount": state.columns.length,
+        "aria-rowcount": state.rowsLength
+      };
+      break;
+    }
+    case "tr": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-rowindex": castedProps.rowIndex + state.startDataRowIndex + 1 + state.expandedBeforeThisRow + (castedProps.isTheExpandedRow ? 1 : 0),
+        "data-focusindex": castedProps.rowIndex + state.startDataRowIndex + 1 + (castedProps.isTheExpandedRow ? 0.5 : 0),
+        "aria-selected": state.isSelected,
+        "data-focused": state.isFocused,
+        "aria-expanded": castedProps.isThisRowExpanded,
+        tabIndex: state.isFocused ? 0 : -1
+      };
+      break;
+    }
+    case "td": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-colindex": castedProps.columnIndex + 1 + state.statesColumns + (state.hasNonAdditionalFilters ? 1 : 0),
+        "data-editionmode": state.isEditionMode && state.isFocused,
+        "data-focused": state.isFocused,
+        tabIndex: state.isFocused ? 0 : -1,
+        "data-rowindex": castedProps.rowIndex + state.startDataRowIndex + 1
+      };
+      break;
+    }
+    case "additionalTd": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-colindex": 1,
+        "data-editionmode": state.isEditionMode && state.isFocused,
+        "data-focused": state.isFocused,
+        tabIndex: state.isFocused ? 0 : -1,
+        "data-rowindex": castedProps.rowIndex + state.startDataRowIndex + 1
+      };
+      break;
+    }
+    case "stateCell": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-colindex": castedProps.columnIndex + 1 + (state.hasNonAdditionalFilters ? 1 : 0),
+        "data-editionmode": state.isEditionMode && state.isFocused,
+        "data-focused": state.isFocused,
+        tabIndex: state.isFocused ? 0 : -1,
+        "data-rowindex": castedProps.rowIndex + state.startDataRowIndex + 1
+      };
+      break;
+    }
+    case "headerStateCell": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-colindex": castedProps.columnIndex + 1 + (state.hasNonAdditionalFilters ? 1 : 0),
+        "aria-sort": "none",
+        "data-editionmode": state.isEditionMode && state.isFocused,
+        "data-focused": state.isFocused,
+        tabIndex: state.isFocused ? 0 : -1,
+        "data-rowindex": castedProps.rowIndex
+      };
+      break;
+    }
+    case "th": {
+      const castedProps = elementProps;
+      returnObject = {
+        "aria-colindex": castedProps.columnIndex + 1 + state.statesColumns + (state.hasNonAdditionalFilters ? 1 : 0),
+        "aria-sort": ["ascending", "descending", "none"][["Asc", "Desc", null].findIndex(
+          (current) => current === state.columns[castedProps.columnIndex].currentSorting
+        )],
+        "data-editionmode": state.isEditionMode && state.isFocused,
+        "data-focused": state.isFocused,
+        tabIndex: state.isFocused ? 0 : -1,
+        "data-rowindex": 1
+      };
+      break;
+    }
+  }
+  return React.useMemo(() => returnObject, Object.values(returnObject));
+}
+
+var __defProp$j = Object.defineProperty;
+var __defProps$g = Object.defineProperties;
+var __getOwnPropDescs$g = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$j = Object.getOwnPropertySymbols;
+var __hasOwnProp$j = Object.prototype.hasOwnProperty;
+var __propIsEnum$j = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$j = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$j.call(b, prop))
+      __defNormalProp$j(a, prop, b[prop]);
+  if (__getOwnPropSymbols$j)
+    for (var prop of __getOwnPropSymbols$j(b)) {
+      if (__propIsEnum$j.call(b, prop))
+        __defNormalProp$j(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
+const widthStorageName = "tablesWidths";
+function getColumnWidth(width) {
+  if (typeof width === "string") {
+    if (width.match(/(%|px|vw|vh|vmin|vmax|cm|mm|in|pt|pc)/))
+      return width;
+    return Number.parseInt(width, 10);
+  }
+  if (typeof width === "number")
+    return width;
+  return width;
+}
+debugDispatcher.on(
+  "cleanTableSizes",
+  ([tableName]) => {
+    const currentWidths = persistentStorage[widthStorageName];
+    delete currentWidths[tableName];
+    persistentStorage[widthStorageName] = currentWidths;
+  },
+  'Se usa para borrar el estado de una tabla. Uso: dd.cleanTableSizes("TableName")'
+);
+function makeColumnName(tableName, columnName) {
+  return `${tableName}${columnName}`;
+}
+const thWidthEmitter = new class ThWidthEmitter extends EventEmitter {
+}();
+const NoMemoHeaderCell = ({
+  apiaColumnIndex,
+  columnIndex,
+  inTableColumnIndex
+}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const { name, onSortChange } = useResponsiveTableContext();
+  const uniqueId = (_d = (_c = (_a = window.location.href.match(/busEntId=(\d+)/)) == null ? void 0 : _a[1]) != null ? _c : (_b = window.location.href.match(/query=(\d+)/)) == null ? void 0 : _b[1]) != null ? _d : "";
+  const isGlobal = window.isGlobal ? "isGlobal" : "notGlobal";
+  const actualName = name + uniqueId + String(isGlobal);
+  const column = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    return tableState == null ? void 0 : tableState.columns[columnIndex];
+  }, shallowEqual);
+  const storedWidth = (_f = (_e = persistentStorage[widthStorageName]) == null ? void 0 : _e[actualName]) == null ? void 0 : _f[column.name];
+  const [width, setWidth] = React.useState(storedWidth != null ? storedWidth : 200);
+  const [isResize, setIsResize] = React.useState(storedWidth !== void 0);
+  React.useEffect(() => {
+    return void thWidthEmitter.on("resize", (ev) => {
+      if (ev.name === makeColumnName(actualName, column.name)) {
+        setIsResize(true);
+        setWidth(ev.width);
+      }
+    });
+  }, [column.name, actualName]);
+  const isFilterRequired = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    const columnFilter = tableState == null ? void 0 : tableState.filters.find(
+      (current) => current.column === column.title
+    );
+    return columnFilter == null ? void 0 : columnFilter.required;
+  }, shallowEqual);
+  const isSortingAllowed = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    return tableState == null ? void 0 : tableState.allowSorting;
+  });
+  const domProps = useDomProps(
+    "th",
+    {
+      columnIndex: inTableColumnIndex
+    },
+    domPropsSelector(name)
+  );
+  const sx = React.useMemo(
+    () => {
+      var _a2;
+      return !isResize ? {
+        minWidth: getColumnWidth((_a2 = column.minWidth) != null ? _a2 : column.width),
+        maxWidth: column.maxWidth !== void 0 ? getColumnWidth(column.maxWidth) : void 0,
+        width: getColumnWidth(column.width),
+        position: "relative"
+      } : {
+        width: `${width}px`,
+        minWidth: `${width}px`,
+        position: "relative"
+      };
+    },
+    [column.maxWidth, column.minWidth, column.width, isResize, width]
+  );
+  const buttonProps = useOtherTagButton(
+    React.useMemo(
+      () => ({
+        className: "headButton",
+        onClick: (ev) => {
+          if (isChild(
+            ev.target,
+            (current) => current.classList.contains("headButton__resizer")
+          ))
+            return;
+          console.warn("Buttons slice is not defined");
+          if (onSortChange && column.allowSorting !== false && isSortingAllowed !== false)
+            onSortChange({
+              column,
+              columnIndex: apiaColumnIndex,
+              name: column.name,
+              sortValue: ["Asc", "Desc"][column.currentSorting !== "A" ? 0 : 1]
+            });
+        }
+      }),
+      [apiaColumnIndex, column, isSortingAllowed, onSortChange]
+    )
+  );
+  return /* @__PURE__ */ jsx(
+    Box,
+    __spreadProps$g(__spreadValues$j(__spreadValues$j({
+      as: "th",
+      style: sx,
+      "data-columnname": column.name,
+      title: (_h = (_g = column.title) != null ? _g : column.label) != null ? _h : column.name
+    }, buttonProps), domProps), {
+      role: "rowheader",
+      className: `${isFilterRequired && window.SHOW_REQUIRED_POSITION ? "requiredFilterColumn" : ""}`,
+      children: /* @__PURE__ */ jsxs(Box, { as: "span", className: "headButton__container", children: [
+        /* @__PURE__ */ jsx(Box, { as: "span", className: "headButton__label", children: /* @__PURE__ */ jsx(
+          Box,
+          {
+            as: "span",
+            className: `${isFilterRequired ? "requiredFilter__Column" : ""}`,
+            children: column.label
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(Box, { as: "span", className: "headButton__sortIcon", children: [
+          column.allowSorting !== false && column.currentSorting === "A" && /* @__PURE__ */ jsx(FaSortUp, {}),
+          column.allowSorting !== false && column.currentSorting === "D" && /* @__PURE__ */ jsx(FaSortDown, {}),
+          column.allowSorting !== false && !column.currentSorting && /* @__PURE__ */ jsx(FaSort, {})
+        ] }),
+        /* @__PURE__ */ jsx(
+          Box,
+          {
+            className: "headButton__resizer",
+            onMouseDown: (ev) => {
+              if (!isResize) {
+                const trElement = getSpecificParent(
+                  ev.target,
+                  (current) => current.tagName === "TR"
+                );
+                trElement == null ? void 0 : trElement.querySelectorAll("th").forEach((current) => {
+                  thWidthEmitter.emit("resize", {
+                    name: makeColumnName(
+                      actualName,
+                      current.dataset.columnname
+                    ),
+                    width: current.clientWidth
+                  });
+                });
+                setIsResize(true);
+              }
+              const th = getSpecificParent(
+                ev.target,
+                (current) => current.tagName === "TH"
+              );
+              if (!th)
+                throw new Error("There is no th");
+              const initialX = ev.clientX;
+              const initialWidth = th.clientWidth;
+              const resize = (mousemoveEv) => {
+                const dif = mousemoveEv.clientX - initialX;
+                setWidth(initialWidth + dif);
+              };
+              const unsuscribe = () => {
+                const trElement = getSpecificParent(
+                  ev.target,
+                  (current) => current.tagName === "TR"
+                );
+                trElement == null ? void 0 : trElement.querySelectorAll("th").forEach((current) => {
+                  var _a2;
+                  persistentStorage[widthStorageName] = __spreadProps$g(__spreadValues$j({}, persistentStorage[widthStorageName]), {
+                    [actualName]: __spreadProps$g(__spreadValues$j({}, (_a2 = persistentStorage[widthStorageName]) == null ? void 0 : _a2[actualName]), {
+                      [current.dataset.columnname]: current.clientWidth
+                    })
+                  });
+                });
+                document.removeEventListener("mousemove", resize);
+                document.removeEventListener("mouseup", unsuscribe);
+              };
+              document.addEventListener("mousemove", resize);
+              document.addEventListener("mouseup", unsuscribe);
+              return false;
+            }
+          }
+        )
+      ] })
+    })
+  );
+};
+const HeaderCell = React.memo(NoMemoHeaderCell);
+
+var __defProp$i = Object.defineProperty;
+var __defProps$f = Object.defineProperties;
+var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$i = Object.getOwnPropertySymbols;
+var __hasOwnProp$i = Object.prototype.hasOwnProperty;
+var __propIsEnum$i = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$i = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$i.call(b, prop))
+      __defNormalProp$i(a, prop, b[prop]);
+  if (__getOwnPropSymbols$i)
+    for (var prop of __getOwnPropSymbols$i(b)) {
+      if (__propIsEnum$i.call(b, prop))
+        __defNormalProp$i(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
+const NoMemoRowStatesRenderer = ({
+  state
+}) => {
+  var _a;
+  const { Icon } = state;
+  return /* @__PURE__ */ jsx(
+    Button,
+    __spreadProps$f(__spreadValues$i({}, getVariant("inherit")), {
+      title: state.tooltip,
+      className: `${(_a = state.className) != null ? _a : "state"}_icon state_icon`,
+      sx: React.useMemo(
+        () => {
+          var _a2;
+          return {
+            "svg, path": {
+              color: (_a2 = state.color) != null ? _a2 : ""
+            }
+          };
+        },
+        [state.color]
+      ),
+      children: /* @__PURE__ */ jsx(Icon, {})
+    })
+  );
+};
+const RowStatesRenderer = React.memo(NoMemoRowStatesRenderer);
+
+var __defProp$h = Object.defineProperty;
+var __defProps$e = Object.defineProperties;
+var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$h = Object.getOwnPropertySymbols;
+var __hasOwnProp$h = Object.prototype.hasOwnProperty;
+var __propIsEnum$h = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$h = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$h.call(b, prop))
+      __defNormalProp$h(a, prop, b[prop]);
+  if (__getOwnPropSymbols$h)
+    for (var prop of __getOwnPropSymbols$h(b)) {
+      if (__propIsEnum$h.call(b, prop))
+        __defNormalProp$h(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
+const StateCell = ({ index, rowIndex, state, isHeader }) => {
+  const { name } = useResponsiveTableContext();
+  const domProps = useDomProps(
+    isHeader ? "headerStateCell" : "stateCell",
+    { columnIndex: index, rowIndex },
+    domPropsSelector(name)
+  );
+  return /* @__PURE__ */ jsx(Box, __spreadProps$e(__spreadValues$h({ as: "td", className: "stateCell" }, domProps), { children: state ? /* @__PURE__ */ jsx(RowStatesRenderer, { state }) : "" }));
+};
+
+var __defProp$g = Object.defineProperty;
+var __defProps$d = Object.defineProperties;
+var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$g = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$g.call(b, prop))
+      __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b)) {
+      if (__propIsEnum$g.call(b, prop))
+        __defNormalProp$g(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+const NoMemoRangeFilter = ({ filter }) => {
+  var _a, _b;
+  const { onFilterBlur, onFilterChange, onFilterPressEnter } = useResponsiveTableContext();
+  const filterLow = {
+    id: filter.id,
+    currentValue: filter.currentValue,
+    type: "number"
+  };
+  const filterHigh = {
+    id: (_a = filter.filterToId) != null ? _a : "",
+    currentValue: (_b = filter.filterToValue) != null ? _b : "",
+    type: "number"
+  };
+  return /* @__PURE__ */ jsxs(Box, { className: "ApiaFilter__Range", children: [
+    /* @__PURE__ */ jsx(Box, { className: "ApiaFilter__Range__Low", children: /* @__PURE__ */ jsx(
+      ApiaFilter,
+      {
+        filter: filterLow,
+        onChange: (currentValue) => {
+          if (onFilterChange)
+            void onFilterChange(__spreadProps$d(__spreadValues$g({}, filterLow), { currentValue }));
+        },
+        onBlur: (currentValue) => {
+          if (onFilterBlur)
+            void onFilterBlur(__spreadProps$d(__spreadValues$g({}, filterLow), { currentValue }));
+        },
+        onPressEnter: (currentValue) => {
+          if (onFilterPressEnter)
+            void onFilterPressEnter(__spreadProps$d(__spreadValues$g({}, filterLow), { currentValue }));
+        }
+      }
+    ) }),
+    " - ",
+    /* @__PURE__ */ jsx(Box, { className: "ApiaFilter__Range__High", children: /* @__PURE__ */ jsx(
+      ApiaFilter,
+      {
+        filter: filterHigh,
+        onChange: (currentValue) => {
+          if (onFilterChange)
+            void onFilterChange(__spreadProps$d(__spreadValues$g({}, filterHigh), { currentValue }));
+        },
+        onBlur: (currentValue) => {
+          if (onFilterBlur)
+            void onFilterBlur(__spreadProps$d(__spreadValues$g({}, filterHigh), { currentValue }));
+        },
+        onPressEnter: (currentValue) => {
+          if (onFilterPressEnter)
+            void onFilterPressEnter(__spreadProps$d(__spreadValues$g({}, filterHigh), { currentValue }));
+        }
+      }
+    ) })
+  ] });
+};
+const RangeFilter = NoMemoRangeFilter;
+
+var __defProp$f = Object.defineProperty;
+var __defProps$c = Object.defineProperties;
+var __getOwnPropDescs$c = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
+var __hasOwnProp$f = Object.prototype.hasOwnProperty;
+var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$f = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$f.call(b, prop))
+      __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(b)) {
+      if (__propIsEnum$f.call(b, prop))
+        __defNormalProp$f(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
+const FilterCell = ({ columnIndex, filter }) => {
+  const { name, onFilterBlur, onFilterChange, onFilterPressEnter } = useResponsiveTableContext();
+  const domProps = useDomProps(
+    "filterTd",
+    {
+      columnIndex
+    },
+    domPropsSelector(name)
+  );
+  const handleOnBlur = React.useCallback(
+    (currentValue) => {
+      if (filter && onFilterBlur)
+        onFilterBlur(__spreadProps$c(__spreadValues$f({}, filter), { currentValue }));
+    },
+    [filter, onFilterBlur]
+  );
+  const handleOnChange = React.useCallback(
+    (currentValue) => {
+      if (filter && onFilterChange)
+        return onFilterChange(__spreadProps$c(__spreadValues$f({}, filter), { currentValue }));
+      return true;
+    },
+    [filter, onFilterChange]
+  );
+  const handleOnPressEnter = React.useCallback(
+    (currentValue) => {
+      if (filter && onFilterPressEnter)
+        onFilterPressEnter(__spreadProps$c(__spreadValues$f({}, filter), { currentValue }));
+    },
+    [filter, onFilterPressEnter]
+  );
+  function findFilter() {
+    if (filter == null ? void 0 : filter.isRange) {
+      return /* @__PURE__ */ jsx(RangeFilter, { filter });
+    }
+    if (filter && !(filter.asAdditional || !filter.column || filter.isRange)) {
+      return /* @__PURE__ */ jsx(
+        ApiaFilter,
+        {
+          onBlur: handleOnBlur,
+          onChange: handleOnChange,
+          onPressEnter: handleOnPressEnter,
+          filter
+        }
+      );
+    }
+    let label;
+    if (filter && (filter.asAdditional || !filter.column || filter.isRange)) {
+      label = window.LBL_ADDITIONAL_FILTER;
+    } else {
+      label = window.LBL_NO_COLUMN_FILTER;
+    }
+    return /* @__PURE__ */ jsx(Input, { "aria-label": label, disabled: true });
+  }
+  return /* @__PURE__ */ jsx("td", __spreadProps$c(__spreadValues$f({}, domProps), { children: findFilter() }));
+};
+
+var __defProp$e = Object.defineProperty;
+var __defProps$b = Object.defineProperties;
+var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
+var __hasOwnProp$e = Object.prototype.hasOwnProperty;
+var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$e = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$e.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(b)) {
+      if (__propIsEnum$e.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
+const NoMemoHeader = () => {
+  const { name } = useResponsiveTableContext();
+  const { columns, hasNonAdditionalFilters, focusedColumn, focusedRow } = useResponsiveTable((global) => {
+    var _a;
+    const tableState = global.responsiveTableSlice[name];
+    window.focusedRow = tableState == null ? void 0 : tableState.focusedRow;
+    window.focusedColumn = tableState == null ? void 0 : tableState.focusedColumn;
+    window.hasNonAdditionalFilters = (tableState == null ? void 0 : tableState.hasNonAdditionalFilters) || false;
+    return {
+      columns: (_a = tableState == null ? void 0 : tableState.columns) != null ? _a : [],
+      focusedColumn: tableState == null ? void 0 : tableState.focusedColumn,
+      focusedRow: tableState == null ? void 0 : tableState.focusedRow,
+      hasNonAdditionalFilters: tableState == null ? void 0 : tableState.hasNonAdditionalFilters
+    };
+  }, shallowEqual$1);
+  const filters = useResponsiveTable(
+    (global) => {
+      var _a;
+      const tableState = global.responsiveTableSlice[name];
+      const returnObject = ((_a = tableState == null ? void 0 : tableState.filters) != null ? _a : []).map((current) => ({
+        columnIndex: tableState.columns.findIndex(
+          (search) => search.name === current.column
+        ),
+        definition: current
+      })).filter((current) => current.columnIndex >= 0);
+      return returnObject;
+    },
+    (a, b) => {
+      return a.length === b.length && a.reduce((result, current, index) => {
+        return result && shallowEqual$1(current.definition, b[index].definition);
+      }, true);
+    }
+  );
+  const statesCount = useResponsiveTable((globalState) => {
+    var _a;
+    const state = globalState.responsiveTableSlice[name];
+    return (_a = state == null ? void 0 : state.statesColumns) != null ? _a : 0;
+  }, shallowEqual$1);
+  const additionalColumns = React.useMemo(
+    () => columns.reduce(
+      (count, column) => count + (column.showAsAdditional ? 1 : 0),
+      0
+    ),
+    [columns]
+  );
+  const statesIds = React.useMemo(() => {
+    return Array(statesCount).fill("").map(() => uniqueId());
+  }, [statesCount]);
+  const [isFiltersRowVisible, setIsFiltersRowVisible] = React.useState(
+    /* (persistentStorage.showResponsiveTableFilters as boolean) ??  */
+    false
+  );
+  React.useEffect(() => {
+    persistentStorage.showResponsiveTableFilters = isFiltersRowVisible;
+  }, [isFiltersRowVisible]);
+  const buttonProps = useOtherTagButton(
+    React.useMemo(
+      () => ({
+        className: "additionalColumn",
+        onClick: () => setIsFiltersRowVisible((current) => !current)
+      }),
+      []
+    )
+  );
+  const [ref, setRef] = useState(null);
+  useUpdateEffect$1(() => {
+    const handleFocus = (ev) => {
+      ev.stopPropagation();
+      setIsFiltersRowVisible(true);
+    };
+    ref == null ? void 0 : ref.addEventListener(customEvents.focus, handleFocus);
+    return () => {
+      ref == null ? void 0 : ref.removeEventListener(customEvents.focus, handleFocus);
+    };
+  }, [ref]);
+  return /* @__PURE__ */ jsxs("thead", { children: [
+    /* @__PURE__ */ jsxs("tr", { "data-focusindex": 1, children: [
+      (additionalColumns > 0 || hasNonAdditionalFilters) && /* @__PURE__ */ jsx(
+        "th",
+        __spreadProps$b(__spreadValues$e({
+          "aria-colindex": 1,
+          "aria-rowindex": 1,
+          "data-focused": focusedColumn === 1 && focusedRow === -1 - (hasNonAdditionalFilters ? 1 : 0)
+        }, buttonProps), {
+          tabIndex: focusedColumn === 1 && focusedRow === -1 - (hasNonAdditionalFilters ? 1 : 0) ? 0 : -1,
+          role: "rowheader",
+          children: hasNonAdditionalFilters ? /* @__PURE__ */ jsx(
+            Icon,
+            {
+              className: "filterButton",
+              name: "Filter",
+              title: isFiltersRowVisible ? window.LBL_HIDE_FILTERS : window.LBL_SHOW_FILTERS,
+              "aria-label": isFiltersRowVisible ? window.LBL_HIDE_FILTERS : window.LBL_SHOW_FILTERS
+            }
+          ) : /* @__PURE__ */ jsx(Fragment, { children: "\xA0" })
+        })
+      ),
+      statesIds.map((id, i) => /* @__PURE__ */ jsx(StateCell, { isHeader: true, index: i, rowIndex: 1 }, id)),
+      columns.map((current, actualColumnIndex) => __spreadProps$b(__spreadValues$e({}, current), {
+        actualTableColumnIndex: actualColumnIndex
+      })).filter((current) => !current.showAsAdditional).map((current, columnIndex) => {
+        if (current.hidden)
+          return null;
+        return /* @__PURE__ */ jsx(
+          HeaderCell,
+          {
+            apiaColumnIndex: current.actualTableColumnIndex,
+            columnIndex: current.actualTableColumnIndex,
+            inTableColumnIndex: columnIndex
+          },
+          current.name
+        );
+      })
+    ] }),
+    filters.length > 0 && /* @__PURE__ */ jsxs(
+      "tr",
+      {
+        ref: setRef,
+        "data-focusindex": 2,
+        className: `responsiveTable__filters__row ${isFiltersRowVisible ? "" : "hidden"}`,
+        children: [
+          (additionalColumns > 0 || hasNonAdditionalFilters) && /* @__PURE__ */ jsx(
+            "td",
+            {
+              className: "noFilter",
+              "aria-colindex": 1,
+              "aria-rowindex": 2,
+              tabIndex: focusedColumn === 1 && focusedRow === -1 ? 0 : -1,
+              "data-focused": focusedColumn === 1 && focusedRow === -1,
+              children: "\xA0"
+            }
+          ),
+          statesIds.map((id, i) => /* @__PURE__ */ jsx(StateCell, { isHeader: true, index: i, rowIndex: 2 }, id)),
+          columns.filter((current) => !current.showAsAdditional).map((current, columnIndex) => {
+            const filter = filters.find(
+              (search) => search.definition.column === current.name
+            );
+            return current.showAsAdditional ? null : /* @__PURE__ */ jsx(
+              FilterCell,
+              {
+                columnIndex,
+                filter: filter == null ? void 0 : filter.definition
+              },
+              current.name
+            );
+          })
+        ]
+      }
+    )
+  ] });
+};
+const Header = React.memo(NoMemoHeader);
+
+const NoMemoAdditionalColumnDefaultRenderer = ({
+  column,
+  cell
+}) => {
+  var _a;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      className: `${(_a = cell.className) != null ? _a : ""} responsiveTable__additionalInfoItem`,
+      id: cell.id,
+      title: cell.title,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { as: "strong", children: [
+          column.name,
+          ":"
+        ] }),
+        " ",
+        cell.children
+      ]
+    }
+  );
+};
+const AdditionalColumnDefaultRenderer = React.memo(
+  NoMemoAdditionalColumnDefaultRenderer
+);
+
+var __defProp$d = Object.defineProperty;
+var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
+var __hasOwnProp$d = Object.prototype.hasOwnProperty;
+var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$d = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$d.call(b, prop))
+      __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$d)
+    for (var prop of __getOwnPropSymbols$d(b)) {
+      if (__propIsEnum$d.call(b, prop))
+        __defNormalProp$d(a, prop, b[prop]);
+    }
+  return a;
+};
+const SeparatorCell = ({
+  colSpan,
+  rowIndex
+}) => {
+  const { name } = useResponsiveTableContext();
+  const domProps = useDomProps(
+    "separator",
+    { rowIndex },
+    domPropsSelector(name)
+  );
+  return /* @__PURE__ */ jsx("td", __spreadValues$d({ className: "row__separator__cell", colSpan }, domProps));
+};
+
+var __defProp$c = Object.defineProperty;
+var __getOwnPropSymbols$c = Object.getOwnPropertySymbols;
+var __hasOwnProp$c = Object.prototype.hasOwnProperty;
+var __propIsEnum$c = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$c = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$c.call(b, prop))
+      __defNormalProp$c(a, prop, b[prop]);
+  if (__getOwnPropSymbols$c)
+    for (var prop of __getOwnPropSymbols$c(b)) {
+      if (__propIsEnum$c.call(b, prop))
+        __defNormalProp$c(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest$9 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$c.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$c)
+    for (var prop of __getOwnPropSymbols$c(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$c.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const NoMemoDefaultRowRenderer = React.forwardRef((_a, currentRef) => {
+  var _b = _a, { row, rowIndex } = _b, props = __objRest$9(_b, ["row", "rowIndex"]);
+  return /* @__PURE__ */ jsx(
+    Box,
+    __spreadValues$c({
+      as: "tr",
+      sx: useMemo(
+        () => ({
+          "&.colored, & > *": {
+            color: row.color,
+            background: row.background
+          }
+        }),
+        [row.background, row.color]
+      ),
+      ref: currentRef
+    }, props)
+  );
+});
+NoMemoDefaultRowRenderer.displayName = "DefaultRowRenderer";
+const DefaultRowRenderer = NoMemoDefaultRowRenderer;
+
+var __defProp$b = Object.defineProperty;
+var __defProps$a = Object.defineProperties;
+var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
+var __hasOwnProp$b = Object.prototype.hasOwnProperty;
+var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$b.call(b, prop))
+      __defNormalProp$b(a, prop, b[prop]);
+  if (__getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(b)) {
+      if (__propIsEnum$b.call(b, prop))
+        __defNormalProp$b(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+var __objRest$8 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$b.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$b.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const NoMemoDefaultCellRenderer = React.forwardRef(
+  (_a, currentRef) => {
+    var _b = _a, {
+      cell: _c
+    } = _b, _d = _c, { Renderer, rendererProps, AccordionRenderer, ariaLabel } = _d, cell = __objRest$8(_d, ["Renderer", "rendererProps", "AccordionRenderer", "ariaLabel"]), _e = _b, props = __objRest$8(_e, [
+      "cell",
+      "column",
+      "row"
+    ]);
+    return /* @__PURE__ */ jsx(
+      Box,
+      __spreadProps$a(__spreadValues$b(__spreadValues$b({
+        as: "td",
+        sx: useMemo(
+          () => ({
+            "&.colored": {
+              background: cell.background,
+              color: cell.color
+            }
+          }),
+          [cell.background, cell.color]
+        ),
+        ref: currentRef
+      }, props), cell), {
+        "aria-label": ariaLabel
+      })
+    );
+  }
+);
+NoMemoDefaultCellRenderer.displayName = "DefaultCellRenderer";
+const DefaultCellRenderer = NoMemoDefaultCellRenderer;
+
+var __defProp$a = Object.defineProperty;
+var __defProps$9 = Object.defineProperties;
+var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
+var __hasOwnProp$a = Object.prototype.hasOwnProperty;
+var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$a = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$a.call(b, prop))
+      __defNormalProp$a(a, prop, b[prop]);
+  if (__getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(b)) {
+      if (__propIsEnum$a.call(b, prop))
+        __defNormalProp$a(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+const NoMemoCell = ({
+  columnIndex,
+  inTableColumnIndex,
+  rowIndex
+}) => {
+  const { name } = useResponsiveTableContext();
+  const domProps = useDomProps(
+    "td",
+    { columnIndex: inTableColumnIndex, rowIndex },
+    domPropsSelector(name)
+  );
+  const cell = useResponsiveTable((global) => {
+    var _a;
+    const tableState = global.responsiveTableSlice[name];
+    return (_a = tableState == null ? void 0 : tableState.rows[rowIndex]) == null ? void 0 : _a.cells[columnIndex];
+  }, shallowEqual);
+  const column = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    return tableState == null ? void 0 : tableState.columns[columnIndex];
+  }, shallowEqual);
+  const row = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    return tableState == null ? void 0 : tableState.rows[rowIndex];
+  }, shallowEqual);
+  const Renderer = React.useMemo(
+    () => {
+      var _a;
+      return (_a = cell == null ? void 0 : cell.Renderer) != null ? _a : DefaultCellRenderer;
+    },
+    [cell == null ? void 0 : cell.Renderer]
+  );
+  if (!Renderer || !cell)
+    return row.separator ? /* @__PURE__ */ jsx("div", { className: "separator" }) : null;
+  return /* @__PURE__ */ jsx(
+    Renderer,
+    __spreadProps$9(__spreadValues$a({}, domProps), {
+      cell,
+      column,
+      row
+    })
+  );
+};
+const Cell = React.memo(NoMemoCell);
+
+var __defProp$9 = Object.defineProperty;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$9(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$9(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+var __objRest$7 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$9.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$9.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const NoMemoRow = ({ rowIndex }) => {
+  var _b;
+  const { name } = useResponsiveTableContext();
+  const { columns, hasNonAdditionalFilters } = useResponsiveTable((global) => {
+    var _a2;
+    const tableState = global.responsiveTableSlice[name];
+    return {
+      columns: (_a2 = tableState == null ? void 0 : tableState.columns) != null ? _a2 : [],
+      hasNonAdditionalFilters: tableState == null ? void 0 : tableState.hasNonAdditionalFilters
+    };
+  }, shallowEqual);
+  const row = useResponsiveTable(
+    (global) => global.responsiveTableSlice[name].rows[rowIndex],
+    shallowEqual
+  );
+  const additionalCells = useResponsiveTable(
+    (global) => {
+      const tableState = global.responsiveTableSlice[name];
+      return tableState.columns.map(
+        (current, index) => current.showAsAdditional ? {
+          index,
+          column: current
+        } : null
+      ).filter(
+        (current) => !!current
+      ).map((current) => {
+        var _a2;
+        return {
+          cell: (_a2 = tableState.rows[rowIndex]) == null ? void 0 : _a2.cells[current.index],
+          column: current.column,
+          columnIndex: current.index
+        };
+      });
+    },
+    (currentValue, newValue) => {
+      return currentValue.reduce(
+        (accumulatedBoolean, currentCell, cellIndex) => {
+          return accumulatedBoolean && shallowEqual(currentCell, newValue[cellIndex]);
+        },
+        true
+      );
+    }
+  );
+  const { isDragging, isExpanded, shouldForbidSelection } = useResponsiveTable(
+    (global) => {
+      var _a2;
+      const tableState = global.responsiveTableSlice[name];
+      return {
+        isExpanded: tableState.expandedRows.includes(rowIndex),
+        isDragging: tableState.draggingRow === rowIndex,
+        shouldForbidSelection: (_a2 = tableState.rows[rowIndex]) == null ? void 0 : _a2.forbidSelection
+      };
+    },
+    shallowEqual
+  );
+  const domProps = useDomProps(
+    "tr",
+    {
+      isThisRowExpanded: isExpanded,
+      rowIndex
+    },
+    domPropsSelector(name)
+  );
+  const expandedRowDomProps = useDomProps(
+    "tr",
+    {
+      isTheExpandedRow: true,
+      rowIndex
+    },
+    domPropsSelector(name)
+  );
+  const handleExpandedState = React.useCallback(
+    (ev) => {
+      const willBeExpanded = typeof ev === "boolean" ? ev : !isExpanded;
+      if (!willBeExpanded)
+        responsiveTableStore.dispatch(
+          responsiveTableActions.update({
+            tableName: name,
+            expandedRows: responsiveTableStore.getState().responsiveTableSlice[name].expandedRows.filter(
+              (current) => current !== rowIndex
+            )
+          })
+        );
+      else
+        responsiveTableStore.dispatch(
+          responsiveTableActions.update({
+            tableName: name,
+            expandedRows: [
+              ...responsiveTableStore.getState().responsiveTableSlice[name].expandedRows,
+              rowIndex
+            ]
+          })
+        );
+    },
+    [isExpanded, name, rowIndex]
+  );
+  const statesCount = useResponsiveTable((globalState) => {
+    var _a2;
+    const state = globalState.responsiveTableSlice[name];
+    return (_a2 = state == null ? void 0 : state.statesColumns) != null ? _a2 : 0;
+  }, shallowEqual);
+  const states = React.useMemo(
+    () => {
+      var _a2;
+      return ((_a2 = row.states) != null ? _a2 : []).map((current) => __spreadProps$8(__spreadValues$9({}, current), { id: uniqueId() }));
+    },
+    [row.states]
+  );
+  const _a = useDomProps(
+    "additionalTd",
+    { rowIndex },
+    domPropsSelector(name)
+  ), additionalCellDomProps = __objRest$7(_a, ["ref"]);
+  const Renderer = React.useMemo(
+    () => {
+      var _a2;
+      return (_a2 = row.renderer) != null ? _a2 : DefaultRowRenderer;
+    },
+    [row.renderer]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      Renderer,
+      __spreadProps$8(__spreadValues$9({}, domProps), {
+        row,
+        rowIndex,
+        className: `responsiveTable__row ${row.isHidden ? "hidden" : ""} ${domProps["aria-selected"] ? "selected" : ""} ${shouldForbidSelection ? "non-selectable" : ""} ${states.map((current) => current.className).join(" ")} ${(_b = row.className) != null ? _b : ""} ${row.separator ? "row__separator" : ""} ${isDragging ? "draggingRow" : ""}`,
+        onKeyDown: React.useCallback(
+          (ev) => {
+            if (ev.key.toLowerCase() === "arrowleft" && ev.ctrlKey) {
+              ev.preventDefault();
+              ev.stopPropagation();
+              handleExpandedState(false);
+            }
+            if (ev.key.toLowerCase() === "arrowright" && ev.ctrlKey) {
+              ev.preventDefault();
+              ev.stopPropagation();
+              handleExpandedState(true);
+            }
+          },
+          [handleExpandedState]
+        ),
+        children: row.separator ? /* @__PURE__ */ jsx(
+          SeparatorCell,
+          {
+            colSpan: (additionalCells.length > 0 || hasNonAdditionalFilters ? 1 : 0) + statesCount + columns.filter((current) => !current.showAsAdditional).length,
+            rowIndex
+          }
+        ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          (additionalCells.length > 0 || hasNonAdditionalFilters) && /* @__PURE__ */ jsx("td", __spreadProps$8(__spreadValues$9({ className: "additionalInfo__cell" }, additionalCellDomProps), { children: additionalCells.length > 0 && /* @__PURE__ */ jsx(
+            IconButton,
+            __spreadProps$8(__spreadValues$9({}, getVariant("icon-outline")), {
+              icon: isExpanded ? FaMinusSquare : FaPlusSquare,
+              "aria-label": isExpanded ? window.LBL_COLLAPSE_ROW : window.LBL_EXPAND_ROW,
+              className: "moreInformationButton",
+              onClick: handleExpandedState
+            })
+          ) })),
+          Array(statesCount).fill("").map((_, i) => {
+            var _a2, _b2;
+            return /* @__PURE__ */ jsx(
+              StateCell,
+              {
+                index: i,
+                state: states[i],
+                rowIndex
+              },
+              (_b2 = (_a2 = states[i]) == null ? void 0 : _a2.id) != null ? _b2 : i
+            );
+          }),
+          columns.map((current, actualColumnIndex) => __spreadProps$8(__spreadValues$9({}, current), {
+            actualColumnIndex
+          })).filter((current) => !current.showAsAdditional).map((current, inTableColumnIndex) => {
+            if (current.hidden)
+              return null;
+            return /* @__PURE__ */ jsx(
+              Cell,
+              {
+                columnIndex: current.actualColumnIndex,
+                rowIndex,
+                inTableColumnIndex
+              },
+              current.name
+            );
+          })
+        ] })
+      })
+    ),
+    isExpanded && /* @__PURE__ */ jsx("tr", __spreadProps$8(__spreadValues$9({ className: "expandedRow" }, expandedRowDomProps), { children: /* @__PURE__ */ jsx(
+      "td",
+      {
+        colSpan: columns.length - additionalCells.length + states.length + 1,
+        children: /* @__PURE__ */ jsx(Box, { className: "responsiveTable__additionalInfoContainer", children: additionalCells.map((current) => {
+          const { Renderer: ColumnRenderer } = current.column;
+          if (ColumnRenderer)
+            return /* @__PURE__ */ jsx(
+              ColumnRenderer,
+              {
+                cell: current.cell,
+                column: current.column,
+                row
+              },
+              current.column.name
+            );
+          return /* @__PURE__ */ jsx(
+            AdditionalColumnDefaultRenderer,
+            {
+              cell: current.cell,
+              column: current.column,
+              row
+            },
+            current.column.name
+          );
+        }) })
+      }
+    ) }))
+  ] });
+};
+const Row = React.memo(NoMemoRow);
+
+const NoRegistersRenderer = () => {
+  const { labels } = useResponsiveTableContext();
+  return /* @__PURE__ */ jsx(Box, { className: "no__registers", children: labels.noRegisters });
+};
+
+var __defProp$8 = Object.defineProperty;
+var __defProps$7 = Object.defineProperties;
+var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$8 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$8.call(b, prop))
+      __defNormalProp$8(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b)) {
+      if (__propIsEnum$8.call(b, prop))
+        __defNormalProp$8(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+const NoMemoTableRenderer = () => {
+  const { name, label } = useResponsiveTableContext();
+  const domProps = useDomProps(
+    "table",
+    {},
+    (global) => global.responsiveTableSlice[name]
+  );
+  const rows = useResponsiveTable((global) => {
+    var _a;
+    const tableState = global.responsiveTableSlice[name];
+    return ((_a = tableState == null ? void 0 : tableState.rows) != null ? _a : []).map((current) => current.id);
+  }, shallowEqual);
+  const { columnsCount, rowsCount } = useResponsiveTable((global) => {
+    var _a, _b, _c;
+    const tableState = global.responsiveTableSlice[name];
+    return {
+      rowsCount: (_a = tableState == null ? void 0 : tableState.rows.length) != null ? _a : 0,
+      columnsCount: ((_b = tableState == null ? void 0 : tableState.nonAdditionalColumnsCount) != null ? _b : 0) + ((tableState == null ? void 0 : tableState.hasNonAdditionalFilters) ? 1 : 0) + ((_c = tableState == null ? void 0 : tableState.statesColumns) != null ? _c : 0)
+    };
+  }, shallowEqual);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    __spreadProps$7(__spreadValues$8(__spreadProps$7(__spreadValues$8({}, domProps), {
+      as: "table",
+      className: "responsiveTable__table"
+    }), getVariant("layout.common.tables.primary")), {
+      "aria-label": label,
+      children: [
+        /* @__PURE__ */ jsx(Header, {}),
+        /* @__PURE__ */ jsx("tbody", { children: rowsCount > 0 ? rows.map((row, index) => {
+          return /* @__PURE__ */ jsx(Row, { rowIndex: index }, row != null ? row : `${row}-${index}`);
+        }) : /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: columnsCount, children: /* @__PURE__ */ jsx(NoRegistersRenderer, {}) }) }) })
+      ]
+    })
+  );
+};
+const TableRenderer = React.memo(NoMemoTableRenderer);
+
+const NoMemoAccordionCell = ({ cell, column }) => {
+  var _a;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      className: "responsiveTable__accordionElement__column",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { as: "strong", children: [
+          (_a = column.label) != null ? _a : column.name,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx(Box, { as: "span", children: cell == null ? void 0 : cell.children })
+      ]
+    },
+    column.name
+  );
+};
+const AccordionCell = NoMemoAccordionCell;
+
+const PrimitiveAccordionElement = ({ children }) => /* @__PURE__ */ jsx(Box, { className: "accordion", children });
+const NoMemoAccordionElement = ({ row, rowIndex }) => {
+  const { name } = useResponsiveTableContext();
+  const indexColumns = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    return tableState == null ? void 0 : tableState.accordionIndexColumns;
+  }, shallowEqual);
+  const columns = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    return tableState == null ? void 0 : tableState.columns;
+  }, shallowEqual);
+  const title = React.useMemo(() => {
+    var _a;
+    if (row.title)
+      return row.title;
+    if (Array.isArray(indexColumns))
+      return indexColumns.map(
+        (current) => {
+          var _a2;
+          return (_a2 = row.cells[current.index].title) != null ? _a2 : row.cells[current.index].children;
+        }
+      ).join(" | ");
+    return (_a = row.cells[0].title) != null ? _a : row.cells[0].children;
+  }, [indexColumns, row.cells, row.title]);
+  if (!Array.isArray(indexColumns) || !columns)
+    return null;
+  return /* @__PURE__ */ jsxs(
+    PrimitiveAccordionElement,
+    {
+      ButtonComponent: Button,
+      className: "responsiveTable__accordionElement",
+      contentClassName: "responsiveTable__accordionElement__content",
+      id: row.id,
+      title,
+      children: [
+        columns.map((currentColumn, columnIndex) => {
+          var _a, _b;
+          const Renderer = (_b = (_a = row.cells[columnIndex].AccordionRenderer) != null ? _a : currentColumn.AccordionRenderer) != null ? _b : AccordionCell;
+          return currentColumn.hideFromAccordion || currentColumn.showAsAdditional ? null : /* @__PURE__ */ jsx(
+            Renderer,
+            {
+              cell: row.cells[columnIndex],
+              column: currentColumn,
+              columnIndex,
+              row,
+              rowIndex
+            },
+            currentColumn.name
+          );
+        }),
+        columns.filter((current) => !!current.showAsAdditional).map((currentColumn, columnIndex) => {
+          var _a, _b;
+          const Renderer = (_b = (_a = row.cells[columnIndex].AccordionRenderer) != null ? _a : currentColumn.AccordionRenderer) != null ? _b : AccordionCell;
+          return currentColumn.hideFromAccordion ? null : /* @__PURE__ */ jsx(
+            Renderer,
+            {
+              cell: row.cells[columnIndex],
+              column: currentColumn,
+              columnIndex,
+              row,
+              rowIndex
+            },
+            currentColumn.name
+          );
+        })
+      ]
+    }
+  );
+};
+const AccordionElement = NoMemoAccordionElement;
+
+var __defProp$7 = Object.defineProperty;
+var __defProps$6 = Object.defineProperties;
+var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+const isDebugging = false;
+const NoMemoAccordionRenderer = () => {
+  const { name } = useResponsiveTableContext();
+  const { columns, rows } = useResponsiveTable((global) => {
+    const tableState = global.responsiveTableSlice[name];
+    return {
+      columns: tableState == null ? void 0 : tableState.columns,
+      rows: tableState == null ? void 0 : tableState.rows
+    };
+  }, shallowEqual);
+  React.useEffect(() => {
+    if (columns && rows) {
+      const markedAsTitleColumns = [];
+      columns.forEach((column, index) => {
+        if (column.showInAccordionTitle)
+          markedAsTitleColumns.push({ column, index });
+      });
+      if (markedAsTitleColumns.length > 0) {
+        responsiveTableStore.dispatch(
+          responsiveTableActions.update({
+            tableName: name,
+            accordionIndexColumns: markedAsTitleColumns
+          })
+        );
+      } else {
+        const columnsLength = columns.length;
+        let indexColumn = null;
+        let currentIndex = 0;
+        while (!indexColumn && !isDebugging && currentIndex < columns.length || isDebugging ) {
+          let isAnyEmptyRow = false;
+          for (const row of rows) {
+            if (!row.cells[currentIndex].children) {
+              isAnyEmptyRow = true;
+              break;
+            }
+          }
+          if (!isAnyEmptyRow && columns[currentIndex]) {
+            indexColumn = columns[currentIndex];
+          } else {
+            currentIndex += 1;
+            if (currentIndex === columnsLength)
+              break;
+          }
+        }
+        if (!indexColumn) {
+          [indexColumn] = columns;
+          currentIndex = 0;
+        }
+        responsiveTableStore.dispatch(
+          responsiveTableActions.update({
+            tableName: name,
+            accordionIndexColumns: [
+              { column: indexColumn, index: currentIndex }
+            ]
+          })
+        );
+      }
+    }
+  }, [columns, name, rows]);
+  const [ref, setRef] = React.useState(null);
+  React.useEffect(() => {
+    const observer = new MutationObserver(([mutation]) => {
+      if (mutation.addedNodes) {
+        mutation.addedNodes.forEach((current) => {
+          var _a, _b;
+          if ((_a = current.classList) == null ? void 0 : _a.contains(
+            "responsiveTable__accordionElement"
+          ))
+            (_b = current.scrollIntoView) == null ? void 0 : _b.call(current);
+        });
+      }
+    });
+    if (ref)
+      observer.observe(ref, { childList: true, subtree: true });
+    return () => {
+      observer.disconnect();
+    };
+  }, [ref]);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    __spreadProps$6(__spreadValues$7({
+      className: "responsiveTable__accordion"
+    }, getVariant("layout.common.tables.accordion")), {
+      ref: setRef,
+      children: [
+        !rows || rows.length === 0 && /* @__PURE__ */ jsx(NoRegistersRenderer, {}),
+        rows == null ? void 0 : rows.slice(0, void 0).map((current, rowIndex) => /* @__PURE__ */ jsx(
+          AccordionElement,
+          {
+            row: current,
+            rowIndex
+          },
+          current.id
+        ))
+      ]
+    })
+  );
+};
+const AccordionRenderer = React.memo(NoMemoAccordionRenderer);
+
+var __defProp$6 = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+var __objRest$6 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const domPropsSelector = (name) => (global) => global.responsiveTableSlice[name];
+const NoMemoResponsiveTable = React.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest$6(_b, ["className"]);
+  const breakpoint = useBreakpointIndex({ defaultIndex: 3 });
+  const { currentBreakPoint } = useResponsiveTableContext();
+  const actualBreakpoint = currentBreakPoint != null ? currentBreakPoint : breakpoint;
+  return /* @__PURE__ */ jsx(KeyHandler, { children: /* @__PURE__ */ jsx(
+    Box,
+    __spreadProps$5(__spreadValues$6(__spreadValues$6({}, props), getVariant("layout.common.tables.responsive")), {
+      className: `responsiveTable__wrapper ${className != null ? className : ""}`,
+      ref,
+      children: actualBreakpoint >= 3 ? /* @__PURE__ */ jsx(TableRenderer, {}) : /* @__PURE__ */ jsx(AccordionRenderer, {})
+    })
+  ) });
+});
+NoMemoResponsiveTable.displayName = "ResponsiveTable";
+const ResponsiveTable = React.memo(NoMemoResponsiveTable);
+
+var __defProp$5 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+var __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$5.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$5.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const NoMemoDocNameCellRenderer = React.forwardRef(
+  (_a, currentRef) => {
+    var _b = _a, {
+      cell: _c
+    } = _b, _d = _c, { children, Renderer, rendererProps, AccordionRenderer } = _d, cell = __objRest$5(_d, ["children", "Renderer", "rendererProps", "AccordionRenderer"]), _e = _b, props = __objRest$5(_e, [
+      "cell",
+      "column",
+      "row"
+    ]);
+    return /* @__PURE__ */ jsx(
+      "td",
+      __spreadProps$4(__spreadValues$5(__spreadValues$5({
+        ref: currentRef
+      }, props), cell), {
+        children: /* @__PURE__ */ jsxs(
+          Link,
+          {
+            className: "cell__download__document",
+            title: rendererProps == null ? void 0 : rendererProps.docName,
+            href: rendererProps == null ? void 0 : rendererProps.docUrl,
+            onClick: (ev) => {
+              ev.preventDefault();
+              if (rendererProps == null ? void 0 : rendererProps.docUrl)
+                void downloadUrl(rendererProps == null ? void 0 : rendererProps.docUrl);
+            },
+            children: [
+              /* @__PURE__ */ jsx(Icon, { title: "", name: "Download" }),
+              rendererProps == null ? void 0 : rendererProps.docName
+            ]
+          }
+        )
+      })
+    );
+  }
+);
+NoMemoDocNameCellRenderer.displayName = "DocNameCellRenderer";
+const DocNameCellRenderer = NoMemoDocNameCellRenderer;
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __objRest$4 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const NoMemoAccordionDocNameCellRenderer = React.forwardRef(
+  (_a, currentRef) => {
+    var _b = _a, {
+      cell: _c
+    } = _b, _d = _c, { children, Renderer, rendererProps, AccordionRenderer } = _d, cell = __objRest$4(_d, ["children", "Renderer", "rendererProps", "AccordionRenderer"]), {
+      column
+    } = _b;
+    var _a2;
+    return /* @__PURE__ */ jsxs(Box, __spreadProps$3(__spreadValues$4({ ref: currentRef }, cell), { children: [
+      /* @__PURE__ */ jsxs(Box, { as: "strong", children: [
+        (_a2 = column.label) != null ? _a2 : column.name,
+        ": "
+      ] }),
+      /* @__PURE__ */ jsxs(
+        Link,
+        {
+          className: "cell__download__document",
+          title: rendererProps == null ? void 0 : rendererProps.docName,
+          href: rendererProps == null ? void 0 : rendererProps.docUrl,
+          onClick: (ev) => {
+            ev.preventDefault();
+            if (rendererProps == null ? void 0 : rendererProps.docUrl)
+              void downloadUrl(rendererProps == null ? void 0 : rendererProps.docUrl);
+          },
+          children: [
+            /* @__PURE__ */ jsx(Icon, { title: "", name: "Download" }),
+            rendererProps == null ? void 0 : rendererProps.docName
+          ]
+        }
+      )
+    ] }));
+  }
+);
+NoMemoAccordionDocNameCellRenderer.displayName = "AccordionDocNameCellRenderer";
+const AccordionDocNameCellRenderer = NoMemoAccordionDocNameCellRenderer;
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const NoMemoAccordionHTMLCellRenderer = React.forwardRef(
+  (_a, currentRef) => {
+    var _b = _a, {
+      cell: _c
+    } = _b, _d = _c, { children, Renderer, rendererProps, AccordionRenderer } = _d, cell = __objRest$3(_d, ["children", "Renderer", "rendererProps", "AccordionRenderer"]), _e = _b, props = __objRest$3(_e, [
+      "cell",
+      "column",
+      "row"
+    ]);
+    return (
+      /**
+       * Aca falta el title de la columna
+       */
+      /* @__PURE__ */ jsx(
+        Box,
+        __spreadProps$2(__spreadValues$3(__spreadValues$3(__spreadValues$3({
+          ref: currentRef
+        }, props), cell), (rendererProps == null ? void 0 : rendererProps.html) ? {
+          dangerouslySetInnerHTML: {
+            __html: rendererProps.html.replaceAll(/<TOK(\d+)/g, "&lt;TOK$1")
+          }
+        } : { children }), {
+          as: "span"
+        })
+      )
+    );
+  }
+);
+NoMemoAccordionHTMLCellRenderer.displayName = "AccordionHTMLCellRenderer";
+const AccordionHTMLCellRenderer = NoMemoAccordionHTMLCellRenderer;
+
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const NoMemoHTMLCellRenderer = React.forwardRef(
+  (_a, currentRef) => {
+    var _b = _a, {
+      cell: _c
+    } = _b, _d = _c, { children, Renderer, rendererProps, AccordionRenderer } = _d, cell = __objRest$2(_d, ["children", "Renderer", "rendererProps", "AccordionRenderer"]), _e = _b, props = __objRest$2(_e, [
+      "cell",
+      "column",
+      "row"
+    ]);
+    return /* @__PURE__ */ jsx(
+      "td",
+      __spreadValues$2(__spreadValues$2(__spreadValues$2({
+        ref: currentRef
+      }, props), cell), (rendererProps == null ? void 0 : rendererProps.html) ? {
+        dangerouslySetInnerHTML: {
+          __html: rendererProps.html.replaceAll(
+            /<TOK(\d+)/g,
+            "&lt;TOK$1"
+          )
+        }
+      } : { children })
+    );
+  }
+);
+NoMemoHTMLCellRenderer.displayName = "HTMLCellRenderer";
+const HTMLCellRenderer = NoMemoHTMLCellRenderer;
+
+const IsLoadingRenderer = () => {
+  return /* @__PURE__ */ jsx(Box, { className: "responsiveTable__isLoading", children: /* @__PURE__ */ jsx(Spinner, {}) });
+};
+
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function makeAccordionAsyncRenderer(additionalInfoGetter) {
+  const InnerRender = forwardRef(({ row }, ref) => {
+    const [moreInfo, setMoreInfo] = useState(null);
+    const loadMore = useCallback(() => __async$1(this, null, function* () {
+      const result = yield additionalInfoGetter(row);
+      setMoreInfo(result);
+    }), [row]);
+    return /* @__PURE__ */ jsx(Fragment, { children: moreInfo ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(IconButton, { icon: "Minus", onClick: () => setMoreInfo(null) }),
+      arrayOrArray(moreInfo).map(
+        (dataCell) => {
+          return /* @__PURE__ */ jsxs(Box, { ref, as: "div", children: [
+            /* @__PURE__ */ jsxs(Box, { as: "strong", children: [
+              dataCell.name,
+              ":"
+            ] }),
+            " ",
+            dataCell.label
+          ] }, dataCell.name);
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx(IconButton, { icon: "Plus", onClick: () => void loadMore() }) });
+  });
+  InnerRender.displayName = "MakeAccordionAsyncRenderer";
+  return InnerRender;
+}
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function makeAsyncRenderer(additionalInfoGetter) {
+  const InnerRender = forwardRef(({ row }, ref) => {
+    const [moreInfo, setMoreInfo] = useState(null);
+    useMount$1(() => {
+      void (() => __async(this, null, function* () {
+        const result = yield additionalInfoGetter(row);
+        setMoreInfo(result);
+      }))();
+    });
+    return /* @__PURE__ */ jsx(Fragment, { children: moreInfo ? arrayOrArray(moreInfo).map((dataCell) => {
+      return /* @__PURE__ */ jsx(
+        Box,
+        {
+          ref,
+          className: `responsiveTable__additionalInfoItem ${dataCell.newline ? "separator" : ""}`,
+          children: dataCell.newline ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Box, { sx: { height: "20px" }, as: "strong", children: [
+              dataCell.name,
+              ":"
+            ] }),
+            " ",
+            dataCell.label
+          ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Box, { as: "strong", children: [
+              dataCell.name,
+              ":"
+            ] }),
+            " ",
+            dataCell.label
+          ] })
+        },
+        `${dataCell.name}-${uniqueId()}`
+      );
+    }) : /* @__PURE__ */ jsx(Spinner, { size: 15 }) });
+  });
+  InnerRender.displayName = "MakeAsyncRenderer";
+  return InnerRender;
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function getPriorityHandler(priority) {
+  let prio;
+  if (priority == null ? void 0 : priority.includes("priority0"))
+    prio = "priorityNone";
+  if (priority == null ? void 0 : priority.includes("priority1"))
+    prio = "priorityLow";
+  if (priority == null ? void 0 : priority.includes("priority2"))
+    prio = "priorityNormal";
+  if (priority == null ? void 0 : priority.includes("priority3"))
+    prio = "priorityHigh";
+  if (priority == null ? void 0 : priority.includes("priority4"))
+    prio = "priorityUrgent";
+  return prio;
+}
+const NoMemoPriorityRenderer = React.forwardRef(
+  (_a, currentRef) => {
+    var _b = _a, {
+      cell: _c
+    } = _b, _d = _c, { children, Renderer, rendererProps, AccordionRenderer } = _d, cell = __objRest$1(_d, ["children", "Renderer", "rendererProps", "AccordionRenderer"]), _e = _b, props = __objRest$1(_e, [
+      "cell",
+      "column",
+      "row"
+    ]);
+    const taskPriorityColor = getPriorityHandler(rendererProps == null ? void 0 : rendererProps.src);
+    return /* @__PURE__ */ jsx(
+      "td",
+      __spreadProps$1(__spreadValues$1(__spreadValues$1({}, props), cell), {
+        ref: currentRef,
+        className: "priority",
+        sx: {
+          color: taskPriorityColor
+        },
+        children: /* @__PURE__ */ jsx(FaSquare, {})
+      })
+    );
+  }
+);
+NoMemoPriorityRenderer.displayName = "PriorityRenderer";
+const PriorityRenderer = NoMemoPriorityRenderer;
+
+const NoMemoPriorityAccordionRenderer = React.forwardRef(
+  ({ cell, column }, currentRef) => {
+    var _a, _b, _c;
+    const taskPriorityColor = getPriorityHandler(
+      (_a = cell.rendererProps) == null ? void 0 : _a.src
+    );
+    const title = (_b = column.label) != null ? _b : column.name;
+    return /* @__PURE__ */ jsxs(Box, { ref: currentRef, className: "priority_container", children: [
+      title && /* @__PURE__ */ jsxs(Box, { as: "strong", children: [
+        (_c = column.label) != null ? _c : column.name,
+        ": "
+      ] }),
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          as: "span",
+          className: "priority",
+          sx: {
+            color: taskPriorityColor
+          },
+          children: /* @__PURE__ */ jsx(FaSquare, {})
+        }
+      )
+    ] });
+  }
+);
+NoMemoPriorityAccordionRenderer.displayName = "PriorityAccordionRenderer";
+const PriorityAccordionRenderer = NoMemoPriorityAccordionRenderer;
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function getStatusRendererClassName(cellValue, columnName) {
+  var _a;
+  if (cellValue === void 0)
+    return "";
+  const cellValueDate = cellValue.split(" ")[0];
+  const cellValueHour = (_a = cellValue.split(" ")[1]) != null ? _a : "00:00:00";
+  const dateFormat = getDateFormat();
+  const currentDate = dayjs();
+  const currentHour = Number(dayjs().format("HHmm"));
+  const queriedDate = dayjs(cellValueDate, dateFormat);
+  const queriedHour = Number(dayjs(cellValueHour, dateFormat));
+  let statusClassName = "";
+  if (currentDate >= queriedDate) {
+    statusClassName = columnName;
+  }
+  if (!queriedHour)
+    return statusClassName;
+  if (currentDate <= queriedDate && currentHour < queriedHour) {
+    statusClassName = columnName;
+  }
+  return statusClassName;
+}
+const NoMemoStatusRenderer = React.forwardRef(
+  (_a, currentRef) => {
+    var _b = _a, {
+      cell: _c
+    } = _b, _d = _c, { children, Renderer, rendererProps, AccordionRenderer } = _d, cell = __objRest(_d, ["children", "Renderer", "rendererProps", "AccordionRenderer"]), _e = _b, {
+      column,
+      row
+    } = _e, props = __objRest(_e, [
+      "cell",
+      "column",
+      "row"
+    ]);
+    const taskStatusClassName = getStatusRendererClassName(
+      children,
+      column.name
+    );
+    return /* @__PURE__ */ jsx(
+      "td",
+      __spreadProps(__spreadValues(__spreadValues({}, props), cell), {
+        ref: currentRef,
+        className: taskStatusClassName,
+        children
+      })
+    );
+  }
+);
+NoMemoStatusRenderer.displayName = "StatusRenderer";
+const StatusRenderer = NoMemoStatusRenderer;
+
+const NoMemoStatusAccordionRenderer = React.forwardRef(({ cell, column }, currentRef) => {
+  var _a;
+  const taskStatusClassName = getStatusRendererClassName(
+    cell.children,
+    column.name
+  );
+  return /* @__PURE__ */ jsxs(Box, { ref: currentRef, children: [
+    /* @__PURE__ */ jsxs(Box, { as: "strong", children: [
+      (_a = column.label) != null ? _a : column.name,
+      ": "
+    ] }),
+    /* @__PURE__ */ jsx(Box, { as: "span", className: taskStatusClassName, children: cell.children })
+  ] });
+});
+NoMemoStatusAccordionRenderer.displayName = "StatusAccordionRenderer";
+const StatusAccordionRenderer = NoMemoStatusAccordionRenderer;
+
+export { AccordionCell, AccordionDocNameCellRenderer, AccordionElement, AccordionHTMLCellRenderer, AccordionRenderer, AdditionalColumnDefaultRenderer, DefaultCellRenderer, DefaultRowRenderer, DocNameCellRenderer, HTMLCellRenderer, IsLoadingRenderer, NoRegistersRenderer, PriorityAccordionRenderer, PriorityRenderer, ResponsiveTable, ResponsiveTableContext, RowStatesRenderer, StatusAccordionRenderer, StatusRenderer, TableRenderer, defaultLabels, getPriorityHandler, getStatusRendererClassName, makeAccordionAsyncRenderer, makeAsyncRenderer, responsiveTableActions, responsiveTableStore, useResponsiveTable };
+//# sourceMappingURL=index.js.map