@hebcal/noaa 0.8.16 → 0.9.1

package/dist/index.d.ts

@@ -116,7 +116,7 @@ export declare class NOAACalculator {
      * The zenith of astronomical sunrise and sunset. The sun is 90° from the vertical 0°
      * @private
      */
-    private static readonly GEOMETRIC_ZENITH;
+    protected static readonly GEOMETRIC_ZENITH: number;
     /**
      * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebcal/noaa",
-  "version": "0.8.16",
+  "version": "0.9.1",
   "description": "sunrise and sunset via NOAA algorithm with elevation, based on KosherJava",
   "author": "Michael J. Radwin (https://github.com/mjradwin)",
   "contributors": [
@@ -8,26 +8,25 @@
     "Eliyahu Hershfeld (https://github.com/KosherJava)",
     "Benny Powers (https://github.com/bennypowers)"
   ],
-  "license": "LGPL-3.0",
+  "license": "LGPL-2.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hebcal/noaa.git"
   },
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
+  "bugs": {
+    "url": "https://github.com/hebcal/noaa/issues"
+  },
+  "homepage": "https://hebcal.github.io/api/noaa/",
+  "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "type": "module",
   "exports": {
-    "import": "./dist/index.mjs",
-    "require": "./dist/index.cjs",
-    "types": "./dist/index.d.ts"
+    ".": "./dist/index.js"
   },
   "scripts": {
     "docs": "typedoc",
     "test": "ava",
-    "build": "npm run build:cjs && mv dist/index.js dist/index.cjs && npm run build:es6 && mv dist/index.js dist/index.mjs",
-    "build:cjs": "tsc -p ./tsconfig-cjs.json",
-    "build:es6": "tsc",
+    "build": "tsc",
     "clean": "gts clean",
     "fix": "gts fix",
     "prepare": "npm run build",
@@ -44,13 +43,13 @@
     "dist/*"
   ],
   "devDependencies": {
-    "@types/node": "22.10.2",
+    "@types/node": "22.13.14",
     "ava": "^6.2.0",
     "gts": "^5.3.1",
-    "typedoc": "^0.27.4",
-    "typescript": "^5.7.2"
+    "typedoc": "^0.28.1",
+    "typescript": "^5.8.2"
   },
   "dependencies": {
-    "temporal-polyfill": "^0.2.5"
+    "temporal-polyfill": "^0.3.0"
   }
 }

package/dist/index.cjs

@@ -1,1102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NOAACalculator = exports.GeoLocation = void 0;
-require("temporal-polyfill/global");
-/**
- * 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 © 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 "Lakewood, NJ"
-     * @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) {
-        this.timeZoneId = timeZoneId;
-    }
-}
-exports.GeoLocation = GeoLocation;
-/**
- * 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;
-    }
-}
-exports.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, 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;