ootk 4.0.8 → 5.0.0

package/src/body/Moon.ts

@@ -0,0 +1,556 @@
+/**
+ * @author Theodore Kruczek.
+ * @license MIT
+ * @copyright (c) 2022-2025 Theodore Kruczek Permission is
+ * hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the
+ * Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * @copyright (c) 2011-2015, Vladimir Agafonkin
+ * @copyright (c) 2022 Robert Gester https://github.com/hypnos3/suncalc3
+ * @see suncalc.LICENSE.md
+ * Some of the math in this file was originally created by Vladimir Agafonkin.
+ * Robert Gester's update was referenced for documentation. There were a couple
+ * of bugs in both versions so there will be some differences if you are
+ * migrating from either to this library.
+ *
+ * suncalc is a JavaScript library for calculating sun/moon position and light
+ * phases. https://github.com/mourner/suncalc
+ * It was reworked and enhanced by Robert Gester.
+ *
+ * The original suncalc is released under the terms of the BSD 2-Clause License.
+ * @see http://aa.quae.nl/en/reken/hemelpositie.html
+ * moon calculations are based on formulas from this website
+ */
+
+import { AngularDiameterMethod, Celestial, Degrees, Kilometers, RaDec, Radians } from '../main.js';
+import { Vector3D } from '../operations/Vector3D.js';
+import { EpochUTC } from '../time/EpochUTC.js';
+import { DEG2RAD, MS_PER_DAY } from '../utils/constants.js';
+import { angularDiameter } from '../utils/functions.js';
+import { Earth } from './Earth.js';
+import { Sun } from './Sun.js';
+
+type MoonIlluminationData = {
+  fraction: number;
+  phase: {
+    from: number;
+    to: number;
+    id: string;
+    emoji: string;
+    code: string;
+    name: string;
+    weight: number;
+    css: string;
+  };
+  phaseValue: number;
+  angle: number;
+  next: {
+    value: number;
+    date: string;
+    type: string;
+    newMoon: {
+      value: number;
+      date: string;
+    };
+    fullMoon: {
+      value: number;
+      date: string;
+    };
+    firstQuarter: {
+      value: number;
+      date: string;
+    };
+    thirdQuarter: {
+      value: number;
+      date: string;
+    };
+  };
+};
+
+// / Moon metrics and operations.
+export class Moon {
+  private constructor() {
+    // disable constructor
+  }
+
+  // / Moon gravitational parameter _(km³/s²)_.
+  static readonly mu = 4902.799;
+
+  // / Moon equatorial radius _(km)_.
+  static readonly radiusEquator = 1738.0;
+
+  // / Calculate the Moon's ECI position _(km)_ for a given UTC [epoch].
+  static eci(epoch: EpochUTC = EpochUTC.fromDateTime(new Date())): Vector3D<Kilometers> {
+    const jc = epoch.toJulianCenturies();
+    const dtr = DEG2RAD;
+    const lamEcl =
+      218.32 +
+      481267.8813 * jc +
+      6.29 * Math.sin((134.9 + 477198.85 * jc) * dtr) -
+      1.27 * Math.sin((259.2 - 413335.38 * jc) * dtr) +
+      0.66 * Math.sin((235.7 + 890534.23 * jc) * dtr) +
+      0.21 * Math.sin((269.9 + 954397.7 * jc) * dtr) -
+      0.19 * Math.sin((357.5 + 35999.05 * jc) * dtr) -
+      0.11 * Math.sin((186.6 + 966404.05 * jc) * dtr);
+    const phiEcl =
+      5.13 * Math.sin((93.3 + 483202.03 * jc) * dtr) +
+      0.28 * Math.sin((228.2 + 960400.87 * jc) * dtr) -
+      0.28 * Math.sin((318.3 + 6003.18 * jc) * dtr) -
+      0.17 * Math.sin((217.6 - 407332.2 * jc) * dtr);
+    const pllx =
+      0.9508 +
+      0.0518 * Math.cos((134.9 + 477198.85 * jc) * dtr) +
+      0.0095 * Math.cos((259.2 - 413335.38 * jc) * dtr) +
+      0.0078 * Math.cos((235.7 + 890534.23 * jc) * dtr) +
+      0.0028 * Math.cos((269.9 + 954397.7 * jc) * dtr);
+    const obq = 23.439291 - 0.0130042 * jc;
+    const rMag = 1 / Math.sin(pllx * dtr);
+    const r = new Vector3D(
+      rMag * Math.cos(phiEcl * dtr) * Math.cos(lamEcl * dtr),
+      rMag *
+      (Math.cos(obq * dtr) * Math.cos(phiEcl * dtr) * Math.sin(lamEcl * dtr) -
+        Math.sin(obq * dtr) * Math.sin(phiEcl * dtr)),
+      rMag *
+      (Math.sin(obq * dtr) * Math.cos(phiEcl * dtr) * Math.sin(lamEcl * dtr) +
+        Math.cos(obq * dtr) * Math.sin(phiEcl * dtr)),
+    );
+    const rMOD = r.scale(Earth.radiusEquator);
+    const p = Earth.precession(epoch);
+
+    return rMOD
+      .rotZ(p.zed)
+      .rotY(-p.theta as Radians)
+      .rotZ(p.zeta);
+  }
+
+  /**
+   * Calculates the illumination of the Moon at a given epoch.
+   * @param epoch - The epoch in UTC.
+   * @param origin - The origin vector. Defaults to the origin vector if not provided.
+   * @returns The illumination of the Moon, ranging from 0 to 1.
+   */
+  static illumination(epoch: EpochUTC, origin?: Vector3D<Kilometers>): number {
+    const orig = origin ?? (Vector3D.origin as Vector3D<Kilometers>);
+    const sunPos = Sun.position(epoch).subtract(orig);
+    const moonPos = this.eci(epoch).subtract(orig);
+    const phaseAngle = sunPos.angle(moonPos);
+
+    return 0.5 * (1 - Math.cos(phaseAngle));
+  }
+
+  /**
+   * Calculates the diameter of the Moon.
+   * @param obsPos - The position of the observer.
+   * @param moonPos - The position of the Moon.
+   * @returns The diameter of the Moon.
+   */
+  static diameter(obsPos: Vector3D, moonPos: Vector3D): number {
+    return angularDiameter(this.radiusEquator * 2, obsPos.subtract(moonPos).magnitude(), AngularDiameterMethod.Sphere);
+  }
+
+  /**
+   * calculations for illumination parameters of the moon, based on
+   * http://idlastro.gsfc.nasa.gov/ftp/pro/astro/mphase.pro formulas and Chapter 48 of "Astronomical Algorithms" 2nd
+   * edition by Jean Meeus (Willmann-Bell, Richmond) 1998.
+   * @param date Date object or timestamp for calculating moon-illumination
+   * @returns result object of moon-illumination
+   */
+  // eslint-disable-next-line max-statements
+  static getMoonIllumination(date: number | Date): MoonIlluminationData {
+    const dateValue = date instanceof Date ? date.getTime() : date;
+
+    const lunarDaysMs = 2551442778; // The duration in days of a lunar cycle is 29.53058770576 days.
+    const firstNewMoon2000 = 947178840000; // first newMoon in the year 2000 2000-01-06 18:14
+    const dateObj = new Date(dateValue);
+    const d = Sun.date2jSince2000(dateObj);
+    const s = Sun.raDec(dateObj);
+    const m = Moon.moonCoords(d);
+    const sdist = 149598000; // distance from Earth to Sun in km
+    const phi = Math.acos(
+      Math.sin(s.dec) * Math.sin(m.dec) + Math.cos(s.dec) * Math.cos(m.dec) * Math.cos(s.ra - m.ra),
+    );
+    const inc = Math.atan2(sdist * Math.sin(phi), m.dist - sdist * Math.cos(phi));
+    const angle = Math.atan2(
+      Math.cos(s.dec) * Math.sin(s.ra - m.ra),
+      Math.sin(s.dec) * Math.cos(m.dec) - Math.cos(s.dec) * Math.sin(m.dec) * Math.cos(s.ra - m.ra),
+    );
+    const phaseValue = 0.5 + (0.5 * inc * (angle < 0 ? -1 : 1)) / Math.PI;
+
+    /*
+     * calculates the difference in ms between the sirst fullMoon 2000 and given
+     * Date
+     */
+    const diffBase = dateValue - firstNewMoon2000;
+    // Calculate modulus to drop completed cycles
+    let cycleModMs = diffBase % lunarDaysMs;
+    // If negative number (date before new moon 2000) add lunarDaysMs
+
+    if (cycleModMs < 0) {
+      cycleModMs += lunarDaysMs;
+    }
+    const nextNewMoon = lunarDaysMs - cycleModMs + dateValue;
+    let nextFullMoon = lunarDaysMs / 2 - cycleModMs + dateValue;
+
+    if (nextFullMoon < dateValue) {
+      nextFullMoon += lunarDaysMs;
+    }
+    const quater = lunarDaysMs / 4;
+    let nextFirstQuarter = quater - cycleModMs + dateValue;
+
+    if (nextFirstQuarter < dateValue) {
+      nextFirstQuarter += lunarDaysMs;
+    }
+    let nextThirdQuarter = lunarDaysMs - quater - cycleModMs + dateValue;
+
+    if (nextThirdQuarter < dateValue) {
+      nextThirdQuarter += lunarDaysMs;
+    }
+    /*
+     * Calculate the fraction of the moon cycle const currentfrac = cycleModMs /
+     * lunarDaysMs;
+     */
+    const next = Math.min(nextNewMoon, nextFirstQuarter, nextFullMoon, nextThirdQuarter);
+    // eslint-disable-next-line init-declarations
+    let phase: (typeof Moon.moonCycles_)[0] | null = null;
+
+    for (const moonCycle of Moon.moonCycles_) {
+      if (phaseValue >= moonCycle.from && phaseValue <= moonCycle.to) {
+        phase = moonCycle;
+        break;
+      }
+    }
+
+    if (!phase) {
+      throw new Error('Moon phase not found');
+    }
+
+    let type = '';
+
+    if (next === nextNewMoon) {
+      type = 'newMoon';
+    } else if (next === nextFirstQuarter) {
+      type = 'firstQuarter';
+    } else if (next === nextFullMoon) {
+      type = 'fullMoon';
+    } else {
+      type = 'thirdQuarter';
+    }
+
+    return {
+      fraction: (1 + Math.cos(inc)) / 2,
+      phase,
+      phaseValue,
+      angle,
+      next: {
+        value: next,
+        date: new Date(next).toISOString(),
+        type,
+        newMoon: {
+          value: nextNewMoon,
+          date: new Date(nextNewMoon).toISOString(),
+        },
+        fullMoon: {
+          value: nextFullMoon,
+          date: new Date(nextFullMoon).toISOString(),
+        },
+        firstQuarter: {
+          value: nextFirstQuarter,
+          date: new Date(nextFirstQuarter).toISOString(),
+        },
+        thirdQuarter: {
+          value: nextThirdQuarter,
+          date: new Date(nextThirdQuarter).toISOString(),
+        },
+      },
+    };
+  }
+
+  static rae(
+    date: Date,
+    lat: Degrees,
+    lon: Degrees,
+  ): {
+    az: Radians;
+    el: Radians;
+    rng: Kilometers;
+    parallacticAngle: Radians;
+  } {
+    const lw = <Radians>(DEG2RAD * -lon);
+    const phi = <Radians>(DEG2RAD * lat);
+    const d = Sun.date2jSince2000(date);
+    const c = Moon.moonCoords(d);
+    const H = Sun.siderealTime(d, lw) - c.ra;
+    let h = Celestial.elevation(H, phi, c.dec);
+    /*
+     * formula 14.1 of "Astronomical Algorithms" 2nd edition by Jean Meeus
+     * (Willmann-Bell, Richmond) 1998.
+     */
+    const pa = Math.atan2(Math.sin(H), Math.tan(phi) * Math.cos(c.dec) - Math.sin(c.dec) * Math.cos(H));
+
+    h = <Radians>(h + Celestial.atmosphericRefraction(h)); // altitude correction for refraction
+
+    return {
+      az: Celestial.azimuth(H, phi, c.dec),
+      el: h,
+      rng: c.dist,
+      parallacticAngle: pa as Radians,
+    };
+  }
+
+  /**
+   * calculations for moon rise/set times are based on http://www.stargazing.net/kepler/moonrise.html article
+   * @param date Date object or timestamp for calculating moon rise/set
+   * @param lat Latitude of observer in degrees
+   * @param lon Longitude of observer in degrees
+   * @param isUtc If true, date will be interpreted as UTC
+   * @returns result object of moon rise/set
+   */
+  static getMoonTimes(date: Date, lat: Degrees, lon: Degrees, isUtc = false) {
+    // Clone the date so we don't change the original
+    const date_ = new Date(date);
+
+    if (isUtc) {
+      date_.setUTCHours(0, 0, 0, 0);
+    } else {
+      date_.setHours(0, 0, 0, 0);
+    }
+
+    const { rise, set, ye } = Moon.calculateRiseSetTimes_(date_, lat, lon);
+
+    const result = {
+      rise: null as Date | null,
+      set: null as Date | null,
+      ye: null as number | null,
+      alwaysUp: null as boolean | null,
+      alwaysDown: null as boolean | null,
+      highest: null as Date | null,
+    };
+
+    if (rise) {
+      result.rise = new Date(Moon.hoursLater_(date_, rise));
+    }
+
+    if (set) {
+      result.set = new Date(Moon.hoursLater_(date_, set));
+    }
+
+    if (!rise && !set) {
+      if (ye > 0) {
+        result.alwaysUp = true;
+        result.alwaysDown = false;
+      } else {
+        result.alwaysUp = false;
+        result.alwaysDown = true;
+      }
+    } else if (rise && set) {
+      result.alwaysUp = false;
+      result.alwaysDown = false;
+      result.highest = new Date(Moon.hoursLater_(date_, Math.min(rise, set) + Math.abs(set - rise) / 2));
+    } else {
+      result.alwaysUp = false;
+      result.alwaysDown = false;
+    }
+
+    return result;
+  }
+
+  private static hoursLater_(date: Date, h: number) {
+    return new Date(date.getTime() + (h * MS_PER_DAY) / 24);
+  }
+
+  /**
+   * Calculates the geocentric ecliptic coordinates of the moon.
+   * @param d - The number of days since year 2000.
+   * @returns An object containing the right ascension, declination, and
+   * distance to the moon.
+   */
+  static moonCoords(d: number): RaDec {
+    const L = DEG2RAD * (218.316 + 13.176396 * d); // ecliptic longitude
+    const M = DEG2RAD * (134.963 + 13.064993 * d); // mean anomaly
+    const F = DEG2RAD * (93.272 + 13.22935 * d); // mean distance
+    const l = L + DEG2RAD * 6.289 * Math.sin(M); // longitude
+    const b = DEG2RAD * 5.128 * Math.sin(F); // latitude
+    const dt = 385001 - 20905 * Math.cos(M); // distance to the moon in km
+
+    return {
+      ra: Celestial.rightAscension(l, b),
+      dec: Celestial.declination(l, b),
+      dist: dt as Kilometers,
+    };
+  }
+
+  private static calculateRiseSetTimes_(t: Date, lat: Degrees, lon: Degrees) {
+    const hc = 0.133 * DEG2RAD;
+    let h0 = Moon.rae(t, lat, lon).el - hc;
+    let h1 = 0;
+    let h2 = 0;
+    let rise = 0;
+    let set = 0;
+    let a = 0;
+    let b = 0;
+    let xe = 0;
+    let ye = 0;
+    let d = 0;
+    let roots = 0;
+    let x1 = 0;
+    let x2 = 0;
+    let dx = 0;
+
+    /*
+     * go in 2-hour chunks, each time seeing if a 3-point quadratic curve
+     * crosses zero (which means rise or set)
+     */
+    for (let i = 1; i <= 24; i += 2) {
+      h1 = Moon.rae(Moon.hoursLater_(t, i), lat, lon).el - hc;
+      h2 = Moon.rae(Moon.hoursLater_(t, i + 1), lat, lon).el - hc;
+
+      a = (h0 + h2) / 2 - h1;
+      b = (h2 - h0) / 2;
+      xe = -b / (2 * a);
+      ye = (a * xe + b) * xe + h1;
+      d = b * b - 4 * a * h1;
+      roots = 0;
+
+      if (d >= 0) {
+        dx = Math.sqrt(d) / (Math.abs(a) * 2);
+        x1 = xe - dx;
+        x2 = xe + dx;
+        if (Math.abs(x1) <= 1) {
+          roots++;
+        }
+        if (Math.abs(x2) <= 1) {
+          roots++;
+        }
+        if (x1 < -1) {
+          x1 = x2;
+        }
+      }
+
+      if (roots === 1) {
+        if (h0 < 0) {
+          rise = i + x1;
+        } else {
+          set = i + x1;
+        }
+      } else if (roots === 2) {
+        rise = i + (ye < 0 ? x2 : x1);
+        set = i + (ye < 0 ? x1 : x2);
+      }
+
+      if (rise && set) {
+        break;
+      }
+
+      h0 = h2;
+    }
+
+    return { rise, set, ye };
+  }
+
+  private static readonly moonCycles_ = [
+    {
+      from: 0,
+      to: 0.033863193308711,
+      id: 'newMoon',
+      emoji: '🌚',
+      code: ':new_moon_with_face:',
+      name: 'New Moon',
+      weight: 1,
+      css: 'wi-moon-new',
+    },
+    {
+      from: 0.033863193308711,
+      to: 0.216136806691289,
+      id: 'waxingCrescentMoon',
+      emoji: '🌒',
+      code: ':waxing_crescent_moon:',
+      name: 'Waxing Crescent',
+      weight: 6.3825,
+      css: 'wi-moon-wax-cres',
+    },
+    {
+      from: 0.216136806691289,
+      to: 0.283863193308711,
+      id: 'firstQuarterMoon',
+      emoji: '🌓',
+      code: ':first_quarter_moon:',
+      name: 'First Quarter',
+      weight: 1,
+      css: 'wi-moon-first-quart',
+    },
+    {
+      from: 0.283863193308711,
+      to: 0.466136806691289,
+      id: 'waxingGibbousMoon',
+      emoji: '🌔',
+      code: ':waxing_gibbous_moon:',
+      name: 'Waxing Gibbous',
+      weight: 6.3825,
+      css: 'wi-moon-wax-gibb',
+    },
+    {
+      from: 0.466136806691289,
+      to: 0.533863193308711,
+      id: 'fullMoon',
+      emoji: '🌝',
+      code: ':full_moon_with_face:',
+      name: 'Full Moon',
+      weight: 1,
+      css: 'wi-moon-full',
+    },
+    {
+      from: 0.533863193308711,
+      to: 0.716136806691289,
+      id: 'waningGibbousMoon',
+      emoji: '🌖',
+      code: ':waning_gibbous_moon:',
+      name: 'Waning Gibbous',
+      weight: 6.3825,
+      css: 'wi-moon-wan-gibb',
+    },
+    {
+      from: 0.716136806691289,
+      to: 0.783863193308711,
+      id: 'thirdQuarterMoon',
+      emoji: '🌗',
+      code: ':last_quarter_moon:',
+      name: 'third Quarter',
+      weight: 1,
+      css: 'wi-moon-third-quart',
+    },
+    {
+      from: 0.783863193308711,
+      to: 0.966136806691289,
+      id: 'waningCrescentMoon',
+      emoji: '🌘',
+      code: ':waning_crescent_moon:',
+      name: 'Waning Crescent',
+      weight: 6.3825,
+      css: 'wi-moon-wan-cres',
+    },
+    {
+      from: 0.966136806691289,
+      to: 1,
+      id: 'newMoon',
+      emoji: '🌚',
+      code: ':new_moon_with_face:',
+      name: 'New Moon',
+      weight: 1,
+      css: 'wi-moon-new',
+    },
+  ];
+}

