@hebcal/core 5.0.0-rc4 → 5.0.0-rc5

package/dist/bundle.js

@@ -1,5 +1,5 @@
-/*! @hebcal/core v5.0.0-rc4 */
-var hebcal = (function (exports) {
+/*! @hebcal/core v5.0.0-rc5 */
+var hebcal = (function (exports, temporalPolyfill) {
 'use strict';
 
 const GERESH = '׳';
@@ -886,46 +886,6 @@ function toSimpleHebrewDate(obj) {
     throw new TypeError(`Argument not a Date: ${obj}`);
   }
 }
-/**
- * Calculates yahrzeit.
- * `hyear` must be after original `date` of death.
- * Returns `undefined` when requested year preceeds or is same as original year.
- *
- * Hebcal uses the algorithm defined in "Calendrical Calculations"
- * by Edward M. Reingold and Nachum Dershowitz.
- *
- * The customary anniversary date of a death is more complicated and depends
- * also on the character of the year in which the first anniversary occurs.
- * There are several cases:
- *
- * * If the date of death is Marcheshvan 30, the anniversary in general depends
- *   on the first anniversary; if that first anniversary was not Marcheshvan 30,
- *   use the day before Kislev 1.
- * * If the date of death is Kislev 30, the anniversary in general again depends
- *   on the first anniversary — if that was not Kislev 30, use the day before
- *   Tevet 1.
- * * If the date of death is Adar II, the anniversary is the same day in the
- *   last month of the Hebrew year (Adar or Adar II).
- * * If the date of death is Adar I 30, the anniversary in a Hebrew year that
- *   is not a leap year (in which Adar only has 29 days) is the last day in
- *   Shevat.
- * * In all other cases, use the normal (that is, same month number) anniversary
- *   of the date of death. [Calendrical Calculations p. 113]
- * @example
- * import {getYahrzeit} from '@hebcal/hdate';
- * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
- * const anniversary = getYahrzeit(5780, dt); // '2/25/2020' == '30 Sh\'vat 5780'
- * @param {number} hyear Hebrew year
- * @param {Date | SimpleHebrewDate | number} date Gregorian or Hebrew date of death
- * @return {Date} anniversary occurring in `hyear`
- */
-function getYahrzeit(hyear, date) {
-  const hd = getYahrzeitHD(hyear, date);
-  if (typeof hd === 'undefined') {
-    return hd;
-  }
-  return exports.greg.abs2greg(hebrew2abs(hd.yy, hd.mm, hd.dd));
-}
 function getYahrzeitHD(hyear, date) {
   let hDeath = toSimpleHebrewDate(date);
   if (hyear <= hDeath.yy) {
@@ -961,38 +921,6 @@ function getYahrzeitHD(hyear, date) {
   hDeath.yy = hyear;
   return hDeath;
 }
-/**
- * Calculates a birthday or anniversary (non-yahrzeit).
- * `hyear` must be after original `date` of anniversary.
- * Returns `undefined` when requested year preceeds or is same as original year.
- *
- * Hebcal uses the algorithm defined in "Calendrical Calculations"
- * by Edward M. Reingold and Nachum Dershowitz.
- *
- * The birthday of someone born in Adar of an ordinary year or Adar II of
- * a leap year is also always in the last month of the year, be that Adar
- * or Adar II. The birthday in an ordinary year of someone born during the
- * first 29 days of Adar I in a leap year is on the corresponding day of Adar;
- * in a leap year, the birthday occurs in Adar I, as expected.
- *
- * Someone born on the thirtieth day of Marcheshvan, Kislev, or Adar I
- * has his birthday postponed until the first of the following month in
- * years where that day does not occur. [Calendrical Calculations p. 111]
- * @example
- * import {getBirthdayOrAnniversary} from '@hebcal/hdate';
- * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
- * const anniversary = getBirthdayOrAnniversary(5780, dt); // '3/26/2020' == '1 Nisan 5780'
- * @param {number} hyear Hebrew year
- * @param {Date | SimpleHebrewDate | number} date Gregorian or Hebrew date of event
- * @return {Date} anniversary occurring in `hyear`
- */
-function getBirthdayOrAnniversary(hyear, date) {
-  const hd = getBirthdayHD(hyear, date);
-  if (typeof hd === 'undefined') {
-    return hd;
-  }
-  return exports.greg.abs2greg(hebrew2abs(hd.yy, hd.mm, hd.dd));
-}
 function getBirthdayHD(hyear, date) {
   const orig = toSimpleHebrewDate(date);
   const origYear = orig.yy;
@@ -1143,11 +1071,11 @@ class HDate {
       this.setDate(day);
     } else {
       // 0 arguments
-      if (typeof day === 'undefined') {
+      if (typeof day === 'undefined' || day === null) {
         day = new Date();
       }
       // 1 argument
-      const abs0 = typeof day === 'number' && !isNaN(day) ? day : exports.greg.isDate(day) ? exports.greg.greg2abs(day) : HDate.isHDate(day) ? day : throwTypeError(`HDate called with bad argument: ${day}`);
+      const abs0 = typeof day === 'number' && !isNaN(day) ? day : exports.greg.isDate(day) ? exports.greg.greg2abs(day) : typeof day.yy === 'number' && typeof day.mm === 'number' && typeof day.dd === 'number' ? day : throwTypeError(`HDate called with bad argument: ${day}`);
       const isNumber = typeof abs0 === 'number';
       const d = isNumber ? abs2hebrew(abs0) : abs0;
       /**
@@ -2062,46 +1990,6 @@ class HebrewDateEvent extends Event {
   }
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-var esm = {};
-
-var __awaiter = commonjsGlobal && commonjsGlobal.__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-Object.defineProperty(esm, "__esModule", {
-  value: true
-});
-exports.NOAACalculator = esm.NOAACalculator = exports.GeoLocation = esm.GeoLocation = void 0;
-(() => __awaiter(void 0, void 0, void 0, function* () {
-  if (typeof Temporal !== 'function') {
-    yield Promise.resolve().then(function () { return global$d; });
-  }
-}))();
 /**
  * java.lang.Math.toRadians
  * @private
@@ -2118,12 +2006,9 @@ function degreesToRadians(degrees) {
 function radiansToDegrees(radians) {
   return radians * 180 / Math.PI;
 }
-const Long_MIN_VALUE = NaN;
 /**
  * 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. Check the documentation for
- * specific implementations of the {@link AstronomicalCalculator} to see if elevation is calculated as part of the
- * algorithm.
+ * 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
@@ -2147,25 +2032,33 @@ class GeoLocation {
    * @param {string} timeZoneId
    *            the <code>TimeZone</code> for the location.
    */
-  constructor(name, latitude, longitude, elevationOrTimeZoneId, timeZoneId) {
-    /**
-     * @private
-     * @see #getLocationName()
-     * @see #setLocationName(String)
-     */
-    this.locationName = null;
-    let elevation = 0;
-    if (timeZoneId) {
-      elevation = elevationOrTimeZoneId;
-    } else {
-      timeZoneId = elevationOrTimeZoneId;
-    }
+  constructor(name, latitude, longitude, elevation, timeZoneId) {
     this.setLocationName(name);
     this.setLatitude(latitude);
     this.setLongitude(longitude);
     this.setElevation(elevation);
     this.setTimeZone(timeZoneId);
   }
+  /**
+   * @private
+   */
+  latitude;
+  /**
+   * @private
+   */
+  longitude;
+  /**
+   * @private
+   */
+  locationName = null;
+  /**
+   * @private
+   */
+  timeZoneId;
+  /**
+   * @private
+   */
+  elevation;
   /**
    * Method to get the elevation in Meters.
    *
@@ -2178,9 +2071,13 @@ class GeoLocation {
    * Method to set the elevation in Meters <b>above </b> sea level.
    *
    * @param {number} elevation
-   *            The elevation to set in Meters. An IllegalArgumentException will be thrown if the value is a negative.
+   *            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) {
@@ -2229,21 +2126,14 @@ class GeoLocation {
     return this.timeZoneId;
   }
   /**
-   * Method to set the TimeZone. If this is ever set after the GeoLocation is set in the
-   * {@link AstronomicalCalendar}, it is critical that
-   * {@link AstronomicalCalendar#getCalendar()}.
-   * {@link java.util.Calendar#setTimeZone(TimeZone) setTimeZone(TimeZone)} be called in order for the
-   * AstronomicalCalendar to output times in the expected offset. This situation will arise if the
-   * AstronomicalCalendar is ever {@link AstronomicalCalendar#clone() cloned}.
-   *
-   * @param {string} timeZone
+   * Method to set the TimeZone.
+   * @param {string} timeZoneId
    *            The timeZone to set.
    */
   setTimeZone(timeZoneId) {
     this.timeZoneId = timeZoneId;
   }
 }
-exports.GeoLocation = esm.GeoLocation = GeoLocation;
 /**
  * The commonly used average solar refraction. Calendrical Calculations lists a more accurate global average of
  * 34.478885263888294
@@ -2278,42 +2168,71 @@ const earthRadius = 6356.9; // in KM
 class NOAACalculator {
   /**
    * A constructor that takes in <a href="http://en.wikipedia.org/wiki/Geolocation">geolocation</a> information as a
-   * parameter. The default {@link AstronomicalCalculator#getDefault() AstronomicalCalculator} used for solar
-   * calculations is the the {@link NOAACalculator}.
+   * parameter.
    *
    * @param {GeoLocation} geoLocation
    *            The location information used for calculating astronomical sun times.
    * @param {Temporal.PlainDate} date
-   *
-   * @see #setAstronomicalCalculator(AstronomicalCalculator) for changing the calculator class.
    */
   constructor(geoLocation, date) {
     this.date = date;
     this.geoLocation = geoLocation;
   }
+  /**
+   * The zenith of astronomical sunrise and sunset. The sun is 90&deg; from the vertical 0&deg;
+   * @private
+   */
+  static 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;). */
+  static CIVIL_ZENITH = 96;
+  /** Sun's zenith at nautical twilight (102&deg;). */
+  static NAUTICAL_ZENITH = 102;
+  /** Sun's zenith at astronomical twilight (108&deg;). */
+  static ASTRONOMICAL_ZENITH = 108;
+  /**
+   * The Java Calendar encapsulated by this class to track the current date used by the class
+   * @private
+   */
+  date;
+  /**
+   * the {@link GeoLocation} used for calculations.
+   * @private
+   */
+  geoLocation;
   /**
    * The getSunrise method Returns a `Date` representing the
-   * {@link AstronomicalCalculator#getElevationAdjustment(double) elevation adjusted} sunrise time. The zenith used
-   * for the calculation uses {@link #GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
-   * {@link AstronomicalCalculator#getElevationAdjustment(double)}. This is adjusted by the
-   * {@link AstronomicalCalculator} 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 AstronomicalCalculator#adjustZenith 90.83333&deg;}.
-   * See documentation for the specific implementation of the {@link AstronomicalCalculator} that you are using.
+   * {@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 AstronomicalCalculator#adjustZenith
-   * @see #getSeaLevelSunrise()
-   * @see AstronomicalCalendar#getUTCSunrise
+   * @see adjustZenith
+   * @see getSeaLevelSunrise()
+   * @see getUTCSunrise
    */
   getSunrise() {
     const sunrise = this.getUTCSunrise0(NOAACalculator.GEOMETRIC_ZENITH);
-    if (Number.isNaN(sunrise)) return null;
+    if (isNaN(sunrise)) return null;
     return this.getDateFromTime(sunrise, true);
   }
   /**
-   * A method that returns the sunrise without {@link AstronomicalCalculator#getElevationAdjustment(double) elevation
+   * 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.
@@ -2321,54 +2240,54 @@ class NOAACalculator {
    * @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 AstronomicalCalendar#getSunrise
-   * @see AstronomicalCalendar#getUTCSeaLevelSunrise
-   * @see #getSeaLevelSunset()
+   * @see getSunrise
+   * @see getUTCSeaLevelSunrise
+   * @see getSeaLevelSunset()
    */
   getSeaLevelSunrise() {
     const sunrise = this.getUTCSeaLevelSunrise(NOAACalculator.GEOMETRIC_ZENITH);
-    if (Number.isNaN(sunrise)) return null;
+    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;}.
+   * 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
+   * @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;}.
+   * 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
+   * @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
+   * 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
+   * @see ASTRONOMICAL_ZENITH
    */
   getBeginAstronomicalTwilight() {
     return this.getSunriseOffsetByDegrees(NOAACalculator.ASTRONOMICAL_ZENITH);
   }
   /**
    * The getSunset method Returns a `Date` representing the
-   * {@link AstronomicalCalculator#getElevationAdjustment(double) elevation adjusted} sunset time. The zenith used for
-   * the calculation uses {@link #GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
-   * {@link AstronomicalCalculator#getElevationAdjustment(double)}. This is adjusted by the
-   * {@link AstronomicalCalculator} 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 AstronomicalCalculator#adjustZenith 90.83333&deg;}.
-   * See documentation for the specific implementation of the {@link AstronomicalCalculator} that you are using. Note:
+   * {@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.
@@ -2376,17 +2295,17 @@ class NOAACalculator {
    * @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 AstronomicalCalculator#adjustZenith
-   * @see #getSeaLevelSunset()
-   * @see AstronomicalCalendar#getUTCSunset
+   * @see adjustZenith
+   * @see getSeaLevelSunset()
+   * @see getUTCSunset
    */
   getSunset() {
     const sunset = this.getUTCSunset0(NOAACalculator.GEOMETRIC_ZENITH);
-    if (Number.isNaN(sunset)) return null;
+    if (isNaN(sunset)) return null;
     return this.getDateFromTime(sunset, false);
   }
   /**
-   * A method that returns the sunset without {@link AstronomicalCalculator#getElevationAdjustment(double) elevation
+   * 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.
@@ -2394,42 +2313,42 @@ class NOAACalculator {
    * @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 AstronomicalCalendar#getSunset
-   * @see AstronomicalCalendar#getUTCSeaLevelSunset 2see {@link #getSunset()}
+   * @see getSunset
+   * @see getUTCSeaLevelSunset
    */
   getSeaLevelSunset() {
     const sunset = this.getUTCSeaLevelSunset(NOAACalculator.GEOMETRIC_ZENITH);
-    if (Number.isNaN(sunset)) return null;
+    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;}.
+   * 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
+   * @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
+   * @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;}.
+   * 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;}
+   * @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
+   * @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;}.
+   * 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
+   * @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
+   * @see ASTRONOMICAL_ZENITH
    */
   getEndAstronomicalTwilight() {
     return this.getSunsetOffsetByDegrees(NOAACalculator.ASTRONOMICAL_ZENITH);
@@ -2447,7 +2366,7 @@ class NOAACalculator {
    * @return {Temporal.ZonedDateTime | null} the `Date` with the offset in milliseconds added to it
    */
   static getTimeOffset(time, offset) {
-    if (time === null || offset === Long_MIN_VALUE || Number.isNaN(offset)) {
+    if (time === null || isNaN(offset)) {
       return null;
     }
     return time.add({
@@ -2456,41 +2375,41 @@ class NOAACalculator {
   }
   /**
    * 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.
+   * {@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
+   *            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
+   *            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
+   * @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 (Number.isNaN(dawn)) return null;
+    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()
+   * 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.
+   * 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
+   *            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
+   *            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 (Number.isNaN(sunset)) return null;
+    if (isNaN(sunset)) return null;
     return this.getDateFromTime(sunset, false);
   }
   /**
@@ -2501,7 +2420,7 @@ class NOAACalculator {
    *            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, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
+   *         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);
@@ -2516,9 +2435,9 @@ class NOAACalculator {
    *            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, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
-   * @see AstronomicalCalendar#getUTCSunrise
-   * @see AstronomicalCalendar#getUTCSeaLevelSunset
+   *         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);
@@ -2531,8 +2450,8 @@ class NOAACalculator {
    *            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, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
-   * @see AstronomicalCalendar#getUTCSeaLevelSunset
+   *         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);
@@ -2548,9 +2467,9 @@ class NOAACalculator {
    *            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, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
-   * @see AstronomicalCalendar#getUTCSunset
-   * @see AstronomicalCalendar#getUTCSeaLevelSunrise
+   *         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);
@@ -2568,9 +2487,9 @@ class NOAACalculator {
    * 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 AstronomicalCalendar#getBeginNauticalTwilight() nautical twilight} since those
+   * {@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}
+   * 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>
@@ -2602,30 +2521,30 @@ class NOAACalculator {
    * 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 (this can be changed via the {@link #setSolarRadius(double)} method , and atmospheric refraction
-   * accounts for 34 minutes or so (this can be changed via the {@link #setRefraction(double)} method), giving a total
+   * 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 AstronomicalCalendar#ASTRONOMICAL_ZENITH 108&deg;
+   * 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()}.
+   * {@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}
+   *            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 AstronomicalCalendar#getEndNauticalTwilight()} that passes
-   *            {@link AstronomicalCalendar#NAUTICAL_ZENITH} to this method.
+   *            {@link getEndNauticalTwilight} that passes
+   *            {@link NAUTICAL_ZENITH} to this method.
    * @param {number} elevation
    *            elevation in Meters.
-   * @return {number} The zenith adjusted to include the {@link #getSolarRadius sun's radius}, {@link #getRefraction
-   *         refraction} and {@link #getElevationAdjustment elevation} adjustment. This will only be adjusted for
+   * @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(double)
+   * @see getElevationAdjustment
    */
   adjustZenith(zenith, elevation) {
     let adjustedZenith = zenith;
@@ -2636,7 +2555,32 @@ class NOAACalculator {
     return adjustedZenith;
   }
   /**
-   * @see AstronomicalCalculator#getUTCSunrise(Calendar, GeoLocation, double, boolean)
+   * The <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a> of January 1, 2000
+   * @private
+   */
+  static JULIAN_DAY_JAN_1_2000 = 2451545;
+  /**
+   * Julian days per century
+   * @private
+   */
+  static JULIAN_DAYS_PER_CENTURY = 36525;
+  /**
+   * 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;
@@ -2653,7 +2597,22 @@ class NOAACalculator {
     return sunrise;
   }
   /**
-   * @see AstronomicalCalculator#getUTCSunset(Calendar, GeoLocation, double, boolean)
+   * 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;
@@ -2672,8 +2631,8 @@ class NOAACalculator {
   /**
    * 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.
+   * 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.
@@ -2681,15 +2640,15 @@ class NOAACalculator {
    *            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
-   *         {@link Long#MIN_VALUE} will be returned. See detailed explanation on top of the page.
+   *         `NaN` will be returned. See detailed explanation on top of the page.
    *
-   * @see #getTemporalHour()
+   * @see getTemporalHour()
    */
   getTemporalHour() {
     let startOfDay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getSeaLevelSunrise();
     let endOfDay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getSeaLevelSunset();
     if (startOfDay === null || endOfDay === null) {
-      return Long_MIN_VALUE;
+      return NaN;
     }
     const delta = endOfDay.epochMilliseconds - startOfDay.epochMilliseconds;
     return Math.floor(delta / 12);
@@ -2728,7 +2687,7 @@ class NOAACalculator {
    * @return {Temporal.ZonedDateTime | null} The Date.
    */
   getDateFromTime(time, isSunrise) {
-    if (Number.isNaN(time)) {
+    if (isNaN(time)) {
       return null;
     }
     let calculatedTime = time;
@@ -2755,7 +2714,7 @@ class NOAACalculator {
     }
     return cal.toZonedDateTime({
       timeZone: 'UTC',
-      plainTime: new Temporal.PlainTime(hours, minutes, seconds, Math.trunc(calculatedTime * 1000))
+      plainTime: new temporalPolyfill.Temporal.PlainTime(hours, minutes, seconds, Math.trunc(calculatedTime * 1000))
     }).withTimeZone(this.geoLocation.getTimeZone());
   }
   /**
@@ -2960,8 +2919,7 @@ class NOAACalculator {
   }
   /**
    * Returns the <a href="http://en.wikipedia.org/wiki/Hour_angle">hour angle</a> of the sun at sunset for the
-   * latitude. TODO: use - {@link #getSunHourAngleAtSunrise(double, double, double)} implementation to avoid
-   * duplication of code.
+   * latitude.
    * @private
    * @param {number} lat
    *            the latitude of observer in degrees
@@ -3122,40 +3080,6 @@ class NOAACalculator {
     return timeUTC;
   }
 }
-exports.NOAACalculator = esm.NOAACalculator = NOAACalculator;
-/**
- * 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 (this can be changed via the {@link #setSunRadius(double)} method , and atmospheric refraction accounts for
- * 34 minutes or so (this can be changed via the {@link #setRefraction(double)} method), 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
@@ -3238,7 +3162,7 @@ function getFormatter$1(tzid) {
 }
 
 /** Class representing Location */
-class Location extends exports.GeoLocation {
+class Location extends GeoLocation {
   /**
    * Initialize a Location instance
    * @param {number} latitude - Latitude as a decimal, valid range -90 thru +90 (e.g. 41.85003)
@@ -6731,10 +6655,6 @@ function m() {
 
 m();
 
-var global$d = /*#__PURE__*/Object.freeze({
-__proto__: null
-});
-
 /**
  * @private
  * @param {number} number
@@ -6808,7 +6728,7 @@ class Zmanim {
       month: dt.getMonth() + 1,
       day: dt.getDate()
     });
-    this.noaa = new exports.NOAACalculator(gloc, plainDate);
+    this.noaa = new NOAACalculator(gloc, plainDate);
     this.useElevation = Boolean(useElevation);
   }
   /**
@@ -6932,7 +6852,7 @@ class Zmanim {
     const endOfDay = this.noaa.getSunset();
     const temporalHour = this.noaa.getTemporalHour(startOfDay, endOfDay);
     const offset = Math.round(temporalHour * hours);
-    const zdt = exports.NOAACalculator.getTimeOffset(startOfDay, offset);
+    const zdt = NOAACalculator.getTimeOffset(startOfDay, offset);
     return zdtToDate(zdt);
   }
   /**
@@ -8125,6 +8045,8 @@ class ParshaEvent extends Event {
   }
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
 var check = function (it) {
   return it && it.Math === Math && it;
 };
@@ -9884,7 +9806,7 @@ class DailyLearning {
   }
 }
 
-const version="5.0.0-rc4";
+const version="5.0.0-rc5";
 
 const headers$1={"plural-forms":"nplurals=2; plural=(n > 1);"};const contexts$1={"":{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"],Tevet:["Teves"],"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 poAshkenazi = {headers:headers$1,contexts:contexts$1};
 
@@ -11330,7 +11252,10 @@ class HebrewCalendar {
    * @return {HDate} anniversary occurring in `hyear`
    */
   static getBirthdayOrAnniversary(hyear, gdate) {
-    const dt = getBirthdayOrAnniversary(hyear, gdate);
+    const dt = getBirthdayHD(hyear, gdate);
+    if (typeof dt === 'undefined') {
+      return dt;
+    }
     return new HDate(dt);
   }
 
@@ -11369,7 +11294,10 @@ class HebrewCalendar {
    * @return {HDate} anniversary occurring in hyear
    */
   static getYahrzeit(hyear, gdate) {
-    const dt = getYahrzeit(hyear, gdate);
+    const dt = getYahrzeitHD(hyear, gdate);
+    if (typeof dt === 'undefined') {
+      return dt;
+    }
     return new HDate(dt);
   }
 
@@ -11596,6 +11524,7 @@ exports.AsaraBTevetEvent = AsaraBTevetEvent;
 exports.CandleLightingEvent = CandleLightingEvent;
 exports.DailyLearning = DailyLearning;
 exports.Event = Event;
+exports.GeoLocation = GeoLocation;
 exports.HDate = HDate;
 exports.HavdalahEvent = HavdalahEvent;
 exports.HebrewCalendar = HebrewCalendar;
@@ -11606,6 +11535,7 @@ exports.Location = Location;
 exports.MevarchimChodeshEvent = MevarchimChodeshEvent;
 exports.Molad = Molad;
 exports.MoladEvent = MoladEvent;
+exports.NOAACalculator = NOAACalculator;
 exports.OmerEvent = OmerEvent;
 exports.ParshaEvent = ParshaEvent;
 exports.RoshChodeshEvent = RoshChodeshEvent;
@@ -11622,4 +11552,4 @@ exports.version = version;
 
 return exports;
 
-})({});
+})({}, Temporal);