Latest repo

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);
+    }
+  });
+}