package/src/body/NutationAngles.ts

@@ -0,0 +1,40 @@
+/**
+ * @author Theodore Kruczek.
+ * @license MIT
+ * @copyright (c) 2022-2025 Theodore Kruczek Permission is
+ * hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the
+ * Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Radians } from '../main.js';
+
+/** Represents the nutation angles. */
+export type NutationAngles = {
+  /** The nutation in longitude (Δψ) in radians. */
+  dPsi: Radians;
+  /** The nutation in obliquity (Δε) in radians. */
+  dEps: Radians;
+  /** The mean obliquity of the ecliptic (ε₀) in radians. */
+  mEps: Radians;
+  /** The true obliquity of the ecliptic (ε) in radians. */
+  eps: Radians;
+  /** The equation of the equinoxes (ΔΔt) in radians. */
+  eqEq: Radians;
+  /** The Greenwich Apparent Sidereal Time (GAST) in radians. */
+  gast: Radians;
+};

package/src/body/PrecessionAngles.ts

@@ -0,0 +1,31 @@
+/**
+ * @author Theodore Kruczek.
+ * @license MIT
+ * @copyright (c) 2022-2025 Theodore Kruczek Permission is
+ * hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the
+ * Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Radians } from '../main.js';
+
+/** Represents the precession angles in radians. */
+export type PrecessionAngles = {
+  zeta: Radians;
+  theta: Radians;
+  zed: Radians;
+};