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

package/dist/index.global.js

@@ -39,7 +39,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return padded;
 	}
 	
-	function formatCalendarDate(date) {
+	function formatCalendarDate$1(date) {
 		return `${padNumber$1(date.year, 4)}-${padNumber$1(date.month, 2)}-${padNumber$1(date.day, 2)}`;
 	}
 	function fromUtcDate(date) {
@@ -57,6 +57,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		id: "gregorian",
 		intlCalendar: "gregory",
 		label: "Gregorian",
+		defaultLocale: "en-US",
+		defaultDirection: "ltr",
+		defaultWeekdays: Object.freeze([
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		]),
 		monthsInYear() {
 			return 12;
 		},
@@ -93,8 +104,52 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return toGregorianUtcDate(date).getUTCDay();
 		}
 	});
+	
+	function getCalendarLocale$1(calendar = gregorianCalendar) {
+		return calendar.defaultLocale ?? gregorianCalendar.defaultLocale ?? "en-US";
+	}
+	
+	function getCalendarDirection$1(calendar = gregorianCalendar) {
+		return calendar.defaultDirection ?? gregorianCalendar.defaultDirection ?? "ltr";
+	}
+	
+	function isCalendarRTL$1(calendar = gregorianCalendar) {
+		return getCalendarDirection$1(calendar) === "rtl";
+	}
+	
+	function getCalendarWeekdays$1(calendar = gregorianCalendar) {
+		return [...calendar.defaultWeekdays ?? gregorianCalendar.defaultWeekdays ?? [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		]];
+	}
 
 
+	function formatCalendarDate(date) {
+		return formatCalendarDate$1(date);
+	}
+	
+	function getCalendarLocale(calendar = gregorianCalendar) {
+		return getCalendarLocale$1(calendar);
+	}
+	
+	function getCalendarDirection(calendar = gregorianCalendar) {
+		return getCalendarDirection$1(calendar);
+	}
+	
+	function isCalendarRTL(calendar = gregorianCalendar) {
+		return isCalendarRTL$1(calendar);
+	}
+	
+	function getCalendarWeekdays(calendar = gregorianCalendar) {
+		return getCalendarWeekdays$1(calendar);
+	}
+	
 	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}))?/;
@@ -291,18 +346,23 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		timestamp.time = getTime(timestamp);
 		return freezeTimestamp(timestamp);
 	}
