@openwaters/almanac 0.0.0-bootstrap

package/dist/positions.js

@@ -0,0 +1,52 @@
+// L1 public positions: apparent geocentric Sun and Moon on the true equator and
+// equinox of date.
+//
+// The composition chain mirrors the cosinekitty/astronomy upstream (pinned sha
+// 865d3da7d8112bbc7911238052c6af4aaf877181):
+//   Sun:  GeoVector(Body.Sun, t, aberration=true) -> BackdatePosition ->
+//         CorrectLightTravel over -HelioVector(Earth), then
+//         Equator(ofdate=true) -> gyration(From2000) -> vector2radec.
+//   Moon: GeoVector(Body.Moon, t) -> GeoMoon (MOON2, ecliptic of date ->
+//         mean equator of date -> J2000), then the same
+//         Equator(ofdate=true) gyration and vector2radec.
+// Both are geocentric, so upstream's `gc_observer` term (Equator's topocentric
+// parallax subtraction) is zero and drops out.
+import { assertSupported } from './types.js';
+import { ttDays } from './time.js';
+import { KM_PER_AU, equatorialFromVector } from './nutation.js';
+import { moonGeoVector } from './moon.js';
+import { sunGeoVector } from './sun.js';
+/**
+ * INTERNAL: apparent Sun for a TT instant, expressed as days since the J2000
+ * epoch in Terrestrial Time. This is the entry point the TT-labeled position
+ * fixtures compare against — going through `sunPosition` would first convert
+ * UTC → TT with a ΔT model, putting a timescale approximation between the
+ * ephemeris and the reference data.
+ */
+export function sunApparentAtTT(tt) {
+    const { raDeg, decDeg, distanceAu } = equatorialFromVector(sunGeoVector(tt));
+    return { raDeg, decDeg, distanceAu };
+}
+/** INTERNAL: apparent Moon for a TT instant. See {@link sunApparentAtTT}. */
+export function moonApparentAtTT(tt) {
+    const { raDeg, decDeg, distanceAu } = equatorialFromVector(moonGeoVector(tt));
+    return { raDeg, decDeg, distanceKm: distanceAu * KM_PER_AU };
+}
+/**
+ * Apparent geocentric position of the Sun — right ascension and declination on
+ * the true equator and equinox of date (precession, nutation and aberration
+ * applied), plus the light-time-corrected distance in AU.
+ */
+export function sunPosition(time) {
+    assertSupported(time);
+    return sunApparentAtTT(ttDays(time));
+}
+/**
+ * Apparent geocentric position of the Moon — right ascension and declination on
+ * the true equator and equinox of date (precession and nutation applied), plus
+ * the Earth-Moon centre distance in kilometres.
+ */
+export function moonPosition(time) {
+    assertSupported(time);
+    return moonApparentAtTT(ttDays(time));
+}

package/dist/sun.d.ts

@@ -0,0 +1,27 @@
+import { Vec3 } from './nutation.js';
+/**
+ * UPSTREAM: `CalcVsop`, astronomy.ts lines 3255-3262, specialised to
+ * `vsop.Earth` — i.e. `HelioVector(Body.Earth, time)`. J2000 mean equator (EQJ).
+ */
+export declare function earthHelioVector(tt: number): Vec3;
+/**
+ * UPSTREAM: `CorrectLightTravel` (astronomy.ts 4170-4191) driving
+ * `BodyPosition.Position` (4193-4241) with observerBody = Earth,
+ * targetBody = Sun, aberration = true — i.e. what
+ * `GeoVector(Body.Sun, time, true)` computes via `BackdatePosition`.
+ *
+ * `HelioVector(Body.Sun, t)` is the zero vector, so the target position is
+ * always the origin and the whole correction is the backdated Earth: the
+ * light-time retardation and the ~20.5" annual aberration fall out of the same
+ * iteration, exactly as upstream intends.
+ *
+ * @returns geocentric position in AU, J2000 mean equator (EQJ).
+ */
+export declare function sunGeoVectorEqj(tt: number): Vec3;
+/**
+ * UPSTREAM: `GeoVector(Body.Sun, time, aberration=true)` composed with the
+ * `gyration(..., From2000)` of `Equator(ofdate=true)` (astronomy.ts 2803-2822).
+ *
+ * @returns geocentric position in AU, true equator & equinox of date.
+ */
+export declare function sunGeoVector(tt: number): Vec3;

