add file

node_modules/vuetify/es5/components/VCalendar/VCalendar.js

@@ -0,0 +1,384 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _calendarWithEvents = _interopRequireDefault(require("./mixins/calendar-with-events"));
+
+var _props = _interopRequireDefault(require("./util/props"));
+
+var _timestamp = require("./util/timestamp");
+
+var _VCalendarMonthly = _interopRequireDefault(require("./VCalendarMonthly"));
+
+var _VCalendarDaily = _interopRequireDefault(require("./VCalendarDaily"));
+
+var _VCalendarWeekly = _interopRequireDefault(require("./VCalendarWeekly"));
+
+var _VCalendarCategory = _interopRequireDefault(require("./VCalendarCategory"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _calendarWithEvents.default.extend({
+  name: 'v-calendar',
+  props: _objectSpread({}, _props.default.calendar, {}, _props.default.weeks, {}, _props.default.intervals, {}, _props.default.category),
+  data: function data() {
+    return {
+      lastStart: null,
+      lastEnd: null
+    };
+  },
+  computed: {
+    parsedValue: function parsedValue() {
+      return (0, _timestamp.validateTimestamp)(this.value) ? (0, _timestamp.parseTimestamp)(this.value, true) : this.parsedStart || this.times.today;
+    },
+    parsedCategoryDays: function parsedCategoryDays() {
+      return parseInt(this.categoryDays) || 1;
+    },
+    renderProps: function renderProps() {
+      var around = this.parsedValue;
+      var component = null;
+      var maxDays = this.maxDays;
+      var weekdays = this.parsedWeekdays;
+      var categories = this.parsedCategories;
+      var start = around;
+      var end = around;
+
+      switch (this.type) {
+        case 'month':
+          component = _VCalendarMonthly.default;
+          start = (0, _timestamp.getStartOfMonth)(around);
+          end = (0, _timestamp.getEndOfMonth)(around);
+          break;
+
+        case 'week':
+          component = _VCalendarDaily.default;
+          start = this.getStartOfWeek(around);
+          end = this.getEndOfWeek(around);
+          maxDays = 7;
+          break;
+
+        case 'day':
+          component = _VCalendarDaily.default;
+          maxDays = 1;
+          weekdays = [start.weekday];
+          break;
+
+        case '4day':
+          component = _VCalendarDaily.default;
+          end = (0, _timestamp.relativeDays)((0, _timestamp.copyTimestamp)(end), _timestamp.nextDay, 4);
+          (0, _timestamp.updateFormatted)(end);
+          maxDays = 4;
+          weekdays = [start.weekday, (start.weekday + 1) % 7, (start.weekday + 2) % 7, (start.weekday + 3) % 7];
+          break;
+
+        case 'custom-weekly':
+          component = _VCalendarWeekly.default;
+          start = this.parsedStart || around;
+          end = this.parsedEnd;
+          break;
+
+        case 'custom-daily':
+          component = _VCalendarDaily.default;
+          start = this.parsedStart || around;
+          end = this.parsedEnd;
+          break;
+
+        case 'category':
+          var days = this.parsedCategoryDays;
+          component = _VCalendarCategory.default;
+          end = (0, _timestamp.relativeDays)((0, _timestamp.copyTimestamp)(end), _timestamp.nextDay, days);
+          (0, _timestamp.updateFormatted)(end);
+          maxDays = days;
+          weekdays = [];
+
+          for (var i = 0; i < days; i++) {
+            weekdays.push((start.weekday + i) % 7);
+          }
+
+          categories = this.getCategoryList(categories);
+          break;
+
+        default:
+          throw new Error(this.type + ' is not a valid Calendar type');
+      }
+
+      return {
+        component: component,
+        start: start,
+        end: end,
+        maxDays: maxDays,
+        weekdays: weekdays,
+        categories: categories
+      };
+    },
+    eventWeekdays: function eventWeekdays() {
+      return this.renderProps.weekdays;
+    },
+    categoryMode: function categoryMode() {
+      return this.type === 'category';
+    },
+    title: function title() {
+      var _this$renderProps = this.renderProps,
+          start = _this$renderProps.start,
+          end = _this$renderProps.end;
+      var spanYears = start.year !== end.year;
+      var spanMonths = spanYears || start.month !== end.month;
+
+      if (spanYears) {
+        return this.monthShortFormatter(start, true) + ' ' + start.year + ' - ' + this.monthShortFormatter(end, true) + ' ' + end.year;
+      }
+
+      if (spanMonths) {
+        return this.monthShortFormatter(start, true) + ' - ' + this.monthShortFormatter(end, true) + ' ' + end.year;
+      } else {
+        return this.monthLongFormatter(start, false) + ' ' + start.year;
+      }
+    },
+    monthLongFormatter: function monthLongFormatter() {
+      return this.getFormatter({
+        timeZone: 'UTC',
+        month: 'long'
+      });
+    },
+    monthShortFormatter: function monthShortFormatter() {
+      return this.getFormatter({
+        timeZone: 'UTC',
+        month: 'short'
+      });
+    },
+    parsedCategories: function parsedCategories() {
+      return typeof this.categories === 'string' && this.categories ? this.categories.split(/\s*,\s*/) : Array.isArray(this.categories) ? this.categories : [];
+    }
+  },
+  watch: {
+    renderProps: 'checkChange'
+  },
+  mounted: function mounted() {
+    this.updateEventVisibility();
+    this.checkChange();
+  },
+  updated: function updated() {
+    window.requestAnimationFrame(this.updateEventVisibility);
+  },
+  methods: {
+    checkChange: function checkChange() {
+      var lastStart = this.lastStart,
+          lastEnd = this.lastEnd;
+      var _this$renderProps2 = this.renderProps,
+          start = _this$renderProps2.start,
+          end = _this$renderProps2.end;
+
+      if (!lastStart || !lastEnd || start.date !== lastStart.date || end.date !== lastEnd.date) {
+        this.lastStart = start;
+        this.lastEnd = end;
+        this.$emit('change', {
+          start: start,
+          end: end
+        });
+      }
+    },
+    move: function move() {
+      var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      var moved = (0, _timestamp.copyTimestamp)(this.parsedValue);
+      var forward = amount > 0;
+      var mover = forward ? _timestamp.nextDay : _timestamp.prevDay;
+      var limit = forward ? _timestamp.DAYS_IN_MONTH_MAX : _timestamp.DAY_MIN;
+      var times = forward ? amount : -amount;
+
+      while (--times >= 0) {
+        switch (this.type) {
+          case 'month':
+            moved.day = limit;
+            mover(moved);
+            break;
+
+          case 'week':
+            (0, _timestamp.relativeDays)(moved, mover, _timestamp.DAYS_IN_WEEK);
+            break;
+
+          case 'day':
+            (0, _timestamp.relativeDays)(moved, mover, 1);
+            break;
+
+          case '4day':
+            (0, _timestamp.relativeDays)(moved, mover, 4);
+            break;
+
+          case 'category':
+            (0, _timestamp.relativeDays)(moved, mover, this.parsedCategoryDays);
+            break;
+        }
+      }
+
+      (0, _timestamp.updateWeekday)(moved);
+      (0, _timestamp.updateFormatted)(moved);
+      (0, _timestamp.updateRelative)(moved, this.times.now);
+
+      if (this.value instanceof Date) {
+        this.$emit('input', (0, _timestamp.timestampToDate)(moved));
+      } else if (typeof this.value === 'number') {
+        this.$emit('input', (0, _timestamp.timestampToDate)(moved).getTime());
+      } else {
+        this.$emit('input', moved.date);
+      }
+
+      this.$emit('moved', moved);
+    },
+    next: function next() {
+      var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      this.move(amount);
+    },
+    prev: function prev() {
+      var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      this.move(-amount);
+    },
+    timeToY: function timeToY(time) {
+      var clamp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var c = this.$children[0];
+
+      if (c && c.timeToY) {
+        return c.timeToY(time, clamp);
+      } else {
+        return false;
+      }
+    },
+    timeDelta: function timeDelta(time) {
+      var c = this.$children[0];
+
+      if (c && c.timeDelta) {
+        return c.timeDelta(time);
+      } else {
+        return false;
+      }
+    },
+    minutesToPixels: function minutesToPixels(minutes) {
+      var c = this.$children[0];
+
+      if (c && c.minutesToPixels) {
+        return c.minutesToPixels(minutes);
+      } else {
+        return -1;
+      }
+    },
+    scrollToTime: function scrollToTime(time) {
+      var c = this.$children[0];
+
+      if (c && c.scrollToTime) {
+        return c.scrollToTime(time);
+      } else {
+        return false;
+      }
+    },
+    parseTimestamp: function parseTimestamp(input, required) {
+      return (0, _timestamp.parseTimestamp)(input, required, this.times.now);
+    },
+    timestampToDate: function timestampToDate(timestamp) {
+      return (0, _timestamp.timestampToDate)(timestamp);
+    },
+    getCategoryList: function getCategoryList(categories) {
+      var _this = this;
+
+      if (!this.noEvents) {
+        var categoryMap = categories.reduce(function (map, category, index) {
+          map[category] = {
+            index: index,
+            count: 0
+          };
+          return map;
+        }, Object.create(null));
+
+        if (!this.categoryHideDynamic || !this.categoryShowAll) {
+          var categoryLength = categories.length;
+          this.parsedEvents.forEach(function (ev) {
+            var category = ev.category;
+
+            if (typeof category !== 'string') {
+              category = _this.categoryForInvalid;
+            }
+
+            if (!category) {
+              return;
+            }
+
+            if (category in categoryMap) {
+              categoryMap[category].count++;
+            } else if (!_this.categoryHideDynamic) {
+              categoryMap[category] = {
+                index: categoryLength++,
+                count: 1
+              };
+            }
+          });
+        }
+
+        if (!this.categoryShowAll) {
+          for (var category in categoryMap) {
+            if (categoryMap[category].count === 0) {
+              delete categoryMap[category];
+            }
+          }
+        }
+
+        categories = Object.keys(categoryMap);
+      }
+
+      return categories;
+    }
+  },
+  render: function render(h) {
+    var _this2 = this;
+
+    var _this$renderProps3 = this.renderProps,
+        start = _this$renderProps3.start,
+        end = _this$renderProps3.end,
+        maxDays = _this$renderProps3.maxDays,
+        component = _this$renderProps3.component,
+        weekdays = _this$renderProps3.weekdays,
+        categories = _this$renderProps3.categories;
+    return h(component, {
+      staticClass: 'v-calendar',
+      class: {
+        'v-calendar-events': !this.noEvents
+      },
+      props: _objectSpread({}, this.$props, {
+        start: start.date,
+        end: end.date,
+        maxDays: maxDays,
+        weekdays: weekdays,
+        categories: categories
+      }),
+      directives: [{
+        modifiers: {
+          quiet: true
+        },
+        name: 'resize',
+        value: this.updateEventVisibility
+      }],
+      on: _objectSpread({}, this.$listeners, {
+        'click:date': function clickDate(day) {
+          if (_this2.$listeners['input']) {
+            _this2.$emit('input', day.date);
+          }
+
+          if (_this2.$listeners['click:date']) {
+            _this2.$emit('click:date', day);
+          }
+        }
+      }),
+      scopedSlots: this.getScopedSlots()
+    });
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendar.js.map

node_modules/vuetify/es5/components/VCalendar/VCalendarCategory.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VCalendar/VCalendarCategory.sass");
+
+var _VCalendarDaily = _interopRequireDefault(require("./VCalendarDaily"));
+
+var _helpers = require("../../util/helpers");
+
+var _props = _interopRequireDefault(require("./util/props"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _VCalendarDaily.default.extend({
+  name: 'v-calendar-category',
+  props: _props.default.category,
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-calendar-daily': true,
+        'v-calendar-category': true
+      }, this.themeClasses);
+    },
+    parsedCategories: function parsedCategories() {
+      return typeof this.categories === 'string' && this.categories ? this.categories.split(/\s*,\s*/) : Array.isArray(this.categories) ? this.categories : [];
+    }
+  },
+  methods: {
+    genDayHeader: function genDayHeader(day, index) {
+      var _this = this;
+
+      var data = {
+        staticClass: 'v-calendar-category__columns'
+      };
+
+      var scope = _objectSpread({
+        week: this.days
+      }, day, {
+        index: index
+      });
+
+      var children = this.parsedCategories.map(function (category) {
+        return _this.genDayHeaderCategory(day, _this.getCategoryScope(scope, category));
+      });
+      return [this.$createElement('div', data, children)];
+    },
+    getCategoryScope: function getCategoryScope(scope, category) {
+      return _objectSpread({}, scope, {
+        category: category === this.categoryForInvalid ? null : category
+      });
+    },
+    genDayHeaderCategory: function genDayHeaderCategory(day, scope) {
+      var _this2 = this;
+
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-category__column-header',
+        on: this.getDefaultMouseEventHandlers(':day-category', function (e) {
+          return _this2.getCategoryScope(_this2.getSlotScope(day), scope.category);
+        })
+      }, [(0, _helpers.getSlot)(this, 'category', scope) || this.genDayHeaderCategoryTitle(scope.category), (0, _helpers.getSlot)(this, 'day-header', scope)]);
+    },
+    genDayHeaderCategoryTitle: function genDayHeaderCategoryTitle(category) {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-category__category'
+      }, category === null ? this.categoryForInvalid : category);
+    },
+    genDayBody: function genDayBody(day) {
+      var _this3 = this;
+
+      var data = {
+        staticClass: 'v-calendar-category__columns'
+      };
+      var children = this.parsedCategories.map(function (category) {
+        return _this3.genDayBodyCategory(day, category);
+      });
+      return [this.$createElement('div', data, children)];
+    },
+    genDayBodyCategory: function genDayBodyCategory(day, category) {
+      var _this4 = this;
+
+      var data = {
+        staticClass: 'v-calendar-category__column',
+        on: this.getDefaultMouseEventHandlers(':time-category', function (e) {
+          return _this4.getCategoryScope(_this4.getSlotScope(_this4.getTimestampAtEvent(e, day)), category);
+        })
+      };
+      var children = (0, _helpers.getSlot)(this, 'day-body', function () {
+        return _this4.getCategoryScope(_this4.getSlotScope(day), category);
+      });
+      return this.$createElement('div', data, children);
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendarCategory.js.map

node_modules/vuetify/es5/components/VCalendar/VCalendarDaily.js

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VCalendar/VCalendarDaily.sass");
+
+var _resize = _interopRequireDefault(require("../../directives/resize"));
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _calendarWithIntervals = _interopRequireDefault(require("./mixins/calendar-with-intervals"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _calendarWithIntervals.default.extend({
+  name: 'v-calendar-daily',
+  directives: {
+    Resize: _resize.default
+  },
+  data: function data() {
+    return {
+      scrollPush: 0
+    };
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-calendar-daily': true
+      }, this.themeClasses);
+    }
+  },
+  mounted: function mounted() {
+    this.init();
+  },
+  methods: {
+    init: function init() {
+      this.$nextTick(this.onResize);
+    },
+    onResize: function onResize() {
+      this.scrollPush = this.getScrollPush();
+    },
+    getScrollPush: function getScrollPush() {
+      var area = this.$refs.scrollArea;
+      var pane = this.$refs.pane;
+      return area && pane ? area.offsetWidth - pane.offsetWidth : 0;
+    },
+    genHead: function genHead() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__head',
+        style: {
+          marginRight: this.scrollPush + 'px'
+        }
+      }, [this.genHeadIntervals()].concat(_toConsumableArray(this.genHeadDays())));
+    },
+    genHeadIntervals: function genHeadIntervals() {
+      var width = (0, _helpers.convertToUnit)(this.intervalWidth);
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__intervals-head',
+        style: {
+          width: width
+        }
+      }, (0, _helpers.getSlot)(this, 'interval-header'));
+    },
+    genHeadDays: function genHeadDays() {
+      return this.days.map(this.genHeadDay);
+    },
+    genHeadDay: function genHeadDay(day, index) {
+      var _this = this;
+
+      return this.$createElement('div', {
+        key: day.date,
+        staticClass: 'v-calendar-daily_head-day',
+        class: this.getRelativeClasses(day),
+        on: this.getDefaultMouseEventHandlers(':day', function (_e) {
+          return _this.getSlotScope(day);
+        })
+      }, [this.genHeadWeekday(day), this.genHeadDayLabel(day)].concat(_toConsumableArray(this.genDayHeader(day, index))));
+    },
+    genDayHeader: function genDayHeader(day, index) {
+      var _this2 = this;
+
+      return (0, _helpers.getSlot)(this, 'day-header', function () {
+        return _objectSpread({
+          week: _this2.days
+        }, day, {
+          index: index
+        });
+      }) || [];
+    },
+    genHeadWeekday: function genHeadWeekday(day) {
+      var color = day.present ? this.color : undefined;
+      return this.$createElement('div', this.setTextColor(color, {
+        staticClass: 'v-calendar-daily_head-weekday'
+      }), this.weekdayFormatter(day, this.shortWeekdays));
+    },
+    genHeadDayLabel: function genHeadDayLabel(day) {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily_head-day-label'
+      }, (0, _helpers.getSlot)(this, 'day-label-header', day) || [this.genHeadDayButton(day)]);
+    },
+    genHeadDayButton: function genHeadDayButton(day) {
+      var color = day.present ? this.color : 'transparent';
+      return this.$createElement(_VBtn.default, {
+        props: {
+          color: color,
+          fab: true,
+          depressed: true
+        },
+        on: this.getMouseEventHandlers({
+          'click:date': {
+            event: 'click',
+            stop: true
+          },
+          'contextmenu:date': {
+            event: 'contextmenu',
+            stop: true,
+            prevent: true,
+            result: false
+          }
+        }, function (_e) {
+          return day;
+        })
+      }, this.dayFormatter(day, false));
+    },
+    genBody: function genBody() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__body'
+      }, [this.genScrollArea()]);
+    },
+    genScrollArea: function genScrollArea() {
+      return this.$createElement('div', {
+        ref: 'scrollArea',
+        staticClass: 'v-calendar-daily__scroll-area'
+      }, [this.genPane()]);
+    },
+    genPane: function genPane() {
+      return this.$createElement('div', {
+        ref: 'pane',
+        staticClass: 'v-calendar-daily__pane',
+        style: {
+          height: (0, _helpers.convertToUnit)(this.bodyHeight)
+        }
+      }, [this.genDayContainer()]);
+    },
+    genDayContainer: function genDayContainer() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__day-container'
+      }, [this.genBodyIntervals()].concat(_toConsumableArray(this.genDays())));
+    },
+    genDays: function genDays() {
+      return this.days.map(this.genDay);
+    },
+    genDay: function genDay(day, index) {
+      var _this3 = this;
+
+      return this.$createElement('div', {
+        key: day.date,
+        staticClass: 'v-calendar-daily__day',
+        class: this.getRelativeClasses(day),
+        on: this.getDefaultMouseEventHandlers(':time', function (e) {
+          return _this3.getSlotScope(_this3.getTimestampAtEvent(e, day));
+        })
+      }, [].concat(_toConsumableArray(this.genDayIntervals(index)), _toConsumableArray(this.genDayBody(day))));
+    },
+    genDayBody: function genDayBody(day) {
+      var _this4 = this;
+
+      return (0, _helpers.getSlot)(this, 'day-body', function () {
+        return _this4.getSlotScope(day);
+      }) || [];
+    },
+    genDayIntervals: function genDayIntervals(index) {
+      return this.intervals[index].map(this.genDayInterval);
+    },
+    genDayInterval: function genDayInterval(interval) {
+      var _this5 = this;
+
+      var height = (0, _helpers.convertToUnit)(this.intervalHeight);
+      var styler = this.intervalStyle || this.intervalStyleDefault;
+      var data = {
+        key: interval.time,
+        staticClass: 'v-calendar-daily__day-interval',
+        style: _objectSpread({
+          height: height
+        }, styler(interval))
+      };
+      var children = (0, _helpers.getSlot)(this, 'interval', function () {
+        return _this5.getSlotScope(interval);
+      });
+      return this.$createElement('div', data, children);
+    },
+    genBodyIntervals: function genBodyIntervals() {
+      var _this6 = this;
+
+      var width = (0, _helpers.convertToUnit)(this.intervalWidth);
+      var data = {
+        staticClass: 'v-calendar-daily__intervals-body',
+        style: {
+          width: width
+        },
+        on: this.getDefaultMouseEventHandlers(':interval', function (e) {
+          return _this6.getTimestampAtEvent(e, _this6.parsedStart);
+        })
+      };
+      return this.$createElement('div', data, this.genIntervalLabels());
+    },
+    genIntervalLabels: function genIntervalLabels() {
+      if (!this.intervals.length) return null;
+      return this.intervals[0].map(this.genIntervalLabel);
+    },
+    genIntervalLabel: function genIntervalLabel(interval) {
+      var height = (0, _helpers.convertToUnit)(this.intervalHeight);
+      var short = this.shortIntervals;
+      var shower = this.showIntervalLabel || this.showIntervalLabelDefault;
+      var show = shower(interval);
+      var label = show ? this.intervalFormatter(interval, short) : undefined;
+      return this.$createElement('div', {
+        key: interval.time,
+        staticClass: 'v-calendar-daily__interval',
+        style: {
+          height: height
+        }
+      }, [this.$createElement('div', {
+        staticClass: 'v-calendar-daily__interval-text'
+      }, label)]);
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      class: this.classes,
+      on: {
+        dragstart: function dragstart(e) {
+          e.preventDefault();
+        }
+      },
+      directives: [{
+        modifiers: {
+          quiet: true
+        },
+        name: 'resize',
+        value: this.onResize
+      }]
+    }, [!this.hideHeader ? this.genHead() : '', this.genBody()]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendarDaily.js.map

