@stridge/noctis-intl 1.0.0-beta.0

package/dist/date/queries.js

@@ -0,0 +1,233 @@
+import { weekStartData } from "./weekStartData.js";
+import { fromAbsolute, toAbsolute, toCalendar, toCalendarDate } from "./conversion.js";
+//#region src/date/queries.ts
+/** Returns whether the given dates occur on the same day, regardless of the time or calendar system. */
+function isSameDay(a, b) {
+	b = toCalendar(b, a.calendar);
+	return a.era === b.era && a.year === b.year && a.month === b.month && a.day === b.day;
+}
+/**
+* Returns whether the given dates occur in the same month, using the calendar system of the first
+* date.
+*/
+function isSameMonth(a, b) {
+	b = toCalendar(b, a.calendar);
+	a = startOfMonth(a);
+	b = startOfMonth(b);
+	return a.era === b.era && a.year === b.year && a.month === b.month;
+}
+/**
+* Returns whether the given dates occur in the same year, using the calendar system of the first
+* date.
+*/
+function isSameYear(a, b) {
+	b = toCalendar(b, a.calendar);
+	a = startOfYear(a);
+	b = startOfYear(b);
+	return a.era === b.era && a.year === b.year;
+}
+/** Returns whether the given dates occur on the same day, and are of the same calendar system. */
+function isEqualDay(a, b) {
+	return isEqualCalendar(a.calendar, b.calendar) && isSameDay(a, b);
+}
+/** Returns whether the given dates occur in the same month, and are of the same calendar system. */
+function isEqualMonth(a, b) {
+	return isEqualCalendar(a.calendar, b.calendar) && isSameMonth(a, b);
+}
+/** Returns whether the given dates occur in the same year, and are of the same calendar system. */
+function isEqualYear(a, b) {
+	return isEqualCalendar(a.calendar, b.calendar) && isSameYear(a, b);
+}
+/** Returns whether two calendars are the same. */
+function isEqualCalendar(a, b) {
+	return a.isEqual?.(b) ?? b.isEqual?.(a) ?? a.identifier === b.identifier;
+}
+/** Returns whether the date is today in the given time zone. */
+function isToday(date, timeZone) {
+	return isSameDay(date, today(timeZone));
+}
+const DAY_MAP = {
+	sun: 0,
+	mon: 1,
+	tue: 2,
+	wed: 3,
+	thu: 4,
+	fri: 5,
+	sat: 6
+};
+/**
+* Returns the day of week for the given date and locale. Days are numbered from zero to six,
+* where zero is the first day of the week in the given locale. For example, in the United States,
+* the first day of the week is Sunday, but in France it is Monday.
+*/
+function getDayOfWeek(date, locale, firstDayOfWeek) {
+	let julian = date.calendar.toJulianDay(date);
+	let weekStart = firstDayOfWeek ? DAY_MAP[firstDayOfWeek] : getWeekStart(locale);
+	let dayOfWeek = Math.ceil(julian + 1 - weekStart) % 7;
+	if (dayOfWeek < 0) dayOfWeek += 7;
+	return dayOfWeek;
+}
+/** Returns the current time in the given time zone. */
+function now(timeZone) {
+	return fromAbsolute(Date.now(), timeZone);
+}
+/** Returns today's date in the given time zone. */
+function today(timeZone) {
+	return toCalendarDate(now(timeZone));
+}
+function compareDate(a, b) {
+	return a.calendar.toJulianDay(a) - b.calendar.toJulianDay(b);
+}
+function compareTime(a, b) {
+	return timeToMs(a) - timeToMs(b);
+}
+function timeToMs(a) {
+	return a.hour * 60 * 60 * 1e3 + a.minute * 60 * 1e3 + a.second * 1e3 + a.millisecond;
+}
+/**
+* Returns the number of hours in the given date and time zone.
+* Usually this is 24, but it could be 23 or 25 if the date is on a daylight saving transition.
+*/
+function getHoursInDay(a, timeZone) {
+	let ms = toAbsolute(a, timeZone);
+	return (toAbsolute(a.add({ days: 1 }), timeZone) - ms) / 36e5;
+}
+let localTimeZone = null;
+let localTimeZoneOverride = false;
+/** Returns the time zone identifier for the current user. */
+function getLocalTimeZone() {
+	if (localTimeZone == null) localTimeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+	return localTimeZone;
+}
+/** Sets the time zone identifier for the current user. */
+function setLocalTimeZone(timeZone) {
+	localTimeZoneOverride = true;
+	localTimeZone = timeZone;
+}
+/** Resets the time zone identifier for the current user. */
+function resetLocalTimeZone() {
+	localTimeZoneOverride = false;
+	localTimeZone = null;
+}
+/** Returns whether the local time zone has been explicitly overridden via `setLocalTimeZone`. */
+function isLocalTimeZoneOverridden() {
+	return localTimeZoneOverride;
+}
+function startOfMonth(date) {
+	return date.subtract({ days: date.day - 1 });
+}
+function endOfMonth(date) {
+	return date.add({ days: date.calendar.getDaysInMonth(date) - date.day });
+}
+function startOfYear(date) {
+	return startOfMonth(date.subtract({ months: date.month - 1 }));
+}
+function endOfYear(date) {
+	return endOfMonth(date.add({ months: date.calendar.getMonthsInYear(date) - date.month }));
+}
+function getMinimumMonthInYear(date) {
+	if (date.calendar.getMinimumMonthInYear) return date.calendar.getMinimumMonthInYear(date);
+	return 1;
+}
+function getMinimumDayInMonth(date) {
+	if (date.calendar.getMinimumDayInMonth) return date.calendar.getMinimumDayInMonth(date);
+	return 1;
+}
+function startOfWeek(date, locale, firstDayOfWeek) {
+	let dayOfWeek = getDayOfWeek(date, locale, firstDayOfWeek);
+	return date.subtract({ days: dayOfWeek });
+}
+function endOfWeek(date, locale, firstDayOfWeek) {
+	return startOfWeek(date, locale, firstDayOfWeek).add({ days: 6 });
+}
+const cachedRegions = /* @__PURE__ */ new Map();
+const cachedWeekInfo = /* @__PURE__ */ new Map();
+function getRegion(locale) {
+	if (Intl.Locale) {
+		let region = cachedRegions.get(locale);
+		if (!region) {
+			region = new Intl.Locale(locale).maximize().region;
+			if (region) cachedRegions.set(locale, region);
+		}
+		return region;
+	}
+	let part = locale.split("-")[1];
+	return part === "u" ? void 0 : part;
+}
+function getWeekStart(locale) {
+	let weekInfo = cachedWeekInfo.get(locale);
+	if (!weekInfo) {
+		if (Intl.Locale) {
+			let localeInst = new Intl.Locale(locale);
+			if ("getWeekInfo" in localeInst) {
+				weekInfo = localeInst.getWeekInfo();
+				if (weekInfo) {
+					cachedWeekInfo.set(locale, weekInfo);
+					return weekInfo.firstDay;
+				}
+			}
+		}
+		let region = getRegion(locale);
+		if (locale.includes("-fw-")) {
+			let day = locale.split("-fw-")[1].split("-")[0];
+			if (day === "mon") weekInfo = { firstDay: 1 };
+			else if (day === "tue") weekInfo = { firstDay: 2 };
+			else if (day === "wed") weekInfo = { firstDay: 3 };
+			else if (day === "thu") weekInfo = { firstDay: 4 };
+			else if (day === "fri") weekInfo = { firstDay: 5 };
+			else if (day === "sat") weekInfo = { firstDay: 6 };
+			else weekInfo = { firstDay: 0 };
+		} else if (locale.includes("-ca-iso8601")) weekInfo = { firstDay: 1 };
+		else weekInfo = { firstDay: region ? weekStartData[region] || 0 : 0 };
+		cachedWeekInfo.set(locale, weekInfo);
+	}
+	return weekInfo.firstDay;
+}
+/** Returns the number of weeks in the given month and locale. */
+function getWeeksInMonth(date, locale, firstDayOfWeek) {
+	let days = date.calendar.getDaysInMonth(date);
+	return Math.ceil((getDayOfWeek(startOfMonth(date), locale, firstDayOfWeek) + days) / 7);
+}
+/** Returns the lesser of the two provider dates. */
+function minDate(a, b) {
+	if (a && b) return a.compare(b) <= 0 ? a : b;
+	return a || b;
+}
+/** Returns the greater of the two provider dates. */
+function maxDate(a, b) {
+	if (a && b) return a.compare(b) >= 0 ? a : b;
+	return a || b;
+}
+const WEEKEND_DATA = {
+	AF: [4, 5],
+	AE: [5, 6],
+	BH: [5, 6],
+	DZ: [5, 6],
+	EG: [5, 6],
+	IL: [5, 6],
+	IQ: [5, 6],
+	IR: [5, 5],
+	JO: [5, 6],
+	KW: [5, 6],
+	LY: [5, 6],
+	OM: [5, 6],
+	QA: [5, 6],
+	SA: [5, 6],
+	SD: [5, 6],
+	SY: [5, 6],
+	YE: [5, 6]
+};
+/** Returns whether the given date is on a weekend in the given locale. */
+function isWeekend(date, locale) {
+	let julian = date.calendar.toJulianDay(date);
+	let dayOfWeek = Math.ceil(julian + 1) % 7;
+	if (dayOfWeek < 0) dayOfWeek += 7;
+	let [start, end] = WEEKEND_DATA[getRegion(locale)] || [6, 0];
+	return dayOfWeek === start || dayOfWeek === end;
+}
+/** Returns whether the given date is on a weekday in the given locale. */
+function isWeekday(date, locale) {
+	return !isWeekend(date, locale);
+}
+//#endregion
+export { compareDate, compareTime, endOfMonth, endOfWeek, endOfYear, getDayOfWeek, getHoursInDay, getLocalTimeZone, getMinimumDayInMonth, getMinimumMonthInYear, getWeeksInMonth, isEqualCalendar, isEqualDay, isEqualMonth, isEqualYear, isLocalTimeZoneOverridden, isSameDay, isSameMonth, isSameYear, isToday, isWeekday, isWeekend, maxDate, minDate, now, resetLocalTimeZone, setLocalTimeZone, startOfMonth, startOfWeek, startOfYear, today };

