@stridge/noctis-intl 1.0.0-beta.0

package/dist/date/calendars/IslamicCalendar.js

@@ -0,0 +1,162 @@
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/IslamicCalendar.ts
+const CIVIL_EPOC = 1948440;
+const ASTRONOMICAL_EPOC = 1948439;
+const UMALQURA_YEAR_START = 1300;
+const UMALQURA_YEAR_END = 1600;
+const UMALQURA_START_DAYS = 460322;
+function islamicToJulianDay(epoch, year, month, day) {
+	return day + Math.ceil(29.5 * (month - 1)) + (year - 1) * 354 + Math.floor((3 + 11 * year) / 30) + epoch - 1;
+}
+function julianDayToIslamic(calendar, epoch, jd) {
+	let year = Math.floor((30 * (jd - epoch) + 10646) / 10631);
+	let month = Math.min(12, Math.ceil((jd - (29 + islamicToJulianDay(epoch, year, 1, 1))) / 29.5) + 1);
+	return new CalendarDate(calendar, year, month, jd - islamicToJulianDay(epoch, year, month, 1) + 1);
+}
+function isLeapYear(year) {
+	return (14 + 11 * year) % 30 < 11;
+}
+/**
+* The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+* world. The civil variant uses simple arithmetic rules rather than astronomical calculations to
+* approximate the traditional calendar, which is based on sighting of the crescent moon. It uses
+* Friday, July 16 622 CE (Julian) as the epoch. Each year has 12 months, with either 354 or 355
+* days depending on whether it is a leap year. Learn more about the available Islamic calendars
+* [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+*/
+var IslamicCivilCalendar = class {
+	identifier = "islamic-civil";
+	fromJulianDay(jd) {
+		return julianDayToIslamic(this, CIVIL_EPOC, jd);
+	}
+	toJulianDay(date) {
+		return islamicToJulianDay(CIVIL_EPOC, date.year, date.month, date.day);
+	}
+	getDaysInMonth(date) {
+		let length = 29 + date.month % 2;
+		if (date.month === 12 && isLeapYear(date.year)) length++;
+		return length;
+	}
+	getMonthsInYear() {
+		return 12;
+	}
+	getDaysInYear(date) {
+		return isLeapYear(date.year) ? 355 : 354;
+	}
+	getMaximumMonthsInYear() {
+		return 12;
+	}
+	getMaximumDaysInMonth() {
+		return 30;
+	}
+	getYearsInEra() {
+		return 9665;
+	}
+	getEras() {
+		return ["AH"];
+	}
+};
+/**
+* The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+* world. The tabular variant uses simple arithmetic rules rather than astronomical calculations to
+* approximate the traditional calendar, which is based on sighting of the crescent moon. It uses
+* Thursday, July 15 622 CE (Julian) as the epoch. Each year has 12 months, with either 354 or 355
+* days depending on whether it is a leap year. Learn more about the available Islamic calendars
+* [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+*/
+var IslamicTabularCalendar = class extends IslamicCivilCalendar {
+	identifier = "islamic-tbla";
+	fromJulianDay(jd) {
+		return julianDayToIslamic(this, ASTRONOMICAL_EPOC, jd);
+	}
+	toJulianDay(date) {
+		return islamicToJulianDay(ASTRONOMICAL_EPOC, date.year, date.month, date.day);
+	}
+};
+const UMALQURA_DATA = "qgpUDckO1AbqBmwDrQpVBakGkgepC9QF2gpcBS0NlQZKB1QLagutBa4ETwoXBYsGpQbVCtYCWwmdBE0KJg2VDawFtgm6AlsKKwWVCsoG6Qr0AnYJtgJWCcoKpAvSC9kF3AJtCU0FpQpSC6ULtAW2CVcFlwJLBaMGUgdlC2oFqworBZUMSg2lDcoF1gpXCasESwmlClILagt1BXYCtwhbBFUFqQW0BdoJ3QRuAjYJqgpUDbIN1QXaAlsJqwRVCkkLZAtxC7QFtQpVCiUNkg7JDtQG6QprCasEkwpJDaQNsg25CroEWworBZUKKgtVC1wFvQQ9Ah0JlQpKC1oLbQW2AjsJmwRVBqkGVAdqC2wFrQpVBSkLkgupC9QF2gpaBasKlQVJB2QHqgu1BbYCVgpNDiULUgtqC60FrgIvCZcESwalBqwG1gpdBZ0ETQoWDZUNqgW1BdoCWwmtBJUFygbkBuoK9QS2AlYJqgpUC9IL2QXqAm0JrQSVCkoLpQuyBbUJ1gSXCkcFkwZJB1ULagVrCisFiwpGDaMNygXWCtsEawJLCaUKUgtpC3UFdgG3CFsCKwVlBbQF2gntBG0BtgimClINqQ3UBdoKWwmrBFMGKQdiB6kLsgW1ClUFJQuSDckO0gbpCmsFqwRVCikNVA2qDbUJugQ7CpsETQqqCtUK2gJdCV4ELgqaDFUNsga5BroEXQotBZUKUguoC7QLuQXaAloJSgukDdEO6AZqC20FNQWVBkoNqA3UDdoGWwWdAisGFQtKC5ULqgWuCi4JjwwnBZUGqgbWCl0FnQI=";
+let UMALQURA_MONTHLENGTH;
+let UMALQURA_YEAR_START_TABLE;
+function umalquraYearStart(year) {
+	return UMALQURA_START_DAYS + UMALQURA_YEAR_START_TABLE[year - UMALQURA_YEAR_START];
+}
+function umalquraMonthLength(year, month) {
+	let idx = year - UMALQURA_YEAR_START;
+	let mask = 1 << 11 - (month - 1);
+	if ((UMALQURA_MONTHLENGTH[idx] & mask) === 0) return 29;
+	else return 30;
+}
+function umalquraMonthStart(year, month) {
+	let day = umalquraYearStart(year);
+	for (let i = 1; i < month; i++) day += umalquraMonthLength(year, i);
+	return day;
+}
+function umalquraYearLength(year) {
+	return UMALQURA_YEAR_START_TABLE[year + 1 - UMALQURA_YEAR_START] - UMALQURA_YEAR_START_TABLE[year - UMALQURA_YEAR_START];
+}
+/**
+* The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+* world. The Umalqura variant is primarily used in Saudi Arabia. It is a lunar calendar, based on
+* astronomical calculations that predict the sighting of a crescent moon. Month and year lengths
+* vary between years depending on these calculations. Learn more about the available Islamic
+* calendars
+* [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+*/
+var IslamicUmalquraCalendar = class extends IslamicCivilCalendar {
+	identifier = "islamic-umalqura";
+	constructor() {
+		super();
+		if (!UMALQURA_MONTHLENGTH) UMALQURA_MONTHLENGTH = new Uint16Array(Uint8Array.from(atob(UMALQURA_DATA), (c) => c.charCodeAt(0)).buffer);
+		if (!UMALQURA_YEAR_START_TABLE) {
+			UMALQURA_YEAR_START_TABLE = new Uint32Array(UMALQURA_YEAR_END - UMALQURA_YEAR_START + 1);
+			let yearStart = 0;
+			for (let year = UMALQURA_YEAR_START; year <= UMALQURA_YEAR_END; year++) {
+				UMALQURA_YEAR_START_TABLE[year - UMALQURA_YEAR_START] = yearStart;
+				for (let i = 1; i <= 12; i++) yearStart += umalquraMonthLength(year, i);
+			}
+		}
+	}
+	fromJulianDay(jd) {
+		let days = jd - CIVIL_EPOC;
+		let startDays = umalquraYearStart(UMALQURA_YEAR_START);
+		let endDays = umalquraYearStart(UMALQURA_YEAR_END);
+		if (days < startDays || days > endDays) return super.fromJulianDay(jd);
+		else {
+			let y = UMALQURA_YEAR_START - 1;
+			let m = 1;
+			let d = 1;
+			while (d > 0) {
+				y++;
+				d = days - umalquraYearStart(y) + 1;
+				let yearLength = umalquraYearLength(y);
+				if (d === yearLength) {
+					m = 12;
+					break;
+				} else if (d < yearLength) {
+					let monthLength = umalquraMonthLength(y, m);
+					m = 1;
+					while (d > monthLength) {
+						d -= monthLength;
+						m++;
+						monthLength = umalquraMonthLength(y, m);
+					}
+					break;
+				}
+			}
+			return new CalendarDate(this, y, m, days - umalquraMonthStart(y, m) + 1);
+		}
+	}
+	toJulianDay(date) {
+		if (date.year < UMALQURA_YEAR_START || date.year > UMALQURA_YEAR_END) return super.toJulianDay(date);
+		return CIVIL_EPOC + umalquraMonthStart(date.year, date.month) + (date.day - 1);
+	}
+	getDaysInMonth(date) {
+		if (date.year < UMALQURA_YEAR_START || date.year > UMALQURA_YEAR_END) return super.getDaysInMonth(date);
+		return umalquraMonthLength(date.year, date.month);
+	}
+	getDaysInYear(date) {
+		if (date.year < UMALQURA_YEAR_START || date.year > UMALQURA_YEAR_END) return super.getDaysInYear(date);
+		return umalquraYearLength(date.year);
+	}
+};
+//#endregion
+export { IslamicCivilCalendar, IslamicTabularCalendar, IslamicUmalquraCalendar };