node_modules/vuetify/es5/components/VCalendar/VCalendarMonthly.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VCalendar/VCalendarWeekly.sass");
+
+var _VCalendarWeekly2 = _interopRequireDefault(require("./VCalendarWeekly"));
+
+var _timestamp = require("./util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Styles
+// Mixins
+// Util
+
+/* @vue/component */
+var _default = _VCalendarWeekly2.default.extend({
+  name: 'v-calendar-monthly',
+  computed: {
+    staticClass: function staticClass() {
+      return 'v-calendar-monthly v-calendar-weekly';
+    },
+    parsedStart: function parsedStart() {
+      return (0, _timestamp.getStartOfMonth)((0, _timestamp.parseTimestamp)(this.start, true));
+    },
+    parsedEnd: function parsedEnd() {
+      return (0, _timestamp.getEndOfMonth)((0, _timestamp.parseTimestamp)(this.end, true));
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendarMonthly.js.map

node_modules/vuetify/es5/components/VCalendar/VCalendarMonthly.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VCalendar/VCalendarMonthly.ts"],"names":[],"mappings":";;;;;;;AACA;;AAGA;;AAGA;;;;AAPA;AAGA;AAGA;;AAIA;eACe,0BAAgB,MAAhB,CAAuB;AACpC,EAAA,IAAI,EAAE,oBAD8B;AAGpC,EAAA,QAAQ,EAAE;AACR,IAAA,WADQ,yBACG;AACT,aAAO,sCAAP;AACD,KAHO;AAIR,IAAA,WAJQ,yBAIG;AACT,aAAO,gCAAgB,+BAAe,KAAK,KAApB,EAA2B,IAA3B,CAAhB,CAAP;AACD,KANO;AAOR,IAAA,SAPQ,uBAOC;AACP,aAAO,8BAAc,+BAAe,KAAK,GAApB,EAAyB,IAAzB,CAAd,CAAP;AACD;AATO;AAH0B,CAAvB,C","sourcesContent":["// Styles\nimport './VCalendarWeekly.sass'\n\n// Mixins\nimport VCalendarWeekly from './VCalendarWeekly'\n\n// Util\nimport { parseTimestamp, getStartOfMonth, getEndOfMonth } from './util/timestamp'\nimport { CalendarTimestamp } from 'vuetify/types'\n\n/* @vue/component */\nexport default VCalendarWeekly.extend({\n  name: 'v-calendar-monthly',\n\n  computed: {\n    staticClass (): string {\n      return 'v-calendar-monthly v-calendar-weekly'\n    },\n    parsedStart (): CalendarTimestamp {\n      return getStartOfMonth(parseTimestamp(this.start, true))\n    },\n    parsedEnd (): CalendarTimestamp {\n      return getEndOfMonth(parseTimestamp(this.end, true))\n    },\n  },\n\n})\n"],"sourceRoot":"","file":"VCalendarMonthly.js"}

node_modules/vuetify/es5/components/VCalendar/VCalendarWeekly.js

@@ -0,0 +1,216 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VCalendar/VCalendarWeekly.sass");
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _calendarBase = _interopRequireDefault(require("./mixins/calendar-base"));
+
+var _helpers = require("../../util/helpers");
+
+var _dateTimeUtils = require("../../util/dateTimeUtils");
+
+var _props = _interopRequireDefault(require("./util/props"));
+
+var _timestamp = require("./util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+/* @vue/component */
+var _default = _calendarBase.default.extend({
+  name: 'v-calendar-weekly',
+  props: _props.default.weeks,
+  computed: {
+    staticClass: function staticClass() {
+      return 'v-calendar-weekly';
+    },
+    classes: function classes() {
+      return this.themeClasses;
+    },
+    parsedMinWeeks: function parsedMinWeeks() {
+      return parseInt(this.minWeeks);
+    },
+    days: function days() {
+      var minDays = this.parsedMinWeeks * this.parsedWeekdays.length;
+      var start = this.getStartOfWeek(this.parsedStart);
+      var end = this.getEndOfWeek(this.parsedEnd);
+      return (0, _timestamp.createDayList)(start, end, this.times.today, this.weekdaySkips, Number.MAX_SAFE_INTEGER, minDays);
+    },
+    todayWeek: function todayWeek() {
+      var today = this.times.today;
+      var start = this.getStartOfWeek(today);
+      var end = this.getEndOfWeek(today);
+      return (0, _timestamp.createDayList)(start, end, today, this.weekdaySkips, this.parsedWeekdays.length, this.parsedWeekdays.length);
+    },
+    monthFormatter: function monthFormatter() {
+      if (this.monthFormat) {
+        return this.monthFormat;
+      }
+
+      var longOptions = {
+        timeZone: 'UTC',
+        month: 'long'
+      };
+      var shortOptions = {
+        timeZone: 'UTC',
+        month: 'short'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (_tms, short) {
+        return short ? shortOptions : longOptions;
+      });
+    }
+  },
+  methods: {
+    isOutside: function isOutside(day) {
+      var dayIdentifier = (0, _timestamp.getDayIdentifier)(day);
+      return dayIdentifier < (0, _timestamp.getDayIdentifier)(this.parsedStart) || dayIdentifier > (0, _timestamp.getDayIdentifier)(this.parsedEnd);
+    },
+    genHead: function genHead() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-weekly__head'
+      }, this.genHeadDays());
+    },
+    genHeadDays: function genHeadDays() {
+      var header = this.todayWeek.map(this.genHeadDay);
+
+      if (this.showWeek) {
+        header.unshift(this.$createElement('div', {
+          staticClass: 'v-calendar-weekly__head-weeknumber'
+        }));
+      }
+
+      return header;
+    },
+    genHeadDay: function genHeadDay(day, index) {
+      var outside = this.isOutside(this.days[index]);
+      var color = day.present ? this.color : undefined;
+      return this.$createElement('div', this.setTextColor(color, {
+        key: day.date,
+        staticClass: 'v-calendar-weekly__head-weekday',
+        class: this.getRelativeClasses(day, outside)
+      }), this.weekdayFormatter(day, this.shortWeekdays));
+    },
+    genWeeks: function genWeeks() {
+      var days = this.days;
+      var weekDays = this.parsedWeekdays.length;
+      var weeks = [];
+
+      for (var i = 0; i < days.length; i += weekDays) {
+        weeks.push(this.genWeek(days.slice(i, i + weekDays), this.getWeekNumber(days[i])));
+      }
+
+      return weeks;
+    },
+    genWeek: function genWeek(week, weekNumber) {
+      var _this = this;
+
+      var weekNodes = week.map(function (day, index) {
+        return _this.genDay(day, index, week);
+      });
+
+      if (this.showWeek) {
+        weekNodes.unshift(this.genWeekNumber(weekNumber));
+      }
+
+      return this.$createElement('div', {
+        key: week[0].date,
+        staticClass: 'v-calendar-weekly__week'
+      }, weekNodes);
+    },
+    getWeekNumber: function getWeekNumber(determineDay) {
+      return (0, _dateTimeUtils.weekNumber)(determineDay.year, determineDay.month - 1, determineDay.day, this.parsedWeekdays[0], parseInt(this.localeFirstDayOfYear));
+    },
+    genWeekNumber: function genWeekNumber(weekNumber) {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-weekly__weeknumber'
+      }, [this.$createElement('small', String(weekNumber))]);
+    },
+    genDay: function genDay(day, index, week) {
+      var outside = this.isOutside(day);
+      return this.$createElement('div', {
+        key: day.date,
+        staticClass: 'v-calendar-weekly__day',
+        class: this.getRelativeClasses(day, outside),
+        on: this.getDefaultMouseEventHandlers(':day', function (_e) {
+          return day;
+        })
+      }, [this.genDayLabel(day)].concat(_toConsumableArray((0, _helpers.getSlot)(this, 'day', function () {
+        return _objectSpread({
+          outside: outside,
+          index: index,
+          week: week
+        }, day);
+      }) || [])));
+    },
+    genDayLabel: function genDayLabel(day) {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-weekly__day-label'
+      }, (0, _helpers.getSlot)(this, 'day-label', day) || [this.genDayLabelButton(day)]);
+    },
+    genDayLabelButton: function genDayLabelButton(day) {
+      var color = day.present ? this.color : 'transparent';
+      var hasMonth = day.day === 1 && this.showMonthOnFirst;
+      return this.$createElement(_VBtn.default, {
+        props: {
+          color: color,
+          fab: true,
+          depressed: true,
+          small: true
+        },
+        on: this.getMouseEventHandlers({
+          'click:date': {
+            event: 'click',
+            stop: true
+          },
+          'contextmenu:date': {
+            event: 'contextmenu',
+            stop: true,
+            prevent: true,
+            result: false
+          }
+        }, function (_e) {
+          return day;
+        })
+      }, hasMonth ? this.monthFormatter(day, this.shortMonths) + ' ' + this.dayFormatter(day, false) : this.dayFormatter(day, false));
+    },
+    genDayMonth: function genDayMonth(day) {
+      var color = day.present ? this.color : undefined;
+      return this.$createElement('div', this.setTextColor(color, {
+        staticClass: 'v-calendar-weekly__day-month'
+      }), (0, _helpers.getSlot)(this, 'day-month', day) || this.monthFormatter(day, this.shortMonths));
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      staticClass: this.staticClass,
+      class: this.classes,
+      on: {
+        dragstart: function dragstart(e) {
+          e.preventDefault();
+        }
+      }
+    }, [!this.hideHeader ? this.genHead() : ''].concat(_toConsumableArray(this.genWeeks())));
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendarWeekly.js.map

node_modules/vuetify/es5/components/VCalendar/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VCalendar", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendar.default;
+  }
+});
+Object.defineProperty(exports, "VCalendarDaily", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendarDaily.default;
+  }
+});
+Object.defineProperty(exports, "VCalendarWeekly", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendarWeekly.default;
+  }
+});
+Object.defineProperty(exports, "VCalendarMonthly", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendarMonthly.default;
+  }
+});
+Object.defineProperty(exports, "VCalendarCategory", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendarCategory.default;
+  }
+});
+exports.default = void 0;
+
+var _VCalendar = _interopRequireDefault(require("./VCalendar"));
+
+var _VCalendarDaily = _interopRequireDefault(require("./VCalendarDaily"));
+
+var _VCalendarWeekly = _interopRequireDefault(require("./VCalendarWeekly"));
+
+var _VCalendarMonthly = _interopRequireDefault(require("./VCalendarMonthly"));
+
+var _VCalendarCategory = _interopRequireDefault(require("./VCalendarCategory"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  $_vuetify_subcomponents: {
+    VCalendar: _VCalendar.default,
+    VCalendarCategory: _VCalendarCategory.default,
+    VCalendarDaily: _VCalendarDaily.default,
+    VCalendarWeekly: _VCalendarWeekly.default,
+    VCalendarMonthly: _VCalendarMonthly.default
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VCalendar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VCalendar/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;;;eAIe;AACb,EAAA,uBAAuB,EAAE;AACvB,IAAA,SAAS,EAAT,kBADuB;AAEvB,IAAA,iBAAiB,EAAjB,0BAFuB;AAGvB,IAAA,cAAc,EAAd,uBAHuB;AAIvB,IAAA,eAAe,EAAf,wBAJuB;AAKvB,IAAA,gBAAgB,EAAhB;AALuB;AADZ,C","sourcesContent":["import VCalendar from './VCalendar'\nimport VCalendarDaily from './VCalendarDaily'\nimport VCalendarWeekly from './VCalendarWeekly'\nimport VCalendarMonthly from './VCalendarMonthly'\nimport VCalendarCategory from './VCalendarCategory'\n\nexport { VCalendar, VCalendarCategory, VCalendarDaily, VCalendarWeekly, VCalendarMonthly }\n\nexport default {\n  $_vuetify_subcomponents: {\n    VCalendar,\n    VCalendarCategory,\n    VCalendarDaily,\n    VCalendarWeekly,\n    VCalendarMonthly,\n  },\n}\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VCalendar/mixins/calendar-base.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _mixins = _interopRequireDefault(require("../../../util/mixins"));
+
+var _colorable = _interopRequireDefault(require("../../../mixins/colorable"));
+
+var _localable = _interopRequireDefault(require("../../../mixins/localable"));
+
+var _mouse = _interopRequireDefault(require("./mouse"));
+
+var _themeable = _interopRequireDefault(require("../../../mixins/themeable"));
+
+var _times = _interopRequireDefault(require("./times"));
+
+var _resize = _interopRequireDefault(require("../../../directives/resize"));
+
+var _props = _interopRequireDefault(require("../util/props"));
+
+var _timestamp = require("../util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Mixins
+// Directives
+// Util
+var _default = (0, _mixins.default)(_colorable.default, _localable.default, _mouse.default, _themeable.default, _times.default
+/* @vue/component */
+).extend({
+  name: 'calendar-base',
+  directives: {
+    Resize: _resize.default
+  },
+  props: _props.default.base,
+  computed: {
+    parsedWeekdays: function parsedWeekdays() {
+      return Array.isArray(this.weekdays) ? this.weekdays : (this.weekdays || '').split(',').map(function (x) {
+        return parseInt(x, 10);
+      });
+    },
+    weekdaySkips: function weekdaySkips() {
+      return (0, _timestamp.getWeekdaySkips)(this.parsedWeekdays);
+    },
+    weekdaySkipsReverse: function weekdaySkipsReverse() {
+      var reversed = this.weekdaySkips.slice();
+      reversed.reverse();
+      return reversed;
+    },
+    parsedStart: function parsedStart() {
+      return (0, _timestamp.parseTimestamp)(this.start, true);
+    },
+    parsedEnd: function parsedEnd() {
+      var start = this.parsedStart;
+      var end = this.end ? (0, _timestamp.parseTimestamp)(this.end) || start : start;
+      return (0, _timestamp.getTimestampIdentifier)(end) < (0, _timestamp.getTimestampIdentifier)(start) ? start : end;
+    },
+    days: function days() {
+      return (0, _timestamp.createDayList)(this.parsedStart, this.parsedEnd, this.times.today, this.weekdaySkips);
+    },
+    dayFormatter: function dayFormatter() {
+      if (this.dayFormat) {
+        return this.dayFormat;
+      }
+
+      var options = {
+        timeZone: 'UTC',
+        day: 'numeric'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (_tms, _short) {
+        return options;
+      });
+    },
+    weekdayFormatter: function weekdayFormatter() {
+      if (this.weekdayFormat) {
+        return this.weekdayFormat;
+      }
+
+      var longOptions = {
+        timeZone: 'UTC',
+        weekday: 'long'
+      };
+      var shortOptions = {
+        timeZone: 'UTC',
+        weekday: 'short'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (_tms, short) {
+        return short ? shortOptions : longOptions;
+      });
+    }
+  },
+  methods: {
+    getRelativeClasses: function getRelativeClasses(timestamp) {
+      var outside = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      return {
+        'v-present': timestamp.present,
+        'v-past': timestamp.past,
+        'v-future': timestamp.future,
+        'v-outside': outside
+      };
+    },
+    getStartOfWeek: function getStartOfWeek(timestamp) {
+      return (0, _timestamp.getStartOfWeek)(timestamp, this.parsedWeekdays, this.times.today);
+    },
+    getEndOfWeek: function getEndOfWeek(timestamp) {
+      return (0, _timestamp.getEndOfWeek)(timestamp, this.parsedWeekdays, this.times.today);
+    },
+    getFormatter: function getFormatter(options) {
+      return (0, _timestamp.createNativeLocaleFormatter)(this.locale, function (_tms, _short) {
+        return options;
+      });
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=calendar-base.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/calendar-with-events.js

@@ -0,0 +1,502 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../../src/components/VCalendar/mixins/calendar-with-events.sass");
+
+var _ripple = _interopRequireDefault(require("../../../directives/ripple"));
+
+var _calendarBase = _interopRequireDefault(require("./calendar-base"));
+
+var _helpers = require("../../../util/helpers");
+
+var _props = _interopRequireDefault(require("../util/props"));
+
+var _modes = require("../modes");
+
+var _timestamp = require("../util/timestamp");
+
+var _events = require("../util/events");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var WIDTH_FULL = 100;
+var WIDTH_START = 95;
+var MINUTES_IN_DAY = 1440;
+/* @vue/component */
+
+var _default = _calendarBase.default.extend({
+  name: 'calendar-with-events',
+  directives: {
+    ripple: _ripple.default
+  },
+  props: _props.default.events,
+  computed: {
+    noEvents: function noEvents() {
+      return this.events.length === 0;
+    },
+    parsedEvents: function parsedEvents() {
+      return this.events.map(this.parseEvent);
+    },
+    parsedEventOverlapThreshold: function parsedEventOverlapThreshold() {
+      return parseInt(this.eventOverlapThreshold);
+    },
+    eventColorFunction: function eventColorFunction() {
+      var _this = this;
+
+      return typeof this.eventColor === 'function' ? this.eventColor : function () {
+        return _this.eventColor;
+      };
+    },
+    eventTimedFunction: function eventTimedFunction() {
+      var _this2 = this;
+
+      return typeof this.eventTimed === 'function' ? this.eventTimed : function (event) {
+        return !!event[_this2.eventTimed];
+      };
+    },
+    eventCategoryFunction: function eventCategoryFunction() {
+      var _this3 = this;
+
+      return typeof this.eventCategory === 'function' ? this.eventCategory : function (event) {
+        return event[_this3.eventCategory];
+      };
+    },
+    eventTextColorFunction: function eventTextColorFunction() {
+      var _this4 = this;
+
+      return typeof this.eventTextColor === 'function' ? this.eventTextColor : function () {
+        return _this4.eventTextColor;
+      };
+    },
+    eventNameFunction: function eventNameFunction() {
+      var _this5 = this;
+
+      return typeof this.eventName === 'function' ? this.eventName : function (event, timedEvent) {
+        return (0, _helpers.escapeHTML)(event.input[_this5.eventName]);
+      };
+    },
+    eventModeFunction: function eventModeFunction() {
+      return typeof this.eventOverlapMode === 'function' ? this.eventOverlapMode : _modes.CalendarEventOverlapModes[this.eventOverlapMode];
+    },
+    eventWeekdays: function eventWeekdays() {
+      return this.parsedWeekdays;
+    },
+    categoryMode: function categoryMode() {
+      return false;
+    }
+  },
+  methods: {
+    parseEvent: function parseEvent(input) {
+      var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      return (0, _events.parseEvent)(input, index, this.eventStart, this.eventEnd, this.eventTimedFunction(input), this.categoryMode ? this.eventCategoryFunction(input) : false);
+    },
+    formatTime: function formatTime(withTime, ampm) {
+      var formatter = this.getFormatter({
+        timeZone: 'UTC',
+        hour: 'numeric',
+        minute: withTime.minute > 0 ? 'numeric' : undefined
+      });
+      return formatter(withTime, true);
+    },
+    updateEventVisibility: function updateEventVisibility() {
+      if (this.noEvents || !this.eventMore) {
+        return;
+      }
+
+      var eventHeight = this.eventHeight;
+      var eventsMap = this.getEventsMap();
+
+      for (var date in eventsMap) {
+        var _eventsMap$date = eventsMap[date],
+            parent = _eventsMap$date.parent,
+            events = _eventsMap$date.events,
+            more = _eventsMap$date.more;
+
+        if (!more) {
+          break;
+        }
+
+        var parentBounds = parent.getBoundingClientRect();
+        var last = events.length - 1;
+        var hide = false;
+        var hidden = 0;
+
+        for (var i = 0; i <= last; i++) {
+          if (!hide) {
+            var eventBounds = events[i].getBoundingClientRect();
+            hide = i === last ? eventBounds.bottom > parentBounds.bottom : eventBounds.bottom + eventHeight > parentBounds.bottom;
+          }
+
+          if (hide) {
+            events[i].style.display = 'none';
+            hidden++;
+          }
+        }
+
+        if (hide) {
+          more.style.display = '';
+          more.innerHTML = this.$vuetify.lang.t(this.eventMoreText, hidden);
+        } else {
+          more.style.display = 'none';
+        }
+      }
+    },
+    getEventsMap: function getEventsMap() {
+      var eventsMap = {};
+      var elements = this.$refs.events;
+
+      if (!elements || !elements.forEach) {
+        return eventsMap;
+      }
+
+      elements.forEach(function (el) {
+        var date = el.getAttribute('data-date');
+
+        if (el.parentElement && date) {
+          if (!(date in eventsMap)) {
+            eventsMap[date] = {
+              parent: el.parentElement,
+              more: null,
+              events: []
+            };
+          }
+
+          if (el.getAttribute('data-more')) {
+            eventsMap[date].more = el;
+          } else {
+            eventsMap[date].events.push(el);
+            el.style.display = '';
+          }
+        }
+      });
+      return eventsMap;
+    },
+    genDayEvent: function genDayEvent(_ref, day) {
+      var event = _ref.event;
+      var eventHeight = this.eventHeight;
+      var eventMarginBottom = this.eventMarginBottom;
+      var dayIdentifier = (0, _timestamp.getDayIdentifier)(day);
+      var week = day.week;
+      var start = dayIdentifier === event.startIdentifier;
+      var end = dayIdentifier === event.endIdentifier;
+      var width = WIDTH_START;
+
+      if (!this.categoryMode) {
+        for (var i = day.index + 1; i < week.length; i++) {
+          var weekdayIdentifier = (0, _timestamp.getDayIdentifier)(week[i]);
+
+          if (event.endIdentifier >= weekdayIdentifier) {
+            width += WIDTH_FULL;
+            end = end || weekdayIdentifier === event.endIdentifier;
+          } else {
+            end = true;
+            break;
+          }
+        }
+      }
+
+      var scope = {
+        eventParsed: event,
+        day: day,
+        start: start,
+        end: end,
+        timed: false
+      };
+      return this.genEvent(event, scope, false, {
+        staticClass: 'v-event',
+        class: {
+          'v-event-start': start,
+          'v-event-end': end
+        },
+        style: {
+          height: "".concat(eventHeight, "px"),
+          width: "".concat(width, "%"),
+          'margin-bottom': "".concat(eventMarginBottom, "px")
+        },
+        attrs: {
+          'data-date': day.date
+        },
+        key: event.index,
+        ref: 'events',
+        refInFor: true
+      });
+    },
+    genTimedEvent: function genTimedEvent(_ref2, day) {
+      var event = _ref2.event,
+          left = _ref2.left,
+          width = _ref2.width;
+
+      if (day.timeDelta(event.end) <= 0 || day.timeDelta(event.start) >= 1) {
+        return false;
+      }
+
+      var dayIdentifier = (0, _timestamp.getDayIdentifier)(day);
+      var start = event.startIdentifier >= dayIdentifier;
+      var end = event.endIdentifier > dayIdentifier;
+      var top = start ? day.timeToY(event.start) : 0;
+      var bottom = end ? day.timeToY(MINUTES_IN_DAY) : day.timeToY(event.end);
+      var height = Math.max(this.eventHeight, bottom - top);
+      var scope = {
+        eventParsed: event,
+        day: day,
+        start: start,
+        end: end,
+        timed: true
+      };
+      return this.genEvent(event, scope, true, {
+        staticClass: 'v-event-timed',
+        style: {
+          top: "".concat(top, "px"),
+          height: "".concat(height, "px"),
+          left: "".concat(left, "%"),
+          width: "".concat(width, "%")
+        }
+      });
+    },
+    genEvent: function genEvent(event, scopeInput, timedEvent, data) {
+      var _this6 = this;
+
+      var slot = this.$scopedSlots.event;
+      var text = this.eventTextColorFunction(event.input);
+      var background = this.eventColorFunction(event.input);
+      var overlapsNoon = event.start.hour < 12 && event.end.hour >= 12;
+      var singline = (0, _timestamp.diffMinutes)(event.start, event.end) <= this.parsedEventOverlapThreshold;
+      var formatTime = this.formatTime;
+
+      var timeSummary = function timeSummary() {
+        return formatTime(event.start, overlapsNoon) + ' - ' + formatTime(event.end, true);
+      };
+
+      var eventSummary = function eventSummary() {
+        var name = _this6.eventNameFunction(event, timedEvent);
+
+        if (event.start.hasTime) {
+          if (timedEvent) {
+            var time = timeSummary();
+            var delimiter = singline ? ', ' : '<br>';
+            return "<strong>".concat(name, "</strong>").concat(delimiter).concat(time);
+          } else {
+            var _time = formatTime(event.start, true);
+
+            return "<strong>".concat(_time, "</strong> ").concat(name);
+          }
+        }
+
+        return name;
+      };
+
+      var scope = _objectSpread({}, scopeInput, {
+        event: event.input,
+        outside: scopeInput.day.outside,
+        singline: singline,
+        overlapsNoon: overlapsNoon,
+        formatTime: formatTime,
+        timeSummary: timeSummary,
+        eventSummary: eventSummary
+      });
+
+      return this.$createElement('div', this.setTextColor(text, this.setBackgroundColor(background, _objectSpread({
+        on: this.getDefaultMouseEventHandlers(':event', function (nativeEvent) {
+          return _objectSpread({}, scope, {
+            nativeEvent: nativeEvent
+          });
+        }),
+        directives: [{
+          name: 'ripple',
+          value: this.eventRipple != null ? this.eventRipple : true
+        }]
+      }, data))), slot ? slot(scope) : [this.genName(eventSummary)]);
+    },
+    genName: function genName(eventSummary) {
+      return this.$createElement('div', {
+        staticClass: 'pl-1',
+        domProps: {
+          innerHTML: eventSummary()
+        }
+      });
+    },
+    genPlaceholder: function genPlaceholder(day) {
+      var height = this.eventHeight + this.eventMarginBottom;
+      return this.$createElement('div', {
+        style: {
+          height: "".concat(height, "px")
+        },
+        attrs: {
+          'data-date': day.date
+        },
+        ref: 'events',
+        refInFor: true
+      });
+    },
+    genMore: function genMore(day) {
+      var _this7 = this;
+
+      var eventHeight = this.eventHeight;
+      var eventMarginBottom = this.eventMarginBottom;
+      return this.$createElement('div', {
+        staticClass: 'v-event-more pl-1',
+        class: {
+          'v-outside': day.outside
+        },
+        attrs: {
+          'data-date': day.date,
+          'data-more': 1
+        },
+        directives: [{
+          name: 'ripple',
+          value: this.eventRipple != null ? this.eventRipple : true
+        }],
+        on: {
+          click: function click() {
+            return _this7.$emit('click:more', day);
+          }
+        },
+        style: {
+          display: 'none',
+          height: "".concat(eventHeight, "px"),
+          'margin-bottom': "".concat(eventMarginBottom, "px")
+        },
+        ref: 'events',
+        refInFor: true
+      });
+    },
+    getVisibleEvents: function getVisibleEvents() {
+      var start = (0, _timestamp.getDayIdentifier)(this.days[0]);
+      var end = (0, _timestamp.getDayIdentifier)(this.days[this.days.length - 1]);
+      return this.parsedEvents.filter(function (event) {
+        return (0, _events.isEventOverlapping)(event, start, end);
+      });
+    },
+    isEventForCategory: function isEventForCategory(event, category) {
+      return !this.categoryMode || category === event.category || typeof event.category !== 'string' && category === null;
+    },
+    getEventsForDay: function getEventsForDay(day) {
+      var identifier = (0, _timestamp.getDayIdentifier)(day);
+      var firstWeekday = this.eventWeekdays[0];
+      return this.parsedEvents.filter(function (event) {
+        return (0, _events.isEventStart)(event, day, identifier, firstWeekday);
+      });
+    },
+    getEventsForDayAll: function getEventsForDayAll(day) {
+      var _this8 = this;
+
+      var identifier = (0, _timestamp.getDayIdentifier)(day);
+      var firstWeekday = this.eventWeekdays[0];
+      return this.parsedEvents.filter(function (event) {
+        return event.allDay && (_this8.categoryMode ? (0, _events.isEventOn)(event, identifier) : (0, _events.isEventStart)(event, day, identifier, firstWeekday)) && _this8.isEventForCategory(event, day.category);
+      });
+    },
+    getEventsForDayTimed: function getEventsForDayTimed(day) {
+      var _this9 = this;
+
+      var identifier = (0, _timestamp.getDayIdentifier)(day);
+      return this.parsedEvents.filter(function (event) {
+        return !event.allDay && (0, _events.isEventOn)(event, identifier) && _this9.isEventForCategory(event, day.category);
+      });
+    },
+    getScopedSlots: function getScopedSlots() {
+      var _this10 = this;
+
+      if (this.noEvents) {
+        return _objectSpread({}, this.$scopedSlots);
+      }
+
+      var mode = this.eventModeFunction(this.parsedEvents, this.eventWeekdays[0], this.parsedEventOverlapThreshold);
+
+      var isNode = function isNode(input) {
+        return !!input;
+      };
+
+      var getSlotChildren = function getSlotChildren(day, getter, mapper, timed) {
+        var events = getter(day);
+        var visuals = mode(day, events, timed, _this10.categoryMode);
+
+        if (timed) {
+          return visuals.map(function (visual) {
+            return mapper(visual, day);
+          }).filter(isNode);
+        }
+
+        var children = [];
+        visuals.forEach(function (visual, index) {
+          while (children.length < visual.column) {
+            children.push(_this10.genPlaceholder(day));
+          }
+
+          var mapped = mapper(visual, day);
+
+          if (mapped) {
+            children.push(mapped);
+          }
+        });
+        return children;
+      };
+
+      var slots = this.$scopedSlots;
+      var slotDay = slots.day;
+      var slotDayHeader = slots['day-header'];
+      var slotDayBody = slots['day-body'];
+      return _objectSpread({}, slots, {
+        day: function day(_day) {
+          var children = getSlotChildren(_day, _this10.getEventsForDay, _this10.genDayEvent, false);
+
+          if (children && children.length > 0 && _this10.eventMore) {
+            children.push(_this10.genMore(_day));
+          }
+
+          if (slotDay) {
+            var slot = slotDay(_day);
+
+            if (slot) {
+              children = children ? children.concat(slot) : slot;
+            }
+          }
+
+          return children;
+        },
+        'day-header': function dayHeader(day) {
+          var children = getSlotChildren(day, _this10.getEventsForDayAll, _this10.genDayEvent, false);
+
+          if (slotDayHeader) {
+            var slot = slotDayHeader(day);
+
+            if (slot) {
+              children = children ? children.concat(slot) : slot;
+            }
+          }
+
+          return children;
+        },
+        'day-body': function dayBody(day) {
+          var events = getSlotChildren(day, _this10.getEventsForDayTimed, _this10.genTimedEvent, true);
+          var children = [_this10.$createElement('div', {
+            staticClass: 'v-event-timed-container'
+          }, events)];
+
+          if (slotDayBody) {
+            var slot = slotDayBody(day);
+
+            if (slot) {
+              children = children.concat(slot);
+            }
+          }
+
+          return children;
+        }
+      });
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=calendar-with-events.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/calendar-with-intervals.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _calendarBase = _interopRequireDefault(require("./calendar-base"));
+
+var _props = _interopRequireDefault(require("../util/props"));
+
+var _timestamp = require("../util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Mixins
+// Util
+
+/* @vue/component */
+var _default = _calendarBase.default.extend({
+  name: 'calendar-with-intervals',
+  props: _props.default.intervals,
+  computed: {
+    parsedFirstInterval: function parsedFirstInterval() {
+      return parseInt(this.firstInterval);
+    },
+    parsedIntervalMinutes: function parsedIntervalMinutes() {
+      return parseInt(this.intervalMinutes);
+    },
+    parsedIntervalCount: function parsedIntervalCount() {
+      return parseInt(this.intervalCount);
+    },
+    parsedIntervalHeight: function parsedIntervalHeight() {
+      return parseFloat(this.intervalHeight);
+    },
+    parsedFirstTime: function parsedFirstTime() {
+      return (0, _timestamp.parseTime)(this.firstTime);
+    },
+    firstMinute: function firstMinute() {
+      var time = this.parsedFirstTime;
+      return time !== false && time >= 0 && time <= _timestamp.MINUTES_IN_DAY ? time : this.parsedFirstInterval * this.parsedIntervalMinutes;
+    },
+    bodyHeight: function bodyHeight() {
+      return this.parsedIntervalCount * this.parsedIntervalHeight;
+    },
+    days: function days() {
+      return (0, _timestamp.createDayList)(this.parsedStart, this.parsedEnd, this.times.today, this.weekdaySkips, this.maxDays);
+    },
+    intervals: function intervals() {
+      var days = this.days;
+      var first = this.firstMinute;
+      var minutes = this.parsedIntervalMinutes;
+      var count = this.parsedIntervalCount;
+      var now = this.times.now;
+      return days.map(function (d) {
+        return (0, _timestamp.createIntervalList)(d, first, minutes, count, now);
+      });
+    },
+    intervalFormatter: function intervalFormatter() {
+      if (this.intervalFormat) {
+        return this.intervalFormat;
+      }
+
+      var longOptions = {
+        timeZone: 'UTC',
+        hour: '2-digit',
+        minute: '2-digit'
+      };
+      var shortOptions = {
+        timeZone: 'UTC',
+        hour: 'numeric',
+        minute: '2-digit'
+      };
+      var shortHourOptions = {
+        timeZone: 'UTC',
+        hour: 'numeric'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (tms, short) {
+        return short ? tms.minute === 0 ? shortHourOptions : shortOptions : longOptions;
+      });
+    }
+  },
+  methods: {
+    showIntervalLabelDefault: function showIntervalLabelDefault(interval) {
+      var first = this.intervals[0][0];
+      var isFirst = first.hour === interval.hour && first.minute === interval.minute;
+      return !isFirst;
+    },
+    intervalStyleDefault: function intervalStyleDefault(_interval) {
+      return undefined;
+    },
+    getTimestampAtEvent: function getTimestampAtEvent(e, day) {
+      var timestamp = (0, _timestamp.copyTimestamp)(day);
+      var bounds = e.currentTarget.getBoundingClientRect();
+      var baseMinutes = this.firstMinute;
+      var touchEvent = e;
+      var mouseEvent = e;
+      var touches = touchEvent.changedTouches || touchEvent.touches;
+      var clientY = touches && touches[0] ? touches[0].clientY : mouseEvent.clientY;
+      var addIntervals = (clientY - bounds.top) / this.parsedIntervalHeight;
+      var addMinutes = Math.floor(addIntervals * this.parsedIntervalMinutes);
+      var minutes = baseMinutes + addMinutes;
+      return (0, _timestamp.updateMinutes)(timestamp, minutes, this.times.now);
+    },
+    getSlotScope: function getSlotScope(timestamp) {
+      var scope = (0, _timestamp.copyTimestamp)(timestamp);
+      scope.timeToY = this.timeToY;
+      scope.timeDelta = this.timeDelta;
+      scope.minutesToPixels = this.minutesToPixels;
+      scope.week = this.days;
+      return scope;
+    },
+    scrollToTime: function scrollToTime(time) {
+      var y = this.timeToY(time);
+      var pane = this.$refs.scrollArea;
+
+      if (y === false || !pane) {
+        return false;
+      }
+
+      pane.scrollTop = y;
+      return true;
+    },
+    minutesToPixels: function minutesToPixels(minutes) {
+      return minutes / this.parsedIntervalMinutes * this.parsedIntervalHeight;
+    },
+    timeToY: function timeToY(time) {
+      var clamp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var y = this.timeDelta(time);
+
+      if (y !== false) {
+        y *= this.bodyHeight;
+
+        if (clamp) {
+          if (y < 0) {
+            y = 0;
+          }
+
+          if (y > this.bodyHeight) {
+            y = this.bodyHeight;
+          }
+        }
+      }
+
+      return y;
+    },
+    timeDelta: function timeDelta(time) {
+      var minutes = (0, _timestamp.parseTime)(time);
+
+      if (minutes === false) {
+        return false;
+      }
+
+      var min = this.firstMinute;
+      var gap = this.parsedIntervalCount * this.parsedIntervalMinutes;
+      return (minutes - min) / gap;
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=calendar-with-intervals.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/mouse.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = _vue.default.extend({
+  name: 'mouse',
+  methods: {
+    getDefaultMouseEventHandlers: function getDefaultMouseEventHandlers(suffix, getEvent) {
+      var _this$getMouseEventHa;
+
+      return this.getMouseEventHandlers((_this$getMouseEventHa = {}, _defineProperty(_this$getMouseEventHa, 'click' + suffix, {
+        event: 'click'
+      }), _defineProperty(_this$getMouseEventHa, 'contextmenu' + suffix, {
+        event: 'contextmenu',
+        prevent: true,
+        result: false
+      }), _defineProperty(_this$getMouseEventHa, 'mousedown' + suffix, {
+        event: 'mousedown'
+      }), _defineProperty(_this$getMouseEventHa, 'mousemove' + suffix, {
+        event: 'mousemove'
+      }), _defineProperty(_this$getMouseEventHa, 'mouseup' + suffix, {
+        event: 'mouseup'
+      }), _defineProperty(_this$getMouseEventHa, 'mouseenter' + suffix, {
+        event: 'mouseenter'
+      }), _defineProperty(_this$getMouseEventHa, 'mouseleave' + suffix, {
+        event: 'mouseleave'
+      }), _defineProperty(_this$getMouseEventHa, 'touchstart' + suffix, {
+        event: 'touchstart'
+      }), _defineProperty(_this$getMouseEventHa, 'touchmove' + suffix, {
+        event: 'touchmove'
+      }), _defineProperty(_this$getMouseEventHa, 'touchend' + suffix, {
+        event: 'touchend'
+      }), _this$getMouseEventHa), getEvent);
+    },
+    getMouseEventHandlers: function getMouseEventHandlers(events, getEvent) {
+      var _this = this;
+
+      var on = {};
+
+      var _loop = function _loop(event) {
+        var eventOptions = events[event];
+        if (!_this.$listeners[event]) return "continue"; // TODO somehow pull in modifiers
+
+        var prefix = eventOptions.passive ? '&' : (eventOptions.once ? '~' : '') + (eventOptions.capture ? '!' : '');
+        var key = prefix + eventOptions.event;
+
+        var handler = function handler(e) {
+          var mouseEvent = e;
+
+          if (eventOptions.button === undefined || mouseEvent.buttons > 0 && mouseEvent.button === eventOptions.button) {
+            if (eventOptions.prevent) {
+              e.preventDefault();
+            }
+
+            if (eventOptions.stop) {
+              e.stopPropagation();
+            }
+
+            _this.$emit(event, getEvent(e));
+          }
+
+          return eventOptions.result;
+        };
+
+        if (key in on) {
+          /* istanbul ignore next */
+          if (Array.isArray(on[key])) {
+            on[key].push(handler);
+          } else {
+            on[key] = [on[key], handler];
+          }
+        } else {
+          on[key] = handler;
+        }
+      };
+
+      for (var event in events) {
+        var _ret = _loop(event);
+
+        if (_ret === "continue") continue;
+      }
+
+      return on;
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=mouse.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/mouse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/mixins/mouse.ts"],"names":[],"mappings":";;;;;;;AAAA;;;;;;eAqBe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,OADkB;AAGxB,EAAA,OAAO,EAAE;AACP,IAAA,4BADO,wCACuB,MADvB,EACuC,QADvC,EAC6D;AAAA;;AAClE,aAAO,KAAK,qBAAL,qEACJ,UAAU,MADN,EACe;AAAE,QAAA,KAAK,EAAE;AAAT,OADf,0CAEJ,gBAAgB,MAFZ,EAEqB;AAAE,QAAA,KAAK,EAAE,aAAT;AAAwB,QAAA,OAAO,EAAE,IAAjC;AAAuC,QAAA,MAAM,EAAE;AAA/C,OAFrB,0CAGJ,cAAc,MAHV,EAGmB;AAAE,QAAA,KAAK,EAAE;AAAT,OAHnB,0CAIJ,cAAc,MAJV,EAImB;AAAE,QAAA,KAAK,EAAE;AAAT,OAJnB,0CAKJ,YAAY,MALR,EAKiB;AAAE,QAAA,KAAK,EAAE;AAAT,OALjB,0CAMJ,eAAe,MANX,EAMoB;AAAE,QAAA,KAAK,EAAE;AAAT,OANpB,0CAOJ,eAAe,MAPX,EAOoB;AAAE,QAAA,KAAK,EAAE;AAAT,OAPpB,0CAQJ,eAAe,MARX,EAQoB;AAAE,QAAA,KAAK,EAAE;AAAT,OARpB,0CASJ,cAAc,MATV,EASmB;AAAE,QAAA,KAAK,EAAE;AAAT,OATnB,0CAUJ,aAAa,MAVT,EAUkB;AAAE,QAAA,KAAK,EAAE;AAAT,OAVlB,2BAWJ,QAXI,CAAP;AAYD,KAdM;AAeP,IAAA,qBAfO,iCAegB,MAfhB,EAeqC,QAfrC,EAe2D;AAAA;;AAChE,UAAM,EAAE,GAAmB,EAA3B;;AADgE,iCAGrD,KAHqD;AAI9D,YAAM,YAAY,GAAG,MAAM,CAAC,KAAD,CAA3B;AAEA,YAAI,CAAC,KAAI,CAAC,UAAL,CAAgB,KAAhB,CAAL,EAA6B,kBANiC,CAQ9D;;AAEA,YAAM,MAAM,GAAG,YAAY,CAAC,OAAb,GAAuB,GAAvB,GAA8B,CAAC,YAAY,CAAC,IAAb,GAAoB,GAApB,GAA0B,EAA3B,KAAkC,YAAY,CAAC,OAAb,GAAuB,GAAvB,GAA6B,EAA/D,CAA7C;AACA,YAAM,GAAG,GAAG,MAAM,GAAG,YAAY,CAAC,KAAlC;;AAEA,YAAM,OAAO,GAAiB,SAAxB,OAAwB,CAAA,CAAC,EAAG;AAChC,cAAM,UAAU,GAAe,CAA/B;;AACA,cAAI,YAAY,CAAC,MAAb,KAAwB,SAAxB,IAAsC,UAAU,CAAC,OAAX,GAAqB,CAArB,IAA0B,UAAU,CAAC,MAAX,KAAsB,YAAY,CAAC,MAAvG,EAAgH;AAC9G,gBAAI,YAAY,CAAC,OAAjB,EAA0B;AACxB,cAAA,CAAC,CAAC,cAAF;AACD;;AACD,gBAAI,YAAY,CAAC,IAAjB,EAAuB;AACrB,cAAA,CAAC,CAAC,eAAF;AACD;;AACD,YAAA,KAAI,CAAC,KAAL,CAAW,KAAX,EAAkB,QAAQ,CAAC,CAAD,CAA1B;AACD;;AAED,iBAAO,YAAY,CAAC,MAApB;AACD,SAbD;;AAeA,YAAI,GAAG,IAAI,EAAX,EAAe;AACb;AACA,cAAI,KAAK,CAAC,OAAN,CAAc,EAAE,CAAC,GAAD,CAAhB,CAAJ,EAA4B;AACzB,YAAA,EAAE,CAAC,GAAD,CAAF,CAA2B,IAA3B,CAAgC,OAAhC;AACF,WAFD,MAEO;AACL,YAAA,EAAE,CAAC,GAAD,CAAF,GAAU,CAAC,EAAE,CAAC,GAAD,CAAH,EAAU,OAAV,CAAV;AACD;AACF,SAPD,MAOO;AACL,UAAA,EAAE,CAAC,GAAD,CAAF,GAAU,OAAV;AACD;AArC6D;;AAGhE,WAAK,IAAM,KAAX,IAAoB,MAApB,EAA4B;AAAA,yBAAjB,KAAiB;;AAAA,iCAGG;AAgC9B;;AAED,aAAO,EAAP;AACD;AAxDM;AAHe,CAAX,C","sourcesContent":["import Vue from 'vue'\n\nexport type MouseHandler = (e: MouseEvent | TouchEvent) => any\n\nexport type MouseEvents = {\n  [event: string]: {\n    event: string\n    passive?: boolean\n    capture?: boolean\n    once?: boolean\n    stop?: boolean\n    prevent?: boolean\n    button?: number\n    result?: any\n  }\n}\n\nexport type MouseEventsMap = {\n  [event: string]: MouseHandler | MouseHandler[]\n}\n\nexport default Vue.extend({\n  name: 'mouse',\n\n  methods: {\n    getDefaultMouseEventHandlers (suffix: string, getEvent: MouseHandler): MouseEventsMap {\n      return this.getMouseEventHandlers({\n        ['click' + suffix]: { event: 'click' },\n        ['contextmenu' + suffix]: { event: 'contextmenu', prevent: true, result: false },\n        ['mousedown' + suffix]: { event: 'mousedown' },\n        ['mousemove' + suffix]: { event: 'mousemove' },\n        ['mouseup' + suffix]: { event: 'mouseup' },\n        ['mouseenter' + suffix]: { event: 'mouseenter' },\n        ['mouseleave' + suffix]: { event: 'mouseleave' },\n        ['touchstart' + suffix]: { event: 'touchstart' },\n        ['touchmove' + suffix]: { event: 'touchmove' },\n        ['touchend' + suffix]: { event: 'touchend' },\n      }, getEvent)\n    },\n    getMouseEventHandlers (events: MouseEvents, getEvent: MouseHandler): MouseEventsMap {\n      const on: MouseEventsMap = {}\n\n      for (const event in events) {\n        const eventOptions = events[event]\n\n        if (!this.$listeners[event]) continue\n\n        // TODO somehow pull in modifiers\n\n        const prefix = eventOptions.passive ? '&' : ((eventOptions.once ? '~' : '') + (eventOptions.capture ? '!' : ''))\n        const key = prefix + eventOptions.event\n\n        const handler: MouseHandler = e => {\n          const mouseEvent: MouseEvent = e as MouseEvent\n          if (eventOptions.button === undefined || (mouseEvent.buttons > 0 && mouseEvent.button === eventOptions.button)) {\n            if (eventOptions.prevent) {\n              e.preventDefault()\n            }\n            if (eventOptions.stop) {\n              e.stopPropagation()\n            }\n            this.$emit(event, getEvent(e))\n          }\n\n          return eventOptions.result\n        }\n\n        if (key in on) {\n          /* istanbul ignore next */\n          if (Array.isArray(on[key])) {\n            (on[key] as MouseHandler[]).push(handler)\n          } else {\n            on[key] = [on[key], handler] as MouseHandler[]\n          }\n        } else {\n          on[key] = handler\n        }\n      }\n\n      return on\n    },\n  },\n})\n"],"sourceRoot":"","file":"mouse.js"}

node_modules/vuetify/es5/components/VCalendar/mixins/times.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var _timestamp = require("../util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _vue.default.extend({
+  name: 'times',
+  props: {
+    now: {
+      type: String,
+      validator: _timestamp.validateTimestamp
+    }
+  },
+  data: function data() {
+    return {
+      times: {
+        now: (0, _timestamp.parseTimestamp)('0000-00-00 00:00', true),
+        today: (0, _timestamp.parseTimestamp)('0000-00-00', true)
+      }
+    };
+  },
+  computed: {
+    parsedNow: function parsedNow() {
+      return this.now ? (0, _timestamp.parseTimestamp)(this.now, true) : null;
+    }
+  },
+  watch: {
+    parsedNow: 'updateTimes'
+  },
+  created: function created() {
+    this.updateTimes();
+    this.setPresent();
+  },
+  methods: {
+    setPresent: function setPresent() {
+      this.times.now.present = this.times.today.present = true;
+      this.times.now.past = this.times.today.past = false;
+      this.times.now.future = this.times.today.future = false;
+    },
+    updateTimes: function updateTimes() {
+      var now = this.parsedNow || this.getNow();
+      this.updateDay(now, this.times.now);
+      this.updateTime(now, this.times.now);
+      this.updateDay(now, this.times.today);
+    },
+    getNow: function getNow() {
+      return (0, _timestamp.parseDate)(new Date());
+    },
+    updateDay: function updateDay(now, target) {
+      if (now.date !== target.date) {
+        target.year = now.year;
+        target.month = now.month;
+        target.day = now.day;
+        target.weekday = now.weekday;
+        target.date = now.date;
+      }
+    },
+    updateTime: function updateTime(now, target) {
+      if (now.time !== target.time) {
+        target.hour = now.hour;
+        target.minute = now.minute;
+        target.time = now.time;
+      }
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=times.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/times.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/mixins/times.ts"],"names":[],"mappings":";;;;;;;AAAA;;AAEA;;;;eAOe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,OADkB;AAGxB,EAAA,KAAK,EAAE;AACL,IAAA,GAAG,EAAE;AACH,MAAA,IAAI,EAAE,MADH;AAEH,MAAA,SAAS,EAAE;AAFR;AADA,GAHiB;AAUxB,EAAA,IAAI,EAAE;AAAA,WAAO;AACX,MAAA,KAAK,EAAE;AACL,QAAA,GAAG,EAAE,+BAAe,kBAAf,EAAmC,IAAnC,CADA;AAEL,QAAA,KAAK,EAAE,+BAAe,YAAf,EAA6B,IAA7B;AAFF;AADI,KAAP;AAAA,GAVkB;AAiBxB,EAAA,QAAQ,EAAE;AACR,IAAA,SADQ,uBACC;AACP,aAAO,KAAK,GAAL,GAAW,+BAAe,KAAK,GAApB,EAAyB,IAAzB,CAAX,GAA4C,IAAnD;AACD;AAHO,GAjBc;AAuBxB,EAAA,KAAK,EAAE;AACL,IAAA,SAAS,EAAE;AADN,GAvBiB;AA2BxB,EAAA,OA3BwB,qBA2BjB;AACL,SAAK,WAAL;AACA,SAAK,UAAL;AACD,GA9BuB;AAgCxB,EAAA,OAAO,EAAE;AACP,IAAA,UADO,wBACG;AACR,WAAK,KAAL,CAAW,GAAX,CAAe,OAAf,GAAyB,KAAK,KAAL,CAAW,KAAX,CAAiB,OAAjB,GAA2B,IAApD;AACA,WAAK,KAAL,CAAW,GAAX,CAAe,IAAf,GAAsB,KAAK,KAAL,CAAW,KAAX,CAAiB,IAAjB,GAAwB,KAA9C;AACA,WAAK,KAAL,CAAW,GAAX,CAAe,MAAf,GAAwB,KAAK,KAAL,CAAW,KAAX,CAAiB,MAAjB,GAA0B,KAAlD;AACD,KALM;AAMP,IAAA,WANO,yBAMI;AACT,UAAM,GAAG,GAAsB,KAAK,SAAL,IAAkB,KAAK,MAAL,EAAjD;AACA,WAAK,SAAL,CAAe,GAAf,EAAoB,KAAK,KAAL,CAAW,GAA/B;AACA,WAAK,UAAL,CAAgB,GAAhB,EAAqB,KAAK,KAAL,CAAW,GAAhC;AACA,WAAK,SAAL,CAAe,GAAf,EAAoB,KAAK,KAAL,CAAW,KAA/B;AACD,KAXM;AAYP,IAAA,MAZO,oBAYD;AACJ,aAAO,0BAAU,IAAI,IAAJ,EAAV,CAAP;AACD,KAdM;AAeP,IAAA,SAfO,qBAeI,GAfJ,EAe4B,MAf5B,EAeqD;AAC1D,UAAI,GAAG,CAAC,IAAJ,KAAa,MAAM,CAAC,IAAxB,EAA8B;AAC5B,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACA,QAAA,MAAM,CAAC,KAAP,GAAe,GAAG,CAAC,KAAnB;AACA,QAAA,MAAM,CAAC,GAAP,GAAa,GAAG,CAAC,GAAjB;AACA,QAAA,MAAM,CAAC,OAAP,GAAiB,GAAG,CAAC,OAArB;AACA,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACD;AACF,KAvBM;AAwBP,IAAA,UAxBO,sBAwBK,GAxBL,EAwB6B,MAxB7B,EAwBsD;AAC3D,UAAI,GAAG,CAAC,IAAJ,KAAa,MAAM,CAAC,IAAxB,EAA8B;AAC5B,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACA,QAAA,MAAM,CAAC,MAAP,GAAgB,GAAG,CAAC,MAApB;AACA,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACD;AACF;AA9BM;AAhCe,CAAX,C","sourcesContent":["import Vue from 'vue'\n\nimport {\n  validateTimestamp,\n  parseTimestamp,\n  parseDate,\n} from '../util/timestamp'\nimport { CalendarTimestamp } from 'vuetify/types'\n\nexport default Vue.extend({\n  name: 'times',\n\n  props: {\n    now: {\n      type: String,\n      validator: validateTimestamp,\n    },\n  },\n\n  data: () => ({\n    times: {\n      now: parseTimestamp('0000-00-00 00:00', true),\n      today: parseTimestamp('0000-00-00', true),\n    },\n  }),\n\n  computed: {\n    parsedNow (): CalendarTimestamp | null {\n      return this.now ? parseTimestamp(this.now, true) : null\n    },\n  },\n\n  watch: {\n    parsedNow: 'updateTimes',\n  },\n\n  created () {\n    this.updateTimes()\n    this.setPresent()\n  },\n\n  methods: {\n    setPresent (): void {\n      this.times.now.present = this.times.today.present = true\n      this.times.now.past = this.times.today.past = false\n      this.times.now.future = this.times.today.future = false\n    },\n    updateTimes (): void {\n      const now: CalendarTimestamp = this.parsedNow || this.getNow()\n      this.updateDay(now, this.times.now)\n      this.updateTime(now, this.times.now)\n      this.updateDay(now, this.times.today)\n    },\n    getNow (): CalendarTimestamp {\n      return parseDate(new Date())\n    },\n    updateDay (now: CalendarTimestamp, target: CalendarTimestamp): void {\n      if (now.date !== target.date) {\n        target.year = now.year\n        target.month = now.month\n        target.day = now.day\n        target.weekday = now.weekday\n        target.date = now.date\n      }\n    },\n    updateTime (now: CalendarTimestamp, target: CalendarTimestamp): void {\n      if (now.time !== target.time) {\n        target.hour = now.hour\n        target.minute = now.minute\n        target.time = now.time\n      }\n    },\n  },\n})\n"],"sourceRoot":"","file":"times.js"}

node_modules/vuetify/es5/components/VCalendar/modes/column.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.column = void 0;
+
+var _common = require("./common");
+
+var FULL_WIDTH = 100;
+
+var column = function column(events, firstWeekday, overlapThreshold) {
+  var handler = (0, _common.getOverlapGroupHandler)(firstWeekday);
+  return function (day, dayEvents, timed, reset) {
+    var visuals = handler.getVisuals(day, dayEvents, timed, reset);
+
+    if (timed) {
+      visuals.forEach(function (visual) {
+        visual.left = visual.column * FULL_WIDTH / visual.columnCount;
+        visual.width = FULL_WIDTH / visual.columnCount;
+      });
+    }
+
+    return visuals;
+  };
+};
+
+exports.column = column;
+//# sourceMappingURL=column.js.map

node_modules/vuetify/es5/components/VCalendar/modes/column.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/modes/column.ts"],"names":[],"mappings":";;;;;;;AACA;;AAEA,IAAM,UAAU,GAAG,GAAnB;;AAEO,IAAM,MAAM,GAA6B,SAAnC,MAAmC,CAAC,MAAD,EAAS,YAAT,EAAuB,gBAAvB,EAA2C;AACzF,MAAM,OAAO,GAAG,oCAAuB,YAAvB,CAAhB;AAEA,SAAO,UAAC,GAAD,EAAM,SAAN,EAAiB,KAAjB,EAAwB,KAAxB,EAAiC;AACtC,QAAM,OAAO,GAAG,OAAO,CAAC,UAAR,CAAmB,GAAnB,EAAwB,SAAxB,EAAmC,KAAnC,EAA0C,KAA1C,CAAhB;;AAEA,QAAI,KAAJ,EAAW;AACT,MAAA,OAAO,CAAC,OAAR,CAAgB,UAAA,MAAM,EAAG;AACvB,QAAA,MAAM,CAAC,IAAP,GAAc,MAAM,CAAC,MAAP,GAAgB,UAAhB,GAA6B,MAAM,CAAC,WAAlD;AACA,QAAA,MAAM,CAAC,KAAP,GAAe,UAAU,GAAG,MAAM,CAAC,WAAnC;AACD,OAHD;AAID;;AAED,WAAO,OAAP;AACD,GAXD;AAYD,CAfM","sourcesContent":["import { CalendarEventOverlapMode } from 'vuetify/types'\nimport { getOverlapGroupHandler } from './common'\n\nconst FULL_WIDTH = 100\n\nexport const column: CalendarEventOverlapMode = (events, firstWeekday, overlapThreshold) => {\n  const handler = getOverlapGroupHandler(firstWeekday)\n\n  return (day, dayEvents, timed, reset) => {\n    const visuals = handler.getVisuals(day, dayEvents, timed, reset)\n\n    if (timed) {\n      visuals.forEach(visual => {\n        visual.left = visual.column * FULL_WIDTH / visual.columnCount\n        visual.width = FULL_WIDTH / visual.columnCount\n      })\n    }\n\n    return visuals\n  }\n}\n"],"sourceRoot":"","file":"column.js"}

node_modules/vuetify/es5/components/VCalendar/modes/common.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVisuals = _getVisuals;
+exports.hasOverlap = hasOverlap;
+exports.setColumnCount = setColumnCount;
+exports.getRange = getRange;
+exports.getDayRange = getDayRange;
+exports.getNormalizedRange = getNormalizedRange;
+exports.getOpenGroup = getOpenGroup;
+exports.getOverlapGroupHandler = getOverlapGroupHandler;
+
+var _timestamp = require("../util/timestamp");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var MILLIS_IN_DAY = 86400000;
+
+function _getVisuals(events) {
+  var minStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var visuals = events.map(function (event) {
+    return {
+      event: event,
+      columnCount: 0,
+      column: 0,
+      left: 0,
+      width: 100
+    };
+  });
+  visuals.sort(function (a, b) {
+    return Math.max(minStart, a.event.startTimestampIdentifier) - Math.max(minStart, b.event.startTimestampIdentifier) || b.event.endTimestampIdentifier - a.event.endTimestampIdentifier;
+  });
+  return visuals;
+}
+
+function hasOverlap(s0, e0, s1, e1) {
+  var exclude = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  return exclude ? !(s0 >= e1 || e0 <= s1) : !(s0 > e1 || e0 < s1);
+}
+
+function setColumnCount(groups) {
+  groups.forEach(function (group) {
+    group.visuals.forEach(function (groupVisual) {
+      groupVisual.columnCount = groups.length;
+    });
+  });
+}
+
+function getRange(event) {
+  return [event.startTimestampIdentifier, event.endTimestampIdentifier];
+}
+
+function getDayRange(event) {
+  return [event.startIdentifier, event.endIdentifier];
+}
+
+function getNormalizedRange(event, dayStart) {
+  return [Math.max(dayStart, event.startTimestampIdentifier), Math.min(dayStart + MILLIS_IN_DAY, event.endTimestampIdentifier)];
+}
+
+function getOpenGroup(groups, start, end, timed) {
+  for (var i = 0; i < groups.length; i++) {
+    var group = groups[i];
+    var intersected = false;
+
+    if (hasOverlap(start, end, group.start, group.end, timed)) {
+      for (var k = 0; k < group.visuals.length; k++) {
+        var groupVisual = group.visuals[k];
+
+        var _ref = timed ? getRange(groupVisual.event) : getDayRange(groupVisual.event),
+            _ref2 = _slicedToArray(_ref, 2),
+            groupStart = _ref2[0],
+            groupEnd = _ref2[1];
+
+        if (hasOverlap(start, end, groupStart, groupEnd, timed)) {
+          intersected = true;
+          break;
+        }
+      }
+    }
+
+    if (!intersected) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+function getOverlapGroupHandler(firstWeekday) {
+  var handler = {
+    groups: [],
+    min: -1,
+    max: -1,
+    reset: function reset() {
+      handler.groups = [];
+      handler.min = handler.max = -1;
+    },
+    getVisuals: function getVisuals(day, dayEvents, timed) {
+      var reset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+      if (day.weekday === firstWeekday || reset) {
+        handler.reset();
+      }
+
+      var dayStart = (0, _timestamp.getTimestampIdentifier)(day);
+
+      var visuals = _getVisuals(dayEvents, dayStart);
+
+      visuals.forEach(function (visual) {
+        var _ref3 = timed ? getRange(visual.event) : getDayRange(visual.event),
+            _ref4 = _slicedToArray(_ref3, 2),
+            start = _ref4[0],
+            end = _ref4[1];
+
+        if (handler.groups.length > 0 && !hasOverlap(start, end, handler.min, handler.max, timed)) {
+          setColumnCount(handler.groups);
+          handler.reset();
+        }
+
+        var targetGroup = getOpenGroup(handler.groups, start, end, timed);
+
+        if (targetGroup === -1) {
+          targetGroup = handler.groups.length;
+          handler.groups.push({
+            start: start,
+            end: end,
+            visuals: []
+          });
+        }
+
+        var target = handler.groups[targetGroup];
+        target.visuals.push(visual);
+        target.start = Math.min(target.start, start);
+        target.end = Math.max(target.end, end);
+        visual.column = targetGroup;
+
+        if (handler.min === -1) {
+          handler.min = start;
+          handler.max = end;
+        } else {
+          handler.min = Math.min(handler.min, start);
+          handler.max = Math.max(handler.max, end);
+        }
+      });
+      setColumnCount(handler.groups);
+
+      if (timed) {
+        handler.reset();
+      }
+
+      return visuals;
+    }
+  };
+  return handler;
+}
+//# sourceMappingURL=common.js.map

node_modules/vuetify/es5/components/VCalendar/modes/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CalendarEventOverlapModes = void 0;
+
+var _stack = require("./stack");
+
+var _column = require("./column");
+
+var CalendarEventOverlapModes = {
+  stack: _stack.stack,
+  column: _column.column
+};
+exports.CalendarEventOverlapModes = CalendarEventOverlapModes;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VCalendar/modes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/modes/index.ts"],"names":[],"mappings":";;;;;;;AACA;;AACA;;AAEO,IAAM,yBAAyB,GAA6C;AACjF,EAAA,KAAK,EAAL,YADiF;AAEjF,EAAA,MAAM,EAAN;AAFiF,CAA5E","sourcesContent":["import { CalendarEventOverlapMode } from 'vuetify/types'\nimport { stack } from './stack'\nimport { column } from './column'\n\nexport const CalendarEventOverlapModes: Record<string, CalendarEventOverlapMode> = {\n  stack,\n  column,\n}\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VCalendar/modes/stack.js

@@ -0,0 +1,481 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stack = void 0;
+
+var _common = require("./common");
+
+var _timestamp = require("../util/timestamp");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var FULL_WIDTH = 100;
+var DEFAULT_OFFSET = 5;
+var WIDTH_MULTIPLIER = 1.7;
+/**
+ * Variation of column mode where events can be stacked. The priority of this
+ * mode is to stack events together taking up the least amount of space while
+ * trying to ensure the content of the event is always visible as well as its
+ * start and end. A sibling column has intersecting event content and must be
+ * placed beside each other. Non-sibling columns are offset by 5% from the
+ * previous column. The width is scaled by 1.7 so the events overlap and
+ * whitespace is reduced. If there is a hole in columns the event width is
+ * scaled up so it intersects with the next column. The columns have equal
+ * width in the space they are given. If the event doesn't have any to the
+ * right of it that intersect with it's content it's right side is extended
+ * to the right side.
+ */
+
+var stack = function stack(events, firstWeekday, overlapThreshold) {
+  var handler = (0, _common.getOverlapGroupHandler)(firstWeekday); // eslint-disable-next-line max-statements
+
+  return function (day, dayEvents, timed, reset) {
+    if (!timed) {
+      return handler.getVisuals(day, dayEvents, timed, reset);
+    }
+
+    var dayStart = (0, _timestamp.getTimestampIdentifier)(day);
+    var visuals = (0, _common.getVisuals)(dayEvents, dayStart);
+    var groups = getGroups(visuals, dayStart);
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = groups[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var group = _step.value;
+        var nodes = [];
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = group.visuals[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var visual = _step2.value;
+            var child = getNode(visual, dayStart);
+            var index = getNextIndex(child, nodes);
+
+            if (index === false) {
+              var parent = getParent(child, nodes);
+
+              if (parent) {
+                child.parent = parent;
+                child.sibling = (0, _common.hasOverlap)(child.start, child.end, parent.start, addTime(parent.start, overlapThreshold));
+                child.index = parent.index + 1;
+                parent.children.push(child);
+              }
+            } else {
+              var _getOverlappingRange = getOverlappingRange(child, nodes, index - 1, index - 1),
+                  _getOverlappingRange2 = _slicedToArray(_getOverlappingRange, 1),
+                  _parent = _getOverlappingRange2[0];
+
+              var children = getOverlappingRange(child, nodes, index + 1, index + nodes.length, true);
+              child.children = children;
+              child.index = index;
+
+              if (_parent) {
+                child.parent = _parent;
+                child.sibling = (0, _common.hasOverlap)(child.start, child.end, _parent.start, addTime(_parent.start, overlapThreshold));
+
+                _parent.children.push(child);
+              }
+
+              var _iteratorNormalCompletion3 = true;
+              var _didIteratorError3 = false;
+              var _iteratorError3 = undefined;
+
+              try {
+                for (var _iterator3 = children[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                  var grand = _step3.value;
+
+                  if (grand.parent === _parent) {
+                    grand.parent = child;
+                  }
+
+                  var grandNext = grand.index - child.index <= 1;
+
+                  if (grandNext && child.sibling && (0, _common.hasOverlap)(child.start, addTime(child.start, overlapThreshold), grand.start, grand.end)) {
+                    grand.sibling = true;
+                  }
+                }
+              } catch (err) {
+                _didIteratorError3 = true;
+                _iteratorError3 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                    _iterator3.return();
+                  }
+                } finally {
+                  if (_didIteratorError3) {
+                    throw _iteratorError3;
+                  }
+                }
+              }
+            }
+
+            nodes.push(child);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+
+        calculateBounds(nodes, overlapThreshold);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    visuals.sort(function (a, b) {
+      return a.left - b.left || a.event.startTimestampIdentifier - b.event.startTimestampIdentifier;
+    });
+    return visuals;
+  };
+};
+
+exports.stack = stack;
+
+function calculateBounds(nodes, overlapThreshold) {
+  var _iteratorNormalCompletion4 = true;
+  var _didIteratorError4 = false;
+  var _iteratorError4 = undefined;
+
+  try {
+    for (var _iterator4 = nodes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+      var node = _step4.value;
+      var visual = node.visual,
+          parent = node.parent;
+      var columns = getMaxChildIndex(node) + 1;
+      var spaceLeft = parent ? parent.visual.left : 0;
+      var spaceWidth = FULL_WIDTH - spaceLeft;
+      var offset = Math.min(DEFAULT_OFFSET, FULL_WIDTH / columns);
+      var columnWidthMultiplier = getColumnWidthMultiplier(node, nodes);
+      var columnOffset = spaceWidth / (columns - node.index + 1);
+      var columnWidth = spaceWidth / (columns - node.index + (node.sibling ? 1 : 0)) * columnWidthMultiplier;
+
+      if (parent) {
+        visual.left = node.sibling ? spaceLeft + columnOffset : spaceLeft + offset;
+      }
+
+      visual.width = hasFullWidth(node, nodes, overlapThreshold) ? FULL_WIDTH - visual.left : Math.min(FULL_WIDTH - visual.left, columnWidth * WIDTH_MULTIPLIER);
+    }
+  } catch (err) {
+    _didIteratorError4 = true;
+    _iteratorError4 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+        _iterator4.return();
+      }
+    } finally {
+      if (_didIteratorError4) {
+        throw _iteratorError4;
+      }
+    }
+  }
+}
+
+function getColumnWidthMultiplier(node, nodes) {
+  if (!node.children.length) {
+    return 1;
+  }
+
+  var maxColumn = node.index + nodes.length;
+  var minColumn = node.children.reduce(function (min, c) {
+    return Math.min(min, c.index);
+  }, maxColumn);
+  return minColumn - node.index;
+}
+
+function getOverlappingIndices(node, nodes) {
+  var indices = [];
+  var _iteratorNormalCompletion5 = true;
+  var _didIteratorError5 = false;
+  var _iteratorError5 = undefined;
+
+  try {
+    for (var _iterator5 = nodes[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+      var other = _step5.value;
+
+      if ((0, _common.hasOverlap)(node.start, node.end, other.start, other.end)) {
+        indices.push(other.index);
+      }
+    }
+  } catch (err) {
+    _didIteratorError5 = true;
+    _iteratorError5 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+        _iterator5.return();
+      }
+    } finally {
+      if (_didIteratorError5) {
+        throw _iteratorError5;
+      }
+    }
+  }
+
+  return indices;
+}
+
+function getNextIndex(node, nodes) {
+  var indices = getOverlappingIndices(node, nodes);
+  indices.sort();
+
+  for (var i = 0; i < indices.length; i++) {
+    if (i < indices[i]) {
+      return i;
+    }
+  }
+
+  return false;
+}
+
+function getOverlappingRange(node, nodes, indexMin, indexMax) {
+  var returnFirstColumn = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var overlapping = [];
+  var _iteratorNormalCompletion6 = true;
+  var _didIteratorError6 = false;
+  var _iteratorError6 = undefined;
+
+  try {
+    for (var _iterator6 = nodes[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+      var other = _step6.value;
+
+      if (other.index >= indexMin && other.index <= indexMax && (0, _common.hasOverlap)(node.start, node.end, other.start, other.end)) {
+        overlapping.push(other);
+      }
+    }
+  } catch (err) {
+    _didIteratorError6 = true;
+    _iteratorError6 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+        _iterator6.return();
+      }
+    } finally {
+      if (_didIteratorError6) {
+        throw _iteratorError6;
+      }
+    }
+  }
+
+  if (returnFirstColumn && overlapping.length > 0) {
+    var first = overlapping.reduce(function (min, n) {
+      return Math.min(min, n.index);
+    }, overlapping[0].index);
+    return overlapping.filter(function (n) {
+      return n.index === first;
+    });
+  }
+
+  return overlapping;
+}
+
+function getParent(node, nodes) {
+  var parent = null;
+  var _iteratorNormalCompletion7 = true;
+  var _didIteratorError7 = false;
+  var _iteratorError7 = undefined;
+
+  try {
+    for (var _iterator7 = nodes[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+      var other = _step7.value;
+
+      if ((0, _common.hasOverlap)(node.start, node.end, other.start, other.end) && (parent === null || other.index > parent.index)) {
+        parent = other;
+      }
+    }
+  } catch (err) {
+    _didIteratorError7 = true;
+    _iteratorError7 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+        _iterator7.return();
+      }
+    } finally {
+      if (_didIteratorError7) {
+        throw _iteratorError7;
+      }
+    }
+  }
+
+  return parent;
+}
+
+function hasFullWidth(node, nodes, overlapThreshold) {
+  var _iteratorNormalCompletion8 = true;
+  var _didIteratorError8 = false;
+  var _iteratorError8 = undefined;
+
+  try {
+    for (var _iterator8 = nodes[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+      var other = _step8.value;
+
+      if (other !== node && other.index > node.index && (0, _common.hasOverlap)(node.start, addTime(node.start, overlapThreshold), other.start, other.end)) {
+        return false;
+      }
+    }
+  } catch (err) {
+    _didIteratorError8 = true;
+    _iteratorError8 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+        _iterator8.return();
+      }
+    } finally {
+      if (_didIteratorError8) {
+        throw _iteratorError8;
+      }
+    }
+  }
+
+  return true;
+}
+
+function getGroups(visuals, dayStart) {
+  var groups = [];
+  var _iteratorNormalCompletion9 = true;
+  var _didIteratorError9 = false;
+  var _iteratorError9 = undefined;
+
+  try {
+    for (var _iterator9 = visuals[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
+      var visual = _step9.value;
+
+      var _getNormalizedRange = (0, _common.getNormalizedRange)(visual.event, dayStart),
+          _getNormalizedRange2 = _slicedToArray(_getNormalizedRange, 2),
+          start = _getNormalizedRange2[0],
+          end = _getNormalizedRange2[1];
+
+      var added = false;
+
+      for (var _i2 = 0, _groups = groups; _i2 < _groups.length; _i2++) {
+        var group = _groups[_i2];
+
+        if ((0, _common.hasOverlap)(start, end, group.start, group.end)) {
+          group.visuals.push(visual);
+          group.end = Math.max(group.end, end);
+          added = true;
+          break;
+        }
+      }
+
+      if (!added) {
+        groups.push({
+          start: start,
+          end: end,
+          visuals: [visual]
+        });
+      }
+    }
+  } catch (err) {
+    _didIteratorError9 = true;
+    _iteratorError9 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+        _iterator9.return();
+      }
+    } finally {
+      if (_didIteratorError9) {
+        throw _iteratorError9;
+      }
+    }
+  }
+
+  return groups;
+}
+
+function getNode(visual, dayStart) {
+  var _getNormalizedRange3 = (0, _common.getNormalizedRange)(visual.event, dayStart),
+      _getNormalizedRange4 = _slicedToArray(_getNormalizedRange3, 2),
+      start = _getNormalizedRange4[0],
+      end = _getNormalizedRange4[1];
+
+  return {
+    parent: null,
+    sibling: true,
+    index: 0,
+    visual: visual,
+    start: start,
+    end: end,
+    children: []
+  };
+}
+
+function getMaxChildIndex(node) {
+  var max = node.index;
+  var _iteratorNormalCompletion10 = true;
+  var _didIteratorError10 = false;
+  var _iteratorError10 = undefined;
+
+  try {
+    for (var _iterator10 = node.children[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+      var child = _step10.value;
+      var childMax = getMaxChildIndex(child);
+
+      if (childMax > max) {
+        max = childMax;
+      }
+    }
+  } catch (err) {
+    _didIteratorError10 = true;
+    _iteratorError10 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+        _iterator10.return();
+      }
+    } finally {
+      if (_didIteratorError10) {
+        throw _iteratorError10;
+      }
+    }
+  }
+
+  return max;
+}
+
+function addTime(identifier, minutes) {
+  var removeMinutes = identifier % 100;
+  var totalMinutes = removeMinutes + minutes;
+  var addHours = Math.floor(totalMinutes / 60);
+  var addMinutes = totalMinutes % 60;
+  return identifier - removeMinutes + addHours * 100 + addMinutes;
+}
+//# sourceMappingURL=stack.js.map

node_modules/vuetify/es5/components/VCalendar/util/events.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseEvent = parseEvent;
+exports.isEventOn = isEventOn;
+exports.isEventStart = isEventStart;
+exports.isEventOverlapping = isEventOverlapping;
+
+var _timestamp = require("./timestamp");
+
+function parseEvent(input, index, startProperty, endProperty) {
+  var timed = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var category = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+  var startInput = input[startProperty];
+  var endInput = input[endProperty];
+  var startParsed = (0, _timestamp.parseTimestamp)(startInput, true);
+  var endParsed = endInput ? (0, _timestamp.parseTimestamp)(endInput, true) : startParsed;
+  var start = (0, _timestamp.isTimedless)(startInput) ? (0, _timestamp.updateHasTime)(startParsed, timed) : startParsed;
+  var end = (0, _timestamp.isTimedless)(endInput) ? (0, _timestamp.updateHasTime)(endParsed, timed) : endParsed;
+  var startIdentifier = (0, _timestamp.getDayIdentifier)(start);
+  var startTimestampIdentifier = (0, _timestamp.getTimestampIdentifier)(start);
+  var endIdentifier = (0, _timestamp.getDayIdentifier)(end);
+  var endOffset = start.hasTime ? 0 : 2359;
+  var endTimestampIdentifier = (0, _timestamp.getTimestampIdentifier)(end) + endOffset;
+  var allDay = !start.hasTime;
+  return {
+    input: input,
+    start: start,
+    startIdentifier: startIdentifier,
+    startTimestampIdentifier: startTimestampIdentifier,
+    end: end,
+    endIdentifier: endIdentifier,
+    endTimestampIdentifier: endTimestampIdentifier,
+    allDay: allDay,
+    index: index,
+    category: category
+  };
+}
+
+function isEventOn(event, dayIdentifier) {
+  return dayIdentifier >= event.startIdentifier && dayIdentifier <= event.endIdentifier && dayIdentifier * _timestamp.OFFSET_TIME !== event.endTimestampIdentifier;
+}
+
+function isEventStart(event, day, dayIdentifier, firstWeekday) {
+  return dayIdentifier === event.startIdentifier || firstWeekday === day.weekday && isEventOn(event, dayIdentifier);
+}
+
+function isEventOverlapping(event, startIdentifier, endIdentifier) {
+  return startIdentifier <= event.endIdentifier && endIdentifier >= event.startIdentifier;
+}
+//# sourceMappingURL=events.js.map

node_modules/vuetify/es5/components/VCalendar/util/events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/util/events.ts"],"names":[],"mappings":";;;;;;;;;;AAAA;;AAUM,SAAU,UAAV,CACJ,KADI,EAEJ,KAFI,EAGJ,aAHI,EAIJ,WAJI,EAM4B;AAAA,MADhC,KACgC,uEADxB,KACwB;AAAA,MAAhC,QAAgC,uEAAL,KAAK;AAEhC,MAAM,UAAU,GAAG,KAAK,CAAC,aAAD,CAAxB;AACA,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAD,CAAtB;AACA,MAAM,WAAW,GAAsB,+BAAe,UAAf,EAA2B,IAA3B,CAAvC;AACA,MAAM,SAAS,GAAuB,QAAQ,GAAG,+BAAe,QAAf,EAAyB,IAAzB,CAAH,GAAoC,WAAlF;AACA,MAAM,KAAK,GAAsB,4BAAY,UAAZ,IAC7B,8BAAc,WAAd,EAA2B,KAA3B,CAD6B,GAE7B,WAFJ;AAGA,MAAM,GAAG,GAAsB,4BAAY,QAAZ,IAC3B,8BAAc,SAAd,EAAyB,KAAzB,CAD2B,GAE3B,SAFJ;AAGA,MAAM,eAAe,GAAW,iCAAiB,KAAjB,CAAhC;AACA,MAAM,wBAAwB,GAAW,uCAAuB,KAAvB,CAAzC;AACA,MAAM,aAAa,GAAW,iCAAiB,GAAjB,CAA9B;AACA,MAAM,SAAS,GAAW,KAAK,CAAC,OAAN,GAAgB,CAAhB,GAAoB,IAA9C;AACA,MAAM,sBAAsB,GAAW,uCAAuB,GAAvB,IAA8B,SAArE;AACA,MAAM,MAAM,GAAY,CAAC,KAAK,CAAC,OAA/B;AAEA,SAAO;AAAE,IAAA,KAAK,EAAL,KAAF;AAAS,IAAA,KAAK,EAAL,KAAT;AAAgB,IAAA,eAAe,EAAf,eAAhB;AAAiC,IAAA,wBAAwB,EAAxB,wBAAjC;AAA2D,IAAA,GAAG,EAAH,GAA3D;AAAgE,IAAA,aAAa,EAAb,aAAhE;AAA+E,IAAA,sBAAsB,EAAtB,sBAA/E;AAAuG,IAAA,MAAM,EAAN,MAAvG;AAA+G,IAAA,KAAK,EAAL,KAA/G;AAAsH,IAAA,QAAQ,EAAR;AAAtH,GAAP;AACD;;AAEK,SAAU,SAAV,CAAqB,KAArB,EAAiD,aAAjD,EAAsE;AAC1E,SAAO,aAAa,IAAI,KAAK,CAAC,eAAvB,IACL,aAAa,IAAI,KAAK,CAAC,aADlB,IAEL,aAAa,GAAG,sBAAhB,KAAgC,KAAK,CAAC,sBAFxC;AAGD;;AAEK,SAAU,YAAV,CAAwB,KAAxB,EAAoD,GAApD,EAA4E,aAA5E,EAAmG,YAAnG,EAAuH;AAC3H,SAAO,aAAa,KAAK,KAAK,CAAC,eAAxB,IAA4C,YAAY,KAAK,GAAG,CAAC,OAArB,IAAgC,SAAS,CAAC,KAAD,EAAQ,aAAR,CAA5F;AACD;;AAEK,SAAU,kBAAV,CAA8B,KAA9B,EAA0D,eAA1D,EAAmF,aAAnF,EAAwG;AAC5G,SAAO,eAAe,IAAI,KAAK,CAAC,aAAzB,IAA0C,aAAa,IAAI,KAAK,CAAC,eAAxE;AACD","sourcesContent":["import {\n  parseTimestamp,\n  getDayIdentifier,\n  getTimestampIdentifier,\n  OFFSET_TIME,\n  isTimedless,\n  updateHasTime,\n} from './timestamp'\nimport { CalendarTimestamp, CalendarEvent, CalendarEventParsed } from 'vuetify/types'\n\nexport function parseEvent (\n  input: CalendarEvent,\n  index: number,\n  startProperty: string,\n  endProperty: string,\n  timed = false,\n  category: string | false = false,\n): CalendarEventParsed {\n  const startInput = input[startProperty]\n  const endInput = input[endProperty]\n  const startParsed: CalendarTimestamp = parseTimestamp(startInput, true)\n  const endParsed: CalendarTimestamp = (endInput ? parseTimestamp(endInput, true) : startParsed)\n  const start: CalendarTimestamp = isTimedless(startInput)\n    ? updateHasTime(startParsed, timed)\n    : startParsed\n  const end: CalendarTimestamp = isTimedless(endInput)\n    ? updateHasTime(endParsed, timed)\n    : endParsed\n  const startIdentifier: number = getDayIdentifier(start)\n  const startTimestampIdentifier: number = getTimestampIdentifier(start)\n  const endIdentifier: number = getDayIdentifier(end)\n  const endOffset: number = start.hasTime ? 0 : 2359\n  const endTimestampIdentifier: number = getTimestampIdentifier(end) + endOffset\n  const allDay: boolean = !start.hasTime\n\n  return { input, start, startIdentifier, startTimestampIdentifier, end, endIdentifier, endTimestampIdentifier, allDay, index, category }\n}\n\nexport function isEventOn (event: CalendarEventParsed, dayIdentifier: number): boolean {\n  return dayIdentifier >= event.startIdentifier &&\n    dayIdentifier <= event.endIdentifier &&\n    dayIdentifier * OFFSET_TIME !== event.endTimestampIdentifier\n}\n\nexport function isEventStart (event: CalendarEventParsed, day: CalendarTimestamp, dayIdentifier: number, firstWeekday: number): boolean {\n  return dayIdentifier === event.startIdentifier || (firstWeekday === day.weekday && isEventOn(event, dayIdentifier))\n}\n\nexport function isEventOverlapping (event: CalendarEventParsed, startIdentifier: number, endIdentifier: number): boolean {\n  return startIdentifier <= event.endIdentifier && endIdentifier >= event.startIdentifier\n}\n"],"sourceRoot":"","file":"events.js"}

node_modules/vuetify/es5/components/VCalendar/util/props.js

@@ -0,0 +1,281 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateNumber = validateNumber;
+exports.validateWeekdays = validateWeekdays;
+exports.default = void 0;
+
+var _timestamp = require("./timestamp");
+
+var _modes = require("../modes");
+
+var _default2 = {
+  base: {
+    start: {
+      type: [String, Number, Date],
+      validate: _timestamp.validateTimestamp,
+      default: function _default() {
+        return (0, _timestamp.parseDate)(new Date()).date;
+      }
+    },
+    end: {
+      type: [String, Number, Date],
+      validate: _timestamp.validateTimestamp
+    },
+    weekdays: {
+      type: [Array, String],
+      default: function _default() {
+        return [0, 1, 2, 3, 4, 5, 6];
+      },
+      validate: validateWeekdays
+    },
+    hideHeader: {
+      type: Boolean
+    },
+    shortWeekdays: {
+      type: Boolean,
+      default: true
+    },
+    weekdayFormat: {
+      type: Function,
+      default: null
+    },
+    dayFormat: {
+      type: Function,
+      default: null
+    }
+  },
+  intervals: {
+    maxDays: {
+      type: Number,
+      default: 7
+    },
+    shortIntervals: {
+      type: Boolean,
+      default: true
+    },
+    intervalHeight: {
+      type: [Number, String],
+      default: 48,
+      validate: validateNumber
+    },
+    intervalWidth: {
+      type: [Number, String],
+      default: 60,
+      validate: validateNumber
+    },
+    intervalMinutes: {
+      type: [Number, String],
+      default: 60,
+      validate: validateNumber
+    },
+    firstInterval: {
+      type: [Number, String],
+      default: 0,
+      validate: validateNumber
+    },
+    firstTime: {
+      type: [Number, String, Object],
+      validate: _timestamp.validateTime
+    },
+    intervalCount: {
+      type: [Number, String],
+      default: 24,
+      validate: validateNumber
+    },
+    intervalFormat: {
+      type: Function,
+      default: null
+    },
+    intervalStyle: {
+      type: Function,
+      default: null
+    },
+    showIntervalLabel: {
+      type: Function,
+      default: null
+    }
+  },
+  weeks: {
+    localeFirstDayOfYear: {
+      type: [String, Number],
+      default: 0
+    },
+    minWeeks: {
+      validate: validateNumber,
+      default: 1
+    },
+    shortMonths: {
+      type: Boolean,
+      default: true
+    },
+    showMonthOnFirst: {
+      type: Boolean,
+      default: true
+    },
+    showWeek: Boolean,
+    monthFormat: {
+      type: Function,
+      default: null
+    }
+  },
+  calendar: {
+    type: {
+      type: String,
+      default: 'month'
+    },
+    value: {
+      type: [String, Number, Date],
+      validate: _timestamp.validateTimestamp
+    }
+  },
+  category: {
+    categories: {
+      type: [Array, String],
+      default: ''
+    },
+    categoryHideDynamic: {
+      type: Boolean
+    },
+    categoryShowAll: {
+      type: Boolean
+    },
+    categoryForInvalid: {
+      type: String,
+      default: ''
+    },
+    categoryDays: {
+      type: [Number, String],
+      default: 1,
+      validate: function validate(x) {
+        return isFinite(parseInt(x)) && parseInt(x) > 0;
+      }
+    }
+  },
+  events: {
+    events: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    eventStart: {
+      type: String,
+      default: 'start'
+    },
+    eventEnd: {
+      type: String,
+      default: 'end'
+    },
+    eventTimed: {
+      type: [String, Function],
+      default: 'timed'
+    },
+    eventCategory: {
+      type: [String, Function],
+      default: 'category'
+    },
+    eventHeight: {
+      type: Number,
+      default: 20
+    },
+    eventColor: {
+      type: [String, Function],
+      default: 'primary'
+    },
+    eventTextColor: {
+      type: [String, Function],
+      default: 'white'
+    },
+    eventName: {
+      type: [String, Function],
+      default: 'name'
+    },
+    eventOverlapThreshold: {
+      type: [String, Number],
+      default: 60
+    },
+    eventOverlapMode: {
+      type: [String, Function],
+      default: 'stack',
+      validate: function validate(mode) {
+        return mode in _modes.CalendarEventOverlapModes || typeof mode === 'function';
+      }
+    },
+    eventMore: {
+      type: Boolean,
+      default: true
+    },
+    eventMoreText: {
+      type: String,
+      default: '$vuetify.calendar.moreEvents'
+    },
+    eventRipple: {
+      type: [Boolean, Object],
+      default: null
+    },
+    eventMarginBottom: {
+      type: Number,
+      default: 1
+    }
+  }
+};
+exports.default = _default2;
+
+function validateNumber(input) {
+  return isFinite(parseInt(input));
+}
+
+function validateWeekdays(input) {
+  if (typeof input === 'string') {
+    input = input.split(',');
+  }
+
+  if (Array.isArray(input)) {
+    var ints = input.map(function (x) {
+      return parseInt(x);
+    });
+
+    if (ints.length > _timestamp.DAYS_IN_WEEK || ints.length === 0) {
+      return false;
+    }
+
+    var visited = {};
+    var wrapped = false;
+
+    for (var i = 0; i < ints.length; i++) {
+      var x = ints[i];
+
+      if (!isFinite(x) || x < 0 || x >= _timestamp.DAYS_IN_WEEK) {
+        return false;
+      }
+
+      if (i > 0) {
+        var d = x - ints[i - 1];
+
+        if (d < 0) {
+          if (wrapped) {
+            return false;
+          }
+
+          wrapped = true;
+        } else if (d === 0) {
+          return false;
+        }
+      }
+
+      if (visited[x]) {
+        return false;
+      }
+
+      visited[x] = true;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+//# sourceMappingURL=props.js.map

node_modules/vuetify/es5/components/VCalendar/util/timestamp.js

@@ -0,0 +1,570 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStartOfWeek = getStartOfWeek;
+exports.getEndOfWeek = getEndOfWeek;
+exports.getStartOfMonth = getStartOfMonth;
+exports.getEndOfMonth = getEndOfMonth;
+exports.validateTime = validateTime;
+exports.parseTime = parseTime;
+exports.validateTimestamp = validateTimestamp;
+exports.parseTimestamp = parseTimestamp;
+exports.parseDate = parseDate;
+exports.getDayIdentifier = getDayIdentifier;
+exports.getTimeIdentifier = getTimeIdentifier;
+exports.getTimestampIdentifier = getTimestampIdentifier;
+exports.updateRelative = updateRelative;
+exports.isTimedless = isTimedless;
+exports.updateHasTime = updateHasTime;
+exports.updateMinutes = updateMinutes;
+exports.updateWeekday = updateWeekday;
+exports.updateFormatted = updateFormatted;
+exports.getWeekday = getWeekday;
+exports.daysInMonth = daysInMonth;
+exports.copyTimestamp = copyTimestamp;
+exports.padNumber = padNumber;
+exports.getDate = getDate;
+exports.getTime = getTime;
+exports.nextMinutes = nextMinutes;
+exports.nextDay = nextDay;
+exports.prevDay = prevDay;
+exports.relativeDays = relativeDays;
+exports.diffMinutes = diffMinutes;
+exports.findWeekday = findWeekday;
+exports.getWeekdaySkips = getWeekdaySkips;
+exports.timestampToDate = timestampToDate;
+exports.createDayList = createDayList;
+exports.createIntervalList = createIntervalList;
+exports.createNativeLocaleFormatter = createNativeLocaleFormatter;
+exports.OFFSET_TIME = exports.OFFSET_HOUR = exports.OFFSET_MONTH = exports.OFFSET_YEAR = exports.FIRST_HOUR = exports.HOUR_MAX = exports.HOURS_IN_DAY = exports.MINUTES_IN_DAY = exports.MINUTE_MAX = exports.MINUTES_IN_HOUR = exports.DAYS_IN_WEEK = exports.DAY_MIN = exports.MONTH_MIN = exports.MONTH_MAX = exports.DAYS_IN_MONTH_MAX = exports.DAYS_IN_MONTH_MIN = exports.DAYS_IN_MONTH_LEAP = exports.DAYS_IN_MONTH = exports.PARSE_TIME = exports.PARSE_REGEX = void 0;
+
+var _dateTimeUtils = require("../../../util/dateTimeUtils");
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var PARSE_REGEX = /^(\d{4})-(\d{1,2})(-(\d{1,2}))?([^\d]+(\d{1,2}))?(:(\d{1,2}))?(:(\d{1,2}))?$/;
+exports.PARSE_REGEX = PARSE_REGEX;
+var PARSE_TIME = /(\d\d?)(:(\d\d?)|)(:(\d\d?)|)/;
+exports.PARSE_TIME = PARSE_TIME;
+var DAYS_IN_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+exports.DAYS_IN_MONTH = DAYS_IN_MONTH;
+var DAYS_IN_MONTH_LEAP = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+exports.DAYS_IN_MONTH_LEAP = DAYS_IN_MONTH_LEAP;
+var DAYS_IN_MONTH_MIN = 28;
+exports.DAYS_IN_MONTH_MIN = DAYS_IN_MONTH_MIN;
+var DAYS_IN_MONTH_MAX = 31;
+exports.DAYS_IN_MONTH_MAX = DAYS_IN_MONTH_MAX;
+var MONTH_MAX = 12;
+exports.MONTH_MAX = MONTH_MAX;
+var MONTH_MIN = 1;
+exports.MONTH_MIN = MONTH_MIN;
+var DAY_MIN = 1;
+exports.DAY_MIN = DAY_MIN;
+var DAYS_IN_WEEK = 7;
+exports.DAYS_IN_WEEK = DAYS_IN_WEEK;
+var MINUTES_IN_HOUR = 60;
+exports.MINUTES_IN_HOUR = MINUTES_IN_HOUR;
+var MINUTE_MAX = 59;
+exports.MINUTE_MAX = MINUTE_MAX;
+var MINUTES_IN_DAY = 24 * 60;
+exports.MINUTES_IN_DAY = MINUTES_IN_DAY;
+var HOURS_IN_DAY = 24;
+exports.HOURS_IN_DAY = HOURS_IN_DAY;
+var HOUR_MAX = 23;
+exports.HOUR_MAX = HOUR_MAX;
+var FIRST_HOUR = 0;
+exports.FIRST_HOUR = FIRST_HOUR;
+var OFFSET_YEAR = 10000;
+exports.OFFSET_YEAR = OFFSET_YEAR;
+var OFFSET_MONTH = 100;
+exports.OFFSET_MONTH = OFFSET_MONTH;
+var OFFSET_HOUR = 100;
+exports.OFFSET_HOUR = OFFSET_HOUR;
+var OFFSET_TIME = 10000;
+exports.OFFSET_TIME = OFFSET_TIME;
+
+function getStartOfWeek(timestamp, weekdays, today) {
+  var start = copyTimestamp(timestamp);
+  findWeekday(start, weekdays[0], prevDay);
+  updateFormatted(start);
+
+  if (today) {
+    updateRelative(start, today, start.hasTime);
+  }
+
+  return start;
+}
+
+function getEndOfWeek(timestamp, weekdays, today) {
+  var end = copyTimestamp(timestamp);
+  findWeekday(end, weekdays[weekdays.length - 1]);
+  updateFormatted(end);
+
+  if (today) {
+    updateRelative(end, today, end.hasTime);
+  }
+
+  return end;
+}
+
+function getStartOfMonth(timestamp) {
+  var start = copyTimestamp(timestamp);
+  start.day = DAY_MIN;
+  updateWeekday(start);
+  updateFormatted(start);
+  return start;
+}
+
+function getEndOfMonth(timestamp) {
+  var end = copyTimestamp(timestamp);
+  end.day = daysInMonth(end.year, end.month);
+  updateWeekday(end);
+  updateFormatted(end);
+  return end;
+}
+
+function validateTime(input) {
+  return typeof input === 'number' && isFinite(input) || !!PARSE_TIME.exec(input) || _typeof(input) === 'object' && isFinite(input.hour) && isFinite(input.minute);
+}
+
+function parseTime(input) {
+  if (typeof input === 'number') {
+    // when a number is given, it's minutes since 12:00am
+    return input;
+  } else if (typeof input === 'string') {
+    // when a string is given, it's a hh:mm:ss format where seconds are optional
+    var parts = PARSE_TIME.exec(input);
+
+    if (!parts) {
+      return false;
+    }
+
+    return parseInt(parts[1]) * 60 + parseInt(parts[3] || 0);
+  } else if (_typeof(input) === 'object') {
+    // when an object is given, it must have hour and minute
+    if (typeof input.hour !== 'number' || typeof input.minute !== 'number') {
+      return false;
+    }
+
+    return input.hour * 60 + input.minute;
+  } else {
+    // unsupported type
+    return false;
+  }
+}
+
+function validateTimestamp(input) {
+  return typeof input === 'number' && isFinite(input) || typeof input === 'string' && !!PARSE_REGEX.exec(input) || input instanceof Date;
+}
+
+function parseTimestamp(input) {
+  var required = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var now = arguments.length > 2 ? arguments[2] : undefined;
+
+  if (typeof input === 'number' && isFinite(input)) {
+    input = new Date(input);
+  }
+
+  if (input instanceof Date) {
+    var date = parseDate(input);
+
+    if (now) {
+      updateRelative(date, now, date.hasTime);
+    }
+
+    return date;
+  }
+
+  if (typeof input !== 'string') {
+    if (required) {
+      throw new Error("".concat(input, " is not a valid timestamp. It must be a Date, number of seconds since Epoch, or a string in the format of YYYY-MM-DD or YYYY-MM-DD hh:mm. Zero-padding is optional and seconds are ignored."));
+    }
+
+    return null;
+  } // YYYY-MM-DD hh:mm:ss
+
+
+  var parts = PARSE_REGEX.exec(input);
+
+  if (!parts) {
+    if (required) {
+      throw new Error("".concat(input, " is not a valid timestamp. It must be a Date, number of seconds since Epoch, or a string in the format of YYYY-MM-DD or YYYY-MM-DD hh:mm. Zero-padding is optional and seconds are ignored."));
+    }
+
+    return null;
+  }
+
+  var timestamp = {
+    date: input,
+    time: '',
+    year: parseInt(parts[1]),
+    month: parseInt(parts[2]),
+    day: parseInt(parts[4]) || 1,
+    hour: parseInt(parts[6]) || 0,
+    minute: parseInt(parts[8]) || 0,
+    weekday: 0,
+    hasDay: !!parts[4],
+    hasTime: !!(parts[6] && parts[8]),
+    past: false,
+    present: false,
+    future: false
+  };
+  updateWeekday(timestamp);
+  updateFormatted(timestamp);
+
+  if (now) {
+    updateRelative(timestamp, now, timestamp.hasTime);
+  }
+
+  return timestamp;
+}
+
+function parseDate(date) {
+  return updateFormatted({
+    date: '',
+    time: '',
+    year: date.getFullYear(),
+    month: date.getMonth() + 1,
+    day: date.getDate(),
+    weekday: date.getDay(),
+    hour: date.getHours(),
+    minute: date.getMinutes(),
+    hasDay: true,
+    hasTime: true,
+    past: false,
+    present: true,
+    future: false
+  });
+}
+
+function getDayIdentifier(timestamp) {
+  return timestamp.year * OFFSET_YEAR + timestamp.month * OFFSET_MONTH + timestamp.day;
+}
+
+function getTimeIdentifier(timestamp) {
+  return timestamp.hour * OFFSET_HOUR + timestamp.minute;
+}
+
+function getTimestampIdentifier(timestamp) {
+  return getDayIdentifier(timestamp) * OFFSET_TIME + getTimeIdentifier(timestamp);
+}
+
+function updateRelative(timestamp, now) {
+  var time = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var a = getDayIdentifier(now);
+  var b = getDayIdentifier(timestamp);
+  var present = a === b;
+
+  if (timestamp.hasTime && time && present) {
+    a = getTimeIdentifier(now);
+    b = getTimeIdentifier(timestamp);
+    present = a === b;
+  }
+
+  timestamp.past = b < a;
+  timestamp.present = present;
+  timestamp.future = b > a;
+  return timestamp;
+}
+
+function isTimedless(input) {
+  return input instanceof Date || typeof input === 'number' && isFinite(input);
+}
+
+function updateHasTime(timestamp, hasTime, now) {
+  if (timestamp.hasTime !== hasTime) {
+    timestamp.hasTime = hasTime;
+
+    if (!hasTime) {
+      timestamp.hour = HOUR_MAX;
+      timestamp.minute = MINUTE_MAX;
+      timestamp.time = getTime(timestamp);
+    }
+
+    if (now) {
+      updateRelative(timestamp, now, timestamp.hasTime);
+    }
+  }
+
+  return timestamp;
+}
+
+function updateMinutes(timestamp, minutes, now) {
+  timestamp.hasTime = true;
+  timestamp.hour = Math.floor(minutes / MINUTES_IN_HOUR);
+  timestamp.minute = minutes % MINUTES_IN_HOUR;
+  timestamp.time = getTime(timestamp);
+
+  if (now) {
+    updateRelative(timestamp, now, true);
+  }
+
+  return timestamp;
+}
+
+function updateWeekday(timestamp) {
+  timestamp.weekday = getWeekday(timestamp);
+  return timestamp;
+}
+
+function updateFormatted(timestamp) {
+  timestamp.time = getTime(timestamp);
+  timestamp.date = getDate(timestamp);
+  return timestamp;
+}
+
+function getWeekday(timestamp) {
+  if (timestamp.hasDay) {
+    var _ = Math.floor;
+    var k = timestamp.day;
+    var m = (timestamp.month + 9) % MONTH_MAX + 1;
+
+    var C = _(timestamp.year / 100);
+
+    var Y = timestamp.year % 100 - (timestamp.month <= 2 ? 1 : 0);
+    return ((k + _(2.6 * m - 0.2) - 2 * C + Y + _(Y / 4) + _(C / 4)) % 7 + 7) % 7;
+  }
+
+  return timestamp.weekday;
+}
+
+function daysInMonth(year, month) {
+  return (0, _dateTimeUtils.isLeapYear)(year) ? DAYS_IN_MONTH_LEAP[month] : DAYS_IN_MONTH[month];
+}
+
+function copyTimestamp(timestamp) {
+  var date = timestamp.date,
+      time = timestamp.time,
+      year = timestamp.year,
+      month = timestamp.month,
+      day = timestamp.day,
+      weekday = timestamp.weekday,
+      hour = timestamp.hour,
+      minute = timestamp.minute,
+      hasDay = timestamp.hasDay,
+      hasTime = timestamp.hasTime,
+      past = timestamp.past,
+      present = timestamp.present,
+      future = timestamp.future;
+  return {
+    date: date,
+    time: time,
+    year: year,
+    month: month,
+    day: day,
+    weekday: weekday,
+    hour: hour,
+    minute: minute,
+    hasDay: hasDay,
+    hasTime: hasTime,
+    past: past,
+    present: present,
+    future: future
+  };
+}
+
+function padNumber(x, length) {
+  var padded = String(x);
+
+  while (padded.length < length) {
+    padded = '0' + padded;
+  }
+
+  return padded;
+}
+
+function getDate(timestamp) {
+  var str = "".concat(padNumber(timestamp.year, 4), "-").concat(padNumber(timestamp.month, 2));
+  if (timestamp.hasDay) str += "-".concat(padNumber(timestamp.day, 2));
+  return str;
+}
+
+function getTime(timestamp) {
+  if (!timestamp.hasTime) {
+    return '';
+  }
+
+  return "".concat(padNumber(timestamp.hour, 2), ":").concat(padNumber(timestamp.minute, 2));
+}
+
+function nextMinutes(timestamp, minutes) {
+  timestamp.minute += minutes;
+
+  while (timestamp.minute > MINUTES_IN_HOUR) {
+    timestamp.minute -= MINUTES_IN_HOUR;
+    timestamp.hour++;
+
+    if (timestamp.hour >= HOURS_IN_DAY) {
+      nextDay(timestamp);
+      timestamp.hour = FIRST_HOUR;
+    }
+  }
+
+  return timestamp;
+}
+
+function nextDay(timestamp) {
+  timestamp.day++;
+  timestamp.weekday = (timestamp.weekday + 1) % DAYS_IN_WEEK;
+
+  if (timestamp.day > DAYS_IN_MONTH_MIN && timestamp.day > daysInMonth(timestamp.year, timestamp.month)) {
+    timestamp.day = DAY_MIN;
+    timestamp.month++;
+
+    if (timestamp.month > MONTH_MAX) {
+      timestamp.month = MONTH_MIN;
+      timestamp.year++;
+    }
+  }
+
+  return timestamp;
+}
+
+function prevDay(timestamp) {
+  timestamp.day--;
+  timestamp.weekday = (timestamp.weekday + 6) % DAYS_IN_WEEK;
+
+  if (timestamp.day < DAY_MIN) {
+    timestamp.month--;
+
+    if (timestamp.month < MONTH_MIN) {
+      timestamp.year--;
+      timestamp.month = MONTH_MAX;
+    }
+
+    timestamp.day = daysInMonth(timestamp.year, timestamp.month);
+  }
+
+  return timestamp;
+}
+
+function relativeDays(timestamp) {
+  var mover = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : nextDay;
+  var days = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+
+  while (--days >= 0) {
+    mover(timestamp);
+  }
+
+  return timestamp;
+}
+
+function diffMinutes(min, max) {
+  var Y = (max.year - min.year) * 525600;
+  var M = (max.month - min.month) * 43800;
+  var D = (max.day - min.day) * 1440;
+  var h = (max.hour - min.hour) * 60;
+  var m = max.minute - min.minute;
+  return Y + M + D + h + m;
+}
+
+function findWeekday(timestamp, weekday) {
+  var mover = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : nextDay;
+  var maxDays = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 6;
+
+  while (timestamp.weekday !== weekday && --maxDays >= 0) {
+    mover(timestamp);
+  }
+
+  return timestamp;
+}
+
+function getWeekdaySkips(weekdays) {
+  var skips = [1, 1, 1, 1, 1, 1, 1];
+  var filled = [0, 0, 0, 0, 0, 0, 0];
+
+  for (var i = 0; i < weekdays.length; i++) {
+    filled[weekdays[i]] = 1;
+  }
+
+  for (var k = 0; k < DAYS_IN_WEEK; k++) {
+    var skip = 1;
+
+    for (var j = 1; j < DAYS_IN_WEEK; j++) {
+      var next = (k + j) % DAYS_IN_WEEK;
+
+      if (filled[next]) {
+        break;
+      }
+
+      skip++;
+    }
+
+    skips[k] = filled[k] * skip;
+  }
+
+  return skips;
+}
+
+function timestampToDate(timestamp) {
+  var time = "".concat(padNumber(timestamp.hour, 2), ":").concat(padNumber(timestamp.minute, 2));
+  var date = timestamp.date;
+  return new Date("".concat(date, "T").concat(time, ":00+00:00"));
+}
+
+function createDayList(start, end, now, weekdaySkips) {
+  var max = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 42;
+  var min = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
+  var stop = getDayIdentifier(end);
+  var days = [];
+  var current = copyTimestamp(start);
+  var currentIdentifier = 0;
+  var stopped = currentIdentifier === stop;
+
+  if (stop < getDayIdentifier(start)) {
+    throw new Error('End date is earlier than start date.');
+  }
+
+  while ((!stopped || days.length < min) && days.length < max) {
+    currentIdentifier = getDayIdentifier(current);
+    stopped = stopped || currentIdentifier === stop;
+
+    if (weekdaySkips[current.weekday] === 0) {
+      current = nextDay(current);
+      continue;
+    }
+
+    var day = copyTimestamp(current);
+    updateFormatted(day);
+    updateRelative(day, now);
+    days.push(day);
+    current = relativeDays(current, nextDay, weekdaySkips[current.weekday]);
+  }
+
+  if (!days.length) throw new Error('No dates found using specified start date, end date, and weekdays.');
+  return days;
+}
+
+function createIntervalList(timestamp, first, minutes, count, now) {
+  var intervals = [];
+
+  for (var i = 0; i < count; i++) {
+    var mins = first + i * minutes;
+    var int = copyTimestamp(timestamp);
+    intervals.push(updateMinutes(int, mins, now));
+  }
+
+  return intervals;
+}
+
+function createNativeLocaleFormatter(locale, getOptions) {
+  var emptyFormatter = function emptyFormatter(_t, _s) {
+    return '';
+  };
+
+  if (typeof Intl === 'undefined' || typeof Intl.DateTimeFormat === 'undefined') {
+    return emptyFormatter;
+  }
+
+  return function (timestamp, short) {
+    try {
+      var intlFormatter = new Intl.DateTimeFormat(locale || undefined, getOptions(timestamp, short));
+      return intlFormatter.format(timestampToDate(timestamp));
+    } catch (e) {
+      return '';
+    }
+  };
+}
+//# sourceMappingURL=timestamp.js.map