package/dist/sun.js

@@ -0,0 +1,184 @@
+// L1 solar position: geocentric Sun from the truncated VSOP87 Earth series,
+// with light-travel and aberration correction.
+//
+// Translated from the cosinekitty/astronomy upstream, pinned sha
+// 865d3da7d8112bbc7911238052c6af4aaf877181, source/js/astronomy.ts. The
+// `vsop.Earth` table below is copied verbatim from that file (lines 555-628);
+// operation order is preserved so a Swift port agrees bit-for-bit.
+//
+// INTERNAL: not part of the curated public API (see index.ts).
+import { C_AUDAY, PI2, PrecessDirection, gyration } from './nutation.js';
+/** UPSTREAM: `vsop.Earth`, astronomy.ts lines 555-628 (longitude, latitude, radius). */
+const vsopEarth = [
+    [
+        [
+            [1.75347045673, 0.00000000000, 0.00000000000],
+            [0.03341656453, 4.66925680415, 6283.07584999140],
+            [0.00034894275, 4.62610242189, 12566.15169998280],
+            [0.00003417572, 2.82886579754, 3.52311834900],
+            [0.00003497056, 2.74411783405, 5753.38488489680],
+            [0.00003135899, 3.62767041756, 77713.77146812050],
+            [0.00002676218, 4.41808345438, 7860.41939243920],
+            [0.00002342691, 6.13516214446, 3930.20969621960],
+            [0.00001273165, 2.03709657878, 529.69096509460],
+            [0.00001324294, 0.74246341673, 11506.76976979360],
+            [0.00000901854, 2.04505446477, 26.29831979980],
+            [0.00001199167, 1.10962946234, 1577.34354244780],
+            [0.00000857223, 3.50849152283, 398.14900340820],
+            [0.00000779786, 1.17882681962, 5223.69391980220],
+            [0.00000990250, 5.23268072088, 5884.92684658320],
+            [0.00000753141, 2.53339052847, 5507.55323866740],
+            [0.00000505267, 4.58292599973, 18849.22754997420],
+            [0.00000492392, 4.20505711826, 775.52261132400],
+            [0.00000356672, 2.91954114478, 0.06731030280],
+            [0.00000284125, 1.89869240932, 796.29800681640],
+            [0.00000242879, 0.34481445893, 5486.77784317500],
+            [0.00000317087, 5.84901948512, 11790.62908865880],
+            [0.00000271112, 0.31486255375, 10977.07880469900],
+            [0.00000206217, 4.80646631478, 2544.31441988340],
+            [0.00000205478, 1.86953770281, 5573.14280143310],
+            [0.00000202318, 2.45767790232, 6069.77675455340],
+            [0.00000126225, 1.08295459501, 20.77539549240],
+            [0.00000155516, 0.83306084617, 213.29909543800]
+        ],
+        [
+            [6283.07584999140, 0.00000000000, 0.00000000000],
+            [0.00206058863, 2.67823455808, 6283.07584999140],
+            [0.00004303419, 2.63512233481, 12566.15169998280]
+        ],
+        [
+            [0.00008721859, 1.07253635559, 6283.07584999140]
+        ]
+    ],
+    [
+        [],
+        [
+            [0.00227777722, 3.41376620530, 6283.07584999140],
+            [0.00003805678, 3.37063423795, 12566.15169998280]
+        ]
+    ],
+    [
+        [
+            [1.00013988784, 0.00000000000, 0.00000000000],
+            [0.01670699632, 3.09846350258, 6283.07584999140],
+            [0.00013956024, 3.05524609456, 12566.15169998280],
+            [0.00003083720, 5.19846674381, 77713.77146812050],
+            [0.00001628463, 1.17387558054, 5753.38488489680],
+            [0.00001575572, 2.84685214877, 7860.41939243920],
+            [0.00000924799, 5.45292236722, 11506.76976979360],
+            [0.00000542439, 4.56409151453, 3930.20969621960],
+            [0.00000472110, 3.66100022149, 5884.92684658320],
+            [0.00000085831, 1.27079125277, 161000.68573767410],
+            [0.00000057056, 2.01374292245, 83996.84731811189],
+            [0.00000055736, 5.24159799170, 71430.69561812909],
+            [0.00000174844, 3.01193636733, 18849.22754997420],
+            [0.00000243181, 4.27349530790, 11790.62908865880]
+        ],
+        [
+            [0.00103018607, 1.10748968172, 6283.07584999140],
+            [0.00001721238, 1.06442300386, 12566.15169998280]
+        ],
+        [
+            [0.00004359385, 5.78455133808, 6283.07584999140]
+        ]
+    ]
+];
+/** UPSTREAM: astronomy.ts lines 3229-3232. */
+const DAYS_PER_MILLENNIUM = 365250;
+const LON_INDEX = 0;
+const LAT_INDEX = 1;
+const RAD_INDEX = 2;
+/** UPSTREAM: `VsopFormula`, astronomy.ts lines 3191-3205. */
+function vsopFormula(formula, t, clamp_angle) {
+    let tpower = 1;
+    let coord = 0;
+    for (let series of formula) {
+        let sum = 0;
+        for (let [ampl, phas, freq] of series)
+            sum += ampl * Math.cos(phas + (t * freq));
+        let incr = tpower * sum;
+        if (clamp_angle)
+            incr %= PI2; // improve precision for longitudes: they can be hundreds of radians
+        coord += incr;
+        tpower *= t;
+    }
+    return coord;
+}
+/** UPSTREAM: `VsopRotate`, astronomy.ts lines 3234-3241 — VSOP ecliptic to J2000 equatorial. */
+function vsopRotate(eclip) {
+    return {
+        x: eclip.x + 0.000000440360 * eclip.y - 0.000000190919 * eclip.z,
+        y: -0.000000479966 * eclip.x + 0.917482137087 * eclip.y - 0.397776982902 * eclip.z,
+        z: 0.397776982902 * eclip.y + 0.917482137087 * eclip.z
+    };
+}
+/** UPSTREAM: `VsopSphereToRect`, astronomy.ts lines 3243-3253. */
+function vsopSphereToRect(lon, lat, radius) {
+    // Convert spherical coordinates to ecliptic cartesian coordinates.
+    const r_coslat = radius * Math.cos(lat);
+    const coslon = Math.cos(lon);
+    const sinlon = Math.sin(lon);
+    return {
+        x: r_coslat * coslon,
+        y: r_coslat * sinlon,
+        z: radius * Math.sin(lat)
+    };
+}
+/**
+ * UPSTREAM: `CalcVsop`, astronomy.ts lines 3255-3262, specialised to
+ * `vsop.Earth` — i.e. `HelioVector(Body.Earth, time)`. J2000 mean equator (EQJ).
+ */
+export function earthHelioVector(tt) {
+    const t = tt / DAYS_PER_MILLENNIUM; // millennia since 2000
+    const lon = vsopFormula(vsopEarth[LON_INDEX], t, true);
+    const lat = vsopFormula(vsopEarth[LAT_INDEX], t, false);
+    const rad = vsopFormula(vsopEarth[RAD_INDEX], t, false);
+    const eclip = vsopSphereToRect(lon, lat, rad);
+    return vsopRotate(eclip);
+}
+/**
+ * UPSTREAM: `CorrectLightTravel` (astronomy.ts 4170-4191) driving
+ * `BodyPosition.Position` (4193-4241) with observerBody = Earth,
+ * targetBody = Sun, aberration = true — i.e. what
+ * `GeoVector(Body.Sun, time, true)` computes via `BackdatePosition`.
+ *
+ * `HelioVector(Body.Sun, t)` is the zero vector, so the target position is
+ * always the origin and the whole correction is the backdated Earth: the
+ * light-time retardation and the ~20.5" annual aberration fall out of the same
+ * iteration, exactly as upstream intends.
+ *
+ * @returns geocentric position in AU, J2000 mean equator (EQJ).
+ */
+export function sunGeoVectorEqj(tt) {
+    let ltime = tt;
+    let dt = 0;
+    for (let iter = 0; iter < 10; ++iter) {
+        // BodyPosition.Position: (0,0,0) - HelioVector(Earth, ltime).
+        const earth = earthHelioVector(ltime);
+        const pos = { x: -earth.x, y: -earth.y, z: -earth.z };
+        const lt = Math.sqrt(pos.x * pos.x + pos.y * pos.y + pos.z * pos.z) / C_AUDAY;
+        // This solver does not support more than one light-day of distance,
+        // because that would cause convergence problems and inaccurate
+        // values for stellar aberration angles.
+        if (lt > 1.0)
+            throw new Error('Object is too distant for light-travel solver.');
+        // Upstream backdates via `AstroTime.AddDays`, which subtracts from UT and
+        // recomputes TT; subtracting from TT directly is what that intends (upstream
+        // documents the UT detour as "slightly wrong" at AddDays, line 1329).
+        const ltime2 = tt - lt;
+        dt = Math.abs(ltime2 - ltime);
+        if (dt < 1.0e-9) // 86.4 microseconds
+            return pos;
+        ltime = ltime2;
+    }
+    throw new Error(`Light-travel time solver did not converge: dt = ${dt}`);
+}
+/**
+ * UPSTREAM: `GeoVector(Body.Sun, time, aberration=true)` composed with the
+ * `gyration(..., From2000)` of `Equator(ofdate=true)` (astronomy.ts 2803-2822).
+ *
+ * @returns geocentric position in AU, true equator & equinox of date.
+ */
+export function sunGeoVector(tt) {
+    return gyration(sunGeoVectorEqj(tt), tt, PrecessDirection.From2000);
+}