package/dist/date/calendars/JapaneseCalendar.d.ts

@@ -0,0 +1,26 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, CalendarIdentifier } from "../types.js";
+import { Mutable } from "../utils.js";
+import { GregorianCalendar } from "./GregorianCalendar.js";
+
+//#region src/date/calendars/JapaneseCalendar.d.ts
+/**
+ * The Japanese calendar is based on the Gregorian calendar, but with eras for the reign of each
+ * Japanese emperor. Whenever a new emperor ascends to the throne, a new era begins and the year
+ * starts again from 1. Note that eras before 1868 (Gregorian) are not currently supported by this
+ * implementation.
+ */
+declare class JapaneseCalendar extends GregorianCalendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  balanceDate(date: Mutable<AnyCalendarDate>): void;
+  constrainDate(date: Mutable<AnyCalendarDate>): void;
+  getEras(): string[];
+  getYearsInEra(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getMinimumMonthInYear(date: AnyCalendarDate): number;
+  getMinimumDayInMonth(date: AnyCalendarDate): number;
+}
+//#endregion
+export { JapaneseCalendar };

package/dist/date/calendars/JapaneseCalendar.js

@@ -0,0 +1,154 @@
+import { GregorianCalendar } from "./GregorianCalendar.js";
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/JapaneseCalendar.ts
+const ERA_START_DATES = [
+	[
+		1868,
+		9,
+		8
+	],
+	[
+		1912,
+		7,
+		30
+	],
+	[
+		1926,
+		12,
+		25
+	],
+	[
+		1989,
+		1,
+		8
+	],
+	[
+		2019,
+		5,
+		1
+	]
+];
+const ERA_END_DATES = [
+	[
+		1912,
+		7,
+		29
+	],
+	[
+		1926,
+		12,
+		24
+	],
+	[
+		1989,
+		1,
+		7
+	],
+	[
+		2019,
+		4,
+		30
+	]
+];
+const ERA_ADDENDS = [
+	1867,
+	1911,
+	1925,
+	1988,
+	2018
+];
+const ERA_NAMES = [
+	"meiji",
+	"taisho",
+	"showa",
+	"heisei",
+	"reiwa"
+];
+function findEraFromGregorianDate(date) {
+	const idx = ERA_START_DATES.findIndex(([year, month, day]) => {
+		if (date.year < year) return true;
+		if (date.year === year && date.month < month) return true;
+		if (date.year === year && date.month === month && date.day < day) return true;
+		return false;
+	});
+	if (idx === -1) return ERA_START_DATES.length - 1;
+	if (idx === 0) return 0;
+	return idx - 1;
+}
+function toGregorian(date) {
+	let eraAddend = ERA_ADDENDS[ERA_NAMES.indexOf(date.era)];
+	if (!eraAddend) throw new Error("Unknown era: " + date.era);
+	return new CalendarDate(date.year + eraAddend, date.month, date.day);
+}
+/**
+* The Japanese calendar is based on the Gregorian calendar, but with eras for the reign of each
+* Japanese emperor. Whenever a new emperor ascends to the throne, a new era begins and the year
+* starts again from 1. Note that eras before 1868 (Gregorian) are not currently supported by this
+* implementation.
+*/
+var JapaneseCalendar = class extends GregorianCalendar {
+	identifier = "japanese";
+	fromJulianDay(jd) {
+		let date = super.fromJulianDay(jd);
+		let era = findEraFromGregorianDate(date);
+		return new CalendarDate(this, ERA_NAMES[era], date.year - ERA_ADDENDS[era], date.month, date.day);
+	}
+	toJulianDay(date) {
+		return super.toJulianDay(toGregorian(date));
+	}
+	balanceDate(date) {
+		let gregorianDate = toGregorian(date);
+		let era = findEraFromGregorianDate(gregorianDate);
+		if (ERA_NAMES[era] !== date.era) {
+			date.era = ERA_NAMES[era];
+			date.year = gregorianDate.year - ERA_ADDENDS[era];
+		}
+		this.constrainDate(date);
+	}
+	constrainDate(date) {
+		let idx = ERA_NAMES.indexOf(date.era);
+		let end = ERA_END_DATES[idx];
+		if (end != null) {
+			let [endYear, endMonth, endDay] = end;
+			let maxYear = endYear - ERA_ADDENDS[idx];
+			date.year = Math.max(1, Math.min(maxYear, date.year));
+			if (date.year === maxYear) {
+				date.month = Math.min(endMonth, date.month);
+				if (date.month === endMonth) date.day = Math.min(endDay, date.day);
+			}
+		}
+		if (date.year === 1 && idx >= 0) {
+			let [, startMonth, startDay] = ERA_START_DATES[idx];
+			date.month = Math.max(startMonth, date.month);
+			if (date.month === startMonth) date.day = Math.max(startDay, date.day);
+		}
+	}
+	getEras() {
+		return ERA_NAMES;
+	}
+	getYearsInEra(date) {
+		let era = ERA_NAMES.indexOf(date.era);
+		let cur = ERA_START_DATES[era];
+		let next = ERA_START_DATES[era + 1];
+		if (next == null) return 9999 - cur[0] + 1;
+		let years = next[0] - cur[0];
+		if (date.month < next[1] || date.month === next[1] && date.day < next[2]) years++;
+		return years;
+	}
+	getDaysInMonth(date) {
+		return super.getDaysInMonth(toGregorian(date));
+	}
+	getMinimumMonthInYear(date) {
+		let start = getMinimums(date);
+		return start ? start[1] : 1;
+	}
+	getMinimumDayInMonth(date) {
+		let start = getMinimums(date);
+		return start && date.month === start[1] ? start[2] : 1;
+	}
+};
+function getMinimums(date) {
+	if (date.year === 1) return ERA_START_DATES[ERA_NAMES.indexOf(date.era)];
+}
+//#endregion
+export { JapaneseCalendar };