package/dist/date/string.d.ts

@@ -0,0 +1,36 @@
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+import { DateTimeDuration, Disambiguation } from "./types.js";
+
+//#region src/date/string.d.ts
+/** Parses an ISO 8601 time string. */
+declare function parseTime(value: string): Time;
+/** Parses an ISO 8601 date string, with no time components. */
+declare function parseDate(value: string): CalendarDate;
+/** Parses an ISO 8601 date and time string, with no time zone. */
+declare function parseDateTime(value: string): CalendarDateTime;
+/**
+ * Parses an ISO 8601 date and time string with a time zone extension and optional UTC offset (e.g.
+ * "2021-11-07T00:45[America/Los_Angeles]" or "2021-11-07T00:45-07:00[America/Los_Angeles]").
+ * Ambiguous times due to daylight saving time transitions are resolved according to the
+ * `disambiguation` parameter.
+ */
+declare function parseZonedDateTime(value: string, disambiguation?: Disambiguation): ZonedDateTime;
+/**
+ * Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+ * or "2021-11-07T07:45:00-07:00"). The result is converted to the provided time zone.
+ */
+declare function parseAbsolute(value: string, timeZone: string): ZonedDateTime;
+/**
+ * Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+ * or "2021-11-07T07:45:00-07:00"). The result is converted to the user's local time zone.
+ */
+declare function parseAbsoluteToLocal(value: string): ZonedDateTime;
+/**
+ * Parses an ISO 8601 duration string (e.g. "P3Y6M6W4DT12H30M5S").
+ *
+ * @param value An ISO 8601 duration string.
+ * @returns A DateTimeDuration object.
+ */
+declare function parseDuration(value: string): Required<DateTimeDuration>;
+//#endregion
+export { parseAbsolute, parseAbsoluteToLocal, parseDate, parseDateTime, parseDuration, parseTime, parseZonedDateTime };

