@hebcal/core 5.9.5 → 5.9.7

package/dist/index.cjs

@@ -1,32 +1,1894 @@
-/*! @hebcal/core v5.9.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/core v5.9.6, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 'use strict';
 
-var hdate = require('@hebcal/hdate');
-var noaa = require('@hebcal/noaa');
 require('temporal-polyfill/global');
 
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-const version = '5.9.5';
+const version = '5.9.6';
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/* eslint-disable @typescript-eslint/no-namespace, no-inner-declarations */
+/** @private */
+const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+/** @private */
+const monthLengths = [lengths, lengths.slice()];
+monthLengths[1][2] = 29;
+/**
+ * @private
+ */
+function mod$1(x, y) {
+    return x - y * Math.floor(x / y);
+}
+/**
+ * @private
+ */
+function quotient(x, y) {
+    return Math.floor(x / y);
+}
+/**
+ * @private
+ * @param abs - R.D. number of days
+ */
+function yearFromFixed(abs) {
+    const l0 = abs - 1;
+    const n400 = quotient(l0, 146097);
+    const d1 = mod$1(l0, 146097);
+    const n100 = quotient(d1, 36524);
+    const d2 = mod$1(d1, 36524);
+    const n4 = quotient(d2, 1461);
+    const d3 = mod$1(d2, 1461);
+    const n1 = quotient(d3, 365);
+    const year = 400 * n400 + 100 * n100 + 4 * n4 + n1;
+    return n100 !== 4 && n1 !== 4 ? year + 1 : year;
+}
+/*
+const ABS_14SEP1752 = 639797;
+const ABS_2SEP1752 = 639785;
+*/
+/*
+ * Formerly in namespace, now top-level
+ */
+/**
+ * Returns true if the Gregorian year is a leap year
+ * @param year Gregorian year
+ */
+function isGregLeapYear(year) {
+    return !(year % 4) && (!!(year % 100) || !(year % 400));
+}
+/**
+ * Number of days in the Gregorian month for given year
+ * @param month Gregorian month (1=January, 12=December)
+ * @param year Gregorian year
+ */
+function daysInGregMonth(month, year) {
+    // 1 based months
+    return monthLengths[+isGregLeapYear(year)][month];
+}
+/**
+ * Returns true if the object is a Javascript Date
+ */
+function isDate(obj) {
+    // eslint-disable-next-line no-prototype-builtins
+    return typeof obj === 'object' && Date.prototype.isPrototypeOf(obj);
+}
+/**
+ * @private
+ * @param year
+ * @param month (1-12)
+ * @param day (1-31)
+ */
+function toFixed(year, month, day) {
+    const py = year - 1;
+    return (365 * py +
+        quotient(py, 4) -
+        quotient(py, 100) +
+        quotient(py, 400) +
+        quotient(367 * month - 362, 12) +
+        (month <= 2 ? 0 : isGregLeapYear(year) ? -1 : -2) +
+        day);
+}
+/**
+ * Converts Gregorian date to absolute R.D. (Rata Die) days
+ * @param date Gregorian date
+ */
+function greg2abs(date) {
+    if (!isDate(date)) {
+        throw new TypeError(`not a Date: ${date}`);
+    }
+    else if (isNaN(date.getTime())) {
+        throw new RangeError('Invalid Date');
+    }
+    const abs = toFixed(date.getFullYear(), date.getMonth() + 1, date.getDate());
+    /*
+      if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
+        throw new RangeError(`Invalid Date: ${date}`);
+      }
+      */
+    return abs;
+}
+/**
+ * Converts from Rata Die (R.D. number) to Gregorian date.
+ * See the footnote on page 384 of ``Calendrical Calculations, Part II:
+ * Three Historical Calendars'' by E. M. Reingold,  N. Dershowitz, and S. M.
+ * Clamen, Software--Practice and Experience, Volume 23, Number 4
+ * (April, 1993), pages 383-404 for an explanation.
+ *
+ * Note that this function returns the daytime portion of the date.
+ * For example, the 15th of Cheshvan 5769 began at sundown on
+ * 12 November 2008 and continues through 13 November 2008. This
+ * function would return only the date 13 November 2008.
+ * @param abs - R.D. number of days
+ * @example
+ * const abs = hebrew2abs(5769, months.CHESHVAN, 15);
+ * const date = abs2greg(abs); // 13 November 2008
+ * const year = date.getFullYear(); // 2008
+ * const monthNum = date.getMonth() + 1; // 11
+ * const day = date.getDate(); // 13
+ */
+function abs2greg(abs) {
+    if (typeof abs !== 'number' || isNaN(abs)) {
+        throw new TypeError(`not a Number: ${abs}`);
+    }
+    abs = Math.trunc(abs);
+    /*
+      if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
+        throw new RangeError(`Invalid Date: ${abs}`);
+      }
+      */
+    const year = yearFromFixed(abs);
+    const priorDays = abs - toFixed(year, 1, 1);
+    const correction = abs < toFixed(year, 3, 1) ? 0 : isGregLeapYear(year) ? 1 : 2;
+    const month = quotient(12 * (priorDays + correction) + 373, 367);
+    const day = abs - toFixed(year, month, 1) + 1;
+    const dt = new Date(year, month - 1, day);
+    if (year < 100 && year >= 0) {
+        dt.setFullYear(year);
+    }
+    return dt;
+}
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+/**
+ * Gregorian date helper functions
+ */
+exports.greg = void 0;
+(function (greg) {
+})(exports.greg || (exports.greg = {}));
+exports.greg.abs2greg = abs2greg;
+exports.greg.daysInMonth = daysInGregMonth;
+exports.greg.greg2abs = greg2abs;
+exports.greg.isDate = isDate;
+exports.greg.isLeapYear = isGregLeapYear;
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*
+ * More minimal HDate
+ */
+const NISAN$4 = 1;
+const IYYAR$1 = 2;
+const SIVAN$1 = 3;
+const TAMUZ$1 = 4;
+const AV$1 = 5;
+const ELUL$1 = 6;
+const TISHREI$2 = 7;
+const CHESHVAN$1 = 8;
+const KISLEV$2 = 9;
+const TEVET$2 = 10;
+const SHVAT$1 = 11;
+const ADAR_I$2 = 12;
+const ADAR_II$2 = 13;
+/**
+ * Hebrew months of the year (NISAN=1, TISHREI=7)
+ * @readonly
+ * @enum {number}
+ */
+const months = {
+    /** Nissan / ניסן */
+    NISAN: NISAN$4,
+    /** Iyyar / אייר */
+    IYYAR: IYYAR$1,
+    /** Sivan / סיון */
+    SIVAN: SIVAN$1,
+    /** Tamuz (sometimes Tammuz) / תמוז */
+    TAMUZ: TAMUZ$1,
+    /** Av / אב */
+    AV: AV$1,
+    /** Elul / אלול */
+    ELUL: ELUL$1,
+    /** Tishrei / תִּשְׁרֵי */
+    TISHREI: TISHREI$2,
+    /** Cheshvan / חשון */
+    CHESHVAN: CHESHVAN$1,
+    /** Kislev / כסלו */
+    KISLEV: KISLEV$2,
+    /** Tevet / טבת */
+    TEVET: TEVET$2,
+    /** Sh'vat / שבט */
+    SHVAT: SHVAT$1,
+    /** Adar or Adar Rishon / אדר */
+    ADAR_I: ADAR_I$2,
+    /** Adar Sheini (only on leap years) / אדר ב׳ */
+    ADAR_II: ADAR_II$2,
+};
+const NISAN_STR = 'Nisan';
+const monthNames0 = [
+    '',
+    NISAN_STR,
+    'Iyyar',
+    'Sivan',
+    'Tamuz',
+    'Av',
+    'Elul',
+    'Tishrei',
+    'Cheshvan',
+    'Kislev',
+    'Tevet',
+    "Sh'vat",
+];
+/*
+ * Transliterations of Hebrew month names.
+ * Regular years are index 0 and leap years are index 1.
+ * @private
+ */
+const monthNames = [
+    [...monthNames0, 'Adar', NISAN_STR],
+    [...monthNames0, 'Adar I', 'Adar II', NISAN_STR],
+];
+const edCache = new Map();
+const EPOCH = -1373428;
+// Avg year length in the cycle (19 solar years with 235 lunar months)
+const AVG_HEBYEAR_DAYS = 365.24682220597794;
+/**
+ * @private
+ */
+function assertNumber(n, name) {
+    if (typeof n !== 'number' || isNaN(n)) {
+        throw new TypeError(`param '${name}' not a number: ${n}`);
+    }
+}
+/**
+ * Converts Hebrew date to R.D. (Rata Die) fixed days.
+ * R.D. 1 is the imaginary date Monday, January 1, 1 on the Gregorian
+ * Calendar.
+ * @param year Hebrew year
+ * @param month Hebrew month
+ * @param day Hebrew date (1-30)
+ * @example
+ * const abs = hebrew2abs(5769, months.CHESHVAN, 15);
+ */
+function hebrew2abs(year, month, day) {
+    assertNumber(year, 'year');
+    assertNumber(month, 'month');
+    assertNumber(day, 'day');
+    if (year < 1) {
+        throw new RangeError(`hebrew2abs: invalid year ${year}`);
+    }
+    let tempabs = day;
+    if (month < TISHREI$2) {
+        for (let m = TISHREI$2; m <= monthsInYear(year); m++) {
+            tempabs += daysInMonth(m, year);
+        }
+        for (let m = NISAN$4; m < month; m++) {
+            tempabs += daysInMonth(m, year);
+        }
+    }
+    else {
+        for (let m = TISHREI$2; m < month; m++) {
+            tempabs += daysInMonth(m, year);
+        }
+    }
+    return EPOCH + elapsedDays(year) + tempabs - 1;
+}
+/**
+ * @private
+ */
+function newYear(year) {
+    return EPOCH + elapsedDays(year);
+}
+/**
+ * Converts absolute R.D. days to Hebrew date
+ * @param abs absolute R.D. days
+ */
+function abs2hebrew(abs) {
+    assertNumber(abs, 'abs');
+    abs = Math.trunc(abs);
+    if (abs <= EPOCH) {
+        throw new RangeError(`abs2hebrew: ${abs} is before epoch`);
+    }
+    // first, quickly approximate year
+    let year = Math.floor((abs - EPOCH) / AVG_HEBYEAR_DAYS);
+    while (newYear(year) <= abs) {
+        ++year;
+    }
+    --year;
+    let month = abs < hebrew2abs(year, 1, 1) ? 7 : 1;
+    while (abs > hebrew2abs(year, month, daysInMonth(month, year))) {
+        ++month;
+    }
+    const day = 1 + abs - hebrew2abs(year, month, 1);
+    return { yy: year, mm: month, dd: day };
+}
+/**
+ * Returns true if Hebrew year is a leap year
+ * @param year Hebrew year
+ */
+function isLeapYear(year) {
+    return (1 + year * 7) % 19 < 7;
+}
+/**
+ * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
+ * @param year Hebrew year
+ */
+function monthsInYear(year) {
+    return 12 + +isLeapYear(year); // boolean is cast to 1 or 0
+}
+/**
+ * Number of days in Hebrew month in a given year (29 or 30)
+ * @param month Hebrew month (e.g. months.TISHREI)
+ * @param year Hebrew year
+ */
+function daysInMonth(month, year) {
+    switch (month) {
+        case IYYAR$1:
+        case TAMUZ$1:
+        case ELUL$1:
+        case TEVET$2:
+        case ADAR_II$2:
+            return 29;
+    }
+    if ((month === ADAR_I$2 && !isLeapYear(year)) ||
+        (month === CHESHVAN$1 && !longCheshvan(year)) ||
+        (month === KISLEV$2 && shortKislev(year))) {
+        return 29;
+    }
+    else {
+        return 30;
+    }
+}
+/**
+ * Returns a transliterated string name of Hebrew month in year,
+ * for example 'Elul' or 'Cheshvan'.
+ * @param month Hebrew month (e.g. months.TISHREI)
+ * @param year Hebrew year
+ */
+function getMonthName(month, year) {
+    assertNumber(month, 'month');
+    assertNumber(year, 'year');
+    if (month < 1 || month > 14) {
+        throw new TypeError(`bad monthNum: ${month}`);
+    }
+    return monthNames[+isLeapYear(year)][month];
+}
+/**
+ * Days from sunday prior to start of Hebrew calendar to mean
+ * conjunction of Tishrei in Hebrew YEAR
+ * @param year Hebrew year
+ */
+function elapsedDays(year) {
+    const n = edCache.get(year);
+    if (typeof n === 'number') {
+        return n;
+    }
+    const elapsed = elapsedDays0(year);
+    edCache.set(year, elapsed);
+    return elapsed;
+}
+/**
+ * Days from sunday prior to start of Hebrew calendar to mean
+ * conjunction of Tishrei in Hebrew YEAR
+ * @private
+ * @param year Hebrew year
+ */
+function elapsedDays0(year) {
+    const prevYear = year - 1;
+    const mElapsed = 235 * Math.floor(prevYear / 19) + // Months in complete 19 year lunar (Metonic) cycles so far
+        12 * (prevYear % 19) + // Regular months in this cycle
+        Math.floor(((prevYear % 19) * 7 + 1) / 19); // Leap months this cycle
+    const pElapsed = 204 + 793 * (mElapsed % 1080);
+    const hElapsed = 5 +
+        12 * mElapsed +
+        793 * Math.floor(mElapsed / 1080) +
+        Math.floor(pElapsed / 1080);
+    const parts = (pElapsed % 1080) + 1080 * (hElapsed % 24);
+    const day = 1 + 29 * mElapsed + Math.floor(hElapsed / 24);
+    let altDay = day;
+    if (parts >= 19440 ||
+        (2 === day % 7 && parts >= 9924 && !isLeapYear(year)) ||
+        (1 === day % 7 && parts >= 16789 && isLeapYear(prevYear))) {
+        altDay++;
+    }
+    if (altDay % 7 === 0 || altDay % 7 === 3 || altDay % 7 === 5) {
+        return altDay + 1;
+    }
+    else {
+        return altDay;
+    }
+}
+/**
+ * Number of days in the hebrew YEAR.
+ * A common Hebrew calendar year can have a length of 353, 354 or 355 days
+ * A leap Hebrew calendar year can have a length of 383, 384 or 385 days
+ * @param year Hebrew year
+ */
+function daysInYear(year) {
+    return elapsedDays(year + 1) - elapsedDays(year);
+}
+/**
+ * true if Cheshvan is long in Hebrew year
+ * @param year Hebrew year
+ */
+function longCheshvan(year) {
+    return daysInYear(year) % 10 === 5;
+}
+/**
+ * true if Kislev is short in Hebrew year
+ * @param year Hebrew year
+ */
+function shortKislev(year) {
+    return daysInYear(year) % 10 === 3;
+}
+/**
+ * Converts Hebrew month string name to numeric
+ * @param monthName monthName
+ */
+function monthFromName(monthName) {
+    if (typeof monthName === 'number') {
+        if (isNaN(monthName) || monthName < 1 || monthName > 14) {
+            throw new RangeError(`bad monthName: ${monthName}`);
+        }
+        return monthName;
+    }
+    let c = monthName.trim().toLowerCase();
+    // If Hebrew month starts with a bet (for example `בתמוז`) then ignore it
+    if (c[0] === 'ב') {
+        c = c.substring(1);
+    }
+    /*
+    the Hebrew months are unique to their second letter
+    N         Nisan  (November?)
+    I         Iyyar
+    E        Elul
+    C        Cheshvan
+    K        Kislev
+    1        1Adar
+    2        2Adar
+    Si Sh     Sivan, Shvat
+    Ta Ti Te Tamuz, Tishrei, Tevet
+    Av Ad    Av, Adar
+  
+    אב אד אי אל   אב אדר אייר אלול
+    ח            חשון
+    ט            טבת
+    כ            כסלו
+    נ            ניסן
+    ס            סיון
+    ש            שבט
+    תמ תש        תמוז תשרי
+    */
+    switch (c[0]) {
+        case 'n':
+        case 'נ':
+            if (c[1] === 'o') {
+                break; /* this catches "november" */
+            }
+            return NISAN$4;
+        case 'i':
+            return IYYAR$1;
+        case 'e':
+            return ELUL$1;
+        case 'c':
+        case 'ח':
+            return CHESHVAN$1;
+        case 'k':
+        case 'כ':
+            return KISLEV$2;
+        case 's':
+            switch (c[1]) {
+                case 'i':
+                    return SIVAN$1;
+                case 'h':
+                    return SHVAT$1;
+            }
+            break;
+        case 't':
+            switch (c[1]) {
+                case 'a':
+                    return TAMUZ$1;
+                case 'i':
+                    return TISHREI$2;
+                case 'e':
+                    return TEVET$2;
+            }
+            break;
+        case 'a':
+            switch (c[1]) {
+                case 'v':
+                    return AV$1;
+                case 'd':
+                    if (/(1|[^i]i|a|א)$/i.test(monthName)) {
+                        return ADAR_I$2;
+                    }
+                    return ADAR_II$2; // else assume sheini
+            }
+            break;
+        case 'ס':
+            return SIVAN$1;
+        case 'ט':
+            return TEVET$2;
+        case 'ש':
+            return SHVAT$1;
+        case 'א':
+            switch (c[1]) {
+                case 'ב':
+                    return AV$1;
+                case 'ד':
+                    if (/(1|[^i]i|a|א)$/i.test(monthName)) {
+                        return ADAR_I$2;
+                    }
+                    return ADAR_II$2; // else assume sheini
+                case 'י':
+                    return IYYAR$1;
+                case 'ל':
+                    return ELUL$1;
+            }
+            break;
+        case 'ת':
+            switch (c[1]) {
+                case 'מ':
+                    return TAMUZ$1;
+                case 'ש':
+                    return TISHREI$2;
+            }
+            break;
+    }
+    throw new RangeError(`bad monthName: ${monthName}`);
+}
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+
+const NISAN$3 = months.NISAN;
+const CHESHVAN = months.CHESHVAN;
+const KISLEV$1 = months.KISLEV;
+const TEVET$1 = months.TEVET;
+const SHVAT = months.SHVAT;
+const ADAR_I$1 = months.ADAR_I;
+const ADAR_II$1 = months.ADAR_II;
+/**
+ * Returns true if the object is a SimpleHebrewDate
+ * @private
+ */
+function isSimpleHebrewDate$1(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        typeof obj.yy === 'number' &&
+        typeof obj.mm === 'number' &&
+        typeof obj.dd === 'number');
+}
+/**
+ * @private
+ */
+function toSimpleHebrewDate(obj) {
+    if (isSimpleHebrewDate$1(obj)) {
+        return obj;
+    }
+    else if (isDate(obj)) {
+        const abs = greg2abs(obj);
+        return abs2hebrew(abs);
+    }
+    else {
+        // typeof obj === 'number'
+        return abs2hebrew(obj);
+    }
+}
+function getYahrzeitHD(hyear, date) {
+    let hDeath = toSimpleHebrewDate(date);
+    if (hyear <= hDeath.yy) {
+        // Hebrew year ${hyear} occurs on or before original date in ${hDeath.yy}
+        return undefined;
+    }
+    if (hDeath.mm === CHESHVAN &&
+        hDeath.dd === 30 &&
+        !longCheshvan(hDeath.yy + 1)) {
+        // If it's Heshvan 30 it depends on the first anniversary;
+        // if that was not Heshvan 30, use the day before Kislev 1.
+        hDeath = abs2hebrew(hebrew2abs(hyear, KISLEV$1, 1) - 1);
+    }
+    else if (hDeath.mm === KISLEV$1 &&
+        hDeath.dd === 30 &&
+        shortKislev(hDeath.yy + 1)) {
+        // If it's Kislev 30 it depends on the first anniversary;
+        // if that was not Kislev 30, use the day before Teveth 1.
+        hDeath = abs2hebrew(hebrew2abs(hyear, TEVET$1, 1) - 1);
+    }
+    else if (hDeath.mm === ADAR_II$1) {
+        // If it's Adar II, use the same day in last month of year (Adar or Adar II).
+        hDeath.mm = monthsInYear(hyear);
+    }
+    else if (hDeath.mm === ADAR_I$1 && hDeath.dd === 30 && !isLeapYear(hyear)) {
+        // If it's the 30th in Adar I and year is not a leap year
+        // (so Adar has only 29 days), use the last day in Shevat.
+        hDeath.dd = 30;
+        hDeath.mm = SHVAT;
+    }
+    // In all other cases, use the normal anniversary of the date of death.
+    // advance day to rosh chodesh if needed
+    if (hDeath.mm === CHESHVAN && hDeath.dd === 30 && !longCheshvan(hyear)) {
+        hDeath.mm = KISLEV$1;
+        hDeath.dd = 1;
+    }
+    else if (hDeath.mm === KISLEV$1 && hDeath.dd === 30 && shortKislev(hyear)) {
+        hDeath.mm = TEVET$1;
+        hDeath.dd = 1;
+    }
+    hDeath.yy = hyear;
+    return hDeath;
+}
+function getBirthdayHD(hyear, date) {
+    const orig = toSimpleHebrewDate(date);
+    const origYear = orig.yy;
+    if (hyear === origYear) {
+        return orig;
+    }
+    else if (hyear < origYear) {
+        // Hebrew year ${hyear} occurs on or before original date in ${origYear}
+        return undefined;
+    }
+    const isOrigLeap = isLeapYear(origYear);
+    let month = orig.mm;
+    let day = orig.dd;
+    if ((month === ADAR_I$1 && !isOrigLeap) || (month === ADAR_II$1 && isOrigLeap)) {
+        month = monthsInYear(hyear);
+    }
+    else if (month === CHESHVAN && day === 30 && !longCheshvan(hyear)) {
+        month = KISLEV$1;
+        day = 1;
+    }
+    else if (month === KISLEV$1 && day === 30 && shortKislev(hyear)) {
+        month = TEVET$1;
+        day = 1;
+    }
+    else if (month === ADAR_I$1 &&
+        day === 30 &&
+        isOrigLeap &&
+        !isLeapYear(hyear)) {
+        month = NISAN$3;
+        day = 1;
+    }
+    return { yy: hyear, mm: month, dd: day };
+}
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+const GERESH = '׳';
+const GERSHAYIM = '״';
+const heb2num = {
+    א: 1,
+    ב: 2,
+    ג: 3,
+    ד: 4,
+    ה: 5,
+    ו: 6,
+    ז: 7,
+    ח: 8,
+    ט: 9,
+    י: 10,
+    כ: 20,
+    ל: 30,
+    מ: 40,
+    נ: 50,
+    ס: 60,
+    ע: 70,
+    פ: 80,
+    צ: 90,
+    ק: 100,
+    ר: 200,
+    ש: 300,
+    ת: 400,
+};
+const num2heb = {};
+for (const [key, val] of Object.entries(heb2num)) {
+    num2heb[val] = key;
+}
+function num2digits(num) {
+    const digits = [];
+    while (num > 0) {
+        if (num === 15 || num === 16) {
+            digits.push(9);
+            digits.push(num - 9);
+            break;
+        }
+        let incr = 100;
+        let i;
+        for (i = 400; i > num; i -= incr) {
+            if (i === incr) {
+                incr = incr / 10;
+            }
+        }
+        digits.push(i);
+        num -= i;
+    }
+    return digits;
+}
+/**
+ * Converts a numerical value to a string of Hebrew letters.
+ *
+ * When specifying years of the Hebrew calendar in the present millennium,
+ * we omit the thousands (which is presently 5 [ה]).
+ * @example
+ * gematriya(5774) // 'תשע״ד' - cropped to 774
+ * gematriya(25) // 'כ״ה'
+ * gematriya(60) // 'ס׳'
+ * gematriya(3761) // 'ג׳תשס״א'
+ * gematriya(1123) // 'א׳קכ״ג'
+ */
+function gematriya(num) {
+    const num1 = parseInt(num, 10);
+    if (!num1 || num1 < 0) {
+        throw new TypeError(`invalid number: ${num}`);
+    }
+    let str = '';
+    const thousands = Math.floor(num1 / 1000);
+    if (thousands > 0 && thousands !== 5) {
+        const tdigits = num2digits(thousands);
+        for (const tdig of tdigits) {
+            str += num2heb[tdig];
+        }
+        str += GERESH;
+    }
+    const digits = num2digits(num1 % 1000);
+    if (digits.length === 1) {
+        return str + num2heb[digits[0]] + GERESH;
+    }
+    for (let i = 0; i < digits.length; i++) {
+        if (i + 1 === digits.length) {
+            str += GERSHAYIM;
+        }
+        str += num2heb[digits[i]];
+    }
+    return str;
+}
+/**
+ * Converts a string of Hebrew letters to a numerical value.
+ *
+ * Only considers the value of Hebrew letters `א` through `ת`.
+ * Ignores final Hebrew letters such as `ך` (kaf sofit) or `ם` (mem sofit)
+ * and vowels (nekudot).
+ */
+function gematriyaStrToNum(str) {
+    let num = 0;
+    const gereshIdx = str.indexOf(GERESH);
+    if (gereshIdx !== -1 && gereshIdx !== str.length - 1) {
+        const thousands = str.substring(0, gereshIdx);
+        num += gematriyaStrToNum(thousands) * 1000;
+        str = str.substring(gereshIdx);
+    }
+    for (const ch of str) {
+        const n = heb2num[ch];
+        if (typeof n === 'number') {
+            num += n;
+        }
+    }
+    return num;
+}
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+
+/**
+ * Calculates the molad for a Hebrew month
+ */
+function molad(year, month) {
+    let m_adj = month - 7;
+    if (m_adj < 0) {
+        m_adj += monthsInYear(year);
+    }
+    const mElapsed = 235 * Math.floor((year - 1) / 19) + // Months in complete 19 year lunar (Metonic) cycles so far
+        12 * ((year - 1) % 19) + // Regular months in this cycle
+        Math.floor((7 * ((year - 1) % 19) + 1) / 19) + // Leap months this cycle
+        m_adj; // add elapsed months till the start of the molad of the month
+    const pElapsed = 204 + Math.floor(793 * (mElapsed % 1080));
+    const hElapsed = 5 +
+        12 * mElapsed +
+        793 * Math.floor(mElapsed / 1080) +
+        Math.floor(pElapsed / 1080) -
+        6;
+    const parts = (pElapsed % 1080) + 1080 * (hElapsed % 24);
+    const chalakim = parts % 1080;
+    const day = 1 + 29 * mElapsed + Math.floor(hElapsed / 24);
+    return {
+        year,
+        month,
+        dayOfWeek: day % 7,
+        hour: hElapsed % 24,
+        minutes: Math.floor(chalakim / 18),
+        chalakim: chalakim % 18,
+    };
+}
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/**
+ * Formats a number with leading zeros so the resulting string is 4 digits long.
+ * Similar to `string.padStart(4, '0')` but will also format
+ * negative numbers similar to how the JavaScript date formats
+ * negative year numbers (e.g. `-37` is formatted as `-000037`).
+ */
+function pad4(num) {
+    if (num < 0) {
+        return '-00' + pad4(-num);
+    }
+    else if (num < 10) {
+        return '000' + num;
+    }
+    else if (num < 100) {
+        return '00' + num;
+    }
+    else if (num < 1000) {
+        return '0' + num;
+    }
+    return String(num);
+}
+/**
+ * Formats a number with leading zeros so the resulting string is 2 digits long.
+ * Similar to `string.padStart(2, '0')`.
+ */
+function pad2(num) {
+    if (num >= 0 && num < 10) {
+        return '0' + num;
+    }
+    return String(num);
+}
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+
+const _formatters = new Map();
+/**
+ * @private
+ */
+function getFormatter$1(tzid) {
+    const fmt = _formatters.get(tzid);
+    if (fmt)
+        return fmt;
+    const f = new Intl.DateTimeFormat('en-US', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+        timeZone: tzid,
+    });
+    _formatters.set(tzid, f);
+    return f;
+}
+const dateFormatRegex = /^(\d+).(\d+).(\d+),?\s+(\d+).(\d+).(\d+)/;
+/**
+ * Returns a string similar to `Date.toISOString()` but in the
+ * timezone `tzid`. Contrary to the typical meaning of `Z` at the end
+ * of the string, this is not actually a UTC date.
+ */
+function getPseudoISO(tzid, date) {
+    const str = getFormatter$1(tzid).format(date);
+    const m = dateFormatRegex.exec(str);
+    if (m === null) {
+        throw new Error(`Unable to parse formatted string: ${str}`);
+    }
+    let hour = m[4];
+    if (hour === '24') {
+        hour = '00';
+    }
+    m[3] = pad4(parseInt(m[3], 10));
+    return `${m[3]}-${m[1]}-${m[2]}T${hour}:${m[5]}:${m[6]}Z`;
+}
+/**
+ * Returns number of minutes `tzid` is offset from UTC on date `date`.
+ */
+function getTimezoneOffset(tzid, date) {
+    const utcStr = getPseudoISO('UTC', date);
+    const localStr = getPseudoISO(tzid, date);
+    const diffMs = new Date(utcStr).getTime() - new Date(localStr).getTime();
+    return Math.ceil(diffMs / 1000 / 60);
+}
+/**
+ * Returns YYYY-MM-DD in the local timezone
+ */
+function isoDateString(dt) {
+    return (pad4(dt.getFullYear()) +
+        '-' +
+        pad2(dt.getMonth() + 1) +
+        '-' +
+        pad2(dt.getDate()));
+}
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+var poAshkenazi$1 = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "en_CA@ashkenazi" }, "contexts": { "": { "Tevet": ["Teves"] } } };
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+var poHe$1 = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "he" }, "contexts": { "": { "Adar": ["אַדָר"], "Adar I": ["אַדָר א׳"], "Adar II": ["אַדָר ב׳"], "Av": ["אָב"], "Cheshvan": ["חֶשְׁוָן"], "Elul": ["אֱלוּל"], "Iyyar": ["אִיָיר"], "Kislev": ["כִּסְלֵו"], "Nisan": ["נִיסָן"], "Sh'vat": ["שְׁבָט"], "Sivan": ["סִיוָן"], "Tamuz": ["תַּמּוּז"], "Tevet": ["טֵבֵת"], "Tishrei": ["תִּשְׁרֵי"] } } };
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+
+const noopLocale = {
+    headers: { 'plural-forms': 'nplurals=2; plural=(n!=1);' },
+    contexts: { '': {} },
+};
+const alias = {
+    h: 'he',
+    a: 'ashkenazi',
+    s: 'en',
+    '': 'en',
+};
+/** @private */
+const locales = new Map();
+/** @private */
+let activeLocale;
+/** @private */
+let activeName;
+/** @private */
+function getEnOrdinal(n) {
+    const s = ['th', 'st', 'nd', 'rd'];
+    const v = n % 100;
+    return n + (s[(v - 20) % 10] || s[v] || s[0]);
+}
+/** @private */
+function checkLocale(locale) {
+    if (typeof locale !== 'string') {
+        throw new TypeError(`Invalid locale name: ${locale}`);
+    }
+    return locale.toLowerCase();
+}
+/** @private */
+function getExistingLocale(locale) {
+    const locale1 = checkLocale(locale);
+    const loc = locales.get(locale1);
+    if (!loc) {
+        throw new RangeError(`Locale '${locale}' not found`);
+    }
+    return loc;
+}
+/**
+ * A locale in Hebcal is used for translations/transliterations of
+ * holidays. `@hebcal/hdate` supports four locales by default
+ * * `en` - default, Sephardic transliterations (e.g. "Shabbat")
+ * * `ashkenazi` - Ashkenazi transliterations (e.g. "Shabbos")
+ * * `he` - Hebrew (e.g. "שַׁבָּת")
+ * * `he-x-NoNikud` - Hebrew without nikud (e.g. "שבת")
+ */
+class Locale {
+    /**
+     * Returns translation only if `locale` offers a non-empty translation for `id`.
+     * Otherwise, returns `undefined`.
+     * @param id Message ID to translate
+     * @param [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
+     */
+    static lookupTranslation(id, locale) {
+        const loc = (typeof locale === 'string' && locales.get(locale.toLowerCase())) ||
+            activeLocale;
+        const array = loc[id];
+        if ((array === null || array === void 0 ? void 0 : array.length) && array[0].length) {
+            return array[0];
+        }
+        return undefined;
+    }
+    /**
+     * By default, if no translation was found, returns `id`.
+     * @param id Message ID to translate
+     * @param [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
+     */
+    static gettext(id, locale) {
+        const text = this.lookupTranslation(id, locale);
+        if (typeof text === 'undefined') {
+            return id;
+        }
+        return text;
+    }
+    /**
+     * Register locale translations.
+     * @param locale Locale name (i.e.: `'he'`, `'fr'`)
+     * @param data parsed data from a `.po` file.
+     */
+    static addLocale(locale, data) {
+        locale = checkLocale(locale);
+        if (typeof data.contexts !== 'object' ||
+            typeof data.contexts[''] !== 'object') {
+            throw new TypeError(`Locale '${locale}' invalid compact format`);
+        }
+        locales.set(locale, data.contexts['']);
+    }
+    /**
+     * Adds a translation to `locale`, replacing any previous translation.
+     * @param locale Locale name (i.e: `'he'`, `'fr'`).
+     * @param id Message ID to translate
+     * @param translation Translation text
+     */
+    static addTranslation(locale, id, translation) {
+        const loc = getExistingLocale(locale);
+        if (typeof id !== 'string' || id.length === 0) {
+            throw new TypeError(`Invalid id string: ${id}`);
+        }
+        const isArray = Array.isArray(translation);
+        if (isArray) {
+            const t0 = translation[0];
+            if (typeof t0 !== 'string' || t0.length === 0) {
+                throw new TypeError(`Invalid translation array: ${translation}`);
+            }
+        }
+        else if (typeof translation !== 'string') {
+            throw new TypeError(`Invalid translation string: ${translation}`);
+        }
+        loc[id] = isArray ? translation : [translation];
+    }
+    /**
+     * Adds multiple translations to `locale`, replacing any previous translations.
+     * @param locale Locale name (i.e: `'he'`, `'fr'`).
+     * @param data parsed data from a `.po` file.
+     */
+    static addTranslations(locale, data) {
+        const loc = getExistingLocale(locale);
+        if (typeof data.contexts !== 'object' ||
+            typeof data.contexts[''] !== 'object') {
+            throw new TypeError(`Locale '${locale}' invalid compact format`);
+        }
+        const ctx = data.contexts[''];
+        Object.assign(loc, ctx);
+    }
+    /**
+     * Activates a locale. Throws an error if the locale has not been previously added.
+     * After setting the locale to be used, all strings marked for translations
+     * will be represented by the corresponding translation in the specified locale.
+     * @param locale Locale name (i.e: `'he'`, `'fr'`)
+     * @deprecated
+     */
+    static useLocale(locale) {
+        const locale0 = checkLocale(locale);
+        const obj = getExistingLocale(locale0);
+        activeName = alias[locale0] || locale0;
+        activeLocale = obj;
+        return activeLocale;
+    }
+    /**
+     * Returns the name of the active locale (i.e. 'he', 'ashkenazi', 'fr')
+     * @deprecated
+     */
+    static getLocaleName() {
+        return activeName;
+    }
+    /**
+     * Returns the names of registered locales
+     */
+    static getLocaleNames() {
+        const keys = Array.from(locales.keys());
+        return keys.sort((a, b) => a.localeCompare(b));
+    }
+    /**
+     * Renders a number in ordinal, such as 1st, 2nd or 3rd
+     * @param [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
+     */
+    static ordinal(n, locale) {
+        const locale1 = locale === null || locale === void 0 ? void 0 : locale.toLowerCase();
+        const locale0 = locale1 || activeName;
+        if (!locale0) {
+            return getEnOrdinal(n);
+        }
+        switch (locale0) {
+            case 'en':
+            case 's':
+            case 'a':
+                return getEnOrdinal(n);
+            case 'es':
+                return n + 'º';
+            case 'h':
+            case 'he':
+            case 'he-x-nonikud':
+                return String(n);
+        }
+        if (locale0.startsWith('ashkenazi')) {
+            return getEnOrdinal(n);
+        }
+        return n + '.';
+    }
+    /**
+     * Removes nekudot from Hebrew string
+     */
+    static hebrewStripNikkud(str) {
+        return str.replace(/[\u0590-\u05bd]/g, '').replace(/[\u05bf-\u05c7]/g, '');
+    }
+}
+Locale.addLocale('en', noopLocale);
+Locale.addLocale('s', noopLocale);
+Locale.addLocale('', noopLocale);
+Locale.useLocale('en');
+/* Ashkenazic transliterations */
+Locale.addLocale('ashkenazi', poAshkenazi$1);
+Locale.addLocale('a', poAshkenazi$1);
+/* Hebrew with nikkud */
+Locale.addLocale('he', poHe$1);
+Locale.addLocale('h', poHe$1);
+/* Hebrew without nikkud */
+const heStrs$1 = poHe$1.contexts[''];
+const heNoNikud$1 = {};
+for (const [key, val] of Object.entries(heStrs$1)) {
+    heNoNikud$1[key] = [Locale.hebrewStripNikkud(val[0])];
+}
+const poHeNoNikud$1 = {
+    headers: poHe$1.headers,
+    contexts: { '': heNoNikud$1 },
+};
+Locale.addLocale('he-x-NoNikud', poHeNoNikud$1);
+
+/*! @hebcal/hdate v0.14.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+
+/*
+    Hebcal - A Jewish Calendar Generator
+    Copyright (c) 1994-2020 Danny Sadinoff
+    Portions copyright Eyal Schachter and Michael J. Radwin
+
+    https://github.com/hebcal/hebcal-es6
+
+    This program is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 2
+    of the License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+function mod(x, y) {
+    return x - y * Math.floor(x / y);
+}
+function isSimpleHebrewDate(obj) {
+    return obj.yy !== undefined;
+}
+const UNITS_DAY = 'day';
+const UNITS_WEEK = 'week';
+const UNITS_MONTH = 'month';
+const UNITS_YEAR = 'year';
+/**
+ * A `HDate` represents a Hebrew calendar date.
+ *
+ * An instance of this class encapsulates a date in the Hebrew calendar system.
+ * It consists of a year, month, and day, without any associated time or location data.
+ * The Hebrew calendar is a lunisolar calendar, meaning it is based on both lunar and solar cycles.
+ *
+ * A Hebrew date internally stores three numbers:
+ * - year: The Hebrew year (1-9999). Counted from the traditional Hebrew date of creation (3761 BCE in the Gregorian calendar)
+ * - month: The Hebrew month (1-13). Month 1 is Nisan, month 7 is Tishrei. There are 12 months in a regular year and 13 months in a leap year.
+ * - day: The day of the month (1-30)
+ *
+ * This class uses Rata Die to convert between the Hebrew and Gregorian calendars.
+ *
+ * To calculate times of day, use `Zmanim` class from `@hebcal/core`
+ * @see {@link https://en.wikipedia.org/wiki/Rata_Die | Rata Die}
+ * @see {@link https://hebcal.github.io/api/core/classes/Zmanim.html | Zmanim}
+ */
+class HDate {
+    /**
+     * Create a Hebrew date. There are 3 basic forms for the `HDate()` constructor.
+     *
+     * 1. No parameters - represents the current Hebrew date at time of instantiation
+     * 2. One parameter
+     *    * `Date` - represents the Hebrew date corresponding to the Gregorian date using
+     *       local time. Hours, minutes, seconds and milliseconds are ignored.
+     *    * `HDate` - clones a copy of the given Hebrew date
+     *    * `number` - Converts absolute R.D. days to Hebrew date.
+     *       R.D. 1 == the imaginary date January 1, 1 (Gregorian)
+     * 3. Three parameters: Hebrew day, Hebrew month, Hebrew year. Hebrew day should
+     *    be a number between 1-30, Hebrew month can be a number or string, and
+     *    Hebrew year is always a number.
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     *
+     * const hd1 = new HDate();
+     * const hd2 = new HDate(new Date(2008, 10, 13));
+     * const hd3 = new HDate(15, 'Cheshvan', 5769);
+     * const hd4 = new HDate(15, months.CHESHVAN, 5769);
+     * const hd5 = new HDate(733359); // ==> 15 Cheshvan 5769
+     * const monthName = 'אייר';
+     * const hd6 = new HDate(5, monthName, 5773);
+     * @param [day] - Day of month (1-30) if a `number`.
+     *   If a `Date` is specified, represents the Hebrew date corresponding to the
+     *   Gregorian date using local time.
+     *   If an `HDate` is specified, clones a copy of the given Hebrew date.
+     * @param [month] - Hebrew month of year (1=NISAN, 7=TISHREI)
+     * @param [year] - Hebrew year
+     */
+    constructor(day, month, year) {
+        if (arguments.length === 2 || arguments.length > 3) {
+            throw new TypeError('HDate constructor requires 0, 1 or 3 arguments');
+        }
+        if (arguments.length === 3) {
+            // Hebrew day, Hebrew month, Hebrew year
+            this.dd = this.mm = 1;
+            const yy = typeof year === 'string' ? parseInt(year, 10) : year;
+            if (isNaN(yy)) {
+                throw new TypeError(`HDate called with bad year: ${year}`);
+            }
+            this.yy = yy;
+            setMonth(this, month); // will throw if we can't parse
+            const dd = typeof day === 'string' ? parseInt(day, 10) : day;
+            if (isNaN(dd)) {
+                throw new TypeError(`HDate called with bad day: ${day}`);
+            }
+            setDate(this, dd);
+        }
+        else {
+            // 0 arguments
+            if (typeof day === 'undefined' || day === null) {
+                day = new Date();
+            }
+            // 1 argument
+            const abs0 = typeof day === 'number' && !isNaN(day)
+                ? day
+                : isDate(day)
+                    ? greg2abs(day)
+                    : isSimpleHebrewDate(day)
+                        ? day
+                        : null;
+            if (abs0 === null) {
+                throw new TypeError(`HDate called with bad arg: ${day}`);
+            }
+            const isNumber = typeof abs0 === 'number';
+            const d = isNumber ? abs2hebrew(abs0) : abs0;
+            this.yy = d.yy;
+            this.mm = d.mm;
+            this.dd = d.dd;
+            if (isNumber) {
+                this.rd = abs0;
+            }
+        }
+    }
+    /**
+     * Returns the Hebrew year of this Hebrew date
+     * @returns an integer >= 1
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getFullYear(); // 5769
+     */
+    getFullYear() {
+        return this.yy;
+    }
+    /**
+     * Returns `true` if this Hebrew date occurs during a Hebrew leap year
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.isLeapYear(); // false
+     */
+    isLeapYear() {
+        return isLeapYear(this.yy);
+    }
+    /**
+     * Returns the Hebrew month (1=NISAN, 7=TISHREI) of this Hebrew date
+     * @returns an integer 1-13
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getMonth(); // 8
+     */
+    getMonth() {
+        return this.mm;
+    }
+    /**
+     * The Tishrei-based month of this Hebrew date. 1 is Tishrei, 7 is Nisan, 13 is Elul in a leap year
+     * @returns an integer 1-13
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getTishreiMonth(); // 2
+     */
+    getTishreiMonth() {
+        const nummonths = monthsInYear(this.getFullYear());
+        return (this.getMonth() + nummonths - 6) % nummonths || nummonths;
+    }
+    /**
+     * Number of days in the month of this Hebrew date (29 or 30)
+     * @returns an integer 29-30
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.daysInMonth(); // 29
+     */
+    daysInMonth() {
+        return daysInMonth(this.getMonth(), this.getFullYear());
+    }
+    /**
+     * Gets the day within the month (1-30)
+     * @returns an integer 1-30
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getDate(); // 15
+     */
+    getDate() {
+        return this.dd;
+    }
+    /**
+     * Returns the day of the week for this Hebrew date,
+     * where 0 represents Sunday, 1 represents Monday, 6 represents Saturday.
+     *
+     * For the day of the month, see `getDate()`
+     * @returns an integer 0-6
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getDate(); // 4
+     */
+    getDay() {
+        return mod(this.abs(), 7);
+    }
+    /**
+     * Converts this Hebrew date to the corresponding Gregorian date.
+     *
+     * The returned `Date` object will be in the local (i.e. host system) time zone.
+     * Hours, minutes, seconds and milliseconds will all be zero.
+     *
+     * Note that this function returns the daytime portion of the date.
+     * For example, the 15th of Cheshvan 5769 began at sundown on
+     * 12 November 2008 and continues through 13 November 2008. This
+     * function would return only the date 13 November 2008.
+     * @example
+     * const hd = new HDate(15, 'Cheshvan', 5769);
+     * const date = hd.greg(); // 13 November 2008
+     * const year = date.getFullYear(); // 2008
+     * const monthNum = date.getMonth() + 1; // 11
+     * const day = date.getDate(); // 13
+     */
+    greg() {
+        return abs2greg(this.abs());
+    }
+    /**
+     * Converts from Hebrew date representation to R.D. (Rata Die) fixed days.
+     * R.D. 1 is the imaginary date Monday, January 1, 1 (Gregorian).
+     * Note also that R.D. = Julian Date − 1,721,424.5
+     * @see {@link https://en.wikipedia.org/wiki/Rata_Die | Rata Die}
+     * @example
+     * const hd = new HDate(15, 'Cheshvan', 5769);
+     * hd.abs(); // 733359
+     */
+    abs() {
+        if (typeof this.rd !== 'number') {
+            this.rd = hebrew2abs(this.yy, this.mm, this.dd);
+        }
+        return this.rd;
+    }
+    /**
+     * Converts Hebrew date to R.D. (Rata Die) fixed days.
+     * R.D. 1 is the imaginary date Monday, January 1, 1 on the Gregorian
+     * Calendar.
+     * @param year Hebrew year
+     * @param month Hebrew month (1=NISAN, 7=TISHREI)
+     * @param day Hebrew date (1-30)
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.hebrew2abs(5769, months.CHESHVAN, 15); // 733359
+     */
+    static hebrew2abs(year, month, day) {
+        return hebrew2abs(year, month, day);
+    }
+    /**
+     * Returns a transliterated Hebrew month name, e.g. `'Elul'` or `'Cheshvan'`.
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getMonthName(); // 'Cheshvan'
+     */
+    getMonthName() {
+        return getMonthName(this.getMonth(), this.getFullYear());
+    }
+    /**
+     * Renders this Hebrew date as a translated or transliterated string,
+     * including ordinal e.g. `'15th of Cheshvan, 5769'`.
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * console.log(hd.render('en')); // '15th of Cheshvan, 5769'
+     * console.log(hd.render('he')); // '15 חֶשְׁוָן, 5769'
+     * console.log(hd.render('en', false)); // '15th of Cheshvan'
+     * console.log(hd.render('he', false)); // '15 חֶשְׁוָן'
+     * @param [locale] Optional locale name (defaults to active locale).
+     * @param [showYear=true] Display year (defaults to true).
+     * @see {@link Locale}
+     */
+    render(locale, showYear = true) {
+        const locale0 = locale || Locale.getLocaleName();
+        const day = this.getDate();
+        const monthName0 = Locale.gettext(this.getMonthName(), locale0);
+        const monthName = monthName0.replace(/'/g, '’');
+        const nth = Locale.ordinal(day, locale0);
+        const dayOf = getDayOfTranslation(locale0);
+        const dateStr = `${nth}${dayOf} ${monthName}`;
+        if (showYear) {
+            const fullYear = this.getFullYear();
+            return `${dateStr}, ${fullYear}`;
+        }
+        else {
+            return dateStr;
+        }
+    }
+    /**
+     * Renders this Hebrew date in Hebrew gematriya, regardless of locale.
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * hd.renderGematriya(); // 'ט״ו חֶשְׁוָן תשס״ט'
+     * hd.renderGematriya(true); // 'ט״ו חשון תשס״ט'
+     */
+    renderGematriya(suppressNikud = false) {
+        const d = this.getDate();
+        const locale = suppressNikud ? 'he-x-NoNikud' : 'he';
+        const m = Locale.gettext(this.getMonthName(), locale);
+        const y = this.getFullYear();
+        return gematriya(d) + ' ' + m + ' ' + gematriya(y);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **before** this Hebrew date
+     * @example
+     * new HDate(new Date('Wednesday February 19, 2014')).before(6).greg() // Sat Feb 15 2014
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    before(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, -1);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **on or before** this Hebrew date
+     * @example
+     * new HDate(new Date('Wednesday February 19, 2014')).onOrBefore(6).greg() // Sat Feb 15 2014
+     * new HDate(new Date('Saturday February 22, 2014')).onOrBefore(6).greg() // Sat Feb 22 2014
+     * new HDate(new Date('Sunday February 23, 2014')).onOrBefore(6).greg() // Sat Feb 22 2014
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    onOrBefore(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 0);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **nearest** to this Hebrew date
+     * @example
+     * new HDate(new Date('Wednesday February 19, 2014')).nearest(6).greg() // Sat Feb 22 2014
+     * new HDate(new Date('Tuesday February 18, 2014')).nearest(6).greg() // Sat Feb 15 2014
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    nearest(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 3);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **on or after** this Hebrew date
+     * @example
+     * new HDate(new Date('Wednesday February 19, 2014')).onOrAfter(6).greg() // Sat Feb 22 2014
+     * new HDate(new Date('Saturday February 22, 2014')).onOrAfter(6).greg() // Sat Feb 22 2014
+     * new HDate(new Date('Sunday February 23, 2014')).onOrAfter(6).greg() // Sat Mar 01 2014
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    onOrAfter(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 6);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **after** this Hebrew date
+     * @example
+     * new HDate(new Date('Wednesday February 19, 2014')).after(6).greg() // Sat Feb 22 2014
+     * new HDate(new Date('Saturday February 22, 2014')).after(6).greg() // Sat Mar 01 2014
+     * new HDate(new Date('Sunday February 23, 2014')).after(6).greg() // Sat Mar 01 2014
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    after(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 7);
+    }
+    /**
+     * Returns the next Hebrew date
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.next(); // '16 Cheshvan 5769'
+     */
+    next() {
+        return new HDate(this.abs() + 1);
+    }
+    /**
+     * Returns the previous Hebrew date
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.prev(); // '14 Cheshvan 5769'
+     */
+    prev() {
+        return new HDate(this.abs() - 1);
+    }
+    /**
+     * Returns a cloned `HDate` object with a specified amount of time added
+     *
+     * Units are case insensitive, and support plural and short forms.
+     * Note, short forms are case sensitive.
+     *
+     * | Unit | Shorthand | Description
+     * | --- | --- | --- |
+     * | `day` | `d` | days |
+     * | `week` | `w` | weeks |
+     * | `month` | `M` | months |
+     * | `year` | `y` | years |
+     */
+    add(amount, units = 'd') {
+        amount =
+            typeof amount === 'string' ? parseInt(amount, 10) : amount;
+        if (!amount) {
+            return new HDate(this);
+        }
+        units = standardizeUnits(units);
+        if (units === UNITS_DAY) {
+            return new HDate(this.abs() + amount);
+        }
+        else if (units === UNITS_WEEK) {
+            return new HDate(this.abs() + 7 * amount);
+        }
+        else if (units === UNITS_YEAR) {
+            return new HDate(this.getDate(), this.getMonth(), this.getFullYear() + amount);
+        }
+        else {
+            // units === UNITS_MONTH
+            let hd = new HDate(this);
+            const sign = amount > 0 ? 1 : -1;
+            amount = Math.abs(amount);
+            for (let i = 0; i < amount; i++) {
+                hd = new HDate(hd.abs() + sign * hd.daysInMonth());
+            }
+            return hd;
+        }
+    }
+    /**
+     * Returns a cloned `HDate` object with a specified amount of time subracted
+     *
+     * Units are case insensitive, and support plural and short forms.
+     * Note, short forms are case sensitive.
+     *
+     * | Unit | Shorthand | Description
+     * | --- | --- | --- |
+     * | `day` | `d` | days |
+     * | `week` | `w` | weeks |
+     * | `month` | `M` | months |
+     * | `year` | `y` | years |
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     *
+     * const hd1 = new HDate(15, months.CHESHVAN, 5769);
+     * const hd2 = hd1.add(1, 'weeks'); // 7 Kislev 5769
+     * const hd3 = hd1.add(-3, 'M'); // 30 Av 5768
+     */
+    subtract(amount, units = 'd') {
+        return this.add(amount * -1, units);
+    }
+    /**
+     * Returns the difference in days between the two given HDates.
+     *
+     * The result is positive if `this` date is comes chronologically
+     * after the `other` date, and negative
+     * if the order of the two dates is reversed.
+     *
+     * The result is zero if the two dates are identical.
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     *
+     * const hd1 = new HDate(25, months.KISLEV, 5770);
+     * const hd2 = new HDate(15, months.CHESHVAN, 5769);
+     * const days = hd1.deltaDays(hd2); // 394
+     * @param other Hebrew date to compare
+     */
+    deltaDays(other) {
+        return this.abs() - other.abs();
+    }
+    /**
+     * Compares this Hebrew date to another date, returning `true` if the dates match.
+     * @param other Hebrew date to compare
+     * @example
+     * const hd1 = new HDate(new Date(2008, 10, 13));
+     * const hd2 = new HDate(15, 'Cheshvan', 5769);
+     * hd1.isSameDate(hd2); // true
+     */
+    isSameDate(other) {
+        return this.yy === other.yy && this.mm === other.mm && this.dd === other.dd;
+    }
+    /**
+     * Returns a string representation of this Hebrew date using English transliterations
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.toString(); // '15 Cheshvan 5769'
+     */
+    toString() {
+        const day = this.getDate();
+        const fullYear = this.getFullYear();
+        const monthName = this.getMonthName();
+        return `${day} ${monthName} ${fullYear}`;
+    }
+    /**
+     * Returns true if Hebrew year is a leap year
+     * @param year Hebrew year
+     * @example
+     * HDate.isLeapYear(5783); // false
+     * HDate.isLeapYear(5784); // true
+     */
+    static isLeapYear(year) {
+        return isLeapYear(year);
+    }
+    /**
+     * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
+     * @param year Hebrew year
+     * @example
+     * HDate.monthsInYear(5783); // 12
+     * HDate.monthsInYear(5784); // 13
+     */
+    static monthsInYear(year) {
+        return monthsInYear(year);
+    }
+    /**
+     * Number of days in Hebrew month in a given year (29 or 30)
+     * @param month Hebrew month (e.g. months.TISHREI)
+     * @param year Hebrew year
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.daysInMonth(months.CHESHVAN, 5769); // 29
+     */
+    static daysInMonth(month, year) {
+        return daysInMonth(month, year);
+    }
+    /**
+     * Returns a transliterated string name of Hebrew month in year,
+     * for example 'Elul' or 'Cheshvan'.
+     * @param month Hebrew month (e.g. months.TISHREI)
+     * @param year Hebrew year
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.getMonthName(months.CHESHVAN, 5769); // 'Cheshvan'
+     */
+    static getMonthName(month, year) {
+        return getMonthName(month, year);
+    }
+    /**
+     * Returns the Hebrew month number (NISAN=1, TISHREI=7)
+     * @param month A number, or Hebrew month name string
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.monthNum(months.CHESHVAN); // 8
+     * HDate.monthNum('Cheshvan'); // 8
+     * HDate.monthNum('חשון'); // 8
+     */
+    static monthNum(month) {
+        if (typeof month === 'number') {
+            if (isNaN(month) || month > 14) {
+                throw new RangeError(`bad monthNum: ${month}`);
+            }
+            return month;
+        }
+        return month.charCodeAt(0) >= 48 && month.charCodeAt(0) <= 57 /* number */
+            ? parseInt(month, 10)
+            : HDate.monthFromName(month);
+    }
+    /**
+     * Number of days in the Hebrew year.
+     * Regular years can have 353, 354, or 355 days.
+     * Leap years can have 383, 384, or 385 days.
+     * @param year Hebrew year
+     * @example
+     * HDate.daysInYear(5783); // 355
+     * HDate.daysInYear(5784); // 383
+     */
+    static daysInYear(year) {
+        return daysInYear(year);
+    }
+    /**
+     * true if Cheshvan is long in Hebrew year
+     * @param year Hebrew year
+     * @example
+     * HDate.longCheshvan(5783); // true
+     * HDate.longCheshvan(5784); // false
+     */
+    static longCheshvan(year) {
+        return longCheshvan(year);
+    }
+    /**
+     * true if Kislev is short in Hebrew year
+     * @param year Hebrew year
+     * @example
+     * HDate.shortKislev(5783); // false
+     * HDate.shortKislev(5784); // true
+     */
+    static shortKislev(year) {
+        return shortKislev(year);
+    }
+    /**
+     * Converts Hebrew month string name to numeric
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.monthFromName(months.CHESHVAN); // 8
+     * HDate.monthFromName('Cheshvan'); // 8
+     * HDate.monthFromName('חשון'); // 8
+     */
+    static monthFromName(monthName) {
+        if (typeof monthName === 'number') {
+            if (isNaN(monthName) || monthName < 1 || monthName > 14) {
+                throw new RangeError(`bad monthName: ${monthName}`);
+            }
+            return monthName;
+        }
+        const name = Locale.hebrewStripNikkud(monthName);
+        return monthFromName(name);
+    }
+    /**
+     * Convenience function for determining the R.D. date
+     * near a specified R.D. date, corresponding to the specified day of week.
+     *
+     * Note: Applying this function to d+6 gives us the `dayOfWeek` on or after an
+     * absolute day d. Similarly, applying it to d+3 gives the `dayOfWeek` nearest to
+     * absolute date d, applying it to d-1 gives the `dayOfWeek` previous to absolute
+     * date d, and applying it to d+7 gives the `dayOfWeek` following absolute date d.
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    static dayOnOrBefore(dayOfWeek, absdate) {
+        return absdate - ((absdate - dayOfWeek) % 7);
+    }
+    /**
+     * Tests if the object is an instance of `HDate`
+     * @example
+     * HDate.isHDate(new HDate()); // true
+     * HDate.isHDate(new Date()); // false
+     * HDate.isHDate(null); // false
+     * HDate.isHDate(12345); // false
+     * HDate.isHDate('15 Cheshvan 5769'); // false
+     */
+    static isHDate(obj) {
+        return (obj !== null &&
+            typeof obj === 'object' &&
+            typeof obj.yy === 'number' &&
+            typeof obj.mm === 'number' &&
+            typeof obj.dd === 'number' &&
+            typeof obj.greg === 'function' &&
+            typeof obj.abs === 'function');
+    }
+    /**
+     * Construct a new instance of `HDate` from a Gematriya-formatted string
+     * @example
+     * HDate.fromGematriyaString('כ״ז בְּתַמּוּז תשפ״ג') // 27 Tamuz 5783
+     * HDate.fromGematriyaString('כ׳ סיון תש״ד') // 20 Sivan 5704
+     * HDate.fromGematriyaString('ה׳ אִיָיר תש״ח') // 5 Iyyar 5708
+     */
+    static fromGematriyaString(str, currentThousands = 5000) {
+        const parts = str.split(' ').filter(x => x.length !== 0);
+        const numParts = parts.length;
+        if (numParts !== 3 && numParts !== 4) {
+            throw new RangeError(`cannot parse gematriya str: "${str}"`);
+        }
+        const day = gematriyaStrToNum(parts[0]);
+        const monthStr = numParts === 3 ? parts[1] : parts[1] + ' ' + parts[2];
+        const month = HDate.monthFromName(monthStr);
+        const yearStr = numParts === 3 ? parts[2] : parts[3];
+        let year = gematriyaStrToNum(yearStr);
+        if (year < 1000) {
+            year += currentThousands;
+        }
+        return new HDate(day, month, year);
+    }
+}
+function standardizeUnits(units) {
+    switch (units) {
+        case 'd':
+            return UNITS_DAY;
+        case 'w':
+            return UNITS_WEEK;
+        case 'M':
+            return UNITS_MONTH;
+        case 'y':
+            return UNITS_YEAR;
+    }
+    const str = String(units || '')
+        .toLowerCase()
+        .replace(/s$/, '');
+    switch (str) {
+        case UNITS_DAY:
+        case UNITS_WEEK:
+        case UNITS_MONTH:
+        case UNITS_YEAR:
+            return str;
+    }
+    throw new TypeError(`Invalid units '${units}'`);
+}
+function getDayOfTranslation(locale) {
+    switch (locale) {
+        case 'en':
+        case 's':
+        case 'a':
+        case 'ashkenazi':
+            return ' of';
+    }
+    const ofStr = Locale.lookupTranslation('of', locale);
+    if (ofStr) {
+        return ' ' + ofStr;
+    }
+    if (locale.startsWith('ashkenazi')) {
+        return ' of';
+    }
+    return '';
+}
+/**
+ * Sets the day of the month of the date. Returns the object it was called upon
+ * @private
+ * @param month A number, or Hebrew month name string
+ */
+function setMonth(hd, month) {
+    hd.mm = HDate.monthNum(month);
+    fix(hd);
+    return hd;
+}
+function setDate(hd, date) {
+    hd.dd = date;
+    fix(hd);
+    return hd;
+}
+function fix(hd) {
+    fixMonth(hd);
+    fixDate(hd);
+}
+function fixDate(hd) {
+    if (hd.dd < 1) {
+        if (hd.mm === months.TISHREI) {
+            hd.yy -= 1;
+        }
+        hd.dd += daysInMonth(hd.mm, hd.yy);
+        hd.mm -= 1;
+        fix(hd);
+    }
+    if (hd.dd > daysInMonth(hd.mm, hd.yy)) {
+        if (hd.mm === months.ELUL) {
+            hd.yy += 1;
+        }
+        hd.dd -= daysInMonth(hd.mm, hd.yy);
+        if (hd.mm === monthsInYear(hd.yy)) {
+            hd.mm = 1; // rollover to NISAN
+        }
+        else {
+            hd.mm += 1;
+        }
+        fix(hd);
+    }
+    fixMonth(hd);
+}
+function fixMonth(hd) {
+    if (hd.mm === months.ADAR_II && !hd.isLeapYear()) {
+        hd.mm -= 1; // to Adar I
+        fix(hd);
+    }
+    else if (hd.mm < 1) {
+        hd.mm += monthsInYear(hd.yy);
+        hd.yy -= 1;
+        fix(hd);
+    }
+    else if (hd.mm > monthsInYear(hd.yy)) {
+        hd.mm -= monthsInYear(hd.yy);
+        hd.yy += 1;
+        fix(hd);
+    }
+    delete hd.rd;
+}
+function onOrBefore(day, t, offset) {
+    return new HDate(HDate.dayOnOrBefore(day, t.abs() + offset));
+}
 
 var poAshkenazi = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "en_CA@ashkenazi" }, "contexts": { "": { "Shabbat": ["Shabbos"], "Achrei Mot": ["Achrei Mos"], "Bechukotai": ["Bechukosai"], "Beha'alotcha": ["Beha’aloscha"], "Bereshit": ["Bereshis"], "Chukat": ["Chukas"], "Erev Shavuot": ["Erev Shavuos"], "Erev Sukkot": ["Erev Sukkos"], "Ki Tavo": ["Ki Savo"], "Ki Teitzei": ["Ki Seitzei"], "Ki Tisa": ["Ki Sisa"], "Matot": ["Matos"], "Purim Katan": ["Purim Koton"], "Shabbat Chazon": ["Shabbos Chazon"], "Shabbat HaChodesh": ["Shabbos HaChodesh"], "Shabbat HaGadol": ["Shabbos HaGadol"], "Shabbat Nachamu": ["Shabbos Nachamu"], "Shabbat Parah": ["Shabbos Parah"], "Shabbat Shekalim": ["Shabbos Shekalim"], "Shabbat Shuva": ["Shabbos Shuvah"], "Shabbat Zachor": ["Shabbos Zachor"], "Shavuot": ["Shavuos"], "Shavuot I": ["Shavuos I"], "Shavuot II": ["Shavuos II"], "Shemot": ["Shemos"], "Shmini Atzeret": ["Shmini Atzeres"], "Simchat Torah": ["Simchas Torah"], "Sukkot": ["Sukkos"], "Sukkot I": ["Sukkos I"], "Sukkot II": ["Sukkos II"], "Sukkot II (CH''M)": ["Sukkos II (CH’’M)"], "Sukkot III (CH''M)": ["Sukkos III (CH’’M)"], "Sukkot IV (CH''M)": ["Sukkos IV (CH’’M)"], "Sukkot V (CH''M)": ["Sukkos V (CH’’M)"], "Sukkot VI (CH''M)": ["Sukkos VI (CH’’M)"], "Sukkot VII (Hoshana Raba)": ["Sukkos VII (Hoshana Raba)"], "Ta'anit Bechorot": ["Ta’anis Bechoros"], "Ta'anit Esther": ["Ta’anis Esther"], "Toldot": ["Toldos"], "Vaetchanan": ["Vaeschanan"], "Yitro": ["Yisro"], "Vezot Haberakhah": ["Vezos Haberakhah"], "Parashat": ["Parshas"], "Leil Selichot": ["Leil Selichos"], "Shabbat Mevarchim Chodesh": ["Shabbos Mevorchim Chodesh"], "Shabbat Shirah": ["Shabbos Shirah"], "Asara B'Tevet": ["Asara B’Teves"], "Alot HaShachar": ["Alos HaShachar"], "Kriat Shema, sof zeman": ["Krias Shema, sof zman"], "Tefilah, sof zeman": ["Tefilah, sof zman"], "Kriat Shema, sof zeman (MGA)": ["Krias Shema, sof zman (MGA)"], "Tefilah, sof zeman (MGA)": ["Tefilah, sof zman (MGA)"], "Chatzot HaLailah": ["Chatzos HaLailah"], "Chatzot hayom": ["Chatzos"], "Tzeit HaKochavim": ["Tzeis HaKochavim"], "Birkat Hachamah": ["Birkas Hachamah"], "Shushan Purim Katan": ["Shushan Purim Koton"] } } };
 
 var poHe = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "he_IL" }, "contexts": { "": { "Shabbat": ["שַׁבָּת"], "Daf Yomi": ["דַף יוֹמִי"], "Parashat": ["פָּרָשַׁת"], "Achrei Mot": ["אַחֲרֵי מוֹת"], "Balak": ["בָּלָק"], "Bamidbar": ["בְּמִדְבַּר"], "Bechukotai": ["בְּחֻקֹּתַי"], "Beha'alotcha": ["בְּהַעֲלֹתְךָ"], "Behar": ["בְּהַר"], "Bereshit": ["בְּרֵאשִׁית"], "Beshalach": ["בְּשַׁלַּח"], "Bo": ["בֹּא"], "Chayei Sara": ["חַיֵּי שָֹרָה"], "Chukat": ["חֻקַּת"], "Devarim": ["דְּבָרִים"], "Eikev": ["עֵקֶב"], "Emor": ["אֱמוֹר"], "Ha'azinu": ["הַאֲזִינוּ"], "Kedoshim": ["קְדשִׁים"], "Ki Tavo": ["כִּי־תָבוֹא"], "Ki Teitzei": ["כִּי־תֵצֵא"], "Ki Tisa": ["כִּי תִשָּׂא"], "Korach": ["קוֹרַח"], "Lech-Lecha": ["לֶךְ־לְךָ"], "Masei": ["מַסְעֵי"], "Matot": ["מַּטּוֹת"], "Metzora": ["מְּצֹרָע"], "Miketz": ["מִקֵּץ"], "Mishpatim": ["מִּשְׁפָּטִים"], "Nasso": ["נָשׂא"], "Nitzavim": ["נִצָּבִים"], "Noach": ["נֹחַ"], "Pekudei": ["פְקוּדֵי"], "Pinchas": ["פִּינְחָס"], "Re'eh": ["רְאֵה"], "Sh'lach": ["שְׁלַח־לְךָ"], "Shemot": ["שְׁמוֹת"], "Shmini": ["שְּׁמִינִי"], "Shoftim": ["שׁוֹפְטִים"], "Tazria": ["תַזְרִיעַ"], "Terumah": ["תְּרוּמָה"], "Tetzaveh": ["תְּצַוֶּה"], "Toldot": ["תּוֹלְדוֹת"], "Tzav": ["צַו"], "Vaera": ["וָאֵרָא"], "Vaetchanan": ["וָאֶתְחַנַּן"], "Vayakhel": ["וַיַּקְהֵל"], "Vayechi": ["וַיְחִי"], "Vayeilech": ["וַיֵּלֶךְ"], "Vayera": ["וַיֵּרָא"], "Vayeshev": ["וַיֵּשֶׁב"], "Vayetzei": ["וַיֵּצֵא"], "Vayigash": ["וַיִּגַּשׁ"], "Vayikra": ["וַיִּקְרָא"], "Vayishlach": ["וַיִּשְׁלַח"], "Vezot Haberakhah": ["וְזֹאת הַבְּרָכָה"], "Yitro": ["יִתְרוֹ"], "Asara B'Tevet": ["עֲשָׂרָה בְּטֵבֵת"], "Candle lighting": ["הַדְלָקַת נֵרוֹת"], "Chanukah": ["חֲנוּכָּה"], "Chanukah: 1 Candle": ["חֲנוּכָּה: א׳ נֵר"], "Chanukah: 2 Candles": ["חֲנוּכָּה: ב׳ נֵרוֹת"], "Chanukah: 3 Candles": ["חֲנוּכָּה: ג׳ נֵרוֹת"], "Chanukah: 4 Candles": ["חֲנוּכָּה: ד׳ נֵרוֹת"], "Chanukah: 5 Candles": ["חֲנוּכָּה: ה׳ נֵרוֹת"], "Chanukah: 6 Candles": ["חֲנוּכָּה: ו׳ נֵרוֹת"], "Chanukah: 7 Candles": ["חֲנוּכָּה: ז׳ נֵרוֹת"], "Chanukah: 8 Candles": ["חֲנוּכָּה: ח׳ נֵרוֹת"], "Chanukah: 8th Day": ["חֲנוּכָּה: יוֹם ח׳"], "Days of the Omer": ["סְפִירַת הָעוֹמֶר"], "Omer": ["עוֹמֶר"], "day of the Omer": ["בָּעוֹמֶר"], "Erev Pesach": ["עֶרֶב פֶּסַח"], "Erev Purim": ["עֶרֶב פּוּרִים"], "Erev Rosh Hashana": ["עֶרֶב רֹאשׁ הַשָּׁנָה"], "Erev Shavuot": ["עֶרֶב שָׁבוּעוֹת"], "Erev Simchat Torah": ["עֶרֶב שִׂמְחַת תּוֹרָה"], "Erev Sukkot": ["עֶרֶב סוּכּוֹת"], "Erev Tish'a B'Av": ["עֶרֶב תִּשְׁעָה בְּאָב"], "Erev Yom Kippur": ["עֶרֶב יוֹם כִּפּוּר"], "Havdalah": ["הַבְדָּלָה"], "Lag BaOmer": ["ל״ג בָּעוֹמֶר"], "Leil Selichot": ["סליחות"], "Pesach": ["פֶּסַח"], "Pesach I": ["פֶּסַח א׳"], "Pesach II": ["פֶּסַח ב׳"], "Pesach II (CH''M)": ["פֶּסַח ב׳ (חוה״מ)"], "Pesach III (CH''M)": ["פֶּסַח ג׳ (חוה״מ)"], "Pesach IV (CH''M)": ["פֶּסַח ד׳ (חוה״מ)"], "Pesach Sheni": ["פֶּסַח שני"], "Pesach V (CH''M)": ["פֶּסַח ה׳ (חוה״מ)"], "Pesach VI (CH''M)": ["פֶּסַח ו׳ (חוה״מ)"], "Pesach VII": ["פֶּסַח ז׳"], "Pesach VIII": ["פֶּסַח ח׳"], "Purim": ["פּוּרִים"], "Purim Katan": ["פּוּרִים קָטָן"], "Rosh Chodesh %s": ["רֹאשׁ חוֹדֶשׁ %s"], "Rosh Chodesh": ["רֹאשׁ חוֹדֶשׁ"], "Rosh Hashana": ["רֹאשׁ הַשָּׁנָה"], "Rosh Hashana I": ["רֹאשׁ הַשָּׁנָה א׳"], "Rosh Hashana II": ["רֹאשׁ הַשָּׁנָה ב׳"], "Shabbat Chazon": ["שַׁבָּת חֲזוֹן"], "Shabbat HaChodesh": ["שַׁבָּת הַחֹדֶשׁ"], "Shabbat HaGadol": ["שַׁבָּת הַגָּדוֹל"], "Shabbat Nachamu": ["שַׁבָּת נַחֲמוּ"], "Shabbat Parah": ["שַׁבָּת פּרה"], "Shabbat Shekalim": ["שַׁבָּת שְׁקָלִים"], "Shabbat Shuva": ["שַׁבָּת שׁוּבָה"], "Shabbat Zachor": ["שַׁבָּת זָכוֹר"], "Shavuot": ["שָׁבוּעוֹת"], "Shavuot I": ["שָׁבוּעוֹת א׳"], "Shavuot II": ["שָׁבוּעוֹת ב׳"], "Shmini Atzeret": ["שְׁמִינִי עֲצֶרֶת"], "Shushan Purim": ["שׁוּשָׁן פּוּרִים"], "Sigd": ["סיגד"], "Simchat Torah": ["שִׂמְחַת תּוֹרָה"], "Sukkot": ["סוּכּוֹת"], "Sukkot I": ["סוּכּוֹת א׳"], "Sukkot II": ["סוּכּוֹת ב׳"], "Sukkot II (CH''M)": ["סוּכּוֹת ב׳ (חוה״מ)"], "Sukkot III (CH''M)": ["סוּכּוֹת ג׳ (חוה״מ)"], "Sukkot IV (CH''M)": ["סוּכּוֹת ד׳ (חוה״מ)"], "Sukkot V (CH''M)": ["סוּכּוֹת ה׳ (חוה״מ)"], "Sukkot VI (CH''M)": ["סוּכּוֹת ו׳ (חוה״מ)"], "Sukkot VII (Hoshana Raba)": ["סוּכּוֹת ז׳ (הוֹשַׁעְנָא רַבָּה)"], "Ta'anit Bechorot": ["תַּעֲנִית בְּכוֹרוֹת"], "Ta'anit Esther": ["תַּעֲנִית אֶסְתֵּר"], "Tish'a B'Av": ["תִּשְׁעָה בְּאָב"], "Tu B'Av": ["טוּ בְּאָב"], "Tu BiShvat": ["טוּ בִּשְׁבָט"], "Tu B'Shvat": ["טוּ בִּשְׁבָט"], "Tzom Gedaliah": ["צוֹם גְּדַלְיָה"], "Tzom Tammuz": ["צוֹם תָּמוּז"], "Yom HaAtzma'ut": ["יוֹם הָעַצְמָאוּת"], "Yom HaShoah": ["יוֹם הַשּׁוֹאָה"], "Yom HaZikaron": ["יוֹם הַזִּכָּרוֹן"], "Yom Kippur": ["יוֹם כִּפּוּר"], "Yom Yerushalayim": ["יוֹם יְרוּשָׁלַיִם"], "Yom HaAliyah": ["יוֹם הַעֲלִיָּה"], "Yom HaAliyah School Observance": ["שְׁמִירָת בֵּית הַסֵפֶר לְיוֹם הַעֲלִיָּה"], "Rosh Chodesh Adar": ["רֹאשׁ חוֹדֶשׁ אַדָר"], "Rosh Chodesh Adar I": ["רֹאשׁ חוֹדֶשׁ אַדָר א׳"], "Rosh Chodesh Adar II": ["רֹאשׁ חוֹדֶשׁ אַדָר ב׳"], "Rosh Chodesh Av": ["רֹאשׁ חוֹדֶשׁ אָב"], "Rosh Chodesh Cheshvan": ["רֹאשׁ חוֹדֶשׁ חֶשְׁוָן"], "Rosh Chodesh Elul": ["רֹאשׁ חוֹדֶשׁ אֱלוּל"], "Rosh Chodesh Iyyar": ["רֹאשׁ חוֹדֶשׁ אִיָיר"], "Rosh Chodesh Kislev": ["רֹאשׁ חוֹדֶשׁ כִּסְלֵו"], "Rosh Chodesh Nisan": ["רֹאשׁ חוֹדֶשׁ נִיסָן"], "Rosh Chodesh Sh'vat": ["רֹאשׁ חוֹדֶשׁ שְׁבָט"], "Rosh Chodesh Sivan": ["רֹאשׁ חוֹדֶשׁ סִיוָן"], "Rosh Chodesh Tamuz": ["רֹאשׁ חוֹדֶשׁ תָּמוּז"], "Rosh Chodesh Tevet": ["רֹאשׁ חוֹדֶשׁ טֵבֵת"], "min": ["דַּקּוֹת"], "Fast begins": ["תחילת הַצוֹם"], "Fast ends": ["סִיּוּם הַצוֹם"], "Rosh Hashana LaBehemot": ["רֹאשׁ הַשָּׁנָה לְמַעְשַׂר בְּהֵמָה"], "Tish'a B'Av (observed)": ["תִּשְׁעָה בְּאָב נִדחֶה"], "Shabbat Mevarchim Chodesh": ["שַׁבָּת מְבָרְכִים חוֹדֶשׁ"], "Shabbat Shirah": ["שַׁבָּת שִׁירָה"], "Chatzot HaLailah": ["חֲצוֹת הַלַיְלָה"], "Alot haShachar": ["עֲלוֹת הַשַּׁחַר"], "Misheyakir": ["מִשֶּׁיַּכִּיר"], "Misheyakir Machmir": ["מִשֶּׁיַּכִּיר מַחמִיר"], "Dawn": ["דִּימְדּוּמֵי בּוֹקֵר"], "Sunrise": ["הַנֵץ הַחַמָּה"], "Kriat Shema, sof zeman": ["סוֹף זְמַן קְרִיאַת שְׁמַע גר״א"], "Tefilah, sof zeman": ["סוֹף זְמַן תְּפִלָּה גר״א"], "Kriat Shema, sof zeman (MGA)": ["סוֹף זְמַן קְרִיאַת שְׁמַע מג״א"], "Tefilah, sof zeman (MGA)": ["סוֹף זְמַן תְּפִלָּה מג״א"], "Chatzot hayom": ["חֲצוֹת הַיּוֹם"], "Mincha Gedolah": ["מִנְחָה גְּדוֹלָה"], "Mincha Ketanah": ["מִנְחָה קְטַנָּה"], "Plag HaMincha": ["פְּלַג הַמִּנְחָה"], "Dusk": ["דִּימְדּוּמֵי עֶרֶב"], "Sunset": ["שְׁקִיעָה"], "Nightfall - End of ordained fasts": ["לַיְלָה - גמר תעניות דרבנן"], "Tzeit HaKochavim": ["צֵאת הַכּוֹכָבִים"], "Lovingkindness": ["חֶֽסֶד"], "Might": ["גְבוּרָה"], "Beauty": ["תִּפְאֶֽרֶת"], "Eternity": ["נֶּֽצַח"], "Splendor": ["הוֹד"], "Foundation": ["יְּסוֹד"], "Majesty": ["מַּלְכוּת"], "day": ["יוֹם"], "Yom Kippur Katan": ["יוֹם כִּפּוּר קָטָן"], "Yizkor": ["יִזְכּוֹר"], "Family Day": ["יוֹם הַמִּשׁפָּחָה"], "Yitzhak Rabin Memorial Day": ["יוֹם הַזִּכָּרוֹן ליצחק רבין"], "Jabotinsky Day": ["יוֹם ז׳בוטינסקי"], "Herzl Day": ["יוֹם הרצל"], "Ben-Gurion Day": ["יוֹם בן־גוריון"], "Hebrew Language Day": ["יוֹם הַשָׂפָה הַעִברִית"], "Birkat Hachamah": ["בִרְכַּת הַחַמָּה"], "Shushan Purim Katan": ["שׁוּשָׁן פּוּרִים קָטָן"], "Purim Meshulash": ["פּוּרִים מְשׁוּלָּשׁ"], "after sunset": ["לְאַחַר הַשְׁקִיעָה"], "Yerushalmi": ["יְרוּשַׁלְמִי"], "Chag HaBanot": ["חַג הַבָּנוֹת"], "Joshua": ["יְהוֹשׁוּעַ"], "Judges": ["שׁוֹפְטִים"], "I Samuel": ["שְׁמוּאֵל רִאשׁוֹן"], "II Samuel": ["שְׁמוּאֵל שֵׁנִי"], "I Kings": ["מְלָכִים רִאשׁוֹן"], "II Kings": ["מְלָכִים שֵׁנִי"], "Isaiah": ["יְשַׁעְיָהוּ"], "Jeremiah": ["יִרְמְיָהוּ"], "Ezekiel": ["יְחֶזְקֵאל"], "Hosea": ["הוֹשֵׁעַ"], "Joel": ["יוֹאֵל"], "Amos": ["עָמוּס"], "Obadiah": ["עוֹבַדְיָה"], "Jonah": ["יוֹנָה"], "Micah": ["מִיכָה"], "Nachum": ["נַחוּם"], "Habakkuk": ["חֲבַקּוּק"], "Zephaniah": ["צְפַנְיָה"], "Haggai": ["חַגַּי"], "Zechariah": ["זְכַרְיָה"], "Malachi": ["מַלְאָכִי"], "Psalms": ["תְּהִלִּים"], "Proverbs": ["מִשְׁלֵי"], "Job": ["אִיּוֹב"], "Song of Songs": ["שִׁיר הַשִּׁירִים"], "Ruth": ["רוּת"], "Lamentations": ["אֵיכָה"], "Ecclesiastes": ["קֹהֶלֶת"], "Esther": ["אֶסְתֵּר"], "Daniel": ["דָּנִיֵּאל"], "Ezra": ["עֶזְרָא"], "Nehemiah": ["נְחֶמְיָה"], "I Chronicles": ["דִברֵי הַיָמִים רִאשׁוֹן"], "II Chronicles": ["דִברֵי הַיָמִים שֵׁנִי"], "Molad": ["מוֹלָד הָלְּבָנָה"], "chalakim": ["חֲלָקִים"], "Pirkei Avot": ["פִּרְקֵי אָבוֹת"] } } };
 