package/dist/date/calendars/PersianCalendar.d.ts

@@ -0,0 +1,23 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, Calendar, CalendarIdentifier } from "../types.js";
+
+//#region src/date/calendars/PersianCalendar.d.ts
+/**
+ * The Persian calendar is the main calendar used in Iran and Afghanistan. It has 12 months
+ * in each year, the first 6 of which have 31 days, and the next 5 have 30 days. The 12th month
+ * has either 29 or 30 days depending on whether it is a leap year. The Persian year starts
+ * around the March equinox.
+ */
+declare class PersianCalendar implements Calendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getMonthsInYear(): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getMaximumMonthsInYear(): number;
+  getMaximumDaysInMonth(): number;
+  getEras(): string[];
+  getYearsInEra(): number;
+}
+//#endregion
+export { PersianCalendar };

package/dist/date/calendars/PersianCalendar.js

@@ -0,0 +1,63 @@
+import { mod } from "../utils.js";
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/PersianCalendar.ts
+const PERSIAN_EPOCH = 1948320;
+const MONTH_START = [
+	0,
+	31,
+	62,
+	93,
+	124,
+	155,
+	186,
+	216,
+	246,
+	276,
+	306,
+	336
+];
+/**
+* The Persian calendar is the main calendar used in Iran and Afghanistan. It has 12 months
+* in each year, the first 6 of which have 31 days, and the next 5 have 30 days. The 12th month
+* has either 29 or 30 days depending on whether it is a leap year. The Persian year starts
+* around the March equinox.
+*/
+var PersianCalendar = class {
+	identifier = "persian";
+	fromJulianDay(jd) {
+		let daysSinceEpoch = jd - PERSIAN_EPOCH;
+		let year = 1 + Math.floor((33 * daysSinceEpoch + 3) / 12053);
+		let dayOfYear = daysSinceEpoch - (365 * (year - 1) + Math.floor((8 * year + 21) / 33));
+		let month = dayOfYear < 216 ? Math.floor(dayOfYear / 31) : Math.floor((dayOfYear - 6) / 30);
+		let day = dayOfYear - MONTH_START[month] + 1;
+		return new CalendarDate(this, year, month + 1, day);
+	}
+	toJulianDay(date) {
+		let jd = PERSIAN_EPOCH - 1 + 365 * (date.year - 1) + Math.floor((8 * date.year + 21) / 33);
+		jd += MONTH_START[date.month - 1];
+		jd += date.day;
+		return jd;
+	}
+	getMonthsInYear() {
+		return 12;
+	}
+	getDaysInMonth(date) {
+		if (date.month <= 6) return 31;
+		if (date.month <= 11) return 30;
+		return mod(25 * date.year + 11, 33) < 8 ? 30 : 29;
+	}
+	getMaximumMonthsInYear() {
+		return 12;
+	}
+	getMaximumDaysInMonth() {
+		return 31;
+	}
+	getEras() {
+		return ["AP"];
+	}
+	getYearsInEra() {
+		return 9377;
+	}
+};
+//#endregion
+export { PersianCalendar };

