@timestamp-js/core 0.1.0-rc.1 → 0.1.0-rc.2

package/dist/index.global.js

@@ -0,0 +1,1550 @@
+var TimestampJsCore = (function(exports) {
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const MILLISECONDS_IN_DAY$1 = 864e5;
+	const GREGORIAN_DAYS_IN_MONTH = [
+		0,
+		31,
+		28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	const GREGORIAN_DAYS_IN_MONTH_LEAP = [
+		0,
+		31,
+		29,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	function padNumber$1(value, length) {
+		let padded = String(value);
+		while (padded.length < length) padded = "0" + padded;
+		return padded;
+	}
+	
+	function formatCalendarDate(date) {
+		return `${padNumber$1(date.year, 4)}-${padNumber$1(date.month, 2)}-${padNumber$1(date.day, 2)}`;
+	}
+	function fromUtcDate(date) {
+		return {
+			year: date.getUTCFullYear(),
+			month: date.getUTCMonth() + 1,
+			day: date.getUTCDate()
+		};
+	}
+	function toGregorianUtcDate(date) {
+		return new Date(Date.UTC(date.year, date.month - 1, date.day));
+	}
+	
+	const gregorianCalendar = Object.freeze({
+		id: "gregorian",
+		intlCalendar: "gregory",
+		label: "Gregorian",
+		monthsInYear() {
+			return 12;
+		},
+		isLeapYear(year) {
+			return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+		},
+		daysInMonth(year, month) {
+			return this.isLeapYear(year) ? GREGORIAN_DAYS_IN_MONTH_LEAP[month] : GREGORIAN_DAYS_IN_MONTH[month];
+		},
+		toEpochDay(date) {
+			return Math.floor(Date.UTC(date.year, date.month - 1, date.day) / MILLISECONDS_IN_DAY$1);
+		},
+		fromEpochDay(epochDay) {
+			return fromUtcDate(/* @__PURE__ */ new Date(epochDay * MILLISECONDS_IN_DAY$1));
+		},
+		addDays(date, amount) {
+			return this.fromEpochDay(this.toEpochDay(date) + amount);
+		},
+		nextDay(date) {
+			return this.addDays(date, 1);
+		},
+		prevDay(date) {
+			return this.addDays(date, -1);
+		},
+		getDayOfYear(date) {
+			const yearStart = this.toEpochDay({
+				year: date.year,
+				month: 1,
+				day: 1
+			});
+			return this.toEpochDay(date) - yearStart + 1;
+		},
+		getWeekday(date) {
+			return toGregorianUtcDate(date).getUTCDay();
+		}
+	});
+
+
+	const PARSE_DATETIME = /^(\d{4})-(\d{1,2})(?:-(\d{1,2}))?(?:[Tt\s]+(\d{1,2})(?::(\d{1,2}))?(?::(\d{1,2})(?:\.(\d{1,3}))?)?)?(?:\s*(Z|[+-]\d{2}:?\d{2}))?$/;
+	
+	const PARSE_DATE = /^(\d{4})-(\d{1,2})(-(\d{1,2}))?/;
+	
+	const PARSE_TIME = /^(\d\d?)(?::(\d\d?))?(?::(\d\d?))?(?:\.(\d{1,3}))?$/;
+	
+	const DAYS_IN_MONTH = [
+		0,
+		31,
+		28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	
+	const DAYS_IN_MONTH_LEAP = [
+		0,
+		31,
+		29,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	
+	const TIME_CONSTANTS = {
+		MILLISECONDS_IN: {
+			SECOND: 1e3,
+			MINUTE: 6e4,
+			HOUR: 36e5,
+			DAY: 864e5,
+			WEEK: 6048e5
+		},
+		SECONDS_IN: {
+			MINUTE: 60,
+			HOUR: 3600,
+			DAY: 86400,
+			WEEK: 604800
+		},
+		MINUTES_IN: {
+			MINUTE: 1,
+			HOUR: 60,
+			DAY: 1440,
+			WEEK: 10080
+		},
+		HOURS_IN: {
+			DAY: 24,
+			WEEK: 168
+		},
+		DAYS_IN: { WEEK: 7 }
+	};
+	
+	const DAYS_IN_MONTH_MIN = 28;
+	
+	const DAYS_IN_MONTH_MAX = 31;
+	
+	const MONTH_MAX = 12;
+	
+	const MONTH_MIN = 1;
+	
+	const DAY_MIN = 1;
+	
+	const FIRST_HOUR = 0;
+	
+	const DAYS_IN_WEEK = TIME_CONSTANTS.DAYS_IN.WEEK;
+	
+	const MINUTES_IN_HOUR = TIME_CONSTANTS.MINUTES_IN.HOUR;
+	
+	const HOURS_IN_DAY = TIME_CONSTANTS.HOURS_IN.DAY;
+	
+	const MILLISECONDS_IN_MINUTE = TIME_CONSTANTS.MILLISECONDS_IN.MINUTE;
+	
+	const MILLISECONDS_IN_SECOND = TIME_CONSTANTS.MILLISECONDS_IN.SECOND;
+	
+	const MILLISECONDS_IN_HOUR = TIME_CONSTANTS.MILLISECONDS_IN.HOUR;
+	
+	const MILLISECONDS_IN_DAY = TIME_CONSTANTS.MILLISECONDS_IN.DAY;
+	
+	const MILLISECONDS_IN_WEEK = TIME_CONSTANTS.MILLISECONDS_IN.WEEK;
+	
+	const SECONDS_IN_MINUTE = TIME_CONSTANTS.SECONDS_IN.MINUTE;
+	
+	const SECONDS_IN_HOUR = TIME_CONSTANTS.SECONDS_IN.HOUR;
+	
+	const SECONDS_IN_DAY = TIME_CONSTANTS.SECONDS_IN.DAY;
+	
+	const Timestamp = freezeTimestamp({
+		date: "",
+		hasDay: false,
+		year: 0,
+		month: 0,
+		day: 0,
+		hasTime: false,
+		hour: 0,
+		minute: 0,
+		weekday: 0,
+		doy: 0,
+		workweek: 0,
+		past: false,
+		current: false,
+		future: false,
+		disabled: false
+	});
+	
+	const TimeObject = Object.freeze({
+		hour: 0,
+		minute: 0
+	});
+	function freezeTimestamp(timestamp) {
+		return Object.freeze({ ...timestamp });
+	}
+	function cloneTimestamp(timestamp) {
+		return { ...timestamp };
+	}
+	
+	function toCalendarDateParts(timestamp) {
+		return {
+			year: timestamp.year,
+			month: timestamp.month,
+			day: timestamp.day
+		};
+	}
+	function getCalendarTimestampOptions(timestamp) {
+		return {
+			hasTime: timestamp.hasTime,
+			hour: timestamp.hour,
+			minute: timestamp.minute,
+			second: timestamp.second,
+			millisecond: timestamp.millisecond,
+			timezone: timestamp.timezone
+		};
+	}
+	function getCalendarWorkWeek(date, calendar) {
+		const firstWeekday = calendar.getWeekday({
+			year: date.year,
+			month: 1,
+			day: 1
+		});
+		return Math.floor((calendar.getDayOfYear(date) + firstWeekday - 1) / 7) + 1;
+	}
+	function parseMillisecond(value) {
+		return value === void 0 ? void 0 : parseInt(value.padEnd(3, "0"), 10);
+	}
+	
+	function validateTimestamp(input) {
+		if (typeof input !== "string") return false;
+		return PARSE_DATETIME.test(input);
+	}
+	
+	function parsed(input) {
+		if (typeof input !== "string") return null;
+		const parts = PARSE_DATETIME.exec(input);
+		if (!parts || !parts[1] || !parts[2]) return null;
+		const year = parseInt(parts[1], 10);
+		const month = parseInt(parts[2], 10);
+		const day = parseInt(parts[3] || "1", 10);
+		const hour = parseInt(parts[4] || "0", 10);
+		const minute = parseInt(parts[5] || "0", 10);
+		const second = parts[6] === void 0 ? void 0 : parseInt(parts[6], 10);
+		const millisecond = parseMillisecond(parts[7]);
+		const timestamp = {
+			date: input,
+			year,
+			month,
+			day,
+			hour,
+			minute,
+			hasDay: !!parts[3],
+			hasTime: true,
+			past: false,
+			current: false,
+			future: false,
+			disabled: false,
+			weekday: 0,
+			doy: 0,
+			workweek: 0
+		};
+		if (second !== void 0) timestamp.second = second;
+		if (millisecond !== void 0) timestamp.millisecond = millisecond;
+		if (parts[8] !== void 0) timestamp.timezone = parts[8];
+		timestamp.time = getTime(timestamp);
+		return freezeTimestamp(timestamp);
+	}
+	function parseDateByMode(date, utc) {
+		if (!(date instanceof Date)) return null;
+		if (Number.isNaN(date.getTime())) return null;
+		const UTC = utc ? "UTC" : "";
+		const second = date[`get${UTC}Seconds`]();
+		const millisecond = date[`get${UTC}Milliseconds`]();
+		const timestamp = {
+			date: padNumber(date[`get${UTC}FullYear`](), 4) + "-" + padNumber(date[`get${UTC}Month`]() + 1, 2) + "-" + padNumber(date[`get${UTC}Date`](), 2),
+			time: padNumber(date[`get${UTC}Hours`]() || 0, 2) + ":" + padNumber(date[`get${UTC}Minutes`]() || 0, 2),
+			year: date[`get${UTC}FullYear`](),
+			month: date[`get${UTC}Month`]() + 1,
+			day: date[`get${UTC}Date`](),
+			hour: date[`get${UTC}Hours`](),
+			minute: date[`get${UTC}Minutes`](),
+			weekday: 0,
+			doy: 0,
+			workweek: 0,
+			hasDay: true,
+			hasTime: true,
+			past: false,
+			current: false,
+			future: false,
+			disabled: false
+		};
+		if (second !== 0) timestamp.second = second;
+		if (millisecond !== 0) timestamp.millisecond = millisecond;
+		return updateFormatted(timestamp);
+	}
+	
+	function parseDate(date) {
+		return parseDateByMode(date, false);
+	}
+	
+	function parseDateUTC(date) {
+		return parseDateByMode(date, true);
+	}
+	
+	function padNumber(x, length) {
+		let padded = String(x);
+		while (padded.length < length) padded = "0" + padded;
+		return padded;
+	}
+	
+	function isLeapYear(year) {
+		return gregorianCalendar.isLeapYear(year);
+	}
+	
+	function daysInMonth(year, month) {
+		return gregorianCalendar.daysInMonth(year, month);
+	}
+	
+	function nextDay(timestamp) {
+		const date = gregorianCalendar.nextDay(toCalendarDateParts(timestamp));
+		return updateFormatted(normalizeTimestamp({
+			...timestamp,
+			year: date.year,
+			month: date.month,
+			day: date.day
+		}));
+	}
+	
+	function prevDay(timestamp) {
+		const date = gregorianCalendar.prevDay(toCalendarDateParts(timestamp));
+		return updateFormatted(normalizeTimestamp({
+			...timestamp,
+			year: date.year,
+			month: date.month,
+			day: date.day
+		}));
+	}
+	
+	function today() {
+		const d = /* @__PURE__ */ new Date(), month = d.getMonth() + 1, day = d.getDate();
+		return [
+			d.getFullYear(),
+			padNumber(month, 2),
+			padNumber(day, 2)
+		].join("-");
+	}
+	
+	function todayUTC(date = /* @__PURE__ */ new Date()) {
+		return [
+			padNumber(date.getUTCFullYear(), 4),
+			padNumber(date.getUTCMonth() + 1, 2),
+			padNumber(date.getUTCDate(), 2)
+		].join("-");
+	}
+	
+	function nowUTC(date = /* @__PURE__ */ new Date()) {
+		return parseDateUTC(date);
+	}
+	
+	function isToday(date) {
+		return date === today();
+	}
+	
+	function isTodayUTC(date, now = /* @__PURE__ */ new Date()) {
+		return date === todayUTC(now);
+	}
+	
+	function getStartOfWeek(timestamp, weekdays, today) {
+		let start = cloneTimestamp(timestamp);
+		if (!weekdays) return freezeTimestamp(start);
+		if (start.day === 1 || start.weekday === 0) while (!weekdays.includes(Number(start.weekday))) start = nextDay(start);
+		start = findWeekday(start, weekdays[0], prevDay);
+		start = updateFormatted(start);
+		if (today) start = updateRelative(start, today, start.hasTime);
+		return start;
+	}
+	
+	function getEndOfWeek(timestamp, weekdays, today) {
+		let end = cloneTimestamp(timestamp);
+		if (!weekdays || !Array.isArray(weekdays)) return freezeTimestamp(end);
+		if (daysInMonth(end.year, end.month) === end.day || end.weekday === weekdays[weekdays.length - 1]) while (!weekdays.includes(Number(end.weekday))) end = prevDay(end);
+		end = findWeekday(end, weekdays[weekdays.length - 1], nextDay);
+		end = updateFormatted(end);
+		if (today) end = updateRelative(end, today, end.hasTime);
+		return end;
+	}
+	
+	function getStartOfMonth(timestamp) {
+		let start = cloneTimestamp(timestamp);
+		start.day = 1;
+		start = updateFormatted(start);
+		return start;
+	}
+	
+	function getEndOfMonth(timestamp) {
+		let end = cloneTimestamp(timestamp);
+		end.day = daysInMonth(end.year, end.month);
+		end = updateFormatted(end);
+		return end;
+	}
+	
+	function parseTime(input) {
+		switch (Object.prototype.toString.call(input)) {
+			case "[object Number]": return input;
+			case "[object String]": {
+				const parts = PARSE_TIME.exec(input);
+				if (!parts) return false;
+				return parseInt(parts[1], 10) * 60 + parseInt(parts[2] || "0", 10);
+			}
+			case "[object Object]":
+				if (typeof input !== "object" || typeof input.hour !== "number" || typeof input.minute !== "number") return false;
+				if (typeof input === "object" && "hour" in input && "minute" in input) return input.hour * 60 + input.minute;
+				return false;
+		}
+		return false;
+	}
+	
+	function compareTimestamps(ts1, ts2) {
+		if (!ts1 || !ts2) return false;
+		return ts1.year === ts2.year && ts1.month === ts2.month && ts1.day === ts2.day && ts1.hour === ts2.hour && ts1.minute === ts2.minute && ts1.second === ts2.second && ts1.millisecond === ts2.millisecond && ts1.timezone === ts2.timezone;
+	}
+	
+	function compareDate(ts1, ts2) {
+		return getDate(ts1) === getDate(ts2);
+	}
+	
+	function compareTime(ts1, ts2) {
+		return getTime(ts1) === getTime(ts2);
+	}
+	
+	function compareDateTime(ts1, ts2) {
+		return getDateTime(ts1) === getDateTime(ts2);
+	}
+	
+	function parseTimestamp(input, now = null) {
+		let timestamp = parsed(input);
+		if (!timestamp) return null;
+		timestamp = updateFormatted(timestamp);
+		if (now) timestamp = updateRelative(timestamp, now, timestamp.hasTime);
+		return timestamp;
+	}
+	
+	function getDayIdentifier(timestamp) {
+		return (timestamp.year ?? 0) * 1e8 + (timestamp.month ?? 0) * 1e6 + (timestamp.day ?? 0) * 1e4;
+	}
+	
+	function getEpochDay(timestamp, calendar = gregorianCalendar) {
+		return calendar.toEpochDay(toCalendarDateParts(timestamp));
+	}
+	
+	function getCalendarDayIdentifier(timestamp, calendar = gregorianCalendar) {
+		return getEpochDay(timestamp, calendar);
+	}
+	
+	function isValidCalendarDate(date, calendar = gregorianCalendar) {
+		if (date.year < 1) return false;
+		if (date.month < 1 || date.month > calendar.monthsInYear(date.year)) return false;
+		return date.day >= 1 && date.day <= calendar.daysInMonth(date.year, date.month);
+	}
+	
+	function createCalendarTimestamp(date, calendar = gregorianCalendar, options = {}) {
+		const timestamp = {
+			calendarId: calendar.id,
+			date: formatCalendarDate(date),
+			hasDay: true,
+			year: date.year,
+			month: date.month,
+			day: date.day,
+			hasTime: options.hasTime ?? true,
+			hour: options.hour ?? 0,
+			minute: options.minute ?? 0,
+			past: false,
+			current: false,
+			future: false,
+			disabled: false,
+			weekday: calendar.getWeekday(date),
+			doy: calendar.getDayOfYear(date),
+			workweek: getCalendarWorkWeek(date, calendar)
+		};
+		if (options.second !== void 0) timestamp.second = options.second;
+		if (options.millisecond !== void 0) timestamp.millisecond = options.millisecond;
+		if (options.timezone !== void 0) timestamp.timezone = options.timezone;
+		timestamp.time = getTime(timestamp);
+		const formatted = freezeTimestamp(timestamp);
+		return options.now ? updateCalendarRelative(formatted, options.now, calendar, formatted.hasTime) : formatted;
+	}
+	
+	function parseCalendarTimestamp(input, calendar = gregorianCalendar, now = null) {
+		const timestamp = parsed(input);
+		if (timestamp === null) return null;
+		const date = toCalendarDateParts(timestamp);
+		if (isValidCalendarDate(date, calendar) === false) return null;
+		return createCalendarTimestamp(date, calendar, {
+			...getCalendarTimestampOptions(timestamp),
+			now
+		});
+	}
+	
+	function createCalendarTimestampFromEpochDay(epochDay, calendar = gregorianCalendar, options = {}) {
+		return createCalendarTimestamp(calendar.fromEpochDay(epochDay), calendar, options);
+	}
+	
+	function updateCalendarFormatted(timestamp, calendar = gregorianCalendar) {
+		return createCalendarTimestamp(toCalendarDateParts(timestamp), calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function updateCalendarRelative(timestamp, now, calendar = gregorianCalendar, time = false) {
+		const ts = cloneTimestamp(timestamp);
+		let a = getCalendarDayIdentifier(now, calendar);
+		let b = getCalendarDayIdentifier(ts, calendar);
+		let current = a === b;
+		if (ts.hasTime && time && current) {
+			a = getTimeComparisonValue(now);
+			b = getTimeComparisonValue(ts);
+			current = a === b;
+		}
+		ts.past = b < a;
+		ts.current = current;
+		ts.future = b > a;
+		ts.currentWeekday = ts.weekday === now.weekday;
+		return freezeTimestamp(ts);
+	}
+	
+	function nextCalendarDay(timestamp, calendar = gregorianCalendar) {
+		return createCalendarTimestamp(calendar.nextDay(toCalendarDateParts(timestamp)), calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function prevCalendarDay(timestamp, calendar = gregorianCalendar) {
+		return createCalendarTimestamp(calendar.prevDay(toCalendarDateParts(timestamp)), calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function addCalendarDays(timestamp, amount, calendar = gregorianCalendar) {
+		return createCalendarTimestamp(calendar.addDays(toCalendarDateParts(timestamp), amount), calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function addCalendarMonths(timestamp, amount, calendar = gregorianCalendar) {
+		let { year, month, day } = toCalendarDateParts(timestamp);
+		let remaining = Math.trunc(amount);
+		while (remaining > 0) {
+			month += 1;
+			if (month > calendar.monthsInYear(year)) {
+				year += 1;
+				month = 1;
+			}
+			remaining -= 1;
+		}
+		while (remaining < 0) {
+			month -= 1;
+			if (month < 1) {
+				year -= 1;
+				month = calendar.monthsInYear(year);
+			}
+			remaining += 1;
+		}
+		day = Math.min(day, calendar.daysInMonth(year, month));
+		return createCalendarTimestamp({
+			year,
+			month,
+			day
+		}, calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function addCalendarYears(timestamp, amount, calendar = gregorianCalendar) {
+		let { year, month, day } = toCalendarDateParts(timestamp);
+		year += Math.trunc(amount);
+		month = Math.min(month, calendar.monthsInYear(year));
+		day = Math.min(day, calendar.daysInMonth(year, month));
+		return createCalendarTimestamp({
+			year,
+			month,
+			day
+		}, calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function getCalendarStartOfMonth(timestamp, calendar = gregorianCalendar) {
+		return createCalendarTimestamp({
+			...toCalendarDateParts(timestamp),
+			day: 1
+		}, calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function getCalendarEndOfMonth(timestamp, calendar = gregorianCalendar) {
+		const date = toCalendarDateParts(timestamp);
+		return createCalendarTimestamp({
+			...date,
+			day: calendar.daysInMonth(date.year, date.month)
+		}, calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function getCalendarStartOfYear(timestamp, calendar = gregorianCalendar) {
+		return createCalendarTimestamp({
+			year: timestamp.year,
+			month: 1,
+			day: 1
+		}, calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function getCalendarEndOfYear(timestamp, calendar = gregorianCalendar) {
+		const month = calendar.monthsInYear(timestamp.year);
+		return createCalendarTimestamp({
+			year: timestamp.year,
+			month,
+			day: calendar.daysInMonth(timestamp.year, month)
+		}, calendar, getCalendarTimestampOptions(timestamp));
+	}
+	
+	function findCalendarWeekday(timestamp, weekday, calendar = gregorianCalendar, direction = "next", maxDays = 6) {
+		let ts = copyTimestamp(timestamp);
+		const mover = direction === "next" ? nextCalendarDay : prevCalendarDay;
+		while (ts.weekday !== weekday && --maxDays >= 0) ts = mover(ts, calendar);
+		return ts;
+	}
+	
+	function getCalendarStartOfWeek(timestamp, weekdays, calendar = gregorianCalendar, now = null) {
+		let start = updateCalendarFormatted(timestamp, calendar);
+		if (!weekdays || !Array.isArray(weekdays)) return start;
+		if (start.day === 1 || start.weekday === 0) while (!weekdays.includes(Number(start.weekday))) start = nextCalendarDay(start, calendar);
+		start = findCalendarWeekday(start, weekdays[0], calendar, "prev");
+		return now ? updateCalendarRelative(start, now, calendar, start.hasTime) : start;
+	}
+	
+	function getCalendarEndOfWeek(timestamp, weekdays, calendar = gregorianCalendar, now = null) {
+		let end = updateCalendarFormatted(timestamp, calendar);
+		if (!weekdays || !Array.isArray(weekdays)) return end;
+		if (calendar.daysInMonth(end.year, end.month) === end.day || end.weekday === weekdays[weekdays.length - 1]) while (!weekdays.includes(Number(end.weekday))) end = prevCalendarDay(end, calendar);
+		end = findCalendarWeekday(end, weekdays[weekdays.length - 1], calendar, "next");
+		return now ? updateCalendarRelative(end, now, calendar, end.hasTime) : end;
+	}
+	
+	function createCalendarDayList(start, end, now, calendar = gregorianCalendar, options = {}) {
+		const { weekdays = [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		], disabledBefore, disabledAfter, disabledWeekdays = [], disabledDays = [], max = 42, min = 0 } = options;
+		const begin = getCalendarDayIdentifier(start, calendar);
+		const stop = getCalendarDayIdentifier(end, calendar);
+		const days = [];
+		let current = updateCalendarFormatted(start, calendar);
+		let currentIdentifier = 0;
+		let stopped = currentIdentifier === stop;
+		if (stop < begin) return days;
+		while ((!stopped || days.length < min) && days.length < max) {
+			currentIdentifier = getCalendarDayIdentifier(current, calendar);
+			stopped = stopped || currentIdentifier > stop && days.length >= min;
+			if (stopped) break;
+			if (!weekdays.includes(Number(current.weekday))) {
+				current = nextCalendarDay(current, calendar);
+				continue;
+			}
+			let day = updateCalendarFormatted(current, calendar);
+			day = updateCalendarRelative(day, now, calendar);
+			day = updateDisabled(day, disabledBefore, disabledAfter, disabledWeekdays, disabledDays);
+			days.push(day);
+			current = nextCalendarDay(current, calendar);
+		}
+		return days;
+	}
+	
+	function getTimeIdentifier(timestamp) {
+		return (timestamp.hour ?? 0) * 100 + (timestamp.minute ?? 0);
+	}
+	function getTimeComparisonValue(timestamp) {
+		return (((timestamp.hour ?? 0) * TIME_CONSTANTS.MINUTES_IN.HOUR + (timestamp.minute ?? 0)) * TIME_CONSTANTS.SECONDS_IN.MINUTE + (timestamp.second ?? 0)) * TIME_CONSTANTS.MILLISECONDS_IN.SECOND + (timestamp.millisecond ?? 0);
+	}
+	
+	function getDayTimeIdentifier(timestamp) {
+		return getDayIdentifier(timestamp) + getTimeIdentifier(timestamp);
+	}
+	
+	function diffTimestamp(ts1, ts2, strict = false) {
+		const utc1 = Date.UTC(ts1.year ?? 0, (ts1.month ?? 1) - 1, ts1.day ?? 1, ts1.hour ?? 0, ts1.minute ?? 0, ts1.second ?? 0, ts1.millisecond ?? 0);
+		const utc2 = Date.UTC(ts2.year ?? 0, (ts2.month ?? 1) - 1, ts2.day ?? 1, ts2.hour ?? 0, ts2.minute ?? 0, ts2.second ?? 0, ts2.millisecond ?? 0);
+		if (strict === true && utc2 < utc1) return 0;
+		return utc2 - utc1;
+	}
+	
+	function updateRelative(timestamp, now, time = false) {
+		const ts = cloneTimestamp(timestamp);
+		let a = getDayIdentifier(now);
+		let b = getDayIdentifier(ts);
+		let current = a === b;
+		if (ts.hasTime && time && current) {
+			a = getTimeComparisonValue(now);
+			b = getTimeComparisonValue(ts);
+			current = a === b;
+		}
+		ts.past = b < a;
+		ts.current = current;
+		ts.future = b > a;
+		ts.currentWeekday = ts.weekday === now.weekday;
+		return freezeTimestamp(ts);
+	}
+	
+	function updateMinutes(timestamp, minutes, now = null) {
+		let ts = cloneTimestamp(timestamp);
+		ts.hasTime = true;
+		ts.hour = Math.floor(minutes / TIME_CONSTANTS.MINUTES_IN.HOUR);
+		ts.minute = minutes % TIME_CONSTANTS.MINUTES_IN.HOUR;
+		delete ts.second;
+		delete ts.millisecond;
+		ts.time = getTime(ts);
+		if (now) return updateRelative(ts, now, true);
+		return freezeTimestamp(ts);
+	}
+	
+	function updateWeekday(timestamp) {
+		const ts = cloneTimestamp(timestamp);
+		ts.weekday = getWeekday(ts);
+		return freezeTimestamp(ts);
+	}
+	
+	function updateDayOfYear(timestamp) {
+		const ts = cloneTimestamp(timestamp);
+		ts.doy = getDayOfYear(ts) || 0;
+		return freezeTimestamp(ts);
+	}
+	
+	function updateWorkWeek(timestamp) {
+		const ts = cloneTimestamp(timestamp);
+		ts.workweek = getWorkWeek(ts);
+		return freezeTimestamp(ts);
+	}
+	function isDisabledDayConfig(value) {
+		return typeof value === "object" && value !== null && Array.isArray(value) === false;
+	}
+	function applyDisabledDayConfig(timestamp, config) {
+		timestamp.disabled = true;
+		if (config !== void 0) {
+			timestamp.disabledColor = config.color;
+			timestamp.disabledTextColor = config.textColor;
+			timestamp.disabledClass = config.class;
+			timestamp.disabledStyle = config.style;
+			timestamp.disabledLabel = config.label;
+		}
+		return timestamp;
+	}
+	function isTimestampInDisabledDay(timestamp, day) {
+		const target = getDayIdentifier(timestamp);
+		if (Array.isArray(day) === true) {
+			if (day.length === 2 && day[0] && day[1]) {
+				const start = parsed(day[0]);
+				const end = parsed(day[1]);
+				return start !== null && end !== null && isBetweenDates(timestamp, start, end);
+			}
+			return day.some((date) => {
+				const disabledDay = parseTimestamp(date);
+				return disabledDay !== null && getDayIdentifier(disabledDay) === target;
+			});
+		}
+		if (isDisabledDayConfig(day) === true) {
+			const date = day.date;
+			const startDate = day.from ?? day.start;
+			const endDate = day.to ?? day.end;
+			if (date !== void 0) {
+				const disabledDay = parseTimestamp(date);
+				return disabledDay !== null && getDayIdentifier(disabledDay) === target;
+			}
+			if (startDate !== void 0 && endDate !== void 0) {
+				const start = parsed(startDate);
+				const end = parsed(endDate);
+				return start !== null && end !== null && isBetweenDates(timestamp, start, end);
+			}
+			return false;
+		}
+		const disabledDay = parseTimestamp(day);
+		return disabledDay !== null && getDayIdentifier(disabledDay) === target;
+	}
+	
+	function updateDisabled(timestamp, disabledBefore, disabledAfter, disabledWeekdays, disabledDays) {
+		let ts = cloneTimestamp(timestamp);
+		const t = getDayIdentifier(ts);
+		if (disabledBefore !== void 0) {
+			const disabledDay = parsed(disabledBefore);
+			if (disabledDay) {
+				if (t <= getDayIdentifier(disabledDay)) ts.disabled = true;
+			}
+		}
+		if (ts.disabled !== true && disabledAfter !== void 0) {
+			const disabledDay = parsed(disabledAfter);
+			if (disabledDay) {
+				if (t >= getDayIdentifier(disabledDay)) ts.disabled = true;
+			}
+		}
+		if (ts.disabled !== true && Array.isArray(disabledWeekdays) && disabledWeekdays.length > 0) {
+			for (const weekday in disabledWeekdays) if (disabledWeekdays[weekday] === ts.weekday) {
+				ts.disabled = true;
+				break;
+			}
+		}
+		if (ts.disabled !== true && Array.isArray(disabledDays) && disabledDays.length > 0) {
+			for (const day of disabledDays) if (isTimestampInDisabledDay(ts, day) === true) {
+				ts = applyDisabledDayConfig(ts, isDisabledDayConfig(day) === true ? day : void 0);
+				break;
+			}
+		}
+		return freezeTimestamp(ts);
+	}
+	
+	function updateFormatted(timestamp) {
+		const ts = cloneTimestamp(timestamp);
+		ts.hasTime = true;
+		ts.time = getTime(ts);
+		ts.date = getDate(ts);
+		ts.weekday = getWeekday(ts);
+		ts.doy = getDayOfYear(ts) || 0;
+		ts.workweek = getWorkWeek(ts);
+		return freezeTimestamp(ts);
+	}
+	
+	function getDayOfYear(timestamp) {
+		if (timestamp.year === 0) return;
+		return gregorianCalendar.getDayOfYear(toCalendarDateParts(timestamp));
+	}
+	
+	function getWorkWeek(timestamp) {
+		let ts = timestamp;
+		if (ts.year === 0) {
+			const parsedToday = parseTimestamp(today());
+			if (parsedToday) ts = parsedToday;
+		}
+		const weekday = new Date(Date.UTC(ts.year, ts.month - 1, ts.day));
+		const dayAdjustment = 4;
+		weekday.setUTCDate(weekday.getUTCDate() - (weekday.getUTCDay() + 6) % 7 + dayAdjustment);
+		weekday.setUTCDate(weekday.getUTCDate() + dayAdjustment - (weekday.getUTCDay() || 7));
+		var yearStart = new Date(Date.UTC(weekday.getUTCFullYear(), 0, 1));
+		return Math.ceil(((weekday.valueOf() - yearStart.valueOf()) / 864e5 + 1) / 7);
+	}
+	
+	function getWeekday(timestamp) {
+		let weekday = timestamp.weekday;
+		if (timestamp.hasDay) weekday = gregorianCalendar.getWeekday(toCalendarDateParts(timestamp));
+		return weekday ?? 0;
+	}
+	
+	function copyTimestamp(timestamp) {
+		return freezeTimestamp(timestamp);
+	}
+	function setTimeParts(timestamp, hour, minute, second, millisecond) {
+		const ts = cloneTimestamp(timestamp);
+		ts.hasTime = true;
+		ts.hour = hour;
+		ts.minute = minute;
+		if (second === void 0) delete ts.second;
+		else ts.second = second;
+		if (millisecond === void 0) delete ts.millisecond;
+		else ts.millisecond = millisecond;
+		return updateFormatted(ts);
+	}
+	
+	function getStartOfDay(timestamp) {
+		return setTimeParts(timestamp, 0, 0);
+	}
+	
+	function getEndOfDay(timestamp) {
+		return setTimeParts(timestamp, 23, 59, 59, 999);
+	}
+	
+	function getStartOfYear(timestamp) {
+		const ts = cloneTimestamp(timestamp);
+		ts.month = 1;
+		ts.day = 1;
+		return getStartOfDay(updateFormatted(ts));
+	}
+	
+	function getEndOfYear(timestamp) {
+		const ts = cloneTimestamp(timestamp);
+		ts.month = 12;
+		ts.day = daysInMonth(ts.year, 12);
+		return getEndOfDay(updateFormatted(ts));
+	}
+	
+	function getDate(timestamp) {
+		let str = `${padNumber(timestamp.year, 4)}-${padNumber(timestamp.month, 2)}`;
+		if (timestamp.hasDay) str += `-${padNumber(timestamp.day, 2)}`;
+		return str;
+	}
+	
+	function getTime(timestamp) {
+		if (!timestamp.hasTime) return "";
+		let time = `${padNumber(timestamp.hour, 2)}:${padNumber(timestamp.minute, 2)}`;
+		if (timestamp.second !== void 0 || timestamp.millisecond !== void 0) time += `:${padNumber(timestamp.second ?? 0, 2)}`;
+		if (timestamp.millisecond !== void 0) time += `.${padNumber(timestamp.millisecond, 3)}`;
+		return time;
+	}
+	
+	function getDateTime(timestamp) {
+		return getDate(timestamp) + " " + (timestamp.hasTime ? getTime(timestamp) : "00:00");
+	}
+	
+	function moveRelativeDays(timestamp, mover = nextDay, days = 1, allowedWeekdays = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6
+	]) {
+		return relativeDays(timestamp, mover, days, allowedWeekdays);
+	}
+	
+	function relativeDays(timestamp, mover = nextDay, days = 1, allowedWeekdays = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6
+	]) {
+		let ts = copyTimestamp(timestamp);
+		if (!allowedWeekdays.includes(Number(ts.weekday)) && ts.weekday === 0 && mover === nextDay) ++days;
+		while (--days >= 0) {
+			ts = mover(ts);
+			if (allowedWeekdays.length < 7 && !allowedWeekdays.includes(Number(ts.weekday))) ++days;
+		}
+		return ts;
+	}
+	
+	function findWeekday(timestamp, weekday, mover = nextDay, maxDays = 6) {
+		let ts = copyTimestamp(timestamp);
+		while (ts.weekday !== weekday && --maxDays >= 0) ts = mover(ts);
+		return ts;
+	}
+	
+	function createDayList(start, end, now, weekdays = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6
+	], disabledBefore = void 0, disabledAfter = void 0, disabledWeekdays = [], disabledDays = [], max = 42, min = 0) {
+		const begin = getDayIdentifier(start);
+		const stop = getDayIdentifier(end);
+		const days = [];
+		let current = copyTimestamp(start);
+		let currentIdentifier = 0;
+		let stopped = currentIdentifier === stop;
+		if (stop < begin) return days;
+		while ((!stopped || days.length < min) && days.length < max) {
+			currentIdentifier = getDayIdentifier(current);
+			stopped = stopped || currentIdentifier > stop && days.length >= min;
+			if (stopped) break;
+			if (!weekdays.includes(Number(current.weekday))) {
+				current = relativeDays(current, nextDay);
+				continue;
+			}
+			let day = copyTimestamp(current);
+			day = updateFormatted(day);
+			day = updateRelative(day, now);
+			day = updateDisabled(day, disabledBefore, disabledAfter, disabledWeekdays, disabledDays);
+			days.push(day);
+			current = relativeDays(current, nextDay);
+		}
+		return days;
+	}
+	
+	function createIntervalList(timestamp, first, minutes, count, now) {
+		const intervals = [];
+		for (let i = 0; i < count; ++i) {
+			const mins = (first + i) * minutes;
+			intervals.push(updateMinutes(timestamp, mins, now));
+		}
+		return intervals;
+	}
+	
+	
+	function createNativeLocaleFormatterByMode(locale, cb, toDate) {
+		const emptyFormatter = () => "";
+		if (typeof Intl === "undefined" || typeof Intl.DateTimeFormat === "undefined") return emptyFormatter;
+		return (timestamp, short) => {
+			try {
+				return new Intl.DateTimeFormat(locale || void 0, cb(timestamp, short)).format(toDate(timestamp));
+			} catch (e) {
+				console.error(`Intl.DateTimeFormat: ${e.message} -> ${getDateTime(timestamp)}`);
+				return "";
+			}
+		};
+	}
+	
+	function createNativeLocaleFormatter(locale, cb) {
+		return createNativeLocaleFormatterByMode(locale, cb, makeDateTime);
+	}
+	
+	function createNativeLocaleFormatterUTC(locale, cb) {
+		return createNativeLocaleFormatterByMode(locale, cb, makeDateTimeUTC);
+	}
+	
+	function createCalendarLocaleFormatterUTC(calendar, locale, cb) {
+		return createNativeLocaleFormatterByMode(locale, (timestamp, short) => {
+			const options = cb(timestamp, short);
+			const resolvedOptions = options.timeZone === void 0 ? {
+				...options,
+				timeZone: "UTC"
+			} : options;
+			if (calendar.intlCalendar === void 0 || resolvedOptions.calendar !== void 0) return resolvedOptions;
+			return {
+				...resolvedOptions,
+				calendar: calendar.intlCalendar
+			};
+		}, (timestamp) => makeCalendarDateTimeUTC(timestamp, calendar));
+	}
+	
+	function makeDate(timestamp) {
+		return new Date(timestamp.year, timestamp.month - 1, timestamp.day, 0, 0);
+	}
+	
+	function makeDateUTC(timestamp) {
+		return new Date(Date.UTC(timestamp.year, timestamp.month - 1, timestamp.day, 0, 0));
+	}
+	
+	function makeCalendarDateUTC(timestamp, calendar = gregorianCalendar) {
+		const date = gregorianCalendar.fromEpochDay(getCalendarDayIdentifier(timestamp, calendar));
+		return new Date(Date.UTC(date.year, date.month - 1, date.day, 0, 0));
+	}
+	
+	function makeDateTime(timestamp) {
+		return new Date(timestamp.year, timestamp.month - 1, timestamp.day, timestamp.hour, timestamp.minute, timestamp.second ?? 0, timestamp.millisecond ?? 0);
+	}
+	
+	function makeCalendarDateTimeUTC(timestamp, calendar = gregorianCalendar) {
+		const date = gregorianCalendar.fromEpochDay(getCalendarDayIdentifier(timestamp, calendar));
+		return new Date(Date.UTC(date.year, date.month - 1, date.day, timestamp.hour, timestamp.minute, timestamp.second ?? 0, timestamp.millisecond ?? 0));
+	}
+	
+	function makeDateTimeUTC(timestamp) {
+		return new Date(Date.UTC(timestamp.year, timestamp.month - 1, timestamp.day, timestamp.hour, timestamp.minute, timestamp.second ?? 0, timestamp.millisecond ?? 0));
+	}
+	
+	function toUnixMilliseconds(timestamp) {
+		return makeDateTimeUTC(timestamp).getTime();
+	}
+	
+	function toUnixSeconds(timestamp) {
+		return Math.floor(toUnixMilliseconds(timestamp) / MILLISECONDS_IN_SECOND);
+	}
+	
+	function fromUnixMilliseconds(milliseconds) {
+		return parseDateUTC(new Date(milliseconds));
+	}
+	
+	function fromUnixSeconds(seconds) {
+		return fromUnixMilliseconds(seconds * MILLISECONDS_IN_SECOND);
+	}
+	
+	function getDateObject(timestamp) {
+		return makeDateTime(timestamp);
+	}
+	
+	function validateNumber(input) {
+		return isFinite(Number(input));
+	}
+	
+	function maxTimestamp(timestamps, useTime = false) {
+		const func = useTime === true ? getDayTimeIdentifier : getDayIdentifier;
+		return timestamps.reduce((prev, cur) => {
+			return Math.max(func(prev), func(cur)) === func(prev) ? prev : cur;
+		});
+	}
+	
+	function minTimestamp(timestamps, useTime = false) {
+		const func = useTime === true ? getDayTimeIdentifier : getDayIdentifier;
+		return timestamps.reduce((prev, cur) => {
+			return Math.min(func(prev), func(cur)) === func(prev) ? prev : cur;
+		});
+	}
+	function getTimestampSortValue(timestamp, useTime) {
+		if (useTime === true) return toUnixMilliseconds(timestamp);
+		return getEpochDay(timestamp) * MILLISECONDS_IN_DAY;
+	}
+	function compareTimestampOrder(first, second, useTime) {
+		return getTimestampSortValue(first, useTime) - getTimestampSortValue(second, useTime);
+	}
+	function createFrozenRange(start, end) {
+		return Object.freeze({
+			start: copyTimestamp(start),
+			end: copyTimestamp(end)
+		});
+	}
+	function isRangeTouchingOrOverlapping(first, second, useTime) {
+		const step = useTime ? 1 : MILLISECONDS_IN_DAY;
+		return getTimestampSortValue(second.start, useTime) <= getTimestampSortValue(first.end, useTime) + step;
+	}
+	function moveBoundary(timestamp, amount, useTime) {
+		if (useTime === true) return fromUnixMilliseconds(toUnixMilliseconds(timestamp) + amount);
+		return addToDate(timestamp, { day: amount });
+	}
+	
+	function createTimestampRange(start, end, useTime = false) {
+		if (compareTimestampOrder(start, end, useTime) <= 0) return createFrozenRange(start, end);
+		return createFrozenRange(end, start);
+	}
+	
+	function isTimestampInRange(timestamp, range, useTime = false) {
+		return isBetweenDates(timestamp, range.start, range.end, useTime);
+	}
+	
+	function isRangeOverlapping(first, second, useTime = false) {
+		const firstRange = createTimestampRange(first.start, first.end, useTime);
+		const secondRange = createTimestampRange(second.start, second.end, useTime);
+		return getTimestampSortValue(firstRange.start, useTime) <= getTimestampSortValue(secondRange.end, useTime) && getTimestampSortValue(secondRange.start, useTime) <= getTimestampSortValue(firstRange.end, useTime);
+	}
+	
+	function intersectRanges(first, second, useTime = false) {
+		if (isRangeOverlapping(first, second, useTime) === false) return null;
+		return createTimestampRange(compareTimestampOrder(first.start, second.start, useTime) >= 0 ? first.start : second.start, compareTimestampOrder(first.end, second.end, useTime) <= 0 ? first.end : second.end, useTime);
+	}
+	
+	function mergeRanges(ranges, useTime = false) {
+		const sorted = ranges.map((range) => createTimestampRange(range.start, range.end, useTime)).sort((a, b) => compareTimestampOrder(a.start, b.start, useTime));
+		const merged = [];
+		for (const range of sorted) {
+			const last = merged[merged.length - 1];
+			if (last === void 0 || isRangeTouchingOrOverlapping(last, range, useTime) === false) {
+				merged.push(range);
+				continue;
+			}
+			const end = compareTimestampOrder(last.end, range.end, useTime) >= 0 ? last.end : range.end;
+			merged[merged.length - 1] = createFrozenRange(last.start, end);
+		}
+		return merged;
+	}
+	
+	function subtractRanges(source, blocked, useTime = false) {
+		const normalizedSource = createTimestampRange(source.start, source.end, useTime);
+		const blockers = mergeRanges(blocked, useTime);
+		let available = [normalizedSource];
+		for (const blocker of blockers) {
+			const nextAvailable = [];
+			for (const range of available) {
+				const overlap = intersectRanges(range, blocker, useTime);
+				if (overlap === null) {
+					nextAvailable.push(range);
+					continue;
+				}
+				if (compareTimestampOrder(range.start, overlap.start, useTime) < 0) nextAvailable.push(createTimestampRange(range.start, moveBoundary(overlap.start, -1, useTime), useTime));
+				if (compareTimestampOrder(overlap.end, range.end, useTime) < 0) nextAvailable.push(createTimestampRange(moveBoundary(overlap.end, 1, useTime), range.end, useTime));
+			}
+			available = nextAvailable;
+		}
+		return available;
+	}
+	
+	function findRangeGaps(source, occupied, useTime = false) {
+		return subtractRanges(source, occupied, useTime);
+	}
+	
+	function isBetweenDates(timestamp, startTimestamp, endTimestamp, useTime = false) {
+		const cd = getDayIdentifier(timestamp) + (useTime === true ? getTimeIdentifier(timestamp) : 0);
+		const sd = getDayIdentifier(startTimestamp) + (useTime === true ? getTimeIdentifier(startTimestamp) : 0);
+		const ed = getDayIdentifier(endTimestamp) + (useTime === true ? getTimeIdentifier(endTimestamp) : 0);
+		return cd >= sd && cd <= ed;
+	}
+	
+	function isOverlappingDates(startTimestamp, endTimestamp, firstTimestamp, lastTimestamp) {
+		const start = getDayIdentifier(startTimestamp);
+		const end = getDayIdentifier(endTimestamp);
+		const first = getDayIdentifier(firstTimestamp);
+		const last = getDayIdentifier(lastTimestamp);
+		return start >= first && start <= last || end >= first && end <= last || first >= start && end >= last;
+	}
+	
+	function addToDate(timestamp, options) {
+		const ts = cloneTimestamp(timestamp);
+		if (options.year) ts.year += options.year;
+		if (options.month) ts.month += options.month;
+		if (options.day) ts.day += options.day;
+		if (options.hour) ts.hour += options.hour;
+		if (options.minute) ts.minute += options.minute;
+		if (options.second) ts.second = (ts.second ?? 0) + options.second;
+		if (options.millisecond) ts.millisecond = (ts.millisecond ?? 0) + options.millisecond;
+		return updateFormatted(normalizeTimestamp(ts));
+	}
+	
+	function addToDateClamped(timestamp, options) {
+		const ts = cloneTimestamp(timestamp);
+		if (options.year || options.month) {
+			const target = normalizeYearMonth(ts.year + (options.year ?? 0), ts.month + (options.month ?? 0));
+			ts.year = target.year;
+			ts.month = target.month;
+			ts.day = Math.min(ts.day, daysInMonth(ts.year, ts.month));
+		}
+		if (options.day) ts.day += options.day;
+		if (options.hour) ts.hour += options.hour;
+		if (options.minute) ts.minute += options.minute;
+		if (options.second) ts.second = (ts.second ?? 0) + options.second;
+		if (options.millisecond) ts.millisecond = (ts.millisecond ?? 0) + options.millisecond;
+		return updateFormatted(normalizeTimestamp(ts));
+	}
+	
+	function normalizeYearMonth(year, month) {
+		const date = new Date(year, month - 1, 1);
+		return {
+			year: date.getFullYear(),
+			month: date.getMonth() + 1
+		};
+	}
+	
+	function normalizeTimestamp(ts) {
+		const date = new Date(ts.year, ts.month - 1, ts.day, ts.hour, ts.minute, ts.second ?? 0, ts.millisecond ?? 0);
+		const timestamp = {
+			...ts,
+			year: date.getFullYear(),
+			month: date.getMonth() + 1,
+			day: date.getDate(),
+			hour: date.getHours(),
+			minute: date.getMinutes()
+		};
+		if (ts.second !== void 0 || date.getSeconds() !== 0) timestamp.second = date.getSeconds();
+		if (ts.millisecond !== void 0 || date.getMilliseconds() !== 0) timestamp.millisecond = date.getMilliseconds();
+		return freezeTimestamp(timestamp);
+	}
+	
+	function daysBetween(ts1, ts2) {
+		const diff = diffTimestamp(ts1, ts2, true);
+		return Math.floor(diff / TIME_CONSTANTS.MILLISECONDS_IN.DAY);
+	}
+	
+	function weeksBetween(ts1, ts2) {
+		let t1 = copyTimestamp(ts1);
+		let t2 = copyTimestamp(ts2);
+		t1 = findWeekday(t1, 0);
+		t2 = findWeekday(t2, 6);
+		return Math.ceil(daysBetween(t1, t2) / TIME_CONSTANTS.DAYS_IN.WEEK);
+	}
+	
+	function createDuration(milliseconds) {
+		const sign = milliseconds === 0 ? 0 : milliseconds < 0 ? -1 : 1;
+		let remaining = Math.abs(milliseconds);
+		const days = Math.floor(remaining / MILLISECONDS_IN_DAY);
+		remaining -= days * MILLISECONDS_IN_DAY;
+		const hours = Math.floor(remaining / MILLISECONDS_IN_HOUR);
+		remaining -= hours * MILLISECONDS_IN_HOUR;
+		const minutes = Math.floor(remaining / MILLISECONDS_IN_MINUTE);
+		remaining -= minutes * MILLISECONDS_IN_MINUTE;
+		const seconds = Math.floor(remaining / MILLISECONDS_IN_SECOND);
+		remaining -= seconds * MILLISECONDS_IN_SECOND;
+		return Object.freeze({
+			totalMilliseconds: milliseconds,
+			absoluteMilliseconds: Math.abs(milliseconds),
+			sign,
+			days,
+			hours,
+			minutes,
+			seconds,
+			milliseconds: remaining
+		});
+	}
+	
+	function durationBetween(start, end) {
+		return createDuration(toUnixMilliseconds(end) - toUnixMilliseconds(start));
+	}
+	
+	function addDuration(timestamp, duration) {
+		const milliseconds = typeof duration === "number" ? duration : duration.totalMilliseconds;
+		return fromUnixMilliseconds(toUnixMilliseconds(timestamp) + milliseconds);
+	}
+	
+	function subtractDuration(timestamp, duration) {
+		return addDuration(timestamp, -(typeof duration === "number" ? duration : duration.totalMilliseconds));
+	}
+	
+	function formatDuration(duration, options = {}) {
+		const value = typeof duration === "number" ? createDuration(duration) : duration;
+		const hours = value.days * HOURS_IN_DAY + value.hours;
+		let formatted = `${options.signed === true && value.sign < 0 ? "-" : ""}${padNumber(hours, 2)}:${padNumber(value.minutes, 2)}:${padNumber(value.seconds, 2)}`;
+		if (options.milliseconds === true) formatted += `.${padNumber(value.milliseconds, 3)}`;
+		return formatted;
+	}
+	function roundTimestampToInterval(timestamp, minutes, rounder) {
+		if (minutes <= 0 || Number.isFinite(minutes) === false) return copyTimestamp(timestamp);
+		const interval = minutes * MILLISECONDS_IN_MINUTE;
+		return fromUnixMilliseconds(rounder(toUnixMilliseconds(timestamp) / interval) * interval);
+	}
+	
+	function floorToInterval(timestamp, minutes) {
+		return roundTimestampToInterval(timestamp, minutes, Math.floor);
+	}
+	
+	function ceilToInterval(timestamp, minutes) {
+		return roundTimestampToInterval(timestamp, minutes, Math.ceil);
+	}
+	
+	function roundToInterval(timestamp, minutes) {
+		return roundTimestampToInterval(timestamp, minutes, Math.round);
+	}
+	const weekdayDateMap = {
+		Sun: /* @__PURE__ */ new Date("2020-01-05T00:00:00.000Z"),
+		Mon: /* @__PURE__ */ new Date("2020-01-06T00:00:00.000Z"),
+		Tue: /* @__PURE__ */ new Date("2020-01-07T00:00:00.000Z"),
+		Wed: /* @__PURE__ */ new Date("2020-01-08T00:00:00.000Z"),
+		Thu: /* @__PURE__ */ new Date("2020-01-09T00:00:00.000Z"),
+		Fri: /* @__PURE__ */ new Date("2020-01-10T00:00:00.000Z"),
+		Sat: /* @__PURE__ */ new Date("2020-01-11T00:00:00.000Z")
+	};
+	function resolveIntlNameFormat(options, type) {
+		if (type === "long" || type === "short" || type === "narrow") return options[type];
+		return options.long;
+	}
+	
+	function getWeekdayFormatter() {
+		const emptyFormatter = () => "";
+		const options = {
+			long: {
+				timeZone: "UTC",
+				weekday: "long"
+			},
+			short: {
+				timeZone: "UTC",
+				weekday: "short"
+			},
+			narrow: {
+				timeZone: "UTC",
+				weekday: "narrow"
+			}
+		};
+		if (typeof Intl === "undefined" || typeof Intl.DateTimeFormat === "undefined") return emptyFormatter;
+		
+		function weekdayFormatter(weekday, type, locale) {
+			try {
+				return new Intl.DateTimeFormat(locale || void 0, resolveIntlNameFormat(options, type)).format(weekdayDateMap[weekday]);
+			} catch (e) {
+				if (e instanceof Error) console.error(`Intl.DateTimeFormat: ${e.message} -> day of week: ${weekday}`);
+				return "";
+			}
+		}
+		return weekdayFormatter;
+	}
+	
+	function getWeekdayNames(type, locale) {
+		const shortWeekdays = Object.keys(weekdayDateMap);
+		const weekdayFormatter = getWeekdayFormatter();
+		return shortWeekdays.map((weekday) => String(weekdayFormatter(weekday, type, locale)));
+	}
+	
+	function getMonthFormatter() {
+		const emptyFormatter = () => "";
+		const options = {
+			long: {
+				timeZone: "UTC",
+				month: "long"
+			},
+			short: {
+				timeZone: "UTC",
+				month: "short"
+			},
+			narrow: {
+				timeZone: "UTC",
+				month: "narrow"
+			}
+		};
+		if (typeof Intl === "undefined" || typeof Intl.DateTimeFormat === "undefined") return emptyFormatter;
+		
+		function monthFormatter(month, type = "long", locale) {
+			try {
+				const intlFormatter = new Intl.DateTimeFormat(locale || void 0, resolveIntlNameFormat(options, type));
+				const date = /* @__PURE__ */ new Date();
+				date.setDate(1);
+				date.setMonth(month);
+				return intlFormatter.format(date);
+			} catch (e) {
+				if (e instanceof Error) console.error(`Intl.DateTimeFormat: ${e.message} -> month: ${month}`);
+				return "";
+			}
+		}
+		return monthFormatter;
+	}
+	
+	function getMonthNames(type, locale) {
+		const monthFormatter = getMonthFormatter();
+		return [...Array(12).keys()].map((month) => monthFormatter(month, type, locale));
+	}
+
+exports.DAYS_IN_MONTH = DAYS_IN_MONTH;
+exports.DAYS_IN_MONTH_LEAP = DAYS_IN_MONTH_LEAP;
+exports.DAYS_IN_MONTH_MAX = DAYS_IN_MONTH_MAX;
+exports.DAYS_IN_MONTH_MIN = DAYS_IN_MONTH_MIN;
+exports.DAYS_IN_WEEK = DAYS_IN_WEEK;
+exports.DAY_MIN = DAY_MIN;
+exports.FIRST_HOUR = FIRST_HOUR;
+exports.HOURS_IN_DAY = HOURS_IN_DAY;
+exports.MILLISECONDS_IN_DAY = MILLISECONDS_IN_DAY;
+exports.MILLISECONDS_IN_HOUR = MILLISECONDS_IN_HOUR;
+exports.MILLISECONDS_IN_MINUTE = MILLISECONDS_IN_MINUTE;
+exports.MILLISECONDS_IN_SECOND = MILLISECONDS_IN_SECOND;
+exports.MILLISECONDS_IN_WEEK = MILLISECONDS_IN_WEEK;
+exports.MINUTES_IN_HOUR = MINUTES_IN_HOUR;
+exports.MONTH_MAX = MONTH_MAX;
+exports.MONTH_MIN = MONTH_MIN;
+exports.PARSE_DATE = PARSE_DATE;
+exports.PARSE_DATETIME = PARSE_DATETIME;
+exports.PARSE_TIME = PARSE_TIME;
+exports.SECONDS_IN_DAY = SECONDS_IN_DAY;
+exports.SECONDS_IN_HOUR = SECONDS_IN_HOUR;
+exports.SECONDS_IN_MINUTE = SECONDS_IN_MINUTE;
+exports.TIME_CONSTANTS = TIME_CONSTANTS;
+exports.TimeObject = TimeObject;
+exports.Timestamp = Timestamp;
+exports.addCalendarDays = addCalendarDays;
+exports.addCalendarMonths = addCalendarMonths;
+exports.addCalendarYears = addCalendarYears;
+exports.addDuration = addDuration;
+exports.addToDate = addToDate;
+exports.addToDateClamped = addToDateClamped;
+exports.ceilToInterval = ceilToInterval;
+exports.compareDate = compareDate;
+exports.compareDateTime = compareDateTime;
+exports.compareTime = compareTime;
+exports.compareTimestamps = compareTimestamps;
+exports.copyTimestamp = copyTimestamp;
+exports.createCalendarDayList = createCalendarDayList;
+exports.createCalendarLocaleFormatterUTC = createCalendarLocaleFormatterUTC;
+exports.createCalendarTimestamp = createCalendarTimestamp;
+exports.createCalendarTimestampFromEpochDay = createCalendarTimestampFromEpochDay;
+exports.createDayList = createDayList;
+exports.createDuration = createDuration;
+exports.createIntervalList = createIntervalList;
+exports.createNativeLocaleFormatter = createNativeLocaleFormatter;
+exports.createNativeLocaleFormatterUTC = createNativeLocaleFormatterUTC;
+exports.createTimestampRange = createTimestampRange;
+exports.daysBetween = daysBetween;
+exports.daysInMonth = daysInMonth;
+exports.diffTimestamp = diffTimestamp;
+exports.durationBetween = durationBetween;
+exports.findCalendarWeekday = findCalendarWeekday;
+exports.findRangeGaps = findRangeGaps;
+exports.findWeekday = findWeekday;
+exports.floorToInterval = floorToInterval;
+exports.formatCalendarDate = formatCalendarDate;
+exports.formatDuration = formatDuration;
+exports.fromUnixMilliseconds = fromUnixMilliseconds;
+exports.fromUnixSeconds = fromUnixSeconds;
+exports.getCalendarDayIdentifier = getCalendarDayIdentifier;
+exports.getCalendarEndOfMonth = getCalendarEndOfMonth;
+exports.getCalendarEndOfWeek = getCalendarEndOfWeek;
+exports.getCalendarEndOfYear = getCalendarEndOfYear;
+exports.getCalendarStartOfMonth = getCalendarStartOfMonth;
+exports.getCalendarStartOfWeek = getCalendarStartOfWeek;
+exports.getCalendarStartOfYear = getCalendarStartOfYear;
+exports.getDate = getDate;
+exports.getDateObject = getDateObject;
+exports.getDateTime = getDateTime;
+exports.getDayIdentifier = getDayIdentifier;
+exports.getDayOfYear = getDayOfYear;
+exports.getDayTimeIdentifier = getDayTimeIdentifier;
+exports.getEndOfDay = getEndOfDay;
+exports.getEndOfMonth = getEndOfMonth;
+exports.getEndOfWeek = getEndOfWeek;
+exports.getEndOfYear = getEndOfYear;
+exports.getEpochDay = getEpochDay;
+exports.getMonthFormatter = getMonthFormatter;
+exports.getMonthNames = getMonthNames;
+exports.getStartOfDay = getStartOfDay;
+exports.getStartOfMonth = getStartOfMonth;
+exports.getStartOfWeek = getStartOfWeek;
+exports.getStartOfYear = getStartOfYear;
+exports.getTime = getTime;
+exports.getTimeIdentifier = getTimeIdentifier;
+exports.getWeekday = getWeekday;
+exports.getWeekdayFormatter = getWeekdayFormatter;
+exports.getWeekdayNames = getWeekdayNames;
+exports.getWorkWeek = getWorkWeek;
+exports.gregorianCalendar = gregorianCalendar;
+exports.intersectRanges = intersectRanges;
+exports.isBetweenDates = isBetweenDates;
+exports.isLeapYear = isLeapYear;
+exports.isOverlappingDates = isOverlappingDates;
+exports.isRangeOverlapping = isRangeOverlapping;
+exports.isTimestampInRange = isTimestampInRange;
+exports.isToday = isToday;
+exports.isTodayUTC = isTodayUTC;
+exports.isValidCalendarDate = isValidCalendarDate;
+exports.makeCalendarDateTimeUTC = makeCalendarDateTimeUTC;
+exports.makeCalendarDateUTC = makeCalendarDateUTC;
+exports.makeDate = makeDate;
+exports.makeDateTime = makeDateTime;
+exports.makeDateTimeUTC = makeDateTimeUTC;
+exports.makeDateUTC = makeDateUTC;
+exports.maxTimestamp = maxTimestamp;
+exports.mergeRanges = mergeRanges;
+exports.minTimestamp = minTimestamp;
+exports.moveRelativeDays = moveRelativeDays;
+exports.nextCalendarDay = nextCalendarDay;
+exports.nextDay = nextDay;
+exports.nowUTC = nowUTC;
+exports.padNumber = padNumber;
+exports.parseCalendarTimestamp = parseCalendarTimestamp;
+exports.parseDate = parseDate;
+exports.parseDateUTC = parseDateUTC;
+exports.parseTime = parseTime;
+exports.parseTimestamp = parseTimestamp;
+exports.parsed = parsed;
+exports.prevCalendarDay = prevCalendarDay;
+exports.prevDay = prevDay;
+exports.relativeDays = relativeDays;
+exports.roundToInterval = roundToInterval;
+exports.subtractDuration = subtractDuration;
+exports.subtractRanges = subtractRanges;
+exports.toCalendarDateParts = toCalendarDateParts;
+exports.toUnixMilliseconds = toUnixMilliseconds;
+exports.toUnixSeconds = toUnixSeconds;
+exports.today = today;
+exports.todayUTC = todayUTC;
+exports.updateCalendarFormatted = updateCalendarFormatted;
+exports.updateCalendarRelative = updateCalendarRelative;
+exports.updateDayOfYear = updateDayOfYear;
+exports.updateDisabled = updateDisabled;
+exports.updateFormatted = updateFormatted;
+exports.updateMinutes = updateMinutes;
+exports.updateRelative = updateRelative;
+exports.updateWeekday = updateWeekday;
+exports.updateWorkWeek = updateWorkWeek;
+exports.validateNumber = validateNumber;
+exports.validateTimestamp = validateTimestamp;
+exports.weeksBetween = weeksBetween;
+return exports;
+})({});