package/dist/date/string.js

@@ -0,0 +1,162 @@
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import { getLocalTimeZone } from "./queries.js";
+import { epochFromDate, fromAbsolute, possibleAbsolutes, toAbsolute, toCalendar, toCalendarDateTime, toTimeZone } from "./conversion.js";
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+//#region src/date/string.ts
+const TIME_RE = /^(\d{2})(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
+const DATE_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})$/;
+const DATE_TIME_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
+const ZONED_DATE_TIME_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:([+-]\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?\[(.*?)\]$/;
+const ABSOLUTE_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:(?:([+-]\d{2})(?::?(\d{2}))?)|Z)$/;
+const DATE_TIME_DURATION_RE = /^((?<negative>-)|\+)?P((?<years>\d*)Y)?((?<months>\d*)M)?((?<weeks>\d*)W)?((?<days>\d*)D)?((?<time>T)((?<hours>\d*[.,]?\d{1,9})H)?((?<minutes>\d*[.,]?\d{1,9})M)?((?<seconds>\d*[.,]?\d{1,9})S)?)?$/;
+const requiredDurationTimeGroups = [
+	"hours",
+	"minutes",
+	"seconds"
+];
+const requiredDurationGroups = [
+	"years",
+	"months",
+	"weeks",
+	"days",
+	...requiredDurationTimeGroups
+];
+/** Parses an ISO 8601 time string. */
+function parseTime(value) {
+	let m = value.match(TIME_RE);
+	if (!m) throw new Error("Invalid ISO 8601 time string: " + value);
+	return new Time(parseNumber(m[1], 0, 23), m[2] ? parseNumber(m[2], 0, 59) : 0, m[3] ? parseNumber(m[3], 0, 59) : 0, m[4] ? parseNumber(m[4], 0, Infinity) * 1e3 : 0);
+}
+/** Parses an ISO 8601 date string, with no time components. */
+function parseDate(value) {
+	let m = value.match(DATE_RE);
+	if (!m) {
+		if (ABSOLUTE_RE.test(value)) throw new Error(`Invalid ISO 8601 date string: ${value}. Use parseAbsolute() instead.`);
+		throw new Error("Invalid ISO 8601 date string: " + value);
+	}
+	let date = new CalendarDate(parseNumber(m[1], 0, 9999), parseNumber(m[2], 1, 12), 1);
+	date.day = parseNumber(m[3], 1, date.calendar.getDaysInMonth(date));
+	return date;
+}
+/** Parses an ISO 8601 date and time string, with no time zone. */
+function parseDateTime(value) {
+	let m = value.match(DATE_TIME_RE);
+	if (!m) {
+		if (ABSOLUTE_RE.test(value)) throw new Error(`Invalid ISO 8601 date time string: ${value}. Use parseAbsolute() instead.`);
+		throw new Error("Invalid ISO 8601 date time string: " + value);
+	}
+	let year = parseNumber(m[1], -9999, 9999);
+	let date = new CalendarDateTime(year < 1 ? "BC" : "AD", year < 1 ? -year + 1 : year, parseNumber(m[2], 1, 12), 1, m[4] ? parseNumber(m[4], 0, 23) : 0, m[5] ? parseNumber(m[5], 0, 59) : 0, m[6] ? parseNumber(m[6], 0, 59) : 0, m[7] ? parseNumber(m[7], 0, Infinity) * 1e3 : 0);
+	date.day = parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
+	return date;
+}
+/**
+* Parses an ISO 8601 date and time string with a time zone extension and optional UTC offset (e.g.
+* "2021-11-07T00:45[America/Los_Angeles]" or "2021-11-07T00:45-07:00[America/Los_Angeles]").
+* Ambiguous times due to daylight saving time transitions are resolved according to the
+* `disambiguation` parameter.
+*/
+function parseZonedDateTime(value, disambiguation) {
+	let m = value.match(ZONED_DATE_TIME_RE);
+	if (!m) throw new Error("Invalid ISO 8601 date time string: " + value);
+	let year = parseNumber(m[1], -9999, 9999);
+	let date = new ZonedDateTime(year < 1 ? "BC" : "AD", year < 1 ? -year + 1 : year, parseNumber(m[2], 1, 12), 1, m[11], 0, m[4] ? parseNumber(m[4], 0, 23) : 0, m[5] ? parseNumber(m[5], 0, 59) : 0, m[6] ? parseNumber(m[6], 0, 59) : 0, m[7] ? parseNumber(m[7], 0, Infinity) * 1e3 : 0);
+	date.day = parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
+	let plainDateTime = toCalendarDateTime(date);
+	let ms;
+	if (m[8]) {
+		let hourOffset = parseNumber(m[8], -23, 23);
+		date.offset = Math.sign(hourOffset) * (Math.abs(hourOffset) * 60 * 60 * 1e3 + parseNumber(m[9] ?? "0", 0, 59) * 60 * 1e3 + parseNumber(m[10] ?? "0", 0, 59) * 1e3);
+		ms = epochFromDate(date) - date.offset;
+		if (!possibleAbsolutes(plainDateTime, date.timeZone).includes(ms)) throw new Error(`Offset ${offsetToString(date.offset)} is invalid for ${dateTimeToString(date)} in ${date.timeZone}`);
+	} else ms = toAbsolute(toCalendarDateTime(plainDateTime), date.timeZone, disambiguation);
+	return fromAbsolute(ms, date.timeZone);
+}
+/**
+* Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+* or "2021-11-07T07:45:00-07:00"). The result is converted to the provided time zone.
+*/
+function parseAbsolute(value, timeZone) {
+	let m = value.match(ABSOLUTE_RE);
+	if (!m) throw new Error("Invalid ISO 8601 date time string: " + value);
+	let year = parseNumber(m[1], -9999, 9999);
+	let date = new ZonedDateTime(year < 1 ? "BC" : "AD", year < 1 ? -year + 1 : year, parseNumber(m[2], 1, 12), 1, timeZone, 0, m[4] ? parseNumber(m[4], 0, 23) : 0, m[5] ? parseNumber(m[5], 0, 59) : 0, m[6] ? parseNumber(m[6], 0, 59) : 0, m[7] ? parseNumber(m[7], 0, Infinity) * 1e3 : 0);
+	date.day = parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
+	if (m[8]) date.offset = parseNumber(m[8], -23, 23) * 60 * 60 * 1e3 + parseNumber(m[9] ?? "0", 0, 59) * 60 * 1e3;
+	return toTimeZone(date, timeZone);
+}
+/**
+* Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+* or "2021-11-07T07:45:00-07:00"). The result is converted to the user's local time zone.
+*/
+function parseAbsoluteToLocal(value) {
+	return parseAbsolute(value, getLocalTimeZone());
+}
+function parseNumber(value, min, max) {
+	let val = Number(value);
+	if (val < min || val > max) throw new RangeError(`Value out of range: ${min} <= ${val} <= ${max}`);
+	return val;
+}
+function timeToString(time) {
+	return `${String(time.hour).padStart(2, "0")}:${String(time.minute).padStart(2, "0")}:${String(time.second).padStart(2, "0")}${time.millisecond ? String(time.millisecond / 1e3).slice(1) : ""}`;
+}
+function dateToString(date) {
+	let gregorianDate = toCalendar(date, new GregorianCalendar());
+	let year;
+	if (gregorianDate.era === "BC") year = gregorianDate.year === 1 ? "0000" : "-" + String(Math.abs(1 - gregorianDate.year)).padStart(6, "00");
+	else year = String(gregorianDate.year).padStart(4, "0");
+	return `${year}-${String(gregorianDate.month).padStart(2, "0")}-${String(gregorianDate.day).padStart(2, "0")}`;
+}
+function dateTimeToString(date) {
+	return `${dateToString(date)}T${timeToString(date)}`;
+}
+function offsetToString(offset) {
+	let sign = Math.sign(offset) < 0 ? "-" : "+";
+	offset = Math.abs(offset);
+	let offsetHours = Math.floor(offset / (3600 * 1e3));
+	let offsetMinutes = Math.floor(offset % (3600 * 1e3) / (60 * 1e3));
+	let offsetSeconds = Math.floor(offset % (3600 * 1e3) % (60 * 1e3) / 1e3);
+	let stringOffset = `${sign}${String(offsetHours).padStart(2, "0")}:${String(offsetMinutes).padStart(2, "0")}`;
+	if (offsetSeconds !== 0) stringOffset += `:${String(offsetSeconds).padStart(2, "0")}`;
+	return stringOffset;
+}
+function zonedDateTimeToString(date) {
+	return `${dateTimeToString(date)}${offsetToString(date.offset)}[${date.timeZone}]`;
+}
+/**
+* Parses an ISO 8601 duration string (e.g. "P3Y6M6W4DT12H30M5S").
+*
+* @param value An ISO 8601 duration string.
+* @returns A DateTimeDuration object.
+*/
+function parseDuration(value) {
+	const match = value.match(DATE_TIME_DURATION_RE);
+	if (!match) throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+	const parseDurationGroup = (group, isNegative) => {
+		if (!group) return 0;
+		try {
+			return (isNegative ? -1 : 1) * Number(group.replace(",", "."));
+		} catch {
+			throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+		}
+	};
+	const isNegative = !!match.groups?.negative;
+	if (!requiredDurationGroups.some((group) => match.groups?.[group])) throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+	if (match.groups?.time) {
+		if (!requiredDurationTimeGroups.some((group) => match.groups?.[group])) throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+	}
+	const duration = {
+		years: parseDurationGroup(match.groups?.years, isNegative),
+		months: parseDurationGroup(match.groups?.months, isNegative),
+		weeks: parseDurationGroup(match.groups?.weeks, isNegative),
+		days: parseDurationGroup(match.groups?.days, isNegative),
+		hours: parseDurationGroup(match.groups?.hours, isNegative),
+		minutes: parseDurationGroup(match.groups?.minutes, isNegative),
+		seconds: parseDurationGroup(match.groups?.seconds, isNegative)
+	};
+	if (duration.hours !== void 0 && duration.hours % 1 !== 0 && (duration.minutes || duration.seconds)) throw new Error(`Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`);
+	if (duration.minutes !== void 0 && duration.minutes % 1 !== 0 && duration.seconds) throw new Error(`Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`);
+	return duration;
+}
+//#endregion
+export { dateTimeToString, dateToString, parseAbsolute, parseAbsoluteToLocal, parseDate, parseDateTime, parseDuration, parseTime, parseZonedDateTime, timeToString, zonedDateTimeToString };

