@stridge/noctis-intl 1.0.0-beta.0

package/dist/date/conversion.js

@@ -0,0 +1,181 @@
+import { GregorianCalendar, getExtendedYear } from "./calendars/GregorianCalendar.js";
+import { constrain } from "./manipulation.js";
+import { getLocalTimeZone, isEqualCalendar, isLocalTimeZoneOverridden } from "./queries.js";
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+//#region src/date/conversion.ts
+function epochFromDate(date) {
+	date = toCalendar(date, new GregorianCalendar());
+	return epochFromParts(getExtendedYear(date.era, date.year), date.month, date.day, date.hour, date.minute, date.second, date.millisecond);
+}
+function epochFromParts(year, month, day, hour, minute, second, millisecond) {
+	let date = /* @__PURE__ */ new Date();
+	date.setUTCHours(hour, minute, second, millisecond);
+	date.setUTCFullYear(year, month - 1, day);
+	return date.getTime();
+}
+function getTimeZoneOffset(ms, timeZone) {
+	if (timeZone === "UTC") return 0;
+	if (ms > 0 && timeZone === getLocalTimeZone() && !isLocalTimeZoneOverridden()) return new Date(ms).getTimezoneOffset() * -60 * 1e3;
+	let { year, month, day, hour, minute, second } = getTimeZoneParts(ms, timeZone);
+	return epochFromParts(year, month, day, hour, minute, second, 0) - Math.floor(ms / 1e3) * 1e3;
+}
+const formattersByTimeZone = /* @__PURE__ */ new Map();
+function getTimeZoneParts(ms, timeZone) {
+	let formatter = formattersByTimeZone.get(timeZone);
+	if (!formatter) {
+		formatter = new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			hour12: false,
+			era: "short",
+			year: "numeric",
+			month: "numeric",
+			day: "numeric",
+			hour: "numeric",
+			minute: "numeric",
+			second: "numeric"
+		});
+		formattersByTimeZone.set(timeZone, formatter);
+	}
+	let parts = formatter.formatToParts(new Date(ms));
+	let namedParts = {};
+	for (let part of parts) if (part.type !== "literal") namedParts[part.type] = part.value;
+	return {
+		year: namedParts.era === "BC" || namedParts.era === "B" ? -namedParts.year + 1 : +namedParts.year,
+		month: +namedParts.month,
+		day: +namedParts.day,
+		hour: namedParts.hour === "24" ? 0 : +namedParts.hour,
+		minute: +namedParts.minute,
+		second: +namedParts.second
+	};
+}
+const DAYMILLIS = 864e5;
+function possibleAbsolutes(date, timeZone) {
+	let ms = epochFromDate(date);
+	return getValidWallTimes(date, timeZone, ms - getTimeZoneOffset(ms - DAYMILLIS, timeZone), ms - getTimeZoneOffset(ms + DAYMILLIS, timeZone));
+}
+function getValidWallTimes(date, timeZone, earlier, later) {
+	return (earlier === later ? [earlier] : [earlier, later]).filter((absolute) => isValidWallTime(date, timeZone, absolute));
+}
+function isValidWallTime(date, timeZone, absolute) {
+	let parts = getTimeZoneParts(absolute, timeZone);
+	return date.year === parts.year && date.month === parts.month && date.day === parts.day && date.hour === parts.hour && date.minute === parts.minute && date.second === parts.second;
+}
+function toAbsolute(date, timeZone, disambiguation = "compatible") {
+	let dateTime = toCalendarDateTime(date);
+	if (timeZone === "UTC") return epochFromDate(dateTime);
+	if (timeZone === getLocalTimeZone() && disambiguation === "compatible" && !isLocalTimeZoneOverridden()) {
+		dateTime = toCalendar(dateTime, new GregorianCalendar());
+		let date = /* @__PURE__ */ new Date();
+		let year = getExtendedYear(dateTime.era, dateTime.year);
+		date.setFullYear(year, dateTime.month - 1, dateTime.day);
+		date.setHours(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+		return date.getTime();
+	}
+	let ms = epochFromDate(dateTime);
+	let offsetBefore = getTimeZoneOffset(ms - DAYMILLIS, timeZone);
+	let offsetAfter = getTimeZoneOffset(ms + DAYMILLIS, timeZone);
+	let valid = getValidWallTimes(dateTime, timeZone, ms - offsetBefore, ms - offsetAfter);
+	if (valid.length === 1) return valid[0];
+	if (valid.length > 1) switch (disambiguation) {
+		case "compatible":
+		case "earlier": return valid[0];
+		case "later": return valid[valid.length - 1];
+		case "reject": throw new RangeError("Multiple possible absolute times found");
+	}
+	switch (disambiguation) {
+		case "earlier": return Math.min(ms - offsetBefore, ms - offsetAfter);
+		case "compatible":
+		case "later": return Math.max(ms - offsetBefore, ms - offsetAfter);
+		case "reject": throw new RangeError("No such absolute time found");
+	}
+}
+function toDate(dateTime, timeZone, disambiguation = "compatible") {
+	return new Date(toAbsolute(dateTime, timeZone, disambiguation));
+}
+/**
+* Takes a Unix epoch (milliseconds since 1970) and converts it to the provided time zone.
+*/
+function fromAbsolute(ms, timeZone) {
+	let offset = getTimeZoneOffset(ms, timeZone);
+	let date = new Date(ms + offset);
+	let year = date.getUTCFullYear();
+	let month = date.getUTCMonth() + 1;
+	let day = date.getUTCDate();
+	let hour = date.getUTCHours();
+	let minute = date.getUTCMinutes();
+	let second = date.getUTCSeconds();
+	let millisecond = date.getUTCMilliseconds();
+	return new ZonedDateTime(year < 1 ? "BC" : "AD", year < 1 ? -year + 1 : year, month, day, timeZone, offset, hour, minute, second, millisecond);
+}
+/**
+* Takes a `Date` object and converts it to the provided time zone.
+*/
+function fromDate(date, timeZone) {
+	return fromAbsolute(date.getTime(), timeZone);
+}
+/**
+* Takes a `Date` object and converts it to the time zone identifier for the current user.
+*/
+function fromDateToLocal(date) {
+	return fromDate(date, getLocalTimeZone());
+}
+/**
+* Converts a value with date components such as a `CalendarDateTime` or `ZonedDateTime` into a
+* `CalendarDate`.
+*/
+function toCalendarDate(dateTime) {
+	return new CalendarDate(dateTime.calendar, dateTime.era, dateTime.year, dateTime.month, dateTime.day);
+}
+/**
+* Converts a date value to a `CalendarDateTime`. An optional `Time` value can be passed to set the
+* time of the resulting value, otherwise it will default to midnight.
+*/
+function toCalendarDateTime(date, time) {
+	let hour = 0, minute = 0, second = 0, millisecond = 0;
+	if ("timeZone" in date) ({hour, minute, second, millisecond} = date);
+	else if ("hour" in date && !time) return date;
+	if (time) ({hour, minute, second, millisecond} = time);
+	return new CalendarDateTime(date.calendar, date.era, date.year, date.month, date.day, hour, minute, second, millisecond);
+}
+/** Extracts the time components from a value containing a date and time. */
+function toTime(dateTime) {
+	return new Time(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+}
+/** Converts a date from one calendar system to another. */
+function toCalendar(date, calendar) {
+	if (isEqualCalendar(date.calendar, calendar)) return date;
+	let calendarDate = calendar.fromJulianDay(date.calendar.toJulianDay(date));
+	let copy = date.copy();
+	copy.calendar = calendar;
+	copy.era = calendarDate.era;
+	copy.year = calendarDate.year;
+	copy.month = calendarDate.month;
+	copy.day = calendarDate.day;
+	constrain(copy);
+	return copy;
+}
+/**
+* Converts a date value to a `ZonedDateTime` in the provided time zone. The `disambiguation` option
+* can be set to control how values that fall on daylight saving time changes are interpreted.
+*/
+function toZoned(date, timeZone, disambiguation) {
+	if (date instanceof ZonedDateTime) {
+		if (date.timeZone === timeZone) return date;
+		return toTimeZone(date, timeZone);
+	}
+	return fromAbsolute(toAbsolute(date, timeZone, disambiguation), timeZone);
+}
+function zonedToDate(date) {
+	let ms = epochFromDate(date) - date.offset;
+	return new Date(ms);
+}
+/** Converts a `ZonedDateTime` from one time zone to another. */
+function toTimeZone(date, timeZone) {
+	return toCalendar(fromAbsolute(epochFromDate(date) - date.offset, timeZone), date.calendar);
+}
+/** Converts the given `ZonedDateTime` into the user's local time zone. */
+function toLocalTimeZone(date) {
+	return toTimeZone(date, getLocalTimeZone());
+}
+//#endregion
+export { epochFromDate, fromAbsolute, fromDate, fromDateToLocal, possibleAbsolutes, toAbsolute, toCalendar, toCalendarDate, toCalendarDateTime, toDate, toLocalTimeZone, toTime, toTimeZone, toZoned, zonedToDate };

package/dist/date/createCalendar.d.ts

@@ -0,0 +1,7 @@
+import { Calendar, CalendarIdentifier } from "./types.js";
+
+//#region src/date/createCalendar.d.ts
+/** Creates a `Calendar` instance from a Unicode calendar identifier string. */
+declare function createCalendar(name: CalendarIdentifier): Calendar;
+//#endregion
+export { createCalendar };

package/dist/date/createCalendar.js

@@ -0,0 +1,30 @@
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import { JapaneseCalendar } from "./calendars/JapaneseCalendar.js";
+import { BuddhistCalendar } from "./calendars/BuddhistCalendar.js";
+import { TaiwanCalendar } from "./calendars/TaiwanCalendar.js";
+import { PersianCalendar } from "./calendars/PersianCalendar.js";
+import { IndianCalendar } from "./calendars/IndianCalendar.js";
+import { IslamicCivilCalendar, IslamicTabularCalendar, IslamicUmalquraCalendar } from "./calendars/IslamicCalendar.js";
+import { HebrewCalendar } from "./calendars/HebrewCalendar.js";
+import { CopticCalendar, EthiopicAmeteAlemCalendar, EthiopicCalendar } from "./calendars/EthiopicCalendar.js";
+//#region src/date/createCalendar.ts
+/** Creates a `Calendar` instance from a Unicode calendar identifier string. */
+function createCalendar(name) {
+	switch (name) {
+		case "buddhist": return new BuddhistCalendar();
+		case "ethiopic": return new EthiopicCalendar();
+		case "ethioaa": return new EthiopicAmeteAlemCalendar();
+		case "coptic": return new CopticCalendar();
+		case "hebrew": return new HebrewCalendar();
+		case "indian": return new IndianCalendar();
+		case "islamic-civil": return new IslamicCivilCalendar();
+		case "islamic-tbla": return new IslamicTabularCalendar();
+		case "islamic-umalqura": return new IslamicUmalquraCalendar();
+		case "japanese": return new JapaneseCalendar();
+		case "persian": return new PersianCalendar();
+		case "roc": return new TaiwanCalendar();
+		default: return new GregorianCalendar();
+	}
+}
+//#endregion
+export { createCalendar };

package/dist/date/manipulation.js

@@ -0,0 +1,274 @@
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import { epochFromDate, fromAbsolute, toAbsolute, toCalendar, toCalendarDateTime } from "./conversion.js";
+//#region src/date/manipulation.ts
+const ONE_HOUR = 36e5;
+function add(date, duration) {
+	let mutableDate = date.copy();
+	let days = "hour" in mutableDate ? addTimeFields(mutableDate, duration) : 0;
+	addYears(mutableDate, duration.years || 0);
+	if (mutableDate.calendar.balanceYearMonth) mutableDate.calendar.balanceYearMonth(mutableDate, date);
+	mutableDate.month += duration.months || 0;
+	balanceYearMonth(mutableDate);
+	constrainMonthDay(mutableDate);
+	mutableDate.day += (duration.weeks || 0) * 7;
+	mutableDate.day += duration.days || 0;
+	mutableDate.day += days;
+	balanceDay(mutableDate);
+	if (mutableDate.calendar.balanceDate) mutableDate.calendar.balanceDate(mutableDate);
+	if (mutableDate.year < 1) {
+		mutableDate.year = 1;
+		mutableDate.month = 1;
+		mutableDate.day = 1;
+	}
+	let maxYear = mutableDate.calendar.getYearsInEra(mutableDate);
+	if (mutableDate.year > maxYear) {
+		let isInverseEra = mutableDate.calendar.isInverseEra?.(mutableDate);
+		mutableDate.year = maxYear;
+		mutableDate.month = isInverseEra ? 1 : mutableDate.calendar.getMonthsInYear(mutableDate);
+		mutableDate.day = isInverseEra ? 1 : mutableDate.calendar.getDaysInMonth(mutableDate);
+	}
+	if (mutableDate.month < 1) {
+		mutableDate.month = 1;
+		mutableDate.day = 1;
+	}
+	let maxMonth = mutableDate.calendar.getMonthsInYear(mutableDate);
+	if (mutableDate.month > maxMonth) {
+		mutableDate.month = maxMonth;
+		mutableDate.day = mutableDate.calendar.getDaysInMonth(mutableDate);
+	}
+	mutableDate.day = Math.max(1, Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day));
+	return mutableDate;
+}
+function addYears(date, years) {
+	if (date.calendar.isInverseEra?.(date)) years = -years;
+	date.year += years;
+}
+function balanceYearMonth(date) {
+	while (date.month < 1) {
+		addYears(date, -1);
+		date.month += date.calendar.getMonthsInYear(date);
+	}
+	let monthsInYear = 0;
+	while (date.month > (monthsInYear = date.calendar.getMonthsInYear(date))) {
+		date.month -= monthsInYear;
+		addYears(date, 1);
+	}
+}
+function balanceDay(date) {
+	while (date.day < 1) {
+		date.month--;
+		balanceYearMonth(date);
+		date.day += date.calendar.getDaysInMonth(date);
+	}
+	while (date.day > date.calendar.getDaysInMonth(date)) {
+		date.day -= date.calendar.getDaysInMonth(date);
+		date.month++;
+		balanceYearMonth(date);
+	}
+}
+function constrainMonthDay(date) {
+	date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
+	date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+}
+function constrain(date) {
+	if (date.calendar.constrainDate) date.calendar.constrainDate(date);
+	date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
+	constrainMonthDay(date);
+}
+function invertDuration(duration) {
+	let inverseDuration = {};
+	for (let key in duration) {
+		let k = key;
+		let value = duration[k];
+		if (typeof value === "number") inverseDuration[k] = -value;
+	}
+	return inverseDuration;
+}
+function subtract(date, duration) {
+	return add(date, invertDuration(duration));
+}
+function set(date, fields) {
+	let mutableDate = date.copy();
+	if (fields.era != null) mutableDate.era = fields.era;
+	if (fields.year != null) mutableDate.year = fields.year;
+	if (fields.month != null) mutableDate.month = fields.month;
+	if (fields.day != null) mutableDate.day = fields.day;
+	constrain(mutableDate);
+	return mutableDate;
+}
+function setTime(value, fields) {
+	let mutableValue = value.copy();
+	if (fields.hour != null) mutableValue.hour = fields.hour;
+	if (fields.minute != null) mutableValue.minute = fields.minute;
+	if (fields.second != null) mutableValue.second = fields.second;
+	if (fields.millisecond != null) mutableValue.millisecond = fields.millisecond;
+	constrainTime(mutableValue);
+	return mutableValue;
+}
+function balanceTime(time) {
+	time.second += Math.floor(time.millisecond / 1e3);
+	time.millisecond = nonNegativeMod(time.millisecond, 1e3);
+	time.minute += Math.floor(time.second / 60);
+	time.second = nonNegativeMod(time.second, 60);
+	time.hour += Math.floor(time.minute / 60);
+	time.minute = nonNegativeMod(time.minute, 60);
+	let days = Math.floor(time.hour / 24);
+	time.hour = nonNegativeMod(time.hour, 24);
+	return days;
+}
+function constrainTime(time) {
+	time.millisecond = Math.max(0, Math.min(time.millisecond, 1e3));
+	time.second = Math.max(0, Math.min(time.second, 59));
+	time.minute = Math.max(0, Math.min(time.minute, 59));
+	time.hour = Math.max(0, Math.min(time.hour, 23));
+}
+function nonNegativeMod(a, b) {
+	let result = a % b;
+	if (result < 0) result += b;
+	return result;
+}
+function addTimeFields(time, duration) {
+	time.hour += duration.hours || 0;
+	time.minute += duration.minutes || 0;
+	time.second += duration.seconds || 0;
+	time.millisecond += duration.milliseconds || 0;
+	return balanceTime(time);
+}
+function addTime(time, duration) {
+	let res = time.copy();
+	addTimeFields(res, duration);
+	return res;
+}
+function subtractTime(time, duration) {
+	return addTime(time, invertDuration(duration));
+}
+function cycleDate(value, field, amount, options) {
+	let mutable = value.copy();
+	switch (field) {
+		case "era": {
+			let eras = value.calendar.getEras();
+			let eraIndex = eras.indexOf(value.era);
+			if (eraIndex < 0) throw new Error("Invalid era: " + value.era);
+			eraIndex = cycleValue(eraIndex, amount, 0, eras.length - 1, options?.round);
+			mutable.era = eras[eraIndex];
+			constrain(mutable);
+			break;
+		}
+		case "year":
+			if (mutable.calendar.isInverseEra?.(mutable)) amount = -amount;
+			mutable.year = cycleValue(value.year, amount, -Infinity, 9999, options?.round);
+			if (mutable.year === -Infinity) mutable.year = 1;
+			if (mutable.calendar.balanceYearMonth) mutable.calendar.balanceYearMonth(mutable, value);
+			break;
+		case "month":
+			mutable.month = cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options?.round);
+			break;
+		case "day":
+			mutable.day = cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options?.round);
+			break;
+		default: throw new Error("Unsupported field " + field);
+	}
+	if (value.calendar.balanceDate) value.calendar.balanceDate(mutable);
+	constrain(mutable);
+	return mutable;
+}
+function cycleTime(value, field, amount, options) {
+	let mutable = value.copy();
+	switch (field) {
+		case "hour": {
+			let hours = value.hour;
+			let min = 0;
+			let max = 23;
+			if (options?.hourCycle === 12) {
+				let isPM = hours >= 12;
+				min = isPM ? 12 : 0;
+				max = isPM ? 23 : 11;
+			}
+			mutable.hour = cycleValue(hours, amount, min, max, options?.round);
+			break;
+		}
+		case "minute":
+			mutable.minute = cycleValue(value.minute, amount, 0, 59, options?.round);
+			break;
+		case "second":
+			mutable.second = cycleValue(value.second, amount, 0, 59, options?.round);
+			break;
+		case "millisecond":
+			mutable.millisecond = cycleValue(value.millisecond, amount, 0, 999, options?.round);
+			break;
+		default: throw new Error("Unsupported field " + field);
+	}
+	return mutable;
+}
+function cycleValue(value, amount, min, max, round = false) {
+	if (round) {
+		value += Math.sign(amount);
+		if (value < min) value = max;
+		let div = Math.abs(amount);
+		if (amount > 0) value = Math.ceil(value / div) * div;
+		else value = Math.floor(value / div) * div;
+		if (value > max) value = min;
+	} else {
+		value += amount;
+		if (value < min) value = max - (min - value - 1);
+		else if (value > max) value = min + (value - max - 1);
+	}
+	return value;
+}
+function addZoned(dateTime, duration) {
+	let ms;
+	if (duration.years != null && duration.years !== 0 || duration.months != null && duration.months !== 0 || duration.weeks != null && duration.weeks !== 0 || duration.days != null && duration.days !== 0) ms = toAbsolute(add(toCalendarDateTime(dateTime), {
+		years: duration.years,
+		months: duration.months,
+		weeks: duration.weeks,
+		days: duration.days
+	}), dateTime.timeZone);
+	else ms = epochFromDate(dateTime) - dateTime.offset;
+	ms += duration.milliseconds || 0;
+	ms += (duration.seconds || 0) * 1e3;
+	ms += (duration.minutes || 0) * 60 * 1e3;
+	ms += (duration.hours || 0) * 60 * 60 * 1e3;
+	return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+}
+function subtractZoned(dateTime, duration) {
+	return addZoned(dateTime, invertDuration(duration));
+}
+function cycleZoned(dateTime, field, amount, options) {
+	switch (field) {
+		case "hour": {
+			let min = 0;
+			let max = 23;
+			if (options?.hourCycle === 12) {
+				let isPM = dateTime.hour >= 12;
+				min = isPM ? 12 : 0;
+				max = isPM ? 23 : 11;
+			}
+			let plainDateTime = toCalendarDateTime(dateTime);
+			let minDate = toCalendar(setTime(plainDateTime, { hour: min }), new GregorianCalendar());
+			let minAbsolute = [toAbsolute(minDate, dateTime.timeZone, "earlier"), toAbsolute(minDate, dateTime.timeZone, "later")].filter((ms) => fromAbsolute(ms, dateTime.timeZone).day === minDate.day)[0];
+			let maxDate = toCalendar(setTime(plainDateTime, { hour: max }), new GregorianCalendar());
+			let maxAbsolute = [toAbsolute(maxDate, dateTime.timeZone, "earlier"), toAbsolute(maxDate, dateTime.timeZone, "later")].filter((ms) => fromAbsolute(ms, dateTime.timeZone).day === maxDate.day).pop();
+			let ms = epochFromDate(dateTime) - dateTime.offset;
+			let hours = Math.floor(ms / ONE_HOUR);
+			let remainder = ms % ONE_HOUR;
+			ms = cycleValue(hours, amount, Math.floor(minAbsolute / ONE_HOUR), Math.floor(maxAbsolute / ONE_HOUR), options?.round) * ONE_HOUR + remainder;
+			return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+		}
+		case "minute":
+		case "second":
+		case "millisecond": return cycleTime(dateTime, field, amount, options);
+		case "era":
+		case "year":
+		case "month":
+		case "day": return toCalendar(fromAbsolute(toAbsolute(cycleDate(toCalendarDateTime(dateTime), field, amount, options), dateTime.timeZone), dateTime.timeZone), dateTime.calendar);
+		default: throw new Error("Unsupported field " + field);
+	}
+}
+function setZoned(dateTime, fields, disambiguation) {
+	let plainDateTime = toCalendarDateTime(dateTime);
+	let res = setTime(set(plainDateTime, fields), fields);
+	if (res.compare(plainDateTime) === 0) return dateTime;
+	return toCalendar(fromAbsolute(toAbsolute(res, dateTime.timeZone, disambiguation), dateTime.timeZone), dateTime.calendar);
+}
+//#endregion
+export { add, addTime, addZoned, constrain, constrainTime, cycleDate, cycleTime, cycleZoned, set, setTime, setZoned, subtract, subtractTime, subtractZoned };

