V1

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

@@ -0,0 +1,37 @@
+import { parseTimestamp, getDayIdentifier, getTimestampIdentifier, OFFSET_TIME, isTimedless, updateHasTime } from './timestamp';
+export function parseEvent(input, index, startProperty, endProperty, timed = false, category = false) {
+  const startInput = input[startProperty];
+  const endInput = input[endProperty];
+  const startParsed = parseTimestamp(startInput, true);
+  const endParsed = endInput ? parseTimestamp(endInput, true) : startParsed;
+  const start = isTimedless(startInput) ? updateHasTime(startParsed, timed) : startParsed;
+  const end = isTimedless(endInput) ? updateHasTime(endParsed, timed) : endParsed;
+  const startIdentifier = getDayIdentifier(start);
+  const startTimestampIdentifier = getTimestampIdentifier(start);
+  const endIdentifier = getDayIdentifier(end);
+  const endOffset = start.hasTime ? 0 : 2359;
+  const endTimestampIdentifier = getTimestampIdentifier(end) + endOffset;
+  const allDay = !start.hasTime;
+  return {
+    input,
+    start,
+    startIdentifier,
+    startTimestampIdentifier,
+    end,
+    endIdentifier,
+    endTimestampIdentifier,
+    allDay,
+    index,
+    category
+  };
+}
+export function isEventOn(event, dayIdentifier) {
+  return dayIdentifier >= event.startIdentifier && dayIdentifier <= event.endIdentifier && dayIdentifier * OFFSET_TIME !== event.endTimestampIdentifier;
+}
+export function isEventStart(event, day, dayIdentifier, firstWeekday) {
+  return dayIdentifier === event.startIdentifier || firstWeekday === day.weekday && isEventOn(event, dayIdentifier);
+}
+export function isEventOverlapping(event, startIdentifier, endIdentifier) {
+  return startIdentifier <= event.endIdentifier && endIdentifier >= event.startIdentifier;
+}
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/util/events.ts"],"names":[],"mappings":"AAAA,SACE,cADF,EAEE,gBAFF,EAGE,sBAHF,EAIE,WAJF,EAKE,WALF,EAME,aANF,QAOO,aAPP;AAUA,OAAM,SAAU,UAAV,CACJ,KADI,EAEJ,KAFI,EAGJ,aAHI,EAIJ,WAJI,EAKJ,KAAK,GAAG,KALJ,EAMJ,QAAA,GAA2B,KANvB,EAM4B;AAEhC,QAAM,UAAU,GAAG,KAAK,CAAC,aAAD,CAAxB;AACA,QAAM,QAAQ,GAAG,KAAK,CAAC,WAAD,CAAtB;AACA,QAAM,WAAW,GAAsB,cAAc,CAAC,UAAD,EAAa,IAAb,CAArD;AACA,QAAM,SAAS,GAAuB,QAAQ,GAAG,cAAc,CAAC,QAAD,EAAW,IAAX,CAAjB,GAAoC,WAAlF;AACA,QAAM,KAAK,GAAsB,WAAW,CAAC,UAAD,CAAX,GAC7B,aAAa,CAAC,WAAD,EAAc,KAAd,CADgB,GAE7B,WAFJ;AAGA,QAAM,GAAG,GAAsB,WAAW,CAAC,QAAD,CAAX,GAC3B,aAAa,CAAC,SAAD,EAAY,KAAZ,CADc,GAE3B,SAFJ;AAGA,QAAM,eAAe,GAAW,gBAAgB,CAAC,KAAD,CAAhD;AACA,QAAM,wBAAwB,GAAW,sBAAsB,CAAC,KAAD,CAA/D;AACA,QAAM,aAAa,GAAW,gBAAgB,CAAC,GAAD,CAA9C;AACA,QAAM,SAAS,GAAW,KAAK,CAAC,OAAN,GAAgB,CAAhB,GAAoB,IAA9C;AACA,QAAM,sBAAsB,GAAW,sBAAsB,CAAC,GAAD,CAAtB,GAA8B,SAArE;AACA,QAAM,MAAM,GAAY,CAAC,KAAK,CAAC,OAA/B;AAEA,SAAO;AAAE,IAAA,KAAF;AAAS,IAAA,KAAT;AAAgB,IAAA,eAAhB;AAAiC,IAAA,wBAAjC;AAA2D,IAAA,GAA3D;AAAgE,IAAA,aAAhE;AAA+E,IAAA,sBAA/E;AAAuG,IAAA,MAAvG;AAA+G,IAAA,KAA/G;AAAsH,IAAA;AAAtH,GAAP;AACD;AAED,OAAM,SAAU,SAAV,CAAqB,KAArB,EAAiD,aAAjD,EAAsE;AAC1E,SAAO,aAAa,IAAI,KAAK,CAAC,eAAvB,IACL,aAAa,IAAI,KAAK,CAAC,aADlB,IAEL,aAAa,GAAG,WAAhB,KAAgC,KAAK,CAAC,sBAFxC;AAGD;AAED,OAAM,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;AAED,OAAM,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/lib/components/VCalendar/util/props.js