package/dist/date/calendars/TaiwanCalendar.d.ts

@@ -0,0 +1,23 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, CalendarIdentifier } from "../types.js";
+import { Mutable } from "../utils.js";
+import { GregorianCalendar } from "./GregorianCalendar.js";
+
+//#region src/date/calendars/TaiwanCalendar.d.ts
+/**
+ * The Taiwanese calendar is the same as the Gregorian calendar, but years
+ * are numbered starting from 1912 (Gregorian). Two eras are supported:
+ * 'before_minguo' and 'minguo'.
+ */
+declare class TaiwanCalendar extends GregorianCalendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getEras(): string[];
+  balanceDate(date: Mutable<AnyCalendarDate>): void;
+  isInverseEra(date: AnyCalendarDate): boolean;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getYearsInEra(date: AnyCalendarDate): number;
+}
+//#endregion
+export { TaiwanCalendar };

package/dist/date/calendars/TaiwanCalendar.js

@@ -0,0 +1,51 @@
+import { GregorianCalendar, fromExtendedYear, getExtendedYear } from "./GregorianCalendar.js";
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/TaiwanCalendar.ts
+const TAIWAN_ERA_START = 1911;
+function gregorianYear(date) {
+	return date.era === "minguo" ? date.year + TAIWAN_ERA_START : 1 - date.year + TAIWAN_ERA_START;
+}
+function gregorianToTaiwan(year) {
+	let y = year - TAIWAN_ERA_START;
+	if (y > 0) return ["minguo", y];
+	else return ["before_minguo", 1 - y];
+}
+/**
+* The Taiwanese calendar is the same as the Gregorian calendar, but years
+* are numbered starting from 1912 (Gregorian). Two eras are supported:
+* 'before_minguo' and 'minguo'.
+*/
+var TaiwanCalendar = class extends GregorianCalendar {
+	identifier = "roc";
+	fromJulianDay(jd) {
+		let date = super.fromJulianDay(jd);
+		let [era, year] = gregorianToTaiwan(getExtendedYear(date.era, date.year));
+		return new CalendarDate(this, era, year, date.month, date.day);
+	}
+	toJulianDay(date) {
+		return super.toJulianDay(toGregorian(date));
+	}
+	getEras() {
+		return ["before_minguo", "minguo"];
+	}
+	balanceDate(date) {
+		let [era, year] = gregorianToTaiwan(gregorianYear(date));
+		date.era = era;
+		date.year = year;
+	}
+	isInverseEra(date) {
+		return date.era === "before_minguo";
+	}
+	getDaysInMonth(date) {
+		return super.getDaysInMonth(toGregorian(date));
+	}
+	getYearsInEra(date) {
+		return date.era === "before_minguo" ? 9999 : 9999 - TAIWAN_ERA_START;
+	}
+};
+function toGregorian(date) {
+	let [era, year] = fromExtendedYear(gregorianYear(date));
+	return new CalendarDate(era, year, date.month, date.day);
+}
+//#endregion
+export { TaiwanCalendar };

