Latest repo

node_modules/react-big-calendar/lib/Agenda.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _addClass = _interopRequireDefault(require("dom-helpers/addClass"));
+var _removeClass = _interopRequireDefault(require("dom-helpers/removeClass"));
+var _width = _interopRequireDefault(require("dom-helpers/width"));
+var _scrollbarSize = _interopRequireDefault(require("dom-helpers/scrollbarSize"));
+var _constants = require("./utils/constants");
+var _eventLevels = require("./utils/eventLevels");
+var _selection = require("./utils/selection");
+var DEFAULT_LENGTH = 30;
+function Agenda(_ref) {
+  var accessors = _ref.accessors,
+    components = _ref.components,
+    date = _ref.date,
+    events = _ref.events,
+    getters = _ref.getters,
+    _ref$length = _ref.length,
+    length = _ref$length === void 0 ? DEFAULT_LENGTH : _ref$length,
+    localizer = _ref.localizer,
+    onDoubleClickEvent = _ref.onDoubleClickEvent,
+    onSelectEvent = _ref.onSelectEvent,
+    selected = _ref.selected;
+  var headerRef = (0, _react.useRef)(null);
+  var dateColRef = (0, _react.useRef)(null);
+  var timeColRef = (0, _react.useRef)(null);
+  var contentRef = (0, _react.useRef)(null);
+  var tbodyRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(function () {
+    _adjustHeader();
+  });
+  var renderDay = function renderDay(day, events, dayKey) {
+    var Event = components.event,
+      AgendaDate = components.date;
+    events = events.filter(function (e) {
+      return (0, _eventLevels.inRange)(e, localizer.startOf(day, 'day'), localizer.endOf(day, 'day'), accessors, localizer);
+    });
+    return events.map(function (event, idx) {
+      var title = accessors.title(event);
+      var end = accessors.end(event);
+      var start = accessors.start(event);
+      var userProps = getters.eventProp(event, start, end, (0, _selection.isSelected)(event, selected));
+      var dateLabel = idx === 0 && localizer.format(day, 'agendaDateFormat');
+      var first = idx === 0 ? /*#__PURE__*/_react.default.createElement("td", {
+        rowSpan: events.length,
+        className: "rbc-agenda-date-cell"
+      }, AgendaDate ? /*#__PURE__*/_react.default.createElement(AgendaDate, {
+        day: day,
+        label: dateLabel
+      }) : dateLabel) : false;
+      return /*#__PURE__*/_react.default.createElement("tr", {
+        key: dayKey + '_' + idx,
+        className: userProps.className,
+        style: userProps.style
+      }, first, /*#__PURE__*/_react.default.createElement("td", {
+        className: "rbc-agenda-time-cell"
+      }, timeRangeLabel(day, event)), /*#__PURE__*/_react.default.createElement("td", {
+        className: "rbc-agenda-event-cell",
+        onClick: function onClick(e) {
+          return onSelectEvent && onSelectEvent(event, e);
+        },
+        onDoubleClick: function onDoubleClick(e) {
+          return onDoubleClickEvent && onDoubleClickEvent(event, e);
+        }
+      }, Event ? /*#__PURE__*/_react.default.createElement(Event, {
+        event: event,
+        title: title
+      }) : title));
+    }, []);
+  };
+  var timeRangeLabel = function timeRangeLabel(day, event) {
+    var labelClass = '',
+      TimeComponent = components.time,
+      label = localizer.messages.allDay;
+    var end = accessors.end(event);
+    var start = accessors.start(event);
+    if (!accessors.allDay(event)) {
+      if (localizer.eq(start, end)) {
+        label = localizer.format(start, 'agendaTimeFormat');
+      } else if (localizer.isSameDate(start, end)) {
+        label = localizer.format({
+          start: start,
+          end: end
+        }, 'agendaTimeRangeFormat');
+      } else if (localizer.isSameDate(day, start)) {
+        label = localizer.format(start, 'agendaTimeFormat');
+      } else if (localizer.isSameDate(day, end)) {
+        label = localizer.format(end, 'agendaTimeFormat');
+      }
+    }
+    if (localizer.gt(day, start, 'day')) labelClass = 'rbc-continues-prior';
+    if (localizer.lt(day, end, 'day')) labelClass += ' rbc-continues-after';
+    return /*#__PURE__*/_react.default.createElement("span", {
+      className: labelClass.trim()
+    }, TimeComponent ? /*#__PURE__*/_react.default.createElement(TimeComponent, {
+      event: event,
+      day: day,
+      label: label
+    }) : label);
+  };
+  var _adjustHeader = function _adjustHeader() {
+    if (!tbodyRef.current) return;
+    var header = headerRef.current;
+    var firstRow = tbodyRef.current.firstChild;
+    if (!firstRow) return;
+    var isOverflowing = contentRef.current.scrollHeight > contentRef.current.clientHeight;
+    var _widths = [];
+    var widths = _widths;
+    _widths = [(0, _width.default)(firstRow.children[0]), (0, _width.default)(firstRow.children[1])];
+    if (widths[0] !== _widths[0] || widths[1] !== _widths[1]) {
+      dateColRef.current.style.width = _widths[0] + 'px';
+      timeColRef.current.style.width = _widths[1] + 'px';
+    }
+    if (isOverflowing) {
+      (0, _addClass.default)(header, 'rbc-header-overflowing');
+      header.style.marginRight = (0, _scrollbarSize.default)() + 'px';
+    } else {
+      (0, _removeClass.default)(header, 'rbc-header-overflowing');
+    }
+  };
+  var messages = localizer.messages;
+  var end = localizer.add(date, length, 'day');
+  var range = localizer.range(date, end, 'day');
+  events = events.filter(function (event) {
+    return (0, _eventLevels.inRange)(event, localizer.startOf(date, 'day'), localizer.endOf(end, 'day'), accessors, localizer);
+  });
+  events.sort(function (a, b) {
+    return +accessors.start(a) - +accessors.start(b);
+  });
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: "rbc-agenda-view"
+  }, events.length !== 0 ? /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("table", {
+    ref: headerRef,
+    className: "rbc-agenda-table"
+  }, /*#__PURE__*/_react.default.createElement("thead", null, /*#__PURE__*/_react.default.createElement("tr", null, /*#__PURE__*/_react.default.createElement("th", {
+    className: "rbc-header",
+    ref: dateColRef
+  }, messages.date), /*#__PURE__*/_react.default.createElement("th", {
+    className: "rbc-header",
+    ref: timeColRef
+  }, messages.time), /*#__PURE__*/_react.default.createElement("th", {
+    className: "rbc-header"
+  }, messages.event)))), /*#__PURE__*/_react.default.createElement("div", {
+    className: "rbc-agenda-content",
+    ref: contentRef
+  }, /*#__PURE__*/_react.default.createElement("table", {
+    className: "rbc-agenda-table"
+  }, /*#__PURE__*/_react.default.createElement("tbody", {
+    ref: tbodyRef
+  }, range.map(function (day, idx) {
+    return renderDay(day, events, idx);
+  }))))) : /*#__PURE__*/_react.default.createElement("span", {
+    className: "rbc-agenda-empty"
+  }, messages.noEventsInRange));
+}
+Agenda.range = function (start, _ref2) {
+  var _ref2$length = _ref2.length,
+    length = _ref2$length === void 0 ? DEFAULT_LENGTH : _ref2$length,
+    localizer = _ref2.localizer;
+  var end = localizer.add(start, length, 'day');
+  return {
+    start: start,
+    end: end
+  };
+};
+Agenda.navigate = function (date, action, _ref3) {
+  var _ref3$length = _ref3.length,
+    length = _ref3$length === void 0 ? DEFAULT_LENGTH : _ref3$length,
+    localizer = _ref3.localizer;
+  switch (action) {
+    case _constants.navigate.PREVIOUS:
+      return localizer.add(date, -length, 'day');
+    case _constants.navigate.NEXT:
+      return localizer.add(date, length, 'day');
+    default:
+      return date;
+  }
+};
+Agenda.title = function (start, _ref4) {
+  var _ref4$length = _ref4.length,
+    length = _ref4$length === void 0 ? DEFAULT_LENGTH : _ref4$length,
+    localizer = _ref4.localizer;
+  var end = localizer.add(start, length, 'day');
+  return localizer.format({
+    start: start,
+    end: end
+  }, 'agendaHeaderFormat');
+};
+var _default = exports.default = Agenda;

node_modules/react-big-calendar/lib/BackgroundCells.js

@@ -0,0 +1,182 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireWildcard(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _helpers = require("./utils/helpers");
+var _selection = require("./utils/selection");
+var _Selection = _interopRequireWildcard(require("./Selection"));
+var BackgroundCells = /*#__PURE__*/function (_React$Component) {
+  function BackgroundCells(props, context) {
+    var _this;
+    (0, _classCallCheck2.default)(this, BackgroundCells);
+    _this = (0, _callSuper2.default)(this, BackgroundCells, [props, context]);
+    _this.state = {
+      selecting: false
+    };
+    _this.containerRef = /*#__PURE__*/(0, _react.createRef)();
+    return _this;
+  }
+  (0, _inherits2.default)(BackgroundCells, _React$Component);
+  return (0, _createClass2.default)(BackgroundCells, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.props.selectable && this._selectable();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._teardownSelectable();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (!prevProps.selectable && this.props.selectable) this._selectable();
+      if (prevProps.selectable && !this.props.selectable) this._teardownSelectable();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        range = _this$props.range,
+        getNow = _this$props.getNow,
+        getters = _this$props.getters,
+        currentDate = _this$props.date,
+        Wrapper = _this$props.components.dateCellWrapper,
+        localizer = _this$props.localizer;
+      var _this$state = this.state,
+        selecting = _this$state.selecting,
+        startIdx = _this$state.startIdx,
+        endIdx = _this$state.endIdx;
+      var current = getNow();
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-row-bg",
+        ref: this.containerRef
+      }, range.map(function (date, index) {
+        var selected = selecting && index >= startIdx && index <= endIdx;
+        var _getters$dayProp = getters.dayProp(date),
+          className = _getters$dayProp.className,
+          style = _getters$dayProp.style;
+        return /*#__PURE__*/_react.default.createElement(Wrapper, {
+          key: index,
+          value: date,
+          range: range
+        }, /*#__PURE__*/_react.default.createElement("div", {
+          style: style,
+          className: (0, _clsx.default)('rbc-day-bg', className, selected && 'rbc-selected-cell', localizer.isSameDate(date, current) && 'rbc-today', currentDate && localizer.neq(currentDate, date, 'month') && 'rbc-off-range-bg')
+        }));
+      }));
+    }
+  }, {
+    key: "_selectable",
+    value: function _selectable() {
+      var _this2 = this;
+      var node = this.containerRef.current;
+      var selector = this._selector = new _Selection.default(this.props.container, {
+        longPressThreshold: this.props.longPressThreshold
+      });
+      var selectorClicksHandler = function selectorClicksHandler(point, actionType) {
+        if (!(0, _Selection.isEvent)(node, point) && !(0, _Selection.isShowMore)(node, point)) {
+          var rowBox = (0, _Selection.getBoundsForNode)(node);
+          var _this2$props = _this2.props,
+            range = _this2$props.range,
+            rtl = _this2$props.rtl;
+          if ((0, _selection.pointInBox)(rowBox, point)) {
+            var currentCell = (0, _selection.getSlotAtX)(rowBox, point.x, rtl, range.length);
+            _this2._selectSlot({
+              startIdx: currentCell,
+              endIdx: currentCell,
+              action: actionType,
+              box: point
+            });
+          }
+        }
+        _this2._initial = {};
+        _this2.setState({
+          selecting: false
+        });
+      };
+      selector.on('selecting', function (box) {
+        var _this2$props2 = _this2.props,
+          range = _this2$props2.range,
+          rtl = _this2$props2.rtl;
+        var startIdx = -1;
+        var endIdx = -1;
+        if (!_this2.state.selecting) {
+          (0, _helpers.notify)(_this2.props.onSelectStart, [box]);
+          _this2._initial = {
+            x: box.x,
+            y: box.y
+          };
+        }
+        if (selector.isSelected(node)) {
+          var nodeBox = (0, _Selection.getBoundsForNode)(node);
+          var _dateCellSelection = (0, _selection.dateCellSelection)(_this2._initial, nodeBox, box, range.length, rtl);
+          startIdx = _dateCellSelection.startIdx;
+          endIdx = _dateCellSelection.endIdx;
+        }
+        _this2.setState({
+          selecting: true,
+          startIdx: startIdx,
+          endIdx: endIdx
+        });
+      });
+      selector.on('beforeSelect', function (box) {
+        if (_this2.props.selectable !== 'ignoreEvents') return;
+        return !(0, _Selection.isEvent)(_this2.containerRef.current, box);
+      });
+      selector.on('click', function (point) {
+        return selectorClicksHandler(point, 'click');
+      });
+      selector.on('doubleClick', function (point) {
+        return selectorClicksHandler(point, 'doubleClick');
+      });
+      selector.on('select', function (bounds) {
+        _this2._selectSlot((0, _objectSpread2.default)((0, _objectSpread2.default)({}, _this2.state), {}, {
+          action: 'select',
+          bounds: bounds
+        }));
+        _this2._initial = {};
+        _this2.setState({
+          selecting: false
+        });
+        (0, _helpers.notify)(_this2.props.onSelectEnd, [_this2.state]);
+      });
+    }
+  }, {
+    key: "_teardownSelectable",
+    value: function _teardownSelectable() {
+      if (!this._selector) return;
+      this._selector.teardown();
+      this._selector = null;
+    }
+  }, {
+    key: "_selectSlot",
+    value: function _selectSlot(_ref) {
+      var endIdx = _ref.endIdx,
+        startIdx = _ref.startIdx,
+        action = _ref.action,
+        bounds = _ref.bounds,
+        box = _ref.box;
+      if (endIdx !== -1 && startIdx !== -1) this.props.onSelectSlot && this.props.onSelectSlot({
+        start: startIdx,
+        end: endIdx,
+        action: action,
+        bounds: bounds,
+        box: box,
+        resourceId: this.props.resourceId
+      });
+    }
+  }]);
+}(_react.default.Component);
+var _default = exports.default = BackgroundCells;

node_modules/react-big-calendar/lib/BackgroundWrapper.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _NoopWrapper = _interopRequireDefault(require("./NoopWrapper"));
+var _default = exports.default = _NoopWrapper.default;

node_modules/react-big-calendar/lib/Calendar.js

@@ -0,0 +1,360 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _react = _interopRequireDefault(require("react"));
+var _uncontrollable = require("uncontrollable");
+var _propTypes = require("./utils/propTypes");
+var _localizer = require("./localizer");
+var _NoopWrapper = _interopRequireDefault(require("./NoopWrapper"));
+var _Toolbar = _interopRequireDefault(require("./Toolbar"));
+var _constants = require("./utils/constants");
+var _helpers = require("./utils/helpers");
+var _messages = _interopRequireDefault(require("./utils/messages"));
+var _move = _interopRequireDefault(require("./utils/move"));
+var _Views = _interopRequireDefault(require("./Views"));
+var _defaults = _interopRequireDefault(require("lodash/defaults"));
+var _mapValues = _interopRequireDefault(require("lodash/mapValues"));
+var _omit = _interopRequireDefault(require("lodash/omit"));
+var _transform = _interopRequireDefault(require("lodash/transform"));
+var _accessors = require("./utils/accessors");
+var _excluded = ["view", "date", "getNow", "onNavigate"],
+  _excluded2 = ["view", "toolbar", "events", "backgroundEvents", "resourceGroupingLayout", "style", "className", "elementProps", "date", "getNow", "length", "showMultiDayTimes", "onShowMore", "doShowMoreDrillDown", "components", "formats", "messages", "culture"];
+function viewNames(_views) {
+  if (Array.isArray(_views)) {
+    return _views;
+  }
+  var views = [];
+  for (var _i = 0, _Object$entries = Object.entries(_views); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (value) {
+      views.push(key);
+    }
+  }
+  return views;
+}
+function isValidView(view, _ref) {
+  var _views = _ref.views;
+  var names = viewNames(_views);
+  return names.indexOf(view) !== -1;
+}
+var Calendar = /*#__PURE__*/function (_React$Component) {
+  function Calendar() {
+    var _this;
+    (0, _classCallCheck2.default)(this, Calendar);
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, Calendar, [].concat(_args));
+    _this.getViews = function () {
+      var views = _this.props.views;
+      if (Array.isArray(views)) {
+        return (0, _transform.default)(views, function (obj, name) {
+          return obj[name] = _Views.default[name];
+        }, {});
+      }
+      if ((0, _typeof2.default)(views) === 'object') {
+        return (0, _mapValues.default)(views, function (value, key) {
+          if (value === true) {
+            return _Views.default[key];
+          }
+          return value;
+        });
+      }
+      return _Views.default;
+    };
+    _this.getView = function () {
+      var views = _this.getViews();
+      return views[_this.props.view];
+    };
+    _this.getDrilldownView = function (date) {
+      var _this$props = _this.props,
+        view = _this$props.view,
+        drilldownView = _this$props.drilldownView,
+        getDrilldownView = _this$props.getDrilldownView;
+      if (!getDrilldownView) return drilldownView;
+      return getDrilldownView(date, view, Object.keys(_this.getViews()));
+    };
+    /**
+     *
+     * @param date
+     * @param viewComponent
+     * @param {'month'|'week'|'work_week'|'day'|'agenda'} [view] - optional
+     * parameter. It appears when range change on view changing. It could be handy
+     * when you need to have both: range and view type at once, i.e. for manage rbc
+     * state via url
+     */
+    _this.handleRangeChange = function (date, viewComponent, view) {
+      var _this$props2 = _this.props,
+        onRangeChange = _this$props2.onRangeChange,
+        localizer = _this$props2.localizer;
+      if (onRangeChange) {
+        if (viewComponent.range) {
+          onRangeChange(viewComponent.range(date, {
+            localizer: localizer
+          }), view);
+        } else {
+          if (process.env.NODE_ENV !== 'production') {
+            console.error('onRangeChange prop not supported for this view');
+          }
+        }
+      }
+    };
+    _this.handleNavigate = function (action, newDate) {
+      var _this$props3 = _this.props,
+        view = _this$props3.view,
+        date = _this$props3.date,
+        getNow = _this$props3.getNow,
+        onNavigate = _this$props3.onNavigate,
+        props = (0, _objectWithoutProperties2.default)(_this$props3, _excluded);
+      var ViewComponent = _this.getView();
+      var today = getNow();
+      date = (0, _move.default)(ViewComponent, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+        action: action,
+        date: newDate || date || today,
+        today: today
+      }));
+      onNavigate(date, view, action);
+      _this.handleRangeChange(date, ViewComponent);
+    };
+    _this.handleViewChange = function (view) {
+      if (view !== _this.props.view && isValidView(view, _this.props)) {
+        _this.props.onView(view);
+      }
+      var views = _this.getViews();
+      _this.handleRangeChange(_this.props.date || _this.props.getNow(), views[view], view);
+    };
+    _this.handleSelectEvent = function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      (0, _helpers.notify)(_this.props.onSelectEvent, args);
+    };
+    _this.handleDoubleClickEvent = function () {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      (0, _helpers.notify)(_this.props.onDoubleClickEvent, args);
+    };
+    _this.handleKeyPressEvent = function () {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      (0, _helpers.notify)(_this.props.onKeyPressEvent, args);
+    };
+    _this.handleSelectSlot = function (slotInfo) {
+      (0, _helpers.notify)(_this.props.onSelectSlot, slotInfo);
+    };
+    _this.handleDrillDown = function (date, view) {
+      var onDrillDown = _this.props.onDrillDown;
+      if (onDrillDown) {
+        onDrillDown(date, view, _this.drilldownView);
+        return;
+      }
+      if (view) _this.handleViewChange(view);
+      _this.handleNavigate(_constants.navigate.DATE, date);
+    };
+    _this.state = {
+      context: Calendar.getContext(_this.props)
+    };
+    return _this;
+  }
+  (0, _inherits2.default)(Calendar, _React$Component);
+  return (0, _createClass2.default)(Calendar, [{
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+        view = _this$props4.view,
+        toolbar = _this$props4.toolbar,
+        events = _this$props4.events,
+        backgroundEvents = _this$props4.backgroundEvents,
+        resourceGroupingLayout = _this$props4.resourceGroupingLayout,
+        style = _this$props4.style,
+        className = _this$props4.className,
+        elementProps = _this$props4.elementProps,
+        current = _this$props4.date,
+        getNow = _this$props4.getNow,
+        length = _this$props4.length,
+        showMultiDayTimes = _this$props4.showMultiDayTimes,
+        onShowMore = _this$props4.onShowMore,
+        doShowMoreDrillDown = _this$props4.doShowMoreDrillDown,
+        _0 = _this$props4.components,
+        _1 = _this$props4.formats,
+        _2 = _this$props4.messages,
+        _3 = _this$props4.culture,
+        props = (0, _objectWithoutProperties2.default)(_this$props4, _excluded2);
+      current = current || getNow();
+      var View = this.getView();
+      var _this$state$context = this.state.context,
+        accessors = _this$state$context.accessors,
+        components = _this$state$context.components,
+        getters = _this$state$context.getters,
+        localizer = _this$state$context.localizer,
+        viewNames = _this$state$context.viewNames;
+      var CalToolbar = components.toolbar || _Toolbar.default;
+      var label = View.title(current, {
+        localizer: localizer,
+        length: length
+      });
+      return /*#__PURE__*/_react.default.createElement("div", Object.assign({}, elementProps, {
+        className: (0, _clsx.default)(className, 'rbc-calendar', props.rtl && 'rbc-rtl'),
+        style: style
+      }), toolbar && /*#__PURE__*/_react.default.createElement(CalToolbar, {
+        date: current,
+        view: view,
+        views: viewNames,
+        label: label,
+        onView: this.handleViewChange,
+        onNavigate: this.handleNavigate,
+        localizer: localizer
+      }), /*#__PURE__*/_react.default.createElement(View, Object.assign({}, props, {
+        events: events,
+        backgroundEvents: backgroundEvents,
+        date: current,
+        getNow: getNow,
+        length: length,
+        localizer: localizer,
+        getters: getters,
+        components: components,
+        accessors: accessors,
+        showMultiDayTimes: showMultiDayTimes,
+        getDrilldownView: this.getDrilldownView,
+        onNavigate: this.handleNavigate,
+        onDrillDown: this.handleDrillDown,
+        onSelectEvent: this.handleSelectEvent,
+        onDoubleClickEvent: this.handleDoubleClickEvent,
+        onKeyPressEvent: this.handleKeyPressEvent,
+        onSelectSlot: this.handleSelectSlot,
+        onShowMore: onShowMore,
+        doShowMoreDrillDown: doShowMoreDrillDown,
+        resourceGroupingLayout: resourceGroupingLayout
+      })));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps) {
+      return {
+        context: Calendar.getContext(nextProps)
+      };
+    }
+  }, {
+    key: "getContext",
+    value: function getContext(_ref2) {
+      var startAccessor = _ref2.startAccessor,
+        endAccessor = _ref2.endAccessor,
+        allDayAccessor = _ref2.allDayAccessor,
+        tooltipAccessor = _ref2.tooltipAccessor,
+        titleAccessor = _ref2.titleAccessor,
+        resourceAccessor = _ref2.resourceAccessor,
+        resourceIdAccessor = _ref2.resourceIdAccessor,
+        resourceTitleAccessor = _ref2.resourceTitleAccessor,
+        eventIdAccessor = _ref2.eventIdAccessor,
+        eventPropGetter = _ref2.eventPropGetter,
+        backgroundEventPropGetter = _ref2.backgroundEventPropGetter,
+        slotPropGetter = _ref2.slotPropGetter,
+        slotGroupPropGetter = _ref2.slotGroupPropGetter,
+        dayPropGetter = _ref2.dayPropGetter,
+        view = _ref2.view,
+        views = _ref2.views,
+        localizer = _ref2.localizer,
+        culture = _ref2.culture,
+        _ref2$messages = _ref2.messages,
+        messages = _ref2$messages === void 0 ? {} : _ref2$messages,
+        _ref2$components = _ref2.components,
+        components = _ref2$components === void 0 ? {} : _ref2$components,
+        _ref2$formats = _ref2.formats,
+        formats = _ref2$formats === void 0 ? {} : _ref2$formats;
+      var names = viewNames(views);
+      var msgs = (0, _messages.default)(messages);
+      return {
+        viewNames: names,
+        localizer: (0, _localizer.mergeWithDefaults)(localizer, culture, formats, msgs),
+        getters: {
+          eventProp: function eventProp() {
+            return eventPropGetter && eventPropGetter.apply(void 0, arguments) || {};
+          },
+          backgroundEventProp: function backgroundEventProp() {
+            return backgroundEventPropGetter && backgroundEventPropGetter.apply(void 0, arguments) || {};
+          },
+          slotProp: function slotProp() {
+            return slotPropGetter && slotPropGetter.apply(void 0, arguments) || {};
+          },
+          slotGroupProp: function slotGroupProp() {
+            return slotGroupPropGetter && slotGroupPropGetter.apply(void 0, arguments) || {};
+          },
+          dayProp: function dayProp() {
+            return dayPropGetter && dayPropGetter.apply(void 0, arguments) || {};
+          }
+        },
+        components: (0, _defaults.default)(components[view] || {}, (0, _omit.default)(components, names), {
+          eventWrapper: _NoopWrapper.default,
+          backgroundEventWrapper: _NoopWrapper.default,
+          eventContainerWrapper: _NoopWrapper.default,
+          dateCellWrapper: _NoopWrapper.default,
+          weekWrapper: _NoopWrapper.default,
+          timeSlotWrapper: _NoopWrapper.default,
+          timeGutterWrapper: _NoopWrapper.default,
+          timeIndicatorWrapper: _NoopWrapper.default
+        }),
+        accessors: {
+          start: (0, _accessors.wrapAccessor)(startAccessor),
+          end: (0, _accessors.wrapAccessor)(endAccessor),
+          allDay: (0, _accessors.wrapAccessor)(allDayAccessor),
+          tooltip: (0, _accessors.wrapAccessor)(tooltipAccessor),
+          title: (0, _accessors.wrapAccessor)(titleAccessor),
+          resource: (0, _accessors.wrapAccessor)(resourceAccessor),
+          resourceId: (0, _accessors.wrapAccessor)(resourceIdAccessor),
+          resourceTitle: (0, _accessors.wrapAccessor)(resourceTitleAccessor),
+          eventId: (0, _accessors.wrapAccessor)(eventIdAccessor)
+        }
+      };
+    }
+  }]);
+}(_react.default.Component);
+Calendar.defaultProps = {
+  events: [],
+  backgroundEvents: [],
+  elementProps: {},
+  popup: false,
+  toolbar: true,
+  view: _constants.views.MONTH,
+  views: [_constants.views.MONTH, _constants.views.WEEK, _constants.views.DAY, _constants.views.AGENDA],
+  step: 30,
+  length: 30,
+  allDayMaxRows: Infinity,
+  doShowMoreDrillDown: true,
+  drilldownView: _constants.views.DAY,
+  titleAccessor: 'title',
+  tooltipAccessor: 'title',
+  allDayAccessor: 'allDay',
+  startAccessor: 'start',
+  endAccessor: 'end',
+  resourceAccessor: 'resourceId',
+  resourceIdAccessor: 'id',
+  resourceTitleAccessor: 'title',
+  eventIdAccessor: 'id',
+  longPressThreshold: 250,
+  getNow: function getNow() {
+    return new Date();
+  },
+  dayLayoutAlgorithm: 'overlap'
+};
+var _default = exports.default = (0, _uncontrollable.uncontrollable)(Calendar, {
+  view: 'onView',
+  date: 'onNavigate',
+  selected: 'onSelectEvent'
+});

node_modules/react-big-calendar/lib/CalendarContext.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _default = exports.default = /*#__PURE__*/_react.default.createContext();

node_modules/react-big-calendar/lib/DateContentRow.js

@@ -0,0 +1,196 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireWildcard(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _height = _interopRequireDefault(require("dom-helpers/height"));
+var _querySelectorAll = _interopRequireDefault(require("dom-helpers/querySelectorAll"));
+var _BackgroundCells = _interopRequireDefault(require("./BackgroundCells"));
+var _EventRow = _interopRequireDefault(require("./EventRow"));
+var _EventEndingRow = _interopRequireDefault(require("./EventEndingRow"));
+var _NoopWrapper = _interopRequireDefault(require("./NoopWrapper"));
+var _ScrollableWeekWrapper = _interopRequireDefault(require("./ScrollableWeekWrapper"));
+var DateSlotMetrics = _interopRequireWildcard(require("./utils/DateSlotMetrics"));
+var DateContentRow = /*#__PURE__*/function (_React$Component) {
+  function DateContentRow() {
+    var _this;
+    (0, _classCallCheck2.default)(this, DateContentRow);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, DateContentRow, [].concat(args));
+    _this.handleSelectSlot = function (slot) {
+      var _this$props = _this.props,
+        range = _this$props.range,
+        onSelectSlot = _this$props.onSelectSlot;
+      onSelectSlot(range.slice(slot.start, slot.end + 1), slot);
+    };
+    _this.handleShowMore = function (slot, target) {
+      var _this$props2 = _this.props,
+        range = _this$props2.range,
+        onShowMore = _this$props2.onShowMore;
+      var metrics = _this.slotMetrics(_this.props);
+      var row = (0, _querySelectorAll.default)(_this.containerRef.current, '.rbc-row-bg')[0];
+      var cell;
+      if (row) cell = row.children[slot - 1];
+      var events = metrics.getEventsForSlot(slot);
+      onShowMore(events, range[slot - 1], cell, slot, target);
+    };
+    _this.getContainer = function () {
+      var container = _this.props.container;
+      return container ? container() : _this.containerRef.current;
+    };
+    _this.renderHeadingCell = function (date, index) {
+      var _this$props3 = _this.props,
+        renderHeader = _this$props3.renderHeader,
+        getNow = _this$props3.getNow,
+        localizer = _this$props3.localizer;
+      return renderHeader({
+        date: date,
+        key: "header_".concat(index),
+        className: (0, _clsx.default)('rbc-date-cell', localizer.isSameDate(date, getNow()) && 'rbc-now')
+      });
+    };
+    _this.renderDummy = function () {
+      var _this$props4 = _this.props,
+        className = _this$props4.className,
+        range = _this$props4.range,
+        renderHeader = _this$props4.renderHeader,
+        showAllEvents = _this$props4.showAllEvents;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: className,
+        ref: _this.containerRef
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: (0, _clsx.default)('rbc-row-content', showAllEvents && 'rbc-row-content-scrollable')
+      }, renderHeader && /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-row",
+        ref: _this.headingRowRef
+      }, range.map(_this.renderHeadingCell)), /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-row",
+        ref: _this.eventRowRef
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-row-segment"
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-event"
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-event-content"
+      }, "\xA0"))))));
+    };
+    _this.containerRef = /*#__PURE__*/(0, _react.createRef)();
+    _this.headingRowRef = /*#__PURE__*/(0, _react.createRef)();
+    _this.eventRowRef = /*#__PURE__*/(0, _react.createRef)();
+    _this.slotMetrics = DateSlotMetrics.getSlotMetrics();
+    return _this;
+  }
+  (0, _inherits2.default)(DateContentRow, _React$Component);
+  return (0, _createClass2.default)(DateContentRow, [{
+    key: "getRowLimit",
+    value: function getRowLimit() {
+      var _this$headingRowRef;
+      /* Guessing this only gets called on the dummyRow */
+      var eventHeight = (0, _height.default)(this.eventRowRef.current);
+      var headingHeight = (_this$headingRowRef = this.headingRowRef) !== null && _this$headingRowRef !== void 0 && _this$headingRowRef.current ? (0, _height.default)(this.headingRowRef.current) : 0;
+      var eventSpace = (0, _height.default)(this.containerRef.current) - headingHeight;
+      return Math.max(Math.floor(eventSpace / eventHeight), 1);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props5 = this.props,
+        date = _this$props5.date,
+        rtl = _this$props5.rtl,
+        range = _this$props5.range,
+        className = _this$props5.className,
+        selected = _this$props5.selected,
+        selectable = _this$props5.selectable,
+        renderForMeasure = _this$props5.renderForMeasure,
+        accessors = _this$props5.accessors,
+        getters = _this$props5.getters,
+        components = _this$props5.components,
+        getNow = _this$props5.getNow,
+        renderHeader = _this$props5.renderHeader,
+        onSelect = _this$props5.onSelect,
+        localizer = _this$props5.localizer,
+        onSelectStart = _this$props5.onSelectStart,
+        onSelectEnd = _this$props5.onSelectEnd,
+        onDoubleClick = _this$props5.onDoubleClick,
+        onKeyPress = _this$props5.onKeyPress,
+        resourceId = _this$props5.resourceId,
+        longPressThreshold = _this$props5.longPressThreshold,
+        isAllDay = _this$props5.isAllDay,
+        resizable = _this$props5.resizable,
+        showAllEvents = _this$props5.showAllEvents;
+      if (renderForMeasure) return this.renderDummy();
+      var metrics = this.slotMetrics(this.props);
+      var levels = metrics.levels,
+        extra = metrics.extra;
+      var ScrollableWeekComponent = showAllEvents ? _ScrollableWeekWrapper.default : _NoopWrapper.default;
+      var WeekWrapper = components.weekWrapper;
+      var eventRowProps = {
+        selected: selected,
+        accessors: accessors,
+        getters: getters,
+        localizer: localizer,
+        components: components,
+        onSelect: onSelect,
+        onDoubleClick: onDoubleClick,
+        onKeyPress: onKeyPress,
+        resourceId: resourceId,
+        slotMetrics: metrics,
+        resizable: resizable
+      };
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: className,
+        role: "rowgroup",
+        ref: this.containerRef
+      }, /*#__PURE__*/_react.default.createElement(_BackgroundCells.default, {
+        localizer: localizer,
+        date: date,
+        getNow: getNow,
+        rtl: rtl,
+        range: range,
+        selectable: selectable,
+        container: this.getContainer,
+        getters: getters,
+        onSelectStart: onSelectStart,
+        onSelectEnd: onSelectEnd,
+        onSelectSlot: this.handleSelectSlot,
+        components: components,
+        longPressThreshold: longPressThreshold,
+        resourceId: resourceId
+      }), /*#__PURE__*/_react.default.createElement("div", {
+        className: (0, _clsx.default)('rbc-row-content', showAllEvents && 'rbc-row-content-scrollable'),
+        role: "row"
+      }, renderHeader && /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-row ",
+        ref: this.headingRowRef
+      }, range.map(this.renderHeadingCell)), /*#__PURE__*/_react.default.createElement(ScrollableWeekComponent, null, /*#__PURE__*/_react.default.createElement(WeekWrapper, Object.assign({
+        isAllDay: isAllDay
+      }, eventRowProps, {
+        rtl: this.props.rtl
+      }), levels.map(function (segs, idx) {
+        return /*#__PURE__*/_react.default.createElement(_EventRow.default, Object.assign({
+          key: idx,
+          segments: segs
+        }, eventRowProps));
+      }), !!extra.length && /*#__PURE__*/_react.default.createElement(_EventEndingRow.default, Object.assign({
+        segments: extra,
+        onShowMore: this.handleShowMore
+      }, eventRowProps))))));
+    }
+  }]);
+}(_react.default.Component);
+DateContentRow.defaultProps = {
+  minRows: 0,
+  maxRows: Infinity
+};
+var _default = exports.default = DateContentRow;

node_modules/react-big-calendar/lib/DateHeader.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var DateHeader = function DateHeader(_ref) {
+  var label = _ref.label,
+    drilldownView = _ref.drilldownView,
+    onDrillDown = _ref.onDrillDown;
+  if (!drilldownView) {
+    return /*#__PURE__*/_react.default.createElement("span", null, label);
+  }
+  return /*#__PURE__*/_react.default.createElement("button", {
+    type: "button",
+    className: "rbc-button-link",
+    onClick: onDrillDown
+  }, label);
+};
+var _default = exports.default = DateHeader;

node_modules/react-big-calendar/lib/Day.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _constants = require("./utils/constants");
+var _propTypes = require("./utils/propTypes");
+var _TimeGrid = _interopRequireDefault(require("./TimeGrid"));
+var _excluded = ["date", "localizer", "min", "max", "scrollToTime", "enableAutoScroll"];
+var Day = /*#__PURE__*/function (_React$Component) {
+  function Day() {
+    (0, _classCallCheck2.default)(this, Day);
+    return (0, _callSuper2.default)(this, Day, arguments);
+  }
+  (0, _inherits2.default)(Day, _React$Component);
+  return (0, _createClass2.default)(Day, [{
+    key: "render",
+    value: function render() {
+      /**
+       * This allows us to default min, max, and scrollToTime
+       * using our localizer. This is necessary until such time
+       * as TODO: TimeGrid is converted to a functional component.
+       */
+      var _this$props = this.props,
+        date = _this$props.date,
+        localizer = _this$props.localizer,
+        _this$props$min = _this$props.min,
+        min = _this$props$min === void 0 ? localizer.startOf(new Date(), 'day') : _this$props$min,
+        _this$props$max = _this$props.max,
+        max = _this$props$max === void 0 ? localizer.endOf(new Date(), 'day') : _this$props$max,
+        _this$props$scrollToT = _this$props.scrollToTime,
+        scrollToTime = _this$props$scrollToT === void 0 ? localizer.startOf(new Date(), 'day') : _this$props$scrollToT,
+        _this$props$enableAut = _this$props.enableAutoScroll,
+        enableAutoScroll = _this$props$enableAut === void 0 ? true : _this$props$enableAut,
+        props = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+      var range = Day.range(date, {
+        localizer: localizer
+      });
+      return /*#__PURE__*/_react.default.createElement(_TimeGrid.default, Object.assign({}, props, {
+        range: range,
+        eventOffset: 10,
+        localizer: localizer,
+        min: min,
+        max: max,
+        scrollToTime: scrollToTime,
+        enableAutoScroll: enableAutoScroll
+      }));
+    }
+  }]);
+}(_react.default.Component);
+Day.range = function (date, _ref) {
+  var localizer = _ref.localizer;
+  return [localizer.startOf(date, 'day')];
+};
+Day.navigate = function (date, action, _ref2) {
+  var localizer = _ref2.localizer;
+  switch (action) {
+    case _constants.navigate.PREVIOUS:
+      return localizer.add(date, -1, 'day');
+    case _constants.navigate.NEXT:
+      return localizer.add(date, 1, 'day');
+    default:
+      return date;
+  }
+};
+Day.title = function (date, _ref3) {
+  var localizer = _ref3.localizer;
+  return localizer.format(date, 'dayHeaderFormat');
+};
+var _default = exports.default = Day;

node_modules/react-big-calendar/lib/DayColumn.js

@@ -0,0 +1,421 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireWildcard(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _Selection = _interopRequireWildcard(require("./Selection"));
+var TimeSlotUtils = _interopRequireWildcard(require("./utils/TimeSlots"));
+var _selection = require("./utils/selection");
+var _helpers = require("./utils/helpers");
+var DayEventLayout = _interopRequireWildcard(require("./utils/DayEventLayout"));
+var _TimeSlotGroup = _interopRequireDefault(require("./TimeSlotGroup"));
+var _TimeGridEvent = _interopRequireDefault(require("./TimeGridEvent"));
+var _propTypes = require("./utils/propTypes");
+var _DayColumnWrapper = _interopRequireDefault(require("./DayColumnWrapper"));
+var _excluded = ["dayProp"],
+  _excluded2 = ["eventContainerWrapper", "timeIndicatorWrapper"];
+var DayColumn = /*#__PURE__*/function (_React$Component) {
+  function DayColumn() {
+    var _this;
+    (0, _classCallCheck2.default)(this, DayColumn);
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, DayColumn, [].concat(_args));
+    _this.state = {
+      selecting: false,
+      timeIndicatorPosition: null
+    };
+    _this.intervalTriggered = false;
+    _this.renderEvents = function (_ref) {
+      var events = _ref.events,
+        isBackgroundEvent = _ref.isBackgroundEvent;
+      var _this$props = _this.props,
+        rtl = _this$props.rtl,
+        selected = _this$props.selected,
+        accessors = _this$props.accessors,
+        localizer = _this$props.localizer,
+        getters = _this$props.getters,
+        components = _this$props.components,
+        step = _this$props.step,
+        timeslots = _this$props.timeslots,
+        dayLayoutAlgorithm = _this$props.dayLayoutAlgorithm,
+        resizable = _this$props.resizable;
+      var _this2 = _this,
+        slotMetrics = _this2.slotMetrics;
+      var messages = localizer.messages;
+      var styledEvents = DayEventLayout.getStyledEvents({
+        events: events,
+        accessors: accessors,
+        slotMetrics: slotMetrics,
+        minimumStartDifference: Math.ceil(step * timeslots / 2),
+        dayLayoutAlgorithm: dayLayoutAlgorithm
+      });
+      return styledEvents.map(function (_ref2, idx) {
+        var _accessors$eventId;
+        var event = _ref2.event,
+          style = _ref2.style;
+        var end = accessors.end(event);
+        var start = accessors.start(event);
+        var key = (_accessors$eventId = accessors.eventId(event)) !== null && _accessors$eventId !== void 0 ? _accessors$eventId : 'evt_' + idx;
+        var format = 'eventTimeRangeFormat';
+        var label;
+        var startsBeforeDay = slotMetrics.startsBeforeDay(start);
+        var startsAfterDay = slotMetrics.startsAfterDay(end);
+        if (startsBeforeDay) format = 'eventTimeRangeEndFormat';else if (startsAfterDay) format = 'eventTimeRangeStartFormat';
+        if (startsBeforeDay && startsAfterDay) label = messages.allDay;else label = localizer.format({
+          start: start,
+          end: end
+        }, format);
+        var continuesPrior = startsBeforeDay || slotMetrics.startsBefore(start);
+        var continuesAfter = startsAfterDay || slotMetrics.startsAfter(end);
+        return /*#__PURE__*/_react.default.createElement(_TimeGridEvent.default, {
+          style: style,
+          event: event,
+          label: label,
+          key: key,
+          getters: getters,
+          rtl: rtl,
+          components: components,
+          continuesPrior: continuesPrior,
+          continuesAfter: continuesAfter,
+          accessors: accessors,
+          resource: _this.props.resource,
+          selected: (0, _selection.isSelected)(event, selected),
+          onClick: function onClick(e) {
+            return _this._select((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, event), _this.props.resource && {
+              sourceResource: _this.props.resource
+            }), isBackgroundEvent && {
+              isBackgroundEvent: true
+            }), e);
+          },
+          onDoubleClick: function onDoubleClick(e) {
+            return _this._doubleClick(event, e);
+          },
+          isBackgroundEvent: isBackgroundEvent,
+          onKeyPress: function onKeyPress(e) {
+            return _this._keyPress(event, e);
+          },
+          resizable: resizable
+        });
+      });
+    };
+    _this._selectable = function () {
+      var node = _this.containerRef.current;
+      var _this$props2 = _this.props,
+        longPressThreshold = _this$props2.longPressThreshold,
+        localizer = _this$props2.localizer;
+      var selector = _this._selector = new _Selection.default(function () {
+        return node;
+      }, {
+        longPressThreshold: longPressThreshold
+      });
+      var maybeSelect = function maybeSelect(box) {
+        var onSelecting = _this.props.onSelecting;
+        var current = _this.state || {};
+        var state = selectionState(box);
+        var start = state.startDate,
+          end = state.endDate;
+        if (onSelecting) {
+          if (localizer.eq(current.startDate, start, 'minutes') && localizer.eq(current.endDate, end, 'minutes') || onSelecting({
+            start: start,
+            end: end,
+            resourceId: _this.props.resource
+          }) === false) return;
+        }
+        if (_this.state.start !== state.start || _this.state.end !== state.end || _this.state.selecting !== state.selecting) {
+          _this.setState(state);
+        }
+      };
+      var selectionState = function selectionState(point) {
+        var currentSlot = _this.slotMetrics.closestSlotFromPoint(point, (0, _Selection.getBoundsForNode)(node));
+        if (!_this.state.selecting) {
+          _this._initialSlot = currentSlot;
+        }
+        var initialSlot = _this._initialSlot;
+        if (localizer.lte(initialSlot, currentSlot)) {
+          currentSlot = _this.slotMetrics.nextSlot(currentSlot);
+        } else if (localizer.gt(initialSlot, currentSlot)) {
+          initialSlot = _this.slotMetrics.nextSlot(initialSlot);
+        }
+        var selectRange = _this.slotMetrics.getRange(localizer.min(initialSlot, currentSlot), localizer.max(initialSlot, currentSlot));
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, selectRange), {}, {
+          selecting: true,
+          top: "".concat(selectRange.top, "%"),
+          height: "".concat(selectRange.height, "%")
+        });
+      };
+      var selectorClicksHandler = function selectorClicksHandler(box, actionType) {
+        if (!(0, _Selection.isEvent)(_this.containerRef.current, box)) {
+          var _selectionState = selectionState(box),
+            startDate = _selectionState.startDate,
+            endDate = _selectionState.endDate;
+          _this._selectSlot({
+            startDate: startDate,
+            endDate: endDate,
+            action: actionType,
+            box: box
+          });
+        }
+        _this.setState({
+          selecting: false
+        });
+      };
+      selector.on('selecting', maybeSelect);
+      selector.on('selectStart', maybeSelect);
+      selector.on('beforeSelect', function (box) {
+        if (_this.props.selectable !== 'ignoreEvents') return;
+        return !(0, _Selection.isEvent)(_this.containerRef.current, box);
+      });
+      selector.on('click', function (box) {
+        return selectorClicksHandler(box, 'click');
+      });
+      selector.on('doubleClick', function (box) {
+        return selectorClicksHandler(box, 'doubleClick');
+      });
+      selector.on('select', function (bounds) {
+        if (_this.state.selecting) {
+          _this._selectSlot((0, _objectSpread2.default)((0, _objectSpread2.default)({}, _this.state), {}, {
+            action: 'select',
+            bounds: bounds
+          }));
+          _this.setState({
+            selecting: false
+          });
+        }
+      });
+      selector.on('reset', function () {
+        if (_this.state.selecting) {
+          _this.setState({
+            selecting: false
+          });
+        }
+      });
+    };
+    _this._teardownSelectable = function () {
+      if (!_this._selector) return;
+      _this._selector.teardown();
+      _this._selector = null;
+    };
+    _this._selectSlot = function (_ref3) {
+      var startDate = _ref3.startDate,
+        endDate = _ref3.endDate,
+        action = _ref3.action,
+        bounds = _ref3.bounds,
+        box = _ref3.box;
+      var current = startDate,
+        slots = [];
+      while (_this.props.localizer.lte(current, endDate)) {
+        slots.push(current);
+        current = new Date(+current + _this.props.step * 60 * 1000); // using Date ensures not to create an endless loop the day DST begins
+      }
+      (0, _helpers.notify)(_this.props.onSelectSlot, {
+        slots: slots,
+        start: startDate,
+        end: endDate,
+        resourceId: _this.props.resource,
+        action: action,
+        bounds: bounds,
+        box: box
+      });
+    };
+    _this._select = function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      (0, _helpers.notify)(_this.props.onSelectEvent, args);
+    };
+    _this._doubleClick = function () {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      (0, _helpers.notify)(_this.props.onDoubleClickEvent, args);
+    };
+    _this._keyPress = function () {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      (0, _helpers.notify)(_this.props.onKeyPressEvent, args);
+    };
+    _this.slotMetrics = TimeSlotUtils.getSlotMetrics(_this.props);
+    _this.containerRef = /*#__PURE__*/(0, _react.createRef)();
+    return _this;
+  }
+  (0, _inherits2.default)(DayColumn, _React$Component);
+  return (0, _createClass2.default)(DayColumn, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.props.selectable && this._selectable();
+      if (this.props.isNow) {
+        this.setTimeIndicatorPositionUpdateInterval();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._teardownSelectable();
+      this.clearTimeIndicatorInterval();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (this.props.selectable && !prevProps.selectable) this._selectable();
+      if (!this.props.selectable && prevProps.selectable) this._teardownSelectable();
+      var _this$props3 = this.props,
+        getNow = _this$props3.getNow,
+        isNow = _this$props3.isNow,
+        localizer = _this$props3.localizer,
+        date = _this$props3.date,
+        min = _this$props3.min,
+        max = _this$props3.max;
+      var getNowChanged = localizer.neq(prevProps.getNow(), getNow(), 'minutes');
+      if (prevProps.isNow !== isNow || getNowChanged) {
+        this.clearTimeIndicatorInterval();
+        if (isNow) {
+          var tail = !getNowChanged && localizer.eq(prevProps.date, date, 'minutes') && prevState.timeIndicatorPosition === this.state.timeIndicatorPosition;
+          this.setTimeIndicatorPositionUpdateInterval(tail);
+        }
+      } else if (isNow && (localizer.neq(prevProps.min, min, 'minutes') || localizer.neq(prevProps.max, max, 'minutes'))) {
+        this.positionTimeIndicator();
+      }
+    }
+
+    /**
+     * @param tail {Boolean} - whether `positionTimeIndicator` call should be
+     *   deferred or called upon setting interval (`true` - if deferred);
+     */
+  }, {
+    key: "setTimeIndicatorPositionUpdateInterval",
+    value: function setTimeIndicatorPositionUpdateInterval() {
+      var _this3 = this;
+      var tail = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      if (!this.intervalTriggered && !tail) {
+        this.positionTimeIndicator();
+      }
+      this._timeIndicatorTimeout = window.setTimeout(function () {
+        _this3.intervalTriggered = true;
+        _this3.positionTimeIndicator();
+        _this3.setTimeIndicatorPositionUpdateInterval();
+      }, 60000);
+    }
+  }, {
+    key: "clearTimeIndicatorInterval",
+    value: function clearTimeIndicatorInterval() {
+      this.intervalTriggered = false;
+      window.clearTimeout(this._timeIndicatorTimeout);
+    }
+  }, {
+    key: "positionTimeIndicator",
+    value: function positionTimeIndicator() {
+      var _this$props4 = this.props,
+        min = _this$props4.min,
+        max = _this$props4.max,
+        getNow = _this$props4.getNow;
+      var current = getNow();
+      if (current >= min && current <= max) {
+        var top = this.slotMetrics.getCurrentTimePosition(current);
+        this.intervalTriggered = true;
+        this.setState({
+          timeIndicatorPosition: top
+        });
+      } else {
+        this.clearTimeIndicatorInterval();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props5 = this.props,
+        date = _this$props5.date,
+        max = _this$props5.max,
+        rtl = _this$props5.rtl,
+        isNow = _this$props5.isNow,
+        resource = _this$props5.resource,
+        accessors = _this$props5.accessors,
+        localizer = _this$props5.localizer,
+        _this$props5$getters = _this$props5.getters,
+        dayProp = _this$props5$getters.dayProp,
+        getters = (0, _objectWithoutProperties2.default)(_this$props5$getters, _excluded),
+        _this$props5$componen = _this$props5.components,
+        EventContainer = _this$props5$componen.eventContainerWrapper,
+        TimeIndicatorWrapper = _this$props5$componen.timeIndicatorWrapper,
+        components = (0, _objectWithoutProperties2.default)(_this$props5$componen, _excluded2);
+      this.slotMetrics = this.slotMetrics.update(this.props);
+      var slotMetrics = this.slotMetrics;
+      var _this$state = this.state,
+        selecting = _this$state.selecting,
+        top = _this$state.top,
+        height = _this$state.height,
+        startDate = _this$state.startDate,
+        endDate = _this$state.endDate;
+      var selectDates = {
+        start: startDate,
+        end: endDate
+      };
+      var _dayProp = dayProp(max, resource),
+        className = _dayProp.className,
+        style = _dayProp.style;
+      var timeIndicatorProps = {
+        className: 'rbc-current-time-indicator',
+        style: {
+          top: "".concat(this.state.timeIndicatorPosition, "%")
+        }
+      };
+      var DayColumnWrapperComponent = components.dayColumnWrapper || _DayColumnWrapper.default;
+      return /*#__PURE__*/_react.default.createElement(DayColumnWrapperComponent, {
+        ref: this.containerRef,
+        date: date,
+        style: style,
+        className: (0, _clsx.default)(className, 'rbc-day-slot', 'rbc-time-column', isNow && 'rbc-now', isNow && 'rbc-today',
+        // WHY
+        selecting && 'rbc-slot-selecting'),
+        slotMetrics: slotMetrics,
+        resource: resource
+      }, slotMetrics.groups.map(function (grp, idx) {
+        return /*#__PURE__*/_react.default.createElement(_TimeSlotGroup.default, {
+          key: idx,
+          group: grp,
+          resource: resource,
+          getters: getters,
+          components: components
+        });
+      }), /*#__PURE__*/_react.default.createElement(EventContainer, {
+        localizer: localizer,
+        resource: resource,
+        accessors: accessors,
+        getters: getters,
+        components: components,
+        slotMetrics: slotMetrics
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: (0, _clsx.default)('rbc-events-container', rtl && 'rtl')
+      }, this.renderEvents({
+        events: this.props.backgroundEvents,
+        isBackgroundEvent: true
+      }), this.renderEvents({
+        events: this.props.events
+      }))), selecting && /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-slot-selection",
+        style: {
+          top: top,
+          height: height
+        }
+      }, /*#__PURE__*/_react.default.createElement("span", null, localizer.format(selectDates, 'selectRangeFormat'))), isNow && this.intervalTriggered && /*#__PURE__*/_react.default.createElement(TimeIndicatorWrapper, timeIndicatorProps, /*#__PURE__*/_react.default.createElement("div", timeIndicatorProps)));
+    }
+  }]);
+}(_react.default.Component);
+DayColumn.defaultProps = {
+  dragThroughEvents: true,
+  timeslots: 2
+};
+var _default = exports.default = DayColumn;

node_modules/react-big-calendar/lib/DayColumnWrapper.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var DayColumnWrapper = function DayColumnWrapper(_ref) {
+  var children = _ref.children,
+    className = _ref.className,
+    style = _ref.style,
+    innerRef = _ref.innerRef;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: className,
+    style: style,
+    ref: innerRef
+  }, children);
+};
+var _default = exports.default = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  return /*#__PURE__*/_react.default.createElement(DayColumnWrapper, Object.assign({}, props, {
+    innerRef: ref
+  }));
+});

node_modules/react-big-calendar/lib/EventCell.js

@@ -0,0 +1,91 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _excluded = ["style", "className", "event", "selected", "isAllDay", "onSelect", "onDoubleClick", "onKeyPress", "localizer", "continuesPrior", "continuesAfter", "accessors", "getters", "children", "components", "slotStart", "slotEnd"];
+var EventCell = /*#__PURE__*/function (_React$Component) {
+  function EventCell() {
+    (0, _classCallCheck2.default)(this, EventCell);
+    return (0, _callSuper2.default)(this, EventCell, arguments);
+  }
+  (0, _inherits2.default)(EventCell, _React$Component);
+  return (0, _createClass2.default)(EventCell, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        style = _this$props.style,
+        className = _this$props.className,
+        event = _this$props.event,
+        selected = _this$props.selected,
+        isAllDay = _this$props.isAllDay,
+        onSelect = _this$props.onSelect,
+        _onDoubleClick = _this$props.onDoubleClick,
+        onKeyPress = _this$props.onKeyPress,
+        localizer = _this$props.localizer,
+        continuesPrior = _this$props.continuesPrior,
+        continuesAfter = _this$props.continuesAfter,
+        accessors = _this$props.accessors,
+        getters = _this$props.getters,
+        children = _this$props.children,
+        _this$props$component = _this$props.components,
+        Event = _this$props$component.event,
+        EventWrapper = _this$props$component.eventWrapper,
+        slotStart = _this$props.slotStart,
+        slotEnd = _this$props.slotEnd,
+        props = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+      delete props.resizable;
+      var title = accessors.title(event);
+      var tooltip = accessors.tooltip(event);
+      var end = accessors.end(event);
+      var start = accessors.start(event);
+      var allDay = accessors.allDay(event);
+      var showAsAllDay = isAllDay || allDay || localizer.diff(start, localizer.ceil(end, 'day'), 'day') > 1;
+      var userProps = getters.eventProp(event, start, end, selected);
+      var content = /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-event-content",
+        title: tooltip || undefined
+      }, Event ? /*#__PURE__*/_react.default.createElement(Event, {
+        event: event,
+        continuesPrior: continuesPrior,
+        continuesAfter: continuesAfter,
+        title: title,
+        isAllDay: allDay,
+        localizer: localizer,
+        slotStart: slotStart,
+        slotEnd: slotEnd
+      }) : title);
+      return /*#__PURE__*/_react.default.createElement(EventWrapper, Object.assign({}, this.props, {
+        type: "date"
+      }), /*#__PURE__*/_react.default.createElement("div", Object.assign({}, props, {
+        style: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, userProps.style), style),
+        className: (0, _clsx.default)('rbc-event', className, userProps.className, {
+          'rbc-selected': selected,
+          'rbc-event-allday': showAsAllDay,
+          'rbc-event-continues-prior': continuesPrior,
+          'rbc-event-continues-after': continuesAfter
+        }),
+        onClick: function onClick(e) {
+          return onSelect && onSelect(event, e);
+        },
+        onDoubleClick: function onDoubleClick(e) {
+          return _onDoubleClick && _onDoubleClick(event, e);
+        },
+        onKeyDown: function onKeyDown(e) {
+          return onKeyPress && onKeyPress(event, e);
+        }
+      }), typeof children === 'function' ? children(content) : content));
+    }
+  }]);
+}(_react.default.Component);
+var _default = exports.default = EventCell;

node_modules/react-big-calendar/lib/EventEndingRow.js

@@ -0,0 +1,167 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _EventRowMixin = _interopRequireDefault(require("./EventRowMixin"));
+var _eventLevels = require("./utils/eventLevels");
+var _range = _interopRequireDefault(require("lodash/range"));
+// Modified: Check if a segment spans through this slot (including events that started earlier)
+var isSegmentInSlot = function isSegmentInSlot(seg, slot) {
+  return seg.left <= slot && seg.right >= slot;
+};
+var eventsInSlot = function eventsInSlot(segments, slot) {
+  return segments.filter(function (seg) {
+    return isSegmentInSlot(seg, slot);
+  }).map(function (seg) {
+    return seg.event;
+  });
+};
+var EventEndingRow = /*#__PURE__*/function (_React$Component) {
+  function EventEndingRow() {
+    (0, _classCallCheck2.default)(this, EventEndingRow);
+    return (0, _callSuper2.default)(this, EventEndingRow, arguments);
+  }
+  (0, _inherits2.default)(EventEndingRow, _React$Component);
+  return (0, _createClass2.default)(EventEndingRow, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        segments = _this$props.segments,
+        slots = _this$props.slotMetrics.slots;
+      var rowSegments = (0, _eventLevels.eventLevels)(segments).levels[0];
+      var current = 1,
+        lastEnd = 1,
+        row = [];
+      while (current <= slots) {
+        var key = '_lvl_' + current;
+
+        // Find segment that starts at or spans through current slot
+        var _ref = rowSegments.filter(function (seg) {
+            return isSegmentInSlot(seg, current);
+          })[0] || {},
+          event = _ref.event,
+          left = _ref.left,
+          right = _ref.right,
+          span = _ref.span;
+        if (!event) {
+          // No visible event starts at this slot, but check if we need a "more" button
+          // for hidden events that span this slot
+          var hiddenEvents = this.getHiddenEventsForSlot(segments, current);
+          if (hiddenEvents.length > 0) {
+            var _gap = current - lastEnd;
+            if (_gap) {
+              row.push(_EventRowMixin.default.renderSpan(slots, _gap, key + '_gap'));
+            }
+            row.push(_EventRowMixin.default.renderSpan(slots, 1, key, this.renderShowMore(segments, current)));
+            lastEnd = current = current + 1;
+            continue;
+          }
+          current++;
+          continue;
+        }
+        var gap = Math.max(0, left - lastEnd);
+        if (this.canRenderSlotEvent(left, span)) {
+          var content = _EventRowMixin.default.renderEvent(this.props, event);
+          if (gap) {
+            row.push(_EventRowMixin.default.renderSpan(slots, gap, key + '_gap'));
+          }
+          row.push(_EventRowMixin.default.renderSpan(slots, span, key, content));
+          lastEnd = current = right + 1;
+        } else {
+          if (gap) {
+            row.push(_EventRowMixin.default.renderSpan(slots, gap, key + '_gap'));
+          }
+          row.push(_EventRowMixin.default.renderSpan(slots, 1, key, this.renderShowMore(segments, current)));
+          lastEnd = current = current + 1;
+        }
+      }
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-row"
+      }, row);
+    }
+
+    // New helper method to find hidden events for a slot
+  }, {
+    key: "getHiddenEventsForSlot",
+    value: function getHiddenEventsForSlot(segments, slot) {
+      // Get all events (visible and hidden) for this slot
+      var allEventsInSlot = eventsInSlot(segments, slot);
+
+      // Get visible events for this slot from the first level
+      var rowSegments = (0, _eventLevels.eventLevels)(segments).levels[0];
+      var visibleEventsInSlot = rowSegments.filter(function (seg) {
+        return isSegmentInSlot(seg, slot);
+      }).map(function (seg) {
+        return seg.event;
+      });
+
+      // Return events that are in allEventsInSlot but not in visibleEventsInSlot
+      return allEventsInSlot.filter(function (event) {
+        return !visibleEventsInSlot.some(function (visEvent) {
+          return visEvent === event;
+        });
+      });
+    }
+  }, {
+    key: "canRenderSlotEvent",
+    value: function canRenderSlotEvent(slot, span) {
+      var segments = this.props.segments;
+      return (0, _range.default)(slot, slot + span).every(function (s) {
+        var count = eventsInSlot(segments, s).length;
+        return count === 1;
+      });
+    }
+  }, {
+    key: "renderShowMore",
+    value: function renderShowMore(segments, slot) {
+      var _this = this;
+      var _this$props2 = this.props,
+        localizer = _this$props2.localizer,
+        slotMetrics = _this$props2.slotMetrics,
+        components = _this$props2.components;
+      var events = slotMetrics.getEventsForSlot(slot);
+      var remainingEvents = eventsInSlot(segments, slot);
+      var count = remainingEvents.length;
+      if (components !== null && components !== void 0 && components.showMore) {
+        var ShowMore = components.showMore;
+        // The received slot seems to be 1-based, but the range we use to pull the date is 0-based
+        var slotDate = slotMetrics.getDateForSlot(slot - 1);
+        return count ? /*#__PURE__*/_react.default.createElement(ShowMore, {
+          localizer: localizer,
+          slotDate: slotDate,
+          slot: slot,
+          count: count,
+          events: events,
+          remainingEvents: remainingEvents
+        }) : false;
+      }
+      return count ? /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        key: 'sm_' + slot,
+        className: (0, _clsx.default)('rbc-button-link', 'rbc-show-more'),
+        onClick: function onClick(e) {
+          return _this.showMore(slot, e);
+        }
+      }, localizer.messages.showMore(count, remainingEvents, events)) : false;
+    }
+  }, {
+    key: "showMore",
+    value: function showMore(slot, e) {
+      e.preventDefault();
+      e.stopPropagation();
+      this.props.onShowMore(slot, e.target);
+    }
+  }]);
+}(_react.default.Component);
+EventEndingRow.defaultProps = (0, _objectSpread2.default)({}, _EventRowMixin.default.defaultProps);
+var _default = exports.default = EventEndingRow;

node_modules/react-big-calendar/lib/EventRow.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _react = _interopRequireDefault(require("react"));
+var _EventRowMixin = _interopRequireDefault(require("./EventRowMixin"));
+var EventRow = /*#__PURE__*/function (_React$Component) {
+  function EventRow() {
+    (0, _classCallCheck2.default)(this, EventRow);
+    return (0, _callSuper2.default)(this, EventRow, arguments);
+  }
+  (0, _inherits2.default)(EventRow, _React$Component);
+  return (0, _createClass2.default)(EventRow, [{
+    key: "render",
+    value: function render() {
+      var _this = this;
+      var _this$props = this.props,
+        segments = _this$props.segments,
+        slots = _this$props.slotMetrics.slots,
+        className = _this$props.className;
+      var lastEnd = 1;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: (0, _clsx.default)(className, 'rbc-row')
+      }, segments.reduce(function (row, _ref, li) {
+        var event = _ref.event,
+          left = _ref.left,
+          right = _ref.right,
+          span = _ref.span;
+        var key = '_lvl_' + li;
+        var gap = left - lastEnd;
+        var content = _EventRowMixin.default.renderEvent(_this.props, event);
+        if (gap) row.push(_EventRowMixin.default.renderSpan(slots, gap, "".concat(key, "_gap")));
+        row.push(_EventRowMixin.default.renderSpan(slots, span, key, content));
+        lastEnd = right + 1;
+        return row;
+      }, []));
+    }
+  }]);
+}(_react.default.Component);
+EventRow.defaultProps = (0, _objectSpread2.default)({}, _EventRowMixin.default.defaultProps);
+var _default = exports.default = EventRow;

node_modules/react-big-calendar/lib/EventRowMixin.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _react = _interopRequireDefault(require("react"));
+var _EventCell = _interopRequireDefault(require("./EventCell"));
+var _selection = require("./utils/selection");
+/* eslint-disable react/prop-types */
+var _default = exports.default = {
+  propTypes: {
+    slotMetrics: _propTypes.default.object.isRequired,
+    selected: _propTypes.default.object,
+    isAllDay: _propTypes.default.bool,
+    accessors: _propTypes.default.object.isRequired,
+    localizer: _propTypes.default.object.isRequired,
+    components: _propTypes.default.object.isRequired,
+    getters: _propTypes.default.object.isRequired,
+    onSelect: _propTypes.default.func,
+    onDoubleClick: _propTypes.default.func,
+    onKeyPress: _propTypes.default.func
+  },
+  defaultProps: {
+    segments: [],
+    selected: {}
+  },
+  renderEvent: function renderEvent(props, event) {
+    var selected = props.selected,
+      _ = props.isAllDay,
+      accessors = props.accessors,
+      getters = props.getters,
+      onSelect = props.onSelect,
+      onDoubleClick = props.onDoubleClick,
+      onKeyPress = props.onKeyPress,
+      localizer = props.localizer,
+      slotMetrics = props.slotMetrics,
+      components = props.components,
+      resizable = props.resizable;
+    var continuesPrior = slotMetrics.continuesPrior(event);
+    var continuesAfter = slotMetrics.continuesAfter(event);
+    return /*#__PURE__*/_react.default.createElement(_EventCell.default, {
+      event: event,
+      getters: getters,
+      localizer: localizer,
+      accessors: accessors,
+      components: components,
+      onSelect: onSelect,
+      onDoubleClick: onDoubleClick,
+      onKeyPress: onKeyPress,
+      continuesPrior: continuesPrior,
+      continuesAfter: continuesAfter,
+      slotStart: slotMetrics.first,
+      slotEnd: slotMetrics.last,
+      selected: (0, _selection.isSelected)(event, selected),
+      resizable: resizable
+    });
+  },
+  renderSpan: function renderSpan(slots, len, key) {
+    var content = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ' ';
+    var per = Math.abs(len) / slots * 100 + '%';
+    return /*#__PURE__*/_react.default.createElement("div", {
+      key: key,
+      className: "rbc-row-segment"
+      // IE10/11 need max-width. flex-basis doesn't respect box-sizing
+      ,
+      style: {
+        WebkitFlexBasis: per,
+        flexBasis: per,
+        maxWidth: per
+      }
+    }, content);
+  }
+};

node_modules/react-big-calendar/lib/EventWrapper.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _NoopWrapper = _interopRequireDefault(require("./NoopWrapper"));
+var _default = exports.default = _NoopWrapper.default;

node_modules/react-big-calendar/lib/Header.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _react = _interopRequireDefault(require("react"));
+var Header = function Header(_ref) {
+  var label = _ref.label;
+  return /*#__PURE__*/_react.default.createElement("span", {
+    role: "columnheader",
+    "aria-sort": "none"
+  }, label);
+};
+Header.propTypes = process.env.NODE_ENV !== "production" ? {
+  label: _propTypes.default.node
+} : {};
+var _default = exports.default = Header;

node_modules/react-big-calendar/lib/Month.js

@@ -0,0 +1,401 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireWildcard(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _chunk = _interopRequireDefault(require("lodash/chunk"));
+var _constants = require("./utils/constants");
+var _helpers = require("./utils/helpers");
+var _position = _interopRequireDefault(require("dom-helpers/position"));
+var animationFrame = _interopRequireWildcard(require("dom-helpers/animationFrame"));
+var _PopOverlay = _interopRequireDefault(require("./PopOverlay"));
+var _DateContentRow = _interopRequireDefault(require("./DateContentRow"));
+var _Header = _interopRequireDefault(require("./Header"));
+var _DateHeader = _interopRequireDefault(require("./DateHeader"));
+var _eventLevels = require("./utils/eventLevels");
+var _excluded = ["date", "className"];
+/* import Popup from './Popup'
+import Overlay from 'react-overlays/Overlay' */
+var eventsForWeek = function eventsForWeek(evts, start, end, accessors, localizer) {
+  return evts.filter(function (e) {
+    return (0, _eventLevels.inRange)(e, start, end, accessors, localizer);
+  });
+};
+var MonthView = /*#__PURE__*/function (_React$Component) {
+  function MonthView() {
+    var _this;
+    (0, _classCallCheck2.default)(this, MonthView);
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, MonthView, [].concat(_args));
+    _this.getContainer = function () {
+      return _this.containerRef.current;
+    };
+    _this.renderWeek = function (week, weekIdx) {
+      var _this$props = _this.props,
+        events = _this$props.events,
+        components = _this$props.components,
+        selectable = _this$props.selectable,
+        getNow = _this$props.getNow,
+        selected = _this$props.selected,
+        date = _this$props.date,
+        localizer = _this$props.localizer,
+        longPressThreshold = _this$props.longPressThreshold,
+        accessors = _this$props.accessors,
+        getters = _this$props.getters,
+        showAllEvents = _this$props.showAllEvents;
+      var _this$state = _this.state,
+        needLimitMeasure = _this$state.needLimitMeasure,
+        rowLimit = _this$state.rowLimit;
+
+      // let's not mutate props
+      var weeksEvents = eventsForWeek((0, _toConsumableArray2.default)(events), week[0], week[week.length - 1], accessors, localizer);
+      var sorted = (0, _eventLevels.sortWeekEvents)(weeksEvents, accessors, localizer);
+      return /*#__PURE__*/_react.default.createElement(_DateContentRow.default, {
+        key: weekIdx,
+        ref: weekIdx === 0 ? _this.slotRowRef : undefined,
+        container: _this.getContainer,
+        className: "rbc-month-row",
+        getNow: getNow,
+        date: date,
+        range: week,
+        events: sorted,
+        maxRows: showAllEvents ? Infinity : rowLimit,
+        selected: selected,
+        selectable: selectable,
+        components: components,
+        accessors: accessors,
+        getters: getters,
+        localizer: localizer,
+        renderHeader: _this.readerDateHeading,
+        renderForMeasure: needLimitMeasure,
+        onShowMore: _this.handleShowMore,
+        onSelect: _this.handleSelectEvent,
+        onDoubleClick: _this.handleDoubleClickEvent,
+        onKeyPress: _this.handleKeyPressEvent,
+        onSelectSlot: _this.handleSelectSlot,
+        longPressThreshold: longPressThreshold,
+        rtl: _this.props.rtl,
+        resizable: _this.props.resizable,
+        showAllEvents: showAllEvents
+      });
+    };
+    _this.readerDateHeading = function (_ref) {
+      var date = _ref.date,
+        className = _ref.className,
+        props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+      var _this$props2 = _this.props,
+        currentDate = _this$props2.date,
+        getDrilldownView = _this$props2.getDrilldownView,
+        localizer = _this$props2.localizer;
+      var isOffRange = localizer.neq(currentDate, date, 'month');
+      var isCurrent = localizer.isSameDate(date, currentDate);
+      var drilldownView = getDrilldownView(date);
+      var label = localizer.format(date, 'dateFormat');
+      var DateHeaderComponent = _this.props.components.dateHeader || _DateHeader.default;
+      return /*#__PURE__*/_react.default.createElement("div", Object.assign({}, props, {
+        className: (0, _clsx.default)(className, isOffRange && 'rbc-off-range', isCurrent && 'rbc-current'),
+        role: "cell"
+      }), /*#__PURE__*/_react.default.createElement(DateHeaderComponent, {
+        label: label,
+        date: date,
+        drilldownView: drilldownView,
+        isOffRange: isOffRange,
+        onDrillDown: function onDrillDown(e) {
+          return _this.handleHeadingClick(date, drilldownView, e);
+        }
+      }));
+    };
+    _this.handleSelectSlot = function (range, slotInfo) {
+      _this._pendingSelection = _this._pendingSelection.concat(range);
+      clearTimeout(_this._selectTimer);
+      _this._selectTimer = setTimeout(function () {
+        return _this.selectDates(slotInfo);
+      });
+    };
+    _this.handleHeadingClick = function (date, view, e) {
+      e.preventDefault();
+      _this.clearSelection();
+      (0, _helpers.notify)(_this.props.onDrillDown, [date, view]);
+    };
+    _this.handleSelectEvent = function () {
+      _this.clearSelection();
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      (0, _helpers.notify)(_this.props.onSelectEvent, args);
+    };
+    _this.handleDoubleClickEvent = function () {
+      _this.clearSelection();
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      (0, _helpers.notify)(_this.props.onDoubleClickEvent, args);
+    };
+    _this.handleKeyPressEvent = function () {
+      _this.clearSelection();
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      (0, _helpers.notify)(_this.props.onKeyPressEvent, args);
+    };
+    _this.handleShowMore = function (events, date, cell, slot, target) {
+      var _this$props3 = _this.props,
+        popup = _this$props3.popup,
+        onDrillDown = _this$props3.onDrillDown,
+        onShowMore = _this$props3.onShowMore,
+        getDrilldownView = _this$props3.getDrilldownView,
+        doShowMoreDrillDown = _this$props3.doShowMoreDrillDown;
+      //cancel any pending selections so only the event click goes through.
+      _this.clearSelection();
+      if (popup) {
+        var position = (0, _position.default)(cell, _this.containerRef.current);
+        _this.setState({
+          overlay: {
+            date: date,
+            events: events,
+            position: position,
+            target: target
+          }
+        });
+      } else if (doShowMoreDrillDown) {
+        (0, _helpers.notify)(onDrillDown, [date, getDrilldownView(date) || _constants.views.DAY]);
+      }
+      (0, _helpers.notify)(onShowMore, [events, date, slot]);
+    };
+    _this.overlayDisplay = function () {
+      _this.setState({
+        overlay: null
+      });
+    };
+    _this.state = {
+      rowLimit: 5,
+      needLimitMeasure: true,
+      date: null
+    };
+    _this.containerRef = /*#__PURE__*/(0, _react.createRef)();
+    _this.slotRowRef = /*#__PURE__*/(0, _react.createRef)();
+    _this._bgRows = [];
+    _this._pendingSelection = [];
+    return _this;
+  }
+  (0, _inherits2.default)(MonthView, _React$Component);
+  return (0, _createClass2.default)(MonthView, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+      var running;
+      if (this.state.needLimitMeasure) this.measureRowLimit(this.props);
+      window.addEventListener('resize', this._resizeListener = function () {
+        if (!running) {
+          animationFrame.request(function () {
+            running = false;
+            _this2.setState({
+              needLimitMeasure: true
+            }); //eslint-disable-line
+          });
+        }
+      }, false);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      if (this.state.needLimitMeasure) this.measureRowLimit(this.props);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      window.removeEventListener('resize', this._resizeListener, false);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+        date = _this$props4.date,
+        localizer = _this$props4.localizer,
+        className = _this$props4.className,
+        month = localizer.visibleDays(date, localizer),
+        weeks = (0, _chunk.default)(month, 7);
+      this._weekCount = weeks.length;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: (0, _clsx.default)('rbc-month-view', className),
+        role: "table",
+        "aria-label": "Month View",
+        ref: this.containerRef
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-row rbc-month-header",
+        role: "row"
+      }, this.renderHeaders(weeks[0])), weeks.map(this.renderWeek), this.props.popup && this.renderOverlay());
+    }
+  }, {
+    key: "renderHeaders",
+    value: function renderHeaders(row) {
+      var _this$props5 = this.props,
+        localizer = _this$props5.localizer,
+        components = _this$props5.components;
+      var first = row[0];
+      var last = row[row.length - 1];
+      var HeaderComponent = components.header || _Header.default;
+      return localizer.range(first, last, 'day').map(function (day, idx) {
+        return /*#__PURE__*/_react.default.createElement("div", {
+          key: 'header_' + idx,
+          className: "rbc-header"
+        }, /*#__PURE__*/_react.default.createElement(HeaderComponent, {
+          date: day,
+          localizer: localizer,
+          label: localizer.format(day, 'weekdayFormat')
+        }));
+      });
+    }
+  }, {
+    key: "renderOverlay",
+    value: function renderOverlay() {
+      var _this$state$overlay,
+        _this$state2,
+        _this3 = this;
+      var overlay = (_this$state$overlay = (_this$state2 = this.state) === null || _this$state2 === void 0 ? void 0 : _this$state2.overlay) !== null && _this$state$overlay !== void 0 ? _this$state$overlay : {};
+      var _this$props6 = this.props,
+        accessors = _this$props6.accessors,
+        localizer = _this$props6.localizer,
+        components = _this$props6.components,
+        getters = _this$props6.getters,
+        selected = _this$props6.selected,
+        popupOffset = _this$props6.popupOffset,
+        handleDragStart = _this$props6.handleDragStart;
+      var onHide = function onHide() {
+        return _this3.setState({
+          overlay: null
+        });
+      };
+      return /*#__PURE__*/_react.default.createElement(_PopOverlay.default, {
+        overlay: overlay,
+        accessors: accessors,
+        localizer: localizer,
+        components: components,
+        getters: getters,
+        selected: selected,
+        popupOffset: popupOffset,
+        ref: this.containerRef,
+        handleKeyPressEvent: this.handleKeyPressEvent,
+        handleSelectEvent: this.handleSelectEvent,
+        handleDoubleClickEvent: this.handleDoubleClickEvent,
+        handleDragStart: handleDragStart,
+        show: !!overlay.position,
+        overlayDisplay: this.overlayDisplay,
+        onHide: onHide
+      });
+
+      /* return (
+        <Overlay
+          rootClose
+          placement="bottom"
+          show={!!overlay.position}
+          onHide={() => this.setState({ overlay: null })}
+          target={() => overlay.target}
+        >
+          {({ props }) => (
+            <Popup
+              {...props}
+              popupOffset={popupOffset}
+              accessors={accessors}
+              getters={getters}
+              selected={selected}
+              components={components}
+              localizer={localizer}
+              position={overlay.position}
+              show={this.overlayDisplay}
+              events={overlay.events}
+              slotStart={overlay.date}
+              slotEnd={overlay.end}
+              onSelect={this.handleSelectEvent}
+              onDoubleClick={this.handleDoubleClickEvent}
+              onKeyPress={this.handleKeyPressEvent}
+              handleDragStart={this.props.handleDragStart}
+            />
+          )}
+        </Overlay>
+      ) */
+    }
+  }, {
+    key: "measureRowLimit",
+    value: function measureRowLimit() {
+      this.setState({
+        needLimitMeasure: false,
+        rowLimit: this.slotRowRef.current.getRowLimit()
+      });
+    }
+  }, {
+    key: "selectDates",
+    value: function selectDates(slotInfo) {
+      var slots = this._pendingSelection.slice();
+      this._pendingSelection = [];
+      slots.sort(function (a, b) {
+        return +a - +b;
+      });
+      var start = new Date(slots[0]);
+      var end = new Date(slots[slots.length - 1]);
+      end.setDate(slots[slots.length - 1].getDate() + 1);
+      (0, _helpers.notify)(this.props.onSelectSlot, {
+        slots: slots,
+        start: start,
+        end: end,
+        action: slotInfo.action,
+        bounds: slotInfo.bounds,
+        box: slotInfo.box
+      });
+    }
+  }, {
+    key: "clearSelection",
+    value: function clearSelection() {
+      clearTimeout(this._selectTimer);
+      this._pendingSelection = [];
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(_ref2, state) {
+      var date = _ref2.date,
+        localizer = _ref2.localizer;
+      return {
+        date: date,
+        needLimitMeasure: localizer.neq(date, state.date, 'month')
+      };
+    }
+  }]);
+}(_react.default.Component);
+MonthView.range = function (date, _ref3) {
+  var localizer = _ref3.localizer;
+  var start = localizer.firstVisibleDay(date, localizer);
+  var end = localizer.lastVisibleDay(date, localizer);
+  return {
+    start: start,
+    end: end
+  };
+};
+MonthView.navigate = function (date, action, _ref4) {
+  var localizer = _ref4.localizer;
+  switch (action) {
+    case _constants.navigate.PREVIOUS:
+      return localizer.add(date, -1, 'month');
+    case _constants.navigate.NEXT:
+      return localizer.add(date, 1, 'month');
+    default:
+      return date;
+  }
+};
+MonthView.title = function (date, _ref5) {
+  var localizer = _ref5.localizer;
+  return localizer.format(date, 'monthHeaderFormat');
+};
+var _default = exports.default = MonthView;

node_modules/react-big-calendar/lib/NoopWrapper.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function NoopWrapper(props) {
+  return props.children;
+}
+var _default = exports.default = NoopWrapper;

node_modules/react-big-calendar/lib/PopOverlay.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactOverlays = require("react-overlays");
+var _Popup = _interopRequireDefault(require("./Popup"));
+function CalOverlay(_ref) {
+  var containerRef = _ref.containerRef,
+    _ref$popupOffset = _ref.popupOffset,
+    popupOffset = _ref$popupOffset === void 0 ? 5 : _ref$popupOffset,
+    overlay = _ref.overlay,
+    accessors = _ref.accessors,
+    localizer = _ref.localizer,
+    components = _ref.components,
+    getters = _ref.getters,
+    selected = _ref.selected,
+    handleSelectEvent = _ref.handleSelectEvent,
+    handleDoubleClickEvent = _ref.handleDoubleClickEvent,
+    handleKeyPressEvent = _ref.handleKeyPressEvent,
+    handleDragStart = _ref.handleDragStart,
+    onHide = _ref.onHide,
+    overlayDisplay = _ref.overlayDisplay;
+  var popperRef = (0, _react.useRef)(null);
+  if (!overlay.position) return null;
+  var offset = popupOffset;
+  if (!isNaN(popupOffset)) {
+    offset = {
+      x: popupOffset,
+      y: popupOffset
+    };
+  }
+  var position = overlay.position,
+    events = overlay.events,
+    date = overlay.date,
+    end = overlay.end;
+  return /*#__PURE__*/_react.default.createElement(_reactOverlays.Overlay, {
+    rootClose: true,
+    flip: true,
+    show: true,
+    placement: "bottom",
+    onHide: onHide,
+    target: overlay.target
+  }, function (_ref2) {
+    var props = _ref2.props;
+    return /*#__PURE__*/_react.default.createElement(_Popup.default, Object.assign({}, props, {
+      containerRef: containerRef,
+      ref: popperRef,
+      target: overlay.target,
+      offset: offset,
+      accessors: accessors,
+      getters: getters,
+      selected: selected,
+      components: components,
+      localizer: localizer,
+      position: position,
+      show: overlayDisplay,
+      events: events,
+      slotStart: date,
+      slotEnd: end,
+      onSelect: handleSelectEvent,
+      onDoubleClick: handleDoubleClickEvent,
+      onKeyPress: handleKeyPressEvent,
+      handleDragStart: handleDragStart
+    }));
+  });
+}
+var PopOverlay = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  return /*#__PURE__*/_react.default.createElement(CalOverlay, Object.assign({}, props, {
+    containerRef: ref
+  }));
+});
+PopOverlay.propTypes = {
+  popupOffset: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({
+    x: _propTypes.default.number,
+    y: _propTypes.default.number
+  })]),
+  overlay: _propTypes.default.shape({
+    position: _propTypes.default.object,
+    events: _propTypes.default.array,
+    date: _propTypes.default.instanceOf(Date),
+    end: _propTypes.default.instanceOf(Date)
+  }),
+  accessors: _propTypes.default.object.isRequired,
+  localizer: _propTypes.default.object.isRequired,
+  components: _propTypes.default.object.isRequired,
+  getters: _propTypes.default.object.isRequired,
+  selected: _propTypes.default.object,
+  handleSelectEvent: _propTypes.default.func,
+  handleDoubleClickEvent: _propTypes.default.func,
+  handleKeyPressEvent: _propTypes.default.func,
+  handleDragStart: _propTypes.default.func,
+  onHide: _propTypes.default.func,
+  overlayDisplay: _propTypes.default.func
+};
+var _default = exports.default = PopOverlay;

node_modules/react-big-calendar/lib/Popup.js

@@ -0,0 +1,150 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _offset = _interopRequireDefault(require("dom-helpers/offset"));
+var _useClickOutside = _interopRequireDefault(require("./hooks/useClickOutside"));
+var _EventCell = _interopRequireDefault(require("./EventCell"));
+var _selection = require("./utils/selection");
+/**
+ * Changes to react-overlays cause issue with auto positioning,
+ * so we need to manually calculate the position of the popper,
+ * and constrain it to the Month container.
+ */
+function getPosition(_ref) {
+  var target = _ref.target,
+    offset = _ref.offset,
+    container = _ref.container,
+    box = _ref.box;
+  var _getOffset = (0, _offset.default)(target),
+    top = _getOffset.top,
+    left = _getOffset.left,
+    width = _getOffset.width,
+    height = _getOffset.height;
+  var _getOffset2 = (0, _offset.default)(container),
+    cTop = _getOffset2.top,
+    cLeft = _getOffset2.left,
+    cWidth = _getOffset2.width,
+    cHeight = _getOffset2.height;
+  var _getOffset3 = (0, _offset.default)(box),
+    bWidth = _getOffset3.width,
+    bHeight = _getOffset3.height;
+  var viewBottom = cTop + cHeight;
+  var viewRight = cLeft + cWidth;
+  var bottom = top + bHeight;
+  var right = left + bWidth;
+  var x = offset.x,
+    y = offset.y;
+  var topOffset = bottom > viewBottom ? top - bHeight - y : top + y + height;
+  var leftOffset = right > viewRight ? left + x - bWidth + width : left + x;
+  return {
+    topOffset: topOffset,
+    leftOffset: leftOffset
+  };
+}
+function Pop(_ref2) {
+  var containerRef = _ref2.containerRef,
+    accessors = _ref2.accessors,
+    getters = _ref2.getters,
+    selected = _ref2.selected,
+    components = _ref2.components,
+    localizer = _ref2.localizer,
+    position = _ref2.position,
+    show = _ref2.show,
+    events = _ref2.events,
+    slotStart = _ref2.slotStart,
+    slotEnd = _ref2.slotEnd,
+    onSelect = _ref2.onSelect,
+    onDoubleClick = _ref2.onDoubleClick,
+    onKeyPress = _ref2.onKeyPress,
+    handleDragStart = _ref2.handleDragStart,
+    popperRef = _ref2.popperRef,
+    target = _ref2.target,
+    offset = _ref2.offset;
+  (0, _useClickOutside.default)({
+    ref: popperRef,
+    callback: show
+  });
+  (0, _react.useLayoutEffect)(function () {
+    var _getPosition = getPosition({
+        target: target,
+        offset: offset,
+        container: containerRef.current,
+        box: popperRef.current
+      }),
+      topOffset = _getPosition.topOffset,
+      leftOffset = _getPosition.leftOffset;
+    popperRef.current.style.top = "".concat(topOffset, "px");
+    popperRef.current.style.left = "".concat(leftOffset, "px");
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [offset.x, offset.y, target]);
+  var width = position.width;
+  var style = {
+    minWidth: width + width / 2
+  };
+  return /*#__PURE__*/_react.default.createElement("div", {
+    style: style,
+    className: "rbc-overlay",
+    ref: popperRef
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "rbc-overlay-header"
+  }, localizer.format(slotStart, 'dayHeaderFormat')), events.map(function (event, idx) {
+    return /*#__PURE__*/_react.default.createElement(_EventCell.default, {
+      key: idx,
+      type: "popup",
+      localizer: localizer,
+      event: event,
+      getters: getters,
+      onSelect: onSelect,
+      accessors: accessors,
+      components: components,
+      onDoubleClick: onDoubleClick,
+      onKeyPress: onKeyPress,
+      continuesPrior: localizer.lt(accessors.end(event), slotStart, 'day'),
+      continuesAfter: localizer.gte(accessors.start(event), slotEnd, 'day'),
+      slotStart: slotStart,
+      slotEnd: slotEnd,
+      selected: (0, _selection.isSelected)(event, selected),
+      draggable: true,
+      onDragStart: function onDragStart() {
+        return handleDragStart(event);
+      },
+      onDragEnd: function onDragEnd() {
+        return show();
+      }
+    });
+  }));
+}
+var Popup = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  return /*#__PURE__*/_react.default.createElement(Pop, Object.assign({}, props, {
+    popperRef: ref
+  }));
+});
+Popup.propTypes = {
+  accessors: _propTypes.default.object.isRequired,
+  getters: _propTypes.default.object.isRequired,
+  selected: _propTypes.default.object,
+  components: _propTypes.default.object.isRequired,
+  localizer: _propTypes.default.object.isRequired,
+  position: _propTypes.default.object.isRequired,
+  show: _propTypes.default.func.isRequired,
+  events: _propTypes.default.array.isRequired,
+  slotStart: _propTypes.default.instanceOf(Date).isRequired,
+  slotEnd: _propTypes.default.instanceOf(Date),
+  onSelect: _propTypes.default.func,
+  onDoubleClick: _propTypes.default.func,
+  onKeyPress: _propTypes.default.func,
+  handleDragStart: _propTypes.default.func,
+  style: _propTypes.default.object,
+  offset: _propTypes.default.shape({
+    x: _propTypes.default.number,
+    y: _propTypes.default.number
+  })
+};
+var _default = exports.default = Popup;

node_modules/react-big-calendar/lib/ResourceHeader.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var ResourceHeader = function ResourceHeader(_ref) {
+  var label = _ref.label;
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, label);
+};
+var _default = exports.default = ResourceHeader;

node_modules/react-big-calendar/lib/ScrollableWeekWrapper.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var ScrollableWeekWrapper = function ScrollableWeekWrapper(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: "rbc-row-content-scroll-container"
+  }, children);
+};
+var _default = exports.default = ScrollableWeekWrapper;

node_modules/react-big-calendar/lib/Selection.js

@@ -0,0 +1,515 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getBoundsForNode = getBoundsForNode;
+exports.getEventNodeFromPoint = getEventNodeFromPoint;
+exports.getShowMoreNodeFromPoint = getShowMoreNodeFromPoint;
+exports.isEvent = isEvent;
+exports.isShowMore = isShowMore;
+exports.objectsCollide = objectsCollide;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _contains = _interopRequireDefault(require("dom-helpers/contains"));
+var _closest = _interopRequireDefault(require("dom-helpers/closest"));
+var _listen = _interopRequireDefault(require("dom-helpers/listen"));
+function addEventListener(type, handler) {
+  var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : document;
+  return (0, _listen.default)(target, type, handler, {
+    passive: false
+  });
+}
+function isOverContainer(container, x, y) {
+  return !container || (0, _contains.default)(container, document.elementFromPoint(x, y));
+}
+function getEventNodeFromPoint(node, _ref) {
+  var clientX = _ref.clientX,
+    clientY = _ref.clientY;
+  var target = document.elementFromPoint(clientX, clientY);
+  return (0, _closest.default)(target, '.rbc-event', node);
+}
+function getShowMoreNodeFromPoint(node, _ref2) {
+  var clientX = _ref2.clientX,
+    clientY = _ref2.clientY;
+  var target = document.elementFromPoint(clientX, clientY);
+  return (0, _closest.default)(target, '.rbc-show-more', node);
+}
+function isEvent(node, bounds) {
+  return !!getEventNodeFromPoint(node, bounds);
+}
+function isShowMore(node, bounds) {
+  return !!getShowMoreNodeFromPoint(node, bounds);
+}
+function getEventCoordinates(e) {
+  var target = e;
+  if (e.touches && e.touches.length) {
+    target = e.touches[0];
+  }
+  return {
+    clientX: target.clientX,
+    clientY: target.clientY,
+    pageX: target.pageX,
+    pageY: target.pageY
+  };
+}
+var clickTolerance = 5;
+var clickInterval = 250;
+var Selection = /*#__PURE__*/function () {
+  function Selection(node) {
+    var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      _ref3$global = _ref3.global,
+      global = _ref3$global === void 0 ? false : _ref3$global,
+      _ref3$longPressThresh = _ref3.longPressThreshold,
+      longPressThreshold = _ref3$longPressThresh === void 0 ? 250 : _ref3$longPressThresh,
+      _ref3$validContainers = _ref3.validContainers,
+      validContainers = _ref3$validContainers === void 0 ? [] : _ref3$validContainers;
+    (0, _classCallCheck2.default)(this, Selection);
+    this._initialEvent = null;
+    this.selecting = false;
+    this.isDetached = false;
+    this.container = node;
+    this.globalMouse = !node || global;
+    this.longPressThreshold = longPressThreshold;
+    this.validContainers = validContainers;
+    this._listeners = Object.create(null);
+    this._handleInitialEvent = this._handleInitialEvent.bind(this);
+    this._handleMoveEvent = this._handleMoveEvent.bind(this);
+    this._handleTerminatingEvent = this._handleTerminatingEvent.bind(this);
+    this._keyListener = this._keyListener.bind(this);
+    this._dropFromOutsideListener = this._dropFromOutsideListener.bind(this);
+    this._dragOverFromOutsideListener = this._dragOverFromOutsideListener.bind(this);
+
+    // Fixes an iOS 10 bug where scrolling could not be prevented on the window.
+    // https://github.com/metafizzy/flickity/issues/457#issuecomment-254501356
+    this._removeTouchMoveWindowListener = addEventListener('touchmove', function () {}, window);
+    this._removeKeyDownListener = addEventListener('keydown', this._keyListener);
+    this._removeKeyUpListener = addEventListener('keyup', this._keyListener);
+    this._removeDropFromOutsideListener = addEventListener('drop', this._dropFromOutsideListener);
+    this._removeDragOverFromOutsideListener = addEventListener('dragover', this._dragOverFromOutsideListener);
+    this._addInitialEventListener();
+  }
+  return (0, _createClass2.default)(Selection, [{
+    key: "on",
+    value: function on(type, handler) {
+      var handlers = this._listeners[type] || (this._listeners[type] = []);
+      handlers.push(handler);
+      return {
+        remove: function remove() {
+          var idx = handlers.indexOf(handler);
+          if (idx !== -1) handlers.splice(idx, 1);
+        }
+      };
+    }
+  }, {
+    key: "emit",
+    value: function emit(type) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      var result;
+      var handlers = this._listeners[type] || [];
+      handlers.forEach(function (fn) {
+        if (result === undefined) result = fn.apply(void 0, args);
+      });
+      return result;
+    }
+  }, {
+    key: "teardown",
+    value: function teardown() {
+      this._initialEvent = null;
+      this._initialEventData = null;
+      this._selectRect = null;
+      this.selecting = false;
+      this._lastClickData = null;
+      this.isDetached = true;
+      this._listeners = Object.create(null);
+      this._removeTouchMoveWindowListener && this._removeTouchMoveWindowListener();
+      this._removeInitialEventListener && this._removeInitialEventListener();
+      this._removeEndListener && this._removeEndListener();
+      this._onEscListener && this._onEscListener();
+      this._removeMoveListener && this._removeMoveListener();
+      this._removeKeyUpListener && this._removeKeyUpListener();
+      this._removeKeyDownListener && this._removeKeyDownListener();
+      this._removeDropFromOutsideListener && this._removeDropFromOutsideListener();
+      this._removeDragOverFromOutsideListener && this._removeDragOverFromOutsideListener();
+    }
+  }, {
+    key: "isSelected",
+    value: function isSelected(node) {
+      var box = this._selectRect;
+      if (!box || !this.selecting) return false;
+      return objectsCollide(box, getBoundsForNode(node));
+    }
+  }, {
+    key: "filter",
+    value: function filter(items) {
+      var box = this._selectRect;
+
+      //not selecting
+      if (!box || !this.selecting) return [];
+      return items.filter(this.isSelected, this);
+    }
+
+    // Adds a listener that will call the handler only after the user has pressed on the screen
+    // without moving their finger for 250ms.
+  }, {
+    key: "_addLongPressListener",
+    value: function _addLongPressListener(handler, initialEvent) {
+      var _this = this;
+      var timer = null;
+      var removeTouchMoveListener = null;
+      var removeTouchEndListener = null;
+      var handleTouchStart = function handleTouchStart(initialEvent) {
+        timer = setTimeout(function () {
+          cleanup();
+          handler(initialEvent);
+        }, _this.longPressThreshold);
+        removeTouchMoveListener = addEventListener('touchmove', function () {
+          return cleanup();
+        });
+        removeTouchEndListener = addEventListener('touchend', function () {
+          return cleanup();
+        });
+      };
+      var removeTouchStartListener = addEventListener('touchstart', handleTouchStart);
+      var cleanup = function cleanup() {
+        if (timer) {
+          clearTimeout(timer);
+        }
+        if (removeTouchMoveListener) {
+          removeTouchMoveListener();
+        }
+        if (removeTouchEndListener) {
+          removeTouchEndListener();
+        }
+        timer = null;
+        removeTouchMoveListener = null;
+        removeTouchEndListener = null;
+      };
+      if (initialEvent) {
+        handleTouchStart(initialEvent);
+      }
+      return function () {
+        cleanup();
+        removeTouchStartListener();
+      };
+    }
+
+    // Listen for mousedown and touchstart events. When one is received, disable the other and setup
+    // future event handling based on the type of event.
+  }, {
+    key: "_addInitialEventListener",
+    value: function _addInitialEventListener() {
+      var _this2 = this;
+      var removeMouseDownListener = addEventListener('mousedown', function (e) {
+        _this2._removeInitialEventListener();
+        _this2._handleInitialEvent(e);
+        _this2._removeInitialEventListener = addEventListener('mousedown', _this2._handleInitialEvent);
+      });
+      var removeTouchStartListener = addEventListener('touchstart', function (e) {
+        _this2._removeInitialEventListener();
+        _this2._removeInitialEventListener = _this2._addLongPressListener(_this2._handleInitialEvent, e);
+      });
+      this._removeInitialEventListener = function () {
+        removeMouseDownListener();
+        removeTouchStartListener();
+      };
+    }
+  }, {
+    key: "_dropFromOutsideListener",
+    value: function _dropFromOutsideListener(e) {
+      var _getEventCoordinates = getEventCoordinates(e),
+        pageX = _getEventCoordinates.pageX,
+        pageY = _getEventCoordinates.pageY,
+        clientX = _getEventCoordinates.clientX,
+        clientY = _getEventCoordinates.clientY;
+      this.emit('dropFromOutside', {
+        x: pageX,
+        y: pageY,
+        clientX: clientX,
+        clientY: clientY
+      });
+      e.preventDefault();
+    }
+  }, {
+    key: "_dragOverFromOutsideListener",
+    value: function _dragOverFromOutsideListener(e) {
+      var _getEventCoordinates2 = getEventCoordinates(e),
+        pageX = _getEventCoordinates2.pageX,
+        pageY = _getEventCoordinates2.pageY,
+        clientX = _getEventCoordinates2.clientX,
+        clientY = _getEventCoordinates2.clientY;
+      this.emit('dragOverFromOutside', {
+        x: pageX,
+        y: pageY,
+        clientX: clientX,
+        clientY: clientY
+      });
+      e.preventDefault();
+    }
+  }, {
+    key: "_handleInitialEvent",
+    value: function _handleInitialEvent(e) {
+      this._initialEvent = e;
+      if (this.isDetached) {
+        return;
+      }
+      var _getEventCoordinates3 = getEventCoordinates(e),
+        clientX = _getEventCoordinates3.clientX,
+        clientY = _getEventCoordinates3.clientY,
+        pageX = _getEventCoordinates3.pageX,
+        pageY = _getEventCoordinates3.pageY;
+      var node = this.container(),
+        collides,
+        offsetData;
+
+      // Right clicks
+      if (e.which === 3 || e.button === 2 || !isOverContainer(node, clientX, clientY)) return;
+      if (!this.globalMouse && node && !(0, _contains.default)(node, e.target)) {
+        var _normalizeDistance = normalizeDistance(0),
+          top = _normalizeDistance.top,
+          left = _normalizeDistance.left,
+          bottom = _normalizeDistance.bottom,
+          right = _normalizeDistance.right;
+        offsetData = getBoundsForNode(node);
+        collides = objectsCollide({
+          top: offsetData.top - top,
+          left: offsetData.left - left,
+          bottom: offsetData.bottom + bottom,
+          right: offsetData.right + right
+        }, {
+          top: pageY,
+          left: pageX
+        });
+        if (!collides) return;
+      }
+      var result = this.emit('beforeSelect', this._initialEventData = {
+        isTouch: /^touch/.test(e.type),
+        x: pageX,
+        y: pageY,
+        clientX: clientX,
+        clientY: clientY
+      });
+      if (result === false) return;
+      switch (e.type) {
+        case 'mousedown':
+          this._removeEndListener = addEventListener('mouseup', this._handleTerminatingEvent);
+          this._onEscListener = addEventListener('keydown', this._handleTerminatingEvent);
+          this._removeMoveListener = addEventListener('mousemove', this._handleMoveEvent);
+          break;
+        case 'touchstart':
+          this._handleMoveEvent(e);
+          this._removeEndListener = addEventListener('touchend', this._handleTerminatingEvent);
+          this._removeMoveListener = addEventListener('touchmove', this._handleMoveEvent);
+          break;
+        default:
+          break;
+      }
+    }
+
+    // Check whether provided event target element
+    // - is contained within a valid container
+  }, {
+    key: "_isWithinValidContainer",
+    value: function _isWithinValidContainer(e) {
+      var eventTarget = e.target;
+      var containers = this.validContainers;
+      if (!containers || !containers.length || !eventTarget) {
+        return true;
+      }
+      return containers.some(function (target) {
+        return !!eventTarget.closest(target);
+      });
+    }
+  }, {
+    key: "_handleTerminatingEvent",
+    value: function _handleTerminatingEvent(e) {
+      var selecting = this.selecting;
+      var bounds = this._selectRect;
+      // If it's not in selecting state, it's a click event
+      if (!selecting && e.type.includes('key')) {
+        e = this._initialEvent;
+      }
+      this.selecting = false;
+      this._removeEndListener && this._removeEndListener();
+      this._removeMoveListener && this._removeMoveListener();
+      this._selectRect = null;
+      this._initialEvent = null;
+      this._initialEventData = null;
+      if (!e) return;
+      var inRoot = !this.container || (0, _contains.default)(this.container(), e.target);
+      var isWithinValidContainer = this._isWithinValidContainer(e);
+      if (e.key === 'Escape' || !isWithinValidContainer) {
+        return this.emit('reset');
+      }
+      if (!selecting && inRoot) {
+        return this._handleClickEvent(e);
+      }
+
+      // User drag-clicked in the Selectable area
+      if (selecting) return this.emit('select', bounds);
+      return this.emit('reset');
+    }
+  }, {
+    key: "_handleClickEvent",
+    value: function _handleClickEvent(e) {
+      var _getEventCoordinates4 = getEventCoordinates(e),
+        pageX = _getEventCoordinates4.pageX,
+        pageY = _getEventCoordinates4.pageY,
+        clientX = _getEventCoordinates4.clientX,
+        clientY = _getEventCoordinates4.clientY;
+      var now = new Date().getTime();
+      if (this._lastClickData && now - this._lastClickData.timestamp < clickInterval) {
+        // Double click event
+        this._lastClickData = null;
+        return this.emit('doubleClick', {
+          x: pageX,
+          y: pageY,
+          clientX: clientX,
+          clientY: clientY
+        });
+      }
+
+      // Click event
+      this._lastClickData = {
+        timestamp: now
+      };
+      return this.emit('click', {
+        x: pageX,
+        y: pageY,
+        clientX: clientX,
+        clientY: clientY
+      });
+    }
+  }, {
+    key: "_handleMoveEvent",
+    value: function _handleMoveEvent(e) {
+      if (this._initialEventData === null || this.isDetached) {
+        return;
+      }
+      var _this$_initialEventDa = this._initialEventData,
+        x = _this$_initialEventDa.x,
+        y = _this$_initialEventDa.y;
+      var _getEventCoordinates5 = getEventCoordinates(e),
+        pageX = _getEventCoordinates5.pageX,
+        pageY = _getEventCoordinates5.pageY;
+      var w = Math.abs(x - pageX);
+      var h = Math.abs(y - pageY);
+      var left = Math.min(pageX, x),
+        top = Math.min(pageY, y),
+        old = this.selecting;
+      var click = this.isClick(pageX, pageY);
+      // Prevent emitting selectStart event until mouse is moved.
+      // in Chrome on Windows, mouseMove event may be fired just after mouseDown event.
+      if (click && !old && !(w || h)) {
+        return;
+      }
+      if (!old && !click) {
+        this.emit('selectStart', this._initialEventData);
+      }
+      if (!click) {
+        this.selecting = true;
+        this._selectRect = {
+          top: top,
+          left: left,
+          x: pageX,
+          y: pageY,
+          right: left + w,
+          bottom: top + h
+        };
+        this.emit('selecting', this._selectRect);
+      }
+      e.preventDefault();
+    }
+  }, {
+    key: "_keyListener",
+    value: function _keyListener(e) {
+      this.ctrl = e.metaKey || e.ctrlKey;
+    }
+  }, {
+    key: "isClick",
+    value: function isClick(pageX, pageY) {
+      var _this$_initialEventDa2 = this._initialEventData,
+        x = _this$_initialEventDa2.x,
+        y = _this$_initialEventDa2.y,
+        isTouch = _this$_initialEventDa2.isTouch;
+      return !isTouch && Math.abs(pageX - x) <= clickTolerance && Math.abs(pageY - y) <= clickTolerance;
+    }
+  }]);
+}();
+/**
+ * Resolve the disance prop from either an Int or an Object
+ * @return {Object}
+ */
+function normalizeDistance() {
+  var distance = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  if ((0, _typeof2.default)(distance) !== 'object') distance = {
+    top: distance,
+    left: distance,
+    right: distance,
+    bottom: distance
+  };
+  return distance;
+}
+
+/**
+ * Given two objects containing "top", "left", "offsetWidth" and "offsetHeight"
+ * properties, determine if they collide.
+ * @param  {Object|HTMLElement} a
+ * @param  {Object|HTMLElement} b
+ * @return {bool}
+ */
+function objectsCollide(nodeA, nodeB) {
+  var tolerance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var _getBoundsForNode = getBoundsForNode(nodeA),
+    aTop = _getBoundsForNode.top,
+    aLeft = _getBoundsForNode.left,
+    _getBoundsForNode$rig = _getBoundsForNode.right,
+    aRight = _getBoundsForNode$rig === void 0 ? aLeft : _getBoundsForNode$rig,
+    _getBoundsForNode$bot = _getBoundsForNode.bottom,
+    aBottom = _getBoundsForNode$bot === void 0 ? aTop : _getBoundsForNode$bot;
+  var _getBoundsForNode2 = getBoundsForNode(nodeB),
+    bTop = _getBoundsForNode2.top,
+    bLeft = _getBoundsForNode2.left,
+    _getBoundsForNode2$ri = _getBoundsForNode2.right,
+    bRight = _getBoundsForNode2$ri === void 0 ? bLeft : _getBoundsForNode2$ri,
+    _getBoundsForNode2$bo = _getBoundsForNode2.bottom,
+    bBottom = _getBoundsForNode2$bo === void 0 ? bTop : _getBoundsForNode2$bo;
+  return !(
+  // 'a' bottom doesn't touch 'b' top
+
+  aBottom - tolerance < bTop ||
+  // 'a' top doesn't touch 'b' bottom
+  aTop + tolerance > bBottom ||
+  // 'a' right doesn't touch 'b' left
+  aRight - tolerance < bLeft ||
+  // 'a' left doesn't touch 'b' right
+  aLeft + tolerance > bRight);
+}
+
+/**
+ * Given a node, get everything needed to calculate its boundaries
+ * @param  {HTMLElement} node
+ * @return {Object}
+ */
+function getBoundsForNode(node) {
+  if (!node.getBoundingClientRect) return node;
+  var rect = node.getBoundingClientRect(),
+    left = rect.left + pageOffset('left'),
+    top = rect.top + pageOffset('top');
+  return {
+    top: top,
+    left: left,
+    right: (node.offsetWidth || 0) + left,
+    bottom: (node.offsetHeight || 0) + top
+  };
+}
+function pageOffset(dir) {
+  if (dir === 'left') return window.pageXOffset || document.body.scrollLeft || 0;
+  if (dir === 'top') return window.pageYOffset || document.body.scrollTop || 0;
+}
+var _default = exports.default = Selection;

node_modules/react-big-calendar/lib/TimeGrid.js

@@ -0,0 +1,438 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var animationFrame = _interopRequireWildcard(require("dom-helpers/animationFrame"));
+var _memoizeOne = _interopRequireDefault(require("memoize-one"));
+var _react = _interopRequireWildcard(require("react"));
+var _position = _interopRequireDefault(require("dom-helpers/position"));
+var _width = _interopRequireDefault(require("dom-helpers/width"));
+var _DayColumn = _interopRequireDefault(require("./DayColumn"));
+var _PopOverlay = _interopRequireDefault(require("./PopOverlay"));
+var _TimeGridHeader = _interopRequireDefault(require("./TimeGridHeader"));
+var _TimeGridHeaderResources = _interopRequireDefault(require("./TimeGridHeaderResources"));
+var _TimeGutter = _interopRequireDefault(require("./TimeGutter"));
+var _constants = require("./utils/constants");
+var _eventLevels = require("./utils/eventLevels");
+var _helpers = require("./utils/helpers");
+var _propTypes = require("./utils/propTypes");
+var _Resources = _interopRequireDefault(require("./utils/Resources"));
+var TimeGrid = exports.default = /*#__PURE__*/function (_Component) {
+  function TimeGrid(props) {
+    var _this;
+    (0, _classCallCheck2.default)(this, TimeGrid);
+    _this = (0, _callSuper2.default)(this, TimeGrid, [props]);
+    _this.handleScroll = function (e) {
+      if (_this.scrollRef.current) {
+        _this.scrollRef.current.scrollLeft = e.target.scrollLeft;
+      }
+    };
+    _this.handleResize = function () {
+      animationFrame.cancel(_this.rafHandle);
+      _this.rafHandle = animationFrame.request(_this.checkOverflow);
+    };
+    _this.handleKeyPressEvent = function () {
+      _this.clearSelection();
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      (0, _helpers.notify)(_this.props.onKeyPressEvent, args);
+    };
+    _this.handleSelectEvent = function () {
+      //cancel any pending selections so only the event click goes through.
+      _this.clearSelection();
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      (0, _helpers.notify)(_this.props.onSelectEvent, args);
+    };
+    _this.handleDoubleClickEvent = function () {
+      _this.clearSelection();
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      (0, _helpers.notify)(_this.props.onDoubleClickEvent, args);
+    };
+    _this.handleShowMore = function (events, date, cell, slot, target) {
+      var _this$props = _this.props,
+        popup = _this$props.popup,
+        onDrillDown = _this$props.onDrillDown,
+        onShowMore = _this$props.onShowMore,
+        getDrilldownView = _this$props.getDrilldownView,
+        doShowMoreDrillDown = _this$props.doShowMoreDrillDown;
+      _this.clearSelection();
+      if (popup) {
+        var position = (0, _position.default)(cell, _this.containerRef.current);
+        _this.setState({
+          overlay: {
+            date: date,
+            events: events,
+            position: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, position), {}, {
+              width: '200px'
+            }),
+            target: target
+          }
+        });
+      } else if (doShowMoreDrillDown) {
+        (0, _helpers.notify)(onDrillDown, [date, getDrilldownView(date) || _constants.views.DAY]);
+      }
+      (0, _helpers.notify)(onShowMore, [events, date, slot]);
+    };
+    _this.handleSelectAllDaySlot = function (slots, slotInfo) {
+      var onSelectSlot = _this.props.onSelectSlot;
+      var start = new Date(slots[0]);
+      var end = new Date(slots[slots.length - 1]);
+      end.setDate(slots[slots.length - 1].getDate() + 1);
+      (0, _helpers.notify)(onSelectSlot, {
+        slots: slots,
+        start: start,
+        end: end,
+        action: slotInfo.action,
+        resourceId: slotInfo.resourceId
+      });
+    };
+    _this.overlayDisplay = function () {
+      _this.setState({
+        overlay: null
+      });
+    };
+    _this.checkOverflow = function () {
+      if (_this._updatingOverflow) return;
+      var content = _this.contentRef.current;
+      if (!(content !== null && content !== void 0 && content.scrollHeight)) return;
+      var isOverflowing = content.scrollHeight > content.clientHeight;
+      if (_this.state.isOverflowing !== isOverflowing) {
+        _this._updatingOverflow = true;
+        _this.setState({
+          isOverflowing: isOverflowing
+        }, function () {
+          _this._updatingOverflow = false;
+        });
+      }
+    };
+    _this.memoizedResources = (0, _memoizeOne.default)(function (resources, accessors) {
+      return (0, _Resources.default)(resources, accessors);
+    });
+    _this.state = {
+      gutterWidth: undefined,
+      isOverflowing: null
+    };
+    _this.scrollRef = /*#__PURE__*/_react.default.createRef();
+    _this.contentRef = /*#__PURE__*/_react.default.createRef();
+    _this.containerRef = /*#__PURE__*/_react.default.createRef();
+    _this._scrollRatio = null;
+    _this.gutterRef = /*#__PURE__*/(0, _react.createRef)();
+    return _this;
+  }
+  (0, _inherits2.default)(TimeGrid, _Component);
+  return (0, _createClass2.default)(TimeGrid, [{
+    key: "getSnapshotBeforeUpdate",
+    value: function getSnapshotBeforeUpdate() {
+      this.checkOverflow();
+      return null;
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.width == null) {
+        this.measureGutter();
+      }
+      this.calculateScroll();
+      this.applyScroll();
+      window.addEventListener('resize', this.handleResize);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      window.removeEventListener('resize', this.handleResize);
+      animationFrame.cancel(this.rafHandle);
+      if (this.measureGutterAnimationFrameRequest) {
+        window.cancelAnimationFrame(this.measureGutterAnimationFrameRequest);
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this.applyScroll();
+    }
+  }, {
+    key: "renderDayColumn",
+    value: function renderDayColumn(date, id, resource, groupedEvents, groupedBackgroundEvents, localizer, accessors, components, dayLayoutAlgorithm, now) {
+      var _this$props2 = this.props,
+        min = _this$props2.min,
+        max = _this$props2.max;
+      var daysEvents = (groupedEvents.get(id) || []).filter(function (event) {
+        return localizer.inRange(date, accessors.start(event), accessors.end(event), 'day');
+      });
+      var daysBackgroundEvents = (groupedBackgroundEvents.get(id) || []).filter(function (event) {
+        return localizer.inRange(date, accessors.start(event), accessors.end(event), 'day');
+      });
+      return /*#__PURE__*/_react.default.createElement(_DayColumn.default, Object.assign({}, this.props, {
+        localizer: localizer,
+        min: localizer.merge(date, min),
+        max: localizer.merge(date, max),
+        resource: resource && id,
+        components: components,
+        isNow: localizer.isSameDate(date, now),
+        key: "".concat(id, "-").concat(date),
+        date: date,
+        events: daysEvents,
+        backgroundEvents: daysBackgroundEvents,
+        dayLayoutAlgorithm: dayLayoutAlgorithm
+      }));
+    }
+  }, {
+    key: "renderResourcesFirst",
+    value: function renderResourcesFirst(range, resources, groupedEvents, groupedBackgroundEvents, localizer, accessors, now, components, dayLayoutAlgorithm) {
+      var _this2 = this;
+      return resources.map(function (_ref) {
+        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+          id = _ref2[0],
+          resource = _ref2[1];
+        return range.map(function (date) {
+          return _this2.renderDayColumn(date, id, resource, groupedEvents, groupedBackgroundEvents, localizer, accessors, components, dayLayoutAlgorithm, now);
+        });
+      });
+    }
+  }, {
+    key: "renderRangeFirst",
+    value: function renderRangeFirst(range, resources, groupedEvents, groupedBackgroundEvents, localizer, accessors, now, components, dayLayoutAlgorithm) {
+      var _this3 = this;
+      return range.map(function (date) {
+        return /*#__PURE__*/_react.default.createElement("div", {
+          style: {
+            display: 'flex',
+            minHeight: '100%',
+            flex: 1
+          },
+          key: date
+        }, resources.map(function (_ref3) {
+          var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+            id = _ref4[0],
+            resource = _ref4[1];
+          return /*#__PURE__*/_react.default.createElement("div", {
+            style: {
+              flex: 1
+            },
+            key: accessors.resourceId(resource)
+          }, _this3.renderDayColumn(date, id, resource, groupedEvents, groupedBackgroundEvents, localizer, accessors, components, dayLayoutAlgorithm, now));
+        }));
+      });
+    }
+  }, {
+    key: "renderEvents",
+    value: function renderEvents(range, events, backgroundEvents, now) {
+      var _this$props3 = this.props,
+        accessors = _this$props3.accessors,
+        localizer = _this$props3.localizer,
+        resourceGroupingLayout = _this$props3.resourceGroupingLayout,
+        components = _this$props3.components,
+        dayLayoutAlgorithm = _this$props3.dayLayoutAlgorithm;
+      var resources = this.memoizedResources(this.props.resources, accessors);
+      var groupedEvents = resources.groupEvents(events);
+      var groupedBackgroundEvents = resources.groupEvents(backgroundEvents);
+      if (!resourceGroupingLayout) {
+        return this.renderResourcesFirst(range, resources, groupedEvents, groupedBackgroundEvents, localizer, accessors, now, components, dayLayoutAlgorithm);
+      } else {
+        return this.renderRangeFirst(range, resources, groupedEvents, groupedBackgroundEvents, localizer, accessors, now, components, dayLayoutAlgorithm);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props$allDayMax;
+      var _this$props4 = this.props,
+        events = _this$props4.events,
+        backgroundEvents = _this$props4.backgroundEvents,
+        range = _this$props4.range,
+        width = _this$props4.width,
+        rtl = _this$props4.rtl,
+        selected = _this$props4.selected,
+        getNow = _this$props4.getNow,
+        resources = _this$props4.resources,
+        components = _this$props4.components,
+        accessors = _this$props4.accessors,
+        getters = _this$props4.getters,
+        localizer = _this$props4.localizer,
+        min = _this$props4.min,
+        max = _this$props4.max,
+        showMultiDayTimes = _this$props4.showMultiDayTimes,
+        longPressThreshold = _this$props4.longPressThreshold,
+        resizable = _this$props4.resizable,
+        resourceGroupingLayout = _this$props4.resourceGroupingLayout;
+      width = width || this.state.gutterWidth;
+      var start = range[0],
+        end = range[range.length - 1];
+      this.slots = range.length;
+      var allDayEvents = [],
+        rangeEvents = [],
+        rangeBackgroundEvents = [];
+      events.forEach(function (event) {
+        if ((0, _eventLevels.inRange)(event, start, end, accessors, localizer)) {
+          var eStart = accessors.start(event),
+            eEnd = accessors.end(event);
+          if (accessors.allDay(event) || localizer.startAndEndAreDateOnly(eStart, eEnd) || !showMultiDayTimes && !localizer.isSameDate(eStart, eEnd)) {
+            allDayEvents.push(event);
+          } else {
+            rangeEvents.push(event);
+          }
+        }
+      });
+      backgroundEvents.forEach(function (event) {
+        if ((0, _eventLevels.inRange)(event, start, end, accessors, localizer)) {
+          rangeBackgroundEvents.push(event);
+        }
+      });
+      allDayEvents.sort(function (a, b) {
+        return (0, _eventLevels.sortEvents)(a, b, accessors, localizer);
+      });
+      var headerProps = {
+        range: range,
+        events: allDayEvents,
+        width: width,
+        rtl: rtl,
+        getNow: getNow,
+        localizer: localizer,
+        selected: selected,
+        allDayMaxRows: this.props.showAllEvents ? Infinity : (_this$props$allDayMax = this.props.allDayMaxRows) !== null && _this$props$allDayMax !== void 0 ? _this$props$allDayMax : Infinity,
+        resources: this.memoizedResources(resources, accessors),
+        selectable: this.props.selectable,
+        accessors: accessors,
+        getters: getters,
+        components: components,
+        scrollRef: this.scrollRef,
+        isOverflowing: this.state.isOverflowing,
+        longPressThreshold: longPressThreshold,
+        onSelectSlot: this.handleSelectAllDaySlot,
+        onSelectEvent: this.handleSelectEvent,
+        onShowMore: this.handleShowMore,
+        onDoubleClickEvent: this.props.onDoubleClickEvent,
+        onKeyPressEvent: this.props.onKeyPressEvent,
+        onDrillDown: this.props.onDrillDown,
+        getDrilldownView: this.props.getDrilldownView,
+        resizable: resizable
+      };
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: (0, _clsx.default)('rbc-time-view', resources && 'rbc-time-view-resources'),
+        ref: this.containerRef
+      }, resources && resources.length > 1 && resourceGroupingLayout ? /*#__PURE__*/_react.default.createElement(_TimeGridHeaderResources.default, headerProps) : /*#__PURE__*/_react.default.createElement(_TimeGridHeader.default, headerProps), this.props.popup && this.renderOverlay(), /*#__PURE__*/_react.default.createElement("div", {
+        ref: this.contentRef,
+        className: "rbc-time-content",
+        onScroll: this.handleScroll
+      }, /*#__PURE__*/_react.default.createElement(_TimeGutter.default, {
+        date: start,
+        ref: this.gutterRef,
+        localizer: localizer,
+        min: localizer.merge(start, min),
+        max: localizer.merge(start, max),
+        step: this.props.step,
+        getNow: this.props.getNow,
+        timeslots: this.props.timeslots,
+        components: components,
+        className: "rbc-time-gutter",
+        getters: getters
+      }), this.renderEvents(range, rangeEvents, rangeBackgroundEvents, getNow())));
+    }
+  }, {
+    key: "renderOverlay",
+    value: function renderOverlay() {
+      var _this$state$overlay,
+        _this$state,
+        _this4 = this;
+      var overlay = (_this$state$overlay = (_this$state = this.state) === null || _this$state === void 0 ? void 0 : _this$state.overlay) !== null && _this$state$overlay !== void 0 ? _this$state$overlay : {};
+      var _this$props5 = this.props,
+        accessors = _this$props5.accessors,
+        localizer = _this$props5.localizer,
+        components = _this$props5.components,
+        getters = _this$props5.getters,
+        selected = _this$props5.selected,
+        popupOffset = _this$props5.popupOffset,
+        handleDragStart = _this$props5.handleDragStart;
+      var onHide = function onHide() {
+        return _this4.setState({
+          overlay: null
+        });
+      };
+      return /*#__PURE__*/_react.default.createElement(_PopOverlay.default, {
+        overlay: overlay,
+        accessors: accessors,
+        localizer: localizer,
+        components: components,
+        getters: getters,
+        selected: selected,
+        popupOffset: popupOffset,
+        ref: this.containerRef,
+        handleKeyPressEvent: this.handleKeyPressEvent,
+        handleSelectEvent: this.handleSelectEvent,
+        handleDoubleClickEvent: this.handleDoubleClickEvent,
+        handleDragStart: handleDragStart,
+        show: !!overlay.position,
+        overlayDisplay: this.overlayDisplay,
+        onHide: onHide
+      });
+    }
+  }, {
+    key: "clearSelection",
+    value: function clearSelection() {
+      clearTimeout(this._selectTimer);
+      this._pendingSelection = [];
+    }
+  }, {
+    key: "measureGutter",
+    value: function measureGutter() {
+      var _this5 = this;
+      if (this.measureGutterAnimationFrameRequest) {
+        window.cancelAnimationFrame(this.measureGutterAnimationFrameRequest);
+      }
+      this.measureGutterAnimationFrameRequest = window.requestAnimationFrame(function () {
+        var _this5$gutterRef;
+        var width = (_this5$gutterRef = _this5.gutterRef) !== null && _this5$gutterRef !== void 0 && _this5$gutterRef.current ? (0, _width.default)(_this5.gutterRef.current) : undefined;
+        if (width && _this5.state.gutterWidth !== width) {
+          _this5.setState({
+            gutterWidth: width
+          });
+        }
+      });
+    }
+  }, {
+    key: "applyScroll",
+    value: function applyScroll() {
+      // If auto-scroll is disabled, we don't actually apply the scroll
+      if (this._scrollRatio != null && this.props.enableAutoScroll === true) {
+        var content = this.contentRef.current;
+        content.scrollTop = content.scrollHeight * this._scrollRatio;
+        // Only do this once
+        this._scrollRatio = null;
+      }
+    }
+  }, {
+    key: "calculateScroll",
+    value: function calculateScroll() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
+      var min = props.min,
+        max = props.max,
+        scrollToTime = props.scrollToTime,
+        localizer = props.localizer;
+      var diffMillis = localizer.diff(localizer.merge(scrollToTime, min), scrollToTime, 'milliseconds');
+      var totalMillis = localizer.diff(min, max, 'milliseconds');
+      this._scrollRatio = diffMillis / totalMillis;
+    }
+  }]);
+}(_react.Component);
+TimeGrid.defaultProps = {
+  step: 30,
+  timeslots: 2,
+  // To be compatible with old versions, default as `false`.
+  resourceGroupingLayout: false
+};

node_modules/react-big-calendar/lib/TimeGridEvent.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread3 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _react = _interopRequireDefault(require("react"));
+function stringifyPercent(v) {
+  return typeof v === 'string' ? v : v + '%';
+}
+
+/* eslint-disable react/prop-types */
+function TimeGridEvent(props) {
+  var style = props.style,
+    className = props.className,
+    event = props.event,
+    accessors = props.accessors,
+    rtl = props.rtl,
+    selected = props.selected,
+    label = props.label,
+    continuesPrior = props.continuesPrior,
+    continuesAfter = props.continuesAfter,
+    getters = props.getters,
+    onClick = props.onClick,
+    onDoubleClick = props.onDoubleClick,
+    isBackgroundEvent = props.isBackgroundEvent,
+    onKeyPress = props.onKeyPress,
+    _props$components = props.components,
+    Event = _props$components.event,
+    EventWrapper = _props$components.eventWrapper;
+  var title = accessors.title(event);
+  var tooltip = accessors.tooltip(event);
+  var end = accessors.end(event);
+  var start = accessors.start(event);
+  var userProps = getters.eventProp(event, start, end, selected);
+  var inner = [/*#__PURE__*/_react.default.createElement("div", {
+    key: "1",
+    className: "rbc-event-label"
+  }, label), /*#__PURE__*/_react.default.createElement("div", {
+    key: "2",
+    className: "rbc-event-content"
+  }, Event ? /*#__PURE__*/_react.default.createElement(Event, {
+    event: event,
+    title: title
+  }) : title)];
+  var height = style.height,
+    top = style.top,
+    width = style.width,
+    xOffset = style.xOffset;
+  var eventStyle = (0, _objectSpread3.default)((0, _objectSpread3.default)({}, userProps.style), {}, (0, _defineProperty2.default)({
+    top: stringifyPercent(top),
+    height: stringifyPercent(height),
+    width: stringifyPercent(width)
+  }, rtl ? 'right' : 'left', stringifyPercent(xOffset)));
+  return /*#__PURE__*/_react.default.createElement(EventWrapper, Object.assign({
+    type: "time"
+  }, props), /*#__PURE__*/_react.default.createElement("div", {
+    role: "button",
+    tabIndex: 0,
+    onClick: onClick,
+    onDoubleClick: onDoubleClick,
+    style: eventStyle,
+    onKeyDown: onKeyPress,
+    title: tooltip ? (typeof label === 'string' ? label + ': ' : '') + tooltip : undefined,
+    className: (0, _clsx.default)(isBackgroundEvent ? 'rbc-background-event' : 'rbc-event', className, userProps.className, {
+      'rbc-selected': selected,
+      'rbc-event-continues-earlier': continuesPrior,
+      'rbc-event-continues-later': continuesAfter
+    })
+  }, inner));
+}
+var _default = exports.default = TimeGridEvent;

node_modules/react-big-calendar/lib/TimeGridHeader.js

@@ -0,0 +1,201 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _scrollbarSize = _interopRequireDefault(require("dom-helpers/scrollbarSize"));
+var _react = _interopRequireDefault(require("react"));
+var _DateContentRow = _interopRequireDefault(require("./DateContentRow"));
+var _Header = _interopRequireDefault(require("./Header"));
+var _ResourceHeader = _interopRequireDefault(require("./ResourceHeader"));
+var _helpers = require("./utils/helpers");
+var TimeGridHeader = /*#__PURE__*/function (_React$Component) {
+  function TimeGridHeader() {
+    var _this;
+    (0, _classCallCheck2.default)(this, TimeGridHeader);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, TimeGridHeader, [].concat(args));
+    _this.handleHeaderClick = function (date, view, e) {
+      e.preventDefault();
+      (0, _helpers.notify)(_this.props.onDrillDown, [date, view]);
+    };
+    _this.renderRow = function (resource) {
+      var _this$props = _this.props,
+        events = _this$props.events,
+        rtl = _this$props.rtl,
+        selectable = _this$props.selectable,
+        getNow = _this$props.getNow,
+        range = _this$props.range,
+        getters = _this$props.getters,
+        localizer = _this$props.localizer,
+        accessors = _this$props.accessors,
+        components = _this$props.components,
+        resizable = _this$props.resizable;
+      var resourceId = accessors.resourceId(resource);
+      var eventsToDisplay = resource ? events.filter(function (event) {
+        return accessors.resource(event) === resourceId;
+      }) : events;
+      return /*#__PURE__*/_react.default.createElement(_DateContentRow.default, {
+        isAllDay: true,
+        rtl: rtl,
+        getNow: getNow,
+        minRows: 2
+        // Add +1 to include showMore button row in the row limit
+        ,
+        maxRows: _this.props.allDayMaxRows + 1,
+        range: range,
+        events: eventsToDisplay,
+        resourceId: resourceId,
+        className: "rbc-allday-cell",
+        selectable: selectable,
+        selected: _this.props.selected,
+        components: components,
+        accessors: accessors,
+        getters: getters,
+        localizer: localizer,
+        onSelect: _this.props.onSelectEvent,
+        onShowMore: _this.props.onShowMore,
+        onDoubleClick: _this.props.onDoubleClickEvent,
+        onKeyPress: _this.props.onKeyPressEvent,
+        onSelectSlot: _this.props.onSelectSlot,
+        longPressThreshold: _this.props.longPressThreshold,
+        resizable: resizable
+      });
+    };
+    return _this;
+  }
+  (0, _inherits2.default)(TimeGridHeader, _React$Component);
+  return (0, _createClass2.default)(TimeGridHeader, [{
+    key: "renderHeaderCells",
+    value: function renderHeaderCells(range) {
+      var _this2 = this;
+      var _this$props2 = this.props,
+        localizer = _this$props2.localizer,
+        getDrilldownView = _this$props2.getDrilldownView,
+        getNow = _this$props2.getNow,
+        dayProp = _this$props2.getters.dayProp,
+        _this$props2$componen = _this$props2.components.header,
+        HeaderComponent = _this$props2$componen === void 0 ? _Header.default : _this$props2$componen;
+      var today = getNow();
+      return range.map(function (date, i) {
+        var drilldownView = getDrilldownView(date);
+        var label = localizer.format(date, 'dayFormat');
+        var _dayProp = dayProp(date),
+          className = _dayProp.className,
+          style = _dayProp.style;
+        var header = /*#__PURE__*/_react.default.createElement(HeaderComponent, {
+          date: date,
+          label: label,
+          localizer: localizer
+        });
+        return /*#__PURE__*/_react.default.createElement("div", {
+          key: i,
+          style: style,
+          className: (0, _clsx.default)('rbc-header', className, localizer.isSameDate(date, today) && 'rbc-today')
+        }, drilldownView ? /*#__PURE__*/_react.default.createElement("button", {
+          type: "button",
+          className: "rbc-button-link",
+          onClick: function onClick(e) {
+            return _this2.handleHeaderClick(date, drilldownView, e);
+          }
+        }, header) : /*#__PURE__*/_react.default.createElement("span", null, header));
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+      var _this$props3 = this.props,
+        width = _this$props3.width,
+        rtl = _this$props3.rtl,
+        resources = _this$props3.resources,
+        range = _this$props3.range,
+        events = _this$props3.events,
+        getNow = _this$props3.getNow,
+        accessors = _this$props3.accessors,
+        selectable = _this$props3.selectable,
+        components = _this$props3.components,
+        getters = _this$props3.getters,
+        scrollRef = _this$props3.scrollRef,
+        localizer = _this$props3.localizer,
+        isOverflowing = _this$props3.isOverflowing,
+        _this$props3$componen = _this$props3.components,
+        TimeGutterHeader = _this$props3$componen.timeGutterHeader,
+        _this$props3$componen2 = _this$props3$componen.resourceHeader,
+        ResourceHeaderComponent = _this$props3$componen2 === void 0 ? _ResourceHeader.default : _this$props3$componen2,
+        resizable = _this$props3.resizable;
+      var style = {};
+      if (isOverflowing) {
+        style[rtl ? 'marginLeft' : 'marginRight'] = "".concat((0, _scrollbarSize.default)() - 1, "px");
+      }
+      var groupedEvents = resources.groupEvents(events);
+      return /*#__PURE__*/_react.default.createElement("div", {
+        style: style,
+        ref: scrollRef,
+        className: (0, _clsx.default)('rbc-time-header', isOverflowing && 'rbc-overflowing')
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-label rbc-time-header-gutter",
+        style: {
+          width: width,
+          minWidth: width,
+          maxWidth: width
+        }
+      }, TimeGutterHeader && /*#__PURE__*/_react.default.createElement(TimeGutterHeader, null)), resources.map(function (_ref, idx) {
+        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+          id = _ref2[0],
+          resource = _ref2[1];
+        return /*#__PURE__*/_react.default.createElement("div", {
+          className: "rbc-time-header-content",
+          key: id || idx
+        }, resource && /*#__PURE__*/_react.default.createElement("div", {
+          className: "rbc-row rbc-row-resource",
+          key: "resource_".concat(idx)
+        }, /*#__PURE__*/_react.default.createElement("div", {
+          className: "rbc-header"
+        }, /*#__PURE__*/_react.default.createElement(ResourceHeaderComponent, {
+          index: idx,
+          label: accessors.resourceTitle(resource),
+          resource: resource
+        }))), /*#__PURE__*/_react.default.createElement("div", {
+          className: "rbc-row rbc-time-header-cell".concat(range.length <= 1 ? ' rbc-time-header-cell-single-day' : '')
+        }, _this3.renderHeaderCells(range)), /*#__PURE__*/_react.default.createElement(_DateContentRow.default, {
+          isAllDay: true,
+          rtl: rtl,
+          getNow: getNow,
+          minRows: 2
+          // Add +1 to include showMore button row in the row limit
+          ,
+          maxRows: _this3.props.allDayMaxRows + 1,
+          range: range,
+          events: groupedEvents.get(id) || [],
+          resourceId: resource && id,
+          className: "rbc-allday-cell",
+          selectable: selectable,
+          selected: _this3.props.selected,
+          components: components,
+          accessors: accessors,
+          getters: getters,
+          localizer: localizer,
+          onSelect: _this3.props.onSelectEvent,
+          onShowMore: _this3.props.onShowMore,
+          onDoubleClick: _this3.props.onDoubleClickEvent,
+          onKeyDown: _this3.props.onKeyPressEvent,
+          onSelectSlot: _this3.props.onSelectSlot,
+          longPressThreshold: _this3.props.longPressThreshold,
+          resizable: resizable
+        }));
+      }));
+    }
+  }]);
+}(_react.default.Component);
+var _default = exports.default = TimeGridHeader;

node_modules/react-big-calendar/lib/TimeGridHeaderResources.js

@@ -0,0 +1,167 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _scrollbarSize = _interopRequireDefault(require("dom-helpers/scrollbarSize"));
+var _react = _interopRequireDefault(require("react"));
+var _DateContentRow = _interopRequireDefault(require("./DateContentRow"));
+var _Header = _interopRequireDefault(require("./Header"));
+var _ResourceHeader = _interopRequireDefault(require("./ResourceHeader"));
+var _helpers = require("./utils/helpers");
+var TimeGridHeaderResources = /*#__PURE__*/function (_React$Component) {
+  function TimeGridHeaderResources() {
+    var _this;
+    (0, _classCallCheck2.default)(this, TimeGridHeaderResources);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, TimeGridHeaderResources, [].concat(args));
+    _this.handleHeaderClick = function (date, view, e) {
+      e.preventDefault();
+      (0, _helpers.notify)(_this.props.onDrillDown, [date, view]);
+    };
+    return _this;
+  }
+  (0, _inherits2.default)(TimeGridHeaderResources, _React$Component);
+  return (0, _createClass2.default)(TimeGridHeaderResources, [{
+    key: "renderHeaderCells",
+    value: function renderHeaderCells(range) {
+      var _this2 = this;
+      var _this$props = this.props,
+        localizer = _this$props.localizer,
+        getDrilldownView = _this$props.getDrilldownView,
+        getNow = _this$props.getNow,
+        dayProp = _this$props.getters.dayProp,
+        _this$props$component = _this$props.components,
+        _this$props$component2 = _this$props$component.header,
+        HeaderComponent = _this$props$component2 === void 0 ? _Header.default : _this$props$component2,
+        _this$props$component3 = _this$props$component.resourceHeader,
+        ResourceHeaderComponent = _this$props$component3 === void 0 ? _ResourceHeader.default : _this$props$component3,
+        resources = _this$props.resources,
+        accessors = _this$props.accessors,
+        events = _this$props.events,
+        rtl = _this$props.rtl,
+        selectable = _this$props.selectable,
+        components = _this$props.components,
+        getters = _this$props.getters,
+        resizable = _this$props.resizable;
+      var today = getNow();
+      var groupedEvents = resources.groupEvents(events);
+      return range.map(function (date, idx) {
+        var drilldownView = getDrilldownView(date);
+        var label = localizer.format(date, 'dayFormat');
+        var _dayProp = dayProp(date),
+          className = _dayProp.className,
+          style = _dayProp.style;
+        var header = /*#__PURE__*/_react.default.createElement(HeaderComponent, {
+          date: date,
+          label: label,
+          localizer: localizer
+        });
+        return /*#__PURE__*/_react.default.createElement("div", {
+          key: idx,
+          className: "rbc-time-header-content rbc-resource-grouping"
+        }, /*#__PURE__*/_react.default.createElement("div", {
+          className: "rbc-row rbc-time-header-cell".concat(range.length <= 1 ? ' rbc-time-header-cell-single-day' : '')
+        }, /*#__PURE__*/_react.default.createElement("div", {
+          style: style,
+          className: (0, _clsx.default)('rbc-header', className, localizer.isSameDate(date, today) && 'rbc-today')
+        }, drilldownView ? /*#__PURE__*/_react.default.createElement("button", {
+          type: "button",
+          className: "rbc-button-link",
+          onClick: function onClick(e) {
+            return _this2.handleHeaderClick(date, drilldownView, e);
+          }
+        }, header) : /*#__PURE__*/_react.default.createElement("span", null, header))), /*#__PURE__*/_react.default.createElement("div", {
+          className: "rbc-row"
+        }, resources.map(function (_ref, idx) {
+          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+            id = _ref2[0],
+            resource = _ref2[1];
+          return /*#__PURE__*/_react.default.createElement("div", {
+            key: "resource_".concat(id, "_").concat(idx),
+            className: (0, _clsx.default)('rbc-header', className, localizer.isSameDate(date, today) && 'rbc-today')
+          }, /*#__PURE__*/_react.default.createElement(ResourceHeaderComponent, {
+            index: idx,
+            label: accessors.resourceTitle(resource),
+            resource: resource
+          }));
+        })), /*#__PURE__*/_react.default.createElement("div", {
+          className: "rbc-row rbc-m-b-negative-3 rbc-h-full"
+        }, resources.map(function (_ref3, idx) {
+          var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+            id = _ref4[0],
+            resource = _ref4[1];
+          // Filter the grouped events by the current date.
+          var filteredEvents = (groupedEvents.get(id) || []).filter(function (event) {
+            return localizer.isSameDate(event.start, date) || localizer.isSameDate(event.end, date);
+          });
+          return /*#__PURE__*/_react.default.createElement(_DateContentRow.default, {
+            key: "resource_".concat(id, "_").concat(idx),
+            isAllDay: true,
+            rtl: rtl,
+            getNow: getNow,
+            minRows: 2,
+            maxRows: _this2.props.allDayMaxRows + 1,
+            range: [date] // This ensures that only the single day is rendered
+            ,
+            events: filteredEvents // Only show filtered events for this day.
+            ,
+            resourceId: resource && id,
+            className: "rbc-allday-cell",
+            selectable: selectable,
+            selected: _this2.props.selected,
+            components: components,
+            accessors: accessors,
+            getters: getters,
+            localizer: localizer,
+            onSelect: _this2.props.onSelectEvent,
+            onShowMore: _this2.props.onShowMore,
+            onDoubleClick: _this2.props.onDoubleClickEvent,
+            onKeyDown: _this2.props.onKeyPressEvent,
+            onSelectSlot: _this2.props.onSelectSlot,
+            longPressThreshold: _this2.props.longPressThreshold,
+            resizable: resizable
+          });
+        })));
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+        width = _this$props2.width,
+        rtl = _this$props2.rtl,
+        range = _this$props2.range,
+        scrollRef = _this$props2.scrollRef,
+        isOverflowing = _this$props2.isOverflowing,
+        TimeGutterHeader = _this$props2.components.timeGutterHeader;
+      var style = {};
+      if (isOverflowing) {
+        style[rtl ? 'marginLeft' : 'marginRight'] = "".concat((0, _scrollbarSize.default)() - 1, "px");
+      }
+      return /*#__PURE__*/_react.default.createElement("div", {
+        style: style,
+        ref: scrollRef,
+        className: (0, _clsx.default)('rbc-time-header', isOverflowing && 'rbc-overflowing')
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-label rbc-time-header-gutter",
+        style: {
+          width: width,
+          minWidth: width,
+          maxWidth: width
+        }
+      }, TimeGutterHeader && /*#__PURE__*/_react.default.createElement(TimeGutterHeader, null)), this.renderHeaderCells(range));
+    }
+  }]);
+}(_react.default.Component);
+var _default = exports.default = TimeGridHeaderResources;

node_modules/react-big-calendar/lib/TimeGutter.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _TimeSlots = require("./utils/TimeSlots");
+var _TimeSlotGroup = _interopRequireDefault(require("./TimeSlotGroup"));
+/**
+ * Since the TimeGutter only displays the 'times' of slots in a day, and is separate
+ * from the Day Columns themselves, we check to see if the range contains an offset difference
+ * and, if so, change the beginning and end 'date' by a day to properly display the slots times
+ * used.
+ */
+function adjustForDST(_ref) {
+  var min = _ref.min,
+    max = _ref.max,
+    localizer = _ref.localizer;
+  if (localizer.getTimezoneOffset(min) !== localizer.getTimezoneOffset(max)) {
+    return {
+      start: localizer.add(min, -1, 'day'),
+      end: localizer.add(max, -1, 'day')
+    };
+  }
+  return {
+    start: min,
+    end: max
+  };
+}
+var TimeGutter = function TimeGutter(_ref2) {
+  var min = _ref2.min,
+    max = _ref2.max,
+    timeslots = _ref2.timeslots,
+    step = _ref2.step,
+    localizer = _ref2.localizer,
+    getNow = _ref2.getNow,
+    resource = _ref2.resource,
+    components = _ref2.components,
+    getters = _ref2.getters,
+    gutterRef = _ref2.gutterRef;
+  var TimeGutterWrapper = components.timeGutterWrapper;
+  var _useMemo = (0, _react.useMemo)(function () {
+      return adjustForDST({
+        min: min,
+        max: max,
+        localizer: localizer
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [min === null || min === void 0 ? void 0 : min.toISOString(), max === null || max === void 0 ? void 0 : max.toISOString(), localizer]),
+    start = _useMemo.start,
+    end = _useMemo.end;
+  var _useState = (0, _react.useState)((0, _TimeSlots.getSlotMetrics)({
+      min: start,
+      max: end,
+      timeslots: timeslots,
+      step: step,
+      localizer: localizer
+    })),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    slotMetrics = _useState2[0],
+    setSlotMetrics = _useState2[1];
+  (0, _react.useEffect)(function () {
+    if (slotMetrics) {
+      setSlotMetrics(slotMetrics.update({
+        min: start,
+        max: end,
+        timeslots: timeslots,
+        step: step,
+        localizer: localizer
+      }));
+    }
+    /**
+     * We don't want this to fire when slotMetrics is updated as it would recursively bomb
+     */
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [start === null || start === void 0 ? void 0 : start.toISOString(), end === null || end === void 0 ? void 0 : end.toISOString(), timeslots, step]);
+  var renderSlot = (0, _react.useCallback)(function (value, idx) {
+    if (idx) return null; // don't return the first (0) idx
+
+    var isNow = slotMetrics.dateIsInGroup(getNow(), idx);
+    return /*#__PURE__*/_react.default.createElement("span", {
+      className: (0, _clsx.default)('rbc-label', isNow && 'rbc-now')
+    }, localizer.format(value, 'timeGutterFormat'));
+  }, [slotMetrics, localizer, getNow]);
+  return /*#__PURE__*/_react.default.createElement(TimeGutterWrapper, {
+    slotMetrics: slotMetrics
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "rbc-time-gutter rbc-time-column",
+    ref: gutterRef
+  }, slotMetrics.groups.map(function (grp, idx) {
+    return /*#__PURE__*/_react.default.createElement(_TimeSlotGroup.default, {
+      key: idx,
+      group: grp,
+      resource: resource,
+      components: components,
+      renderSlot: renderSlot,
+      getters: getters
+    });
+  })));
+};
+var _default = exports.default = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  return /*#__PURE__*/_react.default.createElement(TimeGutter, Object.assign({
+    gutterRef: ref
+  }, props));
+});

node_modules/react-big-calendar/lib/TimeSlotGroup.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _react = _interopRequireWildcard(require("react"));
+var _BackgroundWrapper = _interopRequireDefault(require("./BackgroundWrapper"));
+var TimeSlotGroup = exports.default = /*#__PURE__*/function (_Component) {
+  function TimeSlotGroup() {
+    (0, _classCallCheck2.default)(this, TimeSlotGroup);
+    return (0, _callSuper2.default)(this, TimeSlotGroup, arguments);
+  }
+  (0, _inherits2.default)(TimeSlotGroup, _Component);
+  return (0, _createClass2.default)(TimeSlotGroup, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        renderSlot = _this$props.renderSlot,
+        resource = _this$props.resource,
+        group = _this$props.group,
+        getters = _this$props.getters,
+        _this$props$component = _this$props.components,
+        _this$props$component2 = _this$props$component === void 0 ? {} : _this$props$component,
+        _this$props$component3 = _this$props$component2.timeSlotWrapper,
+        Wrapper = _this$props$component3 === void 0 ? _BackgroundWrapper.default : _this$props$component3;
+      var groupProps = getters ? getters.slotGroupProp(group) : {};
+      return /*#__PURE__*/_react.default.createElement("div", Object.assign({
+        className: "rbc-timeslot-group"
+      }, groupProps), group.map(function (value, idx) {
+        var slotProps = getters ? getters.slotProp(value, resource) : {};
+        return /*#__PURE__*/_react.default.createElement(Wrapper, {
+          key: idx,
+          value: value,
+          resource: resource
+        }, /*#__PURE__*/_react.default.createElement("div", Object.assign({}, slotProps, {
+          className: (0, _clsx.default)('rbc-time-slot', slotProps.className)
+        }), renderSlot && renderSlot(value, idx)));
+      }));
+    }
+  }]);
+}(_react.Component);

node_modules/react-big-calendar/lib/Toolbar.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _constants = require("./utils/constants");
+var Toolbar = /*#__PURE__*/function (_React$Component) {
+  function Toolbar() {
+    var _this;
+    (0, _classCallCheck2.default)(this, Toolbar);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, Toolbar, [].concat(args));
+    _this.navigate = function (action) {
+      _this.props.onNavigate(action);
+    };
+    _this.view = function (view) {
+      _this.props.onView(view);
+    };
+    return _this;
+  }
+  (0, _inherits2.default)(Toolbar, _React$Component);
+  return (0, _createClass2.default)(Toolbar, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        messages = _this$props.localizer.messages,
+        label = _this$props.label;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-toolbar"
+      }, /*#__PURE__*/_react.default.createElement("span", {
+        className: "rbc-btn-group"
+      }, /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        onClick: this.navigate.bind(null, _constants.navigate.TODAY)
+      }, messages.today), /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        onClick: this.navigate.bind(null, _constants.navigate.PREVIOUS)
+      }, messages.previous), /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        onClick: this.navigate.bind(null, _constants.navigate.NEXT)
+      }, messages.next)), /*#__PURE__*/_react.default.createElement("span", {
+        className: "rbc-toolbar-label"
+      }, label), /*#__PURE__*/_react.default.createElement("span", {
+        className: "rbc-btn-group"
+      }, this.viewNamesGroup(messages)));
+    }
+  }, {
+    key: "viewNamesGroup",
+    value: function viewNamesGroup(messages) {
+      var _this2 = this;
+      var viewNames = this.props.views;
+      var view = this.props.view;
+      if (viewNames.length > 1) {
+        return viewNames.map(function (name) {
+          return /*#__PURE__*/_react.default.createElement("button", {
+            type: "button",
+            key: name,
+            className: (0, _clsx.default)({
+              'rbc-active': view === name
+            }),
+            onClick: _this2.view.bind(null, name)
+          }, messages[name]);
+        });
+      }
+    }
+  }]);
+}(_react.default.Component);
+var _default = exports.default = Toolbar;

node_modules/react-big-calendar/lib/Views.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("./utils/constants");
+var _Month = _interopRequireDefault(require("./Month"));
+var _Day = _interopRequireDefault(require("./Day"));
+var _Week = _interopRequireDefault(require("./Week"));
+var _WorkWeek = _interopRequireDefault(require("./WorkWeek"));
+var _Agenda = _interopRequireDefault(require("./Agenda"));
+var VIEWS = (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.views.MONTH, _Month.default), _constants.views.WEEK, _Week.default), _constants.views.WORK_WEEK, _WorkWeek.default), _constants.views.DAY, _Day.default), _constants.views.AGENDA, _Agenda.default);
+var _default = exports.default = VIEWS;

node_modules/react-big-calendar/lib/Week.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _constants = require("./utils/constants");
+var _propTypes = require("./utils/propTypes");
+var _TimeGrid = _interopRequireDefault(require("./TimeGrid"));
+var _excluded = ["date", "localizer", "min", "max", "scrollToTime", "enableAutoScroll"];
+var Week = /*#__PURE__*/function (_React$Component) {
+  function Week() {
+    (0, _classCallCheck2.default)(this, Week);
+    return (0, _callSuper2.default)(this, Week, arguments);
+  }
+  (0, _inherits2.default)(Week, _React$Component);
+  return (0, _createClass2.default)(Week, [{
+    key: "render",
+    value: function render() {
+      /**
+       * This allows us to default min, max, and scrollToTime
+       * using our localizer. This is necessary until such time
+       * as TimeGrid is converted to a functional component.
+       */
+      var _this$props = this.props,
+        date = _this$props.date,
+        localizer = _this$props.localizer,
+        _this$props$min = _this$props.min,
+        min = _this$props$min === void 0 ? localizer.startOf(new Date(), 'day') : _this$props$min,
+        _this$props$max = _this$props.max,
+        max = _this$props$max === void 0 ? localizer.endOf(new Date(), 'day') : _this$props$max,
+        _this$props$scrollToT = _this$props.scrollToTime,
+        scrollToTime = _this$props$scrollToT === void 0 ? localizer.startOf(new Date(), 'day') : _this$props$scrollToT,
+        _this$props$enableAut = _this$props.enableAutoScroll,
+        enableAutoScroll = _this$props$enableAut === void 0 ? true : _this$props$enableAut,
+        props = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+      var range = Week.range(date, this.props);
+      return /*#__PURE__*/_react.default.createElement(_TimeGrid.default, Object.assign({}, props, {
+        range: range,
+        eventOffset: 15,
+        localizer: localizer,
+        min: min,
+        max: max,
+        scrollToTime: scrollToTime,
+        enableAutoScroll: enableAutoScroll
+      }));
+    }
+  }]);
+}(_react.default.Component);
+Week.defaultProps = _TimeGrid.default.defaultProps;
+Week.navigate = function (date, action, _ref) {
+  var localizer = _ref.localizer;
+  switch (action) {
+    case _constants.navigate.PREVIOUS:
+      return localizer.add(date, -1, 'week');
+    case _constants.navigate.NEXT:
+      return localizer.add(date, 1, 'week');
+    default:
+      return date;
+  }
+};
+Week.range = function (date, _ref2) {
+  var localizer = _ref2.localizer;
+  var firstOfWeek = localizer.startOfWeek();
+  var start = localizer.startOf(date, 'week', firstOfWeek);
+  var end = localizer.endOf(date, 'week', firstOfWeek);
+  return localizer.range(start, end);
+};
+Week.title = function (date, _ref3) {
+  var localizer = _ref3.localizer;
+  var _Week$range = Week.range(date, {
+      localizer: localizer
+    }),
+    _Week$range2 = (0, _toArray2.default)(_Week$range),
+    start = _Week$range2[0],
+    rest = _Week$range2.slice(1);
+  return localizer.format({
+    start: start,
+    end: rest.pop()
+  }, 'dayRangeHeaderFormat');
+};
+var _default = exports.default = Week;

node_modules/react-big-calendar/lib/WorkWeek.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _Week = _interopRequireDefault(require("./Week"));
+var _TimeGrid = _interopRequireDefault(require("./TimeGrid"));
+var _excluded = ["date", "localizer", "min", "max", "scrollToTime", "enableAutoScroll"];
+function workWeekRange(date, options) {
+  return _Week.default.range(date, options).filter(function (d) {
+    return [6, 0].indexOf(d.getDay()) === -1;
+  });
+}
+var WorkWeek = /*#__PURE__*/function (_React$Component) {
+  function WorkWeek() {
+    (0, _classCallCheck2.default)(this, WorkWeek);
+    return (0, _callSuper2.default)(this, WorkWeek, arguments);
+  }
+  (0, _inherits2.default)(WorkWeek, _React$Component);
+  return (0, _createClass2.default)(WorkWeek, [{
+    key: "render",
+    value: function render() {
+      /**
+       * This allows us to default min, max, and scrollToTime
+       * using our localizer. This is necessary until such time
+       * as TimeGrid is converted to a functional component.
+       */
+      var _this$props = this.props,
+        date = _this$props.date,
+        localizer = _this$props.localizer,
+        _this$props$min = _this$props.min,
+        min = _this$props$min === void 0 ? localizer.startOf(new Date(), 'day') : _this$props$min,
+        _this$props$max = _this$props.max,
+        max = _this$props$max === void 0 ? localizer.endOf(new Date(), 'day') : _this$props$max,
+        _this$props$scrollToT = _this$props.scrollToTime,
+        scrollToTime = _this$props$scrollToT === void 0 ? localizer.startOf(new Date(), 'day') : _this$props$scrollToT,
+        _this$props$enableAut = _this$props.enableAutoScroll,
+        enableAutoScroll = _this$props$enableAut === void 0 ? true : _this$props$enableAut,
+        props = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+      var range = workWeekRange(date, this.props);
+      return /*#__PURE__*/_react.default.createElement(_TimeGrid.default, Object.assign({}, props, {
+        range: range,
+        eventOffset: 15,
+        localizer: localizer,
+        min: min,
+        max: max,
+        scrollToTime: scrollToTime,
+        enableAutoScroll: enableAutoScroll
+      }));
+    }
+  }]);
+}(_react.default.Component);
+WorkWeek.defaultProps = _TimeGrid.default.defaultProps;
+WorkWeek.range = workWeekRange;
+WorkWeek.navigate = _Week.default.navigate;
+WorkWeek.title = function (date, _ref) {
+  var localizer = _ref.localizer;
+  var _workWeekRange = workWeekRange(date, {
+      localizer: localizer
+    }),
+    _workWeekRange2 = (0, _toArray2.default)(_workWeekRange),
+    start = _workWeekRange2[0],
+    rest = _workWeekRange2.slice(1);
+  return localizer.format({
+    start: start,
+    end: rest.pop()
+  }, 'dayRangeHeaderFormat');
+};
+var _default = exports.default = WorkWeek;

node_modules/react-big-calendar/lib/addons/dragAndDrop/DnDContext.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DnDContext = void 0;
+var _react = _interopRequireDefault(require("react"));
+var DnDContext = exports.DnDContext = /*#__PURE__*/_react.default.createContext();

node_modules/react-big-calendar/lib/addons/dragAndDrop/EventContainerWrapper.js

@@ -0,0 +1,338 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _DnDContext = require("./DnDContext");
+var _domHelpers = require("dom-helpers");
+var _querySelectorAll = _interopRequireDefault(require("dom-helpers/cjs/querySelectorAll"));
+var _Selection = _interopRequireWildcard(require("../../Selection"));
+var _TimeGridEvent = _interopRequireDefault(require("../../TimeGridEvent"));
+var _common = require("./common");
+var EventContainerWrapper = /*#__PURE__*/function (_React$Component) {
+  function EventContainerWrapper() {
+    var _this;
+    (0, _classCallCheck2.default)(this, EventContainerWrapper);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, EventContainerWrapper, [].concat(args));
+    _this.handleMove = function (point, bounds) {
+      if (!(0, _common.pointInColumn)(bounds, point)) return _this.reset();
+      var event = _this.context.draggable.dragAndDropAction.event;
+      var _this$props = _this.props,
+        accessors = _this$props.accessors,
+        slotMetrics = _this$props.slotMetrics;
+      var newSlot = slotMetrics.closestSlotFromPoint({
+        y: point.y - _this.eventOffsetTop,
+        x: point.x
+      }, bounds);
+      var _eventTimes = (0, _common.eventTimes)(event, accessors, _this.props.localizer),
+        duration = _eventTimes.duration;
+      var newEnd = _this.props.localizer.add(newSlot, duration, 'milliseconds');
+      _this.update(event, slotMetrics.getRange(newSlot, newEnd, false, true));
+    };
+    _this._cleanupPreviewElements = function () {
+      if (_this.ref.current) {
+        var previewElements = (0, _querySelectorAll.default)(_this.ref.current, '.rbc-addons-dnd-drag-preview');
+        previewElements.forEach(function (el) {
+          if (el.parentNode) {
+            try {
+              el.parentNode.removeChild(el);
+            } catch (err) {
+              // Ignore removal errors
+            }
+          }
+        });
+      }
+    };
+    _this.handleDropFromOutside = function (point, boundaryBox) {
+      var _this$props2 = _this.props,
+        slotMetrics = _this$props2.slotMetrics,
+        resource = _this$props2.resource;
+      var start = slotMetrics.closestSlotFromPoint({
+        y: point.y,
+        x: point.x
+      }, boundaryBox);
+      var end = _this._calculateDnDEnd(start);
+      _this.context.draggable.onDropFromOutside({
+        start: start,
+        end: end,
+        allDay: false,
+        resource: resource
+      });
+      _this.reset();
+      // Only call cleanup here, after dropping from outside
+      _this._cleanupPreviewElements();
+    };
+    _this.handleDragOverFromOutside = function (point, bounds) {
+      var slotMetrics = _this.props.slotMetrics;
+      var start = slotMetrics.closestSlotFromPoint({
+        y: point.y,
+        x: point.x
+      }, bounds);
+      var end = _this._calculateDnDEnd(start);
+      var event = _this.context.draggable.dragFromOutsideItem();
+      _this.update(event, slotMetrics.getRange(start, end, false, true));
+    };
+    _this._calculateDnDEnd = function (start) {
+      var _this$props3 = _this.props,
+        accessors = _this$props3.accessors,
+        slotMetrics = _this$props3.slotMetrics,
+        localizer = _this$props3.localizer;
+      var event = _this.context.draggable.dragFromOutsideItem();
+      var _eventTimes2 = (0, _common.eventTimes)(event, accessors, localizer),
+        eventDuration = _eventTimes2.duration;
+      var end = slotMetrics.nextSlot(start);
+      var eventHasDuration = !isNaN(eventDuration);
+      if (eventHasDuration) {
+        var eventEndSlot = localizer.add(start, eventDuration, 'milliseconds');
+        end = new Date(Math.max(eventEndSlot, end));
+      }
+      return end;
+    };
+    _this.updateParentScroll = function (parent, node) {
+      setTimeout(function () {
+        var draggedEl = (0, _querySelectorAll.default)(node, '.rbc-addons-dnd-drag-preview')[0];
+        if (draggedEl) {
+          if (draggedEl.offsetTop < parent.scrollTop) {
+            (0, _domHelpers.scrollTop)(parent, Math.max(draggedEl.offsetTop, 0));
+          } else if (draggedEl.offsetTop + draggedEl.offsetHeight > parent.scrollTop + parent.clientHeight) {
+            (0, _domHelpers.scrollTop)(parent, Math.min(draggedEl.offsetTop - parent.offsetHeight + draggedEl.offsetHeight, parent.scrollHeight));
+          }
+        }
+      });
+    };
+    _this._selectable = function () {
+      var wrapper = _this.ref.current;
+      var node = wrapper.children[0];
+      var isBeingDragged = false;
+      var selector = _this._selector = new _Selection.default(function () {
+        return wrapper.closest('.rbc-time-view');
+      });
+      var parent = (0, _domHelpers.scrollParent)(wrapper);
+      selector.on('beforeSelect', function (point) {
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (!dragAndDropAction.action) return false;
+        if (dragAndDropAction.action === 'resize') {
+          return (0, _common.pointInColumn)((0, _Selection.getBoundsForNode)(node), point);
+        }
+        var eventNode = (0, _Selection.getEventNodeFromPoint)(node, point);
+        if (!eventNode) return false;
+
+        // eventOffsetTop is distance from the top of the event to the initial
+        // mouseDown position. We need this later to compute the new top of the
+        // event during move operations, since the final location is really a
+        // delta from this point. note: if we want to DRY this with WeekWrapper,
+        // probably better just to capture the mouseDown point here and do the
+        // placement computation in handleMove()...
+        _this.eventOffsetTop = point.y - (0, _Selection.getBoundsForNode)(eventNode).top;
+      });
+      selector.on('selecting', function (box) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (dragAndDropAction.action === 'move') {
+          _this.updateParentScroll(parent, node);
+          _this.handleMove(box, bounds);
+        }
+        if (dragAndDropAction.action === 'resize') {
+          _this.updateParentScroll(parent, node);
+          _this.handleResize(box, bounds);
+        }
+      });
+      selector.on('dropFromOutside', function (point) {
+        if (!_this.context.draggable.onDropFromOutside) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!(0, _common.pointInColumn)(bounds, point)) return;
+        _this.handleDropFromOutside(point, bounds);
+      });
+      selector.on('dragOverFromOutside', function (point) {
+        var item = _this.context.draggable.dragFromOutsideItem ? _this.context.draggable.dragFromOutsideItem() : null;
+        if (!item) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!(0, _common.pointInColumn)(bounds, point)) return _this.reset();
+        _this.handleDragOverFromOutside(point, bounds);
+      });
+      selector.on('selectStart', function () {
+        isBeingDragged = true;
+        _this.context.draggable.onStart();
+      });
+      selector.on('select', function (point) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        isBeingDragged = false;
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (dragAndDropAction.action === 'resize') {
+          _this.handleInteractionEnd();
+        } else if (!_this.state.event || !(0, _common.pointInColumn)(bounds, point)) {
+          return;
+        } else {
+          _this.handleInteractionEnd();
+        }
+      });
+      selector.on('click', function () {
+        if (isBeingDragged) _this.reset();
+        _this.context.draggable.onEnd(null);
+      });
+      selector.on('reset', function () {
+        _this.reset();
+        _this.context.draggable.onEnd(null);
+      });
+    };
+    _this.handleInteractionEnd = function () {
+      var resource = _this.props.resource;
+      var event = _this.state.event;
+      _this.reset();
+      _this.context.draggable.onEnd({
+        start: event.start,
+        end: event.end,
+        resourceId: resource
+      });
+    };
+    _this._teardownSelectable = function () {
+      if (!_this._selector) return;
+      _this._selector.teardown();
+      _this._selector = null;
+    };
+    _this.state = {};
+    _this.ref = /*#__PURE__*/_react.default.createRef();
+    return _this;
+  }
+  (0, _inherits2.default)(EventContainerWrapper, _React$Component);
+  return (0, _createClass2.default)(EventContainerWrapper, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._selectable();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._teardownSelectable();
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      if (this.state.event) this.setState({
+        event: null,
+        top: null,
+        height: null
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(event, _ref) {
+      var startDate = _ref.startDate,
+        endDate = _ref.endDate,
+        top = _ref.top,
+        height = _ref.height;
+      var lastEvent = this.state.event;
+      if (lastEvent && startDate === lastEvent.start && endDate === lastEvent.end) {
+        return;
+      }
+      this.setState({
+        top: top,
+        height: height,
+        event: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, event), {}, {
+          start: startDate,
+          end: endDate
+        })
+      });
+    }
+  }, {
+    key: "handleResize",
+    value: function handleResize(point, bounds) {
+      var _this$props4 = this.props,
+        accessors = _this$props4.accessors,
+        slotMetrics = _this$props4.slotMetrics,
+        localizer = _this$props4.localizer;
+      var _this$context$draggab = this.context.draggable.dragAndDropAction,
+        event = _this$context$draggab.event,
+        direction = _this$context$draggab.direction;
+      var newTime = slotMetrics.closestSlotFromPoint(point, bounds);
+      var _eventTimes3 = (0, _common.eventTimes)(event, accessors, localizer),
+        start = _eventTimes3.start,
+        end = _eventTimes3.end;
+      var newRange;
+      if (direction === 'UP') {
+        var newStart = localizer.min(newTime, slotMetrics.closestSlotFromDate(end, -1));
+        // Get the new range based on the new start
+        // but don't overwrite the end date as it could be outside this day boundary.
+        newRange = slotMetrics.getRange(newStart, end);
+        newRange = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, newRange), {}, {
+          endDate: end
+        });
+      } else if (direction === 'DOWN') {
+        // Get the new range based on the new end
+        // but don't overwrite the start date as it could be outside this day boundary.
+        var newEnd = localizer.max(newTime, slotMetrics.closestSlotFromDate(start));
+        newRange = slotMetrics.getRange(start, newEnd);
+        newRange = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, newRange), {}, {
+          startDate: start
+        });
+      }
+      this.update(event, newRange);
+    }
+  }, {
+    key: "renderContent",
+    value: function renderContent() {
+      var _this$props5 = this.props,
+        children = _this$props5.children,
+        accessors = _this$props5.accessors,
+        components = _this$props5.components,
+        getters = _this$props5.getters,
+        slotMetrics = _this$props5.slotMetrics,
+        localizer = _this$props5.localizer;
+      var _this$state = this.state,
+        event = _this$state.event,
+        top = _this$state.top,
+        height = _this$state.height;
+      if (!event) return children;
+      var events = children.props.children;
+      var start = event.start,
+        end = event.end;
+      var label;
+      var format = 'eventTimeRangeFormat';
+      var startsBeforeDay = slotMetrics.startsBeforeDay(start);
+      var startsAfterDay = slotMetrics.startsAfterDay(end);
+      if (startsBeforeDay) format = 'eventTimeRangeEndFormat';else if (startsAfterDay) format = 'eventTimeRangeStartFormat';
+      if (startsBeforeDay && startsAfterDay) label = localizer.messages.allDay;else label = localizer.format({
+        start: start,
+        end: end
+      }, format);
+      return /*#__PURE__*/_react.default.cloneElement(children, {
+        children: /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, events, event && /*#__PURE__*/_react.default.createElement(_TimeGridEvent.default, {
+          event: event,
+          label: label,
+          className: "rbc-addons-dnd-drag-preview",
+          style: {
+            top: top,
+            height: height,
+            width: 100
+          },
+          getters: getters,
+          components: components,
+          accessors: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, accessors), _common.dragAccessors),
+          continuesPrior: startsBeforeDay,
+          continuesAfter: startsAfterDay
+        }))
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        ref: this.ref
+      }, this.renderContent());
+    }
+  }]);
+}(_react.default.Component);
+EventContainerWrapper.contextType = _DnDContext.DnDContext;
+var _default = exports.default = EventContainerWrapper;

node_modules/react-big-calendar/lib/addons/dragAndDrop/EventWrapper.js

@@ -0,0 +1,153 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _accessors = require("../../utils/accessors");
+var _DnDContext = require("./DnDContext");
+var EventWrapper = /*#__PURE__*/function (_React$Component) {
+  function EventWrapper() {
+    var _this;
+    (0, _classCallCheck2.default)(this, EventWrapper);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, EventWrapper, [].concat(args));
+    _this.handleResizeUp = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'UP');
+    };
+    _this.handleResizeDown = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'DOWN');
+    };
+    _this.handleResizeLeft = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'LEFT');
+    };
+    _this.handleResizeRight = function (e) {
+      if (e.button !== 0) return;
+      _this.context.draggable.onBeginAction(_this.props.event, 'resize', 'RIGHT');
+    };
+    _this.handleStartDragging = function (e) {
+      var _e$target$getAttribut;
+      if (e.button !== 0) return;
+      // hack: because of the way the anchors are arranged in the DOM, resize
+      // anchor events will bubble up to the move anchor listener. Don't start
+      // move operations when we're on a resize anchor.
+      var isResizeHandle = (_e$target$getAttribut = e.target.getAttribute('class')) === null || _e$target$getAttribut === void 0 ? void 0 : _e$target$getAttribut.includes('rbc-addons-dnd-resize');
+      if (!isResizeHandle) {
+        var extendedEvent = (0, _objectSpread2.default)({}, _this.props.event);
+        extendedEvent.sourceResource = _this.props.resource;
+        _this.context.draggable.onBeginAction(_this.props.event, 'move');
+      }
+    };
+    return _this;
+  }
+  (0, _inherits2.default)(EventWrapper, _React$Component);
+  return (0, _createClass2.default)(EventWrapper, [{
+    key: "renderAnchor",
+    value: function renderAnchor(direction) {
+      var cls = direction === 'Up' || direction === 'Down' ? 'ns' : 'ew';
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-addons-dnd-resize-".concat(cls, "-anchor"),
+        onMouseDown: this["handleResize".concat(direction)]
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: "rbc-addons-dnd-resize-".concat(cls, "-icon")
+      }));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        event = _this$props.event,
+        type = _this$props.type,
+        continuesPrior = _this$props.continuesPrior,
+        continuesAfter = _this$props.continuesAfter,
+        resizable = _this$props.resizable;
+      var children = this.props.children;
+      if (event.__isPreview) return /*#__PURE__*/_react.default.cloneElement(children, {
+        className: (0, _clsx.default)(children.props.className, 'rbc-addons-dnd-drag-preview')
+      });
+      var draggable = this.context.draggable;
+      var draggableAccessor = draggable.draggableAccessor,
+        resizableAccessor = draggable.resizableAccessor;
+      var isDraggable = draggableAccessor ? !!(0, _accessors.accessor)(event, draggableAccessor) : true;
+
+      /* Event is not draggable, no need to wrap it */
+      if (!isDraggable) {
+        return children;
+      }
+
+      /*
+       * The resizability of events depends on whether they are
+       * allDay events and how they are displayed.
+       *
+       * 1. If the event is being shown in an event row (because
+       * it is an allDay event shown in the header row or because as
+       * in month view the view is showing all events as rows) then we
+       * allow east-west resizing.
+       *
+       * 2. Otherwise the event is being displayed
+       * normally, we can drag it north-south to resize the times.
+       *
+       * See `DropWrappers` for handling of the drop of such events.
+       *
+       * Notwithstanding the above, we never show drag anchors for
+       * events which continue beyond current component. This happens
+       * in the middle of events when showMultiDay is true, and to
+       * events at the edges of the calendar's min/max location.
+       */
+      var isResizable = resizable && (resizableAccessor ? !!(0, _accessors.accessor)(event, resizableAccessor) : true);
+      if (isResizable || isDraggable) {
+        /*
+         * props.children is the singular <Event> component.
+         * BigCalendar positions the Event abolutely and we
+         * need the anchors to be part of that positioning.
+         * So we insert the anchors inside the Event's children
+         * rather than wrap the Event here as the latter approach
+         * would lose the positioning.
+         */
+        var newProps = {
+          onMouseDown: this.handleStartDragging,
+          onTouchStart: this.handleStartDragging
+        };
+        if (isResizable) {
+          // replace original event child with anchor-embellished child
+          var StartAnchor = null;
+          var EndAnchor = null;
+          if (type === 'date') {
+            StartAnchor = !continuesPrior && this.renderAnchor('Left');
+            EndAnchor = !continuesAfter && this.renderAnchor('Right');
+          } else {
+            StartAnchor = !continuesPrior && this.renderAnchor('Up');
+            EndAnchor = !continuesAfter && this.renderAnchor('Down');
+          }
+          newProps.children = /*#__PURE__*/_react.default.createElement("div", {
+            className: "rbc-addons-dnd-resizable"
+          }, StartAnchor, children.props.children, EndAnchor);
+        }
+        if (draggable.dragAndDropAction.interacting &&
+        // if an event is being dragged right now
+        draggable.dragAndDropAction.event === event // and it's the current event
+        ) {
+          // add a new class to it
+          newProps.className = (0, _clsx.default)(children.props.className, 'rbc-addons-dnd-dragged-event');
+        }
+        children = /*#__PURE__*/_react.default.cloneElement(children, newProps);
+      }
+      return children;
+    }
+  }]);
+}(_react.default.Component);
+EventWrapper.contextType = _DnDContext.DnDContext;
+var _default = exports.default = EventWrapper;

node_modules/react-big-calendar/lib/addons/dragAndDrop/WeekWrapper.js

@@ -0,0 +1,252 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _EventRow = _interopRequireDefault(require("../../EventRow"));
+var _Selection = _interopRequireWildcard(require("../../Selection"));
+var _eventLevels = require("../../utils/eventLevels");
+var _selection = require("../../utils/selection");
+var _common = require("./common");
+var _DnDContext = require("./DnDContext");
+var WeekWrapper = /*#__PURE__*/function (_React$Component) {
+  function WeekWrapper() {
+    var _this;
+    (0, _classCallCheck2.default)(this, WeekWrapper);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = (0, _callSuper2.default)(this, WeekWrapper, [].concat(args));
+    _this.handleMove = function (point, bounds, draggedEvent) {
+      if (!(0, _selection.pointInBox)(bounds, point)) return _this.reset();
+      var event = _this.context.draggable.dragAndDropAction.event || draggedEvent;
+      var _this$props = _this.props,
+        accessors = _this$props.accessors,
+        slotMetrics = _this$props.slotMetrics,
+        rtl = _this$props.rtl,
+        localizer = _this$props.localizer;
+      var slot = (0, _selection.getSlotAtX)(bounds, point.x, rtl, slotMetrics.slots);
+      var date = slotMetrics.getDateForSlot(slot);
+
+      // Adjust the dates, but maintain the times when moving
+      var _eventTimes = (0, _common.eventTimes)(event, accessors, localizer),
+        start = _eventTimes.start,
+        duration = _eventTimes.duration;
+      start = localizer.merge(date, start);
+      var end = localizer.add(start, duration, 'milliseconds');
+      // LATER: when dragging a multi-row event, only the first row is animating
+      _this.update(event, start, end);
+    };
+    _this.handleDropFromOutside = function (point, bounds) {
+      if (!_this.context.draggable.onDropFromOutside) return;
+      var _this$props2 = _this.props,
+        slotMetrics = _this$props2.slotMetrics,
+        rtl = _this$props2.rtl,
+        localizer = _this$props2.localizer;
+      var slot = (0, _selection.getSlotAtX)(bounds, point.x, rtl, slotMetrics.slots);
+      var start = slotMetrics.getDateForSlot(slot);
+      _this.context.draggable.onDropFromOutside({
+        start: start,
+        end: localizer.add(start, 1, 'day'),
+        allDay: false
+      });
+    };
+    _this.handleDragOverFromOutside = function (point, node) {
+      var item = _this.context.draggable.dragFromOutsideItem ? _this.context.draggable.dragFromOutsideItem() : null;
+      if (!item) return;
+      _this.handleMove(point, node, item);
+    };
+    _this._selectable = function () {
+      var node = _this.ref.current.closest('.rbc-month-row, .rbc-allday-cell');
+      var container = node.closest('.rbc-month-view, .rbc-time-view');
+      var isMonthRow = node.classList.contains('rbc-month-row');
+
+      // Valid container check only necessary in TimeGrid views
+      var selector = _this._selector = new _Selection.default(function () {
+        return container;
+      }, {
+        validContainers: (0, _toConsumableArray2.default)(!isMonthRow ? ['.rbc-day-slot', '.rbc-allday-cell'] : [])
+      });
+      selector.on('beforeSelect', function (point) {
+        var isAllDay = _this.props.isAllDay;
+        var action = _this.context.draggable.dragAndDropAction.action;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        var isInBox = (0, _selection.pointInBox)(bounds, point);
+        return action === 'move' || action === 'resize' && (!isAllDay || isInBox);
+      });
+      selector.on('selecting', function (box) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        var dragAndDropAction = _this.context.draggable.dragAndDropAction;
+        if (dragAndDropAction.action === 'move') _this.handleMove(box, bounds);
+        if (dragAndDropAction.action === 'resize') _this.handleResize(box, bounds);
+      });
+      selector.on('selectStart', function () {
+        return _this.context.draggable.onStart();
+      });
+      selector.on('select', function (point) {
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!_this.state.segment) return;
+        if (!(0, _selection.pointInBox)(bounds, point)) {
+          _this.reset();
+        } else {
+          _this.handleInteractionEnd();
+        }
+      });
+      selector.on('dropFromOutside', function (point) {
+        if (!_this.context.draggable.onDropFromOutside) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        if (!(0, _selection.pointInBox)(bounds, point)) return;
+        _this.handleDropFromOutside(point, bounds);
+      });
+      selector.on('dragOverFromOutside', function (point) {
+        if (!_this.context.draggable.dragFromOutsideItem) return;
+        var bounds = (0, _Selection.getBoundsForNode)(node);
+        _this.handleDragOverFromOutside(point, bounds);
+      });
+      selector.on('click', function () {
+        return _this.context.draggable.onEnd(null);
+      });
+      selector.on('reset', function () {
+        _this.reset();
+        _this.context.draggable.onEnd(null);
+      });
+    };
+    _this.handleInteractionEnd = function () {
+      var _this$props3 = _this.props,
+        resourceId = _this$props3.resourceId,
+        isAllDay = _this$props3.isAllDay;
+      var event = _this.state.segment.event;
+      _this.reset();
+      _this.context.draggable.onEnd({
+        start: event.start,
+        end: event.end,
+        resourceId: resourceId,
+        isAllDay: isAllDay
+      });
+    };
+    _this._teardownSelectable = function () {
+      if (!_this._selector) return;
+      _this._selector.teardown();
+      _this._selector = null;
+    };
+    _this.state = {};
+    _this.ref = /*#__PURE__*/_react.default.createRef();
+    return _this;
+  }
+  (0, _inherits2.default)(WeekWrapper, _React$Component);
+  return (0, _createClass2.default)(WeekWrapper, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._selectable();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._teardownSelectable();
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      if (this.state.segment) this.setState({
+        segment: null
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(event, start, end) {
+      var segment = (0, _eventLevels.eventSegments)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, event), {}, {
+        end: end,
+        start: start,
+        __isPreview: true
+      }), this.props.slotMetrics.range, _common.dragAccessors, this.props.localizer);
+      var lastSegment = this.state.segment;
+      if (lastSegment && segment.span === lastSegment.span && segment.left === lastSegment.left && segment.right === lastSegment.right) {
+        return;
+      }
+      this.setState({
+        segment: segment
+      });
+    }
+  }, {
+    key: "handleResize",
+    value: function handleResize(point, bounds) {
+      var _this$context$draggab = this.context.draggable.dragAndDropAction,
+        event = _this$context$draggab.event,
+        direction = _this$context$draggab.direction;
+      var _this$props4 = this.props,
+        accessors = _this$props4.accessors,
+        slotMetrics = _this$props4.slotMetrics,
+        rtl = _this$props4.rtl,
+        localizer = _this$props4.localizer;
+      var _eventTimes2 = (0, _common.eventTimes)(event, accessors, localizer),
+        start = _eventTimes2.start,
+        end = _eventTimes2.end;
+      var slot = (0, _selection.getSlotAtX)(bounds, point.x, rtl, slotMetrics.slots);
+      var date = slotMetrics.getDateForSlot(slot);
+      var cursorInRow = (0, _selection.pointInBox)(bounds, point);
+      if (direction === 'RIGHT') {
+        if (cursorInRow) {
+          if (slotMetrics.last < start) return this.reset();
+          if (localizer.eq(localizer.startOf(end, 'day'), end)) end = localizer.add(date, 1, 'day');else end = date;
+        } else if (localizer.inRange(start, slotMetrics.first, slotMetrics.last) || bounds.bottom < point.y && +slotMetrics.first > +start) {
+          end = localizer.add(slotMetrics.last, 1, 'milliseconds');
+        } else {
+          this.setState({
+            segment: null
+          });
+          return;
+        }
+        var originalEnd = accessors.end(event);
+        end = localizer.merge(end, originalEnd);
+        if (localizer.lt(end, start)) {
+          end = originalEnd;
+        }
+      } else if (direction === 'LEFT') {
+        if (cursorInRow) {
+          if (slotMetrics.first > end) return this.reset();
+          start = date;
+        } else if (localizer.inRange(end, slotMetrics.first, slotMetrics.last) || bounds.top > point.y && localizer.lt(slotMetrics.last, end)) {
+          start = localizer.add(slotMetrics.first, -1, 'milliseconds');
+        } else {
+          this.reset();
+          return;
+        }
+        var originalStart = accessors.start(event);
+        start = localizer.merge(start, originalStart);
+        if (localizer.gt(start, end)) {
+          start = originalStart;
+        }
+      }
+      this.update(event, start, end);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props5 = this.props,
+        children = _this$props5.children,
+        accessors = _this$props5.accessors;
+      var segment = this.state.segment;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        ref: this.ref,
+        className: "rbc-addons-dnd-row-body"
+      }, children, segment && /*#__PURE__*/_react.default.createElement(_EventRow.default, Object.assign({}, this.props, {
+        selected: null,
+        className: "rbc-addons-dnd-drag-row",
+        segments: [segment],
+        accessors: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, accessors), _common.dragAccessors)
+      })));
+    }
+  }]);
+}(_react.default.Component);
+WeekWrapper.contextType = _DnDContext.DnDContext;
+var _default = exports.default = WeekWrapper;

node_modules/react-big-calendar/lib/addons/dragAndDrop/common.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dragAccessors = void 0;
+exports.eventTimes = eventTimes;
+exports.mergeComponents = mergeComponents;
+exports.pointInColumn = pointInColumn;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _accessors = require("../../utils/accessors");
+var _react = require("react");
+var _excluded = ["children"];
+var dragAccessors = exports.dragAccessors = {
+  start: (0, _accessors.wrapAccessor)(function (e) {
+    return e.start;
+  }),
+  end: (0, _accessors.wrapAccessor)(function (e) {
+    return e.end;
+  })
+};
+function nest() {
+  for (var _len = arguments.length, Components = new Array(_len), _key = 0; _key < _len; _key++) {
+    Components[_key] = arguments[_key];
+  }
+  var factories = Components.filter(Boolean).map(_react.createFactory);
+  var Nest = function Nest(_ref) {
+    var children = _ref.children,
+      props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    return factories.reduceRight(function (child, factory) {
+      return factory(props, child);
+    }, children);
+  };
+  return Nest;
+}
+function mergeComponents() {
+  var components = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var addons = arguments.length > 1 ? arguments[1] : undefined;
+  var keys = Object.keys(addons);
+  var result = (0, _objectSpread2.default)({}, components);
+  keys.forEach(function (key) {
+    result[key] = components[key] ? nest(components[key], addons[key]) : addons[key];
+  });
+  return result;
+}
+function pointInColumn(bounds, point) {
+  var left = bounds.left,
+    right = bounds.right,
+    top = bounds.top;
+  var x = point.x,
+    y = point.y;
+  return x < right + 10 && x > left && y > top;
+}
+function eventTimes(event, accessors, localizer) {
+  var start = accessors.start(event);
+  var end = accessors.end(event);
+  var isZeroDuration = localizer.eq(start, end, 'minutes') && localizer.diff(start, end, 'minutes') === 0;
+  // make zero duration midnight events at least one day long
+  if (isZeroDuration) end = localizer.add(end, 1, 'day');
+  var duration = localizer.diff(start, end, 'milliseconds');
+  return {
+    start: start,
+    end: end,
+    duration: duration
+  };
+}

node_modules/react-big-calendar/lib/addons/dragAndDrop/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _withDragAndDrop = _interopRequireDefault(require("./withDragAndDrop"));
+var _default = exports.default = _withDragAndDrop.default;

node_modules/react-big-calendar/lib/addons/dragAndDrop/styles.css

@@ -0,0 +1,68 @@
+.rbc-addons-dnd .rbc-addons-dnd-row-body {
+  position: relative;
+}
+.rbc-addons-dnd .rbc-addons-dnd-drag-row {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-over {
+  background-color: rgba(0, 0, 0, 0.3);
+}
+.rbc-addons-dnd .rbc-event {
+  transition: opacity 150ms;
+}
+.rbc-addons-dnd .rbc-event:hover .rbc-addons-dnd-resize-ns-icon, .rbc-addons-dnd .rbc-event:hover .rbc-addons-dnd-resize-ew-icon {
+  display: block;
+}
+.rbc-addons-dnd .rbc-addons-dnd-dragged-event {
+  opacity: 0;
+}
+.rbc-addons-dnd.rbc-addons-dnd-is-dragging .rbc-event:not(.rbc-addons-dnd-dragged-event):not(.rbc-addons-dnd-drag-preview) {
+  opacity: 0.5;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resizable {
+  position: relative;
+  width: 100%;
+  height: 100%;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor {
+  width: 100%;
+  text-align: center;
+  position: absolute;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor:first-child {
+  top: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor:last-child {
+  bottom: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ns-anchor .rbc-addons-dnd-resize-ns-icon {
+  display: none;
+  border-top: 3px double;
+  margin: 0 auto;
+  width: 10px;
+  cursor: ns-resize;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor {
+  position: absolute;
+  top: 4px;
+  bottom: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor:first-child {
+  left: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor:last-child {
+  right: 0;
+}
+.rbc-addons-dnd .rbc-addons-dnd-resize-ew-anchor .rbc-addons-dnd-resize-ew-icon {
+  display: none;
+  border-left: 3px double;
+  margin-top: auto;
+  margin-bottom: auto;
+  height: 10px;
+  cursor: ew-resize;
+}
+
+/*# sourceMappingURL=styles.css.map */

node_modules/react-big-calendar/lib/addons/dragAndDrop/styles.css.map

@@ -0,0 +1 @@
+{"version":3,"sourceRoot":"","sources":["styles.scss"],"names":[],"mappings":"AAGE;EACE;;AAEF;EACE;EACA;EACA;EACA;;AAIF;EACE;;AAQF;EACE;;AAGE;EAAiE;;AAIrE;EACE;;AAGF;EACE;;AAGF;EACE;EACA;EACA;;AAGF;EACE;EACA;EACA;;AACA;EAAgB;;AAChB;EAAe;;AAEf;EACE;EACA;EACA;EACA;EACA;;AAIJ;EACE;EACA;EACA;;AACA;EAAgB;;AAChB;EAAe;;AAEf;EACE;EACA;EACA;EACA;EACA;EACA","file":"styles.css"}

node_modules/react-big-calendar/lib/addons/dragAndDrop/styles.scss

@@ -0,0 +1,78 @@
+@import '../../sass/variables';
+
+.rbc-addons-dnd {
+  .rbc-addons-dnd-row-body {
+    position: relative;
+  }
+  .rbc-addons-dnd-drag-row {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+  }
+
+
+  .rbc-addons-dnd-over {
+    background-color: rgba(
+      red($date-selection-bg-color),
+      green($date-selection-bg-color),
+      blue($date-selection-bg-color),
+      .3
+    );
+  }
+
+  .rbc-event {
+    transition: opacity 150ms;
+
+    &:hover {
+      .rbc-addons-dnd-resize-ns-icon, .rbc-addons-dnd-resize-ew-icon { display: block; }
+    }
+  }
+
+  .rbc-addons-dnd-dragged-event {
+    opacity: 0;
+  }
+
+  &.rbc-addons-dnd-is-dragging .rbc-event:not(.rbc-addons-dnd-dragged-event):not(.rbc-addons-dnd-drag-preview) {
+    opacity: .50;
+  }
+
+  .rbc-addons-dnd-resizable {
+    position: relative;
+    width: 100%;
+    height: 100%;
+  }
+
+  .rbc-addons-dnd-resize-ns-anchor {
+    width: 100%;
+    text-align: center;
+    position: absolute;
+    &:first-child { top: 0; }
+    &:last-child { bottom: 0; }
+
+    .rbc-addons-dnd-resize-ns-icon {
+      display: none;
+      border-top: 3px double;
+      margin: 0 auto;
+      width: 10px;
+      cursor: ns-resize;
+    }
+  }
+
+  .rbc-addons-dnd-resize-ew-anchor {
+    position: absolute;
+    top: 4px;
+    bottom: 0;
+    &:first-child { left: 0; }
+    &:last-child { right: 0; }
+
+    .rbc-addons-dnd-resize-ew-icon {
+      display: none;
+      border-left: 3px double;
+      margin-top: auto;
+      margin-bottom: auto;
+      height: 10px;
+      cursor: ew-resize;
+    }
+  }
+}

node_modules/react-big-calendar/lib/addons/dragAndDrop/withDragAndDrop.js

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = withDragAndDrop;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireDefault(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _propTypes = require("../../utils/propTypes");
+var _EventWrapper = _interopRequireDefault(require("./EventWrapper"));
+var _EventContainerWrapper = _interopRequireDefault(require("./EventContainerWrapper"));
+var _WeekWrapper = _interopRequireDefault(require("./WeekWrapper"));
+var _common = require("./common");
+var _DnDContext = require("./DnDContext");
+var _excluded = ["selectable", "elementProps", "components"];
+function withDragAndDrop(Calendar) {
+  var DragAndDropCalendar = /*#__PURE__*/function (_React$Component) {
+    function DragAndDropCalendar() {
+      var _this;
+      (0, _classCallCheck2.default)(this, DragAndDropCalendar);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = (0, _callSuper2.default)(this, DragAndDropCalendar, [].concat(args));
+      _this.defaultOnDragOver = function (event) {
+        event.preventDefault();
+      };
+      _this.handleBeginAction = function (event, action, direction) {
+        _this.setState({
+          event: event,
+          action: action,
+          direction: direction
+        });
+        var onDragStart = _this.props.onDragStart;
+        if (onDragStart) onDragStart({
+          event: event,
+          action: action,
+          direction: direction
+        });
+      };
+      _this.handleInteractionStart = function () {
+        if (_this.state.interacting === false) _this.setState({
+          interacting: true
+        });
+      };
+      _this.handleInteractionEnd = function (interactionInfo) {
+        var _this$state = _this.state,
+          action = _this$state.action,
+          event = _this$state.event;
+        if (!action) return;
+        _this.setState({
+          action: null,
+          event: null,
+          interacting: false,
+          direction: null
+        });
+        if (interactionInfo == null) return;
+        interactionInfo.event = event;
+        var _this$props = _this.props,
+          onEventDrop = _this$props.onEventDrop,
+          onEventResize = _this$props.onEventResize;
+        if (action === 'move' && onEventDrop) onEventDrop(interactionInfo);
+        if (action === 'resize' && onEventResize) onEventResize(interactionInfo);
+      };
+      _this.state = {
+        interacting: false
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(DragAndDropCalendar, _React$Component);
+    return (0, _createClass2.default)(DragAndDropCalendar, [{
+      key: "getDnDContextValue",
+      value: function getDnDContextValue() {
+        return {
+          draggable: {
+            onStart: this.handleInteractionStart,
+            onEnd: this.handleInteractionEnd,
+            onBeginAction: this.handleBeginAction,
+            onDropFromOutside: this.props.onDropFromOutside,
+            dragFromOutsideItem: this.props.dragFromOutsideItem,
+            draggableAccessor: this.props.draggableAccessor,
+            resizableAccessor: this.props.resizableAccessor,
+            dragAndDropAction: this.state
+          }
+        };
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props2 = this.props,
+          selectable = _this$props2.selectable,
+          elementProps = _this$props2.elementProps,
+          components = _this$props2.components,
+          props = (0, _objectWithoutProperties2.default)(_this$props2, _excluded);
+        var interacting = this.state.interacting;
+        delete props.onEventDrop;
+        delete props.onEventResize;
+        props.selectable = selectable ? 'ignoreEvents' : false;
+        this.components = (0, _common.mergeComponents)(components, {
+          eventWrapper: _EventWrapper.default,
+          eventContainerWrapper: _EventContainerWrapper.default,
+          weekWrapper: _WeekWrapper.default
+        });
+        var elementPropsWithDropFromOutside = this.props.onDropFromOutside ? (0, _objectSpread2.default)((0, _objectSpread2.default)({}, elementProps), {}, {
+          onDragOver: this.props.onDragOver || this.defaultOnDragOver
+        }) : elementProps;
+        props.className = (0, _clsx.default)(props.className, 'rbc-addons-dnd', !!interacting && 'rbc-addons-dnd-is-dragging');
+        var context = this.getDnDContextValue();
+        return /*#__PURE__*/_react.default.createElement(_DnDContext.DnDContext.Provider, {
+          value: context
+        }, /*#__PURE__*/_react.default.createElement(Calendar, Object.assign({}, props, {
+          elementProps: elementPropsWithDropFromOutside,
+          components: this.components
+        })));
+      }
+    }]);
+  }(_react.default.Component);
+  DragAndDropCalendar.defaultProps = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, Calendar.defaultProps), {}, {
+    draggableAccessor: null,
+    resizableAccessor: null,
+    resizable: true
+  });
+  return DragAndDropCalendar;
+}

node_modules/react-big-calendar/lib/css/react-big-calendar.css

@@ -0,0 +1,844 @@
+@charset "UTF-8";
+.rbc-btn {
+  color: inherit;
+  font: inherit;
+  margin: 0;
+}
+
+button.rbc-btn {
+  overflow: visible;
+  text-transform: none;
+  -webkit-appearance: button;
+     -moz-appearance: button;
+          appearance: button;
+  cursor: pointer;
+}
+
+button[disabled].rbc-btn {
+  cursor: not-allowed;
+}
+
+button.rbc-input::-moz-focus-inner {
+  border: 0;
+  padding: 0;
+}
+
+.rbc-calendar {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  height: 100%;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+}
+
+.rbc-m-b-negative-3 {
+  margin-bottom: -3px;
+}
+
+.rbc-h-full {
+  height: 100%;
+}
+
+.rbc-calendar *,
+.rbc-calendar *:before,
+.rbc-calendar *:after {
+  -webkit-box-sizing: inherit;
+          box-sizing: inherit;
+}
+
+.rbc-abs-full, .rbc-row-bg {
+  overflow: hidden;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+}
+
+.rbc-ellipsis, .rbc-show-more, .rbc-row-segment .rbc-event-content, .rbc-event-label {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.rbc-rtl {
+  direction: rtl;
+}
+
+.rbc-off-range {
+  color: #999999;
+}
+
+.rbc-off-range-bg {
+  background: #e6e6e6;
+}
+
+.rbc-header {
+  overflow: hidden;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0%;
+          flex: 1 0 0%;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  padding: 0 3px;
+  text-align: center;
+  vertical-align: middle;
+  font-weight: bold;
+  font-size: 90%;
+  min-height: 0;
+  border-bottom: 1px solid #ddd;
+}
+.rbc-header + .rbc-header {
+  border-left: 1px solid #ddd;
+}
+.rbc-rtl .rbc-header + .rbc-header {
+  border-left-width: 0;
+  border-right: 1px solid #ddd;
+}
+.rbc-header > a, .rbc-header > a:active, .rbc-header > a:visited {
+  color: inherit;
+  text-decoration: none;
+}
+
+.rbc-button-link {
+  color: inherit;
+  background: none;
+  margin: 0;
+  padding: 0;
+  border: none;
+  cursor: pointer;
+  -webkit-user-select: text;
+     -moz-user-select: text;
+      -ms-user-select: text;
+          user-select: text;
+}
+
+.rbc-row-content {
+  position: relative;
+  -moz-user-select: none;
+   -ms-user-select: none;
+       user-select: none;
+  -webkit-user-select: none;
+  z-index: 4;
+}
+
+.rbc-row-content-scrollable {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  height: 100%;
+}
+.rbc-row-content-scrollable .rbc-row-content-scroll-container {
+  height: 100%;
+  overflow-y: scroll;
+  -ms-overflow-style: none; /* IE and Edge */
+  scrollbar-width: none; /* Firefox */
+  -ms-overflow-style: none; /* IE and Edge */
+  scrollbar-width: none; /* Firefox */
+  /* Hide scrollbar for Chrome, Safari and Opera */
+}
+.rbc-row-content-scrollable .rbc-row-content-scroll-container::-webkit-scrollbar {
+  display: none;
+}
+
+.rbc-today {
+  background-color: #eaf6ff;
+}
+
+.rbc-toolbar {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -ms-flex-wrap: wrap;
+      flex-wrap: wrap;
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  margin-bottom: 10px;
+  font-size: 16px;
+}
+.rbc-toolbar .rbc-toolbar-label {
+  -webkit-box-flex: 1;
+      -ms-flex-positive: 1;
+          flex-grow: 1;
+  padding: 0 10px;
+  text-align: center;
+}
+.rbc-toolbar button {
+  color: #373a3c;
+  display: inline-block;
+  margin: 0;
+  text-align: center;
+  vertical-align: middle;
+  background: none;
+  background-image: none;
+  border: 1px solid #ccc;
+  padding: 0.375rem 1rem;
+  border-radius: 4px;
+  line-height: normal;
+  white-space: nowrap;
+}
+.rbc-toolbar button:active, .rbc-toolbar button.rbc-active {
+  background-image: none;
+  -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
+          box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
+  background-color: #e6e6e6;
+  border-color: #adadad;
+}
+.rbc-toolbar button:active:hover, .rbc-toolbar button:active:focus, .rbc-toolbar button.rbc-active:hover, .rbc-toolbar button.rbc-active:focus {
+  color: #373a3c;
+  background-color: #d4d4d4;
+  border-color: #8c8c8c;
+}
+.rbc-toolbar button:focus {
+  color: #373a3c;
+  background-color: #e6e6e6;
+  border-color: #adadad;
+}
+.rbc-toolbar button:hover {
+  color: #373a3c;
+  cursor: pointer;
+  background-color: #e6e6e6;
+  border-color: #adadad;
+}
+
+.rbc-btn-group {
+  display: inline-block;
+  white-space: nowrap;
+}
+.rbc-btn-group > button:first-child:not(:last-child) {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.rbc-btn-group > button:last-child:not(:first-child) {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+.rbc-rtl .rbc-btn-group > button:first-child:not(:last-child) {
+  border-radius: 4px;
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+.rbc-rtl .rbc-btn-group > button:last-child:not(:first-child) {
+  border-radius: 4px;
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.rbc-btn-group > button:not(:first-child):not(:last-child) {
+  border-radius: 0;
+}
+.rbc-btn-group button + button {
+  margin-left: -1px;
+}
+.rbc-rtl .rbc-btn-group button + button {
+  margin-left: 0;
+  margin-right: -1px;
+}
+.rbc-btn-group + .rbc-btn-group, .rbc-btn-group + button {
+  margin-left: 10px;
+}
+
+@media (max-width: 767px) {
+  .rbc-toolbar {
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+        -ms-flex-direction: column;
+            flex-direction: column;
+  }
+}
+.rbc-event, .rbc-day-slot .rbc-background-event {
+  border: none;
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  -webkit-box-shadow: none;
+          box-shadow: none;
+  margin: 0;
+  padding: 2px 5px;
+  background-color: #3174ad;
+  border-radius: 5px;
+  color: #fff;
+  cursor: pointer;
+  width: 100%;
+  text-align: left;
+}
+.rbc-slot-selecting .rbc-event, .rbc-slot-selecting .rbc-day-slot .rbc-background-event, .rbc-day-slot .rbc-slot-selecting .rbc-background-event {
+  cursor: inherit;
+  pointer-events: none;
+}
+.rbc-event.rbc-selected, .rbc-day-slot .rbc-selected.rbc-background-event {
+  background-color: #265985;
+}
+.rbc-event:focus, .rbc-day-slot .rbc-background-event:focus {
+  outline: 5px auto #3b99fc;
+}
+
+.rbc-event-label {
+  font-size: 80%;
+}
+
+.rbc-event-overlaps {
+  -webkit-box-shadow: -1px 1px 5px 0px rgba(51, 51, 51, 0.5);
+          box-shadow: -1px 1px 5px 0px rgba(51, 51, 51, 0.5);
+}
+
+.rbc-event-continues-prior {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+
+.rbc-event-continues-after {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+
+.rbc-event-continues-earlier {
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+
+.rbc-event-continues-later {
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+}
+
+.rbc-row {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: row;
+          flex-direction: row;
+}
+
+.rbc-row-segment {
+  padding: 0 1px 1px 1px;
+}
+.rbc-selected-cell {
+  background-color: rgba(0, 0, 0, 0.1);
+}
+
+.rbc-show-more {
+  background-color: rgba(255, 255, 255, 0.3);
+  z-index: 4;
+  font-weight: bold;
+  font-size: 85%;
+  height: auto;
+  line-height: normal;
+  color: #3174ad;
+}
+.rbc-show-more:hover, .rbc-show-more:focus {
+  color: #265985;
+}
+
+.rbc-month-view {
+  position: relative;
+  border: 1px solid #ddd;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0px;
+          flex: 1 0 0;
+  width: 100%;
+  -moz-user-select: none;
+   -ms-user-select: none;
+       user-select: none;
+  -webkit-user-select: none;
+  height: 100%;
+}
+
+.rbc-month-header {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: row;
+          flex-direction: row;
+}
+
+.rbc-month-row {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  position: relative;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0px;
+          flex: 1 0 0;
+  -ms-flex-preferred-size: 0px;
+      flex-basis: 0px;
+  overflow: hidden;
+  height: 100%;
+}
+.rbc-month-row + .rbc-month-row {
+  border-top: 1px solid #ddd;
+}
+
+.rbc-date-cell {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0;
+  min-width: 0;
+  padding-right: 5px;
+  text-align: right;
+}
+.rbc-date-cell.rbc-now {
+  font-weight: bold;
+}
+.rbc-date-cell > a, .rbc-date-cell > a:active, .rbc-date-cell > a:visited {
+  color: inherit;
+  text-decoration: none;
+}
+
+.rbc-row-bg {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: row;
+          flex-direction: row;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0px;
+          flex: 1 0 0;
+  overflow: hidden;
+  right: 1px;
+}
+
+.rbc-day-bg {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0%;
+          flex: 1 0 0%;
+}
+.rbc-day-bg + .rbc-day-bg {
+  border-left: 1px solid #ddd;
+}
+.rbc-rtl .rbc-day-bg + .rbc-day-bg {
+  border-left-width: 0;
+  border-right: 1px solid #ddd;
+}
+
+.rbc-overlay {
+  position: absolute;
+  z-index: 5;
+  border: 1px solid #e5e5e5;
+  background-color: #fff;
+  -webkit-box-shadow: 0 5px 15px rgba(0, 0, 0, 0.25);
+          box-shadow: 0 5px 15px rgba(0, 0, 0, 0.25);
+  padding: 10px;
+}
+.rbc-overlay > * + * {
+  margin-top: 1px;
+}
+
+.rbc-overlay-header {
+  border-bottom: 1px solid #e5e5e5;
+  margin: -10px -10px 5px -10px;
+  padding: 2px 10px;
+}
+
+.rbc-agenda-view {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0px;
+          flex: 1 0 0;
+  overflow: auto;
+}
+.rbc-agenda-view table.rbc-agenda-table {
+  width: 100%;
+  border: 1px solid #ddd;
+  border-spacing: 0;
+  border-collapse: collapse;
+}
+.rbc-agenda-view table.rbc-agenda-table tbody > tr > td {
+  padding: 5px 10px;
+  vertical-align: top;
+}
+.rbc-agenda-view table.rbc-agenda-table .rbc-agenda-time-cell {
+  padding-left: 15px;
+  padding-right: 15px;
+  text-transform: lowercase;
+}
+.rbc-agenda-view table.rbc-agenda-table tbody > tr > td + td {
+  border-left: 1px solid #ddd;
+}
+.rbc-rtl .rbc-agenda-view table.rbc-agenda-table tbody > tr > td + td {
+  border-left-width: 0;
+  border-right: 1px solid #ddd;
+}
+.rbc-agenda-view table.rbc-agenda-table tbody > tr + tr {
+  border-top: 1px solid #ddd;
+}
+.rbc-agenda-view table.rbc-agenda-table thead > tr > th {
+  padding: 3px 5px;
+  text-align: left;
+  border-bottom: 1px solid #ddd;
+}
+.rbc-rtl .rbc-agenda-view table.rbc-agenda-table thead > tr > th {
+  text-align: right;
+}
+
+.rbc-agenda-time-cell {
+  text-transform: lowercase;
+}
+.rbc-agenda-time-cell .rbc-continues-after:after {
+  content: " »";
+}
+.rbc-agenda-time-cell .rbc-continues-prior:before {
+  content: "« ";
+}
+
+.rbc-agenda-date-cell,
+.rbc-agenda-time-cell {
+  white-space: nowrap;
+}
+
+.rbc-agenda-event-cell {
+  width: 100%;
+}
+
+.rbc-time-column {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  min-height: 100%;
+}
+.rbc-time-column .rbc-timeslot-group {
+  -webkit-box-flex: 1;
+      -ms-flex: 1;
+          flex: 1;
+}
+
+.rbc-timeslot-group {
+  border-bottom: 1px solid #ddd;
+  min-height: 40px;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: column nowrap;
+          flex-flow: column nowrap;
+}
+
+.rbc-time-gutter,
+.rbc-header-gutter {
+  -webkit-box-flex: 0;
+      -ms-flex: none;
+          flex: none;
+}
+
+.rbc-label {
+  padding: 0 5px;
+}
+
+.rbc-day-slot {
+  position: relative;
+}
+.rbc-day-slot .rbc-events-container {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  margin-right: 10px;
+  top: 0;
+}
+.rbc-day-slot .rbc-events-container.rbc-rtl {
+  left: 10px;
+  right: 0;
+}
+.rbc-day-slot .rbc-event, .rbc-day-slot .rbc-background-event {
+  border: 1px solid #265985;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  max-height: 100%;
+  min-height: 20px;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-flow: column wrap;
+          flex-flow: column wrap;
+  -webkit-box-align: start;
+      -ms-flex-align: start;
+          align-items: flex-start;
+  overflow: hidden;
+  position: absolute;
+}
+.rbc-day-slot .rbc-background-event {
+  opacity: 0.75;
+}
+.rbc-day-slot .rbc-event-label {
+  -webkit-box-flex: 0;
+      -ms-flex: none;
+          flex: none;
+  padding-right: 5px;
+  width: auto;
+}
+.rbc-day-slot .rbc-event-content {
+  width: 100%;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0;
+  word-wrap: break-word;
+  line-height: 1;
+  height: 100%;
+  min-height: 1em;
+}
+.rbc-day-slot .rbc-time-slot {
+  border-top: 1px solid #f7f7f7;
+}
+
+.rbc-time-view-resources .rbc-time-gutter,
+.rbc-time-view-resources .rbc-time-header-gutter {
+  position: sticky;
+  left: 0;
+  background-color: white;
+  border-right: 1px solid #ddd;
+  z-index: 10;
+  margin-right: -1px;
+}
+.rbc-time-view-resources .rbc-time-header {
+  overflow: hidden;
+}
+.rbc-time-view-resources .rbc-time-header-content {
+  min-width: auto;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0px;
+          flex: 1 0 0;
+  -ms-flex-preferred-size: 0px;
+      flex-basis: 0px;
+}
+.rbc-time-view-resources .rbc-time-header-cell-single-day {
+  display: none;
+}
+.rbc-time-view-resources .rbc-day-slot {
+  min-width: 140px;
+}
+.rbc-time-view-resources .rbc-header,
+.rbc-time-view-resources .rbc-day-bg {
+  width: 140px;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 1 0px;
+          flex: 1 1 0;
+  -ms-flex-preferred-size: 0 px;
+      flex-basis: 0 px;
+}
+
+.rbc-time-header-content + .rbc-time-header-content {
+  margin-left: -1px;
+}
+
+.rbc-time-slot {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0px;
+          flex: 1 0 0;
+}
+.rbc-time-slot.rbc-now {
+  font-weight: bold;
+}
+
+.rbc-day-header {
+  text-align: center;
+}
+
+.rbc-slot-selection {
+  z-index: 10;
+  position: absolute;
+  background-color: rgba(0, 0, 0, 0.5);
+  color: white;
+  font-size: 75%;
+  width: 100%;
+  padding: 3px;
+}
+
+.rbc-slot-selecting {
+  cursor: move;
+}
+
+.rbc-time-view {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  -webkit-box-flex: 1;
+      -ms-flex: 1;
+          flex: 1;
+  width: 100%;
+  border: 1px solid #ddd;
+  min-height: 0;
+}
+.rbc-time-view .rbc-time-gutter {
+  white-space: nowrap;
+  text-align: right;
+}
+.rbc-time-view .rbc-allday-cell {
+  -webkit-box-sizing: content-box;
+          box-sizing: content-box;
+  width: 100%;
+  height: 100%;
+  position: relative;
+}
+.rbc-time-view .rbc-allday-cell + .rbc-allday-cell {
+  border-left: 1px solid #ddd;
+}
+.rbc-time-view .rbc-allday-events {
+  position: relative;
+  z-index: 4;
+}
+.rbc-time-view .rbc-row {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  min-height: 20px;
+}
+
+.rbc-time-header {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: row;
+          flex-direction: row;
+}
+.rbc-time-header.rbc-overflowing {
+  border-right: 1px solid #ddd;
+}
+.rbc-rtl .rbc-time-header.rbc-overflowing {
+  border-right-width: 0;
+  border-left: 1px solid #ddd;
+}
+.rbc-time-header > .rbc-row:first-child {
+  border-bottom: 1px solid #ddd;
+}
+.rbc-time-header > .rbc-row.rbc-row-resource {
+  border-bottom: 1px solid #ddd;
+}
+
+.rbc-time-header-cell-single-day {
+  display: none;
+}
+
+.rbc-time-header-content {
+  -webkit-box-flex: 1;
+      -ms-flex: 1;
+          flex: 1;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  min-width: 0;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  border-left: 1px solid #ddd;
+}
+.rbc-rtl .rbc-time-header-content {
+  border-left-width: 0;
+  border-right: 1px solid #ddd;
+}
+.rbc-time-header-content > .rbc-row.rbc-row-resource {
+  border-bottom: 1px solid #ddd;
+  -ms-flex-negative: 0;
+      flex-shrink: 0;
+}
+
+.rbc-time-content {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0 0%;
+          flex: 1 0 0%;
+  -webkit-box-align: start;
+      -ms-flex-align: start;
+          align-items: flex-start;
+  width: 100%;
+  border-top: 2px solid #ddd;
+  overflow-y: auto;
+  position: relative;
+}
+.rbc-time-content > .rbc-time-gutter {
+  -webkit-box-flex: 0;
+      -ms-flex: none;
+          flex: none;
+}
+.rbc-time-content > * + * > * {
+  border-left: 1px solid #ddd;
+}
+.rbc-rtl .rbc-time-content > * + * > * {
+  border-left-width: 0;
+  border-right: 1px solid #ddd;
+}
+.rbc-time-content > .rbc-day-slot {
+  width: 100%;
+  -moz-user-select: none;
+   -ms-user-select: none;
+       user-select: none;
+  -webkit-user-select: none;
+}
+
+.rbc-current-time-indicator {
+  position: absolute;
+  z-index: 3;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background-color: #74ad31;
+  pointer-events: none;
+}
+
+.rbc-resource-grouping.rbc-time-header-content {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+}
+.rbc-resource-grouping .rbc-row .rbc-header {
+  width: 141px;
+}
+
+/*# sourceMappingURL=react-big-calendar.css.map */

node_modules/react-big-calendar/lib/hooks/useClickOutside.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useClickOutside;
+var _react = require("react");
+function useClickOutside(_ref) {
+  var ref = _ref.ref,
+    callback = _ref.callback;
+  (0, _react.useEffect)(function () {
+    var handleClickOutside = function handleClickOutside(e) {
+      if (ref.current && !ref.current.contains(e.target)) {
+        callback();
+      }
+    };
+    document.addEventListener('mousedown', handleClickOutside);
+    return function () {
+      document.removeEventListener('mousedown', handleClickOutside);
+    };
+  }, [ref, callback]);
+}

node_modules/react-big-calendar/lib/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Calendar", {
+  enumerable: true,
+  get: function get() {
+    return _Calendar.default;
+  }
+});
+Object.defineProperty(exports, "DateLocalizer", {
+  enumerable: true,
+  get: function get() {
+    return _localizer.DateLocalizer;
+  }
+});
+Object.defineProperty(exports, "Navigate", {
+  enumerable: true,
+  get: function get() {
+    return _constants.navigate;
+  }
+});
+Object.defineProperty(exports, "Views", {
+  enumerable: true,
+  get: function get() {
+    return _constants.views;
+  }
+});
+exports.components = void 0;
+Object.defineProperty(exports, "dateFnsLocalizer", {
+  enumerable: true,
+  get: function get() {
+    return _dateFns.default;
+  }
+});
+Object.defineProperty(exports, "dayjsLocalizer", {
+  enumerable: true,
+  get: function get() {
+    return _dayjs.default;
+  }
+});
+Object.defineProperty(exports, "globalizeLocalizer", {
+  enumerable: true,
+  get: function get() {
+    return _globalize.default;
+  }
+});
+Object.defineProperty(exports, "luxonLocalizer", {
+  enumerable: true,
+  get: function get() {
+    return _luxon.default;
+  }
+});
+Object.defineProperty(exports, "momentLocalizer", {
+  enumerable: true,
+  get: function get() {
+    return _moment.default;
+  }
+});
+Object.defineProperty(exports, "move", {
+  enumerable: true,
+  get: function get() {
+    return _move.default;
+  }
+});
+var _EventWrapper = _interopRequireDefault(require("./EventWrapper"));
+var _BackgroundWrapper = _interopRequireDefault(require("./BackgroundWrapper"));
+var _Calendar = _interopRequireDefault(require("./Calendar"));
+var _localizer = require("./localizer");
+var _moment = _interopRequireDefault(require("./localizers/moment"));
+var _luxon = _interopRequireDefault(require("./localizers/luxon"));
+var _globalize = _interopRequireDefault(require("./localizers/globalize"));
+var _dateFns = _interopRequireDefault(require("./localizers/date-fns"));
+var _dayjs = _interopRequireDefault(require("./localizers/dayjs"));
+var _move = _interopRequireDefault(require("./utils/move"));
+var _constants = require("./utils/constants");
+var components = exports.components = {
+  eventWrapper: _EventWrapper.default,
+  timeSlotWrapper: _BackgroundWrapper.default,
+  dateCellWrapper: _BackgroundWrapper.default
+};

node_modules/react-big-calendar/lib/localizer.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateLocalizer = void 0;
+exports.mergeWithDefaults = mergeWithDefaults;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _invariant = _interopRequireDefault(require("invariant"));
+var _dates = require("./utils/dates");
+var localePropType = _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.func]);
+function _format(localizer, formatter, value, format, culture) {
+  var result = typeof format === 'function' ? format(value, culture, localizer) : formatter.call(localizer, value, format, culture);
+  (0, _invariant.default)(result == null || typeof result === 'string', '`localizer format(..)` must return a string, null, or undefined');
+  return result;
+}
+
+/**
+ * This date conversion was moved out of TimeSlots.js, to
+ * allow for localizer override
+ * @param {Date} dt - The date to start from
+ * @param {Number} minutesFromMidnight
+ * @param {Number} offset
+ * @returns {Date}
+ */
+function getSlotDate(dt, minutesFromMidnight, offset) {
+  return new Date(dt.getFullYear(), dt.getMonth(), dt.getDate(), 0, minutesFromMidnight + offset, 0, 0);
+}
+function getDstOffset(start, end) {
+  return start.getTimezoneOffset() - end.getTimezoneOffset();
+}
+
+// if the start is on a DST-changing day but *after* the moment of DST
+// transition we need to add those extra minutes to our minutesFromMidnight
+function getTotalMin(start, end) {
+  return (0, _dates.diff)(start, end, 'minutes') + getDstOffset(start, end);
+}
+function getMinutesFromMidnight(start) {
+  var daystart = (0, _dates.startOf)(start, 'day');
+  return (0, _dates.diff)(daystart, start, 'minutes') + getDstOffset(daystart, start);
+}
+
+// These two are used by DateSlotMetrics
+function continuesPrior(start, first) {
+  return (0, _dates.lt)(start, first, 'day');
+}
+function continuesAfter(start, end, last) {
+  var singleDayDuration = (0, _dates.eq)(start, end, 'minutes');
+  return singleDayDuration ? (0, _dates.gte)(end, last, 'minutes') : (0, _dates.gt)(end, last, 'minutes');
+}
+function daySpan(start, end) {
+  return (0, _dates.duration)(start, end, 'day');
+}
+
+// These two are used by eventLevels
+function sortEvents(_ref) {
+  var _ref$evtA = _ref.evtA,
+    aStart = _ref$evtA.start,
+    aEnd = _ref$evtA.end,
+    aAllDay = _ref$evtA.allDay,
+    _ref$evtB = _ref.evtB,
+    bStart = _ref$evtB.start,
+    bEnd = _ref$evtB.end,
+    bAllDay = _ref$evtB.allDay;
+  var startSort = +(0, _dates.startOf)(aStart, 'day') - +(0, _dates.startOf)(bStart, 'day');
+  var durA = daySpan(aStart, aEnd);
+  var durB = daySpan(bStart, bEnd);
+  return startSort ||
+  // sort by start Day first
+  durB - durA ||
+  // events spanning multiple days go first
+  !!bAllDay - !!aAllDay ||
+  // then allDay single day events
+  +aStart - +bStart ||
+  // then sort by start time
+  +aEnd - +bEnd // then sort by end time
+  ;
+}
+function inEventRange(_ref2) {
+  var _ref2$event = _ref2.event,
+    start = _ref2$event.start,
+    end = _ref2$event.end,
+    _ref2$range = _ref2.range,
+    rangeStart = _ref2$range.start,
+    rangeEnd = _ref2$range.end;
+  var eStart = (0, _dates.startOf)(start, 'day');
+  var startsBeforeEnd = (0, _dates.lte)(eStart, rangeEnd, 'day');
+  // when the event is zero duration we need to handle a bit differently
+  var sameMin = (0, _dates.neq)(eStart, end, 'minutes');
+  var endsAfterStart = sameMin ? (0, _dates.gt)(end, rangeStart, 'minutes') : (0, _dates.gte)(end, rangeStart, 'minutes');
+  return startsBeforeEnd && endsAfterStart;
+}
+
+// other localizers treats 'day' and 'date' equality very differently, so we
+// abstract the change the 'localizer.eq(date1, date2, 'day') into this
+// new method, where they can be treated correctly by the localizer overrides
+function isSameDate(date1, date2) {
+  return (0, _dates.eq)(date1, date2, 'day');
+}
+function startAndEndAreDateOnly(start, end) {
+  return (0, _dates.isJustDate)(start) && (0, _dates.isJustDate)(end);
+}
+var DateLocalizer = exports.DateLocalizer = /*#__PURE__*/(0, _createClass2.default)(function DateLocalizer(spec) {
+  var _this = this;
+  (0, _classCallCheck2.default)(this, DateLocalizer);
+  (0, _invariant.default)(typeof spec.format === 'function', 'date localizer `format(..)` must be a function');
+  (0, _invariant.default)(typeof spec.firstOfWeek === 'function', 'date localizer `firstOfWeek(..)` must be a function');
+  this.propType = spec.propType || localePropType;
+  this.formats = spec.formats;
+  this.format = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _format.apply(void 0, [_this, spec.format].concat(args));
+  };
+  // These date arithmetic methods can be overriden by the localizer
+  this.startOfWeek = spec.firstOfWeek;
+  this.merge = spec.merge || _dates.merge;
+  this.inRange = spec.inRange || _dates.inRange;
+  this.lt = spec.lt || _dates.lt;
+  this.lte = spec.lte || _dates.lte;
+  this.gt = spec.gt || _dates.gt;
+  this.gte = spec.gte || _dates.gte;
+  this.eq = spec.eq || _dates.eq;
+  this.neq = spec.neq || _dates.neq;
+  this.startOf = spec.startOf || _dates.startOf;
+  this.endOf = spec.endOf || _dates.endOf;
+  this.add = spec.add || _dates.add;
+  this.range = spec.range || _dates.range;
+  this.diff = spec.diff || _dates.diff;
+  this.ceil = spec.ceil || _dates.ceil;
+  this.min = spec.min || _dates.min;
+  this.max = spec.max || _dates.max;
+  this.minutes = spec.minutes || _dates.minutes;
+  this.daySpan = spec.daySpan || daySpan;
+  this.firstVisibleDay = spec.firstVisibleDay || _dates.firstVisibleDay;
+  this.lastVisibleDay = spec.lastVisibleDay || _dates.lastVisibleDay;
+  this.visibleDays = spec.visibleDays || _dates.visibleDays;
+  this.getSlotDate = spec.getSlotDate || getSlotDate;
+  this.getTimezoneOffset = spec.getTimezoneOffset || function (value) {
+    return value.getTimezoneOffset();
+  };
+  this.getDstOffset = spec.getDstOffset || getDstOffset;
+  this.getTotalMin = spec.getTotalMin || getTotalMin;
+  this.getMinutesFromMidnight = spec.getMinutesFromMidnight || getMinutesFromMidnight;
+  this.continuesPrior = spec.continuesPrior || continuesPrior;
+  this.continuesAfter = spec.continuesAfter || continuesAfter;
+  this.sortEvents = spec.sortEvents || sortEvents;
+  this.inEventRange = spec.inEventRange || inEventRange;
+  this.isSameDate = spec.isSameDate || isSameDate;
+  this.startAndEndAreDateOnly = spec.startAndEndAreDateOnly || startAndEndAreDateOnly;
+  this.segmentOffset = spec.browserTZOffset ? spec.browserTZOffset() : 0;
+});
+function mergeWithDefaults(localizer, culture, formatOverrides, messages) {
+  var formats = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, localizer.formats), formatOverrides);
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, localizer), {}, {
+    messages: messages,
+    startOfWeek: function startOfWeek() {
+      return localizer.startOfWeek(culture);
+    },
+    format: function format(value, _format2) {
+      return localizer.format(value, formats[_format2] || _format2, culture);
+    }
+  });
+}

node_modules/react-big-calendar/lib/localizers/date-fns.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formats = exports.default = void 0;
+var dates = _interopRequireWildcard(require("../utils/dates"));
+var _localizer = require("../localizer");
+var dateRangeFormat = function dateRangeFormat(_ref, culture, local) {
+  var start = _ref.start,
+    end = _ref.end;
+  return "".concat(local.format(start, 'P', culture), " \u2013 ").concat(local.format(end, 'P', culture));
+};
+var timeRangeFormat = function timeRangeFormat(_ref2, culture, local) {
+  var start = _ref2.start,
+    end = _ref2.end;
+  return "".concat(local.format(start, 'p', culture), " \u2013 ").concat(local.format(end, 'p', culture));
+};
+var timeRangeStartFormat = function timeRangeStartFormat(_ref3, culture, local) {
+  var start = _ref3.start;
+  return "".concat(local.format(start, 'h:mma', culture), " \u2013 ");
+};
+var timeRangeEndFormat = function timeRangeEndFormat(_ref4, culture, local) {
+  var end = _ref4.end;
+  return " \u2013 ".concat(local.format(end, 'h:mma', culture));
+};
+var weekRangeFormat = function weekRangeFormat(_ref5, culture, local) {
+  var start = _ref5.start,
+    end = _ref5.end;
+  return "".concat(local.format(start, 'MMMM dd', culture), " \u2013 ").concat(local.format(end, dates.eq(start, end, 'month') ? 'dd' : 'MMMM dd', culture));
+};
+var formats = exports.formats = {
+  dateFormat: 'dd',
+  dayFormat: 'dd eee',
+  weekdayFormat: 'ccc',
+  selectRangeFormat: timeRangeFormat,
+  eventTimeRangeFormat: timeRangeFormat,
+  eventTimeRangeStartFormat: timeRangeStartFormat,
+  eventTimeRangeEndFormat: timeRangeEndFormat,
+  timeGutterFormat: 'p',
+  monthHeaderFormat: 'MMMM yyyy',
+  dayHeaderFormat: 'cccc MMM dd',
+  dayRangeHeaderFormat: weekRangeFormat,
+  agendaHeaderFormat: dateRangeFormat,
+  agendaDateFormat: 'ccc MMM dd',
+  agendaTimeFormat: 'p',
+  agendaTimeRangeFormat: timeRangeFormat
+};
+var dateFnsLocalizer = function dateFnsLocalizer(_ref6) {
+  var startOfWeek = _ref6.startOfWeek,
+    getDay = _ref6.getDay,
+    _format = _ref6.format,
+    locales = _ref6.locales;
+  return new _localizer.DateLocalizer({
+    formats: formats,
+    firstOfWeek: function firstOfWeek(culture) {
+      return getDay(startOfWeek(new Date(), {
+        locale: locales[culture]
+      }));
+    },
+    format: function format(value, formatString, culture) {
+      return _format(new Date(value), formatString, {
+        locale: locales[culture]
+      });
+    }
+  });
+};
+var _default = exports.default = dateFnsLocalizer;

node_modules/react-big-calendar/lib/localizers/dayjs.js

@@ -0,0 +1,426 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.formats = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _localizer = require("../localizer");
+var _isBetween = _interopRequireDefault(require("dayjs/plugin/isBetween"));
+var _isSameOrAfter = _interopRequireDefault(require("dayjs/plugin/isSameOrAfter"));
+var _isSameOrBefore = _interopRequireDefault(require("dayjs/plugin/isSameOrBefore"));
+var _localeData = _interopRequireDefault(require("dayjs/plugin/localeData"));
+var _localizedFormat = _interopRequireDefault(require("dayjs/plugin/localizedFormat"));
+var _minMax = _interopRequireDefault(require("dayjs/plugin/minMax"));
+var _utc = _interopRequireDefault(require("dayjs/plugin/utc"));
+var _isLeapYear = _interopRequireDefault(require("dayjs/plugin/isLeapYear"));
+// import dayjs plugins
+// Note that the timezone plugin is not imported here
+// this plugin can be optionally loaded by the user
+
+var weekRangeFormat = function weekRangeFormat(_ref, culture, local) {
+  var start = _ref.start,
+    end = _ref.end;
+  return local.format(start, 'MMMM DD', culture) + ' – ' +
+  // updated to use this localizer 'eq()' method
+  local.format(end, local.eq(start, end, 'month') ? 'DD' : 'MMMM DD', culture);
+};
+var dateRangeFormat = function dateRangeFormat(_ref2, culture, local) {
+  var start = _ref2.start,
+    end = _ref2.end;
+  return local.format(start, 'L', culture) + ' – ' + local.format(end, 'L', culture);
+};
+var timeRangeFormat = function timeRangeFormat(_ref3, culture, local) {
+  var start = _ref3.start,
+    end = _ref3.end;
+  return local.format(start, 'LT', culture) + ' – ' + local.format(end, 'LT', culture);
+};
+var timeRangeStartFormat = function timeRangeStartFormat(_ref4, culture, local) {
+  var start = _ref4.start;
+  return local.format(start, 'LT', culture) + ' – ';
+};
+var timeRangeEndFormat = function timeRangeEndFormat(_ref5, culture, local) {
+  var end = _ref5.end;
+  return ' – ' + local.format(end, 'LT', culture);
+};
+var formats = exports.formats = {
+  dateFormat: 'DD',
+  dayFormat: 'DD ddd',
+  weekdayFormat: 'ddd',
+  selectRangeFormat: timeRangeFormat,
+  eventTimeRangeFormat: timeRangeFormat,
+  eventTimeRangeStartFormat: timeRangeStartFormat,
+  eventTimeRangeEndFormat: timeRangeEndFormat,
+  timeGutterFormat: 'LT',
+  monthHeaderFormat: 'MMMM YYYY',
+  dayHeaderFormat: 'dddd MMM DD',
+  dayRangeHeaderFormat: weekRangeFormat,
+  agendaHeaderFormat: dateRangeFormat,
+  agendaDateFormat: 'ddd MMM DD',
+  agendaTimeFormat: 'LT',
+  agendaTimeRangeFormat: timeRangeFormat
+};
+function fixUnit(unit) {
+  var datePart = unit ? unit.toLowerCase() : unit;
+  if (datePart === 'FullYear') {
+    datePart = 'year';
+  } else if (!datePart) {
+    datePart = undefined;
+  }
+  return datePart;
+}
+function _default(dayjsLib) {
+  // load dayjs plugins
+  dayjsLib.extend(_isBetween.default);
+  dayjsLib.extend(_isSameOrAfter.default);
+  dayjsLib.extend(_isSameOrBefore.default);
+  dayjsLib.extend(_localeData.default);
+  dayjsLib.extend(_localizedFormat.default);
+  dayjsLib.extend(_minMax.default);
+  dayjsLib.extend(_utc.default);
+  dayjsLib.extend(_isLeapYear.default);
+  var locale = function locale(dj, c) {
+    return c ? dj.locale(c) : dj;
+  };
+
+  // if the timezone plugin is loaded,
+  // then use the timezone aware version
+  var dayjs = dayjsLib.tz ? dayjsLib.tz : dayjsLib;
+  function getTimezoneOffset(date) {
+    // ensures this gets cast to timezone
+    return dayjs(date).toDate().getTimezoneOffset();
+  }
+  function getDstOffset(start, end) {
+    var _st$tz$$x$$timezone;
+    // convert to dayjs, in case
+    var st = dayjs(start);
+    var ed = dayjs(end);
+    // if not using the dayjs timezone plugin
+    if (!dayjs.tz) {
+      return st.toDate().getTimezoneOffset() - ed.toDate().getTimezoneOffset();
+    }
+    /**
+     * If a default timezone has been applied, then
+     * use this to get the proper timezone offset, otherwise default
+     * the timezone to the browser local
+     */
+    var tzName = (_st$tz$$x$$timezone = st.tz().$x.$timezone) !== null && _st$tz$$x$$timezone !== void 0 ? _st$tz$$x$$timezone : dayjsLib.tz.guess();
+    // invert offsets to be inline with moment.js
+    var startOffset = -dayjs.tz(+st, tzName).utcOffset();
+    var endOffset = -dayjs.tz(+ed, tzName).utcOffset();
+    return startOffset - endOffset;
+  }
+  function getDayStartDstOffset(start) {
+    var dayStart = dayjs(start).startOf('day');
+    return getDstOffset(dayStart, start);
+  }
+
+  /*** BEGIN localized date arithmetic methods with dayjs ***/
+  function defineComparators(a, b, unit) {
+    var datePart = fixUnit(unit);
+    var dtA = datePart ? dayjs(a).startOf(datePart) : dayjs(a);
+    var dtB = datePart ? dayjs(b).startOf(datePart) : dayjs(b);
+    return [dtA, dtB, datePart];
+  }
+  function startOf() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    var datePart = fixUnit(unit);
+    if (datePart) {
+      return dayjs(date).startOf(datePart).toDate();
+    }
+    return dayjs(date).toDate();
+  }
+  function endOf() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    var datePart = fixUnit(unit);
+    if (datePart) {
+      return dayjs(date).endOf(datePart).toDate();
+    }
+    return dayjs(date).toDate();
+  }
+
+  // dayjs comparison operations *always* convert both sides to dayjs objects
+  // prior to running the comparisons
+  function eq(a, b, unit) {
+    var _defineComparators = defineComparators(a, b, unit),
+      _defineComparators2 = (0, _slicedToArray2.default)(_defineComparators, 3),
+      dtA = _defineComparators2[0],
+      dtB = _defineComparators2[1],
+      datePart = _defineComparators2[2];
+    return dtA.isSame(dtB, datePart);
+  }
+  function neq(a, b, unit) {
+    return !eq(a, b, unit);
+  }
+  function gt(a, b, unit) {
+    var _defineComparators3 = defineComparators(a, b, unit),
+      _defineComparators4 = (0, _slicedToArray2.default)(_defineComparators3, 3),
+      dtA = _defineComparators4[0],
+      dtB = _defineComparators4[1],
+      datePart = _defineComparators4[2];
+    return dtA.isAfter(dtB, datePart);
+  }
+  function lt(a, b, unit) {
+    var _defineComparators5 = defineComparators(a, b, unit),
+      _defineComparators6 = (0, _slicedToArray2.default)(_defineComparators5, 3),
+      dtA = _defineComparators6[0],
+      dtB = _defineComparators6[1],
+      datePart = _defineComparators6[2];
+    return dtA.isBefore(dtB, datePart);
+  }
+  function gte(a, b, unit) {
+    var _defineComparators7 = defineComparators(a, b, unit),
+      _defineComparators8 = (0, _slicedToArray2.default)(_defineComparators7, 3),
+      dtA = _defineComparators8[0],
+      dtB = _defineComparators8[1],
+      datePart = _defineComparators8[2];
+    return dtA.isSameOrBefore(dtB, datePart);
+  }
+  function lte(a, b, unit) {
+    var _defineComparators9 = defineComparators(a, b, unit),
+      _defineComparators10 = (0, _slicedToArray2.default)(_defineComparators9, 3),
+      dtA = _defineComparators10[0],
+      dtB = _defineComparators10[1],
+      datePart = _defineComparators10[2];
+    return dtA.isSameOrBefore(dtB, datePart);
+  }
+  function inRange(day, min, max) {
+    var unit = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'day';
+    var datePart = fixUnit(unit);
+    var djDay = dayjs(day);
+    var djMin = dayjs(min);
+    var djMax = dayjs(max);
+    return djDay.isBetween(djMin, djMax, datePart, '[]');
+  }
+  function min(dateA, dateB) {
+    var dtA = dayjs(dateA);
+    var dtB = dayjs(dateB);
+    var minDt = dayjsLib.min(dtA, dtB);
+    return minDt.toDate();
+  }
+  function max(dateA, dateB) {
+    var dtA = dayjs(dateA);
+    var dtB = dayjs(dateB);
+    var maxDt = dayjsLib.max(dtA, dtB);
+    return maxDt.toDate();
+  }
+  function merge(date, time) {
+    if (!date && !time) return null;
+    var tm = dayjs(time).format('HH:mm:ss');
+    var dt = dayjs(date).startOf('day').format('MM/DD/YYYY');
+    // We do it this way to avoid issues when timezone switching
+    var mergedDateTime = dayjs("".concat(dt, " ").concat(tm)).toDate();
+    return dayjsLib(mergedDateTime).utc(true).toDate();
+  }
+  function add(date, adder, unit) {
+    var datePart = fixUnit(unit);
+    return dayjs(date).add(adder, datePart).toDate();
+  }
+  function range(start, end) {
+    var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+    var datePart = fixUnit(unit);
+    // because the add method will put these in tz, we have to start that way
+    var current = dayjs(start).toDate();
+    var days = [];
+    while (lte(current, end)) {
+      days.push(current);
+      current = add(current, 1, datePart);
+    }
+    return days;
+  }
+  function ceil(date, unit) {
+    var datePart = fixUnit(unit);
+    var floor = startOf(date, datePart);
+    return eq(floor, date) ? floor : add(floor, 1, datePart);
+  }
+  function diff(a, b) {
+    var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+    var datePart = fixUnit(unit);
+    // don't use 'defineComparators' here, as we don't want to mutate the values
+    var dtA = dayjs(a);
+    var dtB = dayjs(b);
+    return dtB.diff(dtA, datePart);
+  }
+  function minutes(date) {
+    var dt = dayjs(date);
+    return dt.minutes();
+  }
+  function firstOfWeek(culture) {
+    var data = culture ? dayjsLib.localeData(culture) : dayjsLib.localeData();
+    return data ? data.firstDayOfWeek() : 0;
+  }
+  function firstVisibleDay(date) {
+    var firstDayOfMonth = dayjs(date).startOf('month');
+    var firstDayOfWeek = dayjs(firstDayOfMonth).startOf('week');
+    // special handling for leapyears until Dayjs patches it
+    if (dayjs(firstDayOfMonth).isLeapYear()) {
+      var day = firstDayOfMonth.toDate().getDay(),
+        _diff = firstDayOfMonth.toDate().getDate() - day + (day == 0 ? -6 : 1);
+      firstDayOfWeek.date(_diff);
+    }
+    return firstDayOfWeek.toDate();
+  }
+  function lastVisibleDay(date) {
+    return dayjs(date).endOf('month').endOf('week').toDate();
+  }
+  function visibleDays(date) {
+    var current = firstVisibleDay(date);
+    var last = lastVisibleDay(date);
+    var days = [];
+    while (lte(current, last)) {
+      days.push(current);
+      current = add(current, 1, 'd');
+    }
+    return days;
+  }
+  /*** END localized date arithmetic methods with dayjs ***/
+
+  /**
+   * Moved from TimeSlots.js, this method overrides the method of the same name
+   * in the localizer.js, using dayjs to construct the js Date
+   * @param {Date} dt - date to start with
+   * @param {Number} minutesFromMidnight
+   * @param {Number} offset
+   * @returns {Date}
+   */
+  function getSlotDate(dt, minutesFromMidnight, offset) {
+    return dayjs(dt).startOf('day').minute(minutesFromMidnight + offset).toDate();
+  }
+
+  // dayjs will automatically handle DST differences in it's calculations
+  function getTotalMin(start, end) {
+    return diff(start, end, 'minutes');
+  }
+  function getMinutesFromMidnight(start) {
+    var dayStart = dayjs(start).startOf('day');
+    var day = dayjs(start);
+    return day.diff(dayStart, 'minutes') + getDayStartDstOffset(start);
+  }
+
+  // These two are used by DateSlotMetrics
+  function continuesPrior(start, first) {
+    var djStart = dayjs(start);
+    var djFirst = dayjs(first);
+    return djStart.isBefore(djFirst, 'day');
+  }
+  function continuesAfter(start, end, last) {
+    var djEnd = dayjs(end);
+    var djLast = dayjs(last);
+    return djEnd.isSameOrAfter(djLast, 'minutes');
+  }
+  function daySpan(start, end) {
+    var startDay = dayjs(start);
+    var endDay = dayjs(end);
+    return endDay.diff(startDay, 'day');
+  }
+
+  // These two are used by eventLevels
+  function sortEvents(_ref6) {
+    var _ref6$evtA = _ref6.evtA,
+      aStart = _ref6$evtA.start,
+      aEnd = _ref6$evtA.end,
+      aAllDay = _ref6$evtA.allDay,
+      _ref6$evtB = _ref6.evtB,
+      bStart = _ref6$evtB.start,
+      bEnd = _ref6$evtB.end,
+      bAllDay = _ref6$evtB.allDay;
+    var startSort = +startOf(aStart, 'day') - +startOf(bStart, 'day');
+    var durA = daySpan(aStart, aEnd);
+    var durB = daySpan(bStart, bEnd);
+    return startSort ||
+    // sort by start Day first
+    durB - durA ||
+    // events spanning multiple days go first
+    !!bAllDay - !!aAllDay ||
+    // then allDay single day events
+    +aStart - +bStart ||
+    // then sort by start time *don't need dayjs conversion here
+    +aEnd - +bEnd // then sort by end time *don't need dayjs conversion here either
+    ;
+  }
+  function inEventRange(_ref7) {
+    var _ref7$event = _ref7.event,
+      start = _ref7$event.start,
+      end = _ref7$event.end,
+      _ref7$range = _ref7.range,
+      rangeStart = _ref7$range.start,
+      rangeEnd = _ref7$range.end;
+    var startOfDay = dayjs(start).startOf('day');
+    var eEnd = dayjs(end);
+    var rStart = dayjs(rangeStart);
+    var rEnd = dayjs(rangeEnd);
+    var startsBeforeEnd = startOfDay.isSameOrBefore(rEnd, 'day');
+    // when the event is zero duration we need to handle a bit differently
+    var sameMin = !startOfDay.isSame(eEnd, 'minutes');
+    var endsAfterStart = sameMin ? eEnd.isAfter(rStart, 'minutes') : eEnd.isSameOrAfter(rStart, 'minutes');
+    return startsBeforeEnd && endsAfterStart;
+  }
+  function isSameDate(date1, date2) {
+    var dt = dayjs(date1);
+    var dt2 = dayjs(date2);
+    return dt.isSame(dt2, 'day');
+  }
+
+  /**
+   * This method, called once in the localizer constructor, is used by eventLevels
+   * 'eventSegments()' to assist in determining the 'span' of the event in the display,
+   * specifically when using a timezone that is greater than the browser native timezone.
+   * @returns number
+   */
+  function browserTZOffset() {
+    /**
+     * Date.prototype.getTimezoneOffset horrifically flips the positive/negative from
+     * what you see in it's string, so we have to jump through some hoops to get a value
+     * we can actually compare.
+     */
+    var dt = new Date();
+    var neg = /-/.test(dt.toString()) ? '-' : '';
+    var dtOffset = dt.getTimezoneOffset();
+    var comparator = Number("".concat(neg).concat(Math.abs(dtOffset)));
+    // dayjs correctly provides positive/negative offset, as expected
+    var mtOffset = dayjs().utcOffset();
+    return mtOffset > comparator ? 1 : 0;
+  }
+  return new _localizer.DateLocalizer({
+    formats: formats,
+    firstOfWeek: firstOfWeek,
+    firstVisibleDay: firstVisibleDay,
+    lastVisibleDay: lastVisibleDay,
+    visibleDays: visibleDays,
+    format: function format(value, _format, culture) {
+      return locale(dayjs(value), culture).format(_format);
+    },
+    lt: lt,
+    lte: lte,
+    gt: gt,
+    gte: gte,
+    eq: eq,
+    neq: neq,
+    merge: merge,
+    inRange: inRange,
+    startOf: startOf,
+    endOf: endOf,
+    range: range,
+    add: add,
+    diff: diff,
+    ceil: ceil,
+    min: min,
+    max: max,
+    minutes: minutes,
+    getSlotDate: getSlotDate,
+    getTimezoneOffset: getTimezoneOffset,
+    getDstOffset: getDstOffset,
+    getTotalMin: getTotalMin,
+    getMinutesFromMidnight: getMinutesFromMidnight,
+    continuesPrior: continuesPrior,
+    continuesAfter: continuesAfter,
+    sortEvents: sortEvents,
+    inEventRange: inEventRange,
+    isSameDate: isSameDate,
+    browserTZOffset: browserTZOffset
+  });
+}

node_modules/react-big-calendar/lib/localizers/globalize.js

@@ -0,0 +1,112 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.formats = void 0;
+var dates = _interopRequireWildcard(require("../utils/dates"));
+var _oldGlobalize = _interopRequireDefault(require("./oldGlobalize"));
+var _localizer = require("../localizer");
+// TODO: fix the globalizeLocalizer to work with globalize 1.x
+
+var dateRangeFormat = function dateRangeFormat(_ref, culture, local) {
+  var start = _ref.start,
+    end = _ref.end;
+  return local.format(start, {
+    date: 'short'
+  }, culture) + ' – ' + local.format(end, {
+    date: 'short'
+  }, culture);
+};
+var timeRangeFormat = function timeRangeFormat(_ref2, culture, local) {
+  var start = _ref2.start,
+    end = _ref2.end;
+  return local.format(start, {
+    time: 'short'
+  }, culture) + ' – ' + local.format(end, {
+    time: 'short'
+  }, culture);
+};
+var timeRangeStartFormat = function timeRangeStartFormat(_ref3, culture, local) {
+  var start = _ref3.start;
+  return local.format(start, {
+    time: 'short'
+  }, culture) + ' – ';
+};
+var timeRangeEndFormat = function timeRangeEndFormat(_ref4, culture, local) {
+  var end = _ref4.end;
+  return ' – ' + local.format(end, {
+    time: 'short'
+  }, culture);
+};
+var weekRangeFormat = function weekRangeFormat(_ref5, culture, local) {
+  var start = _ref5.start,
+    end = _ref5.end;
+  return local.format(start, 'MMM dd', culture) + ' – ' + local.format(end, dates.eq(start, end, 'month') ? 'dd' : 'MMM dd', culture);
+};
+var formats = exports.formats = {
+  dateFormat: 'dd',
+  dayFormat: 'eee dd/MM',
+  weekdayFormat: 'eee',
+  selectRangeFormat: timeRangeFormat,
+  eventTimeRangeFormat: timeRangeFormat,
+  eventTimeRangeStartFormat: timeRangeStartFormat,
+  eventTimeRangeEndFormat: timeRangeEndFormat,
+  timeGutterFormat: {
+    time: 'short'
+  },
+  monthHeaderFormat: 'MMMM yyyy',
+  dayHeaderFormat: 'eeee MMM dd',
+  dayRangeHeaderFormat: weekRangeFormat,
+  agendaHeaderFormat: dateRangeFormat,
+  agendaDateFormat: 'eee MMM dd',
+  agendaTimeFormat: {
+    time: 'short'
+  },
+  agendaTimeRangeFormat: timeRangeFormat
+};
+function _default(globalize) {
+  var locale = function locale(culture) {
+    return culture ? globalize(culture) : globalize;
+  };
+
+  // return the first day of the week from the locale data. Defaults to 'world'
+  // territory if no territory is derivable from CLDR.
+  // Failing to use CLDR supplemental (not loaded?), revert to the original
+  // method of getting first day of week.
+  function firstOfWeek(culture) {
+    try {
+      var days = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+      var cldr = locale(culture).cldr;
+      var territory = cldr.attributes.territory;
+      var weekData = cldr.get('supplemental').weekData;
+      var firstDay = weekData.firstDay[territory || '001'];
+      return days.indexOf(firstDay);
+    } catch (e) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.error('Failed to accurately determine first day of the week.' + ' Is supplemental data loaded into CLDR?');
+      }
+      // maybe cldr supplemental is not loaded? revert to original method
+      var date = new Date();
+      //cldr-data doesn't seem to be zero based
+      var localeDay = Math.max(parseInt(locale(culture).formatDate(date, {
+        raw: 'e'
+      }), 10) - 1, 0);
+      return Math.abs(date.getDay() - localeDay);
+    }
+  }
+  if (!globalize.load) return (0, _oldGlobalize.default)(globalize);
+  return new _localizer.DateLocalizer({
+    firstOfWeek: firstOfWeek,
+    formats: formats,
+    format: function format(value, _format, culture) {
+      _format = typeof _format === 'string' ? {
+        raw: _format
+      } : _format;
+      return locale(culture).formatDate(value, _format);
+    }
+  });
+}

node_modules/react-big-calendar/lib/localizers/luxon.js

@@ -0,0 +1,424 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.formats = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _localizer = require("../localizer");
+function pluralizeUnit(unit) {
+  return /s$/.test(unit) ? unit : unit + 's';
+}
+var weekRangeFormat = function weekRangeFormat(_ref, culture, local) {
+  var start = _ref.start,
+    end = _ref.end;
+  return local.format(start, 'MMMM dd', culture) + ' – ' +
+  // updated to use this localizer 'eq()' method
+  local.format(end, local.eq(start, end, 'month') ? 'dd' : 'MMMM dd', culture);
+};
+var dateRangeFormat = function dateRangeFormat(_ref2, culture, local) {
+  var start = _ref2.start,
+    end = _ref2.end;
+  return local.format(start, 'D', culture) + ' – ' + local.format(end, 'D', culture);
+};
+var timeRangeFormat = function timeRangeFormat(_ref3, culture, local) {
+  var start = _ref3.start,
+    end = _ref3.end;
+  return local.format(start, 't', culture) + ' – ' + local.format(end, 't', culture);
+};
+var timeRangeStartFormat = function timeRangeStartFormat(_ref4, culture, local) {
+  var start = _ref4.start;
+  return local.format(start, 't', culture) + ' – ';
+};
+var timeRangeEndFormat = function timeRangeEndFormat(_ref5, culture, local) {
+  var end = _ref5.end;
+  return ' – ' + local.format(end, 't', culture);
+};
+var formats = exports.formats = {
+  dateFormat: 'dd',
+  dayFormat: 'dd EEE',
+  weekdayFormat: 'EEE',
+  selectRangeFormat: timeRangeFormat,
+  eventTimeRangeFormat: timeRangeFormat,
+  eventTimeRangeStartFormat: timeRangeStartFormat,
+  eventTimeRangeEndFormat: timeRangeEndFormat,
+  timeGutterFormat: 't',
+  monthHeaderFormat: 'MMMM yyyy',
+  dayHeaderFormat: 'EEEE MMM dd',
+  dayRangeHeaderFormat: weekRangeFormat,
+  agendaHeaderFormat: dateRangeFormat,
+  agendaDateFormat: 'EEE MMM dd',
+  agendaTimeFormat: 't',
+  agendaTimeRangeFormat: timeRangeFormat
+};
+function fixUnit(unit) {
+  var datePart = unit ? pluralizeUnit(unit.toLowerCase()) : unit;
+  if (datePart === 'FullYear') {
+    datePart = 'year';
+  } else if (!datePart) {
+    datePart = undefined;
+  }
+  return datePart;
+}
+
+// Luxon does not currently have weekInfo by culture
+// Luxon uses 1 based values for month and weekday
+// So we default to Sunday (7)
+function _default(DateTime) {
+  var _ref6 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref6$firstDayOfWeek = _ref6.firstDayOfWeek,
+    firstDayOfWeek = _ref6$firstDayOfWeek === void 0 ? 7 : _ref6$firstDayOfWeek;
+  function formatDate(value, format) {
+    return DateTime.fromJSDate(value).toFormat(format);
+  }
+  function formatDateWithCulture(value, culture, format) {
+    return DateTime.fromJSDate(value).setLocale(culture).toFormat(format);
+  }
+
+  /*** BEGIN localized date arithmetic methods with Luxon ***/
+  function defineComparators(a, b, unit) {
+    var datePart = fixUnit(unit);
+    var dtA = datePart ? DateTime.fromJSDate(a).startOf(datePart) : DateTime.fromJSDate(a);
+    var dtB = datePart ? DateTime.fromJSDate(b).startOf(datePart) : DateTime.fromJSDate(b);
+    return [dtA, dtB, datePart];
+  }
+
+  // Since Luxon (and current Intl API) has no support
+  // for culture based weekInfo, we need to handle
+  // the start of the week differently
+  // depending on locale, the firstDayOfWeek could also be Saturday, Sunday or Monday
+  function startOfDTWeek(dtObj) {
+    var weekday = dtObj.weekday;
+    if (weekday === firstDayOfWeek) {
+      return dtObj.startOf('day'); // already beginning of week
+    } else if (firstDayOfWeek === 1) {
+      return dtObj.startOf('week'); // fow is Monday, which is Luxon default
+    }
+    var diff = firstDayOfWeek === 7 ? weekday : weekday + (7 - firstDayOfWeek);
+    return dtObj.minus({
+      day: diff
+    }).startOf('day');
+  }
+  function endOfDTWeek(dtObj) {
+    var weekday = dtObj.weekday;
+    var eow = firstDayOfWeek === 1 ? 7 : firstDayOfWeek - 1;
+    if (weekday === eow) {
+      return dtObj.endOf('day'); // already last day of the week
+    } else if (firstDayOfWeek === 1) {
+      return dtObj.endOf('week'); // use Luxon default (Sunday)
+    }
+    var fromDate = firstDayOfWeek > eow ? dtObj.plus({
+      day: firstDayOfWeek - eow
+    }) : dtObj;
+    return fromDate.set({
+      weekday: eow
+    }).endOf('day');
+  }
+
+  // This returns a DateTime instance
+  function startOfDT() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    var datePart = fixUnit(unit);
+    if (datePart) {
+      var dt = DateTime.fromJSDate(date);
+      return datePart.includes('week') ? startOfDTWeek(dt) : dt.startOf(datePart);
+    }
+    return DateTime.fromJSDate(date);
+  }
+  function firstOfWeek() {
+    return firstDayOfWeek;
+  }
+
+  // This returns a JS Date from a DateTime instance
+  function startOf() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    return startOfDT(date, unit).toJSDate();
+  }
+
+  // This returns a DateTime instance
+  function endOfDT() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    var datePart = fixUnit(unit);
+    if (datePart) {
+      var dt = DateTime.fromJSDate(date);
+      return datePart.includes('week') ? endOfDTWeek(dt) : dt.endOf(datePart);
+    }
+    return DateTime.fromJSDate(date);
+  }
+  function endOf() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    return endOfDT(date, unit).toJSDate();
+  }
+  function eq(a, b, unit) {
+    var _defineComparators = defineComparators(a, b, unit),
+      _defineComparators2 = (0, _slicedToArray2.default)(_defineComparators, 2),
+      dtA = _defineComparators2[0],
+      dtB = _defineComparators2[1];
+    return +dtA == +dtB;
+  }
+  function neq(a, b, unit) {
+    return !eq(a, b, unit);
+  }
+  function gt(a, b, unit) {
+    var _defineComparators3 = defineComparators(a, b, unit),
+      _defineComparators4 = (0, _slicedToArray2.default)(_defineComparators3, 2),
+      dtA = _defineComparators4[0],
+      dtB = _defineComparators4[1];
+    return +dtA > +dtB;
+  }
+  function lt(a, b, unit) {
+    var _defineComparators5 = defineComparators(a, b, unit),
+      _defineComparators6 = (0, _slicedToArray2.default)(_defineComparators5, 2),
+      dtA = _defineComparators6[0],
+      dtB = _defineComparators6[1];
+    return +dtA < +dtB;
+  }
+  function gte(a, b, unit) {
+    var _defineComparators7 = defineComparators(a, b, unit),
+      _defineComparators8 = (0, _slicedToArray2.default)(_defineComparators7, 2),
+      dtA = _defineComparators8[0],
+      dtB = _defineComparators8[1];
+    return +dtA >= +dtB;
+  }
+  function lte(a, b, unit) {
+    var _defineComparators9 = defineComparators(a, b, unit),
+      _defineComparators10 = (0, _slicedToArray2.default)(_defineComparators9, 2),
+      dtA = _defineComparators10[0],
+      dtB = _defineComparators10[1];
+    return +dtA <= +dtB;
+  }
+  function inRange(day, min, max) {
+    var unit = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'day';
+    var datePart = fixUnit(unit);
+    var mDay = startOfDT(day, datePart);
+    var mMin = startOfDT(min, datePart);
+    var mMax = startOfDT(max, datePart);
+    return +mDay >= +mMin && +mDay <= +mMax;
+  }
+  function min(dateA, dateB) {
+    var dtA = DateTime.fromJSDate(dateA);
+    var dtB = DateTime.fromJSDate(dateB);
+    var minDt = DateTime.min(dtA, dtB);
+    return minDt.toJSDate();
+  }
+  function max(dateA, dateB) {
+    var dtA = DateTime.fromJSDate(dateA);
+    var dtB = DateTime.fromJSDate(dateB);
+    var maxDt = DateTime.max(dtA, dtB);
+    return maxDt.toJSDate();
+  }
+  function merge(date, time) {
+    if (!date && !time) return null;
+    var tm = DateTime.fromJSDate(time);
+    var dt = startOfDT(date, 'day');
+    return dt.set({
+      hour: tm.hour,
+      minute: tm.minute,
+      second: tm.second,
+      millisecond: tm.millisecond
+    }).toJSDate();
+  }
+  function add(date, adder, unit) {
+    var datePart = fixUnit(unit);
+    return DateTime.fromJSDate(date).plus((0, _defineProperty2.default)({}, datePart, adder)).toJSDate();
+  }
+  function range(start, end) {
+    var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+    var datePart = fixUnit(unit);
+    var current = DateTime.fromJSDate(start).toJSDate(); // this is to get it to tz
+    var days = [];
+    while (lte(current, end)) {
+      days.push(current);
+      current = add(current, 1, datePart);
+    }
+    return days;
+  }
+  function ceil(date, unit) {
+    var datePart = fixUnit(unit);
+    var floor = startOf(date, datePart);
+    return eq(floor, date) ? floor : add(floor, 1, datePart);
+  }
+  function diff(a, b) {
+    var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+    var datePart = fixUnit(unit);
+    // don't use 'defineComparators' here, as we don't want to mutate the values
+    var dtA = DateTime.fromJSDate(a);
+    var dtB = DateTime.fromJSDate(b);
+    return Math.floor(dtB.diff(dtA, datePart, {
+      conversionAccuracy: 'longterm'
+    }).toObject()[datePart]);
+  }
+  function firstVisibleDay(date) {
+    var startOfMonth = startOfDT(date, 'month');
+    return startOfDTWeek(startOfMonth).toJSDate();
+  }
+  function lastVisibleDay(date) {
+    var endOfMonth = endOfDT(date, 'month');
+    return endOfDTWeek(endOfMonth).toJSDate();
+  }
+  function visibleDays(date) {
+    var current = firstVisibleDay(date);
+    var last = lastVisibleDay(date);
+    var days = [];
+    while (lte(current, last)) {
+      days.push(current);
+      current = add(current, 1, 'day');
+    }
+    return days;
+  }
+  /*** END localized date arithmetic methods with moment ***/
+
+  /**
+   * Moved from TimeSlots.js, this method overrides the method of the same name
+   * in the localizer.js, using moment to construct the js Date
+   * @param {Date} dt - date to start with
+   * @param {Number} minutesFromMidnight
+   * @param {Number} offset
+   * @returns {Date}
+   */
+  function getSlotDate(dt, minutesFromMidnight, offset) {
+    return startOfDT(dt, 'day').set({
+      minutes: minutesFromMidnight + offset
+    }).toJSDate();
+  }
+
+  // Luxon will automatically handle DST differences in it's calculations
+  function getTotalMin(start, end) {
+    return diff(start, end, 'minutes');
+  }
+  function getMinutesFromMidnight(start) {
+    var dayStart = startOfDT(start, 'day');
+    var day = DateTime.fromJSDate(start);
+    return Math.round(day.diff(dayStart, 'minutes', {
+      conversionAccuracy: 'longterm'
+    }).toObject().minutes);
+  }
+
+  // These two are used by DateSlotMetrics
+  function continuesPrior(start, first) {
+    return lt(start, first);
+  }
+  function continuesAfter(start, end, last) {
+    return gte(end, last);
+  }
+  function daySpan(start, end) {
+    var dtStart = DateTime.fromJSDate(start);
+    var dtEnd = DateTime.fromJSDate(end);
+    return dtEnd.diff(dtStart).as('days');
+  }
+
+  // These two are used by eventLevels
+  function sortEvents(_ref7) {
+    var _ref7$evtA = _ref7.evtA,
+      aStart = _ref7$evtA.start,
+      aEnd = _ref7$evtA.end,
+      aAllDay = _ref7$evtA.allDay,
+      _ref7$evtB = _ref7.evtB,
+      bStart = _ref7$evtB.start,
+      bEnd = _ref7$evtB.end,
+      bAllDay = _ref7$evtB.allDay;
+    var startSort = +startOf(aStart, 'day') - +startOf(bStart, 'day');
+    var durA = daySpan(aStart, aEnd);
+    var durB = daySpan(bStart, bEnd);
+    return startSort ||
+    // sort by start Day first
+    durB - durA ||
+    // events spanning multiple days go first
+    !!bAllDay - !!aAllDay ||
+    // then allDay single day events
+    +aStart - +bStart ||
+    // then sort by start time *don't need moment conversion here
+    +aEnd - +bEnd // then sort by end time *don't need moment conversion here either
+    ;
+  }
+  function inEventRange(_ref8) {
+    var _ref8$event = _ref8.event,
+      start = _ref8$event.start,
+      end = _ref8$event.end,
+      _ref8$range = _ref8.range,
+      rangeStart = _ref8$range.start,
+      rangeEnd = _ref8$range.end;
+    var eStart = startOf(start, 'day');
+    var startsBeforeEnd = lte(eStart, rangeEnd, 'day');
+    // when the event is zero duration we need to handle a bit differently
+    var sameMin = neq(eStart, end, 'minutes');
+    var endsAfterStart = sameMin ? gt(end, rangeStart, 'minutes') : gte(end, rangeStart, 'minutes');
+    return startsBeforeEnd && endsAfterStart;
+  }
+
+  // moment treats 'day' and 'date' equality very different
+  // moment(date1).isSame(date2, 'day') would test that they were both the same day of the week
+  // moment(date1).isSame(date2, 'date') would test that they were both the same date of the month of the year
+  function isSameDate(date1, date2) {
+    var dt = DateTime.fromJSDate(date1);
+    var dt2 = DateTime.fromJSDate(date2);
+    return dt.hasSame(dt2, 'day');
+  }
+
+  /**
+   * This method, called once in the localizer constructor, is used by eventLevels
+   * 'eventSegments()' to assist in determining the 'span' of the event in the display,
+   * specifically when using a timezone that is greater than the browser native timezone.
+   * @returns number
+   */
+  function browserTZOffset() {
+    /**
+     * Date.prototype.getTimezoneOffset horrifically flips the positive/negative from
+     * what you see in it's string, so we have to jump through some hoops to get a value
+     * we can actually compare.
+     */
+    var dt = new Date();
+    var neg = /-/.test(dt.toString()) ? '-' : '';
+    var dtOffset = dt.getTimezoneOffset();
+    var comparator = Number("".concat(neg).concat(Math.abs(dtOffset)));
+    // moment correctly provides positive/negative offset, as expected
+    var mtOffset = DateTime.local().offset;
+    return mtOffset > comparator ? 1 : 0;
+  }
+  return new _localizer.DateLocalizer({
+    format: function format(value, _format, culture) {
+      if (culture) {
+        return formatDateWithCulture(value, culture, _format);
+      }
+      return formatDate(value, _format);
+    },
+    formats: formats,
+    firstOfWeek: firstOfWeek,
+    firstVisibleDay: firstVisibleDay,
+    lastVisibleDay: lastVisibleDay,
+    visibleDays: visibleDays,
+    lt: lt,
+    lte: lte,
+    gt: gt,
+    gte: gte,
+    eq: eq,
+    neq: neq,
+    merge: merge,
+    inRange: inRange,
+    startOf: startOf,
+    endOf: endOf,
+    range: range,
+    add: add,
+    diff: diff,
+    ceil: ceil,
+    min: min,
+    max: max,
+    getSlotDate: getSlotDate,
+    getTotalMin: getTotalMin,
+    getMinutesFromMidnight: getMinutesFromMidnight,
+    continuesPrior: continuesPrior,
+    continuesAfter: continuesAfter,
+    sortEvents: sortEvents,
+    inEventRange: inEventRange,
+    isSameDate: isSameDate,
+    daySpan: daySpan,
+    browserTZOffset: browserTZOffset
+  });
+}

node_modules/react-big-calendar/lib/localizers/moment.js

@@ -0,0 +1,395 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.formats = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _localizer = require("../localizer");
+var weekRangeFormat = function weekRangeFormat(_ref, culture, local) {
+  var start = _ref.start,
+    end = _ref.end;
+  return local.format(start, 'MMMM DD', culture) + ' – ' +
+  // updated to use this localizer 'eq()' method
+  local.format(end, local.eq(start, end, 'month') ? 'DD' : 'MMMM DD', culture);
+};
+var dateRangeFormat = function dateRangeFormat(_ref2, culture, local) {
+  var start = _ref2.start,
+    end = _ref2.end;
+  return local.format(start, 'L', culture) + ' – ' + local.format(end, 'L', culture);
+};
+var timeRangeFormat = function timeRangeFormat(_ref3, culture, local) {
+  var start = _ref3.start,
+    end = _ref3.end;
+  return local.format(start, 'LT', culture) + ' – ' + local.format(end, 'LT', culture);
+};
+var timeRangeStartFormat = function timeRangeStartFormat(_ref4, culture, local) {
+  var start = _ref4.start;
+  return local.format(start, 'LT', culture) + ' – ';
+};
+var timeRangeEndFormat = function timeRangeEndFormat(_ref5, culture, local) {
+  var end = _ref5.end;
+  return ' – ' + local.format(end, 'LT', culture);
+};
+var formats = exports.formats = {
+  dateFormat: 'DD',
+  dayFormat: 'DD ddd',
+  weekdayFormat: 'ddd',
+  selectRangeFormat: timeRangeFormat,
+  eventTimeRangeFormat: timeRangeFormat,
+  eventTimeRangeStartFormat: timeRangeStartFormat,
+  eventTimeRangeEndFormat: timeRangeEndFormat,
+  timeGutterFormat: 'LT',
+  monthHeaderFormat: 'MMMM YYYY',
+  dayHeaderFormat: 'dddd MMM DD',
+  dayRangeHeaderFormat: weekRangeFormat,
+  agendaHeaderFormat: dateRangeFormat,
+  agendaDateFormat: 'ddd MMM DD',
+  agendaTimeFormat: 'LT',
+  agendaTimeRangeFormat: timeRangeFormat
+};
+function fixUnit(unit) {
+  var datePart = unit ? unit.toLowerCase() : unit;
+  if (datePart === 'FullYear') {
+    datePart = 'year';
+  } else if (!datePart) {
+    datePart = undefined;
+  }
+  return datePart;
+}
+function _default(moment) {
+  var locale = function locale(m, c) {
+    return c ? m.locale(c) : m;
+  };
+  function getTimezoneOffset(date) {
+    // ensures this gets cast to timezone
+    return moment(date).toDate().getTimezoneOffset();
+  }
+  function getDstOffset(start, end) {
+    var _st$_z$name, _st$_z;
+    // convert to moment, in case
+    // Calculate the offset in the timezone of the Events (local)
+    // not in the timezone of the calendar (moment.tz)
+    var st = moment(start).local();
+    var ed = moment(end).local();
+    // if not using moment timezone
+    if (!moment.tz) {
+      return st.toDate().getTimezoneOffset() - ed.toDate().getTimezoneOffset();
+    }
+    /**
+     * If using moment-timezone, and a timezone has been applied, then
+     * use this to get the proper timezone offset, otherwise default
+     * the timezone to the browser local
+     */
+    var tzName = (_st$_z$name = st === null || st === void 0 ? void 0 : (_st$_z = st._z) === null || _st$_z === void 0 ? void 0 : _st$_z.name) !== null && _st$_z$name !== void 0 ? _st$_z$name : moment.tz.guess();
+    var startOffset = moment.tz.zone(tzName).utcOffset(+st);
+    var endOffset = moment.tz.zone(tzName).utcOffset(+ed);
+    return startOffset - endOffset;
+  }
+  function getDayStartDstOffset(start) {
+    var dayStart = moment(start).startOf('day');
+    return getDstOffset(dayStart, start);
+  }
+
+  /*** BEGIN localized date arithmetic methods with moment ***/
+  function defineComparators(a, b, unit) {
+    var datePart = fixUnit(unit);
+    var dtA = datePart ? moment(a).startOf(datePart) : moment(a);
+    var dtB = datePart ? moment(b).startOf(datePart) : moment(b);
+    return [dtA, dtB, datePart];
+  }
+  function startOf() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    var datePart = fixUnit(unit);
+    if (datePart) {
+      return moment(date).startOf(datePart).toDate();
+    }
+    return moment(date).toDate();
+  }
+  function endOf() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var unit = arguments.length > 1 ? arguments[1] : undefined;
+    var datePart = fixUnit(unit);
+    if (datePart) {
+      return moment(date).endOf(datePart).toDate();
+    }
+    return moment(date).toDate();
+  }
+
+  // moment comparison operations *always* convert both sides to moment objects
+  // prior to running the comparisons
+  function eq(a, b, unit) {
+    var _defineComparators = defineComparators(a, b, unit),
+      _defineComparators2 = (0, _slicedToArray2.default)(_defineComparators, 3),
+      dtA = _defineComparators2[0],
+      dtB = _defineComparators2[1],
+      datePart = _defineComparators2[2];
+    return dtA.isSame(dtB, datePart);
+  }
+  function neq(a, b, unit) {
+    return !eq(a, b, unit);
+  }
+  function gt(a, b, unit) {
+    var _defineComparators3 = defineComparators(a, b, unit),
+      _defineComparators4 = (0, _slicedToArray2.default)(_defineComparators3, 3),
+      dtA = _defineComparators4[0],
+      dtB = _defineComparators4[1],
+      datePart = _defineComparators4[2];
+    return dtA.isAfter(dtB, datePart);
+  }
+  function lt(a, b, unit) {
+    var _defineComparators5 = defineComparators(a, b, unit),
+      _defineComparators6 = (0, _slicedToArray2.default)(_defineComparators5, 3),
+      dtA = _defineComparators6[0],
+      dtB = _defineComparators6[1],
+      datePart = _defineComparators6[2];
+    return dtA.isBefore(dtB, datePart);
+  }
+  function gte(a, b, unit) {
+    var _defineComparators7 = defineComparators(a, b, unit),
+      _defineComparators8 = (0, _slicedToArray2.default)(_defineComparators7, 3),
+      dtA = _defineComparators8[0],
+      dtB = _defineComparators8[1],
+      datePart = _defineComparators8[2];
+    return dtA.isSameOrBefore(dtB, datePart);
+  }
+  function lte(a, b, unit) {
+    var _defineComparators9 = defineComparators(a, b, unit),
+      _defineComparators10 = (0, _slicedToArray2.default)(_defineComparators9, 3),
+      dtA = _defineComparators10[0],
+      dtB = _defineComparators10[1],
+      datePart = _defineComparators10[2];
+    return dtA.isSameOrBefore(dtB, datePart);
+  }
+  function inRange(day, min, max) {
+    var unit = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'day';
+    var datePart = fixUnit(unit);
+    var mDay = moment(day);
+    var mMin = moment(min);
+    var mMax = moment(max);
+    return mDay.isBetween(mMin, mMax, datePart, '[]');
+  }
+  function min(dateA, dateB) {
+    var dtA = moment(dateA);
+    var dtB = moment(dateB);
+    var minDt = moment.min(dtA, dtB);
+    return minDt.toDate();
+  }
+  function max(dateA, dateB) {
+    var dtA = moment(dateA);
+    var dtB = moment(dateB);
+    var maxDt = moment.max(dtA, dtB);
+    return maxDt.toDate();
+  }
+  function merge(date, time) {
+    if (!date && !time) return null;
+    var tm = moment(time).format('HH:mm:ss');
+    var dt = moment(date).startOf('day').format('MM/DD/YYYY');
+    // We do it this way to avoid issues when timezone switching
+    return moment("".concat(dt, " ").concat(tm), 'MM/DD/YYYY HH:mm:ss').toDate();
+  }
+  function add(date, adder, unit) {
+    var datePart = fixUnit(unit);
+    return moment(date).add(adder, datePart).toDate();
+  }
+  function range(start, end) {
+    var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+    var datePart = fixUnit(unit);
+    // because the add method will put these in tz, we have to start that way
+    var current = moment(start).toDate();
+    var days = [];
+    while (lte(current, end)) {
+      days.push(current);
+      current = add(current, 1, datePart);
+    }
+    return days;
+  }
+  function ceil(date, unit) {
+    var datePart = fixUnit(unit);
+    var floor = startOf(date, datePart);
+    return eq(floor, date) ? floor : add(floor, 1, datePart);
+  }
+  function diff(a, b) {
+    var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+    var datePart = fixUnit(unit);
+    // don't use 'defineComparators' here, as we don't want to mutate the values
+    var dtA = moment(a);
+    var dtB = moment(b);
+    return dtB.diff(dtA, datePart);
+  }
+  function minutes(date) {
+    var dt = moment(date);
+    return dt.minutes();
+  }
+  function firstOfWeek(culture) {
+    var data = culture ? moment.localeData(culture) : moment.localeData();
+    return data ? data.firstDayOfWeek() : 0;
+  }
+  function firstVisibleDay(date) {
+    return moment(date).startOf('month').startOf('week').toDate();
+  }
+  function lastVisibleDay(date) {
+    return moment(date).endOf('month').endOf('week').toDate();
+  }
+  function visibleDays(date) {
+    var current = firstVisibleDay(date);
+    var last = lastVisibleDay(date);
+    var days = [];
+    while (lte(current, last)) {
+      days.push(current);
+      current = add(current, 1, 'd');
+    }
+    return days;
+  }
+  /*** END localized date arithmetic methods with moment ***/
+
+  /**
+   * Moved from TimeSlots.js, this method overrides the method of the same name
+   * in the localizer.js, using moment to construct the js Date
+   * @param {Date} dt - date to start with
+   * @param {Number} minutesFromMidnight
+   * @param {Number} offset
+   * @returns {Date}
+   */
+  function getSlotDate(dt, minutesFromMidnight, offset) {
+    return moment(dt).startOf('day').minute(minutesFromMidnight + offset).toDate();
+  }
+
+  // moment will automatically handle DST differences in it's calculations
+  function getTotalMin(start, end) {
+    return diff(start, end, 'minutes');
+  }
+  function getMinutesFromMidnight(start) {
+    var dayStart = moment(start).startOf('day');
+    var day = moment(start);
+    return day.diff(dayStart, 'minutes') + getDayStartDstOffset(start);
+  }
+
+  // These two are used by DateSlotMetrics
+  function continuesPrior(start, first) {
+    var mStart = moment(start);
+    var mFirst = moment(first);
+    return mStart.isBefore(mFirst, 'day');
+  }
+  function continuesAfter(start, end, last) {
+    var mEnd = moment(end);
+    var mLast = moment(last);
+    return mEnd.isSameOrAfter(mLast, 'minutes');
+  }
+  function daySpan(start, end) {
+    var mStart = moment(start);
+    var mEnd = moment(end);
+    var dur = moment.duration(mEnd.diff(mStart));
+    return dur.days();
+  }
+
+  // These two are used by eventLevels
+  function sortEvents(_ref6) {
+    var _ref6$evtA = _ref6.evtA,
+      aStart = _ref6$evtA.start,
+      aEnd = _ref6$evtA.end,
+      aAllDay = _ref6$evtA.allDay,
+      _ref6$evtB = _ref6.evtB,
+      bStart = _ref6$evtB.start,
+      bEnd = _ref6$evtB.end,
+      bAllDay = _ref6$evtB.allDay;
+    var startSort = +startOf(aStart, 'day') - +startOf(bStart, 'day');
+    var durA = daySpan(aStart, aEnd);
+    var durB = daySpan(bStart, bEnd);
+    return startSort ||
+    // sort by start Day first
+    durB - durA ||
+    // events spanning multiple days go first
+    !!bAllDay - !!aAllDay ||
+    // then allDay single day events
+    +aStart - +bStart ||
+    // then sort by start time *don't need moment conversion here
+    +aEnd - +bEnd // then sort by end time *don't need moment conversion here either
+    ;
+  }
+  function inEventRange(_ref7) {
+    var _ref7$event = _ref7.event,
+      start = _ref7$event.start,
+      end = _ref7$event.end,
+      _ref7$range = _ref7.range,
+      rangeStart = _ref7$range.start,
+      rangeEnd = _ref7$range.end;
+    var startOfDay = moment(start).startOf('day');
+    var eEnd = moment(end);
+    var rStart = moment(rangeStart);
+    var rEnd = moment(rangeEnd);
+    var startsBeforeEnd = startOfDay.isSameOrBefore(rEnd, 'day');
+    // when the event is zero duration we need to handle a bit differently
+    var sameMin = !startOfDay.isSame(eEnd, 'minutes');
+    var endsAfterStart = sameMin ? eEnd.isAfter(rStart, 'minutes') : eEnd.isSameOrAfter(rStart, 'minutes');
+    return startsBeforeEnd && endsAfterStart;
+  }
+  function isSameDate(date1, date2) {
+    var dt = moment(date1);
+    var dt2 = moment(date2);
+    return dt.isSame(dt2, 'day');
+  }
+
+  /**
+   * This method, called once in the localizer constructor, is used by eventLevels
+   * 'eventSegments()' to assist in determining the 'span' of the event in the display,
+   * specifically when using a timezone that is greater than the browser native timezone.
+   * @returns number
+   */
+  function browserTZOffset() {
+    /**
+     * Date.prototype.getTimezoneOffset horrifically flips the positive/negative from
+     * what you see in it's string, so we have to jump through some hoops to get a value
+     * we can actually compare.
+     */
+    var dt = new Date();
+    var neg = /-/.test(dt.toString()) ? '-' : '';
+    var dtOffset = dt.getTimezoneOffset();
+    var comparator = Number("".concat(neg).concat(Math.abs(dtOffset)));
+    // moment correctly provides positive/negative offset, as expected
+    var mtOffset = moment().utcOffset();
+    return mtOffset > comparator ? 1 : 0;
+  }
+  return new _localizer.DateLocalizer({
+    formats: formats,
+    firstOfWeek: firstOfWeek,
+    firstVisibleDay: firstVisibleDay,
+    lastVisibleDay: lastVisibleDay,
+    visibleDays: visibleDays,
+    format: function format(value, _format, culture) {
+      return locale(moment(value), culture).format(_format);
+    },
+    lt: lt,
+    lte: lte,
+    gt: gt,
+    gte: gte,
+    eq: eq,
+    neq: neq,
+    merge: merge,
+    inRange: inRange,
+    startOf: startOf,
+    endOf: endOf,
+    range: range,
+    add: add,
+    diff: diff,
+    ceil: ceil,
+    min: min,
+    max: max,
+    minutes: minutes,
+    getSlotDate: getSlotDate,
+    getTimezoneOffset: getTimezoneOffset,
+    getDstOffset: getDstOffset,
+    getTotalMin: getTotalMin,
+    getMinutesFromMidnight: getMinutesFromMidnight,
+    continuesPrior: continuesPrior,
+    continuesAfter: continuesAfter,
+    sortEvents: sortEvents,
+    inEventRange: inEventRange,
+    isSameDate: isSameDate,
+    daySpan: daySpan,
+    browserTZOffset: browserTZOffset
+  });
+}

node_modules/react-big-calendar/lib/localizers/oldGlobalize.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.formats = void 0;
+var dates = _interopRequireWildcard(require("../utils/dates"));
+var _localizer = require("../localizer");
+var dateRangeFormat = function dateRangeFormat(_ref, culture, local) {
+  var start = _ref.start,
+    end = _ref.end;
+  return local.format(start, 'd', culture) + ' – ' + local.format(end, 'd', culture);
+};
+var timeRangeFormat = function timeRangeFormat(_ref2, culture, local) {
+  var start = _ref2.start,
+    end = _ref2.end;
+  return local.format(start, 't', culture) + ' – ' + local.format(end, 't', culture);
+};
+var timeRangeStartFormat = function timeRangeStartFormat(_ref3, culture, local) {
+  var start = _ref3.start;
+  return local.format(start, 't', culture) + ' – ';
+};
+var timeRangeEndFormat = function timeRangeEndFormat(_ref4, culture, local) {
+  var end = _ref4.end;
+  return ' – ' + local.format(end, 't', culture);
+};
+var weekRangeFormat = function weekRangeFormat(_ref5, culture, local) {
+  var start = _ref5.start,
+    end = _ref5.end;
+  return local.format(start, 'MMM dd', culture) + ' – ' + local.format(end, dates.eq(start, end, 'month') ? 'dd' : 'MMM dd', culture);
+};
+var formats = exports.formats = {
+  dateFormat: 'dd',
+  dayFormat: 'ddd dd/MM',
+  weekdayFormat: 'ddd',
+  selectRangeFormat: timeRangeFormat,
+  eventTimeRangeFormat: timeRangeFormat,
+  eventTimeRangeStartFormat: timeRangeStartFormat,
+  eventTimeRangeEndFormat: timeRangeEndFormat,
+  timeGutterFormat: 't',
+  monthHeaderFormat: 'Y',
+  dayHeaderFormat: 'dddd MMM dd',
+  dayRangeHeaderFormat: weekRangeFormat,
+  agendaHeaderFormat: dateRangeFormat,
+  agendaDateFormat: 'ddd MMM dd',
+  agendaTimeFormat: 't',
+  agendaTimeRangeFormat: timeRangeFormat
+};
+function _default(globalize) {
+  function getCulture(culture) {
+    return culture ? globalize.findClosestCulture(culture) : globalize.culture();
+  }
+  function firstOfWeek(culture) {
+    culture = getCulture(culture);
+    return culture && culture.calendar.firstDay || 0;
+  }
+  return new _localizer.DateLocalizer({
+    firstOfWeek: firstOfWeek,
+    formats: formats,
+    format: function format(value, _format, culture) {
+      return globalize.format(value, _format, culture);
+    }
+  });
+}

node_modules/react-big-calendar/lib/sass/agenda.scss

@@ -0,0 +1,73 @@
+@import './variables';
+
+.rbc-agenda-view {
+  display: flex;
+  flex-direction: column;
+  flex: 1 0 0;
+  overflow: auto;
+
+  table.rbc-agenda-table {
+    width: 100%;
+    border: 1px solid $cell-border;
+    border-spacing: 0;
+    border-collapse: collapse;
+
+    tbody > tr > td {
+      padding: 5px 10px;
+      vertical-align: top;
+    }
+
+    .rbc-agenda-time-cell {
+      padding-left: 15px;
+      padding-right: 15px;
+      text-transform: lowercase;
+    }
+
+    tbody > tr > td + td {
+      border-left: 1px solid $cell-border;
+    }
+
+    .rbc-rtl & {
+      tbody > tr > td + td {
+        border-left-width: 0;
+        border-right: 1px solid $cell-border;
+      }
+    }
+
+    tbody > tr + tr {
+      border-top: 1px solid $cell-border;
+    }
+
+    thead > tr > th {
+      padding: 3px 5px;
+      text-align: left;
+      border-bottom: 1px solid $cell-border;
+
+      .rbc-rtl & {
+        text-align: right;
+      }
+    }
+  }
+}
+
+.rbc-agenda-time-cell {
+  text-transform: lowercase;
+
+  .rbc-continues-after:after {
+    content: ' »'
+  }
+  .rbc-continues-prior:before {
+    content: '« '
+  }
+}
+
+.rbc-agenda-date-cell,
+.rbc-agenda-time-cell {
+  white-space: nowrap;
+}
+
+
+
+.rbc-agenda-event-cell {
+  width: 100%
+}

node_modules/react-big-calendar/lib/sass/event.scss

@@ -0,0 +1,56 @@
+@import './variables';
+
+.rbc-event {
+  border: none;
+  box-sizing: border-box;
+  box-shadow: none;
+  margin: 0;
+  padding: $event-padding;
+  background-color: $event-bg;
+  border-radius: $event-border-radius;
+  color: $event-color;
+  cursor: pointer;
+  width: 100%;
+  text-align: left;
+
+  .rbc-slot-selecting & {
+    cursor: inherit;
+    pointer-events: none;
+  }
+
+  &.rbc-selected {
+    background-color: darken($event-bg, 10%);
+  }
+
+  &:focus {
+    outline: 5px auto $event-outline;
+  }
+}
+
+.rbc-event-label {
+  @extend .rbc-ellipsis;
+  font-size: 80%;
+}
+
+.rbc-event-overlaps {
+  box-shadow: -1px 1px 5px 0px rgba(51,51,51,.5);
+}
+
+.rbc-event-continues-prior {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+.rbc-event-continues-after {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+
+
+.rbc-event-continues-earlier {
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+.rbc-event-continues-later {
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+}

node_modules/react-big-calendar/lib/sass/month.scss

@@ -0,0 +1,127 @@
+@import './variables';
+
+.rbc-row {
+  display: flex;
+  flex-direction: row;
+}
+
+.rbc-row-segment {
+  padding: 0 1px 1px 1px;
+
+  .rbc-event-content {
+    @extend .rbc-ellipsis;
+  }
+}
+
+.rbc-selected-cell {
+  background-color: $date-selection-bg-color;
+}
+
+.rbc-show-more {
+  @extend .rbc-ellipsis;
+  background-color: rgba(255, 255, 255, 0.3);
+  z-index: $event-zindex;
+  font-weight: bold;
+  font-size: 85%;
+  height: auto;
+  line-height: normal;
+  color: $event-bg;
+  &:hover,
+  &:focus {
+    color: darken($event-bg, 10%);
+  }
+}
+
+.rbc-month-view {
+  position: relative;
+  border: 1px solid $calendar-border;
+  display: flex;
+  flex-direction: column;
+  flex: 1 0 0;
+  width: 100%;
+  user-select: none;
+  -webkit-user-select: none;
+
+  height: 100%; // ie-fix
+}
+
+.rbc-month-header {
+  display: flex;
+  flex-direction: row;
+}
+
+.rbc-month-row {
+  display: flex;
+  position: relative;
+  flex-direction: column;
+  flex: 1 0 0; // postcss will remove the 0px here hence the duplication below
+  flex-basis: 0px;
+  overflow: hidden;
+
+  height: 100%; // ie-fix
+
+  & + & {
+    border-top: 1px solid $cell-border;
+  }
+}
+
+.rbc-date-cell {
+  flex: 1 1 0;
+  min-width: 0;
+  padding-right: 5px;
+  text-align: right;
+
+  &.rbc-now {
+    font-weight: bold;
+  }
+
+  > a {
+    &,
+    &:active,
+    &:visited {
+      color: inherit;
+      text-decoration: none;
+    }
+  }
+}
+
+.rbc-row-bg {
+  @extend .rbc-abs-full;
+  display: flex;
+  flex-direction: row;
+  flex: 1 0 0;
+  overflow: hidden;
+  right: 1px;
+}
+
+.rbc-day-bg {
+  flex: 1 0 0%;
+
+  & + & {
+    border-left: 1px solid $cell-border;
+  }
+
+  .rbc-rtl & + & {
+    border-left-width: 0;
+    border-right: 1px solid $cell-border;
+  }
+}
+
+.rbc-overlay {
+  position: absolute;
+  z-index: $event-zindex + 1;
+  border: 1px solid #e5e5e5;
+  background-color: #fff;
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.25);
+  padding: 10px;
+
+  > * + * {
+    margin-top: 1px;
+  }
+}
+
+.rbc-overlay-header {
+  border-bottom: 1px solid #e5e5e5;
+  margin: -10px -10px 5px -10px;
+  padding: 2px 10px;
+}

node_modules/react-big-calendar/lib/sass/reset.scss

@@ -0,0 +1,22 @@
+.rbc-btn {
+  color: inherit;
+  font: inherit;
+  margin: 0;
+}
+
+button.rbc-btn {
+  overflow: visible;
+  text-transform: none;
+  appearance: button;
+  cursor: pointer;
+}
+
+button[disabled].rbc-btn {
+  cursor: not-allowed;
+}
+
+button.rbc-input::-moz-focus-inner {
+  border: 0;
+  padding: 0;
+}
+

node_modules/react-big-calendar/lib/sass/styles.scss

@@ -0,0 +1,132 @@
+@import './variables';
+@import './reset';
+
+.rbc-calendar {
+  box-sizing: border-box;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+}
+
+.rbc-m-b-negative-3 {
+  margin-bottom: -3px;
+}
+
+.rbc-h-full {
+  height: 100%;
+}
+
+.rbc-calendar *,
+.rbc-calendar *:before,
+.rbc-calendar *:after {
+  box-sizing: inherit;
+}
+
+.rbc-abs-full {
+  overflow: hidden;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+}
+
+.rbc-ellipsis {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.rbc-rtl {
+  direction: rtl;
+}
+
+.rbc-off-range {
+  color: $out-of-range-color;
+}
+
+.rbc-off-range-bg {
+  background: $out-of-range-bg-color;
+}
+
+.rbc-header {
+  overflow: hidden;
+  flex: 1 0 0%;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  padding: 0 3px;
+  text-align: center;
+  vertical-align: middle;
+  font-weight: bold;
+  font-size: 90%;
+  min-height: 0;
+  border-bottom: 1px solid $cell-border;
+
+  & + & {
+    border-left: 1px solid $cell-border;
+  }
+
+  .rbc-rtl & + & {
+    border-left-width: 0;
+    border-right: 1px solid $cell-border;
+  }
+
+  & > a {
+    &,
+    &:active,
+    &:visited {
+      color: inherit;
+      text-decoration: none;
+    }
+  }
+}
+
+.rbc-button-link {
+  color: inherit;
+  background: none;
+  margin: 0;
+  padding: 0;
+  border: none;
+  cursor: pointer;
+  user-select: text;
+}
+
+.rbc-row-content {
+  position: relative;
+  user-select: none;
+  -webkit-user-select: none;
+  z-index: 4;
+}
+
+.rbc-row-content-scrollable {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+
+  .rbc-row-content-scroll-container {
+    height: 100%;
+    overflow-y: scroll;
+    -ms-overflow-style: none; /* IE and Edge */
+    scrollbar-width: none; /* Firefox */
+
+    -ms-overflow-style: none; /* IE and Edge */
+    scrollbar-width: none; /* Firefox */
+
+    /* Hide scrollbar for Chrome, Safari and Opera */
+    &::-webkit-scrollbar {
+      display: none;
+    }
+  }
+}
+
+.rbc-today {
+  background-color: $today-highlight-bg;
+}
+
+@import './toolbar';
+@import './event';
+@import './month';
+@import './agenda';
+@import './time-grid';

node_modules/react-big-calendar/lib/sass/time-column.scss

@@ -0,0 +1,135 @@
+@import './variables';
+
+.rbc-time-column {
+  display: flex;
+  flex-direction: column;
+  min-height: 100%;
+
+  .rbc-timeslot-group {
+    flex: 1;
+  }
+}
+
+
+.rbc-timeslot-group {
+  border-bottom: 1px solid $cell-border;
+  min-height: 40px;
+  display: flex;
+  flex-flow: column nowrap;
+}
+
+.rbc-time-gutter,
+.rbc-header-gutter {
+  flex: none;
+}
+
+.rbc-label {
+  padding: 0 5px;
+}
+
+.rbc-day-slot {
+  position: relative;
+
+  .rbc-events-container {
+    bottom: 0;
+    left: 0;
+    position: absolute;
+    right: 0;
+    margin-right: 10px;
+    top: 0;
+
+    &.rbc-rtl {
+      left: 10px;
+      right: 0;
+    }
+  }
+
+  .rbc-event {
+    border: 1px solid $event-border;
+    display: flex;
+    max-height: 100%;
+    min-height: 20px;
+    flex-flow: column wrap;
+    align-items: flex-start;
+    overflow: hidden;
+    position: absolute;
+  }
+  
+  .rbc-background-event {
+    @extend .rbc-event;
+    opacity: 0.75;
+  }
+
+  .rbc-event-label {
+    flex: none;
+    padding-right: 5px;
+    width: auto;
+  }
+
+  .rbc-event-content {
+    width: 100%;
+    flex: 1 1 0;
+    word-wrap: break-word;
+    line-height: 1;
+    height: 100%;
+    min-height: 1em;
+  }
+
+  .rbc-time-slot {
+    border-top: 1px solid lighten($cell-border, 10%);
+  }
+}
+
+.rbc-time-view-resources {
+  .rbc-time-gutter,
+  .rbc-time-header-gutter {
+    position: sticky;
+    left: 0;
+    background-color: white;
+    border-right: 1px solid $cell-border;
+    z-index: 10;
+    margin-right: -1px;
+  }
+
+  .rbc-time-header {
+    overflow: hidden;
+  }
+
+  .rbc-time-header-content {
+    min-width: auto;
+    flex: 1 0 0;
+    flex-basis: 0px;
+  }
+
+  .rbc-time-header-cell-single-day {
+    display: none;
+  }
+
+  .rbc-day-slot {
+    min-width: 140px;
+  }
+
+  .rbc-header,
+  .rbc-day-bg {
+    width: 140px;
+    // min-width: 0;
+    flex:  1 1 0;
+    flex-basis: 0 px;
+  }
+}
+
+.rbc-time-header-content + .rbc-time-header-content {
+  margin-left: -1px;
+}
+
+.rbc-time-slot {
+  flex: 1 0 0;
+
+  &.rbc-now {
+    font-weight: bold;
+  }
+}
+
+.rbc-day-header {
+  text-align: center;
+}

node_modules/react-big-calendar/lib/sass/time-grid.scss

@@ -0,0 +1,154 @@
+@import './variables';
+@import './time-column';
+
+.rbc-slot-selection {
+  z-index: 10;
+  position: absolute;
+  background-color: $time-selection-bg-color;
+  color: $time-selection-color;
+  font-size: 75%;
+  width: 100%;
+  padding: 3px;
+}
+
+.rbc-slot-selecting {
+  cursor: move;
+}
+
+.rbc-time-view {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  width: 100%;
+  border: 1px solid $calendar-border;
+  min-height: 0;
+
+  .rbc-time-gutter {
+    white-space: nowrap;
+    text-align: right;
+  }
+
+  .rbc-allday-cell {
+    box-sizing: content-box;
+    width: 100%;
+    height: 100%;
+    position: relative;
+  }
+  .rbc-allday-cell + .rbc-allday-cell {
+    border-left: 1px solid $cell-border;
+  }
+
+  .rbc-allday-events {
+    position: relative;
+    z-index: 4;
+  }
+
+  .rbc-row {
+    box-sizing: border-box;
+    min-height: 20px;
+  }
+}
+
+.rbc-time-header {
+  display: flex;
+  flex: 0 0 auto; // should not shrink below height
+  flex-direction: row;
+
+  &.rbc-overflowing {
+    border-right: 1px solid $cell-border;
+  }
+
+  .rbc-rtl &.rbc-overflowing {
+    border-right-width: 0;
+    border-left: 1px solid $cell-border;
+  }
+
+  > .rbc-row:first-child {
+    border-bottom: 1px solid $cell-border;
+  }
+
+  > .rbc-row.rbc-row-resource {
+    border-bottom: 1px solid $cell-border;
+  }
+
+  // .rbc-gutter-cell {
+  //   flex: none;
+  // }
+
+  // > .rbc-gutter-cell + * {
+  //   width: 100%;
+  // }
+}
+
+.rbc-time-header-cell-single-day {
+  display: none;
+}
+
+.rbc-time-header-content {
+  flex: 1;
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+  border-left: 1px solid $cell-border;
+
+  .rbc-rtl & {
+    border-left-width: 0;
+    border-right: 1px solid $cell-border;
+  }
+
+  > .rbc-row.rbc-row-resource {
+    border-bottom: 1px solid $cell-border;
+    flex-shrink: 0;
+  }
+}
+
+.rbc-time-content {
+  display: flex;
+  flex: 1 0 0%;
+  align-items: flex-start;
+  width: 100%;
+  border-top: 2px solid $calendar-border;
+  overflow-y: auto;
+  position: relative;
+
+  > .rbc-time-gutter {
+    flex: none;
+  }
+
+  > * + * > * {
+    border-left: 1px solid $cell-border;
+  }
+
+  .rbc-rtl & > * + * > * {
+    border-left-width: 0;
+    border-right: 1px solid $cell-border;
+  }
+
+  > .rbc-day-slot {
+    width: 100%;
+    user-select: none;
+    -webkit-user-select: none;
+  }
+}
+
+.rbc-current-time-indicator {
+  position: absolute;
+  z-index: 3;
+  left: 0;
+  right: 0;
+  height: 1px;
+
+  background-color: $current-time-color;
+  pointer-events: none;
+}
+
+.rbc-resource-grouping {
+  &.rbc-time-header-content {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .rbc-row .rbc-header {
+    width: 141px;
+  }
+}

node_modules/react-big-calendar/lib/sass/toolbar.scss

@@ -0,0 +1,113 @@
+@import './variables';
+
+$active-background: darken($btn-bg, 10%);
+$active-border: darken($btn-border, 12%);
+
+.rbc-toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  align-items: center;
+  margin-bottom: 10px;
+  font-size: 16px;
+
+  .rbc-toolbar-label {
+    flex-grow:1;
+    padding: 0 10px;
+    text-align: center;
+  }
+
+  & button {
+    color: $btn-color;
+    display: inline-block;
+    margin: 0;
+    text-align: center;
+    vertical-align: middle;
+    background: none;
+    background-image: none;
+    border: 1px solid $btn-border;
+    padding: .375rem 1rem;
+    border-radius: 4px;
+    line-height: normal;
+    white-space: nowrap;
+
+    &:active,
+    &.rbc-active {
+      background-image: none;
+      box-shadow: inset 0 3px 5px rgba(0,0,0,.125);
+      background-color: $active-background;
+      border-color: $active-border;
+
+      &:hover,
+      &:focus {
+        color: $btn-color;
+        background-color: darken($btn-bg, 17%);
+        border-color: darken($btn-border, 25%);
+      }
+    }
+
+    &:focus {
+      color: $btn-color;
+      background-color: $active-background;
+      border-color: $active-border;
+    }
+
+    &:hover {
+      color: $btn-color;
+      cursor: pointer;
+      background-color: $active-background;
+          border-color: $active-border;
+    }
+  }
+}
+
+.rbc-btn-group {
+  display: inline-block;
+  white-space: nowrap;
+
+  > button:first-child:not(:last-child) {
+    border-top-right-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  > button:last-child:not(:first-child) {
+    border-top-left-radius: 0;
+    border-bottom-left-radius: 0;
+  }
+
+  .rbc-rtl & > button:first-child:not(:last-child) {
+    border-radius: 4px;
+    border-top-left-radius: 0;
+    border-bottom-left-radius: 0;
+  }
+
+  .rbc-rtl & > button:last-child:not(:first-child) {
+    border-radius: 4px;
+    border-top-right-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  > button:not(:first-child):not(:last-child) {
+    border-radius: 0;
+  }
+
+  button + button {
+    margin-left: -1px;
+  }
+
+  .rbc-rtl & button + button {
+    margin-left: 0;
+    margin-right: -1px;
+  }
+
+  & + &,
+  & + button {
+    margin-left: 10px;
+  }
+}
+
+@media (max-width: 767px) {
+  .rbc-toolbar {
+    flex-direction: column;
+  }
+}

node_modules/react-big-calendar/lib/sass/variables.scss

@@ -0,0 +1,32 @@
+$out-of-range-color: lighten(#333, 40%) !default;
+$out-of-range-bg-color: lighten(#333, 70%) !default;
+
+$calendar-border: #ddd !default;
+$cell-border: #ddd !default;
+
+$border-color: #ccc !default;
+
+// Each calendar segment is 1/7th.
+$segment-width: 0.14286% !default;
+
+$time-selection-color: white !default;
+$time-selection-bg-color: rgba(0, 0, 0, 0.5) !default;
+$date-selection-bg-color: rgba(0, 0, 0, 0.1) !default;
+
+$event-bg: #3174ad !default;
+$event-border: darken(#3174ad, 10%) !default;
+$event-outline: #3b99fc !default;
+$event-color: #fff !default;
+$event-border-radius: 5px !default;
+$event-padding: 2px 5px !default;
+$event-zindex: 4 !default;
+
+$btn-color: #373a3c !default;
+$btn-bg: #fff !default;
+$btn-border: #ccc !default;
+
+$current-time-color: #74ad31 !default;
+
+$rbc-css-prefix: rbc-i !default;
+
+$today-highlight-bg: #eaf6ff !default;

node_modules/react-big-calendar/lib/utils/DateSlotMetrics.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSlotMetrics = getSlotMetrics;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _memoizeOne = _interopRequireDefault(require("memoize-one"));
+var _eventLevels2 = require("./eventLevels");
+var isSegmentInSlot = function isSegmentInSlot(seg, slot) {
+  return seg.left <= slot && seg.right >= slot;
+};
+var isEqual = function isEqual(a, b) {
+  return a[0].range === b[0].range && a[0].events === b[0].events;
+};
+function getSlotMetrics() {
+  return (0, _memoizeOne.default)(function (options) {
+    var range = options.range,
+      events = options.events,
+      maxRows = options.maxRows,
+      minRows = options.minRows,
+      accessors = options.accessors,
+      localizer = options.localizer;
+    var _endOfRange = (0, _eventLevels2.endOfRange)({
+        dateRange: range,
+        localizer: localizer
+      }),
+      first = _endOfRange.first,
+      last = _endOfRange.last;
+    var segments = events.map(function (evt) {
+      return (0, _eventLevels2.eventSegments)(evt, range, accessors, localizer);
+    });
+    var _eventLevels = (0, _eventLevels2.eventLevels)(segments, Math.max(maxRows - 1, 1)),
+      levels = _eventLevels.levels,
+      extra = _eventLevels.extra;
+    // Subtract 1 from minRows to not include showMore button row when
+    // it would be rendered
+    var minEventRows = extra.length > 0 ? minRows - 1 : minRows;
+    while (levels.length < minEventRows) levels.push([]);
+    return {
+      first: first,
+      last: last,
+      levels: levels,
+      extra: extra,
+      range: range,
+      slots: range.length,
+      clone: function clone(args) {
+        var metrics = getSlotMetrics();
+        return metrics((0, _objectSpread2.default)((0, _objectSpread2.default)({}, options), args));
+      },
+      getDateForSlot: function getDateForSlot(slotNumber) {
+        return range[slotNumber];
+      },
+      getSlotForDate: function getSlotForDate(date) {
+        return range.find(function (r) {
+          return localizer.isSameDate(r, date);
+        });
+      },
+      getEventsForSlot: function getEventsForSlot(slot) {
+        return segments.filter(function (seg) {
+          return isSegmentInSlot(seg, slot);
+        }).map(function (seg) {
+          return seg.event;
+        });
+      },
+      continuesPrior: function continuesPrior(event) {
+        return localizer.continuesPrior(accessors.start(event), first);
+      },
+      continuesAfter: function continuesAfter(event) {
+        var start = accessors.start(event);
+        var end = accessors.end(event);
+        return localizer.continuesAfter(start, end, last);
+      }
+    };
+  }, isEqual);
+}

node_modules/react-big-calendar/lib/utils/DayEventLayout.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStyledEvents = getStyledEvents;
+var _overlap = _interopRequireDefault(require("./layout-algorithms/overlap"));
+var _noOverlap = _interopRequireDefault(require("./layout-algorithms/no-overlap"));
+/*eslint no-unused-vars: "off"*/
+
+var DefaultAlgorithms = {
+  overlap: _overlap.default,
+  'no-overlap': _noOverlap.default
+};
+function isFunction(a) {
+  return !!(a && a.constructor && a.call && a.apply);
+}
+
+//
+function getStyledEvents(_ref) {
+  var events = _ref.events,
+    minimumStartDifference = _ref.minimumStartDifference,
+    slotMetrics = _ref.slotMetrics,
+    accessors = _ref.accessors,
+    dayLayoutAlgorithm = _ref.dayLayoutAlgorithm;
+  var algorithm = dayLayoutAlgorithm;
+  if (dayLayoutAlgorithm in DefaultAlgorithms) algorithm = DefaultAlgorithms[dayLayoutAlgorithm];
+  if (!isFunction(algorithm)) {
+    // invalid algorithm
+    return [];
+  }
+  return algorithm.apply(this, arguments);
+}

node_modules/react-big-calendar/lib/utils/Resources.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NONE = void 0;
+exports.default = Resources;
+var NONE = exports.NONE = {};
+function Resources(resources, accessors) {
+  return {
+    map: function map(fn) {
+      if (!resources) return [fn([NONE, null], 0)];
+      return resources.map(function (resource, idx) {
+        return fn([accessors.resourceId(resource), resource], idx);
+      });
+    },
+    groupEvents: function groupEvents(events) {
+      var eventsByResource = new Map();
+      if (!resources) {
+        // Return all events if resources are not provided
+        eventsByResource.set(NONE, events);
+        return eventsByResource;
+      }
+      events.forEach(function (event) {
+        var id = accessors.resource(event) || NONE;
+        if (Array.isArray(id)) {
+          id.forEach(function (item) {
+            var resourceEvents = eventsByResource.get(item) || [];
+            resourceEvents.push(event);
+            eventsByResource.set(item, resourceEvents);
+          });
+        } else {
+          var resourceEvents = eventsByResource.get(id) || [];
+          resourceEvents.push(event);
+          eventsByResource.set(id, resourceEvents);
+        }
+      });
+      return eventsByResource;
+    }
+  };
+}

node_modules/react-big-calendar/lib/utils/TimeSlots.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSlotMetrics = getSlotMetrics;
+var getKey = function getKey(_ref) {
+  var min = _ref.min,
+    max = _ref.max,
+    step = _ref.step,
+    slots = _ref.slots,
+    localizer = _ref.localizer;
+  return "".concat(+localizer.startOf(min, 'minutes')) + "".concat(+localizer.startOf(max, 'minutes')) + "".concat(step, "-").concat(slots);
+};
+function getSlotMetrics(_ref2) {
+  var start = _ref2.min,
+    end = _ref2.max,
+    step = _ref2.step,
+    timeslots = _ref2.timeslots,
+    localizer = _ref2.localizer;
+  var key = getKey({
+    start: start,
+    end: end,
+    step: step,
+    timeslots: timeslots,
+    localizer: localizer
+  });
+
+  // DST differences are handled inside the localizer
+  var totalMin = 1 + localizer.getTotalMin(start, end);
+  var minutesFromMidnight = localizer.getMinutesFromMidnight(start);
+  var numGroups = Math.ceil((totalMin - 1) / (step * timeslots));
+  var numSlots = numGroups * timeslots;
+  var groups = new Array(numGroups);
+  var slots = new Array(numSlots);
+  // Each slot date is created from "zero", instead of adding `step` to
+  // the previous one, in order to avoid DST oddities
+  for (var grp = 0; grp < numGroups; grp++) {
+    groups[grp] = new Array(timeslots);
+    for (var slot = 0; slot < timeslots; slot++) {
+      var slotIdx = grp * timeslots + slot;
+      var minFromStart = slotIdx * step;
+      // A date with total minutes calculated from the start of the day
+      slots[slotIdx] = groups[grp][slot] = localizer.getSlotDate(start, minutesFromMidnight, minFromStart);
+    }
+  }
+
+  // Necessary to be able to select up until the last timeslot in a day
+  var lastSlotMinFromStart = slots.length * step;
+  slots.push(localizer.getSlotDate(start, minutesFromMidnight, lastSlotMinFromStart));
+  function positionFromDate(date) {
+    var diff = localizer.diff(start, date, 'minutes') + localizer.getDstOffset(start, date);
+    return Math.min(diff, totalMin);
+  }
+  return {
+    groups: groups,
+    update: function update(args) {
+      if (getKey(args) !== key) return getSlotMetrics(args);
+      return this;
+    },
+    dateIsInGroup: function dateIsInGroup(date, groupIndex) {
+      var nextGroup = groups[groupIndex + 1];
+      return localizer.inRange(date, groups[groupIndex][0], nextGroup ? nextGroup[0] : end, 'minutes');
+    },
+    nextSlot: function nextSlot(slot) {
+      // We cannot guarantee that the slot object must be in slots,
+      // because after each update, a new slots array will be created.
+      var next = slots[Math.min(slots.findIndex(function (s) {
+        return s === slot || localizer.eq(s, slot);
+      }) + 1, slots.length - 1)];
+      // in the case of the last slot we won't a long enough range so manually get it
+      if (localizer.eq(next, slot)) next = localizer.add(slot, step, 'minutes');
+      return next;
+    },
+    closestSlotToPosition: function closestSlotToPosition(percent) {
+      var slot = Math.min(slots.length - 1, Math.max(0, Math.floor(percent * numSlots)));
+      return slots[slot];
+    },
+    closestSlotFromPoint: function closestSlotFromPoint(point, boundaryRect) {
+      var range = Math.abs(boundaryRect.top - boundaryRect.bottom);
+      return this.closestSlotToPosition((point.y - boundaryRect.top) / range);
+    },
+    closestSlotFromDate: function closestSlotFromDate(date) {
+      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (localizer.lt(date, start, 'minutes')) return slots[0];
+      if (localizer.gt(date, end, 'minutes')) return slots[slots.length - 1];
+      var diffMins = localizer.diff(start, date, 'minutes');
+      return slots[(diffMins - diffMins % step) / step + offset];
+    },
+    startsBeforeDay: function startsBeforeDay(date) {
+      return localizer.lt(date, start, 'day');
+    },
+    startsAfterDay: function startsAfterDay(date) {
+      return localizer.gt(date, end, 'day');
+    },
+    startsBefore: function startsBefore(date) {
+      return localizer.lt(localizer.merge(start, date), start, 'minutes');
+    },
+    startsAfter: function startsAfter(date) {
+      return localizer.gt(localizer.merge(end, date), end, 'minutes');
+    },
+    getRange: function getRange(rangeStart, rangeEnd, ignoreMin, ignoreMax) {
+      if (!ignoreMin) rangeStart = localizer.min(end, localizer.max(start, rangeStart));
+      if (!ignoreMax) rangeEnd = localizer.min(end, localizer.max(start, rangeEnd));
+      var rangeStartMin = positionFromDate(rangeStart);
+      var rangeEndMin = positionFromDate(rangeEnd);
+      var top = rangeEndMin > step * numSlots && !localizer.eq(end, rangeEnd) ? (rangeStartMin - step) / (step * numSlots) * 100 : rangeStartMin / (step * numSlots) * 100;
+      return {
+        top: top,
+        height: rangeEndMin / (step * numSlots) * 100 - top,
+        start: positionFromDate(rangeStart),
+        startDate: rangeStart,
+        end: positionFromDate(rangeEnd),
+        endDate: rangeEnd
+      };
+    },
+    getCurrentTimePosition: function getCurrentTimePosition(rangeStart) {
+      var rangeStartMin = positionFromDate(rangeStart);
+      var top = rangeStartMin / (step * numSlots) * 100;
+      return top;
+    }
+  };
+}

node_modules/react-big-calendar/lib/utils/accessors.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.accessor = accessor;
+exports.wrapAccessor = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+/**
+ * Retrieve via an accessor-like property
+ *
+ *    accessor(obj, 'name')   // => retrieves obj['name']
+ *    accessor(data, func)    // => retrieves func(data)
+ *    ... otherwise null
+ */
+function accessor(data, field) {
+  var value = null;
+  if (typeof field === 'function') value = field(data);else if (typeof field === 'string' && (0, _typeof2.default)(data) === 'object' && data != null && field in data) value = data[field];
+  return value;
+}
+var wrapAccessor = exports.wrapAccessor = function wrapAccessor(acc) {
+  return function (data) {
+    return accessor(data, acc);
+  };
+};

node_modules/react-big-calendar/lib/utils/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.views = exports.navigate = void 0;
+var navigate = exports.navigate = {
+  PREVIOUS: 'PREV',
+  NEXT: 'NEXT',
+  TODAY: 'TODAY',
+  DATE: 'DATE'
+};
+var views = exports.views = {
+  MONTH: 'month',
+  WEEK: 'week',
+  WORK_WEEK: 'work_week',
+  DAY: 'day',
+  AGENDA: 'agenda'
+};

node_modules/react-big-calendar/lib/utils/dates.js

@@ -0,0 +1,236 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "add", {
+  enumerable: true,
+  get: function get() {
+    return dates.add;
+  }
+});
+exports.ceil = ceil;
+exports.diff = diff;
+exports.duration = duration;
+Object.defineProperty(exports, "endOf", {
+  enumerable: true,
+  get: function get() {
+    return dates.endOf;
+  }
+});
+Object.defineProperty(exports, "eq", {
+  enumerable: true,
+  get: function get() {
+    return dates.eq;
+  }
+});
+exports.eqTime = eqTime;
+exports.firstVisibleDay = firstVisibleDay;
+Object.defineProperty(exports, "gt", {
+  enumerable: true,
+  get: function get() {
+    return dates.gt;
+  }
+});
+Object.defineProperty(exports, "gte", {
+  enumerable: true,
+  get: function get() {
+    return dates.gte;
+  }
+});
+Object.defineProperty(exports, "hours", {
+  enumerable: true,
+  get: function get() {
+    return dates.hours;
+  }
+});
+Object.defineProperty(exports, "inRange", {
+  enumerable: true,
+  get: function get() {
+    return dates.inRange;
+  }
+});
+exports.isJustDate = isJustDate;
+exports.lastVisibleDay = lastVisibleDay;
+Object.defineProperty(exports, "lt", {
+  enumerable: true,
+  get: function get() {
+    return dates.lt;
+  }
+});
+Object.defineProperty(exports, "lte", {
+  enumerable: true,
+  get: function get() {
+    return dates.lte;
+  }
+});
+Object.defineProperty(exports, "max", {
+  enumerable: true,
+  get: function get() {
+    return dates.max;
+  }
+});
+exports.merge = merge;
+Object.defineProperty(exports, "milliseconds", {
+  enumerable: true,
+  get: function get() {
+    return dates.milliseconds;
+  }
+});
+Object.defineProperty(exports, "min", {
+  enumerable: true,
+  get: function get() {
+    return dates.min;
+  }
+});
+Object.defineProperty(exports, "minutes", {
+  enumerable: true,
+  get: function get() {
+    return dates.minutes;
+  }
+});
+Object.defineProperty(exports, "month", {
+  enumerable: true,
+  get: function get() {
+    return dates.month;
+  }
+});
+exports.monthsInYear = monthsInYear;
+Object.defineProperty(exports, "neq", {
+  enumerable: true,
+  get: function get() {
+    return dates.neq;
+  }
+});
+exports.range = range;
+Object.defineProperty(exports, "seconds", {
+  enumerable: true,
+  get: function get() {
+    return dates.seconds;
+  }
+});
+Object.defineProperty(exports, "startOf", {
+  enumerable: true,
+  get: function get() {
+    return dates.startOf;
+  }
+});
+exports.today = today;
+exports.tomorrow = tomorrow;
+exports.total = total;
+exports.visibleDays = visibleDays;
+exports.week = week;
+exports.yesterday = yesterday;
+var dates = _interopRequireWildcard(require("date-arithmetic"));
+/* eslint no-fallthrough: off */
+
+var MILLI = {
+  seconds: 1000,
+  minutes: 1000 * 60,
+  hours: 1000 * 60 * 60,
+  day: 1000 * 60 * 60 * 24
+};
+var MONTHS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+function monthsInYear(year) {
+  var date = new Date(year, 0, 1);
+  return MONTHS.map(function (i) {
+    return dates.month(date, i);
+  });
+}
+function firstVisibleDay(date, localizer) {
+  var firstOfMonth = dates.startOf(date, 'month');
+  return dates.startOf(firstOfMonth, 'week', localizer.startOfWeek());
+}
+function lastVisibleDay(date, localizer) {
+  var endOfMonth = dates.endOf(date, 'month');
+  return dates.endOf(endOfMonth, 'week', localizer.startOfWeek());
+}
+function visibleDays(date, localizer) {
+  var current = firstVisibleDay(date, localizer),
+    last = lastVisibleDay(date, localizer),
+    days = [];
+  while (dates.lte(current, last, 'day')) {
+    days.push(current);
+    current = dates.add(current, 1, 'day');
+  }
+  return days;
+}
+function ceil(date, unit) {
+  var floor = dates.startOf(date, unit);
+  return dates.eq(floor, date) ? floor : dates.add(floor, 1, unit);
+}
+function range(start, end) {
+  var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'day';
+  var current = start,
+    days = [];
+  while (dates.lte(current, end, unit)) {
+    days.push(current);
+    current = dates.add(current, 1, unit);
+  }
+  return days;
+}
+function merge(date, time) {
+  if (time == null && date == null) return null;
+  if (time == null) time = new Date();
+  if (date == null) date = new Date();
+  date = dates.startOf(date, 'day');
+  date = dates.hours(date, dates.hours(time));
+  date = dates.minutes(date, dates.minutes(time));
+  date = dates.seconds(date, dates.seconds(time));
+  return dates.milliseconds(date, dates.milliseconds(time));
+}
+function eqTime(dateA, dateB) {
+  return dates.hours(dateA) === dates.hours(dateB) && dates.minutes(dateA) === dates.minutes(dateB) && dates.seconds(dateA) === dates.seconds(dateB);
+}
+function isJustDate(date) {
+  return dates.hours(date) === 0 && dates.minutes(date) === 0 && dates.seconds(date) === 0 && dates.milliseconds(date) === 0;
+}
+function duration(start, end, unit, firstOfWeek) {
+  if (unit === 'day') unit = 'date';
+  return Math.abs(
+  // eslint-disable-next-line import/namespace
+  dates[unit](start, undefined, firstOfWeek) -
+  // eslint-disable-next-line import/namespace
+  dates[unit](end, undefined, firstOfWeek));
+}
+function diff(dateA, dateB, unit) {
+  if (!unit || unit === 'milliseconds') return Math.abs(+dateA - +dateB);
+
+  // the .round() handles an edge case
+  // with DST where the total won't be exact
+  // since one day in the range may be shorter/longer by an hour
+  return Math.round(Math.abs(+dates.startOf(dateA, unit) / MILLI[unit] - +dates.startOf(dateB, unit) / MILLI[unit]));
+}
+function total(date, unit) {
+  var ms = date.getTime(),
+    div = 1;
+  switch (unit) {
+    case 'week':
+      div *= 7;
+    case 'day':
+      div *= 24;
+    case 'hours':
+      div *= 60;
+    case 'minutes':
+      div *= 60;
+    case 'seconds':
+      div *= 1000;
+  }
+  return ms / div;
+}
+function week(date) {
+  var d = new Date(date);
+  d.setHours(0, 0, 0);
+  d.setDate(d.getDate() + 4 - (d.getDay() || 7));
+  return Math.ceil(((d - new Date(d.getFullYear(), 0, 1)) / 8.64e7 + 1) / 7);
+}
+function today() {
+  return dates.startOf(new Date(), 'day');
+}
+function yesterday() {
+  return dates.add(dates.startOf(new Date(), 'day'), -1, 'day');
+}
+function tomorrow() {
+  return dates.add(dates.startOf(new Date(), 'day'), 1, 'day');
+}

node_modules/react-big-calendar/lib/utils/eventLevels.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.endOfRange = endOfRange;
+exports.eventLevels = eventLevels;
+exports.eventSegments = eventSegments;
+exports.inRange = inRange;
+exports.segsOverlap = segsOverlap;
+exports.sortEvents = sortEvents;
+exports.sortWeekEvents = sortWeekEvents;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _findIndex = _interopRequireDefault(require("lodash/findIndex"));
+function endOfRange(_ref) {
+  var dateRange = _ref.dateRange,
+    _ref$unit = _ref.unit,
+    unit = _ref$unit === void 0 ? 'day' : _ref$unit,
+    localizer = _ref.localizer;
+  return {
+    first: dateRange[0],
+    last: localizer.add(dateRange[dateRange.length - 1], 1, unit)
+  };
+}
+
+// properly calculating segments requires working with dates in
+// the timezone we're working with, so we use the localizer
+function eventSegments(event, range, accessors, localizer) {
+  var _endOfRange = endOfRange({
+      dateRange: range,
+      localizer: localizer
+    }),
+    first = _endOfRange.first,
+    last = _endOfRange.last;
+  var slots = localizer.diff(first, last, 'day');
+  var start = localizer.max(localizer.startOf(accessors.start(event), 'day'), first);
+  var end = localizer.min(localizer.ceil(accessors.end(event), 'day'), last);
+  var padding = (0, _findIndex.default)(range, function (x) {
+    return localizer.isSameDate(x, start);
+  });
+  var span = localizer.diff(start, end, 'day');
+  span = Math.min(span, slots);
+  // The segmentOffset is necessary when adjusting for timezones
+  // ahead of the browser timezone
+  span = Math.max(span - localizer.segmentOffset, 1);
+  return {
+    event: event,
+    span: span,
+    left: padding + 1,
+    right: Math.max(padding + span, 1)
+  };
+}
+function eventLevels(rowSegments) {
+  var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity;
+  var i,
+    j,
+    seg,
+    levels = [],
+    extra = [];
+  for (i = 0; i < rowSegments.length; i++) {
+    seg = rowSegments[i];
+    for (j = 0; j < levels.length; j++) if (!segsOverlap(seg, levels[j])) break;
+    if (j >= limit) {
+      extra.push(seg);
+    } else {
+      ;
+      (levels[j] || (levels[j] = [])).push(seg);
+    }
+  }
+  for (i = 0; i < levels.length; i++) {
+    levels[i].sort(function (a, b) {
+      return a.left - b.left;
+    }); //eslint-disable-line
+  }
+  return {
+    levels: levels,
+    extra: extra
+  };
+}
+function inRange(e, start, end, accessors, localizer) {
+  var event = {
+    start: accessors.start(e),
+    end: accessors.end(e)
+  };
+  var range = {
+    start: start,
+    end: end
+  };
+  return localizer.inEventRange({
+    event: event,
+    range: range
+  });
+}
+function segsOverlap(seg, otherSegs) {
+  return otherSegs.some(function (otherSeg) {
+    return otherSeg.left <= seg.right && otherSeg.right >= seg.left;
+  });
+}
+function sortWeekEvents(events, accessors, localizer) {
+  var base = (0, _toConsumableArray2.default)(events);
+  var multiDayEvents = [];
+  var standardEvents = [];
+  base.forEach(function (event) {
+    var startCheck = accessors.start(event);
+    var endCheck = accessors.end(event);
+    if (localizer.daySpan(startCheck, endCheck) > 1) {
+      multiDayEvents.push(event);
+    } else {
+      standardEvents.push(event);
+    }
+  });
+  var multiSorted = multiDayEvents.sort(function (a, b) {
+    return sortEvents(a, b, accessors, localizer);
+  });
+  var standardSorted = standardEvents.sort(function (a, b) {
+    return sortEvents(a, b, accessors, localizer);
+  });
+  return [].concat((0, _toConsumableArray2.default)(multiSorted), (0, _toConsumableArray2.default)(standardSorted));
+}
+function sortEvents(eventA, eventB, accessors, localizer) {
+  var evtA = {
+    start: accessors.start(eventA),
+    end: accessors.end(eventA),
+    allDay: accessors.allDay(eventA)
+  };
+  var evtB = {
+    start: accessors.start(eventB),
+    end: accessors.end(eventB),
+    allDay: accessors.allDay(eventB)
+  };
+  return localizer.sortEvents({
+    evtA: evtA,
+    evtB: evtB
+  });
+}

node_modules/react-big-calendar/lib/utils/helpers.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instanceId = instanceId;
+exports.isFirstFocusedRender = isFirstFocusedRender;
+exports.notify = notify;
+var idCount = 0;
+function uniqueId(prefix) {
+  return '' + ((prefix == null ? '' : prefix) + ++idCount);
+}
+function notify(handler, args) {
+  handler && handler.apply(null, [].concat(args));
+}
+function instanceId(component) {
+  var suffix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  component.__id || (component.__id = uniqueId('rw_'));
+  return (component.props.id || component.__id) + suffix;
+}
+function isFirstFocusedRender(component) {
+  return component._firstFocus || component.state.focused && (component._firstFocus = true);
+}

node_modules/react-big-calendar/lib/utils/layout-algorithms/no-overlap.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _overlap = _interopRequireDefault(require("./overlap"));
+function getMaxIdxDFS(node, maxIdx, visited) {
+  for (var i = 0; i < node.friends.length; ++i) {
+    if (visited.indexOf(node.friends[i]) > -1) continue;
+    maxIdx = maxIdx > node.friends[i].idx ? maxIdx : node.friends[i].idx;
+    // TODO : trace it by not object but kinda index or something for performance
+    visited.push(node.friends[i]);
+    var newIdx = getMaxIdxDFS(node.friends[i], maxIdx, visited);
+    maxIdx = maxIdx > newIdx ? maxIdx : newIdx;
+  }
+  return maxIdx;
+}
+function _default(_ref) {
+  var events = _ref.events,
+    minimumStartDifference = _ref.minimumStartDifference,
+    slotMetrics = _ref.slotMetrics,
+    accessors = _ref.accessors;
+  var styledEvents = (0, _overlap.default)({
+    events: events,
+    minimumStartDifference: minimumStartDifference,
+    slotMetrics: slotMetrics,
+    accessors: accessors
+  });
+  styledEvents.sort(function (a, b) {
+    a = a.style;
+    b = b.style;
+    if (a.top !== b.top) return a.top > b.top ? 1 : -1;else if (a.height !== b.height) return a.top + a.height < b.top + b.height ? 1 : -1;else return 0;
+  });
+  for (var i = 0; i < styledEvents.length; ++i) {
+    styledEvents[i].friends = [];
+    delete styledEvents[i].style.left;
+    delete styledEvents[i].style.left;
+    delete styledEvents[i].idx;
+    delete styledEvents[i].size;
+  }
+  for (var _i2 = 0; _i2 < styledEvents.length - 1; ++_i2) {
+    var se1 = styledEvents[_i2];
+    var y1 = se1.style.top;
+    var y2 = se1.style.top + se1.style.height;
+    for (var j = _i2 + 1; j < styledEvents.length; ++j) {
+      var se2 = styledEvents[j];
+      var y3 = se2.style.top;
+      var y4 = se2.style.top + se2.style.height;
+      if (y3 >= y1 && y4 <= y2 || y4 > y1 && y4 <= y2 || y3 >= y1 && y3 < y2) {
+        // TODO : hashmap would be effective for performance
+        se1.friends.push(se2);
+        se2.friends.push(se1);
+      }
+    }
+  }
+  for (var _i4 = 0; _i4 < styledEvents.length; ++_i4) {
+    var se = styledEvents[_i4];
+    var bitmap = [];
+    for (var _j2 = 0; _j2 < 100; ++_j2) bitmap.push(1); // 1 means available
+
+    for (var _j4 = 0; _j4 < se.friends.length; ++_j4) if (se.friends[_j4].idx !== undefined) bitmap[se.friends[_j4].idx] = 0; // 0 means reserved
+
+    se.idx = bitmap.indexOf(1);
+  }
+  for (var _i6 = 0; _i6 < styledEvents.length; ++_i6) {
+    var size = 0;
+    if (styledEvents[_i6].size) continue;
+    var allFriends = [];
+    var maxIdx = getMaxIdxDFS(styledEvents[_i6], 0, allFriends);
+    size = 100 / (maxIdx + 1);
+    styledEvents[_i6].size = size;
+    for (var _j6 = 0; _j6 < allFriends.length; ++_j6) allFriends[_j6].size = size;
+  }
+  for (var _i8 = 0; _i8 < styledEvents.length; ++_i8) {
+    var e = styledEvents[_i8];
+    e.style.left = e.idx * e.size;
+
+    // stretch to maximum
+    var _maxIdx = 0;
+    for (var _j8 = 0; _j8 < e.friends.length; ++_j8) {
+      var idx = e.friends[_j8].idx;
+      _maxIdx = _maxIdx > idx ? _maxIdx : idx;
+    }
+    if (_maxIdx <= e.idx) e.size = 100 - e.idx * e.size;
+
+    // padding between events
+    // for this feature, `width` is not percentage based unit anymore
+    // it will be used with calc()
+    var padding = e.idx === 0 ? 0 : 3;
+    e.style.width = "calc(".concat(e.size, "% - ").concat(padding, "px)");
+    e.style.height = "calc(".concat(e.style.height, "% - 2px)");
+    e.style.xOffset = "calc(".concat(e.style.left, "% + ").concat(padding, "px)");
+  }
+  return styledEvents;
+}

node_modules/react-big-calendar/lib/utils/layout-algorithms/overlap.js

@@ -0,0 +1,215 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getStyledEvents;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _sortBy = _interopRequireDefault(require("lodash/sortBy"));
+var Event = /*#__PURE__*/function () {
+  function Event(data, _ref) {
+    var accessors = _ref.accessors,
+      slotMetrics = _ref.slotMetrics;
+    (0, _classCallCheck2.default)(this, Event);
+    var _slotMetrics$getRange = slotMetrics.getRange(accessors.start(data), accessors.end(data)),
+      start = _slotMetrics$getRange.start,
+      startDate = _slotMetrics$getRange.startDate,
+      end = _slotMetrics$getRange.end,
+      endDate = _slotMetrics$getRange.endDate,
+      top = _slotMetrics$getRange.top,
+      height = _slotMetrics$getRange.height;
+    this.start = start;
+    this.end = end;
+    this.startMs = +startDate;
+    this.endMs = +endDate;
+    this.top = top;
+    this.height = height;
+    this.data = data;
+  }
+
+  /**
+   * The event's width without any overlap.
+   */
+  return (0, _createClass2.default)(Event, [{
+    key: "_width",
+    get: function get() {
+      // The container event's width is determined by the maximum number of
+      // events in any of its rows.
+      if (this.rows) {
+        var columns = this.rows.reduce(function (max, row) {
+          return Math.max(max, row.leaves.length + 1);
+        },
+        // add itself
+        0) + 1; // add the container
+
+        return 100 / columns;
+      }
+
+      // The row event's width is the space left by the container, divided
+      // among itself and its leaves.
+      if (this.leaves) {
+        var availableWidth = 100 - this.container._width;
+        return availableWidth / (this.leaves.length + 1);
+      }
+
+      // The leaf event's width is determined by its row's width
+      return this.row._width;
+    }
+
+    /**
+     * The event's calculated width, possibly with extra width added for
+     * overlapping effect.
+     */
+  }, {
+    key: "width",
+    get: function get() {
+      var noOverlap = this._width;
+      var overlap = Math.min(100, this._width * 1.7);
+
+      // Containers can always grow.
+      if (this.rows) {
+        return overlap;
+      }
+
+      // Rows can grow if they have leaves.
+      if (this.leaves) {
+        return this.leaves.length > 0 ? overlap : noOverlap;
+      }
+
+      // Leaves can grow unless they're the last item in a row.
+      var leaves = this.row.leaves;
+      var index = leaves.indexOf(this);
+      return index === leaves.length - 1 ? noOverlap : overlap;
+    }
+  }, {
+    key: "xOffset",
+    get: function get() {
+      // Containers have no offset.
+      if (this.rows) return 0;
+
+      // Rows always start where their container ends.
+      if (this.leaves) return this.container._width;
+
+      // Leaves are spread out evenly on the space left by its row.
+      var _this$row = this.row,
+        leaves = _this$row.leaves,
+        xOffset = _this$row.xOffset,
+        _width = _this$row._width;
+      var index = leaves.indexOf(this) + 1;
+      return xOffset + index * _width;
+    }
+  }]);
+}();
+/**
+ * Return true if event a and b is considered to be on the same row.
+ */
+function onSameRow(a, b, minimumStartDifference) {
+  return (
+    // Occupies the same start slot.
+    Math.abs(b.start - a.start) < minimumStartDifference ||
+    // A's start slot overlaps with b's end slot.
+    b.start > a.start && b.start < a.end
+  );
+}
+function sortByRender(events) {
+  var sortedByTime = (0, _sortBy.default)(events, ['startMs', function (e) {
+    return -e.endMs;
+  }]);
+  var sorted = [];
+  while (sortedByTime.length > 0) {
+    var event = sortedByTime.shift();
+    sorted.push(event);
+    for (var i = 0; i < sortedByTime.length; i++) {
+      var test = sortedByTime[i];
+
+      // Still inside this event, look for next.
+      if (event.endMs > test.startMs) continue;
+
+      // We've found the first event of the next event group.
+      // If that event is not right next to our current event, we have to
+      // move it here.
+      if (i > 0) {
+        var _event = sortedByTime.splice(i, 1)[0];
+        sorted.push(_event);
+      }
+
+      // We've already found the next event group, so stop looking.
+      break;
+    }
+  }
+  return sorted;
+}
+function getStyledEvents(_ref2) {
+  var events = _ref2.events,
+    minimumStartDifference = _ref2.minimumStartDifference,
+    slotMetrics = _ref2.slotMetrics,
+    accessors = _ref2.accessors;
+  // Create proxy events and order them so that we don't have
+  // to fiddle with z-indexes.
+  var proxies = events.map(function (event) {
+    return new Event(event, {
+      slotMetrics: slotMetrics,
+      accessors: accessors
+    });
+  });
+  var eventsInRenderOrder = sortByRender(proxies);
+
+  // Group overlapping events, while keeping order.
+  // Every event is always one of: container, row or leaf.
+  // Containers can contain rows, and rows can contain leaves.
+  var containerEvents = [];
+  var _loop = function _loop() {
+    var event = eventsInRenderOrder[i];
+
+    // Check if this event can go into a container event.
+    var container = containerEvents.find(function (c) {
+      return c.end > event.start || Math.abs(event.start - c.start) < minimumStartDifference;
+    });
+
+    // Couldn't find a container — that means this event is a container.
+    if (!container) {
+      event.rows = [];
+      containerEvents.push(event);
+      return 1; // continue
+    }
+
+    // Found a container for the event.
+    event.container = container;
+
+    // Check if the event can be placed in an existing row.
+    // Start looking from behind.
+    var row = null;
+    for (var j = container.rows.length - 1; !row && j >= 0; j--) {
+      if (onSameRow(container.rows[j], event, minimumStartDifference)) {
+        row = container.rows[j];
+      }
+    }
+    if (row) {
+      // Found a row, so add it.
+      row.leaves.push(event);
+      event.row = row;
+    } else {
+      // Couldn't find a row – that means this event is a row.
+      event.leaves = [];
+      container.rows.push(event);
+    }
+  };
+  for (var i = 0; i < eventsInRenderOrder.length; i++) {
+    if (_loop()) continue;
+  }
+
+  // Return the original events, along with their styles.
+  return eventsInRenderOrder.map(function (event) {
+    return {
+      event: event.data,
+      style: {
+        top: event.top,
+        height: event.height,
+        width: event.width,
+        xOffset: Math.max(0, event.xOffset)
+      }
+    };
+  });
+}

node_modules/react-big-calendar/lib/utils/messages.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = messages;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var defaultMessages = {
+  date: 'Date',
+  time: 'Time',
+  event: 'Event',
+  allDay: 'All Day',
+  week: 'Week',
+  work_week: 'Work Week',
+  day: 'Day',
+  month: 'Month',
+  previous: 'Back',
+  next: 'Next',
+  yesterday: 'Yesterday',
+  tomorrow: 'Tomorrow',
+  today: 'Today',
+  agenda: 'Agenda',
+  noEventsInRange: 'There are no events in this range.',
+  showMore: function showMore(total) {
+    return "+".concat(total, " more");
+  }
+};
+function messages(msgs) {
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, defaultMessages), msgs);
+}

node_modules/react-big-calendar/lib/utils/move.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = moveDate;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _invariant = _interopRequireDefault(require("invariant"));
+var _constants = require("./constants");
+var _Views = _interopRequireDefault(require("../Views"));
+var _excluded = ["action", "date", "today"];
+function moveDate(View, _ref) {
+  var action = _ref.action,
+    date = _ref.date,
+    today = _ref.today,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  View = typeof View === 'string' ? _Views.default[View] : View;
+  switch (action) {
+    case _constants.navigate.TODAY:
+      date = today || new Date();
+      break;
+    case _constants.navigate.DATE:
+      break;
+    default:
+      (0, _invariant.default)(View && typeof View.navigate === 'function', 'Calendar View components must implement a static `.navigate(date, action)` method.s');
+      date = View.navigate(date, action, props);
+  }
+  return date;
+}

node_modules/react-big-calendar/lib/utils/propTypes.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.views = exports.dateRangeFormat = exports.dateFormat = exports.accessor = exports.DayLayoutAlgorithmPropType = void 0;
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _constants = require("./constants");
+var viewNames = Object.keys(_constants.views).map(function (k) {
+  return _constants.views[k];
+});
+var accessor = exports.accessor = _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.func]);
+var dateFormat = exports.dateFormat = _propTypes.default.any;
+var dateRangeFormat = exports.dateRangeFormat = _propTypes.default.func;
+
+/**
+ * accepts either an array of builtin view names:
+ *
+ * ```
+ * views={['month', 'day', 'agenda']}
+ * ```
+ *
+ * or an object hash of the view name and the component (or boolean for builtin)
+ *
+ * ```
+ * views={{
+ *   month: true,
+ *   week: false,
+ *   workweek: WorkWeekViewComponent,
+ * }}
+ * ```
+ */
+
+var views = exports.views = _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.oneOf(viewNames)), _propTypes.default.objectOf(function (prop, key) {
+  var isBuiltinView = viewNames.indexOf(key) !== -1 && typeof prop[key] === 'boolean';
+  if (isBuiltinView) {
+    return null;
+  } else {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    return _propTypes.default.elementType.apply(_propTypes.default, [prop, key].concat(args));
+  }
+})]);
+var DayLayoutAlgorithmPropType = exports.DayLayoutAlgorithmPropType = _propTypes.default.oneOfType([_propTypes.default.oneOf(['overlap', 'no-overlap']), _propTypes.default.func]);

node_modules/react-big-calendar/lib/utils/selection.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dateCellSelection = dateCellSelection;
+exports.getSlotAtX = getSlotAtX;
+exports.isSelected = isSelected;
+exports.pointInBox = pointInBox;
+exports.slotWidth = slotWidth;
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+function isSelected(event, selected) {
+  if (!event || selected == null) return false;
+  return (0, _isEqual.default)(event, selected);
+}
+function slotWidth(rowBox, slots) {
+  var rowWidth = rowBox.right - rowBox.left;
+  var cellWidth = rowWidth / slots;
+  return cellWidth;
+}
+function getSlotAtX(rowBox, x, rtl, slots) {
+  var cellWidth = slotWidth(rowBox, slots);
+  return rtl ? slots - 1 - Math.floor((x - rowBox.left) / cellWidth) : Math.floor((x - rowBox.left) / cellWidth);
+}
+function pointInBox(box, _ref) {
+  var x = _ref.x,
+    y = _ref.y;
+  return y >= box.top && y <= box.bottom && x >= box.left && x <= box.right;
+}
+function dateCellSelection(start, rowBox, box, slots, rtl) {
+  var startIdx = -1;
+  var endIdx = -1;
+  var lastSlotIdx = slots - 1;
+  var cellWidth = slotWidth(rowBox, slots);
+
+  // cell under the mouse
+  var currentSlot = getSlotAtX(rowBox, box.x, rtl, slots);
+
+  // Identify row as either the initial row
+  // or the row under the current mouse point
+  var isCurrentRow = rowBox.top < box.y && rowBox.bottom > box.y;
+  var isStartRow = rowBox.top < start.y && rowBox.bottom > start.y;
+
+  // this row's position relative to the start point
+  var isAboveStart = start.y > rowBox.bottom;
+  var isBelowStart = rowBox.top > start.y;
+  var isBetween = box.top < rowBox.top && box.bottom > rowBox.bottom;
+
+  // this row is between the current and start rows, so entirely selected
+  if (isBetween) {
+    startIdx = 0;
+    endIdx = lastSlotIdx;
+  }
+  if (isCurrentRow) {
+    if (isBelowStart) {
+      startIdx = 0;
+      endIdx = currentSlot;
+    } else if (isAboveStart) {
+      startIdx = currentSlot;
+      endIdx = lastSlotIdx;
+    }
+  }
+  if (isStartRow) {
+    // select the cell under the initial point
+    startIdx = endIdx = rtl ? lastSlotIdx - Math.floor((start.x - rowBox.left) / cellWidth) : Math.floor((start.x - rowBox.left) / cellWidth);
+    if (isCurrentRow) {
+      if (currentSlot < startIdx) startIdx = currentSlot;else endIdx = currentSlot; //select current range
+    } else if (start.y < box.y) {
+      // the current row is below start row
+      // select cells to the right of the start cell
+      endIdx = lastSlotIdx;
+    } else {
+      // select cells to the left of the start cell
+      startIdx = 0;
+    }
+  }
+  return {
+    startIdx: startIdx,
+    endIdx: endIdx
+  };
+}