@@ -0,0 +1,255 @@
+import { validateTimestamp, parseDate, DAYS_IN_WEEK, validateTime } from './timestamp';
+import { CalendarEventOverlapModes } from '../modes';
+export default {
+  base: {
+    start: {
+      type: [String, Number, Date],
+      validate: validateTimestamp,
+      default: () => parseDate(new Date()).date
+    },
+    end: {
+      type: [String, Number, Date],
+      validate: validateTimestamp
+    },
+    weekdays: {
+      type: [Array, String],
+      default: () => [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: 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: validateTimestamp
+    }
+  },
+  category: {
+    categories: {
+      type: [Array, String],
+      default: ''
+    },
+    categoryHideDynamic: {
+      type: Boolean
+    },
+    categoryShowAll: {
+      type: Boolean
+    },
+    categoryForInvalid: {
+      type: String,
+      default: ''
+    },
+    categoryDays: {
+      type: [Number, String],
+      default: 1,
+      validate: x => isFinite(parseInt(x)) && parseInt(x) > 0
+    }
+  },
+  events: {
+    events: {
+      type: Array,
+      default: () => []
+    },
+    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: mode => mode in 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
+    }
+  }
+};
+export function validateNumber(input) {
+  return isFinite(parseInt(input));
+}
+export function validateWeekdays(input) {
+  if (typeof input === 'string') {
+    input = input.split(',');
+  }
+
+  if (Array.isArray(input)) {
+    const ints = input.map(x => parseInt(x));
+
+    if (ints.length > DAYS_IN_WEEK || ints.length === 0) {
+      return false;
+    }
+
+    const visited = {};
+    let wrapped = false;
+
+    for (let i = 0; i < ints.length; i++) {
+      const x = ints[i];
+
+      if (!isFinite(x) || x < 0 || x >= DAYS_IN_WEEK) {
+        return false;
+      }
+
+      if (i > 0) {
+        const 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/lib/components/VCalendar/util/timestamp.js

@@ -0,0 +1,454 @@
+import { isLeapYear } from '../../../util/dateTimeUtils';
+export const PARSE_REGEX = /^(\d{4})-(\d{1,2})(-(\d{1,2}))?([^\d]+(\d{1,2}))?(:(\d{1,2}))?(:(\d{1,2}))?$/;
+export const PARSE_TIME = /(\d\d?)(:(\d\d?)|)(:(\d\d?)|)/;
+export const DAYS_IN_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+export const DAYS_IN_MONTH_LEAP = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+export const DAYS_IN_MONTH_MIN = 28;
+export const DAYS_IN_MONTH_MAX = 31;
+export const MONTH_MAX = 12;
+export const MONTH_MIN = 1;
+export const DAY_MIN = 1;
+export const DAYS_IN_WEEK = 7;
+export const MINUTES_IN_HOUR = 60;
+export const MINUTE_MAX = 59;
+export const MINUTES_IN_DAY = 24 * 60;
+export const HOURS_IN_DAY = 24;
+export const HOUR_MAX = 23;
+export const FIRST_HOUR = 0;
+export const OFFSET_YEAR = 10000;
+export const OFFSET_MONTH = 100;
+export const OFFSET_HOUR = 100;
+export const OFFSET_TIME = 10000;
+export function getStartOfWeek(timestamp, weekdays, today) {
+  const start = copyTimestamp(timestamp);
+  findWeekday(start, weekdays[0], prevDay);
+  updateFormatted(start);
+
+  if (today) {
+    updateRelative(start, today, start.hasTime);
+  }
+
+  return start;
+}
+export function getEndOfWeek(timestamp, weekdays, today) {
+  const end = copyTimestamp(timestamp);
+  findWeekday(end, weekdays[weekdays.length - 1]);
+  updateFormatted(end);
+
+  if (today) {
+    updateRelative(end, today, end.hasTime);
+  }
+
+  return end;
+}
+export function getStartOfMonth(timestamp) {
+  const start = copyTimestamp(timestamp);
+  start.day = DAY_MIN;
+  updateWeekday(start);
+  updateFormatted(start);
+  return start;
+}
+export function getEndOfMonth(timestamp) {
+  const end = copyTimestamp(timestamp);
+  end.day = daysInMonth(end.year, end.month);
+  updateWeekday(end);
+  updateFormatted(end);
+  return end;
+}
+export function validateTime(input) {
+  return typeof input === 'number' && isFinite(input) || !!PARSE_TIME.exec(input) || typeof input === 'object' && isFinite(input.hour) && isFinite(input.minute);
+}
+export 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
+    const 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;
+  }
+}
+export function validateTimestamp(input) {
+  return typeof input === 'number' && isFinite(input) || typeof input === 'string' && !!PARSE_REGEX.exec(input) || input instanceof Date;
+}
+export function parseTimestamp(input, required = false, now) {
+  if (typeof input === 'number' && isFinite(input)) {
+    input = new Date(input);
+  }
+
+  if (input instanceof Date) {
+    const date = parseDate(input);
+
+    if (now) {
+      updateRelative(date, now, date.hasTime);
+    }
+
+    return date;
+  }
+
+  if (typeof input !== 'string') {
+    if (required) {
+      throw new Error(`${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
+
+
+  const parts = PARSE_REGEX.exec(input);
+
+  if (!parts) {
+    if (required) {
+      throw new Error(`${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;
+  }
+
+  const 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;
+}
+export 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
+  });
+}
+export function getDayIdentifier(timestamp) {
+  return timestamp.year * OFFSET_YEAR + timestamp.month * OFFSET_MONTH + timestamp.day;
+}
+export function getTimeIdentifier(timestamp) {
+  return timestamp.hour * OFFSET_HOUR + timestamp.minute;
+}
+export function getTimestampIdentifier(timestamp) {
+  return getDayIdentifier(timestamp) * OFFSET_TIME + getTimeIdentifier(timestamp);
+}
+export function updateRelative(timestamp, now, time = false) {
+  let a = getDayIdentifier(now);
+  let b = getDayIdentifier(timestamp);
+  let 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;
+}
+export function isTimedless(input) {
+  return input instanceof Date || typeof input === 'number' && isFinite(input);
+}
+export 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;
+}
+export 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;
+}
+export function updateWeekday(timestamp) {
+  timestamp.weekday = getWeekday(timestamp);
+  return timestamp;
+}
+export function updateFormatted(timestamp) {
+  timestamp.time = getTime(timestamp);
+  timestamp.date = getDate(timestamp);
+  return timestamp;
+}
+export function getWeekday(timestamp) {
+  if (timestamp.hasDay) {
+    const _ = Math.floor;
+    const k = timestamp.day;
+    const m = (timestamp.month + 9) % MONTH_MAX + 1;
+
+    const C = _(timestamp.year / 100);
+
+    const 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;
+}
+export function daysInMonth(year, month) {
+  return isLeapYear(year) ? DAYS_IN_MONTH_LEAP[month] : DAYS_IN_MONTH[month];
+}
+export function copyTimestamp(timestamp) {
+  const {
+    date,
+    time,
+    year,
+    month,
+    day,
+    weekday,
+    hour,
+    minute,
+    hasDay,
+    hasTime,
+    past,
+    present,
+    future
+  } = timestamp;
+  return {
+    date,
+    time,
+    year,
+    month,
+    day,
+    weekday,
+    hour,
+    minute,
+    hasDay,
+    hasTime,
+    past,
+    present,
+    future
+  };
+}
+export function padNumber(x, length) {
+  let padded = String(x);
+
+  while (padded.length < length) {
+    padded = '0' + padded;
+  }
+
+  return padded;
+}
+export function getDate(timestamp) {
+  let str = `${padNumber(timestamp.year, 4)}-${padNumber(timestamp.month, 2)}`;
+  if (timestamp.hasDay) str += `-${padNumber(timestamp.day, 2)}`;
+  return str;
+}
+export function getTime(timestamp) {
+  if (!timestamp.hasTime) {
+    return '';
+  }
+
+  return `${padNumber(timestamp.hour, 2)}:${padNumber(timestamp.minute, 2)}`;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export function relativeDays(timestamp, mover = nextDay, days = 1) {
+  while (--days >= 0) mover(timestamp);
+
+  return timestamp;
+}
+export function diffMinutes(min, max) {
+  const Y = (max.year - min.year) * 525600;
+  const M = (max.month - min.month) * 43800;
+  const D = (max.day - min.day) * 1440;
+  const h = (max.hour - min.hour) * 60;
+  const m = max.minute - min.minute;
+  return Y + M + D + h + m;
+}
+export function findWeekday(timestamp, weekday, mover = nextDay, maxDays = 6) {
+  while (timestamp.weekday !== weekday && --maxDays >= 0) mover(timestamp);
+
+  return timestamp;
+}
+export function getWeekdaySkips(weekdays) {
+  const skips = [1, 1, 1, 1, 1, 1, 1];
+  const filled = [0, 0, 0, 0, 0, 0, 0];
+
+  for (let i = 0; i < weekdays.length; i++) {
+    filled[weekdays[i]] = 1;
+  }
+
+  for (let k = 0; k < DAYS_IN_WEEK; k++) {
+    let skip = 1;
+
+    for (let j = 1; j < DAYS_IN_WEEK; j++) {
+      const next = (k + j) % DAYS_IN_WEEK;
+
+      if (filled[next]) {
+        break;
+      }
+
+      skip++;
+    }
+
+    skips[k] = filled[k] * skip;
+  }
+
+  return skips;
+}
+export function timestampToDate(timestamp) {
+  const time = `${padNumber(timestamp.hour, 2)}:${padNumber(timestamp.minute, 2)}`;
+  const date = timestamp.date;
+  return new Date(`${date}T${time}:00+00:00`);
+}
+export function createDayList(start, end, now, weekdaySkips, max = 42, min = 0) {
+  const stop = getDayIdentifier(end);
+  const days = [];
+  let current = copyTimestamp(start);
+  let currentIdentifier = 0;
+  let 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;
+    }
+
+    const 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;
+}
+export function createIntervalList(timestamp, first, minutes, count, now) {
+  const intervals = [];
+
+  for (let i = 0; i < count; i++) {
+    const mins = first + i * minutes;
+    const int = copyTimestamp(timestamp);
+    intervals.push(updateMinutes(int, mins, now));
+  }
+
+  return intervals;
+}
+export function createNativeLocaleFormatter(locale, getOptions) {
+  const emptyFormatter = (_t, _s) => '';
+
+  if (typeof Intl === 'undefined' || typeof Intl.DateTimeFormat === 'undefined') {
+    return emptyFormatter;
+  }
+
+  return (timestamp, short) => {
+    try {
+      const intlFormatter = new Intl.DateTimeFormat(locale || undefined, getOptions(timestamp, short));
+      return intlFormatter.format(timestampToDate(timestamp));
+    } catch (e) {
+      return '';
+    }
+  };
+}
+//# sourceMappingURL=timestamp.js.map