@stridge/noctis-intl 1.0.0-beta.0

package/dist/date/calendars/EthiopicCalendar.js

@@ -0,0 +1,129 @@
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/EthiopicCalendar.ts
+const ETHIOPIC_EPOCH = 1723856;
+const COPTIC_EPOCH = 1824665;
+const AMETE_MIHRET_DELTA = 5500;
+function ceToJulianDay(epoch, year, month, day) {
+	return epoch + 365 * year + Math.floor(year / 4) + 30 * (month - 1) + day - 1;
+}
+function julianDayToCE(epoch, jd) {
+	let year = Math.floor(4 * (jd - epoch) / 1461);
+	let month = 1 + Math.floor((jd - ceToJulianDay(epoch, year, 1, 1)) / 30);
+	return [
+		year,
+		month,
+		jd + 1 - ceToJulianDay(epoch, year, month, 1)
+	];
+}
+function getLeapDay(year) {
+	return Math.floor(year % 4 / 3);
+}
+function getDaysInMonth(year, month) {
+	if (month % 13 !== 0) return 30;
+	else return getLeapDay(year) + 5;
+}
+/**
+* The Ethiopic calendar system is the official calendar used in Ethiopia.
+* It includes 12 months of 30 days each, plus 5 or 6 intercalary days depending
+* on whether it is a leap year. Two eras are supported: 'AA' and 'AM'.
+*/
+var EthiopicCalendar = class {
+	identifier = "ethiopic";
+	fromJulianDay(jd) {
+		let [year, month, day] = julianDayToCE(ETHIOPIC_EPOCH, jd);
+		let era = "AM";
+		if (year <= 0) {
+			era = "AA";
+			year += AMETE_MIHRET_DELTA;
+		}
+		return new CalendarDate(this, era, year, month, day);
+	}
+	toJulianDay(date) {
+		let year = date.year;
+		if (date.era === "AA") year -= AMETE_MIHRET_DELTA;
+		return ceToJulianDay(ETHIOPIC_EPOCH, year, date.month, date.day);
+	}
+	getDaysInMonth(date) {
+		return getDaysInMonth(date.year, date.month);
+	}
+	getMonthsInYear() {
+		return 13;
+	}
+	getDaysInYear(date) {
+		return 365 + getLeapDay(date.year);
+	}
+	getMaximumMonthsInYear() {
+		return 13;
+	}
+	getMaximumDaysInMonth() {
+		return 30;
+	}
+	getYearsInEra(date) {
+		return date.era === "AA" ? 9999 : 9991;
+	}
+	getEras() {
+		return ["AA", "AM"];
+	}
+};
+/**
+* The Ethiopic (Amete Alem) calendar is the same as the modern Ethiopic calendar,
+* except years were measured from a different epoch. Only one era is supported: 'AA'.
+*/
+var EthiopicAmeteAlemCalendar = class extends EthiopicCalendar {
+	identifier = "ethioaa";
+	fromJulianDay(jd) {
+		let [year, month, day] = julianDayToCE(ETHIOPIC_EPOCH, jd);
+		year += AMETE_MIHRET_DELTA;
+		return new CalendarDate(this, "AA", year, month, day);
+	}
+	getEras() {
+		return ["AA"];
+	}
+	getYearsInEra() {
+		return 9999;
+	}
+};
+/**
+* The Coptic calendar is similar to the Ethiopic calendar.
+* It includes 12 months of 30 days each, plus 5 or 6 intercalary days depending
+* on whether it is a leap year. Two eras are supported: 'BCE' and 'CE'.
+*/
+var CopticCalendar = class extends EthiopicCalendar {
+	identifier = "coptic";
+	fromJulianDay(jd) {
+		let [year, month, day] = julianDayToCE(COPTIC_EPOCH, jd);
+		let era = "CE";
+		if (year <= 0) {
+			era = "BCE";
+			year = 1 - year;
+		}
+		return new CalendarDate(this, era, year, month, day);
+	}
+	toJulianDay(date) {
+		let year = date.year;
+		if (date.era === "BCE") year = 1 - year;
+		return ceToJulianDay(COPTIC_EPOCH, year, date.month, date.day);
+	}
+	getDaysInMonth(date) {
+		let year = date.year;
+		if (date.era === "BCE") year = 1 - year;
+		return getDaysInMonth(year, date.month);
+	}
+	isInverseEra(date) {
+		return date.era === "BCE";
+	}
+	balanceDate(date) {
+		if (date.year <= 0) {
+			date.era = date.era === "BCE" ? "CE" : "BCE";
+			date.year = 1 - date.year;
+		}
+	}
+	getEras() {
+		return ["BCE", "CE"];
+	}
+	getYearsInEra(date) {
+		return date.era === "BCE" ? 9999 : 9715;
+	}
+};
+//#endregion
+export { CopticCalendar, EthiopicAmeteAlemCalendar, EthiopicCalendar };

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