package/dist/date/types.d.ts

@@ -0,0 +1,138 @@
+import { CalendarDate } from "./CalendarDate.js";
+
+//#region src/date/types.d.ts
+/** An interface that is compatible with any object with date fields. */
+interface AnyCalendarDate {
+  readonly calendar: Calendar;
+  readonly era: string;
+  readonly year: number;
+  readonly month: number;
+  readonly day: number;
+  copy(): this;
+}
+/** An interface that is compatible with any object with time fields. */
+interface AnyTime {
+  readonly hour: number;
+  readonly minute: number;
+  readonly second: number;
+  readonly millisecond: number;
+  copy(): this;
+}
+/** An interface that is compatible with any object with both date and time fields. */
+interface AnyDateTime extends AnyCalendarDate, AnyTime {}
+type CalendarIdentifier = "gregory" | "buddhist" | "chinese" | "coptic" | "dangi" | "ethioaa" | "ethiopic" | "hebrew" | "indian" | "islamic" | "islamic-umalqura" | "islamic-tbla" | "islamic-civil" | "islamic-rgsa" | "iso8601" | "japanese" | "persian" | "roc";
+/**
+ * The Calendar interface represents a calendar system, including information
+ * about how days, months, years, and eras are organized, and methods to perform
+ * arithmetic on dates.
+ */
+interface Calendar {
+  /**
+   * A string identifier for the calendar, as defined by Unicode CLDR. See
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf#supported_calendar_types).
+   */
+  identifier: CalendarIdentifier;
+  /** Creates a CalendarDate in this calendar from the given Julian day number. */
+  fromJulianDay(jd: number): CalendarDate;
+  /** Converts a date in this calendar to a Julian day number. */
+  toJulianDay(date: AnyCalendarDate): number;
+  /** Returns the number of days in the month of the given date. */
+  getDaysInMonth(date: AnyCalendarDate): number;
+  /** Returns the number of months in the year of the given date. */
+  getMonthsInYear(date: AnyCalendarDate): number;
+  /** Returns the number of years in the era of the given date. */
+  getYearsInEra(date: AnyCalendarDate): number;
+  /** Returns a list of era identifiers for the calendar. */
+  getEras(): string[];
+  /**
+   * Returns the minimum month number of the given date's year.
+   * Normally, this is 1, but in some calendars such as the Japanese,
+   * eras may begin in the middle of a year.
+   */
+  getMinimumMonthInYear?(date: AnyCalendarDate): number;
+  /**
+   * Returns the minimum day number of the given date's month.
+   * Normally, this is 1, but in some calendars such as the Japanese,
+   * eras may begin in the middle of a month.
+   */
+  getMinimumDayInMonth?(date: AnyCalendarDate): number;
+  /** Returns the maximum months across all years. */
+  getMaximumMonthsInYear(): number;
+  /** Returns the maximum days across all months. */
+  getMaximumDaysInMonth(): number;
+  /**
+   * Returns a date that is the first day of the month for the given date.
+   * This is used to determine the month that the given date falls in, if
+   * the calendar has months that do not align with the standard calendar months
+   * (e.g. fiscal calendars).
+   */
+  getFormattableMonth?(date: AnyCalendarDate): CalendarDate;
+  /** Returns whether the given calendar is the same as this calendar. */
+  isEqual?(calendar: Calendar): boolean;
+  /** @private */
+  balanceDate?(date: AnyCalendarDate): void;
+  /** @private */
+  balanceYearMonth?(date: AnyCalendarDate, previousDate: AnyCalendarDate): void;
+  /** @private */
+  constrainDate?(date: AnyCalendarDate): void;
+  /** @private */
+  isInverseEra?(date: AnyCalendarDate): boolean;
+}
+/** Represents an amount of time in calendar-specific units, for use when performing arithmetic. */
+interface DateDuration {
+  /** The number of years to add or subtract. */
+  years?: number;
+  /** The number of months to add or subtract. */
+  months?: number;
+  /** The number of weeks to add or subtract. */
+  weeks?: number;
+  /** The number of days to add or subtract. */
+  days?: number;
+}
+/** Represents an amount of time, for use whe performing arithmetic. */
+interface TimeDuration {
+  /** The number of hours to add or subtract. */
+  hours?: number;
+  /** The number of minutes to add or subtract. */
+  minutes?: number;
+  /** The number of seconds to add or subtract. */
+  seconds?: number;
+  /** The number of milliseconds to add or subtract. */
+  milliseconds?: number;
+}
+/**
+ * Represents an amount of time with both date and time components, for use when performing
+ * arithmetic.
+ */
+interface DateTimeDuration extends DateDuration, TimeDuration {}
+interface DateFields {
+  era?: string;
+  year?: number;
+  month?: number;
+  day?: number;
+}
+interface TimeFields {
+  hour?: number;
+  minute?: number;
+  second?: number;
+  millisecond?: number;
+}
+type DateField = keyof DateFields;
+type TimeField = keyof TimeFields;
+type Disambiguation = "compatible" | "earlier" | "later" | "reject";
+interface CycleOptions {
+  /** Whether to round the field value to the nearest interval of the amount. */
+  round?: boolean;
+}
+interface CycleTimeOptions extends CycleOptions {
+  /**
+   * Whether to use 12 or 24 hour time. If 12 hour time is chosen, the resulting value
+   * will remain in the same day period as the original value (e.g. if the value is AM,
+   * the resulting value also be AM).
+   *
+   * @default 24
+   */
+  hourCycle?: 12 | 24;
+}
+//#endregion
+export { AnyCalendarDate, AnyDateTime, AnyTime, Calendar, CalendarIdentifier, CycleOptions, CycleTimeOptions, DateDuration, DateField, DateFields, DateTimeDuration, Disambiguation, TimeDuration, TimeField, TimeFields };