package/dist/time.d.ts

@@ -0,0 +1,28 @@
+/** Days since J2000 (UT), fractional. */
+export declare function utDays(d: Date): number;
+/** Julian day (UT). */
+export declare function julianDay(d: Date): number;
+/**
+ * ΔT = TT − UT, in seconds, for a given decimal year.
+ *
+ * Translated from `DeltaT_EspenakMeeus` in the cosinekitty/astronomy upstream
+ * (pinned sha 865d3da7d8112bbc7911238052c6af4aaf877181,
+ * source/js/astronomy.ts, lines ~1098-1190). The upstream function converts a
+ * `ut` (days since J2000) argument to a decimal year `y` first; this port
+ * takes the decimal year directly (see ttDays' yearOf below for the caller's
+ * ut→year conversion) and translates the piecewise polynomial verbatim,
+ * coefficient-for-coefficient, including branches outside the 1950-2100
+ * interval this package supports.
+ */
+export declare function deltaTSeconds(decimalYear: number): number;
+/**
+ * Days since J2000 (TT) for a UT-days value already in hand — factored out of
+ * {@link ttDays} so L2 transforms that compute `ut` once (sidereal time,
+ * topocentric parallax) can derive `tt` from it without re-deriving the
+ * ut→year→ΔT conversion.
+ */
+export declare function ttDaysFromUt(ut: number): number;
+/** Days since J2000 (TT), fractional — the argument every translated function consumes. */
+export declare function ttDays(d: Date): number;
+/** Inverse of {@link utDays} — the instant, truncated to integer epoch ms (TimeClip). */
+export declare function dateFromUt(ut: number): Date;