@@ -0,0 +1,26 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, Calendar, CalendarIdentifier } from "../types.js";
+import { Mutable } from "../utils.js";
+
+//#region src/date/calendars/GregorianCalendar.d.ts
+/**
+ * The Gregorian calendar is the most commonly used calendar system in the world. It supports two
+ * eras: BC, and AD. Years always contain 12 months, and 365 or 366 days depending on whether it is
+ * a leap year.
+ */
+declare class GregorianCalendar implements Calendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getMonthsInYear(date: AnyCalendarDate): number;
+  getDaysInYear(date: AnyCalendarDate): number;
+  getMaximumMonthsInYear(): number;
+  getMaximumDaysInMonth(): number;
+  getYearsInEra(date: AnyCalendarDate): number;
+  getEras(): string[];
+  isInverseEra(date: AnyCalendarDate): boolean;
+  balanceDate(date: Mutable<AnyCalendarDate>): void;
+}
+//#endregion
+export { GregorianCalendar };

package/dist/date/calendars/GregorianCalendar.js

@@ -0,0 +1,117 @@
+import { mod } from "../utils.js";
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/GregorianCalendar.ts
+const EPOCH = 1721426;
+function gregorianToJulianDay(era, year, month, day) {
+	year = getExtendedYear(era, year);
+	let y1 = year - 1;
+	let monthOffset = -2;
+	if (month <= 2) monthOffset = 0;
+	else if (isLeapYear(year)) monthOffset = -1;
+	return EPOCH - 1 + 365 * y1 + Math.floor(y1 / 4) - Math.floor(y1 / 100) + Math.floor(y1 / 400) + Math.floor((367 * month - 362) / 12 + monthOffset + day);
+}
+function isLeapYear(year) {
+	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function getExtendedYear(era, year) {
+	return era === "BC" ? 1 - year : year;
+}
+function fromExtendedYear(year) {
+	let era = "AD";
+	if (year <= 0) {
+		era = "BC";
+		year = 1 - year;
+	}
+	return [era, year];
+}
+const daysInMonth = {
+	standard: [
+		31,
+		28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	],
+	leapyear: [
+		31,
+		29,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	]
+};
+/**
+* The Gregorian calendar is the most commonly used calendar system in the world. It supports two
+* eras: BC, and AD. Years always contain 12 months, and 365 or 366 days depending on whether it is
+* a leap year.
+*/
+var GregorianCalendar = class {
+	identifier = "gregory";
+	fromJulianDay(jd) {
+		let jd0 = jd;
+		let depoch = jd0 - EPOCH;
+		let quadricent = Math.floor(depoch / 146097);
+		let dqc = mod(depoch, 146097);
+		let cent = Math.floor(dqc / 36524);
+		let dcent = mod(dqc, 36524);
+		let quad = Math.floor(dcent / 1461);
+		let dquad = mod(dcent, 1461);
+		let yindex = Math.floor(dquad / 365);
+		let [era, year] = fromExtendedYear(quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0));
+		let yearDay = jd0 - gregorianToJulianDay(era, year, 1, 1);
+		let leapAdj = 2;
+		if (jd0 < gregorianToJulianDay(era, year, 3, 1)) leapAdj = 0;
+		else if (isLeapYear(year)) leapAdj = 1;
+		let month = Math.floor(((yearDay + leapAdj) * 12 + 373) / 367);
+		return new CalendarDate(era, year, month, jd0 - gregorianToJulianDay(era, year, month, 1) + 1);
+	}
+	toJulianDay(date) {
+		return gregorianToJulianDay(date.era, date.year, date.month, date.day);
+	}
+	getDaysInMonth(date) {
+		return daysInMonth[isLeapYear(date.year) ? "leapyear" : "standard"][date.month - 1];
+	}
+	getMonthsInYear(date) {
+		return 12;
+	}
+	getDaysInYear(date) {
+		return isLeapYear(date.year) ? 366 : 365;
+	}
+	getMaximumMonthsInYear() {
+		return 12;
+	}
+	getMaximumDaysInMonth() {
+		return 31;
+	}
+	getYearsInEra(date) {
+		return 9999;
+	}
+	getEras() {
+		return ["BC", "AD"];
+	}
+	isInverseEra(date) {
+		return date.era === "BC";
+	}
+	balanceDate(date) {
+		if (date.year <= 0) {
+			date.era = date.era === "BC" ? "AD" : "BC";
+			date.year = 1 - date.year;
+		}
+	}
+};
+//#endregion
+export { GregorianCalendar, fromExtendedYear, getExtendedYear, gregorianToJulianDay, isLeapYear };

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