package/dist/date/queries.d.ts

@@ -0,0 +1,92 @@
+import { CalendarDate, CalendarDateTime, DateValue, ZonedDateTime } from "./CalendarDate.js";
+import { AnyCalendarDate, Calendar } from "./types.js";
+
+//#region src/date/queries.d.ts
+/** Returns whether the given dates occur on the same day, regardless of the time or calendar system. */
+declare function isSameDay(a: DateValue, b: DateValue): boolean;
+/**
+ * Returns whether the given dates occur in the same month, using the calendar system of the first
+ * date.
+ */
+declare function isSameMonth(a: DateValue, b: DateValue): boolean;
+/**
+ * Returns whether the given dates occur in the same year, using the calendar system of the first
+ * date.
+ */
+declare function isSameYear(a: DateValue, b: DateValue): boolean;
+/** Returns whether the given dates occur on the same day, and are of the same calendar system. */
+declare function isEqualDay(a: DateValue, b: DateValue): boolean;
+/** Returns whether the given dates occur in the same month, and are of the same calendar system. */
+declare function isEqualMonth(a: DateValue, b: DateValue): boolean;
+/** Returns whether the given dates occur in the same year, and are of the same calendar system. */
+declare function isEqualYear(a: DateValue, b: DateValue): boolean;
+/** Returns whether two calendars are the same. */
+declare function isEqualCalendar(a: Calendar, b: Calendar): boolean;
+/** Returns whether the date is today in the given time zone. */
+declare function isToday(date: DateValue, timeZone: string): boolean;
+type DayOfWeek = "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat";
+/**
+ * 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.
+ */
+declare function getDayOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): number;
+/** Returns the current time in the given time zone. */
+declare function now(timeZone: string): ZonedDateTime;
+/** Returns today's date in the given time zone. */
+declare function today(timeZone: string): CalendarDate;
+/**
+ * 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.
+ */
+declare function getHoursInDay(a: CalendarDate, timeZone: string): number;
+/** Returns the time zone identifier for the current user. */
+declare function getLocalTimeZone(): string;
+/** Sets the time zone identifier for the current user. */
+declare function setLocalTimeZone(timeZone: string): void;
+/** Resets the time zone identifier for the current user. */
+declare function resetLocalTimeZone(): void;
+/** Returns the first date of the month for the given date. */
+declare function startOfMonth(date: ZonedDateTime): ZonedDateTime;
+declare function startOfMonth(date: CalendarDateTime): CalendarDateTime;
+declare function startOfMonth(date: CalendarDate): CalendarDate;
+declare function startOfMonth(date: DateValue): DateValue;
+/** Returns the last date of the month for the given date. */
+declare function endOfMonth(date: ZonedDateTime): ZonedDateTime;
+declare function endOfMonth(date: CalendarDateTime): CalendarDateTime;
+declare function endOfMonth(date: CalendarDate): CalendarDate;
+declare function endOfMonth(date: DateValue): DateValue;
+/** Returns the first day of the year for the given date. */
+declare function startOfYear(date: ZonedDateTime): ZonedDateTime;
+declare function startOfYear(date: CalendarDateTime): CalendarDateTime;
+declare function startOfYear(date: CalendarDate): CalendarDate;
+declare function startOfYear(date: DateValue): DateValue;
+/** Returns the last day of the year for the given date. */
+declare function endOfYear(date: ZonedDateTime): ZonedDateTime;
+declare function endOfYear(date: CalendarDateTime): CalendarDateTime;
+declare function endOfYear(date: CalendarDate): CalendarDate;
+declare function endOfYear(date: DateValue): DateValue;
+declare function getMinimumMonthInYear(date: AnyCalendarDate): number;
+declare function getMinimumDayInMonth(date: AnyCalendarDate): number;
+/** Returns the first date of the week for the given date and locale. */
+declare function startOfWeek(date: ZonedDateTime, locale: string, firstDayOfWeek?: DayOfWeek): ZonedDateTime;
+declare function startOfWeek(date: CalendarDateTime, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDateTime;
+declare function startOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDate;
+declare function startOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue;
+/** Returns the last date of the week for the given date and locale. */
+declare function endOfWeek(date: ZonedDateTime, locale: string, firstDayOfWeek?: DayOfWeek): ZonedDateTime;
+declare function endOfWeek(date: CalendarDateTime, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDateTime;
+declare function endOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDate;
+declare function endOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue;
+/** Returns the number of weeks in the given month and locale. */
+declare function getWeeksInMonth(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): number;
+/** Returns the lesser of the two provider dates. */
+declare function minDate<A extends DateValue, B extends DateValue>(a?: A | null, b?: B | null): A | B | null | undefined;
+/** Returns the greater of the two provider dates. */
+declare function maxDate<A extends DateValue, B extends DateValue>(a?: A | null, b?: B | null): A | B | null | undefined;
+/** Returns whether the given date is on a weekend in the given locale. */
+declare function isWeekend(date: DateValue, locale: string): boolean;
+/** Returns whether the given date is on a weekday in the given locale. */
+declare function isWeekday(date: DateValue, locale: string): boolean;
+//#endregion
+export { endOfMonth, endOfWeek, endOfYear, getDayOfWeek, getHoursInDay, getLocalTimeZone, getMinimumDayInMonth, getMinimumMonthInYear, getWeeksInMonth, isEqualCalendar, isEqualDay, isEqualMonth, isEqualYear, isSameDay, isSameMonth, isSameYear, isToday, isWeekday, isWeekend, maxDate, minDate, now, resetLocalTimeZone, setLocalTimeZone, startOfMonth, startOfWeek, startOfYear, today };