package/dist/time.js

@@ -0,0 +1,144 @@
+// L0 time layer: Julian day, ΔT (Espenak–Meeus), and TT — the foundation every
+// later astronomy layer (sun/moon position, rise/set, phase) consumes via ttDays().
+// INTERNAL: not part of the curated public API (see index.ts) — L1+ layers import
+// directly from './time.js'.
+const J2000_EPOCH_MS = Date.UTC(2000, 0, 1, 12); // 2000-01-01T12:00:00Z
+/** Days since J2000 (UT), fractional. */
+export function utDays(d) {
+    return (d.getTime() - J2000_EPOCH_MS) / 86400000;
+}
+/** Julian day (UT). */
+export function julianDay(d) {
+    return utDays(d) + 2451545.0;
+}
+/**
+ * ΔT = TT − UT, in seconds, for a given decimal year.
+ *
+ * Translated from `DeltaT_EspenakMeeus` in the cosinekitty/astronomy upstream
+ * (pinned sha 865d3da7d8112bbc7911238052c6af4aaf877181,
+ * source/js/astronomy.ts, lines ~1098-1190). The upstream function converts a
+ * `ut` (days since J2000) argument to a decimal year `y` first; this port
+ * takes the decimal year directly (see ttDays' yearOf below for the caller's
+ * ut→year conversion) and translates the piecewise polynomial verbatim,
+ * coefficient-for-coefficient, including branches outside the 1950-2100
+ * interval this package supports.
+ */
+export function deltaTSeconds(decimalYear) {
+    const y = decimalYear;
+    let u, u2, u3, u4, u5, u6, u7;
+    if (y < -500) {
+        u = (y - 1820) / 100;
+        return -20 + 32 * u * u;
+    }
+    if (y < 500) {
+        u = y / 100;
+        u2 = u * u;
+        u3 = u * u2;
+        u4 = u2 * u2;
+        u5 = u2 * u3;
+        u6 = u3 * u3;
+        return 10583.6 - 1014.41 * u + 33.78311 * u2 - 5.952053 * u3 - 0.1798452 * u4 + 0.022174192 * u5 + 0.0090316521 * u6;
+    }
+    if (y < 1600) {
+        u = (y - 1000) / 100;
+        u2 = u * u;
+        u3 = u * u2;
+        u4 = u2 * u2;
+        u5 = u2 * u3;
+        u6 = u3 * u3;
+        return 1574.2 - 556.01 * u + 71.23472 * u2 + 0.319781 * u3 - 0.8503463 * u4 - 0.005050998 * u5 + 0.0083572073 * u6;
+    }
+    if (y < 1700) {
+        u = y - 1600;
+        u2 = u * u;
+        u3 = u * u2;
+        return 120 - 0.9808 * u - 0.01532 * u2 + u3 / 7129.0;
+    }
+    if (y < 1800) {
+        u = y - 1700;
+        u2 = u * u;
+        u3 = u * u2;
+        u4 = u2 * u2;
+        return 8.83 + 0.1603 * u - 0.0059285 * u2 + 0.00013336 * u3 - u4 / 1174000;
+    }
+    if (y < 1860) {
+        u = y - 1800;
+        u2 = u * u;
+        u3 = u * u2;
+        u4 = u2 * u2;
+        u5 = u2 * u3;
+        u6 = u3 * u3;
+        u7 = u3 * u4;
+        return 13.72 - 0.332447 * u + 0.0068612 * u2 + 0.0041116 * u3 - 0.00037436 * u4 + 0.0000121272 * u5 - 0.0000001699 * u6 + 0.000000000875 * u7;
+    }
+    if (y < 1900) {
+        u = y - 1860;
+        u2 = u * u;
+        u3 = u * u2;
+        u4 = u2 * u2;
+        u5 = u2 * u3;
+        return 7.62 + 0.5737 * u - 0.251754 * u2 + 0.01680668 * u3 - 0.0004473624 * u4 + u5 / 233174;
+    }
+    if (y < 1920) {
+        u = y - 1900;
+        u2 = u * u;
+        u3 = u * u2;
+        u4 = u2 * u2;
+        return -2.79 + 1.494119 * u - 0.0598939 * u2 + 0.0061966 * u3 - 0.000197 * u4;
+    }
+    if (y < 1941) {
+        u = y - 1920;
+        u2 = u * u;
+        u3 = u * u2;
+        return 21.20 + 0.84493 * u - 0.076100 * u2 + 0.0020936 * u3;
+    }
+    if (y < 1961) {
+        u = y - 1950;
+        u2 = u * u;
+        u3 = u * u2;
+        return 29.07 + 0.407 * u - u2 / 233 + u3 / 2547;
+    }
+    if (y < 1986) {
+        u = y - 1975;
+        u2 = u * u;
+        u3 = u * u2;
+        return 45.45 + 1.067 * u - u2 / 260 - u3 / 718;
+    }
+    if (y < 2005) {
+        u = y - 2000;
+        u2 = u * u;
+        u3 = u * u2;
+        u4 = u2 * u2;
+        u5 = u2 * u3;
+        return 63.86 + 0.3345 * u - 0.060374 * u2 + 0.0017275 * u3 + 0.000651814 * u4 + 0.00002373599 * u5;
+    }
+    if (y < 2050) {
+        u = y - 2000;
+        return 62.92 + 0.32217 * u + 0.005589 * u * u;
+    }
+    if (y < 2150) {
+        u = (y - 1820) / 100;
+        return -20 + 32 * u * u - 0.5628 * (2150 - y);
+    }
+    /* all years after 2150 */
+    u = (y - 1820) / 100;
+    return -20 + 32 * u * u;
+}
+/**
+ * Days since J2000 (TT) for a UT-days value already in hand — factored out of
+ * {@link ttDays} so L2 transforms that compute `ut` once (sidereal time,
+ * topocentric parallax) can derive `tt` from it without re-deriving the
+ * ut→year→ΔT conversion.
+ */
+export function ttDaysFromUt(ut) {
+    const year = 2000 + ut / 365.25;
+    return ut + deltaTSeconds(year) / 86400;
+}
+/** Days since J2000 (TT), fractional — the argument every translated function consumes. */
+export function ttDays(d) {
+    return ttDaysFromUt(utDays(d));
+}
+/** Inverse of {@link utDays} — the instant, truncated to integer epoch ms (TimeClip). */
+export function dateFromUt(ut) {
+    return new Date(ut * 86400000 + J2000_EPOCH_MS);
+}