@@ -0,0 +1,25 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, Calendar, CalendarIdentifier } from "../types.js";
+import { Mutable } from "../utils.js";
+
+//#region src/date/calendars/HebrewCalendar.d.ts
+/**
+ * The Hebrew calendar is used in Israel and around the world by the Jewish faith.
+ * Years include either 12 or 13 months depending on whether it is a leap year.
+ * In leap years, an extra month is inserted at month 6.
+ */
+declare class HebrewCalendar implements Calendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getMonthsInYear(date: AnyCalendarDate): number;
+  getDaysInYear(date: AnyCalendarDate): number;
+  getMaximumMonthsInYear(): number;
+  getMaximumDaysInMonth(): number;
+  getYearsInEra(): number;
+  getEras(): string[];
+  balanceYearMonth(date: Mutable<AnyCalendarDate>, previousDate: AnyCalendarDate): void;
+}
+//#endregion
+export { HebrewCalendar };

package/dist/date/calendars/HebrewCalendar.js

@@ -0,0 +1,114 @@
+import { mod } from "../utils.js";
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/HebrewCalendar.ts
+const HEBREW_EPOCH = 347997;
+const HOUR_PARTS = 1080;
+const DAY_PARTS = 24 * HOUR_PARTS;
+const MONTH_DAYS = 29;
+const MONTH_FRACT = 12 * HOUR_PARTS + 793;
+const MONTH_PARTS = MONTH_DAYS * DAY_PARTS + MONTH_FRACT;
+function isLeapYear(year) {
+	return mod(year * 7 + 1, 19) < 7;
+}
+function hebrewDelay1(year) {
+	let months = Math.floor((235 * year - 234) / 19);
+	let parts = 12084 + 13753 * months;
+	let day = months * 29 + Math.floor(parts / 25920);
+	if (mod(3 * (day + 1), 7) < 3) day += 1;
+	return day;
+}
+function hebrewDelay2(year) {
+	let last = hebrewDelay1(year - 1);
+	let present = hebrewDelay1(year);
+	if (hebrewDelay1(year + 1) - present === 356) return 2;
+	if (present - last === 382) return 1;
+	return 0;
+}
+function startOfYear(year) {
+	return hebrewDelay1(year) + hebrewDelay2(year);
+}
+function getDaysInYear(year) {
+	return startOfYear(year + 1) - startOfYear(year);
+}
+function getYearType(year) {
+	let yearLength = getDaysInYear(year);
+	if (yearLength > 380) yearLength -= 30;
+	switch (yearLength) {
+		case 353: return 0;
+		case 354: return 1;
+		case 355: return 2;
+	}
+}
+function getDaysInMonth(year, month) {
+	if (month >= 6 && !isLeapYear(year)) month++;
+	if (month === 4 || month === 7 || month === 9 || month === 11 || month === 13) return 29;
+	let yearType = getYearType(year);
+	if (month === 2) return yearType === 2 ? 30 : 29;
+	if (month === 3) return yearType === 0 ? 29 : 30;
+	if (month === 6) return isLeapYear(year) ? 30 : 0;
+	return 30;
+}
+/**
+* The Hebrew calendar is used in Israel and around the world by the Jewish faith.
+* Years include either 12 or 13 months depending on whether it is a leap year.
+* In leap years, an extra month is inserted at month 6.
+*/
+var HebrewCalendar = class {
+	identifier = "hebrew";
+	fromJulianDay(jd) {
+		let d = jd - HEBREW_EPOCH;
+		let m = d * DAY_PARTS / MONTH_PARTS;
+		let year = Math.floor((19 * m + 234) / 235) + 1;
+		let ys = startOfYear(year);
+		let dayOfYear = Math.floor(d - ys);
+		while (dayOfYear < 1) {
+			year--;
+			ys = startOfYear(year);
+			dayOfYear = Math.floor(d - ys);
+		}
+		let month = 1;
+		let monthStart = 0;
+		while (monthStart < dayOfYear) {
+			monthStart += getDaysInMonth(year, month);
+			month++;
+		}
+		month--;
+		monthStart -= getDaysInMonth(year, month);
+		let day = dayOfYear - monthStart;
+		return new CalendarDate(this, year, month, day);
+	}
+	toJulianDay(date) {
+		let jd = startOfYear(date.year);
+		for (let month = 1; month < date.month; month++) jd += getDaysInMonth(date.year, month);
+		return jd + date.day + HEBREW_EPOCH;
+	}
+	getDaysInMonth(date) {
+		return getDaysInMonth(date.year, date.month);
+	}
+	getMonthsInYear(date) {
+		return isLeapYear(date.year) ? 13 : 12;
+	}
+	getDaysInYear(date) {
+		return getDaysInYear(date.year);
+	}
+	getMaximumMonthsInYear() {
+		return 13;
+	}
+	getMaximumDaysInMonth() {
+		return 30;
+	}
+	getYearsInEra() {
+		return 9999;
+	}
+	getEras() {
+		return ["AM"];
+	}
+	balanceYearMonth(date, previousDate) {
+		if (previousDate.year !== date.year) {
+			if (isLeapYear(previousDate.year) && !isLeapYear(date.year) && previousDate.month > 6) date.month--;
+			else if (!isLeapYear(previousDate.year) && isLeapYear(date.year) && previousDate.month > 6) date.month++;
+		}
+	}
+};
+//#endregion
+export { HebrewCalendar };

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