-	function parseDateByMode(date, utc) {
+	function parseDateByMode(date, utc, calendar = gregorianCalendar) {
 		if (!(date instanceof Date)) return null;
 		if (Number.isNaN(date.getTime())) return null;
 		const UTC = utc ? "UTC" : "";
+		const gregorian = {
+			year: date[`get${UTC}FullYear`](),
+			month: date[`get${UTC}Month`]() + 1,
+			day: date[`get${UTC}Date`]()
+		};
 		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),
+			date: formatCalendarDate(gregorian),
 			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`](),
+			year: gregorian.year,
+			month: gregorian.month,
+			day: gregorian.day,
 			hour: date[`get${UTC}Hours`](),
 			minute: date[`get${UTC}Minutes`](),
 			weekday: 0,
@@ -317,15 +377,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		};
 		if (second !== 0) timestamp.second = second;
 		if (millisecond !== 0) timestamp.millisecond = millisecond;
-		return updateFormatted(timestamp);
+		const formatted = updateFormatted(timestamp);
+		if (calendar === gregorianCalendar) return formatted;
+		return createCalendarTimestampFromEpochDay(gregorianCalendar.toEpochDay(gregorian), calendar, { ...getCalendarTimestampOptions(formatted) });
 	}
 	
-	function parseDate(date) {
-		return parseDateByMode(date, false);
+	function parseDate(date, calendar = gregorianCalendar) {
+		return parseDateByMode(date, false, calendar);
 	}
 	
-	function parseDateUTC(date) {
-		return parseDateByMode(date, true);
+	function parseDateUTC(date, calendar = gregorianCalendar) {
+		return parseDateByMode(date, true, calendar);
 	}
 	
 	function padNumber(x, length) {
@@ -334,95 +396,66 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return padded;
 	}
 	
-	function isLeapYear(year) {
-		return gregorianCalendar.isLeapYear(year);
+	function isLeapYear(year, calendar = gregorianCalendar) {
+		return calendar.isLeapYear(year);
 	}
 	
-	function daysInMonth(year, month) {
-		return gregorianCalendar.daysInMonth(year, month);
+	function daysInMonth(year, month, calendar = gregorianCalendar) {
+		return calendar.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 nextDay(timestamp, calendar = gregorianCalendar) {
+		return nextCalendarDay(timestamp, calendar);
 	}
 	
-	function prevDay(timestamp) {
-		const date = gregorianCalendar.prevDay(toCalendarDateParts(timestamp));
-		return updateFormatted(normalizeTimestamp({
-			...timestamp,
-			year: date.year,
-			month: date.month,
-			day: date.day
-		}));
+	function prevDay(timestamp, calendar = gregorianCalendar) {
+		return prevCalendarDay(timestamp, calendar);
+	}
+	function formatCalendarDateFromDate(date, utc, calendar = gregorianCalendar) {
+		const UTC = utc ? "UTC" : "";
+		const gregorian = {
+			year: date[`get${UTC}FullYear`](),
+			month: date[`get${UTC}Month`]() + 1,
+			day: date[`get${UTC}Date`]()
+		};
+		const epochDay = gregorianCalendar.toEpochDay(gregorian);
+		return formatCalendarDate(calendar.fromEpochDay(epochDay));
 	}
 	
-	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 today(calendar = gregorianCalendar) {
+		return formatCalendarDateFromDate(/* @__PURE__ */ new Date(), false, calendar);
 	}
 	
-	function todayUTC(date = /* @__PURE__ */ new Date()) {
-		return [
-			padNumber(date.getUTCFullYear(), 4),
-			padNumber(date.getUTCMonth() + 1, 2),
-			padNumber(date.getUTCDate(), 2)
-		].join("-");
+	function todayUTC(date = /* @__PURE__ */ new Date(), calendar = gregorianCalendar) {
+		return formatCalendarDateFromDate(date, true, calendar);
 	}
 	
-	function nowUTC(date = /* @__PURE__ */ new Date()) {
-		return parseDateUTC(date);
+	function nowUTC(date = /* @__PURE__ */ new Date(), calendar = gregorianCalendar) {
+		return parseDateUTC(date, calendar);
 	}
 	
-	function isToday(date) {
-		return date === today();
+	function isToday(date, calendar = gregorianCalendar) {
+		return date === today(calendar);
 	}
 	
-	function isTodayUTC(date, now = /* @__PURE__ */ new Date()) {
-		return date === todayUTC(now);
+	function isTodayUTC(date, now = /* @__PURE__ */ new Date(), calendar = gregorianCalendar) {
+		return date === todayUTC(now, calendar);
 	}
 	
-	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 getStartOfWeek(timestamp, weekdays, today, calendar = gregorianCalendar) {
+		return getCalendarStartOfWeek(timestamp, weekdays, calendar, today);
 	}
 	
-	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 getEndOfWeek(timestamp, weekdays, today, calendar = gregorianCalendar) {
+		return getCalendarEndOfWeek(timestamp, weekdays, calendar, today);
 	}
 	
-	function getStartOfMonth(timestamp) {
-		let start = cloneTimestamp(timestamp);
-		start.day = 1;
-		start = updateFormatted(start);
-		return start;
+	function getStartOfMonth(timestamp, calendar = gregorianCalendar) {
+		return getCalendarStartOfMonth(timestamp, calendar);
 	}
 	
-	function getEndOfMonth(timestamp) {
-		let end = cloneTimestamp(timestamp);
-		end.day = daysInMonth(end.year, end.month);
-		end = updateFormatted(end);
-		return end;
+	function getEndOfMonth(timestamp, calendar = gregorianCalendar) {
+		return getCalendarEndOfMonth(timestamp, calendar);
 	}
 	
 	function parseTime(input) {
@@ -478,6 +511,20 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return getEpochDay(timestamp, calendar);
 	}
 	
+	function getCalendarDateIdentity(timestamp, calendar = gregorianCalendar) {
+		const native = toCalendarDateParts(timestamp);
+		const epochDay = calendar.toEpochDay(native);
+		const gregorian = gregorianCalendar.fromEpochDay(epochDay);
+		return Object.freeze({
+			calendarId: calendar.id,
+			nativeDate: formatCalendarDate(native),
+			native,
+			gregorianDate: formatCalendarDate(gregorian),
+			gregorian,
+			epochDay
+		});
+	}
+	
 	function isValidCalendarDate(date, calendar = gregorianCalendar) {
 		if (date.year < 1) return false;
 		if (date.month < 1 || date.month > calendar.monthsInYear(date.year)) return false;
@@ -522,6 +569,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		});
 	}
 	
+	function validateCalendarTimestamp(input, calendar = gregorianCalendar) {
+		return parseCalendarTimestamp(input, calendar) !== null;
+	}
+	
 	function createCalendarTimestampFromEpochDay(epochDay, calendar = gregorianCalendar, options = {}) {
 		return createCalendarTimestamp(calendar.fromEpochDay(epochDay), calendar, options);
 	}
@@ -680,13 +731,20 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			}
 			let day = updateCalendarFormatted(current, calendar);
 			day = updateCalendarRelative(day, now, calendar);
-			day = updateDisabled(day, disabledBefore, disabledAfter, disabledWeekdays, disabledDays);
+			day = updateCalendarDisabled(day, disabledBefore, disabledAfter, disabledWeekdays, disabledDays, calendar);
 			days.push(day);
 			current = nextCalendarDay(current, calendar);
 		}
 		return days;
 	}
 	
+	function isOutsideCalendarMonth(timestamp, reference, calendar = gregorianCalendar) {
+		const start = getCalendarStartOfMonth(reference, calendar);
+		const end = getCalendarEndOfMonth(reference, calendar);
+		const targetIdentifier = getCalendarDayIdentifier(timestamp, calendar);
+		return targetIdentifier < getCalendarDayIdentifier(start, calendar) || targetIdentifier > getCalendarDayIdentifier(end, calendar);
+	}
+	
 	function getTimeIdentifier(timestamp) {
 		return (timestamp.hour ?? 0) * 100 + (timestamp.minute ?? 0);
 	}
@@ -705,10 +763,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return utc2 - utc1;
 	}
 	
-	function updateRelative(timestamp, now, time = false) {
+	function updateRelative(timestamp, now, time = false, calendar = gregorianCalendar) {
 		const ts = cloneTimestamp(timestamp);
-		let a = getDayIdentifier(now);
-		let b = getDayIdentifier(ts);
+		let a = getCalendarDayIdentifier(now, calendar);
+		let b = getCalendarDayIdentifier(ts, calendar);
 		let current = a === b;
 		if (ts.hasTime && time && current) {
 			a = getTimeComparisonValue(now);
@@ -722,7 +780,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return freezeTimestamp(ts);
 	}
 	
-	function updateMinutes(timestamp, minutes, now = null) {
+	function updateMinutes(timestamp, minutes, now = null, calendar = gregorianCalendar) {
 		let ts = cloneTimestamp(timestamp);
 		ts.hasTime = true;
 		ts.hour = Math.floor(minutes / TIME_CONSTANTS.MINUTES_IN.HOUR);
@@ -730,25 +788,25 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		delete ts.second;
 		delete ts.millisecond;
 		ts.time = getTime(ts);
-		if (now) return updateRelative(ts, now, true);
+		if (now) return updateRelative(ts, now, true, calendar);
 		return freezeTimestamp(ts);
 	}
 	
-	function updateWeekday(timestamp) {
+	function updateWeekday(timestamp, calendar = gregorianCalendar) {
 		const ts = cloneTimestamp(timestamp);
-		ts.weekday = getWeekday(ts);
+		ts.weekday = getWeekday(ts, calendar);
 		return freezeTimestamp(ts);
 	}
 	
-	function updateDayOfYear(timestamp) {
+	function updateDayOfYear(timestamp, calendar = gregorianCalendar) {
 		const ts = cloneTimestamp(timestamp);
-		ts.doy = getDayOfYear(ts) || 0;
+		ts.doy = getDayOfYear(ts, calendar) || 0;
 		return freezeTimestamp(ts);
 	}
 	
-	function updateWorkWeek(timestamp) {
+	function updateWorkWeek(timestamp, calendar = gregorianCalendar) {
 		const ts = cloneTimestamp(timestamp);
-		ts.workweek = getWorkWeek(ts);
+		ts.workweek = getWorkWeek(ts, calendar);
 		return freezeTimestamp(ts);
 	}
 	function isDisabledDayConfig(value) {
@@ -796,6 +854,34 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		const disabledDay = parseTimestamp(day);
 		return disabledDay !== null && getDayIdentifier(disabledDay) === target;
 	}
+	function parseCalendarDateIdentifier(value, calendar) {
+		const timestamp = parseCalendarTimestamp(value, calendar);
+		return timestamp === null ? null : getCalendarDayIdentifier(timestamp, calendar);
+	}
+	function isTimestampInCalendarDisabledDay(timestamp, day, calendar) {
+		const target = getCalendarDayIdentifier(timestamp, calendar);
+		if (Array.isArray(day) === true) {
+			if (day.length === 2 && day[0] && day[1]) {
+				const start = parseCalendarDateIdentifier(day[0], calendar);
+				const end = parseCalendarDateIdentifier(day[1], calendar);
+				return start !== null && end !== null && target >= Math.min(start, end) && target <= Math.max(start, end);
+			}
+			return day.some((date) => parseCalendarDateIdentifier(date, calendar) === 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) return parseCalendarDateIdentifier(date, calendar) === target;
+			if (startDate !== void 0 && endDate !== void 0) {
+				const start = parseCalendarDateIdentifier(startDate, calendar);
+				const end = parseCalendarDateIdentifier(endDate, calendar);
+				return start !== null && end !== null && target >= Math.min(start, end) && target <= Math.max(start, end);
+			}
+			return false;
+		}
+		return parseCalendarDateIdentifier(day, calendar) === target;
+	}
 	
 	function updateDisabled(timestamp, disabledBefore, disabledAfter, disabledWeekdays, disabledDays) {
 		let ts = cloneTimestamp(timestamp);
@@ -827,28 +913,138 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return freezeTimestamp(ts);
 	}
 	
-	function updateFormatted(timestamp) {
+	function updateCalendarDisabled(timestamp, disabledBefore, disabledAfter, disabledWeekdays, disabledDays, calendar = gregorianCalendar) {
+		let ts = cloneTimestamp(timestamp);
+		const target = getCalendarDayIdentifier(ts, calendar);
+		if (disabledBefore !== void 0) {
+			const before = parseCalendarDateIdentifier(disabledBefore, calendar);
+			if (before !== null && target <= before) ts.disabled = true;
+		}
+		if (ts.disabled !== true && disabledAfter !== void 0) {
+			const after = parseCalendarDateIdentifier(disabledAfter, calendar);
+			if (after !== null && target >= after) ts.disabled = true;
+		}
+		if (ts.disabled !== true && Array.isArray(disabledWeekdays) && disabledWeekdays.length > 0) {
+			for (const weekday of disabledWeekdays) if (weekday === ts.weekday) {
+				ts.disabled = true;
+				break;
+			}
+		}
+		if (ts.disabled !== true && Array.isArray(disabledDays) && disabledDays.length > 0) {
+			for (const day of disabledDays) if (isTimestampInCalendarDisabledDay(ts, day, calendar) === true) {
+				ts = applyDisabledDayConfig(ts, isDisabledDayConfig(day) === true ? day : void 0);
+				break;
+			}
+		}
+		return freezeTimestamp(ts);
+	}
+	function isTimestampInCalendarDateCollection(timestamp, dates, calendar) {
+		if (dates === void 0) return false;
+		const target = getCalendarDayIdentifier(timestamp, calendar);
+		for (const date of dates) if (parseCalendarDateIdentifier(date, calendar) === target) return true;
+		return false;
+	}
+	
+	function getCalendarSelectionState(timestamp, options = {}, calendar = gregorianCalendar) {
+		const selectedDate = isTimestampInCalendarDateCollection(timestamp, options.selectedDates, calendar);
+		const target = getCalendarDayIdentifier(timestamp, calendar);
+		const rangeBoundaryDates = options.selectedStartEndDates ?? [];
+		let rangeFirst = false;
+		let range = false;
+		let rangeLast = false;
+		if (rangeBoundaryDates.length === 2 && rangeBoundaryDates[0] && rangeBoundaryDates[1]) {
+			const first = parseCalendarDateIdentifier(rangeBoundaryDates[0], calendar);
+			const last = parseCalendarDateIdentifier(rangeBoundaryDates[1], calendar);
+			if (first !== null && last !== null) {
+				const start = Math.min(first, last);
+				const end = Math.max(first, last);
+				rangeFirst = target === start;
+				rangeLast = target === end;
+				range = target > start && target < end;
+			}
+		}
+		return Object.freeze({
+			selectedDate,
+			rangeFirst,
+			range,
+			rangeLast,
+			selected: selectedDate || rangeFirst || range || rangeLast
+		});
+	}
+	
+	function getCalendarDateState(timestamp, options = {}, calendar = gregorianCalendar) {
+		const disabledTimestamp = updateCalendarDisabled(timestamp, options.disabledBefore, options.disabledAfter, options.disabledWeekdays, options.disabledDays, calendar);
+		const selection = getCalendarSelectionState(disabledTimestamp, options, calendar);
+		const outside = options.outside ?? (options.referenceMonth === void 0 ? false : isOutsideCalendarMonth(disabledTimestamp, options.referenceMonth, calendar));
+		return Object.freeze({
+			timestamp: disabledTimestamp,
+			identity: getCalendarDateIdentity(disabledTimestamp, calendar),
+			outside,
+			disabled: disabledTimestamp.disabled === true,
+			...selection
+		});
+	}
+	
+	function createCalendarMonthView(timestamp, now, calendar = gregorianCalendar, options = {}) {
+		const weekdays = options.weekdays ?? [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		];
+		const reference = updateCalendarFormatted(timestamp, calendar);
+		const start = getCalendarStartOfMonth(reference, calendar);
+		const end = getCalendarEndOfMonth(reference, calendar);
+		const visibleStart = getCalendarStartOfWeek(start, weekdays, calendar, now);
+		const visibleEnd = getCalendarEndOfWeek(end, weekdays, calendar, now);
+		const days = createCalendarDayList(visibleStart, visibleEnd, now, calendar, {
+			weekdays,
+			disabledBefore: options.disabledBefore,
+			disabledAfter: options.disabledAfter,
+			disabledWeekdays: options.disabledWeekdays,
+			disabledDays: options.disabledDays,
+			max: options.max ?? weekdays.length * 6,
+			min: options.min ?? weekdays.length * 6
+		}).map((day) => getCalendarDateState(day, {
+			...options,
+			referenceMonth: reference
+		}, calendar));
+		return Object.freeze({
+			reference,
+			start,
+			end,
+			visibleStart,
+			visibleEnd,
+			days
+		});
+	}
+	
+	function updateFormatted(timestamp, calendar = gregorianCalendar) {
 		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);
+		ts.weekday = getWeekday(ts, calendar);
+		ts.doy = getDayOfYear(ts, calendar) || 0;
+		ts.workweek = getWorkWeek(ts, calendar);
 		return freezeTimestamp(ts);
 	}
 	
-	function getDayOfYear(timestamp) {
+	function getDayOfYear(timestamp, calendar = gregorianCalendar) {
 		if (timestamp.year === 0) return;
-		return gregorianCalendar.getDayOfYear(toCalendarDateParts(timestamp));
+		return calendar.getDayOfYear(toCalendarDateParts(timestamp));
 	}
 	
-	function getWorkWeek(timestamp) {
+	function getWorkWeek(timestamp, calendar = gregorianCalendar) {
 		let ts = timestamp;
 		if (ts.year === 0) {
-			const parsedToday = parseTimestamp(today());
+			const parsedToday = parseCalendarTimestamp(today(calendar), calendar);
 			if (parsedToday) ts = parsedToday;
 		}
+		if (calendar !== gregorianCalendar) return getCalendarWorkWeek(toCalendarDateParts(ts), calendar);
 		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);
@@ -857,9 +1053,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return Math.ceil(((weekday.valueOf() - yearStart.valueOf()) / 864e5 + 1) / 7);
 	}
 	
-	function getWeekday(timestamp) {
+	function getWeekday(timestamp, calendar = gregorianCalendar) {
 		let weekday = timestamp.weekday;
-		if (timestamp.hasDay) weekday = gregorianCalendar.getWeekday(toCalendarDateParts(timestamp));
+		if (timestamp.hasDay) weekday = calendar.getWeekday(toCalendarDateParts(timestamp));
 		return weekday ?? 0;
 	}
 	
@@ -886,18 +1082,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		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 getStartOfYear(timestamp, calendar = gregorianCalendar) {
+		return getStartOfDay(getCalendarStartOfYear(timestamp, calendar));
 	}
 	
-	function getEndOfYear(timestamp) {
-		const ts = cloneTimestamp(timestamp);
-		ts.month = 12;
-		ts.day = daysInMonth(ts.year, 12);
-		return getEndOfDay(updateFormatted(ts));
+	function getEndOfYear(timestamp, calendar = gregorianCalendar) {
+		return getEndOfDay(getCalendarEndOfYear(timestamp, calendar));
 	}
 	
 	function getDate(timestamp) {
@@ -926,8 +1116,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		4,
 		5,
 		6
-	]) {
-		return relativeDays(timestamp, mover, days, allowedWeekdays);
+	], calendar = gregorianCalendar) {
+		return relativeDays(timestamp, mover, days, allowedWeekdays, calendar);
 	}
 	
 	function relativeDays(timestamp, mover = nextDay, days = 1, allowedWeekdays = [
@@ -938,19 +1128,19 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		4,
 		5,
 		6
-	]) {
+	], calendar = gregorianCalendar) {
 		let ts = copyTimestamp(timestamp);
 		if (!allowedWeekdays.includes(Number(ts.weekday)) && ts.weekday === 0 && mover === nextDay) ++days;
 		while (--days >= 0) {
-			ts = mover(ts);
+			ts = mover(ts, calendar);
 			if (allowedWeekdays.length < 7 && !allowedWeekdays.includes(Number(ts.weekday))) ++days;
 		}
 		return ts;
 	}
 	
-	function findWeekday(timestamp, weekday, mover = nextDay, maxDays = 6) {
+	function findWeekday(timestamp, weekday, mover = nextDay, maxDays = 6, calendar = gregorianCalendar) {
 		let ts = copyTimestamp(timestamp);
-		while (ts.weekday !== weekday && --maxDays >= 0) ts = mover(ts);
+		while (ts.weekday !== weekday && --maxDays >= 0) ts = mover(ts, calendar);
 		return ts;
 	}
 	
@@ -962,7 +1152,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		4,
 		5,
 		6
-	], disabledBefore = void 0, disabledAfter = void 0, disabledWeekdays = [], disabledDays = [], max = 42, min = 0) {
+	], disabledBefore = void 0, disabledAfter = void 0, disabledWeekdays = [], disabledDays = [], max = 42, min = 0, calendar = gregorianCalendar) {
+		if (calendar !== gregorianCalendar) return createCalendarDayList(start, end, now, calendar, {
+			weekdays,
+			disabledBefore,
+			disabledAfter,
+			disabledWeekdays,
+			disabledDays,
+			max,
+			min
+		});
 		const begin = getDayIdentifier(start);
 		const stop = getDayIdentifier(end);
 		const days = [];
@@ -1193,7 +1392,34 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return start >= first && start <= last || end >= first && end <= last || first >= start && end >= last;
 	}
 	
-	function addToDate(timestamp, options) {
+	function addToCalendarDateTime(timestamp, options, calendar) {
+		let ts = updateCalendarFormatted(timestamp, calendar);
+		if (options.year) ts = addCalendarYears(ts, options.year, calendar);
+		if (options.month) ts = addCalendarMonths(ts, options.month, calendar);
+		if (options.day) ts = addCalendarDays(ts, options.day, calendar);
+		if (options.hour !== void 0 || options.minute !== void 0 || options.second !== void 0 || options.millisecond !== void 0) {
+			const totalMilliseconds = (ts.hour + (options.hour ?? 0)) * MILLISECONDS_IN_HOUR + (ts.minute + (options.minute ?? 0)) * MILLISECONDS_IN_MINUTE + ((ts.second ?? 0) + (options.second ?? 0)) * MILLISECONDS_IN_SECOND + ((ts.millisecond ?? 0) + (options.millisecond ?? 0));
+			const dayOffset = Math.floor(totalMilliseconds / MILLISECONDS_IN_DAY);
+			let timeMilliseconds = totalMilliseconds % MILLISECONDS_IN_DAY;
+			if (timeMilliseconds < 0) timeMilliseconds += MILLISECONDS_IN_DAY;
+			if (dayOffset !== 0) ts = addCalendarDays(ts, dayOffset, calendar);
+			const next = cloneTimestamp(ts);
+			next.hasTime = true;
+			next.hour = Math.floor(timeMilliseconds / MILLISECONDS_IN_HOUR);
+			timeMilliseconds %= MILLISECONDS_IN_HOUR;
+			next.minute = Math.floor(timeMilliseconds / MILLISECONDS_IN_MINUTE);
+			timeMilliseconds %= MILLISECONDS_IN_MINUTE;
+			next.second = Math.floor(timeMilliseconds / MILLISECONDS_IN_SECOND);
+			next.millisecond = timeMilliseconds % MILLISECONDS_IN_SECOND;
+			if (next.second === 0 && timestamp.second === void 0 && options.second === void 0) delete next.second;
+			if (next.millisecond === 0 && timestamp.millisecond === void 0 && options.millisecond === void 0) delete next.millisecond;
+			ts = next;
+		}
+		return updateCalendarFormatted(ts, calendar);
+	}
+	
+	function addToDate(timestamp, options, calendar = gregorianCalendar) {
+		if (calendar !== gregorianCalendar) return addToCalendarDateTime(timestamp, options, calendar);
 		const ts = cloneTimestamp(timestamp);
 		if (options.year) ts.year += options.year;
 		if (options.month) ts.month += options.month;
@@ -1205,7 +1431,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return updateFormatted(normalizeTimestamp(ts));
 	}
 	
-	function addToDateClamped(timestamp, options) {
+	function addToDateClamped(timestamp, options, calendar = gregorianCalendar) {
+		if (calendar !== gregorianCalendar) return addToCalendarDateTime(timestamp, options, calendar);
 		const ts = cloneTimestamp(timestamp);
 		if (options.year || options.month) {
 			const target = normalizeYearMonth(ts.year + (options.year ?? 0), ts.month + (options.month ?? 0));
@@ -1399,10 +1626,57 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return monthFormatter;
 	}
 	
+	function getCalendarMonthFormatter(calendar = gregorianCalendar) {
+		const options = {
+			long: {
+				timeZone: "UTC",
+				month: "long"
+			},
+			short: {
+				timeZone: "UTC",
+				month: "short"
+			},
+			narrow: {
+				timeZone: "UTC",
+				month: "narrow"
+			}
+		};
+		const fallbackFormatter = (month) => Number.isFinite(month) && month >= 1 ? `Month ${month}` : "";
+		if (typeof Intl === "undefined" || typeof Intl.DateTimeFormat === "undefined") return fallbackFormatter;
+		return (month, type = "long", locale, year = 1) => {
+			const calendarMonth = Math.trunc(month);
+			const calendarYear = Math.trunc(year);
+			const date = {
+				year: calendarYear,
+				month: calendarMonth,
+				day: 1
+			};
+			if (Number.isFinite(calendarMonth) === false || Number.isFinite(calendarYear) === false || isValidCalendarDate(date, calendar) === false) return "";
+			try {
+				const resolvedOptions = resolveIntlNameFormat(options, type);
+				const formatterOptions = calendar.intlCalendar === void 0 || resolvedOptions.calendar !== void 0 ? resolvedOptions : {
+					...resolvedOptions,
+					calendar: calendar.intlCalendar
+				};
+				const gregorianDate = gregorianCalendar.fromEpochDay(calendar.toEpochDay(date));
+				const nativeDate = new Date(Date.UTC(gregorianDate.year, gregorianDate.month - 1, gregorianDate.day));
+				return new Intl.DateTimeFormat(locale || void 0, formatterOptions).format(nativeDate);
+			} catch (e) {
+				if (e instanceof Error) console.error(`Intl.DateTimeFormat: ${e.message} -> calendar month: ${calendarMonth}`);
+				return fallbackFormatter(calendarMonth);
+			}
+		};
+	}
+	
 	function getMonthNames(type, locale) {
 		const monthFormatter = getMonthFormatter();
 		return [...Array(12).keys()].map((month) => monthFormatter(month, type, locale));
 	}
+	
+	function getCalendarMonthNames(calendar = gregorianCalendar, type = "long", locale, year = 1) {
+		const monthFormatter = getCalendarMonthFormatter(calendar);
+		return [...Array(calendar.monthsInYear(year)).keys()].map((month) => monthFormatter(month + 1, type, locale, year));
+	}
 
 exports.DAYS_IN_MONTH = DAYS_IN_MONTH;
 exports.DAYS_IN_MONTH_LEAP = DAYS_IN_MONTH_LEAP;
@@ -1443,6 +1717,7 @@ exports.compareTimestamps = compareTimestamps;
 exports.copyTimestamp = copyTimestamp;
 exports.createCalendarDayList = createCalendarDayList;
 exports.createCalendarLocaleFormatterUTC = createCalendarLocaleFormatterUTC;
+exports.createCalendarMonthView = createCalendarMonthView;
 exports.createCalendarTimestamp = createCalendarTimestamp;
 exports.createCalendarTimestampFromEpochDay = createCalendarTimestampFromEpochDay;
 exports.createDayList = createDayList;
@@ -1463,13 +1738,21 @@ exports.formatCalendarDate = formatCalendarDate;
 exports.formatDuration = formatDuration;
 exports.fromUnixMilliseconds = fromUnixMilliseconds;
 exports.fromUnixSeconds = fromUnixSeconds;
+exports.getCalendarDateIdentity = getCalendarDateIdentity;
+exports.getCalendarDateState = getCalendarDateState;
 exports.getCalendarDayIdentifier = getCalendarDayIdentifier;
+exports.getCalendarDirection = getCalendarDirection;
 exports.getCalendarEndOfMonth = getCalendarEndOfMonth;
 exports.getCalendarEndOfWeek = getCalendarEndOfWeek;
 exports.getCalendarEndOfYear = getCalendarEndOfYear;
+exports.getCalendarLocale = getCalendarLocale;
+exports.getCalendarMonthFormatter = getCalendarMonthFormatter;
+exports.getCalendarMonthNames = getCalendarMonthNames;
+exports.getCalendarSelectionState = getCalendarSelectionState;
 exports.getCalendarStartOfMonth = getCalendarStartOfMonth;
 exports.getCalendarStartOfWeek = getCalendarStartOfWeek;
 exports.getCalendarStartOfYear = getCalendarStartOfYear;
+exports.getCalendarWeekdays = getCalendarWeekdays;
 exports.getDate = getDate;
 exports.getDateObject = getDateObject;
 exports.getDateTime = getDateTime;
@@ -1496,7 +1779,9 @@ exports.getWorkWeek = getWorkWeek;
 exports.gregorianCalendar = gregorianCalendar;
 exports.intersectRanges = intersectRanges;
 exports.isBetweenDates = isBetweenDates;
+exports.isCalendarRTL = isCalendarRTL;
 exports.isLeapYear = isLeapYear;
+exports.isOutsideCalendarMonth = isOutsideCalendarMonth;
 exports.isOverlappingDates = isOverlappingDates;
 exports.isRangeOverlapping = isRangeOverlapping;
 exports.isTimestampInRange = isTimestampInRange;
@@ -1534,6 +1819,7 @@ exports.toUnixMilliseconds = toUnixMilliseconds;
 exports.toUnixSeconds = toUnixSeconds;
 exports.today = today;
 exports.todayUTC = todayUTC;
+exports.updateCalendarDisabled = updateCalendarDisabled;
 exports.updateCalendarFormatted = updateCalendarFormatted;
 exports.updateCalendarRelative = updateCalendarRelative;
 exports.updateDayOfYear = updateDayOfYear;
@@ -1543,6 +1829,7 @@ exports.updateMinutes = updateMinutes;
 exports.updateRelative = updateRelative;
 exports.updateWeekday = updateWeekday;
 exports.updateWorkWeek = updateWorkWeek;
+exports.validateCalendarTimestamp = validateCalendarTimestamp;
 exports.validateNumber = validateNumber;
 exports.validateTimestamp = validateTimestamp;
 exports.weeksBetween = weeksBetween;