package/dist/transforms.d.ts

@@ -0,0 +1,61 @@
+import { Observer } from './types.js';
+import { Vec3 } from './nutation.js';
+/** Topocentric horizontal position: azimuth from true north through east, altitude above the horizon. */
+export interface AltAz {
+    azDeg: number;
+    altDeg: number;
+}
+/**
+ * INTERNAL: what {@link topoAltAzUnrefracted} already computes on the way to
+ * az/alt. The L3 event layer needs all four from a single evaluation — the
+ * local hour angle brackets each daily cycle's altitude extrema, and the
+ * topocentric distance sets the Moon's semidiameter, hence its rise/set target.
+ */
+export interface TopoUnrefracted extends AltAz {
+    hourAngleDeg: number;
+    distanceAu: number;
+}
+/**
+ * UPSTREAM: `sidereal_time`, astronomy.ts ~2031 — Greenwich Apparent Sidereal
+ * Time (GAST). Returned in **degrees** [0, 360) rather than upstream's hours:
+ * every caller in this port (terra/geo_pos, Horizon's spin angle) only ever
+ * uses `15 * gastHours`, so upstream's final `/15` and each caller's `*15`
+ * are folded into one multiply here — same value, one division dropped.
+ */
+export declare function siderealDeg(ut: number): number;
+/**
+ * UPSTREAM: the topocentric path composed of `Equator(body, date, observer,
+ * ofdate=true, aberration=true)` (astronomy.ts ~2803) followed by `Horizon`
+ * (astronomy.ts ~2565), through its az/zd computation only — Horizon's
+ * post-refraction ra/dec refinement branch produces topocentric ra/dec, which
+ * this layer's callers (sunAltAz/moonAltAz) don't need.
+ *
+ * @param bodyEqj geocentric position of the body in AU, J2000 mean equator
+ *      (EQJ) — i.e. `GeoVector`'s return, matching {@link sunGeoVectorEqj} /
+ *      {@link moonGeoVectorEqj}, NOT the already-of-date vector
+ *      {@link sunApparentAtTT}/{@link moonApparentAtTT} consume.
+ * @param ut days since J2000 in UT — the event layer iterates in days, and
+ *      `Date` round-trips are pure overhead on a search's inner loop.
+ * @returns unrefracted topocentric azimuth/altitude, plus the local hour angle
+ *      and topocentric distance the same evaluation already produced.
+ */
+export declare function topoAltAzUnrefracted(bodyEqj: Vec3, ut: number, observer: Observer): TopoUnrefracted;
+/**
+ * UPSTREAM: `Refraction('normal', altitude)`, astronomy.ts ~7176 — the
+ * Saemundsson/Meeus atmospheric-lift formula (JPL Horizons' algorithm per
+ * upstream's comment), gradually reduced toward the nadir so a refracted
+ * altitude never drops below -90.
+ */
+export declare function refractionDeg(altitudeDeg: number): number;
+/**
+ * Topocentric azimuth/altitude of the Sun — parallax (via the observer's
+ * geocentric position, WGS-84 flattening, elevation) and atmospheric
+ * refraction (upstream `'normal'` model) both applied.
+ */
+export declare function sunAltAz(time: Date, observer: Observer): AltAz;
+/**
+ * Topocentric azimuth/altitude of the Moon — parallax (via the observer's
+ * geocentric position, WGS-84 flattening, elevation) and atmospheric
+ * refraction (upstream `'normal'` model) both applied.
+ */
+export declare function moonAltAz(time: Date, observer: Observer): AltAz;