schummar-table 0.5.0-beta-1 → 0.5.0-beta-2

package/dist/cjs/index.js

@@ -0,0 +1,3802 @@
+"use strict";
+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 = (a2, b2) => {
+  for (var prop in b2 || (b2 = {}))
+    if (__hasOwnProp.call(b2, prop))
+      __defNormalProp(a2, prop, b2[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b2)) {
+      if (__propIsEnum.call(b2, prop))
+        __defNormalProp(a2, prop, b2[prop]);
+    }
+  return a2;
+};
+var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports[Symbol.toStringTag] = "Module";
+var require$$0 = require("react");
+var tableTheme = require("../tableTheme.js");
+require("react-dom");
+function _interopDefaultLegacy(e2) {
+  return e2 && typeof e2 === "object" && "default" in e2 ? e2 : { "default": e2 };
+}
+var require$$0__default = /* @__PURE__ */ _interopDefaultLegacy(require$$0);
+var propTypes = { exports: {} };
+var ReactPropTypesSecret$1 = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+var ReactPropTypesSecret_1 = ReactPropTypesSecret$1;
+var ReactPropTypesSecret = ReactPropTypesSecret_1;
+function emptyFunction() {
+}
+function emptyFunctionWithReset() {
+}
+emptyFunctionWithReset.resetWarningCache = emptyFunction;
+var factoryWithThrowingShims = function() {
+  function shim2(props, propName, componentName, location, propFullName, secret) {
+    if (secret === ReactPropTypesSecret) {
+      return;
+    }
+    var err = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");
+    err.name = "Invariant Violation";
+    throw err;
+  }
+  shim2.isRequired = shim2;
+  function getShim() {
+    return shim2;
+  }
+  var ReactPropTypes = {
+    array: shim2,
+    bigint: shim2,
+    bool: shim2,
+    func: shim2,
+    number: shim2,
+    object: shim2,
+    string: shim2,
+    symbol: shim2,
+    any: shim2,
+    arrayOf: getShim,
+    element: shim2,
+    elementType: shim2,
+    instanceOf: getShim,
+    node: shim2,
+    objectOf: getShim,
+    oneOf: getShim,
+    oneOfType: getShim,
+    shape: getShim,
+    exact: getShim,
+    checkPropTypes: emptyFunctionWithReset,
+    resetWarningCache: emptyFunction
+  };
+  ReactPropTypes.PropTypes = ReactPropTypes;
+  return ReactPropTypes;
+};
+{
+  propTypes.exports = factoryWithThrowingShims();
+}
+var PropTypes = propTypes.exports;
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i2 = 1; i2 < arguments.length; i2++) {
+      var source = arguments[i2];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i2;
+  for (i2 = 0; i2 < sourceKeys.length; i2++) {
+    key = sourceKeys[i2];
+    if (excluded.indexOf(key) >= 0)
+      continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function toInteger(dirtyNumber) {
+  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
+    return NaN;
+  }
+  var number = Number(dirtyNumber);
+  if (isNaN(number)) {
+    return number;
+  }
+  return number < 0 ? Math.ceil(number) : Math.floor(number);
+}
+function toDate(argument) {
+  if (arguments.length < 1) {
+    throw new TypeError("1 argument required, but only " + arguments.length + " present");
+  }
+  var argStr = Object.prototype.toString.call(argument);
+  if (argument instanceof Date || typeof argument === "object" && argStr === "[object Date]") {
+    return new Date(argument.getTime());
+  } else if (typeof argument === "number" || argStr === "[object Number]") {
+    return new Date(argument);
+  } else {
+    if ((typeof argument === "string" || argStr === "[object String]") && typeof console !== "undefined") {
+      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule");
+      console.warn(new Error().stack);
+    }
+    return new Date(NaN);
+  }
+}
+function addDays(dirtyDate, dirtyAmount) {
+  if (arguments.length < 2) {
+    throw new TypeError("2 arguments required, but only " + arguments.length + " present");
+  }
+  var date = toDate(dirtyDate);
+  var amount = toInteger(dirtyAmount);
+  date.setDate(date.getDate() + amount);
+  return date;
+}
+function isBefore(dirtyDate, dirtyDateToCompare) {
+  if (arguments.length < 2) {
+    throw new TypeError("2 arguments required, but only " + arguments.length + " present");
+  }
+  var date = toDate(dirtyDate);
+  var dateToCompare = toDate(dirtyDateToCompare);
+  return date.getTime() < dateToCompare.getTime();
+}
+function startOfDay$1(dirtyDate) {
+  if (arguments.length < 1) {
+    throw new TypeError("1 argument required, but only " + arguments.length + " present");
+  }
+  var date = toDate(dirtyDate);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+function isSameDay(dirtyDateLeft, dirtyDateRight) {
+  if (arguments.length < 2) {
+    throw new TypeError("2 arguments required, but only " + arguments.length + " present");
+  }
+  var dateLeftStartOfDay = startOfDay$1(dirtyDateLeft);
+  var dateRightStartOfDay = startOfDay$1(dirtyDateRight);
+  return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime();
+}
+function isToday(dirtyDate) {
+  if (arguments.length < 1) {
+    throw new TypeError("1 argument required, but only " + arguments.length + " present");
+  }
+  return isSameDay(dirtyDate, Date.now());
+}
+function differenceInCalendarMonths(dirtyDateLeft, dirtyDateRight) {
+  if (arguments.length < 2) {
+    throw new TypeError("2 arguments required, but only " + arguments.length + " present");
+  }
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var yearDiff = dateLeft.getFullYear() - dateRight.getFullYear();
+  var monthDiff = dateLeft.getMonth() - dateRight.getMonth();
+  return yearDiff * 12 + monthDiff;
+}
+function composeEventHandlers() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function(event) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    return fns.some(function(fn2) {
+      fn2 && fn2.apply(void 0, [event].concat(args));
+      return event.defaultPrevented;
+    });
+  };
+}
+function requiredProp(fnName, propName) {
+  throw new Error('The property "' + propName + '" is required in "' + fnName + '"');
+}
+function subtractMonth(_ref) {
+  var calendars = _ref.calendars, offset = _ref.offset, minDate = _ref.minDate;
+  if (offset > 1 && minDate) {
+    var firstDayOfMonth = calendars[0].firstDayOfMonth;
+    var diffInMonths = differenceInCalendarMonths(firstDayOfMonth, minDate);
+    if (diffInMonths < offset) {
+      offset = diffInMonths;
+    }
+  }
+  return offset;
+}
+function addMonth(_ref2) {
+  var calendars = _ref2.calendars, offset = _ref2.offset, maxDate = _ref2.maxDate;
+  if (offset > 1 && maxDate) {
+    var lastDayOfMonth = calendars[calendars.length - 1].lastDayOfMonth;
+    var diffInMonths = differenceInCalendarMonths(maxDate, lastDayOfMonth);
+    if (diffInMonths < offset) {
+      offset = diffInMonths;
+    }
+  }
+  return offset;
+}
+function isBackDisabled(_ref3) {
+  var calendars = _ref3.calendars, minDate = _ref3.minDate;
+  if (!minDate) {
+    return false;
+  }
+  var firstDayOfMonth = calendars[0].firstDayOfMonth;
+  var firstDayOfMonthMinusOne = addDays(firstDayOfMonth, -1);
+  if (isBefore(firstDayOfMonthMinusOne, minDate)) {
+    return true;
+  }
+  return false;
+}
+function isForwardDisabled(_ref4) {
+  var calendars = _ref4.calendars, maxDate = _ref4.maxDate;
+  if (!maxDate) {
+    return false;
+  }
+  var lastDayOfMonth = calendars[calendars.length - 1].lastDayOfMonth;
+  var lastDayOfMonthPlusOne = addDays(lastDayOfMonth, 1);
+  if (isBefore(maxDate, lastDayOfMonthPlusOne)) {
+    return true;
+  }
+  return false;
+}
+function getCalendars(_ref5) {
+  var date = _ref5.date, selected = _ref5.selected, monthsToDisplay = _ref5.monthsToDisplay, offset = _ref5.offset, minDate = _ref5.minDate, maxDate = _ref5.maxDate, firstDayOfWeek = _ref5.firstDayOfWeek, showOutsideDays = _ref5.showOutsideDays;
+  var months2 = [];
+  var startDate = getStartDate(date, minDate, maxDate);
+  for (var i2 = 0; i2 < monthsToDisplay; i2++) {
+    var calendarDates = getMonths({
+      month: startDate.getMonth() + i2 + offset,
+      year: startDate.getFullYear(),
+      selectedDates: selected,
+      minDate,
+      maxDate,
+      firstDayOfWeek,
+      showOutsideDays
+    });
+    months2.push(calendarDates);
+  }
+  return months2;
+}
+function getStartDate(date, minDate, maxDate) {
+  var startDate = startOfDay$1(date);
+  if (minDate) {
+    var minDateNormalized = startOfDay$1(minDate);
+    if (isBefore(startDate, minDateNormalized)) {
+      startDate = minDateNormalized;
+    }
+  }
+  if (maxDate) {
+    var maxDateNormalized = startOfDay$1(maxDate);
+    if (isBefore(maxDateNormalized, startDate)) {
+      startDate = maxDateNormalized;
+    }
+  }
+  return startDate;
+}
+function getMonths(_ref6) {
+  var month = _ref6.month, year = _ref6.year, selectedDates = _ref6.selectedDates, minDate = _ref6.minDate, maxDate = _ref6.maxDate, firstDayOfWeek = _ref6.firstDayOfWeek, showOutsideDays = _ref6.showOutsideDays;
+  var daysMonthYear = getNumDaysMonthYear(month, year);
+  var daysInMonth = daysMonthYear.daysInMonth;
+  month = daysMonthYear.month;
+  year = daysMonthYear.year;
+  var dates = [];
+  for (var day = 1; day <= daysInMonth; day++) {
+    var date = new Date(year, month, day);
+    var dateObj = {
+      date,
+      selected: isSelected(selectedDates, date),
+      selectable: isSelectable(minDate, maxDate, date),
+      today: isToday(date),
+      prevMonth: false,
+      nextMonth: false
+    };
+    dates.push(dateObj);
+  }
+  var firstDayOfMonth = new Date(year, month, 1);
+  var lastDayOfMonth = new Date(year, month, daysInMonth);
+  var frontWeekBuffer = fillFrontWeek({
+    firstDayOfMonth,
+    minDate,
+    maxDate,
+    selectedDates,
+    firstDayOfWeek,
+    showOutsideDays
+  });
+  var backWeekBuffer = fillBackWeek({
+    lastDayOfMonth,
+    minDate,
+    maxDate,
+    selectedDates,
+    firstDayOfWeek,
+    showOutsideDays
+  });
+  dates.unshift.apply(dates, frontWeekBuffer);
+  dates.push.apply(dates, backWeekBuffer);
+  var weeks = getWeeks(dates);
+  return {
+    firstDayOfMonth,
+    lastDayOfMonth,
+    month,
+    year,
+    weeks
+  };
+}
+function fillFrontWeek(_ref7) {
+  var firstDayOfMonth = _ref7.firstDayOfMonth, minDate = _ref7.minDate, maxDate = _ref7.maxDate, selectedDates = _ref7.selectedDates, firstDayOfWeek = _ref7.firstDayOfWeek, showOutsideDays = _ref7.showOutsideDays;
+  var dates = [];
+  var firstDay = (firstDayOfMonth.getDay() + 7 - firstDayOfWeek) % 7;
+  if (showOutsideDays) {
+    var lastDayOfPrevMonth = addDays(firstDayOfMonth, -1);
+    var prevDate = lastDayOfPrevMonth.getDate();
+    var prevDateMonth = lastDayOfPrevMonth.getMonth();
+    var prevDateYear = lastDayOfPrevMonth.getFullYear();
+    var counter = 0;
+    while (counter < firstDay) {
+      var date = new Date(prevDateYear, prevDateMonth, prevDate - counter);
+      var dateObj = {
+        date,
+        selected: isSelected(selectedDates, date),
+        selectable: isSelectable(minDate, maxDate, date),
+        today: false,
+        prevMonth: true,
+        nextMonth: false
+      };
+      dates.unshift(dateObj);
+      counter++;
+    }
+  } else {
+    while (firstDay > 0) {
+      dates.unshift("");
+      firstDay--;
+    }
+  }
+  return dates;
+}
+function fillBackWeek(_ref8) {
+  var lastDayOfMonth = _ref8.lastDayOfMonth, minDate = _ref8.minDate, maxDate = _ref8.maxDate, selectedDates = _ref8.selectedDates, firstDayOfWeek = _ref8.firstDayOfWeek, showOutsideDays = _ref8.showOutsideDays;
+  var dates = [];
+  var lastDay = (lastDayOfMonth.getDay() + 7 - firstDayOfWeek) % 7;
+  if (showOutsideDays) {
+    var firstDayOfNextMonth = addDays(lastDayOfMonth, 1);
+    var nextDateMonth = firstDayOfNextMonth.getMonth();
+    var nextDateYear = firstDayOfNextMonth.getFullYear();
+    var counter = 0;
+    while (counter < 6 - lastDay) {
+      var date = new Date(nextDateYear, nextDateMonth, 1 + counter);
+      var dateObj = {
+        date,
+        selected: isSelected(selectedDates, date),
+        selectable: isSelectable(minDate, maxDate, date),
+        today: false,
+        prevMonth: false,
+        nextMonth: true
+      };
+      dates.push(dateObj);
+      counter++;
+    }
+  } else {
+    while (lastDay < 6) {
+      dates.push("");
+      lastDay++;
+    }
+  }
+  return dates;
+}
+function getNumDaysMonthYear(month, year) {
+  var normalizedMonthYear = new Date(year, month, 1);
+  month = normalizedMonthYear.getMonth();
+  year = normalizedMonthYear.getFullYear();
+  var daysInMonth = 32 - new Date(year, month, 32).getDate();
+  return {
+    daysInMonth,
+    month,
+    year
+  };
+}
+function getWeeks(dates) {
+  var weeksLength = Math.ceil(dates.length / 7);
+  var weeks = [];
+  for (var i2 = 0; i2 < weeksLength; i2++) {
+    weeks[i2] = [];
+    for (var x2 = 0; x2 < 7; x2++) {
+      weeks[i2].push(dates[i2 * 7 + x2]);
+    }
+  }
+  return weeks;
+}
+function isSelected(selectedDates, date) {
+  selectedDates = Array.isArray(selectedDates) ? selectedDates : [selectedDates];
+  return selectedDates.some(function(selectedDate) {
+    if (selectedDate instanceof Date && startOfDay$1(selectedDate).getTime() === startOfDay$1(date).getTime()) {
+      return true;
+    }
+    return false;
+  });
+}
+function isSelectable(minDate, maxDate, date) {
+  if (minDate && isBefore(date, minDate) || maxDate && isBefore(maxDate, date)) {
+    return false;
+  }
+  return true;
+}
+function isOffsetControlled(propOffset) {
+  return propOffset !== void 0;
+}
+function getOffset(prop, state) {
+  return isOffsetControlled(prop) ? prop : state;
+}
+function getDateProps(onDateSelected, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp, onClick = _ref.onClick, _ref$dateObj = _ref.dateObj, dateObj = _ref$dateObj === void 0 ? requiredProp("getDateProps", "dateObj") : _ref$dateObj, rest = _objectWithoutPropertiesLoose(_ref, ["onClick", "dateObj"]);
+  return _extends({
+    onClick: composeEventHandlers(onClick, function(event) {
+      onDateSelected(dateObj, event);
+    }),
+    disabled: !dateObj.selectable,
+    "aria-label": dateObj.date.toDateString(),
+    "aria-pressed": dateObj.selected,
+    role: "button"
+  }, rest);
+}
+function getBackProps(_ref2, _temp2) {
+  var minDate = _ref2.minDate, offsetMonth = _ref2.offsetMonth, handleOffsetChanged = _ref2.handleOffsetChanged;
+  var _ref3 = _temp2 === void 0 ? {} : _temp2, onClick = _ref3.onClick, _ref3$offset = _ref3.offset, offset = _ref3$offset === void 0 ? 1 : _ref3$offset, _ref3$calendars = _ref3.calendars, calendars = _ref3$calendars === void 0 ? requiredProp("getBackProps", "calendars") : _ref3$calendars, rest = _objectWithoutPropertiesLoose(_ref3, ["onClick", "offset", "calendars"]);
+  return _extends({
+    onClick: composeEventHandlers(onClick, function() {
+      handleOffsetChanged(offsetMonth - subtractMonth({
+        calendars,
+        offset,
+        minDate
+      }));
+    }),
+    disabled: isBackDisabled({
+      calendars,
+      offset,
+      minDate
+    }),
+    "aria-label": "Go back " + offset + " month" + (offset === 1 ? "" : "s")
+  }, rest);
+}
+function getForwardProps(_ref4, _temp3) {
+  var maxDate = _ref4.maxDate, offsetMonth = _ref4.offsetMonth, handleOffsetChanged = _ref4.handleOffsetChanged;
+  var _ref5 = _temp3 === void 0 ? {} : _temp3, onClick = _ref5.onClick, _ref5$offset = _ref5.offset, offset = _ref5$offset === void 0 ? 1 : _ref5$offset, _ref5$calendars = _ref5.calendars, calendars = _ref5$calendars === void 0 ? requiredProp("getForwardProps", "calendars") : _ref5$calendars, rest = _objectWithoutPropertiesLoose(_ref5, ["onClick", "offset", "calendars"]);
+  return _extends({
+    onClick: composeEventHandlers(onClick, function() {
+      handleOffsetChanged(offsetMonth + addMonth({
+        calendars,
+        offset,
+        maxDate
+      }));
+    }),
+    disabled: isForwardDisabled({
+      calendars,
+      offset,
+      maxDate
+    }),
+    "aria-label": "Go forward " + offset + " month" + (offset === 1 ? "" : "s")
+  }, rest);
+}
+function useDayzed(_ref6) {
+  var _ref6$date = _ref6.date, date = _ref6$date === void 0 ? new Date() : _ref6$date, maxDate = _ref6.maxDate, minDate = _ref6.minDate, _ref6$monthsToDisplay = _ref6.monthsToDisplay, monthsToDisplay = _ref6$monthsToDisplay === void 0 ? 1 : _ref6$monthsToDisplay, _ref6$firstDayOfWeek = _ref6.firstDayOfWeek, firstDayOfWeek = _ref6$firstDayOfWeek === void 0 ? 0 : _ref6$firstDayOfWeek, _ref6$showOutsideDays = _ref6.showOutsideDays, showOutsideDays = _ref6$showOutsideDays === void 0 ? false : _ref6$showOutsideDays, offset = _ref6.offset, onDateSelected = _ref6.onDateSelected, _ref6$onOffsetChanged = _ref6.onOffsetChanged, onOffsetChanged = _ref6$onOffsetChanged === void 0 ? function() {
+  } : _ref6$onOffsetChanged, selected = _ref6.selected;
+  var _useState = require$$0.useState(0), stateOffset = _useState[0], setStateOffset = _useState[1];
+  var offsetMonth = getOffset(offset, stateOffset);
+  function handleOffsetChanged(newOffset) {
+    if (!isOffsetControlled(offset)) {
+      setStateOffset(newOffset);
+    }
+    onOffsetChanged(newOffset);
+  }
+  var calendars = getCalendars({
+    date,
+    selected,
+    monthsToDisplay,
+    minDate,
+    maxDate,
+    offset: offsetMonth,
+    firstDayOfWeek,
+    showOutsideDays
+  });
+  return {
+    calendars,
+    getDateProps: getDateProps.bind(null, onDateSelected),
+    getBackProps: getBackProps.bind(null, {
+      minDate,
+      offsetMonth,
+      handleOffsetChanged
+    }),
+    getForwardProps: getForwardProps.bind(null, {
+      maxDate,
+      offsetMonth,
+      handleOffsetChanged
+    })
+  };
+}
+({
+  render: PropTypes.func,
+  children: PropTypes.func,
+  date: PropTypes.instanceOf(Date),
+  maxDate: PropTypes.instanceOf(Date),
+  minDate: PropTypes.instanceOf(Date),
+  monthsToDisplay: PropTypes.number,
+  firstDayOfWeek: PropTypes.number,
+  showOutsideDays: PropTypes.bool,
+  offset: PropTypes.number,
+  onDateSelected: PropTypes.func.isRequired,
+  onOffsetChanged: PropTypes.func,
+  selected: PropTypes.oneOfType([PropTypes.arrayOf(Date), PropTypes.instanceOf(Date)])
+});
+function useCssVariables() {
+  const table = useTableContext();
+  return table.useState((state) => ({
+    "--spacing": state.theme.spacing,
+    "--primaryMain": state.theme.colors.primary.main,
+    "--primaryLight": state.theme.colors.primary.light,
+    "--primaryContrastText": state.theme.colors.primary.contrastText,
+    "--secondaryMain": state.theme.colors.secondary.main,
+    "--secondaryLight": state.theme.colors.secondary.light,
+    "--secondaryContrastText": state.theme.colors.secondary.contrastText
+  }));
+}
+const weekDays = [0, 1, 2, 3, 4, 5, 6];
+const months = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+const startOfDay = (d2) => new Date(d2.getFullYear(), d2.getMonth(), d2.getDate());
+const endOfDay = (d2) => new Date(d2.getFullYear(), d2.getMonth(), d2.getDate() + 1, 0, 0, 0, -1);
+const today = () => {
+  const today2 = startOfDay(new Date());
+  return {
+    min: today2,
+    max: today2
+  };
+};
+function dateIntersect(a2, b2) {
+  if (a2 instanceof Date) {
+    a2 = {
+      min: a2,
+      max: a2
+    };
+  }
+  if (b2 instanceof Date) {
+    b2 = {
+      min: b2,
+      max: b2
+    };
+  }
+  if (!(a2 == null ? void 0 : a2.min) || !a2.max || !(b2 == null ? void 0 : b2.min) || !b2.max) {
+    return false;
+  }
+  return !(endOfDay(a2.max) < startOfDay(b2.min) || startOfDay(a2.min) > endOfDay(b2.max));
+}
+function DatePicker({
+  value,
+  onChange,
+  rangeSelect,
+  locale,
+  firstDayOfWeek = 0
+}) {
+  const {
+    components: {
+      IconButton
+    },
+    icons: {
+      ChevronRight
+    }
+  } = useTheme();
+  const [baseDate] = require$$0.useState(new Date());
+  const [dateInView, setDateInView] = require$$0.useState(baseDate);
+  const [currentMin, setCurrentMin] = require$$0.useState();
+  const [hovered, setHovered] = require$$0.useState();
+  const min = currentMin != null ? currentMin : value instanceof Date ? value : value == null ? void 0 : value.min;
+  const max = currentMin ? void 0 : value instanceof Date ? value : value == null ? void 0 : value.max;
+  const {
+    calendars,
+    getBackProps: getBackProps2,
+    getForwardProps: getForwardProps2,
+    getDateProps: getDateProps2
+  } = useDayzed({
+    onDateSelected: () => void 0,
+    firstDayOfWeek,
+    showOutsideDays: true,
+    date: dateInView,
+    onOffsetChanged: (offset) => setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),
+    offset: 0
+  });
+  const formatWeekday = require$$0.useMemo(() => {
+    const {
+      format
+    } = new Intl.DateTimeFormat(locale, {
+      weekday: "short"
+    });
+    return (weekDay) => format(new Date(Date.UTC(2021, 5, weekDay)));
+  }, [locale]);
+  require$$0.useEffect(() => setDateInView(value === null ? new Date() : value instanceof Date ? value : value.max), [value]);
+  return tableTheme.jsx("div", {
+    children: calendars.map(({
+      month,
+      year,
+      weeks
+    }) => tableTheme.jsxs("div", {
+      children: [tableTheme.jsxs("div", {
+        css: {
+          margin: "calc(var(--spacing) * 4) 0",
+          display: "grid",
+          gridAutoFlow: "column",
+          justifyContent: "space-between",
+          alignItems: "center"
+        },
+        children: [tableTheme.jsx(IconButton, __spreadProps(__spreadValues({}, getBackProps2({
+          calendars
+        })), {
+          children: tableTheme.jsx(ChevronRight, {
+            css: {
+              transform: "rotate3d(0, 0, 1, 180deg)"
+            }
+          })
+        })), tableTheme.jsxs("div", {
+          css: {
+            display: "flex"
+          },
+          children: [tableTheme.jsx(MonthSelector, {
+            value: month,
+            onChange: (month2) => setDateInView(new Date(year, month2)),
+            locale
+          }), tableTheme.jsx(YearSelector, {
+            value: year,
+            onChange: (year2) => setDateInView(new Date(year2, month))
+          })]
+        }), tableTheme.jsx(IconButton, __spreadProps(__spreadValues({}, getForwardProps2({
+          calendars
+        })), {
+          children: tableTheme.jsx(ChevronRight, {})
+        }))]
+      }), tableTheme.jsxs("div", {
+        css: {
+          display: "grid",
+          gridTemplateColumns: "repeat(7, max-content)",
+          fontWeight: "bold"
+        },
+        children: [weekDays.map((_v, weekDay) => tableTheme.jsx("div", {
+          css: {
+            justifySelf: "center",
+            marginBottom: "var(--spacing)"
+          },
+          children: formatWeekday(weekDay)
+        }, weekDay)), weeks.map((week, index) => week.map((dateObj, dayIndex) => {
+          if (!dateObj) {
+            return tableTheme.jsx("div", {});
+          }
+          const {
+            prevMonth,
+            nextMonth,
+            date,
+            today: today2
+          } = dateObj;
+          const selected = date.getTime() === (min == null ? void 0 : min.getTime()) || min && max && dateIntersect(date, {
+            min,
+            max
+          });
+          const preSelected = !selected && (date.getTime() === (hovered == null ? void 0 : hovered.getTime()) || min && !max && hovered && dateIntersect(date, min <= hovered ? {
+            min,
+            max: hovered
+          } : {
+            min: hovered,
+            max: min
+          }));
+          return tableTheme.jsx("button", __spreadProps(__spreadValues({
+            css: [{
+              padding: 10,
+              border: "1px solid transparent",
+              background: "transparent",
+              cursor: "pointer"
+            }, (prevMonth || nextMonth) && {
+              color: tableTheme.gray
+            }, today2 && {
+              border: "1px solid var(--secondaryMain)"
+            }, selected && {
+              background: "var(--primaryMain)",
+              color: "var(--primaryContrastText)"
+            }, preSelected && {
+              background: "var(--primaryLight)",
+              color: "var(--primaryContrastText)"
+            }]
+          }, getDateProps2({
+            dateObj
+          })), {
+            onClick: () => {
+              if (!rangeSelect) {
+                setCurrentMin(void 0);
+                onChange(date);
+              } else if (min && !max) {
+                setCurrentMin(void 0);
+                if (date > min) {
+                  onChange({
+                    min,
+                    max: date
+                  });
+                } else {
+                  onChange({
+                    min: date,
+                    max: min
+                  });
+                }
+              } else {
+                setCurrentMin(date);
+              }
+            },
+            onPointerOver: () => setHovered(date),
+            onPointerOut: () => setHovered(void 0),
+            children: date.getDate()
+          }), `${index}-${dayIndex}`);
+        }))]
+      })]
+    }, `${month}${year}`))
+  });
+}
+function MonthSelector({
+  value,
+  onChange,
+  locale
+}) {
+  const {
+    components: {
+      Popover
+    }
+  } = useTheme();
+  const cssVariables = useCssVariables();
+  const [anchor, setAnchor] = require$$0.useState();
+  const formatMonth = require$$0.useMemo(() => {
+    const {
+      format
+    } = new Intl.DateTimeFormat(locale, {
+      month: "long"
+    });
+    return (month) => format(new Date(2021, month));
+  }, [locale]);
+  return tableTheme.jsxs(tableTheme.Fragment, {
+    children: [tableTheme.jsx("button", {
+      css: {
+        border: "none",
+        background: "transparent",
+        fontSize: "inherit",
+        cursor: "pointer"
+      },
+      onClick: (e2) => setAnchor(e2.currentTarget),
+      children: formatMonth(value)
+    }), tableTheme.jsx(Popover, {
+      open: !!anchor,
+      anchorEl: anchor != null ? anchor : null,
+      onClose: () => setAnchor(void 0),
+      align: "center",
+      css: cssVariables,
+      children: tableTheme.jsx("div", {
+        css: {
+          display: "grid"
+        },
+        children: months.map((month) => tableTheme.jsx("button", {
+          css: [{
+            padding: "var(--spacing)",
+            border: "none",
+            background: "transparent",
+            "&:hover": {
+              background: "var(--primaryLight)"
+            }
+          }, month === value && {
+            background: "var(--primaryMain)"
+          }],
+          onClick: () => onChange(month),
+          children: formatMonth(month)
+        }, month))
+      })
+    })]
+  });
+}
+function YearSelector({
+  value,
+  onChange,
+  locale
+}) {
+  const [input, setInput] = require$$0.useState();
+  function apply() {
+    onChange(Number(input));
+    setInput(void 0);
+  }
+  const formatYear = require$$0.useMemo(() => {
+    const {
+      format
+    } = new Intl.DateTimeFormat(locale, {
+      year: "numeric"
+    });
+    return (year) => format(new Date(year, 0, 1));
+  }, [locale]);
+  if (input === void 0) {
+    return tableTheme.jsx("div", {
+      onClick: () => setInput(String(value)),
+      children: formatYear(value)
+    });
+  }
+  return tableTheme.jsx("input", {
+    css: {
+      width: "4ch"
+    },
+    value: input,
+    onChange: (e2) => {
+      if (e2.target.value.match(/^\d{0,4}$/)) {
+        setInput(e2.target.value);
+      }
+    },
+    onBlur: apply,
+    onKeyPress: (e2) => e2.key === "Enter" && apply()
+  });
+}
+function convertDate(x2) {
+  if (x2 instanceof Date)
+    return x2;
+  if (typeof x2 === "number" || typeof x2 === "string")
+    return new Date(x2);
+  return null;
+}
+function convertDateOrRange(x2) {
+  if (x2 instanceof Object && "min" in x2 && "max" in x2) {
+    const range = {
+      min: convertDate(x2.min),
+      max: convertDate(x2.max)
+    };
+    return range.min && range.max ? range : null;
+  }
+  return convertDate(x2);
+}
+function convertDateOrArray(x2) {
+  if (x2 instanceof Array)
+    return x2.map(convertDateOrRange).filter(Boolean);
+  return convertDateOrRange(x2);
+}
+function DateFilter(_a) {
+  var _b = _a, {
+    locale,
+    firstDayOfWeek,
+    singleSelect,
+    filterBy = convertDateOrArray
+  } = _b, props = __objRest(_b, [
+    "locale",
+    "firstDayOfWeek",
+    "singleSelect",
+    "filterBy"
+  ]);
+  const {
+    components: {
+      Button
+    },
+    text
+  } = useTheme();
+  const {
+    value = null,
+    onChange
+  } = useFilter(__spreadProps(__spreadValues({}, props), {
+    filterBy,
+    id: "dateFilter",
+    isActive(filterValue) {
+      return !!filterValue;
+    },
+    test(filterValue, value2) {
+      return dateIntersect(filterValue, value2);
+    }
+  }));
+  const formatDate = require$$0.useMemo(() => {
+    const {
+      format
+    } = new Intl.DateTimeFormat(locale, {
+      dateStyle: "medium"
+    });
+    return format;
+  }, [locale]);
+  return tableTheme.jsxs("div", {
+    css: {
+      padding: "calc(var(--spacing) * 2)",
+      display: "grid",
+      gap: "var(--spacing)",
+      justifyItems: "center"
+    },
+    children: [tableTheme.jsxs("div", {
+      css: {
+        marginBottom: "var(--spacing)",
+        display: "grid",
+        gridAutoFlow: "column",
+        gap: "calc(var(--spacing) * 4)",
+        justifyContent: "space-between",
+        alignItems: "center"
+      },
+      children: [tableTheme.jsx("div", {
+        css: {
+          minWidth: "22ch"
+        },
+        children: !value ? text.dateFilter : value instanceof Date ? formatDate(value) : [formatDate(value.min), formatDate(value.max)].join(" - ")
+      }), tableTheme.jsxs("div", {
+        css: {
+          display: "grid",
+          gridAutoFlow: "column",
+          gap: "var(--spacing)"
+        },
+        children: [tableTheme.jsx(Button, {
+          variant: "contained",
+          onClick: () => onChange(today()),
+          children: text.today
+        }), tableTheme.jsx(Button, {
+          variant: "contained",
+          onClick: () => onChange(null),
+          children: text.reset
+        })]
+      })]
+    }), tableTheme.jsx(DatePicker, {
+      rangeSelect: !singleSelect,
+      value,
+      onChange,
+      locale,
+      firstDayOfWeek
+    })]
+  });
+}
+const flatMap = (arr, flatMap2) => {
+  return [...arr].reduce((out, cur) => out.concat(flatMap2(cur)), []);
+};
+const orderBy = (arr, selectors = [], direction = []) => {
+  if (selectors.length === 0)
+    selectors = [(t2) => t2];
+  return [...arr].sort((a2, b2) => {
+    var _a, _b;
+    for (let i2 = 0; i2 < selectors.length; i2++) {
+      const _a2 = (_a = selectors[i2]) == null ? void 0 : _a.call(selectors, a2);
+      const _b2 = (_b = selectors[i2]) == null ? void 0 : _b.call(selectors, b2);
+      const dir = direction[i2] === "desc" ? -1 : 1;
+      if (_a2 > _b2)
+        return dir;
+      if (_a2 < _b2)
+        return -dir;
+    }
+    return 0;
+  });
+};
+const uniq = (arr) => {
+  const set = /* @__PURE__ */ new Set();
+  for (const t2 of arr)
+    set.add(t2);
+  return [...set.values()];
+};
+const intersect = (a2, b2) => {
+  const result = /* @__PURE__ */ new Set();
+  for (const x2 of a2)
+    if (b2.has(x2))
+      result.add(x2);
+  return result;
+};
+const getAncestors = (activeItemsById, ...items) => {
+  const result = /* @__PURE__ */ new Set();
+  const find = ({ parentId }) => {
+    const parent = parentId ? activeItemsById.get(parentId) : void 0;
+    if (parent && !result.has(parent.id)) {
+      result.add(parent.id);
+      find(parent);
+    }
+  };
+  items.forEach(find);
+  return result;
+};
+const getDescendants = (...items) => {
+  const result = /* @__PURE__ */ new Set();
+  const find = (item) => {
+    for (const child of item.children) {
+      if (!result.has(child.id)) {
+        result.add(child.id);
+        find(child);
+      }
+    }
+  };
+  items.forEach(find);
+  return result;
+};
+const asString = (x2) => {
+  if (x2 instanceof Array)
+    return x2.map(asString).join(", ");
+  if (x2 instanceof Object)
+    return JSON.stringify(x2);
+  return String(x2 != null ? x2 : "");
+};
+const asStringOrArray = (x2) => {
+  if (x2 instanceof Array)
+    return x2.map(asString);
+  return asString(x2);
+};
+const castArray = (a2) => a2 instanceof Array ? a2 : [a2];
+function FormControlLabel({
+  control,
+  label
+}) {
+  return tableTheme.jsxs("label", {
+    css: {
+      display: "flex",
+      alignItems: "center",
+      cursor: "pointer",
+      userSelect: "none",
+      "& > *": {
+        cursor: "pointer"
+      }
+    },
+    children: [control, tableTheme.jsx("span", {
+      css: {
+        marginLeft: "var(--spacing)"
+      },
+      children: label
+    })]
+  });
+}
+class Queue {
+  constructor() {
+    this.q = new Array();
+    this.isRunning = false;
+  }
+  run(job, replace) {
+    return new Promise((resolve, reject) => {
+      if (replace) {
+        this.q = [];
+      }
+      this.q.push({ job, resolve, reject });
+      if (!this.isRunning)
+        this.start();
+    });
+  }
+  async start() {
+    this.isRunning = true;
+    let next;
+    while (next = this.q.shift()) {
+      try {
+        const result = await next.job();
+        next.resolve(result);
+      } catch (e2) {
+        next.reject(e2);
+      }
+    }
+    this.isRunning = false;
+  }
+}
+const KEYS = ["sort", "selection", "expanded", "hiddenColumns", "filterValues", "columnWidths", "columnOrder"];
+function stringify(value) {
+  function prepare(value2) {
+    if (value2 instanceof Date) {
+      return { __date: value2.toJSON() };
+    }
+    if (value2 instanceof Set) {
+      return { __set: Array.from(value2).map(prepare) };
+    }
+    if (value2 instanceof Map) {
+      return { __map: Array.from(value2.entries()).map((entry) => entry.map(prepare)) };
+    }
+    if (value2 instanceof Array) {
+      return value2.map(prepare);
+    }
+    if (value2 instanceof Object) {
+      return Object.fromEntries(Object.entries(value2).map(([k2, v2]) => [k2, prepare(v2)]));
+    }
+    return value2;
+  }
+  return JSON.stringify(prepare(value));
+}
+function parse(value) {
+  return JSON.parse(value, (_key, value2) => {
+    if (value2 instanceof Object && "__date" in value2) {
+      return new Date(value2.__date);
+    }
+    if (value2 instanceof Object && "__set" in value2) {
+      return new Set(value2.__set);
+    }
+    if (value2 instanceof Object && "__map" in value2) {
+      return new Map(value2.__map);
+    }
+    return value2;
+  });
+}
+function useTableStateStorage() {
+  const table = useTableContext();
+  const [isHydrated, setIsHydrated] = require$$0.useState(false);
+  require$$0.useEffect(() => {
+    const { persist } = table.getState().props;
+    if (!persist) {
+      setIsHydrated(true);
+      return;
+    }
+    let isCanceled = false;
+    (async () => {
+      var _a, _b;
+      try {
+        const { storage, id = "table", include, exclude } = persist;
+        const json = await storage.getItem(`${id}_state`);
+        if (isCanceled || !json)
+          return;
+        const data = parse(json);
+        (_b = (_a = table.getState().props).debug) == null ? void 0 : _b.call(_a, "load", json, data);
+        table.update((state) => {
+          var _a2, _b2, _c, _d;
+          for (const key of KEYS) {
+            if ((!include || include.includes(key)) && !(exclude == null ? void 0 : exclude.includes(key)) && key in data) {
+              if (key === "filterValues") {
+                for (const [id2, value] of data[key]) {
+                  if ((_b2 = (_a2 = state.filters.get(id2)) == null ? void 0 : _a2.persist) != null ? _b2 : true) {
+                    state.filterValues.set(id2, value);
+                  }
+                }
+              } else {
+                state[key] = data[key];
+                if (key === "expanded" || key === "hiddenColumns" || key === "selection" || key === "sort") {
+                  (_d = (_c = state.props)[`on${key.slice(0, 1).toUpperCase() + key.slice(1)}Change`]) == null ? void 0 : _d.call(_c, data[key]);
+                }
+              }
+            }
+          }
+        });
+      } catch (e2) {
+        console.error("Failed to load table state:", e2);
+      } finally {
+        setIsHydrated(true);
+      }
+    })();
+    return () => {
+      isCanceled = true;
+    };
+  }, []);
+  require$$0.useEffect(() => {
+    if (!isHydrated)
+      return;
+    const q2 = new Queue();
+    return table.subscribe((state) => {
+      var _a, _b;
+      if (!state.props.persist)
+        return;
+      const { storage, id = "table", include, exclude } = state.props.persist;
+      const data = {};
+      for (const key of KEYS) {
+        if ((!include || include.includes(key)) && !(exclude == null ? void 0 : exclude.includes(key))) {
+          if (key === "filterValues") {
+            data[key] = /* @__PURE__ */ new Map();
+            for (const [id2, value] of state.filterValues) {
+              if ((_b = (_a = state.filters.get(id2)) == null ? void 0 : _a.persist) != null ? _b : true) {
+                data.filterValues.set(id2, value);
+              }
+            }
+          } else {
+            data[key] = state[key];
+          }
+        }
+      }
+      return { storage, id, data };
+    }, (props) => {
+      var _a, _b;
+      if (!props)
+        return;
+      const { storage, id, data } = props;
+      (_b = (_a = table.getState().props).debug) == null ? void 0 : _b.call(_a, "save", data, stringify(data));
+      q2.run(async () => {
+        await storage.setItem(`${id}_state`, stringify(data));
+      }, true);
+    }, { throttle: 1e3 });
+  }, [isHydrated]);
+  return isHydrated;
+}
+function n$2(n2) {
+  for (var r2 = arguments.length, t2 = Array(r2 > 1 ? r2 - 1 : 0), e2 = 1; e2 < r2; e2++)
+    t2[e2 - 1] = arguments[e2];
+  throw Error("[Immer] minified error nr: " + n2 + (t2.length ? " " + t2.map(function(n3) {
+    return "'" + n3 + "'";
+  }).join(",") : "") + ". Find the full error at: https://bit.ly/3cXEKWf");
+}
+function r$2(n2) {
+  return !!n2 && !!n2[Q];
+}
+function t$2(n2) {
+  return !!n2 && (function(n3) {
+    if (!n3 || typeof n3 != "object")
+      return false;
+    var r2 = Object.getPrototypeOf(n3);
+    if (r2 === null)
+      return true;
+    var t2 = Object.hasOwnProperty.call(r2, "constructor") && r2.constructor;
+    return t2 === Object || typeof t2 == "function" && Function.toString.call(t2) === Z;
+  }(n2) || Array.isArray(n2) || !!n2[L] || !!n2.constructor[L] || s(n2) || v$1(n2));
+}
+function i(n2, r2, t2) {
+  t2 === void 0 && (t2 = false), o(n2) === 0 ? (t2 ? Object.keys : nn)(n2).forEach(function(e2) {
+    t2 && typeof e2 == "symbol" || r2(e2, n2[e2], n2);
+  }) : n2.forEach(function(t3, e2) {
+    return r2(e2, t3, n2);
+  });
+}
+function o(n2) {
+  var r2 = n2[Q];
+  return r2 ? r2.i > 3 ? r2.i - 4 : r2.i : Array.isArray(n2) ? 1 : s(n2) ? 2 : v$1(n2) ? 3 : 0;
+}
+function u$2(n2, r2) {
+  return o(n2) === 2 ? n2.has(r2) : Object.prototype.hasOwnProperty.call(n2, r2);
+}
+function a(n2, r2) {
+  return o(n2) === 2 ? n2.get(r2) : n2[r2];
+}
+function f(n2, r2, t2) {
+  var e2 = o(n2);
+  e2 === 2 ? n2.set(r2, t2) : e2 === 3 ? (n2.delete(r2), n2.add(t2)) : n2[r2] = t2;
+}
+function c(n2, r2) {
+  return n2 === r2 ? n2 !== 0 || 1 / n2 == 1 / r2 : n2 != n2 && r2 != r2;
+}
+function s(n2) {
+  return X && n2 instanceof Map;
+}
+function v$1(n2) {
+  return q$2 && n2 instanceof Set;
+}
+function p$2(n2) {
+  return n2.o || n2.t;
+}
+function l$1(n2) {
+  if (Array.isArray(n2))
+    return Array.prototype.slice.call(n2);
+  var r2 = rn(n2);
+  delete r2[Q];
+  for (var t2 = nn(r2), e2 = 0; e2 < t2.length; e2++) {
+    var i2 = t2[e2], o2 = r2[i2];
+    o2.writable === false && (o2.writable = true, o2.configurable = true), (o2.get || o2.set) && (r2[i2] = { configurable: true, writable: true, enumerable: o2.enumerable, value: n2[i2] });
+  }
+  return Object.create(Object.getPrototypeOf(n2), r2);
+}
+function d(n2, e2) {
+  return e2 === void 0 && (e2 = false), y(n2) || r$2(n2) || !t$2(n2) ? n2 : (o(n2) > 1 && (n2.set = n2.add = n2.clear = n2.delete = h$2), Object.freeze(n2), e2 && i(n2, function(n3, r2) {
+    return d(r2, true);
+  }, true), n2);
+}
+function h$2() {
+  n$2(2);
+}
+function y(n2) {
+  return n2 == null || typeof n2 != "object" || Object.isFrozen(n2);
+}
+function b(r2) {
+  var t2 = tn[r2];
+  return t2 || n$2(18, r2), t2;
+}
+function m$1(n2, r2) {
+  tn[n2] || (tn[n2] = r2);
+}
+function _() {
+  return U;
+}
+function j(n2, r2) {
+  r2 && (b("Patches"), n2.u = [], n2.s = [], n2.v = r2);
+}
+function O(n2) {
+  g(n2), n2.p.forEach(S), n2.p = null;
+}
+function g(n2) {
+  n2 === U && (U = n2.l);
+}
+function w$1(n2) {
+  return U = { p: [], l: U, h: n2, m: true, _: 0 };
+}
+function S(n2) {
+  var r2 = n2[Q];
+  r2.i === 0 || r2.i === 1 ? r2.j() : r2.O = true;
+}
+function P(r2, e2) {
+  e2._ = e2.p.length;
+  var i2 = e2.p[0], o2 = r2 !== void 0 && r2 !== i2;
+  return e2.h.g || b("ES5").S(e2, r2, o2), o2 ? (i2[Q].P && (O(e2), n$2(4)), t$2(r2) && (r2 = M(e2, r2), e2.l || x(e2, r2)), e2.u && b("Patches").M(i2[Q].t, r2, e2.u, e2.s)) : r2 = M(e2, i2, []), O(e2), e2.u && e2.v(e2.u, e2.s), r2 !== H ? r2 : void 0;
+}
+function M(n2, r2, t2) {
+  if (y(r2))
+    return r2;
+  var e2 = r2[Q];
+  if (!e2)
+    return i(r2, function(i2, o3) {
+      return A(n2, e2, r2, i2, o3, t2);
+    }, true), r2;
+  if (e2.A !== n2)
+    return r2;
+  if (!e2.P)
+    return x(n2, e2.t, true), e2.t;
+  if (!e2.I) {
+    e2.I = true, e2.A._--;
+    var o2 = e2.i === 4 || e2.i === 5 ? e2.o = l$1(e2.k) : e2.o;
+    i(e2.i === 3 ? new Set(o2) : o2, function(r3, i2) {
+      return A(n2, e2, o2, r3, i2, t2);
+    }), x(n2, o2, false), t2 && n2.u && b("Patches").R(e2, t2, n2.u, n2.s);
+  }
+  return e2.o;
+}
+function A(e2, i2, o2, a2, c2, s2) {
+  if (r$2(c2)) {
+    var v2 = M(e2, c2, s2 && i2 && i2.i !== 3 && !u$2(i2.D, a2) ? s2.concat(a2) : void 0);
+    if (f(o2, a2, v2), !r$2(v2))
+      return;
+    e2.m = false;
+  }
+  if (t$2(c2) && !y(c2)) {
+    if (!e2.h.F && e2._ < 1)
+      return;
+    M(e2, c2), i2 && i2.A.l || x(e2, c2);
+  }
+}
+function x(n2, r2, t2) {
+  t2 === void 0 && (t2 = false), n2.h.F && n2.m && d(r2, t2);
+}
+function z(n2, r2) {
+  var t2 = n2[Q];
+  return (t2 ? p$2(t2) : n2)[r2];
+}
+function I(n2, r2) {
+  if (r2 in n2)
+    for (var t2 = Object.getPrototypeOf(n2); t2; ) {
+      var e2 = Object.getOwnPropertyDescriptor(t2, r2);
+      if (e2)
+        return e2;
+      t2 = Object.getPrototypeOf(t2);
+    }
+}
+function k$1(n2) {
+  n2.P || (n2.P = true, n2.l && k$1(n2.l));
+}
+function E(n2) {
+  n2.o || (n2.o = l$1(n2.t));
+}
+function R(n2, r2, t2) {
+  var e2 = s(r2) ? b("MapSet").N(r2, t2) : v$1(r2) ? b("MapSet").T(r2, t2) : n2.g ? function(n3, r3) {
+    var t3 = Array.isArray(n3), e3 = { i: t3 ? 1 : 0, A: r3 ? r3.A : _(), P: false, I: false, D: {}, l: r3, t: n3, k: null, o: null, j: null, C: false }, i2 = e3, o2 = en;
+    t3 && (i2 = [e3], o2 = on);
+    var u2 = Proxy.revocable(i2, o2), a2 = u2.revoke, f2 = u2.proxy;
+    return e3.k = f2, e3.j = a2, f2;
+  }(r2, t2) : b("ES5").J(r2, t2);
+  return (t2 ? t2.A : _()).p.push(e2), e2;
+}
+function D(e2) {
+  return r$2(e2) || n$2(22, e2), function n2(r2) {
+    if (!t$2(r2))
+      return r2;
+    var e3, u2 = r2[Q], c2 = o(r2);
+    if (u2) {
+      if (!u2.P && (u2.i < 4 || !b("ES5").K(u2)))
+        return u2.t;
+      u2.I = true, e3 = F(r2, c2), u2.I = false;
+    } else
+      e3 = F(r2, c2);
+    return i(e3, function(r3, t2) {
+      u2 && a(u2.t, r3) === t2 || f(e3, r3, n2(t2));
+    }), c2 === 3 ? new Set(e3) : e3;
+  }(e2);
+}
+function F(n2, r2) {
+  switch (r2) {
+    case 2:
+      return new Map(n2);
+    case 3:
+      return Array.from(n2);
+  }
+  return l$1(n2);
+}
+function T() {
+  function e2(n2) {
+    if (!t$2(n2))
+      return n2;
+    if (Array.isArray(n2))
+      return n2.map(e2);
+    if (s(n2))
+      return new Map(Array.from(n2.entries()).map(function(n3) {
+        return [n3[0], e2(n3[1])];
+      }));
+    if (v$1(n2))
+      return new Set(Array.from(n2).map(e2));
+    var r2 = Object.create(Object.getPrototypeOf(n2));
+    for (var i2 in n2)
+      r2[i2] = e2(n2[i2]);
+    return u$2(n2, L) && (r2[L] = n2[L]), r2;
+  }
+  function f2(n2) {
+    return r$2(n2) ? e2(n2) : n2;
+  }
+  var c2 = "add";
+  m$1("Patches", { $: function(r2, t2) {
+    return t2.forEach(function(t3) {
+      for (var i2 = t3.path, u2 = t3.op, f3 = r2, s2 = 0; s2 < i2.length - 1; s2++) {
+        var v2 = o(f3), p2 = "" + i2[s2];
+        v2 !== 0 && v2 !== 1 || p2 !== "__proto__" && p2 !== "constructor" || n$2(24), typeof f3 == "function" && p2 === "prototype" && n$2(24), typeof (f3 = a(f3, p2)) != "object" && n$2(15, i2.join("/"));
+      }
+      var l2 = o(f3), d2 = e2(t3.value), h2 = i2[i2.length - 1];
+      switch (u2) {
+        case "replace":
+          switch (l2) {
+            case 2:
+              return f3.set(h2, d2);
+            case 3:
+              n$2(16);
+            default:
+              return f3[h2] = d2;
+          }
+        case c2:
+          switch (l2) {
+            case 1:
+              return h2 === "-" ? f3.push(d2) : f3.splice(h2, 0, d2);
+            case 2:
+              return f3.set(h2, d2);
+            case 3:
+              return f3.add(d2);
+            default:
+              return f3[h2] = d2;
+          }
+        case "remove":
+          switch (l2) {
+            case 1:
+              return f3.splice(h2, 1);
+            case 2:
+              return f3.delete(h2);
+            case 3:
+              return f3.delete(t3.value);
+            default:
+              return delete f3[h2];
+          }
+        default:
+          n$2(17, u2);
+      }
+    }), r2;
+  }, R: function(n2, r2, t2, e3) {
+    switch (n2.i) {
+      case 0:
+      case 4:
+      case 2:
+        return function(n3, r3, t3, e4) {
+          var o2 = n3.t, s2 = n3.o;
+          i(n3.D, function(n4, i2) {
+            var v2 = a(o2, n4), p2 = a(s2, n4), l2 = i2 ? u$2(o2, n4) ? "replace" : c2 : "remove";
+            if (v2 !== p2 || l2 !== "replace") {
+              var d2 = r3.concat(n4);
+              t3.push(l2 === "remove" ? { op: l2, path: d2 } : { op: l2, path: d2, value: p2 }), e4.push(l2 === c2 ? { op: "remove", path: d2 } : l2 === "remove" ? { op: c2, path: d2, value: f2(v2) } : { op: "replace", path: d2, value: f2(v2) });
+            }
+          });
+        }(n2, r2, t2, e3);
+      case 5:
+      case 1:
+        return function(n3, r3, t3, e4) {
+          var i2 = n3.t, o2 = n3.D, u2 = n3.o;
+          if (u2.length < i2.length) {
+            var a2 = [u2, i2];
+            i2 = a2[0], u2 = a2[1];
+            var s2 = [e4, t3];
+            t3 = s2[0], e4 = s2[1];
+          }
+          for (var v2 = 0; v2 < i2.length; v2++)
+            if (o2[v2] && u2[v2] !== i2[v2]) {
+              var p2 = r3.concat([v2]);
+              t3.push({ op: "replace", path: p2, value: f2(u2[v2]) }), e4.push({ op: "replace", path: p2, value: f2(i2[v2]) });
+            }
+          for (var l2 = i2.length; l2 < u2.length; l2++) {
+            var d2 = r3.concat([l2]);
+            t3.push({ op: c2, path: d2, value: f2(u2[l2]) });
+          }
+          i2.length < u2.length && e4.push({ op: "replace", path: r3.concat(["length"]), value: i2.length });
+        }(n2, r2, t2, e3);
+      case 3:
+        return function(n3, r3, t3, e4) {
+          var i2 = n3.t, o2 = n3.o, u2 = 0;
+          i2.forEach(function(n4) {
+            if (!o2.has(n4)) {
+              var i3 = r3.concat([u2]);
+              t3.push({ op: "remove", path: i3, value: n4 }), e4.unshift({ op: c2, path: i3, value: n4 });
+            }
+            u2++;
+          }), u2 = 0, o2.forEach(function(n4) {
+            if (!i2.has(n4)) {
+              var o3 = r3.concat([u2]);
+              t3.push({ op: c2, path: o3, value: n4 }), e4.unshift({ op: "remove", path: o3, value: n4 });
+            }
+            u2++;
+          });
+        }(n2, r2, t2, e3);
+    }
+  }, M: function(n2, r2, t2, e3) {
+    t2.push({ op: "replace", path: [], value: r2 === H ? void 0 : r2 }), e3.push({ op: "replace", path: [], value: n2 });
+  } });
+}
+function C() {
+  function r2(n2, r3) {
+    function t2() {
+      this.constructor = n2;
+    }
+    a2(n2, r3), n2.prototype = (t2.prototype = r3.prototype, new t2());
+  }
+  function e2(n2) {
+    n2.o || (n2.D = /* @__PURE__ */ new Map(), n2.o = new Map(n2.t));
+  }
+  function o2(n2) {
+    n2.o || (n2.o = /* @__PURE__ */ new Set(), n2.t.forEach(function(r3) {
+      if (t$2(r3)) {
+        var e3 = R(n2.A.h, r3, n2);
+        n2.p.set(r3, e3), n2.o.add(e3);
+      } else
+        n2.o.add(r3);
+    }));
+  }
+  function u2(r3) {
+    r3.O && n$2(3, JSON.stringify(p$2(r3)));
+  }
+  var a2 = function(n2, r3) {
+    return (a2 = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(n3, r4) {
+      n3.__proto__ = r4;
+    } || function(n3, r4) {
+      for (var t2 in r4)
+        r4.hasOwnProperty(t2) && (n3[t2] = r4[t2]);
+    })(n2, r3);
+  }, f2 = function() {
+    function n2(n3, r3) {
+      return this[Q] = { i: 2, l: r3, A: r3 ? r3.A : _(), P: false, I: false, o: void 0, D: void 0, t: n3, k: this, C: false, O: false }, this;
+    }
+    r2(n2, Map);
+    var o3 = n2.prototype;
+    return Object.defineProperty(o3, "size", { get: function() {
+      return p$2(this[Q]).size;
+    } }), o3.has = function(n3) {
+      return p$2(this[Q]).has(n3);
+    }, o3.set = function(n3, r3) {
+      var t2 = this[Q];
+      return u2(t2), p$2(t2).has(n3) && p$2(t2).get(n3) === r3 || (e2(t2), k$1(t2), t2.D.set(n3, true), t2.o.set(n3, r3), t2.D.set(n3, true)), this;
+    }, o3.delete = function(n3) {
+      if (!this.has(n3))
+        return false;
+      var r3 = this[Q];
+      return u2(r3), e2(r3), k$1(r3), r3.t.has(n3) ? r3.D.set(n3, false) : r3.D.delete(n3), r3.o.delete(n3), true;
+    }, o3.clear = function() {
+      var n3 = this[Q];
+      u2(n3), p$2(n3).size && (e2(n3), k$1(n3), n3.D = /* @__PURE__ */ new Map(), i(n3.t, function(r3) {
+        n3.D.set(r3, false);
+      }), n3.o.clear());
+    }, o3.forEach = function(n3, r3) {
+      var t2 = this;
+      p$2(this[Q]).forEach(function(e3, i2) {
+        n3.call(r3, t2.get(i2), i2, t2);
+      });
+    }, o3.get = function(n3) {
+      var r3 = this[Q];
+      u2(r3);
+      var i2 = p$2(r3).get(n3);
+      if (r3.I || !t$2(i2))
+        return i2;
+      if (i2 !== r3.t.get(n3))
+        return i2;
+      var o4 = R(r3.A.h, i2, r3);
+      return e2(r3), r3.o.set(n3, o4), o4;
+    }, o3.keys = function() {
+      return p$2(this[Q]).keys();
+    }, o3.values = function() {
+      var n3, r3 = this, t2 = this.keys();
+      return (n3 = {})[V] = function() {
+        return r3.values();
+      }, n3.next = function() {
+        var n4 = t2.next();
+        return n4.done ? n4 : { done: false, value: r3.get(n4.value) };
+      }, n3;
+    }, o3.entries = function() {
+      var n3, r3 = this, t2 = this.keys();
+      return (n3 = {})[V] = function() {
+        return r3.entries();
+      }, n3.next = function() {
+        var n4 = t2.next();
+        if (n4.done)
+          return n4;
+        var e3 = r3.get(n4.value);
+        return { done: false, value: [n4.value, e3] };
+      }, n3;
+    }, o3[V] = function() {
+      return this.entries();
+    }, n2;
+  }(), c2 = function() {
+    function n2(n3, r3) {
+      return this[Q] = { i: 3, l: r3, A: r3 ? r3.A : _(), P: false, I: false, o: void 0, t: n3, k: this, p: /* @__PURE__ */ new Map(), O: false, C: false }, this;
+    }
+    r2(n2, Set);
+    var t2 = n2.prototype;
+    return Object.defineProperty(t2, "size", { get: function() {
+      return p$2(this[Q]).size;
+    } }), t2.has = function(n3) {
+      var r3 = this[Q];
+      return u2(r3), r3.o ? !!r3.o.has(n3) || !(!r3.p.has(n3) || !r3.o.has(r3.p.get(n3))) : r3.t.has(n3);
+    }, t2.add = function(n3) {
+      var r3 = this[Q];
+      return u2(r3), this.has(n3) || (o2(r3), k$1(r3), r3.o.add(n3)), this;
+    }, t2.delete = function(n3) {
+      if (!this.has(n3))
+        return false;
+      var r3 = this[Q];
+      return u2(r3), o2(r3), k$1(r3), r3.o.delete(n3) || !!r3.p.has(n3) && r3.o.delete(r3.p.get(n3));
+    }, t2.clear = function() {
+      var n3 = this[Q];
+      u2(n3), p$2(n3).size && (o2(n3), k$1(n3), n3.o.clear());
+    }, t2.values = function() {
+      var n3 = this[Q];
+      return u2(n3), o2(n3), n3.o.values();
+    }, t2.entries = function() {
+      var n3 = this[Q];
+      return u2(n3), o2(n3), n3.o.entries();
+    }, t2.keys = function() {
+      return this.values();
+    }, t2[V] = function() {
+      return this.values();
+    }, t2.forEach = function(n3, r3) {
+      for (var t3 = this.values(), e3 = t3.next(); !e3.done; )
+        n3.call(r3, e3.value, e3.value, this), e3 = t3.next();
+    }, n2;
+  }();
+  m$1("MapSet", { N: function(n2, r3) {
+    return new f2(n2, r3);
+  }, T: function(n2, r3) {
+    return new c2(n2, r3);
+  } });
+}
+function K(n2) {
+  return n2;
+}
+var G, U, W = typeof Symbol != "undefined" && typeof Symbol("x") == "symbol", X = typeof Map != "undefined", q$2 = typeof Set != "undefined", B = typeof Proxy != "undefined" && Proxy.revocable !== void 0 && typeof Reflect != "undefined", H = W ? Symbol.for("immer-nothing") : ((G = {})["immer-nothing"] = true, G), L = W ? Symbol.for("immer-draftable") : "__$immer_draftable", Q = W ? Symbol.for("immer-state") : "__$immer_state", V = typeof Symbol != "undefined" && Symbol.iterator || "@@iterator", Z = "" + Object.prototype.constructor, nn = typeof Reflect != "undefined" && Reflect.ownKeys ? Reflect.ownKeys : Object.getOwnPropertySymbols !== void 0 ? function(n2) {
+  return Object.getOwnPropertyNames(n2).concat(Object.getOwnPropertySymbols(n2));
+} : Object.getOwnPropertyNames, rn = Object.getOwnPropertyDescriptors || function(n2) {
+  var r2 = {};
+  return nn(n2).forEach(function(t2) {
+    r2[t2] = Object.getOwnPropertyDescriptor(n2, t2);
+  }), r2;
+}, tn = {}, en = { get: function(n2, r2) {
+  if (r2 === Q)
+    return n2;
+  var e2 = p$2(n2);
+  if (!u$2(e2, r2))
+    return function(n3, r3, t2) {
+      var e3, i3 = I(r3, t2);
+      return i3 ? "value" in i3 ? i3.value : (e3 = i3.get) === null || e3 === void 0 ? void 0 : e3.call(n3.k) : void 0;
+    }(n2, e2, r2);
+  var i2 = e2[r2];
+  return n2.I || !t$2(i2) ? i2 : i2 === z(n2.t, r2) ? (E(n2), n2.o[r2] = R(n2.A.h, i2, n2)) : i2;
+}, has: function(n2, r2) {
+  return r2 in p$2(n2);
+}, ownKeys: function(n2) {
+  return Reflect.ownKeys(p$2(n2));
+}, set: function(n2, r2, t2) {
+  var e2 = I(p$2(n2), r2);
+  if (e2 == null ? void 0 : e2.set)
+    return e2.set.call(n2.k, t2), true;
+  if (!n2.P) {
+    var i2 = z(p$2(n2), r2), o2 = i2 == null ? void 0 : i2[Q];
+    if (o2 && o2.t === t2)
+      return n2.o[r2] = t2, n2.D[r2] = false, true;
+    if (c(t2, i2) && (t2 !== void 0 || u$2(n2.t, r2)))
+      return true;
+    E(n2), k$1(n2);
+  }
+  return n2.o[r2] === t2 && typeof t2 != "number" && (t2 !== void 0 || r2 in n2.o) || (n2.o[r2] = t2, n2.D[r2] = true, true);
+}, deleteProperty: function(n2, r2) {
+  return z(n2.t, r2) !== void 0 || r2 in n2.t ? (n2.D[r2] = false, E(n2), k$1(n2)) : delete n2.D[r2], n2.o && delete n2.o[r2], true;
+}, getOwnPropertyDescriptor: function(n2, r2) {
+  var t2 = p$2(n2), e2 = Reflect.getOwnPropertyDescriptor(t2, r2);
+  return e2 ? { writable: true, configurable: n2.i !== 1 || r2 !== "length", enumerable: e2.enumerable, value: t2[r2] } : e2;
+}, defineProperty: function() {
+  n$2(11);
+}, getPrototypeOf: function(n2) {
+  return Object.getPrototypeOf(n2.t);
+}, setPrototypeOf: function() {
+  n$2(12);
+} }, on = {};
+i(en, function(n2, r2) {
+  on[n2] = function() {
+    return arguments[0] = arguments[0][0], r2.apply(this, arguments);
+  };
+}), on.deleteProperty = function(r2, t2) {
+  return on.set.call(this, r2, t2, void 0);
+}, on.set = function(r2, t2, e2) {
+  return en.set.call(this, r2[0], t2, e2, r2[0]);
+};
+var un = function() {
+  function e2(r2) {
+    var e3 = this;
+    this.g = B, this.F = true, this.produce = function(r3, i3, o2) {
+      if (typeof r3 == "function" && typeof i3 != "function") {
+        var u2 = i3;
+        i3 = r3;
+        var a2 = e3;
+        return function(n2) {
+          var r4 = this;
+          n2 === void 0 && (n2 = u2);
+          for (var t2 = arguments.length, e4 = Array(t2 > 1 ? t2 - 1 : 0), o3 = 1; o3 < t2; o3++)
+            e4[o3 - 1] = arguments[o3];
+          return a2.produce(n2, function(n3) {
+            var t3;
+            return (t3 = i3).call.apply(t3, [r4, n3].concat(e4));
+          });
+        };
+      }
+      var f2;
+      if (typeof i3 != "function" && n$2(6), o2 !== void 0 && typeof o2 != "function" && n$2(7), t$2(r3)) {
+        var c2 = w$1(e3), s2 = R(e3, r3, void 0), v2 = true;
+        try {
+          f2 = i3(s2), v2 = false;
+        } finally {
+          v2 ? O(c2) : g(c2);
+        }
+        return typeof Promise != "undefined" && f2 instanceof Promise ? f2.then(function(n2) {
+          return j(c2, o2), P(n2, c2);
+        }, function(n2) {
+          throw O(c2), n2;
+        }) : (j(c2, o2), P(f2, c2));
+      }
+      if (!r3 || typeof r3 != "object") {
+        if ((f2 = i3(r3)) === void 0 && (f2 = r3), f2 === H && (f2 = void 0), e3.F && d(f2, true), o2) {
+          var p2 = [], l2 = [];
+          b("Patches").M(r3, f2, p2, l2), o2(p2, l2);
+        }
+        return f2;
+      }
+      n$2(21, r3);
+    }, this.produceWithPatches = function(n2, r3) {
+      if (typeof n2 == "function")
+        return function(r4) {
+          for (var t3 = arguments.length, i4 = Array(t3 > 1 ? t3 - 1 : 0), o3 = 1; o3 < t3; o3++)
+            i4[o3 - 1] = arguments[o3];
+          return e3.produceWithPatches(r4, function(r5) {
+            return n2.apply(void 0, [r5].concat(i4));
+          });
+        };
+      var t2, i3, o2 = e3.produce(n2, r3, function(n3, r4) {
+        t2 = n3, i3 = r4;
+      });
+      return typeof Promise != "undefined" && o2 instanceof Promise ? o2.then(function(n3) {
+        return [n3, t2, i3];
+      }) : [o2, t2, i3];
+    }, typeof (r2 == null ? void 0 : r2.useProxies) == "boolean" && this.setUseProxies(r2.useProxies), typeof (r2 == null ? void 0 : r2.autoFreeze) == "boolean" && this.setAutoFreeze(r2.autoFreeze);
+  }
+  var i2 = e2.prototype;
+  return i2.createDraft = function(e3) {
+    t$2(e3) || n$2(8), r$2(e3) && (e3 = D(e3));
+    var i3 = w$1(this), o2 = R(this, e3, void 0);
+    return o2[Q].C = true, g(i3), o2;
+  }, i2.finishDraft = function(r2, t2) {
+    var e3 = r2 && r2[Q];
+    var i3 = e3.A;
+    return j(i3, t2), P(void 0, i3);
+  }, i2.setAutoFreeze = function(n2) {
+    this.F = n2;
+  }, i2.setUseProxies = function(r2) {
+    r2 && !B && n$2(20), this.g = r2;
+  }, i2.applyPatches = function(n2, t2) {
+    var e3;
+    for (e3 = t2.length - 1; e3 >= 0; e3--) {
+      var i3 = t2[e3];
+      if (i3.path.length === 0 && i3.op === "replace") {
+        n2 = i3.value;
+        break;
+      }
+    }
+    e3 > -1 && (t2 = t2.slice(e3 + 1));
+    var o2 = b("Patches").$;
+    return r$2(n2) ? o2(n2, t2) : this.produce(n2, function(n3) {
+      return o2(n3, t2);
+    });
+  }, e2;
+}(), an = new un(), fn = an.produce;
+an.produceWithPatches.bind(an);
+an.setAutoFreeze.bind(an);
+an.setUseProxies.bind(an);
+var pn = an.applyPatches.bind(an);
+an.createDraft.bind(an);
+an.finishDraft.bind(an);
+var react = function equal(a2, b2) {
+  if (a2 === b2)
+    return true;
+  if (a2 && b2 && typeof a2 == "object" && typeof b2 == "object") {
+    if (a2.constructor !== b2.constructor)
+      return false;
+    var length, i2, keys;
+    if (Array.isArray(a2)) {
+      length = a2.length;
+      if (length != b2.length)
+        return false;
+      for (i2 = length; i2-- !== 0; )
+        if (!equal(a2[i2], b2[i2]))
+          return false;
+      return true;
+    }
+    if (a2 instanceof Map && b2 instanceof Map) {
+      if (a2.size !== b2.size)
+        return false;
+      for (i2 of a2.entries())
+        if (!b2.has(i2[0]))
+          return false;
+      for (i2 of a2.entries())
+        if (!equal(i2[1], b2.get(i2[0])))
+          return false;
+      return true;
+    }
+    if (a2 instanceof Set && b2 instanceof Set) {
+      if (a2.size !== b2.size)
+        return false;
+      for (i2 of a2.entries())
+        if (!b2.has(i2[0]))
+          return false;
+      return true;
+    }
+    if (ArrayBuffer.isView(a2) && ArrayBuffer.isView(b2)) {
+      length = a2.length;
+      if (length != b2.length)
+        return false;
+      for (i2 = length; i2-- !== 0; )
+        if (a2[i2] !== b2[i2])
+          return false;
+      return true;
+    }
+    if (a2.constructor === RegExp)
+      return a2.source === b2.source && a2.flags === b2.flags;
+    if (a2.valueOf !== Object.prototype.valueOf)
+      return a2.valueOf() === b2.valueOf();
+    if (a2.toString !== Object.prototype.toString)
+      return a2.toString() === b2.toString();
+    keys = Object.keys(a2);
+    length = keys.length;
+    if (length !== Object.keys(b2).length)
+      return false;
+    for (i2 = length; i2-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b2, keys[i2]))
+        return false;
+    for (i2 = length; i2-- !== 0; ) {
+      var key = keys[i2];
+      if (key === "_owner" && a2.$$typeof) {
+        continue;
+      }
+      if (!equal(a2[key], b2[key]))
+        return false;
+    }
+    return true;
+  }
+  return a2 !== a2 && b2 !== b2;
+};
+function createSelector(stringSelector) {
+  const parts = stringSelector.split(".");
+  return (state) => parts.reduce((v2, p2) => v2 instanceof Object && p2 in v2 ? v2[p2] : void 0, state);
+}
+function setWithSelector(state, stringSelector, value) {
+  const parts = stringSelector.split(".");
+  const prefix = parts.slice(0, -1);
+  const last = parts[parts.length - 1];
+  for (const part of prefix) {
+    if (state instanceof Object && part in state) {
+      state = state[part];
+    } else {
+      throw Error(`Could not set ${stringSelector} because path ${stringSelector} doesn't exist`);
+    }
+  }
+  if (state instanceof Object) {
+    state[last] = value;
+  } else {
+    throw Error(`Could not set ${stringSelector} because path ${stringSelector} doesn't exist`);
+  }
+}
+function throttle$1(fn2, ms) {
+  let last = 0;
+  let lastArgs;
+  let timeout;
+  function run() {
+    const args = lastArgs;
+    last = Date.now();
+    lastArgs = void 0;
+    timeout = void 0;
+    fn2(...args);
+  }
+  return function(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    if (timeout)
+      ;
+    else if (now < last + ms) {
+      timeout = setTimeout(run, last + ms - now);
+    } else {
+      run();
+    }
+  };
+}
+const RESTART_UPDATE = Symbol("RESTART_UPDATE");
+class Store$1 {
+  constructor(state, { log = (...data) => console.error(...data) } = {}) {
+    this.state = state;
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.batchCounter = 0;
+    this.reactions = /* @__PURE__ */ new Set();
+    this.patches = new Array();
+    d(state, true);
+    C();
+    T();
+    this.options = {
+      log
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  update(update) {
+    this.state = fn(this.state, (draft) => update(draft, this.state), (patches) => this.patches.push(...patches));
+    this.notify();
+  }
+  set(state) {
+    this.state = fn(this.state, () => state, (patches) => this.patches.push(...patches));
+    this.notify();
+  }
+  applyPatches(patches) {
+    this.state = pn(this.state, patches);
+    this.patches.push(...patches);
+    this.notify();
+  }
+  batchUpdates(fn2) {
+    try {
+      this.batchCounter++;
+      fn2();
+    } finally {
+      this.batchCounter--;
+      if (this.batchCounter === 0) {
+        this.notify();
+      }
+    }
+  }
+  subscribe(...args) {
+    let selector, listener, options;
+    if (args[1] instanceof Function) {
+      [selector, listener, options] = args;
+      if (typeof selector === "string") {
+        selector = createSelector(selector);
+      }
+    } else {
+      [selector, listener, options] = [(x2) => x2, ...args];
+    }
+    const { runNow = true, throttle: throttle2 = 0, compare = react } = options !== null && options !== void 0 ? options : {};
+    const throttledListener = throttle2 ? throttle$1(listener, throttle2) : listener;
+    let value = selector(this.state);
+    const internalListener = (state, _patches, init) => {
+      try {
+        this.lock = "subscription";
+        const oldValue = value;
+        value = selector(state);
+        if (!init && compare(value, oldValue))
+          return;
+        (init ? listener : throttledListener)(value, oldValue, this.state);
+      } catch (e2) {
+        this.options.log("Failed to execute listener:", e2);
+      } finally {
+        delete this.lock;
+      }
+    };
+    this.subscriptions.add(internalListener);
+    if (runNow)
+      internalListener(this.state, [], true);
+    return () => {
+      this.subscriptions.delete(internalListener);
+    };
+  }
+  addReaction(...args) {
+    let selector, reaction, options;
+    if (args[1] instanceof Function) {
+      [selector, reaction, options] = args;
+      if (typeof selector === "string") {
+        selector = createSelector(selector);
+      }
+    } else {
+      [selector, reaction, options] = [(x2) => x2, ...args];
+    }
+    const { runNow = true, compare = react } = options !== null && options !== void 0 ? options : {};
+    let value = selector(this.state);
+    const internalListener = (init) => {
+      let hasChanged = false;
+      try {
+        this.lock = "reaction";
+        const oldValue = value;
+        value = selector(this.state);
+        if (!init && compare(value, oldValue))
+          return;
+        this.state = fn(this.state, (draft) => reaction(value, draft, this.state, oldValue), (patches) => {
+          hasChanged = true;
+          this.patches.push(...patches);
+        });
+      } catch (e2) {
+        this.options.log("Failed to execute reaction:", e2);
+      } finally {
+        delete this.lock;
+      }
+      if (hasChanged && !init)
+        throw RESTART_UPDATE;
+      if (hasChanged && init)
+        this.notify();
+    };
+    this.reactions.add(internalListener);
+    if (runNow)
+      internalListener(true);
+    return () => {
+      this.reactions.delete(internalListener);
+    };
+  }
+  subscribePatches(listener) {
+    const internalListener = (_state, patches) => {
+      try {
+        listener(patches);
+      } catch (e2) {
+        this.options.log("Failed to execute patch listener:", e2);
+      }
+    };
+    this.subscriptions.add(internalListener);
+    return () => {
+      this.subscriptions.delete(internalListener);
+    };
+  }
+  checkLock() {
+    if (this.lock === "reaction") {
+      throw Error("You cannot call update from within a reaction. Use the passed draft instead.");
+    } else if (this.lock === "subscription") {
+      throw Error("You cannot call update from within a subscription.");
+    }
+  }
+  notify() {
+    if (this.batchCounter > 0 || this.patches.length === 0)
+      return;
+    try {
+      for (const reaction of this.reactions) {
+        reaction();
+      }
+    } catch (e2) {
+      return this.notify();
+    }
+    const patches = this.patches;
+    this.patches = [];
+    this.batchUpdates(() => {
+      for (const subscription of this.subscriptions) {
+        subscription(this.state, patches);
+      }
+    });
+  }
+}
+var withSelector = { exports: {} };
+var withSelector_production_min = {};
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production_min = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var e = require$$0__default["default"];
+function h$1(a2, b2) {
+  return a2 === b2 && (a2 !== 0 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+}
+var k = typeof Object.is === "function" ? Object.is : h$1, l = e.useState, m = e.useEffect, n$1 = e.useLayoutEffect, p$1 = e.useDebugValue;
+function q$1(a2, b2) {
+  var d2 = b2(), f2 = l({ inst: { value: d2, getSnapshot: b2 } }), c2 = f2[0].inst, g2 = f2[1];
+  n$1(function() {
+    c2.value = d2;
+    c2.getSnapshot = b2;
+    r$1(c2) && g2({ inst: c2 });
+  }, [a2, d2, b2]);
+  m(function() {
+    r$1(c2) && g2({ inst: c2 });
+    return a2(function() {
+      r$1(c2) && g2({ inst: c2 });
+    });
+  }, [a2]);
+  p$1(d2);
+  return d2;
+}
+function r$1(a2) {
+  var b2 = a2.getSnapshot;
+  a2 = a2.value;
+  try {
+    var d2 = b2();
+    return !k(a2, d2);
+  } catch (f2) {
+    return true;
+  }
+}
+function t$1(a2, b2) {
+  return b2();
+}
+var u$1 = typeof window === "undefined" || typeof window.document === "undefined" || typeof window.document.createElement === "undefined" ? t$1 : q$1;
+useSyncExternalStoreShim_production_min.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : u$1;
+{
+  shim.exports = useSyncExternalStoreShim_production_min;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var h = require$$0__default["default"], n = shim.exports;
+function p(a2, b2) {
+  return a2 === b2 && (a2 !== 0 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+}
+var q = typeof Object.is === "function" ? Object.is : p, r = n.useSyncExternalStore, t = h.useRef, u = h.useEffect, v = h.useMemo, w = h.useDebugValue;
+withSelector_production_min.useSyncExternalStoreWithSelector = function(a2, b2, e2, l2, g2) {
+  var c2 = t(null);
+  if (c2.current === null) {
+    var f2 = { hasValue: false, value: null };
+    c2.current = f2;
+  } else
+    f2 = c2.current;
+  c2 = v(function() {
+    function a3(a4) {
+      if (!c3) {
+        c3 = true;
+        d3 = a4;
+        a4 = l2(a4);
+        if (g2 !== void 0 && f2.hasValue) {
+          var b3 = f2.value;
+          if (g2(b3, a4))
+            return k2 = b3;
+        }
+        return k2 = a4;
+      }
+      b3 = k2;
+      if (q(d3, a4))
+        return b3;
+      var e3 = l2(a4);
+      if (g2 !== void 0 && g2(b3, e3))
+        return b3;
+      d3 = a4;
+      return k2 = e3;
+    }
+    var c3 = false, d3, k2, m2 = e2 === void 0 ? null : e2;
+    return [function() {
+      return a3(b2());
+    }, m2 === null ? void 0 : function() {
+      return a3(m2());
+    }];
+  }, [b2, e2, l2, g2]);
+  var d2 = r(a2, c2[0], c2[1]);
+  u(function() {
+    f2.hasValue = true;
+    f2.value = d2;
+  }, [d2]);
+  w(d2);
+  return d2;
+};
+{
+  withSelector.exports = withSelector_production_min;
+}
+function useStoreState(store, ...args) {
+  var _a, _b, _c, _d;
+  let selector, options;
+  if (args[0] instanceof Function) {
+    selector = args[0];
+    options = (_a = args[1]) !== null && _a !== void 0 ? _a : {};
+  } else if (typeof args[0] === "string") {
+    selector = createSelector(args[0]);
+    options = (_b = args[1]) !== null && _b !== void 0 ? _b : {};
+  } else {
+    selector = (x2) => x2;
+    options = (_c = args[0]) !== null && _c !== void 0 ? _c : {};
+  }
+  const subscribe = require$$0.useCallback((listener) => {
+    return store.subscribe((x2) => x2, listener, {
+      throttle: options.throttle,
+      runNow: false,
+      compare: (a2, b2) => a2 === b2
+    });
+  }, [store, options.throttle]);
+  const value = withSelector.exports.useSyncExternalStoreWithSelector(subscribe, () => store.getState(), void 0, selector, (_d = options.compare) !== null && _d !== void 0 ? _d : react);
+  require$$0.useDebugValue(value);
+  return value;
+}
+function useStoreProp(store, selector) {
+  const value = useStoreState(store, selector);
+  const update = (value2) => store.update((state) => setWithSelector(state, selector, value2));
+  return [value, update];
+}
+class Store extends Store$1 {
+  useState(...args) {
+    return useStoreState(this, ...args);
+  }
+  useProp(selector) {
+    return useStoreProp(this, selector);
+  }
+}
+class StoreScope {
+  constructor(defaultValue) {
+    this.defaultValue = defaultValue;
+    this.Provider = ({ children, store }) => {
+      const _store = require$$0.useMemo(() => store !== null && store !== void 0 ? store : new Store(this.defaultValue), [store]);
+      return tableTheme.jsx$1(this.context.Provider, Object.assign({ value: _store }, { children }), void 0);
+    };
+    this.withScope = (Component) => {
+      return (args) => tableTheme.jsx$1(this.Provider, { children: tableTheme.jsx$1(Component, Object.assign({}, args), void 0) }, void 0);
+    };
+    this.context = require$$0.createContext(new Store(defaultValue));
+  }
+  useStore() {
+    return require$$0.useContext(this.context);
+  }
+  useState(...args) {
+    const store = this.useStore();
+    return useStoreState(store, ...args);
+  }
+  useProp(selector) {
+    const store = this.useStore();
+    return useStoreProp(store, selector);
+  }
+}
+function calcItems(state) {
+  require$$0.useEffect(() => state.addReaction((state2) => [
+    state2.props.items,
+    state2.props.id,
+    state2.props.parentId,
+    state2.props.revealFiltered,
+    state2.sort,
+    state2.filters,
+    state2.filterValues,
+    state2.activeColumns,
+    state2.expanded
+  ], ([items = [], id, parentId, revealFiltered, sort, filters, filterValues, activeColumns], draft) => {
+    const tableItems = items.map((item) => __spreadProps(__spreadValues({}, item), {
+      id: id(item),
+      parentId: parentId == null ? void 0 : parentId(item),
+      children: []
+    }));
+    let sorted;
+    if (sort.length === 0) {
+      sorted = tableItems;
+    } else {
+      const selectors = flatMap(sort, (sort2) => {
+        const column = activeColumns.find((column2) => column2.id === sort2.columnId);
+        if (!column)
+          return [];
+        const sortBy = column.sortBy instanceof Array ? column.sortBy : [column.sortBy];
+        return sortBy.map((sortBy2) => ({ selector: (item) => sortBy2(column.value(item), item), direction: sort2.direction }));
+      }).filter(Boolean);
+      sorted = orderBy(tableItems, selectors.map((x2) => x2.selector), selectors.map((x2) => x2.direction));
+    }
+    const lookup = /* @__PURE__ */ new Map();
+    for (const item of sorted) {
+      lookup.set(item.id, item);
+    }
+    for (const item of sorted) {
+      const parent = item.parentId !== void 0 ? lookup.get(item.parentId) : void 0;
+      parent == null ? void 0 : parent.children.push(item);
+    }
+    const allItems = new Array();
+    const allItemsById = /* @__PURE__ */ new Map();
+    const traverse = (items2) => {
+      for (const item of items2) {
+        allItems.push(item);
+        allItemsById.set(item.id, item);
+        traverse(item.children);
+      }
+    };
+    traverse(sorted.filter((item) => item.parentId === void 0));
+    let expandedChanged = false;
+    const activeItemsById = /* @__PURE__ */ new Map();
+    const activeSet = /* @__PURE__ */ new Set();
+    const activeItems = [...allItems].reverse().filter((item) => {
+      let isActive = activeSet.has(item.id);
+      isActive || (isActive = activeColumns.every((column) => {
+        var _a;
+        const filter = filters.get(column.id);
+        if (!filter)
+          return true;
+        const filterValue = filterValues.get(column.id);
+        if (filterValue === void 0 || !filter.isActive(filterValue))
+          return true;
+        const filterBy = (_a = filter.filterBy) != null ? _a : (x2) => x2;
+        const value = filterBy(column.value(item), item);
+        return castArray(value).some((value2) => filter.test(filterValue, value2));
+      }));
+      if (isActive && item.parentId !== void 0) {
+        if (revealFiltered && [...filters.entries()].some(([id2, filter]) => {
+          const filterValue = filterValues.get(id2);
+          return !!filter && filterValue !== void 0 && filter.isActive(filterValue);
+        })) {
+          expandedChanged || (expandedChanged = !draft.expanded.has(item.parentId));
+          draft.expanded.add(item.parentId);
+        } else if (!draft.expanded.has(item.parentId)) {
+          isActive = false;
+        }
+      }
+      if (isActive && item.parentId !== void 0) {
+        activeSet.add(item.parentId);
+      }
+      if (isActive) {
+        activeItemsById.set(item.id, item);
+      }
+      return isActive;
+    }).reverse();
+    draft.items = K(allItems);
+    draft.itemsById = K(allItemsById);
+    draft.activeItems = K(activeItems);
+    draft.activeItemsById = K(activeItemsById);
+    if (expandedChanged) {
+      setTimeout(() => {
+        var _a, _b;
+        (_b = (_a = state.getState().props).onExpandedChange) == null ? void 0 : _b.call(_a, state.getState().expanded);
+      });
+    }
+  }, { runNow: true }), [state]);
+}
+const noopParentId = () => void 0;
+function calcProps(props) {
+  const columnCache = require$$0.useRef(/* @__PURE__ */ new Map());
+  return require$$0.useMemo(() => {
+    var _c, _d, _e, _f, _g, _h;
+    let id;
+    if (props.id instanceof Function) {
+      id = props.id;
+    } else {
+      id = (item) => item[props.id];
+    }
+    let parentId;
+    if (props.parentId instanceof Function) {
+      parentId = props.parentId;
+    } else if (typeof props.parentId === "string") {
+      parentId = (item) => item[props.parentId];
+    } else {
+      parentId = noopParentId;
+    }
+    let inputColumns;
+    if (props.columns instanceof Function) {
+      inputColumns = props.columns((value, column) => __spreadProps(__spreadValues({}, column), { value }));
+    } else {
+      inputColumns = props.columns.map((column) => __spreadProps(__spreadValues({}, column), { dependecies: void 0 }));
+    }
+    const newColumnCache = /* @__PURE__ */ new Map();
+    const columns = inputColumns.map(function(_a, index) {
+      var _b = _a, {
+        id: id2,
+        header = null,
+        renderCell = asString,
+        exportCell = asString,
+        sortBy = (v2) => typeof v2 === "number" || v2 instanceof Date ? v2 : String(v2),
+        dependencies = []
+      } = _b, props2 = __objRest(_b, [
+        "id",
+        "header",
+        "renderCell",
+        "exportCell",
+        "sortBy",
+        "dependencies"
+      ]);
+      var _a2;
+      const [depsInCache, columnInCache] = (_a2 = columnCache.current.get(id2 != null ? id2 : index)) != null ? _a2 : [];
+      let column;
+      if (depsInCache && columnInCache && depsInCache.length === dependencies.length && depsInCache.every((x2, i2) => dependencies[i2] === x2)) {
+        column = columnInCache;
+      } else {
+        column = __spreadValues({
+          id: id2 != null ? id2 : index,
+          header,
+          renderCell,
+          exportCell,
+          sortBy,
+          dependencies
+        }, props2);
+      }
+      newColumnCache.set(id2 != null ? id2 : index, [dependencies, column]);
+      return column;
+    });
+    columnCache.current = newColumnCache;
+    let copy;
+    if (props.enableExport === true || props.enableExport instanceof Object && props.enableExport.copy === true) {
+      copy = { separator: "	" };
+    } else if (props.enableExport && props.enableExport.copy instanceof Object) {
+      copy = props.enableExport.copy;
+    }
+    let download;
+    if (props.enableExport === true || props.enableExport instanceof Object && props.enableExport.download === true) {
+      download = { sepPrefix: true };
+    } else if (props.enableExport && props.enableExport.download instanceof Object) {
+      download = props.enableExport.download;
+    }
+    const enableExport = { copy, download };
+    return __spreadProps(__spreadValues({}, props), {
+      id,
+      parentId,
+      columns,
+      enableSelection: (_c = props.enableSelection) != null ? _c : true,
+      selectSyncChildren: (_d = props.selectSyncChildren) != null ? _d : true,
+      stickyHeader: (_e = props.stickyHeader) != null ? _e : true,
+      enableExport,
+      enableColumnSelection: (_f = props.enableColumnSelection) != null ? _f : true,
+      enableColumnResize: (_g = props.enableColumnResize) != null ? _g : true,
+      enableColumnReorder: (_h = props.enableColumnReorder) != null ? _h : true
+    });
+  }, [props]);
+}
+function cleanupState(state) {
+  require$$0.useEffect(() => state.addReaction((state2) => [state2.props.columns, state2.itemsById, state2.activeItemsById, state2.activeColumns], ([columns, itemsById, activeItemsById, activeColumns], draft) => {
+    var _a, _b, _c, _d, _e, _f;
+    const columnIds = new Set(columns.map((column) => column.id));
+    const activeColumnIds = new Set(activeColumns.map((column) => column.id));
+    const newSort = draft.sort.filter((s2) => activeColumnIds.has(s2.columnId));
+    if (newSort.length < draft.sort.length) {
+      draft.sort = newSort;
+      (_b = (_a = draft.props).onSortChange) == null ? void 0 : _b.call(_a, newSort);
+    }
+    for (const id of draft.filters.keys()) {
+      if (!activeColumnIds.has(id))
+        draft.filters.delete(id);
+    }
+    for (const id of draft.filterValues.keys()) {
+      if (!activeColumnIds.has(id))
+        draft.filterValues.delete(id);
+    }
+    for (const id of draft.hiddenColumns.keys()) {
+      if (!columnIds.has(id))
+        draft.hiddenColumns.delete(id);
+    }
+    for (const id of draft.columnWidths.keys()) {
+      if (!columnIds.has(id))
+        draft.columnWidths.delete(id);
+    }
+    for (const id of draft.columnOrder) {
+      if (!columnIds.has(id))
+        draft.columnOrder = draft.columnOrder.filter((x2) => x2 !== id);
+    }
+    if (draft.props.items) {
+      const newSelection = intersect(draft.selection, activeItemsById);
+      if (newSelection.size !== draft.selection.size) {
+        draft.selection = newSelection;
+        (_d = (_c = draft.props).onSelectionChange) == null ? void 0 : _d.call(_c, newSelection);
+      }
+      const newExpanded = intersect(draft.expanded, itemsById);
+      if (newExpanded.size < draft.expanded.size) {
+        draft.expanded = newExpanded;
+        (_f = (_e = draft.props).onExpandedChange) == null ? void 0 : _f.call(_e, newExpanded);
+      }
+    }
+  }, { runNow: true }), [state]);
+}
+function filterColumns(state) {
+  require$$0.useEffect(() => state.addReaction((state2) => [state2.props.columns, state2.hiddenColumns, state2.columnOrder], ([columns, hiddenColumns, columnOrder], draft) => {
+    draft.activeColumns = orderBy(columns.filter((column) => !hiddenColumns.has(column.id)), [(column) => columnOrder.indexOf(column.id)]);
+  }, { runNow: true }), [state]);
+}
+function syncSelections(state) {
+  require$$0.useEffect(() => state.addReaction((state2) => [state2.props.selectSyncChildren, state2.selection, state2.activeItems], ([selectSyncChildren, selection, activeItems], state2) => {
+    var _a, _b;
+    if (!selectSyncChildren)
+      return;
+    const newSelection = new Set(selection);
+    for (const item of activeItems) {
+      if (item.parentId !== void 0 && newSelection.has(item.parentId)) {
+        newSelection.add(item.id);
+      }
+    }
+    if (newSelection.size !== selection.size) {
+      state2.selection = newSelection;
+      (_b = (_a = state2.props).onSelectionChange) == null ? void 0 : _b.call(_a, newSelection);
+    }
+  }, { runNow: true }), [state]);
+}
+function useTableState(_props) {
+  const props = calcProps(_props);
+  const theme = tableTheme.useTableTheme(props);
+  const state = require$$0.useMemo(() => {
+    var _a, _b, _c, _d;
+    return new Store({
+      props,
+      theme,
+      sort: (_a = props.defaultSort) != null ? _a : [],
+      selection: (_b = props.defaultSelection) != null ? _b : /* @__PURE__ */ new Set(),
+      expanded: (_c = props.defaultExpanded) != null ? _c : /* @__PURE__ */ new Set(),
+      rowHeights: /* @__PURE__ */ new Map(),
+      filters: /* @__PURE__ */ new Map(),
+      filterValues: /* @__PURE__ */ new Map(),
+      hiddenColumns: (_d = props.defaultHiddenColumns) != null ? _d : /* @__PURE__ */ new Set(),
+      columnWidths: /* @__PURE__ */ new Map(),
+      columnOrder: props.columns.map((column) => column.id),
+      columnStyleOverride: /* @__PURE__ */ new Map(),
+      activeColumns: [],
+      items: [],
+      itemsById: /* @__PURE__ */ new Map(),
+      activeItems: [],
+      activeItemsById: /* @__PURE__ */ new Map(),
+      lastSelectedId: void 0
+    });
+  }, []);
+  filterColumns(state);
+  calcItems(state);
+  syncSelections(state);
+  cleanupState(state);
+  require$$0.useEffect(() => {
+    state.update((state2) => {
+      state2.props = K(props);
+      if (props.sort)
+        state2.sort = props.sort;
+      if (props.selection)
+        state2.selection = props.selection;
+      if (props.expanded)
+        state2.expanded = props.expanded;
+      if (props.hiddenColumns)
+        state2.hiddenColumns = props.hiddenColumns;
+      for (const column of props.columns) {
+        if (!state2.columnOrder.includes(column.id)) {
+          const index = props.columns.indexOf(column);
+          state2.columnOrder.splice(index, 0, column.id);
+        }
+      }
+      state2.theme = theme;
+    });
+  }, [state, props]);
+  return state;
+}
+const ColumnHeaderContext = new StoreScope({
+  items: /* @__PURE__ */ new Map()
+});
+function ColumnHeader(props) {
+  const ref = require$$0.useRef(null);
+  const columnId = useColumnContext();
+  const table = useTableContext();
+  const enabled = table.useState("props.enableColumnReorder");
+  const store = ColumnHeaderContext.useStore();
+  const draggingStart = require$$0.useRef();
+  const clone = require$$0.useRef();
+  require$$0.useEffect(() => {
+    const div = ref.current;
+    if (!div)
+      return;
+    store.update((state) => {
+      state.items.set(columnId, K(div));
+    });
+    return () => {
+      store.update((state) => {
+        state.items.delete(columnId);
+      });
+    };
+  }, [ref.current, store, columnId]);
+  function calcTargetIndex(offsetLeft) {
+    var _a, _b, _c;
+    const cols = table.getState().columnOrder.map((id) => ({
+      id,
+      div: store.getState().items.get(id)
+    }));
+    const otherCols = cols.filter((col) => col.id !== columnId);
+    const firstOffsetleft = (_c = (_b = (_a = cols.find((col) => col.div)) == null ? void 0 : _a.div) == null ? void 0 : _b.offsetLeft) != null ? _c : 0;
+    let sum = 0;
+    const targetIndex = otherCols.findIndex((col) => {
+      var _a2, _b2;
+      const width = (_b2 = (_a2 = col.div) == null ? void 0 : _a2.offsetWidth) != null ? _b2 : 0;
+      if (sum + width / 2 > offsetLeft - firstOffsetleft)
+        return true;
+      sum += width;
+      return false;
+    });
+    return targetIndex === -1 ? otherCols.length : targetIndex;
+  }
+  function onPointerDown(e2) {
+    const div = ref.current;
+    if (!div)
+      return;
+    draggingStart.current = {
+      mouseX: e2.clientX,
+      bounds: div.getBoundingClientRect()
+    };
+  }
+  function onPointerMove(e2) {
+    table.update((state) => {
+      const div = ref.current;
+      if (!div || draggingStart.current === void 0 || Math.abs(e2.clientX - draggingStart.current.mouseX) < 5)
+        return;
+      e2.stopPropagation();
+      div.setPointerCapture(e2.pointerId);
+      if (!clone.current) {
+        clone.current = div.cloneNode(true);
+        document.body.append(clone.current);
+        for (const [key, value] of Object.entries(getComputedStyle(div))) {
+          try {
+            clone.current.style[key] = value;
+          } catch {
+          }
+        }
+        Object.assign(clone.current.style, {
+          pointerEvents: "none",
+          position: "fixed",
+          boxShadow: "0px 5px 5px -3px rgb(0 0 0 / 20%), 0px 8px 10px 1px rgb(0 0 0 / 14%), 0px 3px 14px 2px rgb(0 0 0 / 12%)",
+          left: `${draggingStart.current.bounds.left}px`,
+          top: `${draggingStart.current.bounds.top}px`
+        });
+        div.style.color = "rgba(0, 0, 0, 0.2)";
+      }
+      clone.current.style.left = `${draggingStart.current.bounds.left + e2.clientX - draggingStart.current.mouseX}px`;
+      const index = state.columnOrder.indexOf(columnId);
+      const targetIndex = calcTargetIndex(div.offsetLeft + e2.clientX - draggingStart.current.mouseX);
+      const columns = table.getState().columnOrder.map((id, index2) => {
+        var _a, _b;
+        return {
+          id,
+          index: index2,
+          width: (_b = (_a = store.getState().items.get(id)) == null ? void 0 : _a.offsetWidth) != null ? _b : 0
+        };
+      });
+      state.columnOrder.forEach((id, i2) => {
+        let offset = 0;
+        if (i2 === index) {
+          if (targetIndex > index) {
+            offset = columns.slice(index + 1, targetIndex + 1).reduce((sum, col) => sum + col.width, 0);
+          } else if (targetIndex < index) {
+            offset = -columns.slice(targetIndex, index).reduce((sum, col) => sum + col.width, 0);
+          }
+        } else if (i2 >= targetIndex && i2 < index) {
+          offset = div.offsetWidth;
+        } else if (i2 > index && i2 <= targetIndex) {
+          offset = -div.offsetWidth;
+        }
+        state.columnStyleOverride.set(id, {
+          transition: "transform 500ms",
+          transform: `translate3d(${offset}px, 0, 0)`,
+          zIndex: i2 === index ? 1 : void 0
+        });
+      });
+    });
+  }
+  function onPointerUp(e2) {
+    table.update((state) => {
+      var _a;
+      const div = ref.current;
+      if (!div || draggingStart.current === void 0)
+        return;
+      const index = state.columnOrder.indexOf(columnId);
+      const targetIndex = calcTargetIndex(div.offsetLeft + e2.clientX - draggingStart.current.mouseX);
+      state.columnOrder.splice(index, 1);
+      state.columnOrder.splice(targetIndex, 0, columnId);
+      (_a = clone.current) == null ? void 0 : _a.remove();
+      div.style.color = "";
+      state.columnStyleOverride.clear();
+      draggingStart.current = void 0;
+      clone.current = void 0;
+    });
+  }
+  return tableTheme.jsx("div", __spreadProps(__spreadValues({}, props), {
+    css: {
+      position: "relative",
+      userSelect: "none"
+    },
+    ref,
+    onPointerDown: enabled ? onPointerDown : void 0,
+    onPointerMove: enabled ? onPointerMove : void 0,
+    onPointerUp: enabled ? onPointerUp : void 0,
+    children: props.children
+  }));
+}
+function ColumnSelection() {
+  const {
+    components: {
+      IconButton,
+      Popover,
+      Checkbox
+    },
+    icons: {
+      Settings
+    },
+    text
+  } = useTheme();
+  const cssVariables = useCssVariables();
+  const table = useTableContext();
+  const columns = table.useState("props.columns");
+  const hiddenColumns = table.useState("hiddenColumns");
+  const [anchorEl, setAnchorEl] = require$$0.useState(null);
+  const toggle2 = (column) => {
+    const {
+      props: {
+        hiddenColumns: controlledHiddenColumns,
+        onHiddenColumnsChange
+      }
+    } = table.getState();
+    const newValue = new Set(hiddenColumns);
+    if (hiddenColumns.has(column.id))
+      newValue.delete(column.id);
+    else
+      newValue.add(column.id);
+    if (!controlledHiddenColumns) {
+      table.update((state) => {
+        state.hiddenColumns = newValue;
+      });
+    }
+    onHiddenColumnsChange == null ? void 0 : onHiddenColumnsChange(newValue);
+  };
+  return tableTheme.jsxs(tableTheme.Fragment, {
+    children: [tableTheme.jsx(IconButton, {
+      onClick: (e2) => setAnchorEl(anchorEl ? null : e2.currentTarget),
+      children: tableTheme.jsx(Settings, {})
+    }), tableTheme.jsx(Popover, {
+      anchorEl,
+      open: !!anchorEl,
+      onClose: () => setAnchorEl(null),
+      css: cssVariables,
+      children: tableTheme.jsxs("div", {
+        css: {
+          padding: `calc(var(--spacing) * 2)`,
+          display: "grid"
+        },
+        children: [tableTheme.jsx("div", {
+          css: {
+            marginBottom: "var(--spacing)"
+          },
+          children: text.selectColumns
+        }), columns.map((column) => tableTheme.jsx(FormControlLabel, {
+          control: tableTheme.jsx(Checkbox, {
+            checked: !hiddenColumns.has(column.id),
+            onChange: () => toggle2(column),
+            disabled: column.cannotHide
+          }),
+          label: column.header
+        }, column.id))]
+      })
+    })]
+  });
+}
+function csvExport(data, { sepPrefix, separator = ",", quote = '"', eol = "\n" } = {}) {
+  const cells = data.map((line) => line.map((value) => {
+    if (typeof value === "number")
+      return String(value);
+    if (![separator, quote, eol].some((c2) => value.includes(c2)))
+      return value;
+    const clean = value.replace(new RegExp(quote, "g"), `${quote}${quote}`);
+    return `${quote}${clean}${quote}`;
+  }));
+  return (sepPrefix ? `SEP=${separator}
+` : "") + cells.map((line) => line.join(separator)).join(eol);
+}
+function Export() {
+  const table = useTableContext();
+  const {
+    components: {
+      Button,
+      IconButton,
+      Popover
+    },
+    icons: {
+      Export: Export2,
+      Clipboard
+    },
+    text
+  } = useTheme();
+  const cssVariables = useCssVariables();
+  const [anchor, setAnchor] = require$$0.useState(null);
+  const generate = (options) => {
+    const {
+      activeColumns,
+      activeItems
+    } = table.getState();
+    const data = [activeColumns.map((column) => String(column.id)), ...activeItems.map((item) => activeColumns.map((column) => column.exportCell(column.value(item), item)))];
+    return csvExport(data, options);
+  };
+  const copy = () => {
+    navigator.clipboard.writeText(generate(table.getState().props.enableExport.copy));
+  };
+  const download = () => {
+    const a2 = document.createElement("a");
+    a2.href = "data:text/csv;charset=utf-8," + encodeURIComponent(generate(table.getState().props.enableExport.download));
+    a2.download = "export.csv";
+    document.body.appendChild(a2);
+    a2.click();
+    document.body.removeChild(a2);
+  };
+  return tableTheme.jsxs(tableTheme.Fragment, {
+    children: [tableTheme.jsx(IconButton, {
+      onClick: (e2) => setAnchor(anchor ? null : e2.currentTarget),
+      children: tableTheme.jsx(Export2, {})
+    }), tableTheme.jsx(Popover, {
+      open: !!anchor,
+      onClose: () => setAnchor(null),
+      anchorEl: anchor,
+      css: cssVariables,
+      children: tableTheme.jsxs("div", {
+        css: {
+          padding: `calc(var(--spacing) * 2)`,
+          display: "grid",
+          justifyItems: "stretch",
+          gap: "var(--spacing)",
+          "& > *": {
+            justifyContent: "start"
+          }
+        },
+        children: [tableTheme.jsx("div", {
+          css: {
+            marginBottom: "var(--spacing)"
+          },
+          children: text.exportTitle
+        }), tableTheme.jsx(Button, {
+          startIcon: tableTheme.jsx(Clipboard, {}),
+          onClick: copy,
+          children: text.exportCopy
+        }), tableTheme.jsx(Button, {
+          startIcon: tableTheme.jsx(Export2, {}),
+          onClick: download,
+          children: text.exportDownload
+        })]
+      })
+    })]
+  });
+}
+function useTheme() {
+  const table = useTableContext();
+  return table.useState("theme");
+}
+function FilterControl() {
+  const table = useTableContext();
+  const columnId = useColumnContext();
+  const {
+    components: {
+      IconButton,
+      Popover
+    },
+    icons: {
+      FilterList,
+      ArrowDropDown
+    }
+  } = useTheme();
+  const cssVariables = useCssVariables();
+  const [anchor, setAnchor] = require$$0.useState(null);
+  const isActive = table.useState((state) => {
+    const filter2 = state.filters.get(columnId);
+    const filterValue = state.filterValues.get(columnId);
+    return filter2 !== void 0 && filterValue !== void 0 && filter2.isActive(filterValue);
+  });
+  const filter = table.useState((state) => {
+    var _a;
+    return (_a = state.activeColumns.find((column) => column.id === columnId)) == null ? void 0 : _a.filter;
+  });
+  if (!filter)
+    return null;
+  return tableTheme.jsxs(tableTheme.Fragment, {
+    children: [tableTheme.jsx(IconButton, {
+      onClick: (e2) => setAnchor(e2.currentTarget),
+      css: [isActive && {
+        color: "white !important",
+        backgroundColor: "var(--primaryMain) !important"
+      }],
+      children: isActive ? tableTheme.jsx(FilterList, {}) : tableTheme.jsx(ArrowDropDown, {})
+    }), tableTheme.jsx("div", {
+      onPointerDown: (e2) => {
+        e2.stopPropagation();
+      },
+      onPointerMove: (e2) => {
+        e2.stopPropagation();
+      },
+      children: tableTheme.jsx(Popover, {
+        open: true,
+        hidden: !anchor,
+        onClose: () => setAnchor(null),
+        anchorEl: anchor != null ? anchor : document.body,
+        css: cssVariables,
+        children: filter
+      })
+    })]
+  });
+}
+function ResizeHandle() {
+  const table = useTableContext();
+  const columnId = useColumnContext();
+  const enabled = table.useState("props.enableColumnResize");
+  function onPointerDown(e2) {
+    e2.stopPropagation();
+    const div = e2.target;
+    div.setPointerCapture(e2.pointerId);
+  }
+  function onPointerMove(e2) {
+    e2.stopPropagation();
+    const div = e2.target;
+    if (!div.hasPointerCapture(e2.pointerId))
+      return;
+    const parent = div.parentElement;
+    const width = Math.max(e2.clientX - parent.getBoundingClientRect().left + 5, 50);
+    table.update((state) => {
+      state.columnWidths.set(columnId, `${width}px`);
+    });
+  }
+  function onPointerUp(e2) {
+    e2.stopPropagation();
+    const div = e2.target;
+    div.releasePointerCapture(e2.pointerId);
+  }
+  function onDoubleClick(e2) {
+    table.update((state) => {
+      if (e2.getModifierState("Control")) {
+        state.columnWidths.delete(columnId);
+      } else {
+        state.columnWidths.set(columnId, "max-content");
+      }
+    });
+  }
+  return tableTheme.jsx("div", {
+    css: {
+      alignSelf: "stretch",
+      padding: "0 5px",
+      cursor: enabled ? "col-resize" : "initial",
+      display: "flex",
+      alignItems: "center",
+      "&:after": {
+        content: '""',
+        width: 1,
+        height: "1.2em",
+        background: "currentColor",
+        transition: "transform 300ms"
+      }
+    },
+    onPointerDown: enabled ? onPointerDown : void 0,
+    onPointerMove: enabled ? onPointerMove : void 0,
+    onPointerUp: enabled ? onPointerUp : void 0,
+    onDoubleClick: enabled ? onDoubleClick : void 0
+  });
+}
+const Cell = require$$0.memo(function Cell2({
+  itemId,
+  rowIndex
+}) {
+  var _a, _b;
+  const table = useTableContext();
+  const columnId = useColumnContext();
+  const {
+    css
+  } = useTheme();
+  const column = table.useState((state) => state.activeColumns.find((column2) => column2.id === columnId));
+  const item = table.useState((state) => state.activeItemsById.get(itemId));
+  const columnStyleOverride = table.useState((state) => state.columnStyleOverride.get(columnId), {
+    throttle: 16
+  });
+  if (!column || !item)
+    return null;
+  (_b = (_a = table.getState().props).debugRender) == null ? void 0 : _b.call(_a, "render cell", itemId, columnId);
+  const classNames = [...calcClassNames(css, item, rowIndex), ...calcClassNames(column == null ? void 0 : column.css, item, rowIndex)];
+  const content = column.renderCell(column.value(item), item);
+  return tableTheme.jsx("div", {
+    css: [tableTheme.defaultClasses.cell, classNames, columnStyleOverride],
+    children: typeof content === "string" ? tableTheme.jsx("span", {
+      css: tableTheme.defaultClasses.text,
+      children: content
+    }) : content
+  });
+});
+function ExpandControl({
+  itemId,
+  hasDeferredChildren
+}) {
+  const {
+    components: {
+      IconButton,
+      Spinner
+    },
+    icons: {
+      ChevronRight
+    }
+  } = useTheme();
+  const table = useTableContext();
+  const isExpanded = table.useState((state) => state.expanded.has(itemId));
+  const hasChildren = table.useState((state) => {
+    var _a;
+    return !!((_a = state.activeItemsById.get(itemId)) == null ? void 0 : _a.children.length);
+  });
+  function toggle2() {
+    const {
+      props: {
+        expanded: controlledExpanded,
+        expandOnlyOne,
+        onExpandedChange
+      },
+      expanded,
+      activeItemsById
+    } = table.getState();
+    const newExpanded = new Set(expanded);
+    if (expandOnlyOne)
+      newExpanded.clear();
+    if (isExpanded)
+      newExpanded.delete(itemId);
+    else {
+      newExpanded.add(itemId);
+      const item = activeItemsById.get(itemId);
+      for (const ancestor of item ? getAncestors(activeItemsById, item) : []) {
+        newExpanded.add(ancestor);
+      }
+    }
+    onExpandedChange == null ? void 0 : onExpandedChange(newExpanded);
+    if (!controlledExpanded) {
+      table.update((state) => {
+        state.expanded = newExpanded;
+      });
+    }
+  }
+  if (isExpanded && hasDeferredChildren && !hasChildren) {
+    return tableTheme.jsx(Spinner, {
+      css: {
+        margin: "0 var(--spacing)"
+      }
+    });
+  }
+  return tableTheme.jsx(IconButton, {
+    onClick: toggle2,
+    children: tableTheme.jsx("span", {
+      css: {
+        display: "inline-flex",
+        transition: "all 300ms",
+        transform: isExpanded ? "rotate3d(0, 0, 1, 90deg)" : "rotate3d(0, 0, 1, 0deg)"
+      },
+      children: tableTheme.jsx(ChevronRight, {})
+    })
+  });
+}
+function SelectComponent({
+  itemId
+}) {
+  const table = useTableContext();
+  const {
+    components: {
+      Checkbox
+    }
+  } = useTheme();
+  const isSelected2 = table.useState((state) => {
+    const itemIds = itemId ? [itemId] : [...state.activeItemsById.keys()];
+    return state.activeItemsById.size > 0 && itemIds.every((itemId2) => state.selection.has(itemId2));
+  });
+  function toggle2(e2) {
+    const mouseEvent = e2.nativeEvent;
+    const {
+      activeItems,
+      activeItemsById,
+      lastSelectedId,
+      selection,
+      props: {
+        selectSyncChildren,
+        selection: controlledSelection,
+        onSelectionChange
+      }
+    } = table.getState();
+    let range;
+    if (mouseEvent.shiftKey && itemId) {
+      const a2 = lastSelectedId ? activeItems.findIndex((i2) => lastSelectedId === i2.id) : 0;
+      const b2 = activeItems.findIndex((item) => item.id === itemId);
+      range = activeItems.slice(Math.min(a2, b2), Math.max(a2, b2) + 1);
+    } else {
+      const item = itemId ? activeItemsById.get(itemId) : void 0;
+      range = item ? [item] : activeItems;
+    }
+    const newSelection = new Set(selection);
+    for (const item of range) {
+      if (isSelected2)
+        newSelection.delete(item.id);
+      else
+        newSelection.add(item.id);
+    }
+    if (selectSyncChildren && isSelected2) {
+      for (const ancestor of getAncestors(activeItemsById, ...range)) {
+        newSelection.delete(ancestor);
+      }
+      for (const descendant of getDescendants(...range)) {
+        newSelection.delete(descendant);
+      }
+    }
+    onSelectionChange == null ? void 0 : onSelectionChange(newSelection);
+    if (!controlledSelection) {
+      table.update((state) => {
+        state.selection = newSelection;
+      });
+    }
+    table.update((state) => {
+      state.lastSelectedId = itemId;
+    });
+  }
+  return tableTheme.jsx(Checkbox, {
+    css: {
+      justifySelf: "start",
+      color: "inherit"
+    },
+    checked: isSelected2,
+    onChange: toggle2
+  });
+}
+function calcClassNames(css, item, index) {
+  return [(css == null ? void 0 : css.cell) instanceof Function ? css.cell(item, index) : css == null ? void 0 : css.cell, index % 2 === 0 && (css == null ? void 0 : css.evenCell), index % 2 === 1 && (css == null ? void 0 : css.oddCell)];
+}
+const Row = require$$0.memo(function Row2({
+  itemId,
+  rowIndex
+}) {
+  var _a, _b;
+  const table = useTableContext();
+  const divRef = require$$0.useRef(null);
+  const {
+    className,
+    indent,
+    hasChildren,
+    hasDeferredChildren,
+    columnIds,
+    enableSelection,
+    rowAction
+  } = table.useState((state) => {
+    var _a2, _b2;
+    const item = state.activeItemsById.get(itemId);
+    const index = !item ? -1 : state.activeItems.indexOf(item);
+    return {
+      className: calcClassNames(state.props.css, item, index),
+      indent: item ? getAncestors(state.activeItemsById, item).size : 0,
+      hasChildren: !!(item == null ? void 0 : item.children.length),
+      hasDeferredChildren: item && ((_b2 = (_a2 = state.props).hasDeferredChildren) == null ? void 0 : _b2.call(_a2, item)),
+      columnIds: state.activeColumns.map((column) => column.id),
+      enableSelection: state.props.enableSelection,
+      rowAction: state.props.rowAction instanceof Function ? item ? state.props.rowAction(item, index) : null : state.props.rowAction
+    };
+  });
+  require$$0.useEffect(() => {
+    const div = divRef.current;
+    if (!div)
+      return;
+    const o2 = new ResizeObserver(() => {
+      if (!document.contains(div))
+        return;
+      table.update((state) => {
+        state.rowHeights.set(itemId, div.offsetHeight);
+      });
+    });
+    o2.observe(div);
+    return () => o2.disconnect();
+  }, [divRef.current]);
+  (_b = (_a = table.getState().props).debugRender) == null ? void 0 : _b.call(_a, "render row", itemId);
+  return tableTheme.jsxs(tableTheme.Fragment, {
+    children: [tableTheme.jsx("div", {
+      css: [tableTheme.defaultClasses.cellFill, className],
+      ref: divRef
+    }), tableTheme.jsxs("div", {
+      css: [tableTheme.defaultClasses.cell, tableTheme.defaultClasses.firstCell, className],
+      children: [tableTheme.jsx("div", {
+        css: {
+          width: indent * 20
+        }
+      }), enableSelection && tableTheme.jsx(SelectComponent, {
+        itemId
+      }), (hasChildren || hasDeferredChildren) && tableTheme.jsx(ExpandControl, {
+        itemId,
+        hasDeferredChildren
+      }), rowAction]
+    }), columnIds.map((columnId) => tableTheme.jsx(ColumnContext.Provider, {
+      value: columnId,
+      children: tableTheme.jsx(Cell, {
+        itemId,
+        rowIndex
+      })
+    }, columnId)), tableTheme.jsx("div", {
+      css: [tableTheme.defaultClasses.cellFill, className]
+    })]
+  });
+});
+function SortComponent({
+  children
+}) {
+  const table = useTableContext();
+  const columnId = useColumnContext();
+  const {
+    components: {
+      Badge
+    },
+    icons: {
+      ArrowUpward
+    }
+  } = useTheme();
+  const {
+    direction,
+    index
+  } = table.useState((state) => {
+    var _a, _b;
+    const index2 = (_a = state.sort.findIndex((s2) => s2.columnId === columnId)) != null ? _a : -1;
+    return {
+      direction: (_b = state.sort[index2]) == null ? void 0 : _b.direction,
+      index: index2 >= 0 && state.sort.length > 1 ? index2 + 1 : void 0
+    };
+  });
+  function toggle2(e2) {
+    const {
+      props: {
+        sort: controlledSort,
+        onSortChange
+      }
+    } = table.getState();
+    const newDirection = direction === "asc" ? "desc" : "asc";
+    const newSort = (e2.getModifierState("Control") ? table.getState().sort.filter((s2) => s2.columnId !== columnId) : []).concat({
+      columnId,
+      direction: newDirection
+    });
+    onSortChange == null ? void 0 : onSortChange(newSort);
+    if (!controlledSort) {
+      table.update((state) => {
+        state.sort = newSort;
+      });
+    }
+  }
+  return tableTheme.jsxs("div", {
+    css: {
+      userSelect: "none",
+      display: "grid",
+      gridTemplateColumns: "minmax(0, 1fr) max-content",
+      alignItems: "center",
+      cursor: "pointer",
+      "& > div": {
+        overflow: "hidden",
+        textOverflow: "ellipsis"
+      }
+    },
+    onClick: toggle2,
+    children: [tableTheme.jsx("div", {
+      children
+    }), tableTheme.jsx(Badge, {
+      badgeContent: index,
+      children: tableTheme.jsx("span", {
+        css: [{
+          transition: "all 300ms",
+          fontSize: "0.8em"
+        }, !direction && {
+          opacity: 0
+        }, direction === "desc" && {
+          transform: "rotate3d(0, 0, 1, 180deg)"
+        }],
+        children: tableTheme.jsx(ArrowUpward, {})
+      })
+    })]
+  });
+}
+function throttle(fn2, ms) {
+  let last = 0;
+  let lastArgs;
+  let timeout;
+  function run() {
+    const args = lastArgs;
+    last = Date.now();
+    lastArgs = void 0;
+    timeout = void 0;
+    fn2(...args);
+  }
+  return Object.assign(function(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    if (timeout)
+      ;
+    else if (now < last + ms) {
+      timeout = setTimeout(run, last + ms - now);
+    } else {
+      run();
+    }
+  }, {
+    flush() {
+      if (lastArgs) {
+        run();
+      }
+    }
+  });
+}
+const onAncestorScroll = (x2, onScroll) => {
+  const find = (x22) => x22.parentElement ? [x22.parentElement, ...find(x22.parentElement)] : [document];
+  const ancestors = find(x2);
+  for (const ancestor of ancestors) {
+    ancestor.addEventListener("scroll", onScroll);
+  }
+  return () => {
+    for (const ancestor of ancestors) {
+      ancestor.removeEventListener("scroll", onScroll);
+    }
+  };
+};
+const findScrollRoot = (x2) => {
+  const parent = x2.parentElement;
+  if (!parent)
+    return document.documentElement;
+  if (parent.scrollHeight > parent.clientHeight)
+    return parent;
+  return findScrollRoot(parent);
+};
+const relativeOffset = (x2, y2) => {
+  if (x2.offsetParent === y2.offsetParent || !x2.offsetParent)
+    return x2.offsetTop - y2.offsetTop;
+  if (x2.offsetParent instanceof HTMLElement)
+    return relativeOffset(x2.offsetParent, y2) + x2.offsetTop;
+  return 0;
+};
+function Virtualized(_c) {
+  var _d = _c, {
+    header,
+    children
+  } = _d, props = __objRest(_d, [
+    "header",
+    "children"
+  ]);
+  var _a, _b, _c2, _d2;
+  const table = useTableContext();
+  const virtual = table.useState("props.virtual");
+  const probeRef = require$$0.useRef(null);
+  const [, setCounter] = require$$0.useState(0);
+  const {
+    itemIds = [],
+    from = 0,
+    to,
+    before = 0,
+    after = 0
+  } = table.useState((state) => {
+    var _a2;
+    const itemIds2 = state.activeItems.map((item) => item.id);
+    const root = probeRef.current && findScrollRoot(probeRef.current);
+    if (!state.props.virtual)
+      return {
+        itemIds: itemIds2
+      };
+    if (!probeRef.current || !root || !document.contains(root))
+      return {};
+    const {
+      rowHeight,
+      initalRowHeight,
+      overscan = 200,
+      overscanTop,
+      overscanBottom
+    } = (_a2 = state.props.virtual instanceof Object ? state.props.virtual : void 0) != null ? _a2 : {};
+    let totalHeight = 0;
+    const rowHeights = itemIds2.map((itemId, index) => {
+      var _a3, _b2;
+      const h2 = (_b2 = (_a3 = rowHeight != null ? rowHeight : state.rowHeights.get(itemId)) != null ? _a3 : initalRowHeight) != null ? _b2 : index === 0 ? 100 : totalHeight / index;
+      totalHeight += h2;
+      return h2;
+    });
+    const probeOffset = relativeOffset(probeRef.current, root);
+    const headerHeight = probeRef.current.offsetTop;
+    const topOfTable = root.scrollTop - probeOffset + headerHeight;
+    const bottomOfTable = topOfTable + root.clientHeight - headerHeight;
+    let from2 = 0, to2 = itemIds2.length, before2 = 0, after2 = 0;
+    for (const h2 of rowHeights) {
+      if (before2 + h2 > topOfTable - (overscanTop != null ? overscanTop : overscan))
+        break;
+      from2++;
+      before2 += h2;
+    }
+    for (const h2 of rowHeights.reverse()) {
+      if (after2 + h2 > totalHeight - bottomOfTable - (overscanBottom != null ? overscanBottom : overscan))
+        break;
+      to2--;
+      after2 += h2;
+    }
+    return {
+      itemIds: itemIds2.slice(from2, to2),
+      from: from2,
+      to: to2,
+      before: before2,
+      after: after2
+    };
+  });
+  const throttleScroll = (_b = (_a = typeof virtual === "boolean" ? void 0 : virtual) == null ? void 0 : _a.throttleScroll) != null ? _b : 500;
+  const incCounter = require$$0.useMemo(() => throttle(() => setCounter((c2) => c2 + 1), throttleScroll), [throttleScroll]);
+  require$$0.useEffect(() => {
+    if (!virtual || !probeRef.current)
+      return;
+    return onAncestorScroll(probeRef.current, incCounter);
+  }, [probeRef.current, incCounter]);
+  (_d2 = (_c2 = table.getState().props).debugRender) == null ? void 0 : _d2.call(_c2, `Virtualalized render ${from} to ${to}`);
+  return tableTheme.jsxs("div", __spreadProps(__spreadValues({}, props), {
+    children: [header, virtual && tableTheme.jsx("div", {
+      style: {
+        gridColumn: "1 / -1",
+        height: before
+      },
+      ref: probeRef
+    }), children(itemIds, from), virtual && tableTheme.jsx("div", {
+      style: {
+        gridColumn: "1 / -1",
+        height: after
+      }
+    })]
+  }));
+}
+const TableContext = require$$0.createContext(null);
+const ColumnContext = require$$0.createContext(null);
+function useTableContext() {
+  const value = require$$0.useContext(TableContext);
+  if (!value)
+    throw Error("No table context available");
+  return value;
+}
+function useColumnContext() {
+  const value = require$$0.useContext(ColumnContext);
+  if (value === null)
+    throw Error("No column context available");
+  return value;
+}
+function Table(props) {
+  var _a, _b;
+  const table = useTableState(props);
+  (_b = (_a = table.getState().props).debugRender) == null ? void 0 : _b.call(_a, "render table");
+  return tableTheme.jsx(TableContext.Provider, {
+    value: table,
+    children: tableTheme.jsx(TableLoadingState, {})
+  });
+}
+function TableLoadingState() {
+  const {
+    text
+  } = useTheme();
+  const isHydrated = useTableStateStorage();
+  const [showLoading, setShowLoading] = require$$0.useState(false);
+  require$$0.useEffect(() => {
+    const handle = setTimeout(() => setShowLoading(true), 500);
+    return () => clearTimeout(handle);
+  });
+  return tableTheme.jsxs(tableTheme.Fragment, {
+    children: [!isHydrated && showLoading && tableTheme.jsx("div", {
+      children: text.loading
+    }), tableTheme.jsx(TableInner, {
+      hidden: !isHydrated
+    })]
+  });
+}
+const TableInner = require$$0.memo(function TableInner2({
+  hidden
+}) {
+  var _a, _b;
+  const table = useTableContext();
+  const fullWidth = table.useState("props.fullWidth");
+  const activeColumns = table.useState((state) => state.activeColumns.map((column) => ({
+    id: column.id,
+    width: column.width,
+    css: column.css,
+    header: column.header
+  })));
+  const columnWidths = table.useState("columnWidths", {
+    throttle: 16
+  });
+  const columnStyleOverride = table.useState("columnStyleOverride", {
+    throttle: 16
+  });
+  const defaultWidth = table.useState("props.defaultWidth");
+  const css = table.useState("props.css");
+  const stickyHeader = table.useState("props.stickyHeader");
+  const enableSelection = table.useState("props.enableSelection");
+  const enableColumnSelection = table.useState("props.enableColumnSelection");
+  const enableExport = table.useState((state) => !!state.props.enableExport.copy || !!state.props.enableExport.download);
+  const cssVariables = useCssVariables();
+  (_b = (_a = table.getState().props).debugRender) == null ? void 0 : _b.call(_a, "render table inner");
+  return tableTheme.jsx(Virtualized, {
+    css: [cssVariables, tableTheme.defaultClasses.table, css == null ? void 0 : css.table, {
+      gridTemplateColumns: [
+        fullWidth === "right" || fullWidth === true ? "auto" : "0",
+        "max-content",
+        ...activeColumns.map((column) => {
+          var _a2, _b2, _c;
+          return (_c = (_b2 = (_a2 = columnWidths.get(column.id)) != null ? _a2 : column.width) != null ? _b2 : defaultWidth) != null ? _c : "max-content";
+        }),
+        fullWidth === "left" || fullWidth === true ? "auto" : "0"
+      ].join(" ")
+    }, hidden && {
+      visibility: "hidden"
+    }],
+    header: tableTheme.jsxs(tableTheme.Fragment, {
+      children: [tableTheme.jsx("div", {
+        css: [tableTheme.defaultClasses.headerFill, stickyHeader && tableTheme.defaultClasses.sticky, css == null ? void 0 : css.headerCell]
+      }), tableTheme.jsxs("div", {
+        css: [tableTheme.defaultClasses.headerCell, stickyHeader && tableTheme.defaultClasses.sticky, css == null ? void 0 : css.headerCell],
+        children: [enableSelection && tableTheme.jsx(SelectComponent, {}), enableColumnSelection && tableTheme.jsx(ColumnSelection, {}), enableExport && tableTheme.jsx(Export, {})]
+      }), tableTheme.jsx(ColumnHeaderContext.Provider, {
+        children: activeColumns.map((column) => {
+          var _a2;
+          return tableTheme.jsx(ColumnContext.Provider, {
+            value: column.id,
+            children: tableTheme.jsxs(ColumnHeader, {
+              css: [tableTheme.defaultClasses.headerCell, css == null ? void 0 : css.headerCell, (_a2 = column.css) == null ? void 0 : _a2.headerCell, columnStyleOverride.get(column.id), stickyHeader && tableTheme.defaultClasses.sticky],
+              children: [tableTheme.jsx(FilterControl, {}), tableTheme.jsx(SortComponent, {
+                children: column.header
+              }), tableTheme.jsx("div", {
+                css: {
+                  flex: 1
+                }
+              }), tableTheme.jsx(ResizeHandle, {})]
+            }, column.id)
+          }, column.id);
+        })
+      }), tableTheme.jsx("div", {
+        css: [tableTheme.defaultClasses.headerFill, stickyHeader && tableTheme.defaultClasses.sticky, css == null ? void 0 : css.headerCell]
+      })]
+    }),
+    children: (itemIds, startIndex) => itemIds.map((itemId, index) => tableTheme.jsx(Row, {
+      itemId,
+      rowIndex: startIndex + index
+    }, itemId))
+  });
+});
+function toggle(set, value, singleSelect) {
+  const newSet = new Set(singleSelect ? [] : set);
+  if (set.has(value)) {
+    newSet.delete(value);
+  } else {
+    newSet.add(value);
+  }
+  return newSet;
+}
+function SelectFilter(_e) {
+  var _f = _e, {
+    options: providedOptions,
+    stringValue = asString,
+    render = stringValue,
+    singleSelect
+  } = _f, props = __objRest(_f, [
+    "options",
+    "stringValue",
+    "render",
+    "singleSelect"
+  ]);
+  const {
+    components: {
+      TextField,
+      Button,
+      IconButton,
+      Checkbox
+    },
+    icons: {
+      Search,
+      Clear
+    },
+    text
+  } = useTheme();
+  const table = useTableContext();
+  const columnId = useColumnContext();
+  const options = table.useState((state) => {
+    var _a;
+    if (providedOptions)
+      return uniq(providedOptions);
+    const column = state.activeColumns.find((column2) => column2.id === columnId);
+    if (!column)
+      return [];
+    const filterBy = (_a = props.filterBy) != null ? _a : (x2) => x2;
+    return uniq(flatMap(state.items, (item) => castArray(filterBy(column.value(item), item))));
+  });
+  const [query, setQuery] = require$$0.useState("");
+  const filtered = options.filter((option) => !query || stringValue(option).toLowerCase().includes(query.toLowerCase()));
+  const {
+    value = /* @__PURE__ */ new Set(),
+    onChange
+  } = useFilter(__spreadProps(__spreadValues({}, props), {
+    id: "selectFilter",
+    isActive(filterValue) {
+      return filterValue.size > 0;
+    },
+    test(filterValue, value2) {
+      return filterValue.has(value2);
+    }
+  }));
+  return tableTheme.jsxs("div", {
+    css: {
+      padding: "calc(var(--spacing) * 2)",
+      display: "grid",
+      gap: "var(--spacing)"
+    },
+    children: [tableTheme.jsxs("div", {
+      css: {
+        marginBottom: "var(--spacing)",
+        display: "grid",
+        gridAutoFlow: "column",
+        gap: "var(--spacing)",
+        justifyContent: "space-between",
+        alignItems: "center"
+      },
+      children: [tableTheme.jsx("div", {
+        children: text.selectFilter
+      }), tableTheme.jsx(Button, {
+        variant: "contained",
+        onClick: () => onChange(/* @__PURE__ */ new Set()),
+        disabled: value.size === 0,
+        children: text.reset
+      })]
+    }), tableTheme.jsx(TextField, {
+      value: query,
+      onChange: (e2) => setQuery(e2.target.value),
+      endIcon: tableTheme.jsx(IconButton, {
+        onClick: () => setQuery(""),
+        children: !query ? tableTheme.jsx(Search, {}) : tableTheme.jsx(Clear, {})
+      }),
+      css: {
+        marginBottom: "var(--spacing)"
+      }
+    }), filtered.map((option, index) => tableTheme.jsx(FormControlLabel, {
+      control: tableTheme.jsx(Checkbox, {
+        checked: value.has(option),
+        onChange: () => onChange(toggle(value, option, singleSelect))
+      }),
+      label: render(option)
+    }, index)), filtered.length === 0 && tableTheme.jsx("span", {
+      css: {
+        textAlign: "center"
+      },
+      children: text.noResults
+    })]
+  });
+}
+function debounce(fn2, ms) {
+  let lastArgs;
+  let timeout;
+  function run() {
+    const args = lastArgs;
+    lastArgs = void 0;
+    timeout = void 0;
+    fn2(...args);
+  }
+  return Object.assign(function(...args) {
+    lastArgs = args;
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(run, ms);
+  }, {
+    flush() {
+      if (timeout) {
+        clearTimeout(timeout);
+        run();
+      }
+    }
+  });
+}
+function useFilter(impl) {
+  var _a;
+  const table = useTableContext();
+  const columnId = useColumnContext();
+  require$$0.useEffect(() => {
+    table.update((state) => {
+      if (impl.defaultValue !== void 0) {
+        state.filterValues.set(columnId, impl.defaultValue);
+      }
+    });
+  }, []);
+  require$$0.useEffect(() => {
+    table.update((state) => {
+      state.filters.set(columnId, K(impl));
+      if (impl.value !== void 0) {
+        state.filterValues.set(columnId, impl.value);
+      }
+    });
+    return () => {
+      table.update((state) => {
+        state.filters.delete(columnId);
+      });
+    };
+  }, [table, columnId, ...(_a = impl.dependencies) != null ? _a : [impl]]);
+  const value = table.useState((state) => state.filterValues.get(columnId));
+  const [dirtyValue, setDirtyValue] = require$$0.useState();
+  const implRef = require$$0.useRef(impl);
+  require$$0.useLayoutEffect(() => {
+    implRef.current = impl;
+  });
+  const delayedUpdate = require$$0.useMemo(() => debounce((value2) => {
+    const { value: controlledValue, onChange: onChange2 } = implRef.current;
+    if (controlledValue === void 0) {
+      table.update((state) => {
+        state.filterValues.set(columnId, value2);
+      });
+    }
+    onChange2 == null ? void 0 : onChange2(value2);
+  }, 500), [table]);
+  function onChange(value2) {
+    setDirtyValue(value2);
+    delayedUpdate(value2);
+  }
+  require$$0.useEffect(() => delayedUpdate.flush(), [delayedUpdate]);
+  return {
+    value: dirtyValue != null ? dirtyValue : value,
+    onChange
+  };
+}
+const textMatch = (text, query) => {
+  text = text.toLowerCase();
+  query = query.toLowerCase();
+  return query.split(/\s+/).every((part) => termMatch(text, part));
+};
+const termMatch = (text, query) => {
+  let i2 = 0;
+  outer:
+    for (const char of query) {
+      for (; i2 < text.length; i2++) {
+        if (text[i2] === char) {
+          i2++;
+          continue outer;
+        }
+      }
+      return false;
+    }
+  return true;
+};
+function TextFilter(_g) {
+  var _h = _g, {
+    compare = textMatch,
+    filterBy = asStringOrArray
+  } = _h, props = __objRest(_h, [
+    "compare",
+    "filterBy"
+  ]);
+  const {
+    components: {
+      TextField,
+      IconButton,
+      Button
+    },
+    icons: {
+      Search,
+      Clear
+    },
+    text
+  } = useTheme();
+  const {
+    value = "",
+    onChange
+  } = useFilter(__spreadProps(__spreadValues({}, props), {
+    filterBy,
+    id: "textFilter",
+    isActive(filterValue) {
+      return !!filterValue;
+    },
+    test(filterValue, value2) {
+      return compare(value2, filterValue);
+    }
+  }));
+  return tableTheme.jsxs("div", {
+    css: {
+      padding: `calc(var(--spacing) * 2)`,
+      display: "grid",
+      gap: "var(--spacing)"
+    },
+    children: [tableTheme.jsxs("div", {
+      css: {
+        marginBottom: "var(--spacing)",
+        display: "grid",
+        gridAutoFlow: "column",
+        gap: "var(--spacing)",
+        justifyContent: "space-between",
+        alignItems: "center"
+      },
+      children: [tableTheme.jsx("div", {
+        children: text.textFilter
+      }), tableTheme.jsx(Button, {
+        variant: "contained",
+        onClick: () => onChange(""),
+        disabled: !value,
+        children: text.reset
+      })]
+    }), tableTheme.jsx(TextField, {
+      value,
+      onChange: (e2) => onChange(e2.target.value),
+      endIcon: tableTheme.jsx(IconButton, {
+        onClick: () => onChange(""),
+        children: !value ? tableTheme.jsx(Search, {}) : tableTheme.jsx(Clear, {})
+      })
+    })]
+  });
+}
+exports.TableThemeContext = tableTheme.TableThemeContext;
+exports.configureTableTheme = tableTheme.configureTableTheme;
+exports.ColumnContext = ColumnContext;
+exports.DateFilter = DateFilter;
+exports.SelectFilter = SelectFilter;
+exports.Table = Table;
+exports.TableContext = TableContext;
+exports.TextFilter = TextFilter;
+exports.termMatch = termMatch;
+exports.textMatch = textMatch;
+exports.useColumnContext = useColumnContext;
+exports.useFilter = useFilter;
+exports.useTableContext = useTableContext;
+exports.useTheme = useTheme;
+//# sourceMappingURL=index.js.map