@@ -0,0 +1,21 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, CalendarIdentifier } from "../types.js";
+import { GregorianCalendar } from "./GregorianCalendar.js";
+
+//#region src/date/calendars/IndianCalendar.d.ts
+/**
+ * The Indian National Calendar is similar to the Gregorian calendar, but with
+ * years numbered since the Saka era in 78 AD (Gregorian). There are 12 months
+ * in each year, with either 30 or 31 days. Only one era identifier is supported: 'saka'.
+ */
+declare class IndianCalendar extends GregorianCalendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getYearsInEra(): number;
+  getEras(): string[];
+  balanceDate(): void;
+}
+//#endregion
+export { IndianCalendar };

package/dist/date/calendars/IndianCalendar.js

@@ -0,0 +1,75 @@
+import { GregorianCalendar, fromExtendedYear, gregorianToJulianDay, isLeapYear } from "./GregorianCalendar.js";
+import { CalendarDate } from "../CalendarDate.js";
+//#region src/date/calendars/IndianCalendar.ts
+const INDIAN_ERA_START = 78;
+const INDIAN_YEAR_START = 80;
+/**
+* The Indian National Calendar is similar to the Gregorian calendar, but with
+* years numbered since the Saka era in 78 AD (Gregorian). There are 12 months
+* in each year, with either 30 or 31 days. Only one era identifier is supported: 'saka'.
+*/
+var IndianCalendar = class extends GregorianCalendar {
+	identifier = "indian";
+	fromJulianDay(jd) {
+		let date = super.fromJulianDay(jd);
+		let indianYear = date.year - INDIAN_ERA_START;
+		let yDay = jd - gregorianToJulianDay(date.era, date.year, 1, 1);
+		let leapMonth;
+		if (yDay < INDIAN_YEAR_START) {
+			indianYear--;
+			leapMonth = isLeapYear(date.year - 1) ? 31 : 30;
+			yDay += leapMonth + 155 + 90 + 10;
+		} else {
+			leapMonth = isLeapYear(date.year) ? 31 : 30;
+			yDay -= INDIAN_YEAR_START;
+		}
+		let indianMonth;
+		let indianDay;
+		if (yDay < leapMonth) {
+			indianMonth = 1;
+			indianDay = yDay + 1;
+		} else {
+			let mDay = yDay - leapMonth;
+			if (mDay < 155) {
+				indianMonth = Math.floor(mDay / 31) + 2;
+				indianDay = mDay % 31 + 1;
+			} else {
+				mDay -= 155;
+				indianMonth = Math.floor(mDay / 30) + 7;
+				indianDay = mDay % 30 + 1;
+			}
+		}
+		return new CalendarDate(this, indianYear, indianMonth, indianDay);
+	}
+	toJulianDay(date) {
+		let [era, year] = fromExtendedYear(date.year + INDIAN_ERA_START);
+		let leapMonth;
+		let jd;
+		if (isLeapYear(year)) {
+			leapMonth = 31;
+			jd = gregorianToJulianDay(era, year, 3, 21);
+		} else {
+			leapMonth = 30;
+			jd = gregorianToJulianDay(era, year, 3, 22);
+		}
+		if (date.month === 1) return jd + date.day - 1;
+		jd += leapMonth + Math.min(date.month - 2, 5) * 31;
+		if (date.month >= 8) jd += (date.month - 7) * 30;
+		jd += date.day - 1;
+		return jd;
+	}
+	getDaysInMonth(date) {
+		if (date.month === 1 && isLeapYear(date.year + INDIAN_ERA_START)) return 31;
+		if (date.month >= 2 && date.month <= 6) return 31;
+		return 30;
+	}
+	getYearsInEra() {
+		return 9919;
+	}
+	getEras() {
+		return ["saka"];
+	}
+	balanceDate() {}
+};
+//#endregion
+export { IndianCalendar };

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