package/dist/date/utils.d.ts

@@ -0,0 +1,4 @@
+//#region src/date/utils.d.ts
+type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+//#endregion
+export { Mutable };

package/dist/date/utils.js

@@ -0,0 +1,6 @@
+//#region src/date/utils.ts
+function mod(amount, numerator) {
+	return amount - numerator * Math.floor(amount / numerator);
+}
+//#endregion
+export { mod };

package/dist/date/weekStartData.js

@@ -0,0 +1,100 @@
+//#region src/date/weekStartData.ts
+const weekStartData = {
+	"001": 1,
+	AD: 1,
+	AE: 6,
+	AF: 6,
+	AI: 1,
+	AL: 1,
+	AM: 1,
+	AN: 1,
+	AR: 1,
+	AT: 1,
+	AU: 1,
+	AX: 1,
+	AZ: 1,
+	BA: 1,
+	BE: 1,
+	BG: 1,
+	BH: 6,
+	BM: 1,
+	BN: 1,
+	BY: 1,
+	CH: 1,
+	CL: 1,
+	CM: 1,
+	CN: 1,
+	CR: 1,
+	CY: 1,
+	CZ: 1,
+	DE: 1,
+	DJ: 6,
+	DK: 1,
+	DZ: 6,
+	EC: 1,
+	EE: 1,
+	EG: 6,
+	ES: 1,
+	FI: 1,
+	FJ: 1,
+	FO: 1,
+	FR: 1,
+	GB: 1,
+	GE: 1,
+	GF: 1,
+	GP: 1,
+	GR: 1,
+	HR: 1,
+	HU: 1,
+	IE: 1,
+	IQ: 6,
+	IR: 6,
+	IS: 1,
+	IT: 1,
+	JO: 6,
+	KG: 1,
+	KW: 6,
+	KZ: 1,
+	LB: 1,
+	LI: 1,
+	LK: 1,
+	LT: 1,
+	LU: 1,
+	LV: 1,
+	LY: 6,
+	MC: 1,
+	MD: 1,
+	ME: 1,
+	MK: 1,
+	MN: 1,
+	MQ: 1,
+	MV: 5,
+	MY: 1,
+	NL: 1,
+	NO: 1,
+	NZ: 1,
+	OM: 6,
+	PL: 1,
+	QA: 6,
+	RE: 1,
+	RO: 1,
+	RS: 1,
+	RU: 1,
+	SD: 6,
+	SE: 1,
+	SI: 1,
+	SK: 1,
+	SM: 1,
+	SY: 6,
+	TJ: 1,
+	TM: 1,
+	TR: 1,
+	UA: 1,
+	UY: 1,
+	UZ: 1,
+	VA: 1,
+	VN: 1,
+	XK: 1
+};
+//#endregion
+export { weekStartData };