-hdate.Locale.addTranslations('he', poHe);
-hdate.Locale.addTranslations('h', poHe);
-hdate.Locale.addTranslations('ashkenazi', poAshkenazi);
-hdate.Locale.addTranslations('a', poAshkenazi);
+Locale.addTranslations('he', poHe);
+Locale.addTranslations('h', poHe);
+Locale.addTranslations('ashkenazi', poAshkenazi);
+Locale.addTranslations('a', poAshkenazi);
 /* Hebrew without nikkud */
 const heStrs = poHe.contexts[''];
 const heNoNikud = {};
 for (const [key, val] of Object.entries(heStrs)) {
-    heNoNikud[key] = [hdate.Locale.hebrewStripNikkud(val[0])];
+    heNoNikud[key] = [Locale.hebrewStripNikkud(val[0])];
 }
 const poHeNoNikud = {
     headers: poHe.headers,
     contexts: { '': heNoNikud },
 };
-hdate.Locale.addTranslations('he-x-NoNikud', poHeNoNikud);
+Locale.addTranslations('he-x-NoNikud', poHeNoNikud);
 
 /**
  * Holiday flags for Event. These flags are typically
@@ -126,7 +1988,7 @@ class Event {
      * @param [attrs={}] optional additional attributes (e.g. `eventTimeStr`, `cholHaMoedDay`)
      */
     constructor(date, desc, mask = 0, attrs) {
-        if (!hdate.HDate.isHDate(date)) {
+        if (!HDate.isHDate(date)) {
             throw new TypeError(`Invalid Event date: ${date}`);
         }
         else if (typeof desc !== 'string') {
@@ -170,7 +2032,7 @@ class Event {
      * @param [locale] Optional locale name (defaults to active locale).
      */
     render(locale) {
-        return hdate.Locale.gettext(this.desc, locale);
+        return Locale.gettext(this.desc, locale);
     }
     /**
      * Returns a brief (translated) description of this event.
@@ -284,7 +2146,7 @@ class HebrewDateEvent extends Event {
      */
     render(locale) {
         const locale1 = locale === null || locale === void 0 ? void 0 : locale.toLowerCase();
-        const locale0 = locale1 !== null && locale1 !== void 0 ? locale1 : hdate.Locale.getLocaleName();
+        const locale0 = locale1 !== null && locale1 !== void 0 ? locale1 : Locale.getLocaleName();
         const hd = this.getDate();
         switch (locale0) {
             case 'h':
@@ -303,8 +2165,8 @@ class HebrewDateEvent extends Event {
     renderBriefHebrew(locale) {
         const hd = this.getDate();
         const dd = hd.getDate();
-        const mm = hdate.Locale.gettext(hd.getMonthName(), locale);
-        return hdate.gematriya(dd) + ' ' + mm;
+        const mm = Locale.gettext(hd.getMonthName(), locale);
+        return gematriya(dd) + ' ' + mm;
     }
     /**
      * @param [locale] Optional locale name (defaults to active locale).
@@ -318,9 +2180,9 @@ class HebrewDateEvent extends Event {
      */
     renderBrief(locale) {
         const locale1 = locale === null || locale === void 0 ? void 0 : locale.toLowerCase();
-        const locale0 = locale1 !== null && locale1 !== void 0 ? locale1 : hdate.Locale.getLocaleName();
+        const locale0 = locale1 !== null && locale1 !== void 0 ? locale1 : Locale.getLocaleName();
         const hd = this.getDate();
-        if (hd.getMonth() === hdate.months.TISHREI && hd.getDate() === 1) {
+        if (hd.getMonth() === months.TISHREI && hd.getDate() === 1) {
             return this.render(locale0);
         }
         switch (locale0) {
@@ -334,6 +2196,1106 @@ class HebrewDateEvent extends Event {
     }
 }
 
+/**
+ * java.lang.Math.toRadians
+ * @private
+ * @param degrees
+ */
+function degreesToRadians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+/**
+ * java.lang.Math.toDegrees
+ * @private
+ * @param radians
+ */
+function radiansToDegrees(radians) {
+    return (radians * 180) / Math.PI;
+}
+/**
+ * A class that contains location information such as latitude and longitude required for astronomical calculations. The
+ * elevation field may not be used by some calculation engines and would be ignored if set.
+ *
+ * @author &copy; Eliyahu Hershfeld 2004 - 2016
+ * @version 1.1
+ */
+class GeoLocation {
+    /**
+     * GeoLocation constructor with parameters for all required fields.
+     *
+     * @param {string} name
+     *            The location name for display use such as &quot;Lakewood, NJ&quot;
+     * @param {number} latitude
+     *            the latitude in a double format such as 40.095965 for Lakewood, NJ.
+     *            <b>Note: </b> For latitudes south of the equator, a negative value should be used.
+     * @param {number} longitude
+     *            double the longitude in a double format such as -74.222130 for Lakewood, NJ.
+     *            <b>Note: </b> For longitudes west of the <a href="http://en.wikipedia.org/wiki/Prime_Meridian">Prime
+     *            Meridian </a> (Greenwich), a negative value should be used.
+     * @param {number} elevation
+     *            the elevation above sea level in Meters. Elevation is not used in most algorithms used for calculating
+     *            sunrise and set.
+     * @param {string} timeZoneId
+     *            the <code>TimeZone</code> for the location.
+     */
+    constructor(name, latitude, longitude, elevation, timeZoneId) {
+        /**
+         * @private
+         */
+        this.locationName = null;
+        this.setLocationName(name);
+        this.setLatitude(latitude);
+        this.setLongitude(longitude);
+        this.setElevation(elevation);
+        this.setTimeZone(timeZoneId);
+    }
+    /**
+     * Method to get the elevation in Meters.
+     *
+     * @return {number} Returns the elevation in Meters.
+     */
+    getElevation() {
+        return this.elevation;
+    }
+    /**
+     * Method to set the elevation in Meters <b>above </b> sea level.
+     *
+     * @param {number} elevation
+     *            The elevation to set in Meters. An Error will be thrown if the value is a negative.
+     */
+    setElevation(elevation) {
+        if (typeof elevation !== 'number')
+            throw new TypeError('Invalid elevation');
+        if (elevation < 0) {
+            throw new RangeError(`elevation ${elevation} must be zero or positive`);
+        }
+        this.elevation = elevation;
+    }
+    setLatitude(latitude) {
+        if (typeof latitude !== 'number')
+            throw new TypeError('Invalid latitude');
+        if (latitude < -90 || latitude > 90) {
+            throw new RangeError(`Latitude ${latitude} out of range [-90,90]`);
+        }
+        this.latitude = latitude;
+    }
+    /**
+     * @return {number} Returns the latitude.
+     */
+    getLatitude() {
+        return this.latitude;
+    }
+    setLongitude(longitude) {
+        if (typeof longitude !== 'number')
+            throw new TypeError('Invalid longitude');
+        if (longitude < -180 || longitude > 180) {
+            throw new RangeError(`Longitude ${longitude} out of range [-180,180]`);
+        }
+        this.longitude = longitude;
+    }
+    /**
+     * @return {number} Returns the longitude.
+     */
+    getLongitude() {
+        return this.longitude;
+    }
+    /**
+     * @return {string|null} Returns the location name.
+     */
+    getLocationName() {
+        return this.locationName;
+    }
+    /**
+     * @param {string|null} name
+     *            The setter method for the display name.
+     */
+    setLocationName(name) {
+        this.locationName = name;
+    }
+    /**
+     * @return {string} Returns the timeZone.
+     */
+    getTimeZone() {
+        return this.timeZoneId;
+    }
+    /**
+     * Method to set the TimeZone.
+     * @param {string} timeZoneId
+     *            The timeZone to set.
+     */
+    setTimeZone(timeZoneId) {
+        if (!timeZoneId) {
+            throw new RangeError('Invalid timeZoneId');
+        }
+        this.timeZoneId = timeZoneId;
+    }
+}
+/**
+ * The commonly used average solar refraction. Calendrical Calculations lists a more accurate global average of
+ * 34.478885263888294
+ * @private
+ */
+const refraction = 34 / 60;
+// private double refraction = 34.478885263888294 / 60d;
+/**
+ * The commonly used average solar radius in minutes of a degree.
+ * @private
+ */
+const solarRadius = 16 / 60;
+/**
+ * The commonly used average earth radius in KM. At this time, this only affects elevation adjustment and not the
+ * sunrise and sunset calculations. The value currently defaults to 6356.9 KM.
+ * @private
+ */
+const earthRadius = 6356.9; // in KM
+/**
+ * Implementation of sunrise and sunset methods to calculate astronomical times based on the <a
+ * href="http://noaa.gov">NOAA</a> algorithm. This calculator uses the Java algorithm based on the implementation by <a
+ * href="http://noaa.gov">NOAA - National Oceanic and Atmospheric Administration</a>'s <a href =
+ * "http://www.srrb.noaa.gov/highlights/sunrise/sunrise.html">Surface Radiation Research Branch</a>. NOAA's <a
+ * href="http://www.srrb.noaa.gov/highlights/sunrise/solareqns.PDF">implementation</a> is based on equations from <a
+ * href="http://www.willbell.com/math/mc1.htm">Astronomical Algorithms</a> by <a
+ * href="http://en.wikipedia.org/wiki/Jean_Meeus">Jean Meeus</a>. Added to the algorithm is an adjustment of the zenith
+ * to account for elevation. The algorithm can be found in the <a
+ * href="http://en.wikipedia.org/wiki/Sunrise_equation">Wikipedia Sunrise Equation</a> article.
+ *
+ * @author &copy; Eliyahu Hershfeld 2011 - 2019
+ */
+class NOAACalculator {
+    /**
+     * A constructor that takes in <a href="http://en.wikipedia.org/wiki/Geolocation">geolocation</a> information as a
+     * parameter.
+     *
+     * @param {GeoLocation} geoLocation
+     *            The location information used for calculating astronomical sun times.
+     * @param {Temporal.PlainDate} date
+     */
+    constructor(geoLocation, date) {
+        this.date = date;
+        this.geoLocation = geoLocation;
+    }
+    /**
+     * The getSunrise method Returns a `Date` representing the
+     * {@link getElevationAdjustment elevation adjusted} sunrise time. The zenith used
+     * for the calculation uses {@link GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
+     * {@link getElevationAdjustment}. This is adjusted
+     * to add approximately 50/60 of a degree to account for 34 archminutes of refraction
+     * and 16 archminutes for the sun's radius for a total of {@link adjustZenith 90.83333&deg;}.
+     *
+     * @return {Temporal.ZonedDateTime | null} the `Date` representing the exact sunrise time. If the calculation can't be computed such as
+     *         in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
+     *         does not set, a null will be returned. See detailed explanation on top of the page.
+     * @see adjustZenith
+     * @see getSeaLevelSunrise()
+     * @see getUTCSunrise
+     */
+    getSunrise() {
+        const sunrise = this.getUTCSunrise0(NOAACalculator.GEOMETRIC_ZENITH);
+        if (isNaN(sunrise))
+            return null;
+        return this.getDateFromTime(sunrise, true);
+    }
+    /**
+     * A method that returns the sunrise without {@link getElevationAdjustment elevation
+     * adjustment}. Non-sunrise and sunset calculations such as dawn and dusk, depend on the amount of visible light,
+     * something that is not affected by elevation. This method returns sunrise calculated at sea level. This forms the
+     * base for dawn calculations that are calculated as a dip below the horizon before sunrise.
+     *
+     * @return {Temporal.ZonedDateTime | null} the `Date` representing the exact sea-level sunrise time. If the calculation can't be computed
+     *         such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one
+     *         where it does not set, a null will be returned. See detailed explanation on top of the page.
+     * @see getSunrise
+     * @see getUTCSeaLevelSunrise
+     * @see getSeaLevelSunset()
+     */
+    getSeaLevelSunrise() {
+        const sunrise = this.getUTCSeaLevelSunrise(NOAACalculator.GEOMETRIC_ZENITH);
+        if (isNaN(sunrise))
+            return null;
+        return this.getDateFromTime(sunrise, true);
+    }
+    /**
+     * A method that returns the beginning of civil twilight (dawn) using a zenith of {@link CIVIL_ZENITH 96&deg;}.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the beginning of civil twilight using a zenith of 96&deg;. If the calculation
+     *         can't be computed, null will be returned. See detailed explanation on top of the page.
+     * @see CIVIL_ZENITH
+     */
+    getBeginCivilTwilight() {
+        return this.getSunriseOffsetByDegrees(NOAACalculator.CIVIL_ZENITH);
+    }
+    /**
+     * A method that returns the beginning of nautical twilight using a zenith of {@link NAUTICAL_ZENITH 102&deg;}.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the beginning of nautical twilight using a zenith of 102&deg;. If the
+     *         calculation can't be computed null will be returned. See detailed explanation on top of the page.
+     * @see NAUTICAL_ZENITH
+     */
+    getBeginNauticalTwilight() {
+        return this.getSunriseOffsetByDegrees(NOAACalculator.NAUTICAL_ZENITH);
+    }
+    /**
+     * A method that returns the beginning of astronomical twilight using a zenith of {@link ASTRONOMICAL_ZENITH
+     * 108&deg;}.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the beginning of astronomical twilight using a zenith of 108&deg;. If the
+     *         calculation can't be computed, null will be returned. See detailed explanation on top of the page.
+     * @see ASTRONOMICAL_ZENITH
+     */
+    getBeginAstronomicalTwilight() {
+        return this.getSunriseOffsetByDegrees(NOAACalculator.ASTRONOMICAL_ZENITH);
+    }
+    /**
+     * The getSunset method Returns a `Date` representing the
+     * {@link getElevationAdjustment elevation adjusted} sunset time. The zenith used for
+     * the calculation uses {@link GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
+     * {@link getElevationAdjustment}. This is adjusted
+     * to add approximately 50/60 of a degree to account for 34 archminutes of refraction
+     * and 16 archminutes for the sun's radius for a total of {@link adjustZenith 90.83333&deg;}.
+     * Note:
+     * In certain cases the calculates sunset will occur before sunrise. This will typically happen when a timezone
+     * other than the local timezone is used (calculating Los Angeles sunset using a GMT timezone for example). In this
+     * case the sunset date will be incremented to the following date.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` representing the exact sunset time. If the calculation can't be computed such as in
+     *         the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
+     *         does not set, a null will be returned. See detailed explanation on top of the page.
+     * @see adjustZenith
+     * @see getSeaLevelSunset()
+     * @see getUTCSunset
+     */
+    getSunset() {
+        const sunset = this.getUTCSunset0(NOAACalculator.GEOMETRIC_ZENITH);
+        if (isNaN(sunset))
+            return null;
+        return this.getDateFromTime(sunset, false);
+    }
+    /**
+     * A method that returns the sunset without {@link getElevationAdjustment elevation
+     * adjustment}. Non-sunrise and sunset calculations such as dawn and dusk, depend on the amount of visible light,
+     * something that is not affected by elevation. This method returns sunset calculated at sea level. This forms the
+     * base for dusk calculations that are calculated as a dip below the horizon after sunset.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` representing the exact sea-level sunset time. If the calculation can't be computed
+     *         such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one
+     *         where it does not set, a null will be returned. See detailed explanation on top of the page.
+     * @see getSunset
+     * @see getUTCSeaLevelSunset
+     */
+    getSeaLevelSunset() {
+        const sunset = this.getUTCSeaLevelSunset(NOAACalculator.GEOMETRIC_ZENITH);
+        if (isNaN(sunset))
+            return null;
+        return this.getDateFromTime(sunset, false);
+    }
+    /**
+     * A method that returns the end of civil twilight using a zenith of {@link CIVIL_ZENITH 96&deg;}.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of civil twilight using a zenith of {@link CIVIL_ZENITH 96&deg;}. If
+     *         the calculation can't be computed, null will be returned. See detailed explanation on top of the page.
+     * @see CIVIL_ZENITH
+     */
+    getEndCivilTwilight() {
+        return this.getSunsetOffsetByDegrees(NOAACalculator.CIVIL_ZENITH);
+    }
+    /**
+     * A method that returns the end of nautical twilight using a zenith of {@link NAUTICAL_ZENITH 102&deg;}.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of nautical twilight using a zenith of {@link NAUTICAL_ZENITH 102&deg;}
+     *         . If the calculation can't be computed, null will be returned. See detailed explanation on top of the
+     *         page.
+     * @see NAUTICAL_ZENITH
+     */
+    getEndNauticalTwilight() {
+        return this.getSunsetOffsetByDegrees(NOAACalculator.NAUTICAL_ZENITH);
+    }
+    /**
+     * A method that returns the end of astronomical twilight using a zenith of {@link ASTRONOMICAL_ZENITH 108&deg;}.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of astronomical twilight using a zenith of {@link ASTRONOMICAL_ZENITH
+     *         108&deg;}. If the calculation can't be computed, null will be returned. See detailed explanation on top
+     *         of the page.
+     * @see ASTRONOMICAL_ZENITH
+     */
+    getEndAstronomicalTwilight() {
+        return this.getSunsetOffsetByDegrees(NOAACalculator.ASTRONOMICAL_ZENITH);
+    }
+    /**
+     * A utility method that returns a date offset by the offset time passed in. Please note that the level of light
+     * during twilight is not affected by elevation, so if this is being used to calculate an offset before sunrise or
+     * after sunset with the intent of getting a rough "level of light" calculation, the sunrise or sunset time passed
+     * to this method should be sea level sunrise and sunset.
+     *
+     * @param {Temporal.ZonedDateTime | null} time
+     *            the start time
+     * @param {number} offset
+     *            the offset in milliseconds to add to the time.
+     * @return {Temporal.ZonedDateTime | null} the `Date` with the offset in milliseconds added to it
+     */
+    static getTimeOffset(time, offset) {
+        if (time === null || isNaN(offset)) {
+            return null;
+        }
+        return time.add({ milliseconds: offset });
+    }
+    /**
+     * A utility method that returns the time of an offset by degrees below or above the horizon of
+     * {@link getSunrise() sunrise}. Note that the degree offset is from the vertical, so for a calculation of 14&deg;
+     * before sunrise, an offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
+     *
+     * @param {number} offsetZenith
+     *            the degrees before {@link getSunrise} to use in the calculation. For time after sunrise use
+     *            negative numbers. Note that the degree offset is from the vertical, so for a calculation of 14&deg;
+     *            before sunrise, an offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a
+     *            parameter.
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the offset after (or before) {@link getSunrise}. If the calculation
+     *         can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does
+     *         not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the
+     *         page.
+     */
+    getSunriseOffsetByDegrees(offsetZenith) {
+        const dawn = this.getUTCSunrise0(offsetZenith);
+        if (isNaN(dawn))
+            return null;
+        return this.getDateFromTime(dawn, true);
+    }
+    /**
+     * A utility method that returns the time of an offset by degrees below or above the horizon of {@link getSunset()
+     * sunset}. Note that the degree offset is from the vertical, so for a calculation of 14&deg; after sunset, an
+     * offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
+     *
+     * @param {number} offsetZenith
+     *            the degrees after {@link getSunset} to use in the calculation. For time before sunset use negative
+     *            numbers. Note that the degree offset is from the vertical, so for a calculation of 14&deg; after
+     *            sunset, an offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
+     * @return {Temporal.ZonedDateTime | null} The `Date`of the offset after (or before) {@link getSunset}. If the calculation can't
+     *         be computed such as in the Arctic Circle where there is at least one day a year where the sun does not
+     *         rise, and one where it does not set, a null will be returned. See detailed explanation on top of the
+     *         page.
+     */
+    getSunsetOffsetByDegrees(offsetZenith) {
+        const sunset = this.getUTCSunset0(offsetZenith);
+        if (isNaN(sunset))
+            return null;
+        return this.getDateFromTime(sunset, false);
+    }
+    /**
+     * A method that returns the sunrise in UTC time without correction for time zone offset from GMT and without using
+     * daylight savings time.
+     *
+     * @param {number} zenith
+     *            the degrees below the horizon. For time after sunrise use negative numbers.
+     * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
+     */
+    getUTCSunrise0(zenith) {
+        return this.getUTCSunrise(this.getAdjustedDate(), this.geoLocation, zenith, true);
+    }
+    /**
+     * A method that returns the sunrise in UTC time without correction for time zone offset from GMT and without using
+     * daylight savings time. Non-sunrise and sunset calculations such as dawn and dusk, depend on the amount of visible
+     * light, something that is not affected by elevation. This method returns UTC sunrise calculated at sea level. This
+     * forms the base for dawn calculations that are calculated as a dip below the horizon before sunrise.
+     *
+     * @param {number} zenith
+     *            the degrees below the horizon. For time after sunrise use negative numbers.
+     * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
+     * @see getUTCSunrise
+     * @see getUTCSeaLevelSunset
+     */
+    getUTCSeaLevelSunrise(zenith) {
+        return this.getUTCSunrise(this.getAdjustedDate(), this.geoLocation, zenith, false);
+    }
+    /**
+     * A method that returns the sunset in UTC time without correction for time zone offset from GMT and without using
+     * daylight savings time.
+     *
+     * @param {number} zenith
+     *            the degrees below the horizon. For time after sunset use negative numbers.
+     * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
+     * @see getUTCSeaLevelSunset
+     */
+    getUTCSunset0(zenith) {
+        return this.getUTCSunset(this.getAdjustedDate(), this.geoLocation, zenith, true);
+    }
+    /**
+     * A method that returns the sunset in UTC time without correction for elevation, time zone offset from GMT and
+     * without using daylight savings time. Non-sunrise and sunset calculations such as dawn and dusk, depend on the
+     * amount of visible light, something that is not affected by elevation. This method returns UTC sunset calculated
+     * at sea level. This forms the base for dusk calculations that are calculated as a dip below the horizon after
+     * sunset.
+     *
+     * @param {number} zenith
+     *            the degrees below the horizon. For time before sunset use negative numbers.
+     * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
+     * @see getUTCSunset
+     * @see getUTCSeaLevelSunrise
+     */
+    getUTCSeaLevelSunset(zenith) {
+        return this.getUTCSunset(this.getAdjustedDate(), this.geoLocation, zenith, false);
+    }
+    /**
+     * Adjusts the <code>Calendar</code> to deal with edge cases where the location crosses the antimeridian.
+     * @private
+     * @see GeoLocation#getAntimeridianAdjustment()
+     * @return the adjusted Calendar
+     */
+    getAdjustedDate() {
+        return this.date;
+    }
+    /**
+     * Method to return the adjustment to the zenith required to account for the elevation. Since a person at a higher
+     * elevation can see farther below the horizon, the calculation for sunrise / sunset is calculated below the horizon
+     * used at sea level. This is only used for sunrise and sunset and not times before or after it such as
+     * {@link getBeginNauticalTwilight() nautical twilight} since those
+     * calculations are based on the level of available light at the given dip below the horizon, something that is not
+     * affected by elevation, the adjustment should only made if the zenith == 90&deg; {@link adjustZenith adjusted}
+     * for refraction and solar radius. The algorithm used is
+     *
+     * <pre>
+     * elevationAdjustment = Math.toDegrees(Math.acos(earthRadiusInMeters / (earthRadiusInMeters + elevationMeters)));
+     * </pre>
+     *
+     * The source of this algorithm is <a href="http://www.calendarists.com">Calendrical Calculations</a> by Edward M.
+     * Reingold and Nachum Dershowitz. An alternate algorithm that produces an almost identical (but not accurate)
+     * result found in Ma'aglay Tzedek by Moishe Kosower and other sources is:
+     *
+     * <pre>
+     * elevationAdjustment = 0.0347 * Math.sqrt(elevationMeters);
+     * </pre>
+     *
+     * @param {number} elevation
+     *            elevation in Meters.
+     * @return {number} the adjusted zenith
+     */
+    getElevationAdjustment(elevation) {
+        // double elevationAdjustment = 0.0347 * Math.sqrt(elevation);
+        const elevationAdjustment = radiansToDegrees(Math.acos(earthRadius / (earthRadius + elevation / 1000)));
+        return elevationAdjustment;
+    }
+    /**
+     * Adjusts the zenith of astronomical sunrise and sunset to account for solar refraction, solar radius and
+     * elevation. The value for Sun's zenith and true rise/set Zenith (used in this class and subclasses) is the angle
+     * that the center of the Sun makes to a line perpendicular to the Earth's surface. If the Sun were a point and the
+     * Earth were without an atmosphere, true sunset and sunrise would correspond to a 90&deg; zenith. Because the Sun
+     * is not a point, and because the atmosphere refracts light, this 90&deg; zenith does not, in fact, correspond to
+     * true sunset or sunrise, instead the centre of the Sun's disk must lie just below the horizon for the upper edge
+     * to be obscured. This means that a zenith of just above 90&deg; must be used. The Sun subtends an angle of 16
+     * minutes of arc, and atmospheric refraction
+     * accounts for 34 minutes or so, giving a total
+     * of 50 arcminutes. The total value for ZENITH is 90+(5/6) or 90.8333333&deg; for true sunrise/sunset. Since a
+     * person at an elevation can see blow the horizon of a person at sea level, this will also adjust the zenith to
+     * account for elevation if available. Note that this will only adjust the value if the zenith is exactly 90 degrees.
+     * For values below and above this no correction is done. As an example, astronomical twilight is when the sun is
+     * 18&deg; below the horizon or {@link ASTRONOMICAL_ZENITH 108&deg;
+     * below the zenith}. This is traditionally calculated with none of the above mentioned adjustments. The same goes
+     * for various <em>tzais</em> and <em>alos</em> times such as the
+     * {@link ZmanimCalendar#ZENITH_16_POINT_1 16.1&deg;} dip used in
+     * {@link ComplexZmanimCalendar#getAlos16Point1Degrees}.
+     *
+     * @param {number} zenith
+     *            the azimuth below the vertical zenith of 90&deg;. For sunset typically the {@link adjustZenith
+     *            zenith} used for the calculation uses geometric zenith of 90&deg; and {@link adjustZenith adjusts}
+     *            this slightly to account for solar refraction and the sun's radius. Another example would be
+     *            {@link getEndNauticalTwilight} that passes
+     *            {@link NAUTICAL_ZENITH} to this method.
+     * @param {number} elevation
+     *            elevation in Meters.
+     * @return {number} The zenith adjusted to include the sun's radius, refracton
+     *         and {@link getElevationAdjustment elevation} adjustment. This will only be adjusted for
+     *         sunrise and sunset (if the zenith == 90&deg;)
+     * @see getElevationAdjustment
+     */
+    adjustZenith(zenith, elevation) {
+        let adjustedZenith = zenith;
+        if (zenith === NOAACalculator.GEOMETRIC_ZENITH) {
+            // only adjust if it is exactly sunrise or sunset
+            adjustedZenith =
+                zenith +
+                    (solarRadius + refraction + this.getElevationAdjustment(elevation));
+        }
+        return adjustedZenith;
+    }
+    /**
+     * A method that calculates UTC sunrise as well as any time based on an angle above or below sunrise.
+     * @param date
+     *            Used to calculate day of year.
+     * @param geoLocation
+     *            The location information used for astronomical calculating sun times.
+     * @param zenith
+     *            the azimuth below the vertical zenith of 90 degrees. for sunrise typically the {@link adjustZenith
+     *            zenith} used for the calculation uses geometric zenith of 90&deg; and {@link adjustZenith adjusts}
+     *            this slightly to account for solar refraction and the sun's radius. Another example would be
+     *            {@link getBeginNauticalTwilight} that passes
+     *            {@link NAUTICAL_ZENITH} to this method.
+     * @param adjustForElevation
+     *            Should the time be adjusted for elevation
+     * @return The UTC time of sunrise in 24 hour format. 5:45:00 AM will return 5.75.0. If an error was encountered in
+     *         the calculation (expected behavior for some locations such as near the poles,
+     *         `NaN` will be returned.
+     */
+    getUTCSunrise(date, geoLocation, zenith, adjustForElevation) {
+        const elevation = adjustForElevation
+            ? geoLocation.getElevation()
+            : 0;
+        const adjustedZenith = this.adjustZenith(zenith, elevation);
+        let sunrise = NOAACalculator.getSunriseUTC(NOAACalculator.getJulianDay(date), geoLocation.getLatitude(), -geoLocation.getLongitude(), adjustedZenith);
+        sunrise = sunrise / 60;
+        // ensure that the time is >= 0 and < 24
+        while (sunrise < 0) {
+            sunrise += 24;
+        }
+        while (sunrise >= 24) {
+            sunrise -= 24;
+        }
+        return sunrise;
+    }
+    /**
+     * A method that calculates UTC sunset as well as any time based on an angle above or below sunset.
+     * @param date
+     *            Used to calculate day of year.
+     * @param geoLocation
+     *            The location information used for astronomical calculating sun times.
+     * @param zenith
+     *            the azimuth below the vertical zenith of 90&deg;. For sunset typically the {@link adjustZenith
+     *            zenith} used for the calculation uses geometric zenith of 90&deg; and {@link adjustZenith adjusts}
+     *            this slightly to account for solar refraction and the sun's radius. Another example would be
+     *            {@link getEndNauticalTwilight} that passes
+     *            {@link NAUTICAL_ZENITH} to this method.
+     * @param adjustForElevation
+     *            Should the time be adjusted for elevation
+     * @return The UTC time of sunset in 24 hour format. 5:45:00 AM will return 5.75.0. If an error was encountered in
+     *         the calculation (expected behavior for some locations such as near the poles,
+     *         `NaN` will be returned.
+     */
+    getUTCSunset(date, geoLocation, zenith, adjustForElevation) {
+        const elevation = adjustForElevation
+            ? geoLocation.getElevation()
+            : 0;
+        const adjustedZenith = this.adjustZenith(zenith, elevation);
+        let sunset = NOAACalculator.getSunsetUTC(NOAACalculator.getJulianDay(date), geoLocation.getLatitude(), -geoLocation.getLongitude(), adjustedZenith);
+        sunset = sunset / 60;
+        // ensure that the time is >= 0 and < 24
+        while (sunset < 0) {
+            sunset += 24;
+        }
+        while (sunset >= 24) {
+            sunset -= 24;
+        }
+        return sunset;
+    }
+    /**
+     * A utility method that will allow the calculation of a temporal (solar) hour based on the sunrise and sunset
+     * passed as parameters to this method. An example of the use of this method would be the calculation of a
+     * non-elevation adjusted temporal hour by passing in {@link getSeaLevelSunrise() sea level sunrise} and
+     * {@link getSeaLevelSunset() sea level sunset} as parameters.
+     *
+     * @param {Temporal.ZonedDateTime | null} startOfDay
+     *            The start of the day.
+     * @param {Temporal.ZonedDateTime | null} endOfDay
+     *            The end of the day.
+     *
+     * @return {number} the <code>long</code> millisecond length of the temporal hour. If the calculation can't be computed a
+     *         `NaN` will be returned. See detailed explanation on top of the page.
+     *
+     * @see getTemporalHour()
+     */
+    getTemporalHour(startOfDay = this.getSeaLevelSunrise(), endOfDay = this.getSeaLevelSunset()) {
+        if (startOfDay === null || endOfDay === null) {
+            return NaN;
+        }
+        const delta = endOfDay.epochMilliseconds - startOfDay.epochMilliseconds;
+        return Math.floor(delta / 12);
+    }
+    /**
+     * A method that returns sundial or solar noon. It occurs when the Sun is <a href
+     * ="http://en.wikipedia.org/wiki/Transit_%28astronomy%29">transiting</a> the <a
+     * href="http://en.wikipedia.org/wiki/Meridian_%28astronomy%29">celestial meridian</a>. In this class it is
+     * calculated as halfway between the sunrise and sunset passed to this method. This time can be slightly off the
+     * real transit time due to changes in declination (the lengthening or shortening day).
+     *
+     * @param {Temporal.ZonedDateTime | null} startOfDay
+     *            the start of day for calculating the sun's transit. This can be sea level sunrise, visual sunrise (or
+     *            any arbitrary start of day) passed to this method.
+     * @param {Temporal.ZonedDateTime | null} endOfDay
+     *            the end of day for calculating the sun's transit. This can be sea level sunset, visual sunset (or any
+     *            arbitrary end of day) passed to this method.
+     *
+     * @return {Temporal.ZonedDateTime | null} The `Date` representing Sun's transit. If the calculation can't be computed such as in the
+     *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
+     *         not set, null will be returned. See detailed explanation on top of the page.
+     */
+    getSunTransit(startOfDay = this.getSeaLevelSunrise(), endOfDay = this.getSeaLevelSunset()) {
+        const temporalHour = this.getTemporalHour(startOfDay, endOfDay);
+        return NOAACalculator.getTimeOffset(startOfDay, temporalHour * 6);
+    }
+    /**
+     * A method that returns a `Date` from the time passed in as a parameter.
+     * @protected
+     * @param {number} time
+     *            The time to be set as the time for the `Date`. The time expected is in the format: 18.75
+     *            for 6:45:00 PM.
+     * @param {boolean} isSunrise true if the time is sunrise, and false if it is sunset
+     * @return {Temporal.ZonedDateTime | null} The Date.
+     */
+    getDateFromTime(time, isSunrise) {
+        if (isNaN(time)) {
+            return null;
+        }
+        let calculatedTime = time;
+        let cal = this.getAdjustedDate();
+        //    let cal = new Temporal.PlainDate(adj.year, adj.month, adj.day);
+        const hours = Math.trunc(calculatedTime); // retain only the hours
+        calculatedTime -= hours;
+        const minutes = Math.trunc((calculatedTime *= 60)); // retain only the minutes
+        calculatedTime -= minutes;
+        const seconds = Math.trunc((calculatedTime *= 60)); // retain only the seconds
+        calculatedTime -= seconds; // remaining milliseconds
+        // Check if a date transition has occurred, or is about to occur - this indicates the date of the event is
+        // actually not the target date, but the day prior or after
+        const localTimeHours = Math.trunc(this.geoLocation.getLongitude() / 15);
+        if (isSunrise && localTimeHours + hours > 18) {
+            cal = cal.add({ days: -1 });
+            //      cal = cal.minus({days: 1});
+        }
+        else if (!isSunrise && localTimeHours + hours < 6) {
+            cal = cal.add({ days: 1 });
+        }
+        return cal
+            .toZonedDateTime({
+            timeZone: 'UTC',
+            plainTime: new Temporal.PlainTime(hours, minutes, seconds, Math.trunc(calculatedTime * 1000)),
+        })
+            .withTimeZone(this.geoLocation.getTimeZone());
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a> from a Java Calendar
+     * @private
+     * @param {Temporal.ZonedDateTime} date
+     *            The Java Calendar
+     * @return the Julian day corresponding to the date Note: Number is returned for start of day. Fractional days
+     *         should be added later.
+     */
+    static getJulianDay(date) {
+        let { year, month } = date;
+        const { day } = date;
+        if (month <= 2) {
+            year -= 1;
+            month += 12;
+        }
+        const a = Math.trunc(year / 100);
+        const b = Math.trunc(2 - a + a / 4);
+        return (Math.floor(365.25 * (year + 4716)) +
+            Math.floor(30.6001 * (month + 1)) +
+            day +
+            b -
+            1524.5);
+    }
+    /**
+     * Convert <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a> to centuries since J2000.0.
+     * @private
+     * @param julianDay
+     *            the Julian Day to convert
+     * @return the centuries since 2000 Julian corresponding to the Julian Day
+     */
+    static getJulianCenturiesFromJulianDay(julianDay) {
+        return ((julianDay - NOAACalculator.JULIAN_DAY_JAN_1_2000) /
+            NOAACalculator.JULIAN_DAYS_PER_CENTURY);
+    }
+    /**
+     * Convert centuries since J2000.0 to <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a>.
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the Julian Day corresponding to the Julian centuries passed in
+     */
+    static getJulianDayFromJulianCenturies(julianCenturies) {
+        return (julianCenturies * NOAACalculator.JULIAN_DAYS_PER_CENTURY +
+            NOAACalculator.JULIAN_DAY_JAN_1_2000);
+    }
+    /**
+     * Returns the Geometric <a href="http://en.wikipedia.org/wiki/Mean_longitude">Mean Longitude</a> of the Sun.
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the Geometric Mean Longitude of the Sun in degrees
+     */
+    static getSunGeometricMeanLongitude(julianCenturies) {
+        let longitude = 280.46646 + julianCenturies * (36000.76983 + 0.0003032 * julianCenturies);
+        while (longitude > 360) {
+            longitude -= 360;
+        }
+        while (longitude < 0) {
+            longitude += 360;
+        }
+        return longitude; // in degrees
+    }
+    /**
+     * Returns the Geometric <a href="http://en.wikipedia.org/wiki/Mean_anomaly">Mean Anomaly</a> of the Sun.
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the Geometric Mean Anomaly of the Sun in degrees
+     */
+    static getSunGeometricMeanAnomaly(julianCenturies) {
+        return (357.52911 + julianCenturies * (35999.05029 - 0.0001537 * julianCenturies)); // in degrees
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Eccentricity_%28orbit%29">eccentricity of earth's orbit</a>.
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the unitless eccentricity
+     */
+    static getEarthOrbitEccentricity(julianCenturies) {
+        return (0.016708634 -
+            julianCenturies * (0.000042037 + 0.0000001267 * julianCenturies)); // unitless
+    }
+    /**
+     * Returns the <a href="http://en.wikipedia.org/wiki/Equation_of_the_center">equation of center</a> for the sun.
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the equation of center for the sun in degrees
+     */
+    static getSunEquationOfCenter(julianCenturies) {
+        const m = NOAACalculator.getSunGeometricMeanAnomaly(julianCenturies);
+        const mrad = degreesToRadians(m);
+        const sinm = Math.sin(mrad);
+        const sin2m = Math.sin(mrad + mrad);
+        const sin3m = Math.sin(mrad + mrad + mrad);
+        return (sinm *
+            (1.914602 - julianCenturies * (0.004817 + 0.000014 * julianCenturies)) +
+            sin2m * (0.019993 - 0.000101 * julianCenturies) +
+            sin3m * 0.000289); // in degrees
+    }
+    /**
+     * Return the true longitude of the sun
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the sun's true longitude in degrees
+     */
+    static getSunTrueLongitude(julianCenturies) {
+        const sunLongitude = NOAACalculator.getSunGeometricMeanLongitude(julianCenturies);
+        const center = NOAACalculator.getSunEquationOfCenter(julianCenturies);
+        return sunLongitude + center; // in degrees
+    }
+    /**
+     * Return the apparent longitude of the sun
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return sun's apparent longitude in degrees
+     */
+    static getSunApparentLongitude(julianCenturies) {
+        const sunTrueLongitude = NOAACalculator.getSunTrueLongitude(julianCenturies);
+        const omega = 125.04 - 1934.136 * julianCenturies;
+        const lambda = sunTrueLongitude - 0.00569 - 0.00478 * Math.sin(degreesToRadians(omega));
+        return lambda; // in degrees
+    }
+    /**
+     * Returns the mean <a href="http://en.wikipedia.org/wiki/Axial_tilt">obliquity of the ecliptic</a> (Axial tilt).
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the mean obliquity in degrees
+     */
+    static getMeanObliquityOfEcliptic(julianCenturies) {
+        const seconds = 21.448 -
+            julianCenturies *
+                (46.815 + julianCenturies * (0.00059 - julianCenturies * 0.001813));
+        return 23 + (26 + seconds / 60) / 60; // in degrees
+    }
+    /**
+     * Returns the corrected <a href="http://en.wikipedia.org/wiki/Axial_tilt">obliquity of the ecliptic</a> (Axial
+     * tilt).
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return the corrected obliquity in degrees
+     */
+    static getObliquityCorrection(julianCenturies) {
+        const obliquityOfEcliptic = NOAACalculator.getMeanObliquityOfEcliptic(julianCenturies);
+        const omega = 125.04 - 1934.136 * julianCenturies;
+        return obliquityOfEcliptic + 0.00256 * Math.cos(degreesToRadians(omega)); // in degrees
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Declination">declination</a> of the sun.
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return
+     *            the sun's declination in degrees
+     */
+    static getSunDeclination(julianCenturies) {
+        const obliquityCorrection = NOAACalculator.getObliquityCorrection(julianCenturies);
+        const lambda = NOAACalculator.getSunApparentLongitude(julianCenturies);
+        const sint = Math.sin(degreesToRadians(obliquityCorrection)) *
+            Math.sin(degreesToRadians(lambda));
+        const theta = radiansToDegrees(Math.asin(sint));
+        return theta; // in degrees
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Equation_of_time">Equation of Time</a> - the difference between
+     * true solar time and mean solar time
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @return equation of time in minutes of time
+     */
+    static getEquationOfTime(julianCenturies) {
+        const epsilon = NOAACalculator.getObliquityCorrection(julianCenturies);
+        const geomMeanLongSun = NOAACalculator.getSunGeometricMeanLongitude(julianCenturies);
+        const eccentricityEarthOrbit = NOAACalculator.getEarthOrbitEccentricity(julianCenturies);
+        const geomMeanAnomalySun = NOAACalculator.getSunGeometricMeanAnomaly(julianCenturies);
+        let y = Math.tan(degreesToRadians(epsilon) / 2);
+        y *= y;
+        const sin2l0 = Math.sin(2 * degreesToRadians(geomMeanLongSun));
+        const sinm = Math.sin(degreesToRadians(geomMeanAnomalySun));
+        const cos2l0 = Math.cos(2 * degreesToRadians(geomMeanLongSun));
+        const sin4l0 = Math.sin(4 * degreesToRadians(geomMeanLongSun));
+        const sin2m = Math.sin(2 * degreesToRadians(geomMeanAnomalySun));
+        const equationOfTime = y * sin2l0 -
+            2 * eccentricityEarthOrbit * sinm +
+            4 * eccentricityEarthOrbit * y * sinm * cos2l0 -
+            0.5 * y * y * sin4l0 -
+            1.25 * eccentricityEarthOrbit * eccentricityEarthOrbit * sin2m;
+        return radiansToDegrees(equationOfTime) * 4; // in minutes of time
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Hour_angle">hour angle</a> of the sun at sunrise for the
+     * latitude.
+     * @private
+     * @param {number} lat
+     *            , the latitude of observer in degrees
+     * @param solarDec
+     *            the declination angle of sun in degrees
+     * @param {number} zenith
+     *            the zenith
+     * @return hour angle of sunrise in radians
+     */
+    static getSunHourAngleAtSunrise(lat, solarDec, zenith) {
+        const latRad = degreesToRadians(lat);
+        const sdRad = degreesToRadians(solarDec);
+        return Math.acos(Math.cos(degreesToRadians(zenith)) /
+            (Math.cos(latRad) * Math.cos(sdRad)) -
+            Math.tan(latRad) * Math.tan(sdRad)); // in radians
+    }
+    /**
+     * Returns the <a href="http://en.wikipedia.org/wiki/Hour_angle">hour angle</a> of the sun at sunset for the
+     * latitude.
+     * @private
+     * @param {number} lat
+     *            the latitude of observer in degrees
+     * @param solarDec
+     *            the declination angle of sun in degrees
+     * @param {number} zenith
+     *            the zenith
+     * @return the hour angle of sunset in radians
+     */
+    static getSunHourAngleAtSunset(lat, solarDec, zenith) {
+        const latRad = degreesToRadians(lat);
+        const sdRad = degreesToRadians(solarDec);
+        const hourAngle = Math.acos(Math.cos(degreesToRadians(zenith)) /
+            (Math.cos(latRad) * Math.cos(sdRad)) -
+            Math.tan(latRad) * Math.tan(sdRad));
+        return -hourAngle; // in radians
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Celestial_coordinate_system">Solar Elevation</a> for the
+     * horizontal coordinate system at the given location at the given time. Can be negative if the sun is below the
+     * horizon. Not corrected for altitude.
+     *
+     * @param {Temporal.ZonedDateTime} date
+     *            time of calculation
+     * @param {number} lat
+     *            latitude of location for calculation
+     * @param {number} lon
+     *            longitude of location for calculation
+     * @return {number} solar elevation in degrees - horizon is 0 degrees, civil twilight is -6 degrees
+     */
+    static getSolarElevation(date, lat, lon) {
+        const julianDay = NOAACalculator.getJulianDay(date.toPlainDate());
+        const julianCenturies = NOAACalculator.getJulianCenturiesFromJulianDay(julianDay);
+        const equationOfTime = NOAACalculator.getEquationOfTime(julianCenturies);
+        let longitude = date.hour + 12 + (date.minute + equationOfTime + date.second / 60) / 60;
+        longitude = -((longitude * 360) / 24) % 360;
+        const hourAngleRad = degreesToRadians(lon - longitude);
+        const declination = NOAACalculator.getSunDeclination(julianCenturies);
+        const decRad = degreesToRadians(declination);
+        const latRad = degreesToRadians(lat);
+        return radiansToDegrees(Math.asin(Math.sin(latRad) * Math.sin(decRad) +
+            Math.cos(latRad) * Math.cos(decRad) * Math.cos(hourAngleRad)));
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Celestial_coordinate_system">Solar Azimuth</a> for the
+     * horizontal coordinate system at the given location at the given time. Not corrected for altitude. True south is 0
+     * degrees.
+     *
+     * @param {Temporal.ZonedDateTime} date
+     *            time of calculation
+     * @param {number} latitude
+     *            latitude of location for calculation
+     * @param {number} lon
+     *            longitude of location for calculation
+     * @return {number}
+     */
+    static getSolarAzimuth(date, latitude, lon) {
+        const julianDay = NOAACalculator.getJulianDay(date.toPlainDate());
+        const julianCenturies = NOAACalculator.getJulianCenturiesFromJulianDay(julianDay);
+        const equationOfTime = NOAACalculator.getEquationOfTime(julianCenturies);
+        let longitude = date.hour + 12 + (date.minute + equationOfTime + date.second / 60) / 60;
+        longitude = -((longitude * 360) / 24) % 360;
+        const hourAngleRad = degreesToRadians(lon - longitude);
+        const declination = NOAACalculator.getSunDeclination(julianCenturies);
+        const decRad = degreesToRadians(declination);
+        const latRad = degreesToRadians(latitude);
+        return (radiansToDegrees(Math.atan(Math.sin(hourAngleRad) /
+            (Math.cos(hourAngleRad) * Math.sin(latRad) -
+                Math.tan(decRad) * Math.cos(latRad)))) + 180);
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Universal_Coordinated_Time">Universal Coordinated Time</a> (UTC)
+     * of sunrise for the given day at the given location on earth
+     * @private
+     * @param julianDay
+     *            the Julian day
+     * @param {number} latitude
+     *            the latitude of observer in degrees
+     * @param {number} longitude
+     *            the longitude of observer in degrees
+     * @param {number} zenith
+     *            the zenith
+     * @return the time in minutes from zero UTC
+     */
+    static getSunriseUTC(julianDay, latitude, longitude, zenith) {
+        const julianCenturies = NOAACalculator.getJulianCenturiesFromJulianDay(julianDay);
+        // Find the time of solar noon at the location, and use that declination. This is better than start of the
+        // Julian day
+        const noonmin = NOAACalculator.getSolarNoonUTC(julianCenturies, longitude);
+        const tnoon = NOAACalculator.getJulianCenturiesFromJulianDay(julianDay + noonmin / 1440);
+        // First pass to approximate sunrise (using solar noon)
+        let eqTime = NOAACalculator.getEquationOfTime(tnoon);
+        let solarDec = NOAACalculator.getSunDeclination(tnoon);
+        let hourAngle = NOAACalculator.getSunHourAngleAtSunrise(latitude, solarDec, zenith);
+        let delta = longitude - radiansToDegrees(hourAngle);
+        let timeDiff = 4 * delta; // in minutes of time
+        let timeUTC = 720 + timeDiff - eqTime; // in minutes
+        // Second pass includes fractional Julian Day in gamma calc
+        const newt = NOAACalculator.getJulianCenturiesFromJulianDay(NOAACalculator.getJulianDayFromJulianCenturies(julianCenturies) +
+            timeUTC / 1440);
+        eqTime = NOAACalculator.getEquationOfTime(newt);
+        solarDec = NOAACalculator.getSunDeclination(newt);
+        hourAngle = NOAACalculator.getSunHourAngleAtSunrise(latitude, solarDec, zenith);
+        delta = longitude - radiansToDegrees(hourAngle);
+        timeDiff = 4 * delta;
+        timeUTC = 720 + timeDiff - eqTime; // in minutes
+        return timeUTC;
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Universal_Coordinated_Time">Universal Coordinated Time</a> (UTC)
+     * of <a href="http://en.wikipedia.org/wiki/Noon#Solar_noon">solar noon</a> for the given day at the given location
+     * on earth.
+     * @private
+     * @param julianCenturies
+     *            the number of Julian centuries since J2000.0
+     * @param {number} longitude
+     *            the longitude of observer in degrees
+     * @return the time in minutes from zero UTC
+     */
+    static getSolarNoonUTC(julianCenturies, longitude) {
+        // First pass uses approximate solar noon to calculate eqtime
+        const tnoon = NOAACalculator.getJulianCenturiesFromJulianDay(NOAACalculator.getJulianDayFromJulianCenturies(julianCenturies) +
+            longitude / 360);
+        let eqTime = NOAACalculator.getEquationOfTime(tnoon);
+        const solNoonUTC = 720 + longitude * 4 - eqTime; // min
+        const newt = NOAACalculator.getJulianCenturiesFromJulianDay(NOAACalculator.getJulianDayFromJulianCenturies(julianCenturies) -
+            0.5 +
+            solNoonUTC / 1440);
+        eqTime = NOAACalculator.getEquationOfTime(newt);
+        return 720 + longitude * 4 - eqTime; // min
+    }
+    /**
+     * Return the <a href="http://en.wikipedia.org/wiki/Universal_Coordinated_Time">Universal Coordinated Time</a> (UTC)
+     * of sunset for the given day at the given location on earth
+     * @private
+     * @param julianDay
+     *            the Julian day
+     * @param {number} latitude
+     *            the latitude of observer in degrees
+     * @param {number} longitude
+     *            : longitude of observer in degrees
+     * @param {number} zenith
+     *            the zenith
+     * @return the time in minutes from zero Universal Coordinated Time (UTC)
+     */
+    static getSunsetUTC(julianDay, latitude, longitude, zenith) {
+        const julianCenturies = NOAACalculator.getJulianCenturiesFromJulianDay(julianDay);
+        // Find the time of solar noon at the location, and use that declination. This is better than start of the
+        // Julian day
+        const noonmin = NOAACalculator.getSolarNoonUTC(julianCenturies, longitude);
+        const tnoon = NOAACalculator.getJulianCenturiesFromJulianDay(julianDay + noonmin / 1440);
+        // First calculates sunrise and approx length of day
+        let eqTime = NOAACalculator.getEquationOfTime(tnoon);
+        let solarDec = NOAACalculator.getSunDeclination(tnoon);
+        let hourAngle = NOAACalculator.getSunHourAngleAtSunset(latitude, solarDec, zenith);
+        let delta = longitude - radiansToDegrees(hourAngle);
+        let timeDiff = 4 * delta;
+        let timeUTC = 720 + timeDiff - eqTime;
+        // Second pass includes fractional Julian Day in gamma calc
+        const newt = NOAACalculator.getJulianCenturiesFromJulianDay(NOAACalculator.getJulianDayFromJulianCenturies(julianCenturies) +
+            timeUTC / 1440);
+        eqTime = NOAACalculator.getEquationOfTime(newt);
+        solarDec = NOAACalculator.getSunDeclination(newt);
+        hourAngle = NOAACalculator.getSunHourAngleAtSunset(latitude, solarDec, zenith);
+        delta = longitude - radiansToDegrees(hourAngle);
+        timeDiff = 4 * delta;
+        timeUTC = 720 + timeDiff - eqTime; // in minutes
+        return timeUTC;
+    }
+}
+/**
+ * The zenith of astronomical sunrise and sunset. The sun is 90&deg; from the vertical 0&deg;
+ * @private
+ */
+NOAACalculator.GEOMETRIC_ZENITH = 90;
+/**
+ * Default value for Sun's zenith and true rise/set Zenith (used in this class and subclasses) is the angle that the
+ * center of the Sun makes to a line perpendicular to the Earth's surface. If the Sun were a point and the Earth
+ * were without an atmosphere, true sunset and sunrise would correspond to a 90&deg; zenith. Because the Sun is not
+ * a point, and because the atmosphere refracts light, this 90&deg; zenith does not, in fact, correspond to true
+ * sunset or sunrise, instead the center of the Sun's disk must lie just below the horizon for the upper edge to be
+ * obscured. This means that a zenith of just above 90&deg; must be used. The Sun subtends an angle of 16 minutes of
+ * arc, and atmospheric refraction accounts for
+ * 34 minutes or so, giving a total of 50
+ * arcminutes. The total value for ZENITH is 90+(5/6) or 90.8333333&deg; for true sunrise/sunset.
+ */
+// const ZENITH: number = GEOMETRIC_ZENITH + 5.0 / 6.0;
+/** Sun's zenith at civil twilight (96&deg;). */
+NOAACalculator.CIVIL_ZENITH = 96;
+/** Sun's zenith at nautical twilight (102&deg;). */
+NOAACalculator.NAUTICAL_ZENITH = 102;
+/** Sun's zenith at astronomical twilight (108&deg;). */
+NOAACalculator.ASTRONOMICAL_ZENITH = 108;
+/**
+ * The <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a> of January 1, 2000
+ * @private
+ */
+NOAACalculator.JULIAN_DAY_JAN_1_2000 = 2451545;
+/**
+ * Julian days per century
+ * @private
+ */
+NOAACalculator.JULIAN_DAYS_PER_CENTURY = 36525;
+
 /*
     Hebcal - A Jewish Calendar Generator
     Copyright (c) 1994-2020 Danny Sadinoff
@@ -466,7 +3428,7 @@ function getFormatter(tzid) {
     return f;
 }
 /** Class representing Location */
-class Location extends noaa.GeoLocation {
+class Location extends GeoLocation {
     /**
      * Initialize a Location instance
      * @param latitude - Latitude as a decimal, valid range -90 thru +90 (e.g. 41.85003)
@@ -650,9 +3612,9 @@ function zdtToDate(zdt) {
     return res;
 }
 function getDate(date) {
-    if (hdate.isDate(date))
+    if (isDate(date))
         return date;
-    if (hdate.HDate.isHDate(date))
+    if (HDate.isHDate(date))
         return date.greg();
     throw new TypeError(`invalid date: ${date}`);
 }
@@ -703,7 +3665,7 @@ class Zmanim {
             month: dt.getMonth() + 1,
             day: dt.getDate(),
         });
-        this.noaa = new noaa.NOAACalculator(gloc, plainDate);
+        this.noaa = new NOAACalculator(gloc, plainDate);
         this.useElevation = Boolean(useElevation);
     }
     /**
@@ -858,7 +3820,7 @@ class Zmanim {
             : this.noaa.getSeaLevelSunset();
         const temporalHour = this.noaa.getTemporalHour(startOfDay, endOfDay);
         const offset = Math.round(temporalHour * hours);
-        const zdt = noaa.NOAACalculator.getTimeOffset(startOfDay, offset);
+        const zdt = NOAACalculator.getTimeOffset(startOfDay, offset);
         return zdtToDate(zdt);
     }
     /**
@@ -1106,11 +4068,11 @@ class Zmanim {
      * @param date
      */
     static timeZoneOffset(tzid, date) {
-        const offset = hdate.getTimezoneOffset(tzid, date);
+        const offset = getTimezoneOffset(tzid, date);
         const offsetAbs = Math.abs(offset);
         const hours = Math.floor(offsetAbs / 60);
         const minutes = offsetAbs % 60;
-        return (offset < 0 ? '+' : '-') + hdate.pad2(hours) + ':' + hdate.pad2(minutes);
+        return (offset < 0 ? '+' : '-') + pad2(hours) + ':' + pad2(minutes);
     }
     /**
      * Returns a string like "2022-04-01T13:06:00-11:00"
@@ -1121,7 +4083,7 @@ class Zmanim {
         if (isNaN(date.getTime())) {
             return '0000-00-00T00:00:00Z';
         }
-        return (hdate.getPseudoISO(tzid, date).substring(0, 19) +
+        return (getPseudoISO(tzid, date).substring(0, 19) +
             Zmanim.timeZoneOffset(tzid, date));
     }
     /**
@@ -1192,7 +4154,7 @@ class Zmanim {
     static makeSunsetAwareHDate(gloc, date, useElevation) {
         const zmanim = new Zmanim(gloc, date, useElevation);
         const sunset = zmanim.sunset();
-        let hd = new hdate.HDate(date);
+        let hd = new HDate(date);
         const sunsetMillis = sunset.getTime();
         if (isNaN(sunsetMillis)) {
             return hd;
@@ -1274,14 +4236,14 @@ class TimedEvent extends Event {
      * @param [locale] Optional locale name (defaults to active locale).
      */
     render(locale) {
-        return hdate.Locale.gettext(this.getDesc(), locale) + ': ' + this.fmtTime;
+        return Locale.gettext(this.getDesc(), locale) + ': ' + this.fmtTime;
     }
     /**
      * Returns translation of "Candle lighting" without the time.
      * @param [locale] Optional locale name (defaults to active locale).
      */
     renderBrief(locale) {
-        return hdate.Locale.gettext(this.getDesc(), locale);
+        return Locale.gettext(this.getDesc(), locale);
     }
     getCategories() {
         const desc = this.getDesc();
@@ -1329,9 +4291,9 @@ class HavdalahEvent extends TimedEvent {
      * @param [locale] Optional locale name (defaults to active locale).
      */
     renderBrief(locale) {
-        let str = hdate.Locale.gettext(this.getDesc(), locale);
+        let str = Locale.gettext(this.getDesc(), locale);
         if (this.havdalahMins) {
-            const min = hdate.Locale.gettext('min', locale);
+            const min = Locale.gettext('min', locale);
             str += ` (${this.havdalahMins} ${min})`;
         }
         return str;
@@ -1341,17 +4303,17 @@ class HavdalahEvent extends TimedEvent {
     }
 }
 
-const Nisan = hdate.months.NISAN;
-const Iyyar = hdate.months.IYYAR;
-const Sivan = hdate.months.SIVAN;
-const Tamuz = hdate.months.TAMUZ;
-const Av = hdate.months.AV;
-const Elul = hdate.months.ELUL;
-const Tishrei = hdate.months.TISHREI;
-const Cheshvan = hdate.months.CHESHVAN;
-const Kislev = hdate.months.KISLEV;
-const Shvat = hdate.months.SHVAT;
-const Adar2 = hdate.months.ADAR_II;
+const Nisan = months.NISAN;
+const Iyyar = months.IYYAR;
+const Sivan = months.SIVAN;
+const Tamuz = months.TAMUZ;
+const Av = months.AV;
+const Elul = months.ELUL;
+const Tishrei = months.TISHREI;
+const Cheshvan = months.CHESHVAN;
+const Kislev = months.KISLEV;
+const Shvat = months.SHVAT;
+const Adar2 = months.ADAR_II;
 const CHAG$1 = flags.CHAG;
 const LIGHT_CANDLES$2 = flags.LIGHT_CANDLES;
 const YOM_TOV_ENDS$1 = flags.YOM_TOV_ENDS;
@@ -1955,7 +4917,7 @@ const staticModernHolidays = [
     // https://www.gov.il/he/departments/policies/2012_des5234
     {
         firstYear: 5773,
-        mm: hdate.months.TEVET,
+        mm: months.TEVET,
         dd: 21,
         desc: HEBREW_LANGUAGE_DAY,
         friSatMovetoThu: true,
@@ -2060,7 +5022,7 @@ class HolidayEvent extends Event {
  */
 class AsaraBTevetEvent extends HolidayEvent {
     urlDateSuffix() {
-        const isoDate = hdate.isoDateString(this.getDate().greg());
+        const isoDate = isoDateString(this.getDate().greg());
         return isoDate.replace(/-/g, '');
     }
 }
@@ -2095,7 +5057,7 @@ class RoshHashanaEvent extends HolidayEvent {
      * @param [locale] Optional locale name (defaults to active locale).
      */
     render(locale) {
-        return hdate.Locale.gettext('Rosh Hashana', locale) + ' ' + this.hyear;
+        return Locale.gettext('Rosh Hashana', locale) + ' ' + this.hyear;
     }
     getEmoji() {
         return '🍏🍯';
@@ -2118,9 +5080,9 @@ class RoshChodeshEvent extends HolidayEvent {
      */
     render(locale) {
         const monthName = this.getDesc().substring(roshChodeshStr.length + 1);
-        const monthName0 = hdate.Locale.gettext(monthName, locale);
+        const monthName0 = Locale.gettext(monthName, locale);
         const monthName1 = monthName0.replace(/'/g, '’');
-        return hdate.Locale.gettext(roshChodeshStr, locale) + ' ' + monthName1;
+        return Locale.gettext(roshChodeshStr, locale) + ' ' + monthName1;
     }
     basename() {
         return this.getDesc();
@@ -2241,7 +5203,7 @@ function makeFastStartEnd(ev, options) {
             startEvent = makeTimedEvent(ev, dawn, FAST_BEGINS, options);
         }
         if (dt.getDay() !== 5 &&
-            !(hd.getDate() === 14 && hd.getMonth() === hdate.months.NISAN)) {
+            !(hd.getDate() === 14 && hd.getMonth() === months.NISAN)) {
             const tzeit = zmanim.tzeit(fastEndDeg);
             if (!isNaN(tzeit.getTime())) {
                 endEvent = makeTimedEvent(ev, tzeit, FAST_ENDS, options);
@@ -2324,7 +5286,7 @@ class Molad {
      * @param month
      */
     constructor(year, month) {
-        this.m = hdate.molad(year, month);
+        this.m = molad(year, month);
     }
     /**
      */
@@ -2339,7 +5301,7 @@ class Molad {
     /**
      */
     getMonthName() {
-        return hdate.HDate.getMonthName(this.m.month, this.m.year);
+        return HDate.getMonthName(this.m.month, this.m.year);
     }
     /**
      * @returns Day of Week (0=Sunday, 6=Saturday)
@@ -2371,23 +5333,23 @@ class Molad {
      */
     render(locale, options) {
         var _a;
-        locale = locale !== null && locale !== void 0 ? locale : hdate.Locale.getLocaleName();
+        locale = locale !== null && locale !== void 0 ? locale : Locale.getLocaleName();
         if (typeof locale === 'string') {
             locale = locale.toLowerCase();
         }
         const isHebrewLocale = locale === 'he' || locale === 'he-x-nonikud' || locale === 'h';
         const isFrenchLocale = locale === 'fr';
-        const monthName = hdate.Locale.gettext(this.getMonthName(), locale);
+        const monthName = Locale.gettext(this.getMonthName(), locale);
         const dayNames = isHebrewLocale ? heDayNames : (isFrenchLocale ? frDayNames : shortDayNames);
         const dow = dayNames[this.getDow()];
         const minutes = this.getMinutes();
         const hour = this.getHour();
         const chalakim = this.getChalakim();
-        const moladStr = hdate.Locale.gettext('Molad', locale);
-        const minutesStr = (_a = hdate.Locale.lookupTranslation('min', locale)) !== null && _a !== void 0 ? _a : 'minutes';
-        const chalakimStr = hdate.Locale.gettext('chalakim', locale);
-        const and = hdate.Locale.gettext('and', locale);
-        const after = hdate.Locale.gettext('after', locale);
+        const moladStr = Locale.gettext('Molad', locale);
+        const minutesStr = (_a = Locale.lookupTranslation('min', locale)) !== null && _a !== void 0 ? _a : 'minutes';
+        const chalakimStr = Locale.gettext('chalakim', locale);
+        const and = Locale.gettext('and', locale);
+        const after = Locale.gettext('after', locale);
         if (isHebrewLocale) {
             const ampm = getHebrewTimeOfDay(hour);
             const result = `${moladStr} ${monthName} יִהְיֶה בַּיּוֹם ${dow} בשָׁבוּעַ, ` +
@@ -2395,7 +5357,7 @@ class Molad {
                 `ו-${minutes} ${minutesStr} ` +
                 `ו-${chalakim} ${chalakimStr}`;
             if (locale === 'he-x-nonikud') {
-                return hdate.Locale.hebrewStripNikkud(result);
+                return Locale.hebrewStripNikkud(result);
             }
             return result;
         }
@@ -2651,23 +5613,23 @@ class OmerEvent extends Event {
      * @param [locale] Optional locale name (defaults to active locale).
      */
     render(locale) {
-        locale = locale !== null && locale !== void 0 ? locale : hdate.Locale.getLocaleName();
+        locale = locale !== null && locale !== void 0 ? locale : Locale.getLocaleName();
         if (typeof locale === 'string') {
             locale = locale.toLowerCase();
         }
         const isHebrewLocale = locale === 'he' || locale === 'he-x-nonikud' || locale === 'h';
         const omer = this.omer;
-        const nth = isHebrewLocale ? hdate.gematriya(omer) : hdate.Locale.ordinal(omer, locale);
-        return nth + ' ' + hdate.Locale.gettext('day of the Omer', locale);
+        const nth = isHebrewLocale ? gematriya(omer) : Locale.ordinal(omer, locale);
+        return nth + ' ' + Locale.gettext('day of the Omer', locale);
     }
     /**
      * Returns translation of "Omer day 22" without ordinal numbers.
      * @param [locale] Optional locale name (defaults to active locale).
      */
     renderBrief(locale) {
-        return (hdate.Locale.gettext('Omer', locale) +
+        return (Locale.gettext('Omer', locale) +
             ' ' +
-            hdate.Locale.gettext('day', locale) +
+            Locale.gettext('day', locale) +
             ' ' +
             this.omer);
     }
@@ -2708,14 +5670,14 @@ class OmerEvent extends Event {
      *  or `הַיוֹם עֲשָׂרָה יָמִים, שְׁהֵם שָׁבוּעַ אֶחָד וְשְׁלוֹשָׁה יָמִים לָעוֹמֶר`
      */
     getTodayIs(locale) {
-        locale = locale !== null && locale !== void 0 ? locale : hdate.Locale.getLocaleName();
+        locale = locale !== null && locale !== void 0 ? locale : Locale.getLocaleName();
         if (typeof locale === 'string') {
             locale = locale.toLowerCase();
         }
         const isHebrew = locale === 'he' || locale === 'he-x-nonikud';
         const str = isHebrew ? omerTodayIsHe(this.omer) : omerTodayIsEn(this.omer);
         if (locale === 'he-x-nonikud') {
-            return hdate.Locale.hebrewStripNikkud(str);
+            return Locale.hebrewStripNikkud(str);
         }
         return str;
     }
@@ -2726,14 +5688,14 @@ class OmerEvent extends Event {
 
 /** @private */
 function renderParshaName(parsha, locale) {
-    const locale0 = locale !== null && locale !== void 0 ? locale : hdate.Locale.getLocaleName();
-    let name = hdate.Locale.gettext(parsha[0], locale0);
+    const locale0 = locale !== null && locale !== void 0 ? locale : Locale.getLocaleName();
+    let name = Locale.gettext(parsha[0], locale0);
     if (parsha.length === 2) {
         const hyphen = locale0 === 'he' ? '־' : '-';
-        name += hyphen + hdate.Locale.gettext(parsha[1], locale0);
+        name += hyphen + Locale.gettext(parsha[1], locale0);
     }
     name = name.replace(/'/g, '’');
-    const str = hdate.Locale.gettext('Parashat', locale) + ' ' + name;
+    const str = Locale.gettext('Parashat', locale) + ' ' + name;
     return str.normalize();
 }
 
@@ -3056,8 +6018,8 @@ const INCOMPLETE = 0;
 const REGULAR = 1;
 const COMPLETE = 2;
 function yearType(hyear) {
-    const longC = hdate.HDate.longCheshvan(hyear);
-    const shortK = hdate.HDate.shortKislev(hyear);
+    const longC = HDate.longCheshvan(hyear);
+    const shortK = HDate.shortKislev(hyear);
     if (longC && !shortK) {
         return COMPLETE;
     }
@@ -3080,21 +6042,23 @@ class Sedra {
     constructor(hyear, il) {
         hyear = +hyear;
         this.year = hyear;
-        const rh0 = new hdate.HDate(1, hdate.months.TISHREI, hyear);
+        const rh0 = new HDate(1, months.TISHREI, hyear);
         const rh = rh0.abs();
         const rhDay = rh0.getDay() + 1;
         // find the first Saturday on or after Rosh Hashana
-        this.firstSaturday = hdate.HDate.dayOnOrBefore(6, rh + 6);
-        const leap = +hdate.HDate.isLeapYear(hyear);
+        this.firstSaturday = HDate.dayOnOrBefore(6, rh + 6);
+        const leap = +HDate.isLeapYear(hyear);
         this.il = Boolean(il);
         const type = yearType(hyear);
         let key = `${leap}${rhDay}${type}`;
         if (types[key]) {
             this.theSedraArray = types[key];
+            this.yearKey = key;
         }
         else {
             key = key + +this.il; // cast to num, then concat
             this.theSedraArray = types[key];
+            this.yearKey = key;
         }
         if (!this.theSedraArray) {
             throw new Error(`improper sedra year type ${key} calculated for ${hyear}`);
@@ -3186,7 +6150,7 @@ class Sedra {
         if (idx === -1) {
             return null; // doesn't occur this year
         }
-        return new hdate.HDate(this.firstSaturday + idx * 7);
+        return new HDate(this.firstSaturday + idx * 7);
     }
     /**
      * Returns the date that a parsha (or its doubled or undoubled counterpart)
@@ -3253,32 +6217,32 @@ class Sedra {
      * @param hd Hebrew date or R.D. days
      */
     lookup(hd) {
-        const abs = typeof hd === 'number' ? hd : hdate.HDate.isHDate(hd) ? hd.abs() : NaN;
+        const abs = typeof hd === 'number' ? hd : HDate.isHDate(hd) ? hd.abs() : NaN;
         if (isNaN(abs)) {
             throw new TypeError(`Bad date argument: ${hd}`);
         }
         // find the first saturday on or after today's date
-        const saturday = hdate.HDate.dayOnOrBefore(6, abs + 6);
+        const saturday = HDate.dayOnOrBefore(6, abs + 6);
         const weekNum = (saturday - this.firstSaturday) / 7;
         const index = this.theSedraArray[weekNum];
         if (typeof index === 'undefined') {
             const sedra = getSedra(this.year + 1, this.il);
             return sedra.lookup(saturday); // must be next year
         }
-        const hdate$1 = new hdate.HDate(saturday);
+        const hdate = new HDate(saturday);
         if (typeof index === 'string') {
             // Shabbat has a chag. Return a description
-            return { parsha: [index], chag: true, hdate: hdate$1 };
+            return { parsha: [index], chag: true, hdate };
         }
         if (index >= 0) {
-            return { parsha: [parshiot[index]], chag: false, num: index + 1, hdate: hdate$1 };
+            return { parsha: [parshiot[index]], chag: false, num: index + 1, hdate };
         }
         const p1 = D(index); // undouble the parsha
         return {
             parsha: [parshiot[p1], parshiot[p1 + 1]],
             chag: false,
             num: [p1 + 1, p1 + 2],
-            hdate: hdate$1,
+            hdate,
         };
     }
 }
@@ -3412,11 +6376,11 @@ const types = {
     /* Hebrew year that starts on Monday, is `incomplete' (Heshvan and
      * Kislev each have 29 days), and has Passover start on Tuesday. */
     // e.g. 5753
-    '020': yearStartVayeilech.concat(r020, D(21), 23, 24, PESACH, 25, D(26), D(28), 30, D(31), r3340, D(41), r4349, D(50)),
+    '020': yearStartVayeilech.concat(r020, D(21), 23, 24, CHMPESACH, 25, D(26), D(28), 30, D(31), r3340, D(41), r4349, D(50)),
     /* Hebrew year that starts on Monday, is `complete' (Heshvan and
      * Kislev each have 30 days), and has Passover start on Thursday. */
     // e.g. 5756
-    '0220': yearStartVayeilech.concat(r020, D(21), 23, 24, PESACH, 25, D(26), D(28), 30, D(31), 33, SHAVUOT, range$1(34, 37), D(38), 40, D(41), r4349, D(50)),
+    '0220': yearStartVayeilech.concat(r020, D(21), 23, 24, CHMPESACH, 25, D(26), D(28), 30, D(31), 33, SHAVUOT, range$1(34, 37), D(38), 40, D(41), r4349, D(50)),
     /* Hebrew year that starts on Thursday, is `regular' (Heshvan has 29
      * days and Kislev has 30 days), and has Passover start on Saturday. */
     // e.g. 5701
@@ -3547,7 +6511,7 @@ class ParshaEvent extends Event {
         return this.il ? url + '?i=on' : url;
     }
     urlDateSuffix() {
-        const isoDate = hdate.isoDateString(this.getDate().greg());
+        const isoDate = isoDateString(this.getDate().greg());
         return isoDate.replace(/-/g, '');
     }
 }
@@ -3562,7 +6526,7 @@ class ParshaEvent extends Event {
 function parshaYear(year, il) {
     const sedra = getSedra(year, il);
     const startAbs = sedra.getFirstSaturday();
-    const endAbs = hdate.HDate.hebrew2abs(year, hdate.months.ELUL, 29);
+    const endAbs = HDate.hebrew2abs(year, months.ELUL, 29);
     const events = [];
     for (let absDt = startAbs; absDt <= endAbs; absDt += 7) {
         const parsha = sedra.lookup(absDt);
@@ -3578,8 +6542,8 @@ const SUN$1 = 0;
 const TUE$1 = 2;
 const FRI$2 = 5;
 const SAT$2 = 6;
-const NISAN$2 = hdate.months.NISAN;
-const IYYAR = hdate.months.IYYAR;
+const NISAN$2 = months.NISAN;
+const IYYAR = months.IYYAR;
 /**
  * Yom HaShoah first observed in 1951.
  * When the actual date of Yom Hashoah falls on a Friday, the
@@ -3594,12 +6558,12 @@ function dateYomHaShoah(year) {
     if (year < 5711) {
         return null;
     }
-    let nisan27dt = new hdate.HDate(27, NISAN$2, year);
+    let nisan27dt = new HDate(27, NISAN$2, year);
     if (nisan27dt.getDay() === FRI$2) {
-        nisan27dt = new hdate.HDate(26, NISAN$2, year);
+        nisan27dt = new HDate(26, NISAN$2, year);
     }
     else if (nisan27dt.getDay() === SUN$1) {
-        nisan27dt = new hdate.HDate(28, NISAN$2, year);
+        nisan27dt = new HDate(28, NISAN$2, year);
     }
     return nisan27dt;
 }
@@ -3613,7 +6577,7 @@ function dateYomHaZikaron(year) {
         return null;
     }
     let day;
-    const pesach = new hdate.HDate(15, NISAN$2, year);
+    const pesach = new HDate(15, NISAN$2, year);
     const pdow = pesach.getDay();
     if (pdow === SUN$1) {
         day = 2;
@@ -3630,7 +6594,7 @@ function dateYomHaZikaron(year) {
     else {
         day = 4;
     }
-    return new hdate.HDate(day, IYYAR, year);
+    return new HDate(day, IYYAR, year);
 }
 
 const ykk = 'Yom Kippur Katan';
@@ -3653,15 +6617,15 @@ class YomKippurKatanEvent extends HolidayEvent {
      * @param [locale] Optional locale name (defaults to active locale).
      */
     render(locale) {
-        const monthName0 = hdate.Locale.gettext(this.nextMonthName, locale);
+        const monthName0 = Locale.gettext(this.nextMonthName, locale);
         const monthName = monthName0.replace(/'/g, '’');
-        return hdate.Locale.gettext(ykk, locale) + ' ' + monthName;
+        return Locale.gettext(ykk, locale) + ' ' + monthName;
     }
     /**
      * @param [locale] Optional locale name (defaults to active locale).
      */
     renderBrief(locale) {
-        return hdate.Locale.gettext(ykk, locale);
+        return Locale.gettext(ykk, locale);
     }
     url() {
         return undefined;
@@ -3706,7 +6670,7 @@ function holidayFilter(il) {
  * @param [il] use the Israeli schedule for holidays
  */
 function getHolidaysOnDate(date, il) {
-    const hd = hdate.HDate.isHDate(date) ? date : new hdate.HDate(date);
+    const hd = HDate.isHDate(date) ? date : new HDate(date);
     const hdStr = hd.toString();
     const yearMap = getHolidaysForYear_(hd.getFullYear());
     const events = yearMap.get(hdStr);
@@ -3732,14 +6696,14 @@ const TUE = 2;
 const THU = 4;
 const FRI$1 = 5;
 const SAT$1 = 6;
-const NISAN$1 = hdate.months.NISAN;
-const TAMUZ = hdate.months.TAMUZ;
-const AV = hdate.months.AV;
-const TISHREI$1 = hdate.months.TISHREI;
-const KISLEV = hdate.months.KISLEV;
-const TEVET = hdate.months.TEVET;
-const ADAR_I = hdate.months.ADAR_I;
-const ADAR_II = hdate.months.ADAR_II;
+const NISAN$1 = months.NISAN;
+const TAMUZ = months.TAMUZ;
+const AV = months.AV;
+const TISHREI$1 = months.TISHREI;
+const KISLEV = months.KISLEV;
+const TEVET = months.TEVET;
+const ADAR_I = months.ADAR_I;
+const ADAR_II = months.ADAR_II;
 const emojiIsraelFlag = { emoji: '🇮🇱' };
 const chanukahEmoji = '🕎';
 const yearCache = new QuickLRU({ maxSize: 400 });
@@ -3772,8 +6736,8 @@ function getHolidaysForYear_(year) {
     if (cached) {
         return cached;
     }
-    const RH = new hdate.HDate(1, TISHREI$1, year);
-    const pesach = new hdate.HDate(15, NISAN$1, year);
+    const RH = new HDate(1, TISHREI$1, year);
+    const pesach = new HDate(15, NISAN$1, year);
     const map = new Map();
     function add(...events) {
         for (const ev of events) {
@@ -3793,7 +6757,7 @@ function getHolidaysForYear_(year) {
         }
     }
     for (const h of staticHolidays) {
-        const hd = new hdate.HDate(h.dd, h.mm, year);
+        const hd = new HDate(h.dd, h.mm, year);
         const ev = new HolidayEvent(hd, h.desc, h.flags);
         if (h.emoji)
             ev.emoji = h.emoji;
@@ -3805,39 +6769,39 @@ function getHolidaysForYear_(year) {
     add(new RoshHashanaEvent(RH, year, CHAG | LIGHT_CANDLES_TZEIS$1));
     // Variable date holidays
     const tzomGedaliahDay = RH.getDay() === THU ? 4 : 3;
-    add(new HolidayEvent(new hdate.HDate(tzomGedaliahDay, TISHREI$1, year), holidayDesc.TZOM_GEDALIAH, MINOR_FAST$1));
+    add(new HolidayEvent(new HDate(tzomGedaliahDay, TISHREI$1, year), holidayDesc.TZOM_GEDALIAH, MINOR_FAST$1));
     // first SAT after RH
-    add(new HolidayEvent(new hdate.HDate(hdate.HDate.dayOnOrBefore(SAT$1, 7 + RH.abs())), holidayDesc.SHABBAT_SHUVA, SPECIAL_SHABBAT$1));
-    const rchTevet = hdate.HDate.shortKislev(year)
-        ? new hdate.HDate(1, TEVET, year)
-        : new hdate.HDate(30, KISLEV, year);
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$1, 7 + RH.abs())), holidayDesc.SHABBAT_SHUVA, SPECIAL_SHABBAT$1));
+    const rchTevet = HDate.shortKislev(year)
+        ? new HDate(1, TEVET, year)
+        : new HDate(30, KISLEV, year);
     add(new HolidayEvent(rchTevet, holidayDesc.CHAG_HABANOT, MINOR_HOLIDAY$1));
     // yes, we know Kislev 30-32 are wrong
     // HDate() corrects the month automatically
     for (let candles = 2; candles <= 8; candles++) {
-        const hd = new hdate.HDate(23 + candles, KISLEV, year);
+        const hd = new HDate(23 + candles, KISLEV, year);
         add(new ChanukahEvent(hd, `Chanukah: ${candles} Candles`, MINOR_HOLIDAY$1 | CHANUKAH_CANDLES$1, {
             chanukahDay: candles - 1,
             emoji: chanukahEmoji + KEYCAP_DIGITS[candles],
         }));
     }
-    add(new ChanukahEvent(new hdate.HDate(32, KISLEV, year), holidayDesc.CHANUKAH_8TH_DAY, MINOR_HOLIDAY$1, { chanukahDay: 8, emoji: chanukahEmoji }));
-    add(new AsaraBTevetEvent(new hdate.HDate(10, TEVET, year), holidayDesc.ASARA_BTEVET, MINOR_FAST$1));
+    add(new ChanukahEvent(new HDate(32, KISLEV, year), holidayDesc.CHANUKAH_8TH_DAY, MINOR_HOLIDAY$1, { chanukahDay: 8, emoji: chanukahEmoji }));
+    add(new AsaraBTevetEvent(new HDate(10, TEVET, year), holidayDesc.ASARA_BTEVET, MINOR_FAST$1));
     const pesachAbs = pesach.abs();
-    add(new HolidayEvent(new hdate.HDate(hdate.HDate.dayOnOrBefore(SAT$1, pesachAbs - 43)), holidayDesc.SHABBAT_SHEKALIM, SPECIAL_SHABBAT$1), new HolidayEvent(new hdate.HDate(hdate.HDate.dayOnOrBefore(SAT$1, pesachAbs - 30)), holidayDesc.SHABBAT_ZACHOR, SPECIAL_SHABBAT$1), new HolidayEvent(new hdate.HDate(pesachAbs - (pesach.getDay() === TUE ? 33 : 31)), holidayDesc.TAANIT_ESTHER, MINOR_FAST$1));
-    const haChodeshAbs = hdate.HDate.dayOnOrBefore(SAT$1, pesachAbs - 14);
-    add(new HolidayEvent(new hdate.HDate(haChodeshAbs - 7), holidayDesc.SHABBAT_PARAH, SPECIAL_SHABBAT$1), new HolidayEvent(new hdate.HDate(haChodeshAbs), holidayDesc.SHABBAT_HACHODESH, SPECIAL_SHABBAT$1), new HolidayEvent(new hdate.HDate(hdate.HDate.dayOnOrBefore(SAT$1, pesachAbs - 1)), holidayDesc.SHABBAT_HAGADOL, SPECIAL_SHABBAT$1), new HolidayEvent(
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$1, pesachAbs - 43)), holidayDesc.SHABBAT_SHEKALIM, SPECIAL_SHABBAT$1), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$1, pesachAbs - 30)), holidayDesc.SHABBAT_ZACHOR, SPECIAL_SHABBAT$1), new HolidayEvent(new HDate(pesachAbs - (pesach.getDay() === TUE ? 33 : 31)), holidayDesc.TAANIT_ESTHER, MINOR_FAST$1));
+    const haChodeshAbs = HDate.dayOnOrBefore(SAT$1, pesachAbs - 14);
+    add(new HolidayEvent(new HDate(haChodeshAbs - 7), holidayDesc.SHABBAT_PARAH, SPECIAL_SHABBAT$1), new HolidayEvent(new HDate(haChodeshAbs), holidayDesc.SHABBAT_HACHODESH, SPECIAL_SHABBAT$1), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$1, pesachAbs - 1)), holidayDesc.SHABBAT_HAGADOL, SPECIAL_SHABBAT$1), new HolidayEvent(
     // if the fast falls on Shabbat, move to Thursday
     pesach.prev().getDay() === SAT$1
         ? pesach.onOrBefore(THU)
-        : new hdate.HDate(14, NISAN$1, year), holidayDesc.TAANIT_BECHOROT, MINOR_FAST$1));
-    add(new HolidayEvent(new hdate.HDate(hdate.HDate.dayOnOrBefore(SAT$1, new hdate.HDate(1, TISHREI$1, year + 1).abs() - 4)), holidayDesc.LEIL_SELICHOT, MINOR_HOLIDAY$1, { emoji: '🕍' }));
+        : new HDate(14, NISAN$1, year), holidayDesc.TAANIT_BECHOROT, MINOR_FAST$1));
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$1, new HDate(1, TISHREI$1, year + 1).abs() - 4)), holidayDesc.LEIL_SELICHOT, MINOR_HOLIDAY$1, { emoji: '🕍' }));
     if (pesach.getDay() === SUN) {
-        add(new HolidayEvent(new hdate.HDate(16, ADAR_II, year), holidayDesc.PURIM_MESHULASH, MINOR_HOLIDAY$1));
+        add(new HolidayEvent(new HDate(16, ADAR_II, year), holidayDesc.PURIM_MESHULASH, MINOR_HOLIDAY$1));
     }
-    if (hdate.HDate.isLeapYear(year)) {
-        add(new HolidayEvent(new hdate.HDate(14, ADAR_I, year), holidayDesc.PURIM_KATAN, MINOR_HOLIDAY$1, { emoji: '🎭️' }));
-        add(new HolidayEvent(new hdate.HDate(15, ADAR_I, year), holidayDesc.SHUSHAN_PURIM_KATAN, MINOR_HOLIDAY$1, { emoji: '🎭️' }));
+    if (HDate.isLeapYear(year)) {
+        add(new HolidayEvent(new HDate(14, ADAR_I, year), holidayDesc.PURIM_KATAN, MINOR_HOLIDAY$1, { emoji: '🎭️' }));
+        add(new HolidayEvent(new HDate(15, ADAR_I, year), holidayDesc.SHUSHAN_PURIM_KATAN, MINOR_HOLIDAY$1, { emoji: '🎭️' }));
     }
     const nisan27dt = dateYomHaShoah(year);
     if (nisan27dt) {
@@ -3849,13 +6813,13 @@ function getHolidaysForYear_(year) {
     }
     for (const h of staticModernHolidays) {
         if (year >= h.firstYear) {
-            let hd = new hdate.HDate(h.dd, h.mm, year);
+            let hd = new HDate(h.dd, h.mm, year);
             const dow = hd.getDay();
             if (h.friSatMovetoThu && (dow === FRI$1 || dow === SAT$1)) {
                 hd = hd.onOrBefore(THU);
             }
             else if (h.friPostponeToSun && dow === FRI$1) {
-                hd = new hdate.HDate(hd.abs() + 2);
+                hd = new HDate(hd.abs() + 2);
             }
             else if (h.satPostponeToSun && dow === SAT$1) {
                 hd = hd.next();
@@ -3868,14 +6832,14 @@ function getHolidaysForYear_(year) {
             add(ev);
         }
     }
-    let tamuz17 = new hdate.HDate(17, TAMUZ, year);
+    let tamuz17 = new HDate(17, TAMUZ, year);
     let tamuz17attrs;
     if (tamuz17.getDay() === SAT$1) {
-        tamuz17 = new hdate.HDate(18, TAMUZ, year);
+        tamuz17 = new HDate(18, TAMUZ, year);
         tamuz17attrs = { observed: true };
     }
     add(new HolidayEvent(tamuz17, holidayDesc.TZOM_TAMMUZ, MINOR_FAST$1, tamuz17attrs));
-    let av9dt = new hdate.HDate(9, AV, year);
+    let av9dt = new HDate(9, AV, year);
     let av9title = holidayDesc.TISHA_BAV;
     let av9attrs;
     if (av9dt.getDay() === SAT$1) {
@@ -3884,38 +6848,38 @@ function getHolidaysForYear_(year) {
         av9title += ' (observed)';
     }
     const av9abs = av9dt.abs();
-    add(new HolidayEvent(new hdate.HDate(hdate.HDate.dayOnOrBefore(SAT$1, av9abs)), holidayDesc.SHABBAT_CHAZON, SPECIAL_SHABBAT$1), new HolidayEvent(av9dt.prev(), holidayDesc.EREV_TISHA_BAV, EREV$1 | MAJOR_FAST$1, av9attrs), new HolidayEvent(av9dt, av9title, MAJOR_FAST$1, av9attrs), new HolidayEvent(new hdate.HDate(hdate.HDate.dayOnOrBefore(SAT$1, av9abs + 7)), holidayDesc.SHABBAT_NACHAMU, SPECIAL_SHABBAT$1));
-    const monthsInYear = hdate.HDate.monthsInYear(year);
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$1, av9abs)), holidayDesc.SHABBAT_CHAZON, SPECIAL_SHABBAT$1), new HolidayEvent(av9dt.prev(), holidayDesc.EREV_TISHA_BAV, EREV$1 | MAJOR_FAST$1, av9attrs), new HolidayEvent(av9dt, av9title, MAJOR_FAST$1, av9attrs), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$1, av9abs + 7)), holidayDesc.SHABBAT_NACHAMU, SPECIAL_SHABBAT$1));
+    const monthsInYear = HDate.monthsInYear(year);
     for (let month = 1; month <= monthsInYear; month++) {
-        const monthName = hdate.HDate.getMonthName(month, year);
+        const monthName = HDate.getMonthName(month, year);
         if ((month === NISAN$1
-            ? hdate.HDate.daysInMonth(hdate.HDate.monthsInYear(year - 1), year - 1)
-            : hdate.HDate.daysInMonth(month - 1, year)) === 30) {
-            add(new RoshChodeshEvent(new hdate.HDate(1, month, year), monthName));
-            add(new RoshChodeshEvent(new hdate.HDate(30, month - 1, year), monthName));
+            ? HDate.daysInMonth(HDate.monthsInYear(year - 1), year - 1)
+            : HDate.daysInMonth(month - 1, year)) === 30) {
+            add(new RoshChodeshEvent(new HDate(1, month, year), monthName));
+            add(new RoshChodeshEvent(new HDate(30, month - 1, year), monthName));
         }
         else if (month !== TISHREI$1) {
-            add(new RoshChodeshEvent(new hdate.HDate(1, month, year), monthName));
+            add(new RoshChodeshEvent(new HDate(1, month, year), monthName));
         }
     }
     // Begin: Yom Kippur Katan
     // start at Iyyar because one may not fast during Nisan
-    for (let month = hdate.months.IYYAR; month <= monthsInYear; month++) {
+    for (let month = months.IYYAR; month <= monthsInYear; month++) {
         const nextMonth = month + 1;
         // Yom Kippur Katan is not observed on the day before Rosh Hashanah.
         // Not observed prior to Rosh Chodesh Cheshvan because Yom Kippur has just passed.
         // Not observed before Rosh Chodesh Tevet, because that day is Hanukkah.
         if (nextMonth === TISHREI$1 ||
-            nextMonth === hdate.months.CHESHVAN ||
+            nextMonth === months.CHESHVAN ||
             nextMonth === TEVET) {
             continue;
         }
-        let ykk = new hdate.HDate(29, month, year);
+        let ykk = new HDate(29, month, year);
         const dow = ykk.getDay();
         if (dow === FRI$1 || dow === SAT$1) {
             ykk = ykk.onOrBefore(THU);
         }
-        const nextMonthName = hdate.HDate.getMonthName(nextMonth, year);
+        const nextMonthName = HDate.getMonthName(nextMonth, year);
         const ev = new YomKippurKatanEvent(ykk, nextMonthName);
         add(ev);
     }
@@ -3925,7 +6889,7 @@ function getHolidaysForYear_(year) {
     // Birkat Hachamah appears only once every 28 years
     const birkatHaChama = getBirkatHaChama(year);
     if (birkatHaChama) {
-        const hd = new hdate.HDate(birkatHaChama);
+        const hd = new HDate(birkatHaChama);
         add(new HolidayEvent(hd, holidayDesc.BIRKAT_HACHAMAH, MINOR_HOLIDAY$1, { emoji: '☀️' }));
     }
     yearCache.set(year, map);
@@ -3942,10 +6906,10 @@ function getHolidaysForYear_(year) {
  * @private
  */
 function getBirkatHaChama(year) {
-    const leap = hdate.HDate.isLeapYear(year);
+    const leap = HDate.isLeapYear(year);
     const startMonth = leap ? ADAR_II : NISAN$1;
     const startDay = leap ? 20 : 1;
-    const baseRd = hdate.HDate.hebrew2abs(year, startMonth, startDay);
+    const baseRd = HDate.hebrew2abs(year, startMonth, startDay);
     for (let day = 0; day <= 40; day++) {
         const abs = baseRd + day;
         const elapsed = abs + 1373429;
@@ -3962,12 +6926,12 @@ function getBirkatHaChama(year) {
  */
 function getHolidaysForYearArray(year, il) {
     const yearMap = getHolidaysForYear_(year);
-    const startAbs = hdate.HDate.hebrew2abs(year, TISHREI$1, 1);
-    const endAbs = hdate.HDate.hebrew2abs(year + 1, TISHREI$1, 1) - 1;
+    const startAbs = HDate.hebrew2abs(year, TISHREI$1, 1);
+    const endAbs = HDate.hebrew2abs(year + 1, TISHREI$1, 1) - 1;
     let events = [];
     const myFilter = il ? observedInIsrael : observedInDiaspora;
     for (let absDt = startAbs; absDt <= endAbs; absDt++) {
-        const hd = new hdate.HDate(absDt);
+        const hd = new HDate(absDt);
         const holidays = yearMap.get(hd.toString());
         if (holidays) {
             const filtered = holidays.filter(myFilter);
@@ -3989,14 +6953,14 @@ class MevarchimChodeshEvent extends Event {
      */
     constructor(date, monthName, memo, locale) {
         super(date, `${mevarchimChodeshStr} ${monthName}`, flags.SHABBAT_MEVARCHIM);
-        this.monthName = hdate.Locale.gettext(monthName, locale);
+        this.monthName = Locale.gettext(monthName, locale);
         if (memo) {
             this.memo = memo;
         }
         else {
             const hyear = date.getFullYear();
             const hmonth = date.getMonth();
-            const monNext = hmonth === hdate.HDate.monthsInYear(hyear) ? hdate.months.NISAN : hmonth + 1;
+            const monNext = hmonth === HDate.monthsInYear(hyear) ? months.NISAN : hmonth + 1;
             const molad = new Molad(hyear, monNext);
             this.memo = molad.render('en', { hour12: false });
         }
@@ -4009,9 +6973,9 @@ class MevarchimChodeshEvent extends Event {
      * @param [locale] Optional locale name (defaults to active locale).
      */
     render(locale) {
-        const monthName0 = hdate.Locale.gettext(this.monthName, locale);
+        const monthName0 = Locale.gettext(this.monthName, locale);
         const monthName = monthName0.replace(/'/g, '’');
-        return hdate.Locale.gettext(mevarchimChodeshStr, locale) + ' ' + monthName;
+        return Locale.gettext(mevarchimChodeshStr, locale) + ' ' + monthName;
     }
     /**
      * Returns (translated) description of this event
@@ -4086,7 +7050,7 @@ const WHOLE = 2;
 /**
  * @private
  */
-function hallel_(events, hdate$1) {
+function hallel_(events, hdate) {
     const whole = events
         .filter(ev => {
         const desc = ev.getDesc();
@@ -4096,7 +7060,7 @@ function hallel_(events, hdate$1) {
         return (desc.startsWith('Chanukah') ||
             desc.startsWith('Shavuot') ||
             desc.startsWith('Sukkot') ||
-            (month === hdate.months.NISAN &&
+            (month === months.NISAN &&
                 (mday === 15 || mday === 16) &&
                 ev.getFlags() & flags.CHAG) || // Pesach
             desc === "Yom HaAtzma'ut" ||
@@ -4105,7 +7069,7 @@ function hallel_(events, hdate$1) {
         .map(ev => {
         return ev.getDate().abs();
     });
-    const abs = hdate$1.abs();
+    const abs = hdate.abs();
     if (whole.includes(abs)) {
         return WHOLE;
     }
@@ -4157,14 +7121,14 @@ const NONE = {
 function tachanun(hdate, il) {
     return tachanun0(hdate, il, true);
 }
-function tachanun0(hdate$1, il, checkNext) {
-    const year = hdate$1.yy;
+function tachanun0(hdate, il, checkNext) {
+    const year = hdate.yy;
     const dates = tachanunYear(year, il);
-    const abs = hdate$1.abs();
+    const abs = hdate.abs();
     if (dates.none.indexOf(abs) > -1) {
         return NONE;
     }
-    const dow = hdate$1.getDay();
+    const dow = hdate.getDay();
     const ret = {
         shacharit: false,
         mincha: false,
@@ -4178,7 +7142,7 @@ function tachanun0(hdate$1, il, checkNext) {
     }
     const tomorrow = abs + 1;
     if (checkNext && dates.yesPrev.indexOf(tomorrow) === -1) {
-        const tmp = tachanun0(new hdate.HDate(tomorrow), il, false);
+        const tmp = tachanun0(new HDate(tomorrow), il, false);
         ret.mincha = tmp.shacharit;
     }
     else {
@@ -4190,53 +7154,53 @@ function tachanun0(hdate$1, il, checkNext) {
     return ret;
 }
 function tachanunYear(year, il) {
-    const leap = hdate.HDate.isLeapYear(year);
-    const monthsInYear = hdate.HDate.monthsInYear(year);
-    let av9dt = new hdate.HDate(9, hdate.months.AV, year);
+    const leap = HDate.isLeapYear(year);
+    const monthsInYear = HDate.monthsInYear(year);
+    let av9dt = new HDate(9, months.AV, year);
     if (av9dt.getDay() === 6) {
         av9dt = av9dt.next();
     }
-    let shushPurim = new hdate.HDate(15, hdate.months.ADAR_II, year);
+    let shushPurim = new HDate(15, months.ADAR_II, year);
     if (shushPurim.getDay() === 6) {
         shushPurim = shushPurim.next();
     }
     const none = [
-        new hdate.HDate(2, hdate.months.TISHREI, year), // Rosh Hashana II
+        new HDate(2, months.TISHREI, year), // Rosh Hashana II
     ].concat(
     // Rosh Chodesh - 1st of every month. Also includes RH day 1 (1 Tishrei)
-    range(1, monthsInYear).map(month => new hdate.HDate(1, month, year)), 
+    range(1, monthsInYear).map(month => new HDate(1, month, year)), 
     // Rosh Chodesh - 30th of months that have one
     range(1, monthsInYear)
-        .filter(month => hdate.HDate.daysInMonth(month, year) === 30)
-        .map(month => new hdate.HDate(30, month, year)), 
+        .filter(month => HDate.daysInMonth(month, year) === 30)
+        .map(month => new HDate(30, month, year)), 
     // entire month of Nisan
-    range(1, hdate.HDate.daysInMonth(hdate.months.NISAN, year)).map(mday => new hdate.HDate(mday, hdate.months.NISAN, year)), new hdate.HDate(18, hdate.months.IYYAR, year), // Lag BaOmer
+    range(1, HDate.daysInMonth(months.NISAN, year)).map(mday => new HDate(mday, months.NISAN, year)), new HDate(18, months.IYYAR, year), // Lag BaOmer
     // Rosh Chodesh Sivan thru Isru Chag
-    range(1, 8 - (il ? 1 : 0)).map(mday => new hdate.HDate(mday, hdate.months.SIVAN, year)), av9dt, // Tisha B'Av
-    new hdate.HDate(15, hdate.months.AV, year), // Tu B'Av
-    new hdate.HDate(29, hdate.months.ELUL, year), // Erev Rosh Hashanah
+    range(1, 8 - (il ? 1 : 0)).map(mday => new HDate(mday, months.SIVAN, year)), av9dt, // Tisha B'Av
+    new HDate(15, months.AV, year), // Tu B'Av
+    new HDate(29, months.ELUL, year), // Erev Rosh Hashanah
     // Erev Yom Kippur thru Isru Chag
-    range(9, 24 - (il ? 1 : 0)).map(mday => new hdate.HDate(mday, hdate.months.TISHREI, year)), 
+    range(9, 24 - (il ? 1 : 0)).map(mday => new HDate(mday, months.TISHREI, year)), 
     // Chanukah
-    range(25, 33).map(mday => new hdate.HDate(mday, hdate.months.KISLEV, year)), new hdate.HDate(15, hdate.months.SHVAT, year), // Tu BiShvat
-    new hdate.HDate(14, hdate.months.ADAR_II, year), // Purim
-    shushPurim, leap ? new hdate.HDate(14, hdate.months.ADAR_I, year) : [] // Purim Katan
+    range(25, 33).map(mday => new HDate(mday, months.KISLEV, year)), new HDate(15, months.SHVAT, year), // Tu BiShvat
+    new HDate(14, months.ADAR_II, year), // Purim
+    shushPurim, leap ? new HDate(14, months.ADAR_I, year) : [] // Purim Katan
     );
     const some = [
-        new hdate.HDate(14, hdate.months.IYYAR, year), // Pesach Sheini
+        new HDate(14, months.IYYAR, year), // Pesach Sheini
     ].concat(
     // Until 14 Sivan
-    range(1, 13).map(mday => new hdate.HDate(mday, hdate.months.SIVAN, year)), 
+    range(1, 13).map(mday => new HDate(mday, months.SIVAN, year)), 
     // Until after Rosh Chodesh Cheshvan
-    range(20, 31).map(mday => new hdate.HDate(mday, hdate.months.TISHREI, year)), 
+    range(20, 31).map(mday => new HDate(mday, months.TISHREI, year)), 
     // Yom HaAtzma'ut, which changes based on day of week
     year >= 5708 ? dateYomHaZikaron(year).next() : [], 
     // Yom Yerushalayim
-    year >= 5727 ? new hdate.HDate(28, hdate.months.IYYAR, year) : []);
+    year >= 5727 ? new HDate(28, months.IYYAR, year) : []);
     const yesPrev = [
-        new hdate.HDate(29, hdate.months.ELUL, year - 1), // Erev Rosh Hashanah
-        new hdate.HDate(9, hdate.months.TISHREI, year), // Erev Yom Kippur
-        new hdate.HDate(14, hdate.months.IYYAR, year), // Pesach Sheini
+        new HDate(29, months.ELUL, year - 1), // Erev Rosh Hashanah
+        new HDate(9, months.TISHREI, year), // Erev Yom Kippur
+        new HDate(14, months.IYYAR, year), // Pesach Sheini
     ];
     return {
         none: none.map(hd => hd.abs()).sort((a, b) => a - b),
@@ -4245,7 +7209,7 @@ function tachanunYear(year, il) {
     };
 }
 
-const TISHREI = hdate.months.TISHREI;
+const TISHREI = months.TISHREI;
 /**
  * Gets the R.D. days for a number, Date, or HDate
  * @private
@@ -4253,9 +7217,9 @@ const TISHREI = hdate.months.TISHREI;
 function getAbs(d) {
     if (typeof d === 'number')
         return d;
-    if (hdate.isDate(d))
-        return hdate.greg2abs(d);
-    if (hdate.HDate.isHDate(d))
+    if (isDate(d))
+        return greg2abs(d);
+    if (HDate.isHDate(d))
         return d.abs();
     throw new TypeError(`Invalid date type: ${d}`);
 }
@@ -4264,7 +7228,7 @@ function getYear(options) {
         return Number(options.year);
     }
     return options.isHebrewYear
-        ? new hdate.HDate().getFullYear()
+        ? new HDate().getFullYear()
         : new Date().getFullYear();
 }
 /**
@@ -4298,7 +7262,7 @@ function getStartAndEnd(options) {
 function getMonth(options) {
     if (options.month) {
         if (options.isHebrewYear) {
-            return hdate.HDate.monthNum(options.month);
+            return HDate.monthNum(options.month);
         }
         else if (typeof options.month === 'number') {
             return options.month;
@@ -4312,10 +7276,10 @@ function startEndGregorian(theMonth, theYear, numYears) {
     if (theYear < 100) {
         startGreg.setFullYear(theYear);
     }
-    const startAbs = hdate.greg2abs(startGreg);
+    const startAbs = greg2abs(startGreg);
     let endAbs;
     if (theMonth) {
-        endAbs = startAbs + hdate.daysInGregMonth(theMonth, theYear) - 1;
+        endAbs = startAbs + daysInGregMonth(theMonth, theYear) - 1;
     }
     else {
         const endYear = theYear + numYears;
@@ -4323,16 +7287,16 @@ function startEndGregorian(theMonth, theYear, numYears) {
         if (endYear < 100) {
             endGreg.setFullYear(endYear);
         }
-        endAbs = hdate.greg2abs(endGreg) - 1;
+        endAbs = greg2abs(endGreg) - 1;
     }
     return [startAbs, endAbs];
 }
 function startEndHebrew(theMonth, theYear, numYears) {
-    const startDate = new hdate.HDate(1, theMonth || TISHREI, theYear);
+    const startDate = new HDate(1, theMonth || TISHREI, theYear);
     let startAbs = startDate.abs();
     const endAbs = theMonth
         ? startAbs + startDate.daysInMonth()
-        : new hdate.HDate(1, TISHREI, theYear + numYears).abs() - 1;
+        : new HDate(1, TISHREI, theYear + numYears).abs() - 1;
     // for full Hebrew year, start on Erev Rosh Hashana which
     // is technically in the previous Hebrew year
     // (but conveniently lets us get candle-lighting time for Erev)
@@ -4462,13 +7426,13 @@ function calendar(options = {}) {
             throw new TypeError(`Invalid options.locale: ${options.locale}`);
         }
         const locale = options.ashkenazi ? 'ashkenazi' : options.locale;
-        const translationObj = hdate.Locale.useLocale(locale);
+        const translationObj = Locale.useLocale(locale);
         if (!translationObj) {
             throw new TypeError(`Locale '${locale}' not found; did you forget to import @hebcal/locales?`);
         }
     }
     else {
-        hdate.Locale.useLocale('en');
+        Locale.useLocale('en');
     }
     const evts = [];
     let sedra;
@@ -4480,12 +7444,12 @@ function calendar(options = {}) {
     warnUnrecognizedOptions(options);
     const startAbs = startAndEnd[0];
     const endAbs = startAndEnd[1];
-    const startGreg = hdate.abs2greg(startAbs);
+    const startGreg = abs2greg(startAbs);
     if (startGreg.getFullYear() < 100) {
         options.candlelighting = false;
     }
     for (let abs = startAbs; abs <= endAbs; abs++) {
-        const hd = new hdate.HDate(abs);
+        const hd = new HDate(abs);
         const hyear = hd.getFullYear();
         if (hyear !== currentYear) {
             currentYear = hyear;
@@ -4494,8 +7458,8 @@ function calendar(options = {}) {
                 sedra = getSedra(currentYear, il);
             }
             if (options.omer) {
-                beginOmer = hdate.HDate.hebrew2abs(currentYear, NISAN, 16);
-                endOmer = hdate.HDate.hebrew2abs(currentYear, SIVAN, 5);
+                beginOmer = HDate.hebrew2abs(currentYear, NISAN, 16);
+                endOmer = HDate.hebrew2abs(currentYear, SIVAN, 5);
             }
         }
         const prevEventsLength = evts.length;
@@ -4516,7 +7480,7 @@ function calendar(options = {}) {
         if (options.yizkor) {
             const mm = hd.getMonth();
             const dd = hd.getDate();
-            if ((mm === hdate.months.TISHREI && (dd === 10 || dd === 22)) ||
+            if ((mm === months.TISHREI && (dd === 10 || dd === 22)) ||
                 (mm === NISAN && dd === (il ? 21 : 22)) ||
                 (mm === SIVAN && dd === (il ? 6 : 7))) {
                 const linkedEvent = holidays.filter(ev => ev.observedIn(il))[0];
@@ -4577,9 +7541,9 @@ function calendar(options = {}) {
 }
 const FRI = 5;
 const SAT = 6;
-const NISAN = hdate.months.NISAN;
-const SIVAN = hdate.months.SIVAN;
-const ELUL = hdate.months.ELUL;
+const NISAN = months.NISAN;
+const SIVAN = months.SIVAN;
+const ELUL = months.ELUL;
 const LIGHT_CANDLES = flags.LIGHT_CANDLES;
 const YOM_TOV_ENDS = flags.YOM_TOV_ENDS;
 const CHUL_ONLY = flags.CHUL_ONLY;
@@ -4928,15 +7892,15 @@ function appendHolidayAndRelated(candlesEv, events, ev, options, isFriday, isSat
 function makeMoladAndMevarchimChodesh(hd, options) {
     const evts = [];
     const hmonth = hd.getMonth();
-    const hdate$1 = hd.getDate();
-    if (hmonth !== ELUL && hdate$1 >= 23 && hdate$1 <= 29) {
+    const hdate = hd.getDate();
+    if (hmonth !== ELUL && hdate >= 23 && hdate <= 29) {
         const hyear = hd.getFullYear();
-        const monNext = hmonth === hdate.HDate.monthsInYear(hyear) ? NISAN : hmonth + 1;
+        const monNext = hmonth === HDate.monthsInYear(hyear) ? NISAN : hmonth + 1;
         if (options.molad) {
             evts.push(new MoladEvent(hd, hyear, monNext, options));
         }
         if (options.shabbatMevarchim) {
-            const nextMonthName = hdate.HDate.getMonthName(monNext, hyear);
+            const nextMonthName = HDate.getMonthName(monNext, hyear);
             const molad = new Molad(hyear, monNext);
             const memo = molad.render(options.locale || 'en', options);
             evts.push(new MevarchimChodeshEvent(hd, nextMonthName, memo, options.locale));
@@ -5142,11 +8106,11 @@ class HebrewCalendar {
      * @returns anniversary occurring in `hyear`
      */
     static getBirthdayOrAnniversary(hyear, gdate) {
-        const dt = hdate.getBirthdayHD(hyear, gdate);
+        const dt = getBirthdayHD(hyear, gdate);
         if (typeof dt === 'undefined') {
             return dt;
         }
-        return new hdate.HDate(dt);
+        return new HDate(dt);
     }
     /**
      * Calculates yahrzeit.
@@ -5183,11 +8147,11 @@ class HebrewCalendar {
      * @returns anniversary occurring in hyear
      */
     static getYahrzeit(hyear, gdate) {
-        const dt = hdate.getYahrzeitHD(hyear, gdate);
+        const dt = getYahrzeitHD(hyear, gdate);
         if (typeof dt === 'undefined') {
             return dt;
         }
-        return new hdate.HDate(dt);
+        return new HDate(dt);
     }
     /**
      * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
@@ -5221,7 +8185,7 @@ class HebrewCalendar {
         if (date.getDay() < 3 || date.getDay() > 4) {
             return false;
         }
-        const today = new hdate.HDate(date);
+        const today = new HDate(date);
         const friday = today.after(5);
         const tomorrow = today.next();
         if (!isChag(friday, il) || isChag(today, il) || !isChag(tomorrow, il)) {
@@ -5299,52 +8263,24 @@ function isChag(date, il) {
     return chag.length !== 0;
 }
 
-Object.defineProperty(exports, "HDate", {
-    enumerable: true,
-    get: function () { return hdate.HDate; }
-});
-Object.defineProperty(exports, "Locale", {
-    enumerable: true,
-    get: function () { return hdate.Locale; }
-});
-Object.defineProperty(exports, "gematriya", {
-    enumerable: true,
-    get: function () { return hdate.gematriya; }
-});
-Object.defineProperty(exports, "gematriyaStrToNum", {
-    enumerable: true,
-    get: function () { return hdate.gematriyaStrToNum; }
-});
-Object.defineProperty(exports, "greg", {
-    enumerable: true,
-    get: function () { return hdate.greg; }
-});
-Object.defineProperty(exports, "months", {
-    enumerable: true,
-    get: function () { return hdate.months; }
-});
-Object.defineProperty(exports, "GeoLocation", {
-    enumerable: true,
-    get: function () { return noaa.GeoLocation; }
-});
-Object.defineProperty(exports, "NOAACalculator", {
-    enumerable: true,
-    get: function () { return noaa.NOAACalculator; }
-});
 exports.AsaraBTevetEvent = AsaraBTevetEvent;
 exports.CandleLightingEvent = CandleLightingEvent;
 exports.ChanukahEvent = ChanukahEvent;
 exports.DailyLearning = DailyLearning;
 exports.Event = Event;
 exports.FastDayEvent = FastDayEvent;
+exports.GeoLocation = GeoLocation;
+exports.HDate = HDate;
 exports.HavdalahEvent = HavdalahEvent;
 exports.HebrewCalendar = HebrewCalendar;
 exports.HebrewDateEvent = HebrewDateEvent;
 exports.HolidayEvent = HolidayEvent;
+exports.Locale = Locale;
 exports.Location = Location;
 exports.MevarchimChodeshEvent = MevarchimChodeshEvent;
 exports.Molad = Molad;
 exports.MoladEvent = MoladEvent;
+exports.NOAACalculator = NOAACalculator;
 exports.OmerEvent = OmerEvent;
 exports.ParshaEvent = ParshaEvent;
 exports.RoshChodeshEvent = RoshChodeshEvent;
@@ -5355,9 +8291,12 @@ exports.TimedEvent = TimedEvent;
 exports.YomKippurKatanEvent = YomKippurKatanEvent;
 exports.Zmanim = Zmanim;
 exports.flags = flags;
+exports.gematriya = gematriya;
+exports.gematriyaStrToNum = gematriyaStrToNum;
 exports.getHolidaysOnDate = getHolidaysOnDate;
 exports.getSedra = getSedra;
 exports.holidayDesc = holidayDesc;
+exports.months = months;
 exports.parshaYear = parshaYear;
 exports.parshiot = parshiot;
 exports.version = version;