@@ -0,0 +1,55 @@
+import { CalendarDate } from "../CalendarDate.js";
+import { AnyCalendarDate, Calendar, CalendarIdentifier } from "../types.js";
+
+//#region src/date/calendars/IslamicCalendar.d.ts
+/**
+ * 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).
+ */
+declare class IslamicCivilCalendar implements Calendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getMonthsInYear(): number;
+  getDaysInYear(date: AnyCalendarDate): number;
+  getMaximumMonthsInYear(): number;
+  getMaximumDaysInMonth(): number;
+  getYearsInEra(): number;
+  getEras(): string[];
+}
+/**
+ * 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).
+ */
+declare class IslamicTabularCalendar extends IslamicCivilCalendar {
+  identifier: CalendarIdentifier;
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+}
+/**
+ * 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).
+ */
+declare class IslamicUmalquraCalendar extends IslamicCivilCalendar {
+  identifier: CalendarIdentifier;
+  constructor();
+  fromJulianDay(jd: number): CalendarDate;
+  toJulianDay(date: AnyCalendarDate): number;
+  getDaysInMonth(date: AnyCalendarDate): number;
+  getDaysInYear(date: AnyCalendarDate): number;
+}
+//#endregion
+export { IslamicCivilCalendar, IslamicTabularCalendar, IslamicUmalquraCalendar };