package/dist/date/conversion.d.ts

@@ -0,0 +1,41 @@
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+import { AnyCalendarDate, AnyTime, Calendar, Disambiguation } from "./types.js";
+
+//#region src/date/conversion.d.ts
+/**
+ * Takes a Unix epoch (milliseconds since 1970) and converts it to the provided time zone.
+ */
+declare function fromAbsolute(ms: number, timeZone: string): ZonedDateTime;
+/**
+ * Takes a `Date` object and converts it to the provided time zone.
+ */
+declare function fromDate(date: Date, timeZone: string): ZonedDateTime;
+/**
+ * Takes a `Date` object and converts it to the time zone identifier for the current user.
+ */
+declare function fromDateToLocal(date: Date): ZonedDateTime;
+/**
+ * Converts a value with date components such as a `CalendarDateTime` or `ZonedDateTime` into a
+ * `CalendarDate`.
+ */
+declare function toCalendarDate(dateTime: AnyCalendarDate): CalendarDate;
+/**
+ * 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.
+ */
+declare function toCalendarDateTime(date: CalendarDate | CalendarDateTime | ZonedDateTime, time?: AnyTime): CalendarDateTime;
+/** Extracts the time components from a value containing a date and time. */
+declare function toTime(dateTime: CalendarDateTime | ZonedDateTime): Time;
+/** Converts a date from one calendar system to another. */
+declare function toCalendar<T extends AnyCalendarDate>(date: T, calendar: Calendar): T;
+/**
+ * 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.
+ */
+declare function toZoned(date: CalendarDate | CalendarDateTime | ZonedDateTime, timeZone: string, disambiguation?: Disambiguation): ZonedDateTime;
+/** Converts a `ZonedDateTime` from one time zone to another. */
+declare function toTimeZone(date: ZonedDateTime, timeZone: string): ZonedDateTime;
+/** Converts the given `ZonedDateTime` into the user's local time zone. */
+declare function toLocalTimeZone(date: ZonedDateTime): ZonedDateTime;
+//#endregion
+export { fromAbsolute, fromDate, fromDateToLocal, toCalendar, toCalendarDate, toCalendarDateTime, toLocalTimeZone, toTime, toTimeZone, toZoned };