@saber-usa/node-common 1.6.207

package/src/astro.js

@@ -0,0 +1,3169 @@
+const {cross, dot, norm, multiply, subtract, inv, polynomialRoot, add} = require("mathjs");
+const {dateToMySqlDate, dtStrtoJsDt, parseDate} = require("./fixDate.js");
+const solar = require("solar-calculator");
+const {
+    twoline2satrec,
+    propagate,
+    sgp4,
+    gstime,
+    eciToGeodetic,
+    degreesToRadians,
+    radiansToDegrees,
+    eciToEcf,
+    ecfToLookAngles,
+    degreesLong,
+    degreesLat,
+} = require("satellite.js");
+const {lowerCaseObjectKeys} = require("./transform.js");
+const squid = require("pious-squid");
+const {
+    normalize,
+    transpose,
+    multiplyVector,
+    dist,
+    julianToGregorian,
+    epochToDate,
+    isValidDataMode,
+    isBoolean,
+    isNonEmptyString,
+    removeNullUndefined,
+    getTimeDifference,
+    isDefined,
+    getAngle,
+    wrapToRange,
+    getAngleDiffSigned,
+    posToArray,
+} = require("./utils.js");
+const {
+    DEG2RAD,
+    RAD2DEG,
+    SEC2RAD,
+    ARCSEC2RAD,
+    AU_KM,
+    SUN_RADIUS_KM,
+    REGIMES,
+    GRAV_CONST,
+    EARTH_MASS,
+    WGS72_EARTH_EQUATORIAL_RADIUS_KM,
+    WGS84_EARTH_EQUATORIAL_RADIUS_KM,
+    MILLIS_PER_DAY,
+    GEO_ALTITUDE_KM,
+} = require("./constants.js");
+
+// Solar Terminator
+// Returns sun latitude and longitude as -180/180
+const sunPosAt = (dt) => {
+    const day = new Date(+dt).setUTCHours(0, 0, 0, 0);
+    const t = solar.century(dt);
+    const longitude = ((day - dt) / 864e5) * 360 - 180;
+    return [
+        solar.declination(t),
+        (longitude - solar.equationOfTime(t) / 4) % 360,
+    ];
+};
+
+const checkTle = (line1, line2) => {
+    try {
+        // Initialize a satellite record
+        const satrec = twoline2satrec(line1, line2);
+        satrec.epoch = dateToMySqlDate(julianToGregorian(satrec.jdsatepoch)); // Add the epoch
+        const pv = sgp4(satrec, 0);
+        if (Number.isNaN(pv.position.x) || Number.isNaN(pv.position.y) || Number.isNaN(pv.position.z)) {
+            return false;
+        } else {
+            return satrec;
+        }
+    } catch (e) {
+        return false; // TLE invalid
+    }
+};
+
+/**
+ * Calculates the semi-major axis in kilometers from a satellite record.
+ * @param {Object} satrec The satellite record from satellite.js
+ * @return {number} Semi-major axis in kilometers
+ */
+const getSemiMajorAxis = (satrec) => {
+    // satrec.a is in non-dimensionalized units (Earth radii)
+    // Convert to kilometers using WGS72 Earth equatorial radius (SGP4 standard)
+    return satrec.a * WGS72_EARTH_EQUATORIAL_RADIUS_KM;
+};
+
+const getRaanPrecession = (line1, line2) => {
+    try {
+        // Initialize a satellite record
+        const satrec = twoline2satrec(line1, line2);
+        // satrec nodedot is in radians per minute
+        // 1400 minutes / day (60 min/hr * 24 hr/day)
+        // result is in degrees per day
+        return satrec.nodedot * 1440 * RAD2DEG;
+    } catch (e) {
+        return 0;
+    }
+};
+
+const getLonAndDrift = (line1, line2, datetime) => {
+    try {
+        // Initialize a satellite record
+        const satrec = twoline2satrec(line1, line2);
+
+        let pv;
+        let pv2;
+
+        if (datetime) {
+            pv = propagate(satrec, datetime);
+            pv2 = propagate(
+                satrec,
+                new Date(datetime.getTime() + 1440 * 60000),
+            );
+        } else {
+            //  Propagate satellite using time since epoch (in minutes).
+            pv = sgp4(satrec, 0);
+            pv2 = sgp4(satrec, 1440); // One day later
+        }
+
+        // You will need GMST for some of the coordinate transforms.
+        // http://en.wikipedia.org/wiki/Sidereal_time#Definition
+        const gmst = gstime(datetime ?? satrec.jdsatepoch); // GMST at epoch
+        const gmst2 = gstime(
+            datetime
+                ? new Date(datetime.getTime() + 1440 * 60000)
+                : satrec.jdsatepoch + 1,
+        ); // GMST One day later
+
+        // You can get ECF, Geodetic, Look Angles, and Doppler Factor.
+        const positionGd = eciToGeodetic(pv.position, gmst);
+        const positionGd2 = eciToGeodetic(pv2.position, gmst2);
+
+        // Geodetic coords are accessed via `longitude`, `latitude`, `height`.
+        const lon = degreesLong(positionGd.longitude);
+        const lon2 = degreesLong(positionGd2.longitude);
+        const lat = degreesLat(positionGd.latitude);
+
+        let diff = lon2 - lon;
+        if (diff < -180) {
+            diff = (diff % 180) + 180;
+        } else if (diff > 180) {
+            diff = (diff % 180) - 180;
+        }
+
+        return {
+            latitude: lat,
+            longitude: lon,
+            longitude360: (lon+ 360) % 360,
+            lonDriftDegreesPerDay: diff,
+        };
+    } catch (e) {
+        return {
+            latitude: 0,
+            longitude: 0,
+            longitude360: 0,
+            lonDriftDegreesPerDay: 0,
+        };
+    }
+};
+
+/**
+ * Given eccentricity, inclination, meanmotion, and period
+ * Calculates & returns type of orbit to include LEO, MEO, HEO, GEO Drifter, GEO Inclined,GEO Stationary, and undetermined if applicable
+ * @param {Object} orbit Object with keys eccentricity, inclination (deg), meanmotion (rev/day) and period (min)
+ * @return {number} the regime index
+ */
+const calcRegime = (orbit) => {
+    if (!isDefined(orbit)) {
+        return REGIMES.Undetermined;
+    }
+
+    const {eccentricity, inclination, meanmotion, period}
+        = lowerCaseObjectKeys(orbit);
+
+    if (!isDefined(meanmotion) && (!isDefined(period) || !isDefined(eccentricity))) {
+        return REGIMES.Undetermined;
+    }
+
+    if (meanmotion >= 0.99 && meanmotion <= 1.01 && inclination <= 0.01) {
+        return REGIMES.GeoStationary;
+    }
+
+    if (meanmotion >= 0.99 && meanmotion <= 1.01 && inclination > 0.01) {
+        return REGIMES.GeoInclined;
+    }
+
+    if (meanmotion >= 0.94 && meanmotion <= 1.06) {
+        return REGIMES.GeoDrifter;
+    }
+
+    if (period >= 600 && period <= 800 && eccentricity < 0.25) {
+        return REGIMES.Meo;
+    }
+
+    if (meanmotion > 11.25 && eccentricity < 0.25) {
+        return REGIMES.Leo;
+    }
+
+    return eccentricity > 0.25 ? REGIMES.Heo : REGIMES.Undetermined;
+};
+
+/**
+ * Given altitude, calculates & returns type of orbit to include LEO, MEO, HEO, GEO Drifter, GEO Inclined,GEO Stationary, and undetermined if applicable
+ * @param {Number} alt Altitude in km
+ * @param {Number} buffer altitude buffer in km, default 0 km
+ * @return {Array} Array of the regime indices
+ */
+const altToRegime = (alt, buffer = 0) => {
+    const regimes = [];
+    if (alt >= 35786 - buffer) {
+        regimes.push([
+            REGIMES.GeoStationary,
+            REGIMES.GeoInclined,
+            REGIMES.GeoDrifter,
+        ]);
+    }
+    if (alt < 35786 + buffer && alt >= 2000 - buffer) {
+        regimes.push([REGIMES.Meo]);
+    }
+    if (alt < 2000 + buffer && alt >= 100 - buffer) {
+        regimes.push([REGIMES.Leo, REGIMES.Sso, REGIMES.Polar]);
+    }
+    if (alt < 100) {
+        return [REGIMES.Undetermined];
+    }
+    return regimes.flat();
+};
+
+/**
+ * Converts cartesian coordinates to polar coordinates
+ *
+ * @param {Object} r 3D point
+ * @param {Object} v 3D vector
+ *
+ * @return {Object} Corresponding 2D vector (polar coordinates)
+ */
+const cartesianToRIC = (r, v) => {
+    const rArray = [r.x, r.y, r.z];
+    const vArray = [v.x, v.y, v.z];
+    const rCrossV = cross(rArray, vArray);
+    let R = normalize(r);
+    R = [R.x, R.y, R.z];
+    let W = normalize({x: rCrossV[0], y: rCrossV[1], z: rCrossV[2]});
+    W = [W.x, W.y, W.z];
+    const S = cross(W, R);
+    const convMatrix = transpose([R, S, W]);
+    return inv(convMatrix);
+};
+
+/**
+ * @param {Object} coord1 1st (3D) coordinate
+ * @param {Object} coord2 2nd (3D) coordinate
+ *
+ * @return {boolean} Whether coordinates are equal
+ */
+const areCoordsEqual = (coord1, coord2) => {
+    return coord1.x === coord2.x && coord1.y === coord2.y && coord1.z === coord2.z;
+};
+
+/**
+ * Calculate angle between three points in 3D space.
+ * Note: assumes we want one vector to run from coord1 -> coord2, and the other
+ * from coord3 -> coord2.
+ *
+ * @param {Object} coord1 1st (3D) coordinate
+ * @param {Object} coord2 2nd (3D) coordinate
+ * @param {Object} coord3 3rd (3D) coordinate
+ *
+ * @return {number} Angle between the 3 points
+ */
+const angleBetween3DCoords = (coord1, coord2, coord3) => {
+    // Calculate vector between points 1 and 2
+    const v1 = {
+        x: coord1.x - coord2.x,
+        y: coord1.y - coord2.y,
+        z: coord1.z - coord2.z,
+    };
+
+    // Calculate vector between points 2 and 3
+    const v2 = {
+        x: coord3.x - coord2.x,
+        y: coord3.y - coord2.y,
+        z: coord3.z - coord2.z,
+    };
+
+    // The dot product of vectors v1 & v2 is a function of the cosine of the
+    // angle between them (it's scaled by the product of their magnitudes).
+
+    // Normalize v1
+    const v1mag = Math.sqrt(v1.x * v1.x + v1.y * v1.y + v1.z * v1.z);
+    const v1norm = {
+        x: v1.x / v1mag,
+        y: v1.y / v1mag,
+        z: v1.z / v1mag,
+    };
+
+    // Normalize v2
+    const v2mag = Math.sqrt(v2.x * v2.x + v2.y * v2.y + v2.z * v2.z);
+    const v2norm = {
+        x: v2.x / v2mag,
+        y: v2.y / v2mag,
+        z: v2.z / v2mag,
+    };
+
+    // Calculate the dot products of vectors v1 and v2
+    const dotProducts
+        = v1norm.x * v2norm.x + v1norm.y * v2norm.y + v1norm.z * v2norm.z;
+
+    // Extract the angle from the dot products
+    const angle = (Math.acos(dotProducts) * 180.0) / Math.PI;
+
+    // Round result to 3 decimal points and return
+    return Math.round(angle * 1000) / 1000;
+};
+
+/** Calculates the Minimum Delta-V required for sat1 to plane match to sat2,
+ * with a single impulsive maneuver at one of the two mutual modal points of
+ * sat1.
+ *
+ * This maneuver, when performed at one of these points, and when its components
+ * are properly computed, will only modify the inclination and RAAN of sat1 to
+ * match those of sat2 while the position vector and velocity magnitude
+ * (but not direction) after the impulsive burn will be the same as
+ * pre-maneuver!
+ *
+ * The intersection of two arbitrary Keplerian orbits is a single line
+ * defined by the cross product of the orbits' angular momenta.
+ *
+ * The Ascending Mutual node of sat1 is the true anomaly of sat1 at which the
+ * mutual nodal vector is positive. The Descending Mutual node of sat1 is the
+ * true anomaly of the ascending mutual node plus 180 degrees, modulo 360 (to
+ * stay within 0 to 360 bounds).
+ *
+ * This function evaluates the Dv required at the Ascending Mutual Node and
+ * Descending Mutual Node, and chooses the one with the smallest Dv.
+ *
+ * The direction and components of this minimum Dv depend on two factors:
+ * (a) The relative inclination of sat1 and sat2 with respect to the equatorial
+ *  plane.
+ * (b) Whether the burn is performed at the ascending or descending mutual node.
+ *
+ * The Dv magnitude and direction also depends on the flight path angle at each
+ * of those mutual node points, which is generally not the same.
+ *
+ * Therefore, the process steps are:
+ * 1. Compute the angular momentum of each orbit from the pos vel vectors.
+ * 2. Compute the mutual line of nodes vector from the orbits' angular momenta.
+ * 3. Compute the eccentricity vector of sat1 (i.e. the line of apsides with a
+ * direction from apo to periapsis), in the inertial frame
+ * 4. Compute the true anomalies of ascending and descending mutual node points
+ * for sat1, based on the mutual nodal vector and eccentricity vector.
+ * 5. Compute the flight path angle at each of these points, using the Keplerian
+ * representation of sat1 (requires conversion of pos, vel to Kepler elements)
+ * 6. Compute the magnitude of Dv required at each point.
+ * 7. By evaluating the relative inclination of start and final orbit, as well
+ * as the nodal point on which to burn, compute the exact components.
+ *
+ * Note: The burn components are expressed in the Radial,Along-Track,Cross-Track
+ * frame, known as RSW by Vallado notation. This is distinct from the NTW frame,
+ * which uses the In-track,Cross-Track axes to instantiate it.
+ * @param {Object} pv1
+ * @param {Object} pv2
+ * @return {Object} Delta-v in m/s in RSW frame to perform a single impulsive
+ * plane match maneuver of sat1 to sat2.
+*/
+const planeChangeDeltaV = (pv1, pv2) => {
+    const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+
+    // 1. Compute the angular momentum of each orbit from the pos vel vectors
+    const r = multiply([pv1.position.x, pv1.position.y, pv1.position.z],
+        1000.0);
+    const v = multiply([pv1.velocity.x, pv1.velocity.y, pv1.velocity.z],
+        1000.0);
+    const h1 = cross(r, v);
+
+    const vMag = norm(v);
+
+    const r2 = multiply([pv2.position.x, pv2.position.y, pv2.position.z],
+        1000.0);
+    const v2 = multiply([pv2.velocity.x, pv2.velocity.y, pv2.velocity.z],
+        1000.0);
+    const h2 = cross(r2, v2);
+
+    // 2. Compute the mutual line of nodes vector
+    const n = cross(h1, h2);
+
+    // 3. Compute the eccentricity vector of sat1
+    const e = multiply(
+        (1 / mu),
+        subtract(
+            (multiply(Math.pow(norm(v, 2), 2) - (mu / norm(r, 2)), r)),
+            multiply(dot(r, v), v)),
+    );
+
+    // 4. Compute the true anomalies of ascending and descending mutual node
+    const vAsc = Math.acos((dot(n, e))/(norm(n)* norm(e)));
+    const vDesc = (vAsc + Math.PI) % (2* Math.PI);
+
+    // 5. Compute the flight path angle at each of these points
+    const el = cartesianToKeplerian(r, v);
+    const gammaAsc = Math.atan(el.e* Math.sin(vAsc)/(1+ el.e* Math.cos(vAsc)));
+    const gammaDesc = Math.atan(el.e* Math.sin(vDesc)/(1+ el.e* Math.cos(vDesc)));
+
+    // 6. Compute the magnitude of Dv required at each point.
+    // The absolute inclination difference
+    const dihedralAngle = Math.abs(angleBetweenPlanes(pv1, pv2)*DEG2RAD);
+
+    const dvAsc = 2* vMag * Math.cos(gammaAsc) * Math.sin(dihedralAngle/2);
+    const dvDesc = 2* vMag * Math.cos(gammaDesc) * Math.sin(dihedralAngle/2);
+
+    const el2 = cartesianToKeplerian(r2, v2);
+
+    // 7. Choose minimum dv, and compute the exact components.
+
+    // The Along-track component. We need to perform this slight retrograde burn
+    // in order to cancel out the eccentricity a pure cross-track burn
+    // would introduce.
+    let dvI = 0;
+    // The Cross-track component
+    let dvC = 0;
+
+    // If sat 1 is higer inc than sat2
+    if (el.i >= el2.i) {
+        // In-track component is always retrograde to correct for sma and e increase
+        dvI = (-1) * vMag * Math.cos(gammaAsc) * (1 - Math.cos(dihedralAngle));
+        if (Math.abs(dvAsc) <= Math.abs(dvDesc)) {
+            // Burn at ASC node is opposite of the sat1 cross-track axis!
+            dvC = (-1) * vMag * Math.cos(gammaAsc) * Math.sin(dihedralAngle);
+        } else {
+            // Burn at DESC node is aligned with sat1 cross-track
+            dvC = (+1) * vMag * Math.cos(gammaAsc) * Math.sin(dihedralAngle);
+        }
+    } else {
+        // In-track component is always retrograde to correct for sma and e increase
+        dvI = (-1) * vMag * Math.cos(gammaDesc) * (1 - Math.cos(dihedralAngle));
+        if (Math.abs(dvAsc) <= Math.abs(dvDesc)) {
+            // Burn at ASC node is aligned with sat1 cross-track
+            dvC = (+1) * vMag * Math.cos(gammaDesc) * Math.sin(dihedralAngle);
+        } else {
+            // Burn at DESC node is opposite of the sat1 cross-track axis
+            dvC = (-1) * vMag * Math.cos(gammaDesc) * Math.sin(dihedralAngle);
+        }
+    }
+
+    // 5. Return the RSW components of the required burn!
+    // Note that there's no radial component for this type of burn.
+    return {
+        r: 0,
+        i: dvI,
+        c: dvC,
+        mag: (dvAsc <= dvDesc) ? dvAsc: dvDesc,
+        node: (dvAsc <= dvDesc) ? "asc": "desc",
+    };
+};
+
+/** Calculates the Minimum delta-v required for sat1 to match the inclination of sat2.
+ * This will generally not match the plane of sat1 with that of sat2, but only their inclination.
+ *
+ * For a maneuver that perform a plane match between sat1 and sat2, see the
+ * function planeChangeDeltaV, which accounts for the RAAN AND inclination change,
+ * to exactly align the orbital plane with the least Dv.
+ *
+ * Reference: https://ai-solutions.com/_freeflyeruniversityguide/plane_change_maneuver.htm
+ *
+ * The delta-v calculation is performed under the assumption that it will generate a
+ * new orbit for sat1 whose Orbital elements are all the same except for inclination,
+ * which will match that of sat2!
+ *
+ * This assumption is possible only by additionally assuming that such am impulsive
+ * maneuver will be performed at a sat1 nodal crossing. This algorithm specifies the node at which
+ * the plane change maneuver will require the least amount of fuel.
+ *
+ * The algorithm is applicable for all closed, planar, elliptical orbits.
+ * Note the contribution of the flight path angle in the calculations,
+ * which guarantees this algorithm's applicability for eccentic orbits.
+ * The flight path angle is separately computed for the ascending and descending node.
+ *
+ * For more information, consult Vallado's Algorithm 39 and Example 6-4 in Edition 4.
+ *
+ * @param {Object} pv1 Position and Velocity Vector of Satelltie 1 at Time = x
+ * @param {Object} pv2 Position and velocity Vector of Satellite 2 at Time = x
+ * @return {Object} Delta-v in m/s to perform a pure inclination plane change at
+ * the sat1 asc or desc node.
+ */
+const planeChangePureInclinationDeltaV = (pv1, pv2)=>{
+    // 1. Get position and velocity vectors and magnitudes.
+    // Note that the magnitude of the final velocity for sat1 will be EQUAL
+    // to this initial velocity magnitude of sat1!
+    const r = multiply([pv1.position.x, pv1.position.y, pv1.position.z], 1000.0);
+    const v = multiply([pv1.velocity.x, pv1.velocity.y, pv1.velocity.z], 1000.0);
+
+    // Velocity Magnitude in m/s
+    const vMag = norm(v);
+
+    const r2 = multiply([pv2.position.x, pv2.position.y, pv2.position.z], 1000.0);
+    const v2 = multiply([pv2.velocity.x, pv2.velocity.y, pv2.velocity.z], 1000.0);
+
+    // 2. Compute the Keplerian Elements of both satellites.
+    const el = cartesianToKeplerian(r, v);
+    const el2 = cartesianToKeplerian(r2, v2);
+
+    // 3. Compute the desired inclination change, based on sat1 starting orbit and sat2 orbit
+    // CAREFUL: Do not use the function angleBetweenPlanes. It would not be correct
+    // in this context, because the result of that function integrates the changes
+    // in inclination AND raan, since it simply computes the
+    // angular momentum vector angle!!!
+    const incRad = Math.abs(el.i - el2.i)*DEG2RAD;
+
+    // 4a. Compute the flight path angle and DV at ascending node.
+    // The flight path angle in this context is the angle between the inertial
+    // velocity vector and local horizontal plane.
+
+    // The true anomaly of a satellite at the ascending node is equal to the negative of the
+    // argument of periapsis. We use this trick to compute the flight path angle at that location.
+    const fAtAsc = (-1) * Math.abs(el.w);
+    const gammaAscending = Math.atan(
+        el.e* Math.sin(fAtAsc*DEG2RAD)/(1+ el.e* Math.cos(fAtAsc*DEG2RAD)));
+    const dvAsc = 2* vMag * Math.cos(gammaAscending) * Math.sin(incRad/2);
+
+    // 4b. Compute the flight path angle and DV at descending node
+    const fAtDesc = fAtAsc + 180.0;
+    const gammaDescending = Math.atan(
+        el.e* Math.sin(fAtDesc*DEG2RAD)/(1+ el.e* Math.cos(fAtDesc*DEG2RAD)));
+    const dvDesc = 2* vMag * Math.cos(gammaDescending) * Math.sin(incRad/2);
+
+    // The Along-track component. We need to perform this slight retrograde burn
+    // in order to cancel out the eccentricity a pure cross-track burn
+    // would introduce.
+    let dvI = 0;
+    // The Cross-track component
+    let dvC = 0;
+
+    // 5. Compute the cross-track and along-track burn components in the satellite's
+    // RSW frame (Radial, Along-Track, Cross-track)
+    // Note, in general, Along-Track is NOT the same as In-Track!
+
+    // The direction of the along and cross-track components will depend on the relative inclination of sat1 to sat2,
+    // In addition, we try to find the node with the smaller burn, in each of those cases of relative incliantion.
+
+    // If sat 1 is higer inc than sat2
+    // In-track component is always retrograde to correct for sma and e increase
+    if (el.i >= el2.i) {
+        if (Math.abs(dvAsc) <= Math.abs(dvDesc)) {
+            // Burn at ASC node is opposite of the sat1 cross-track axis!
+            dvC = (-1) * vMag * Math.cos(gammaAscending) * Math.sin(incRad);
+            dvI = (-1) * vMag * Math.cos(gammaAscending) * (1 - Math.cos(incRad));
+        } else {
+            // Burn at DESC node is aligned with sat1 cross-track
+            dvC = (+1) * vMag * Math.cos(gammaDescending) * Math.sin(incRad);
+            dvI = (-1) * vMag * Math.cos(gammaDescending) * (1 - Math.cos(incRad));
+        }
+    } else {
+        if (Math.abs(dvAsc) <= Math.abs(dvDesc)) {
+            // Burn at ASC node is aligned with sat1 cross-track
+            dvC = (+1) * vMag * Math.cos(gammaAscending) * Math.sin(incRad);
+            dvI = (-1) * vMag * Math.cos(gammaAscending) * (1 - Math.cos(incRad));
+        } else {
+            // Burn at DESC node is opposite of the sat1 cross-track axis
+            dvC = (-1) * vMag * Math.cos(gammaDescending) * Math.sin(incRad);
+            dvI = (-1) * vMag * Math.cos(gammaDescending) * (1 - Math.cos(incRad));
+        }
+    }
+
+    // 5. Return the RSW components of the required burn!
+    // Note that there's no radial component for this type of burn.
+    return {
+        r: 0,
+        i: dvI,
+        c: dvC,
+        mag: (dvAsc <= dvDesc) ? dvAsc: dvDesc,
+        node: (dvAsc <= dvDesc) ? "asc": "desc",
+    };
+};
+
+/**
+ * Takes two StateVectors from two satellits at the same time, and calculates the angle between their orbit planes.
+ * This angle DOES NOT directly translate to an inclination delta, but a combined effect of inclination AND raan difference between
+ * the two states, since an orbit's plane orientation is defined by both of those parameters!
+ * To do this, we need to find vector normal to each plane and find the cross product (angle) between them instead.
+ * Step 1: Calculate RxV for each satellite.
+ * Step 2: Normalize the RxV vectors to a unit vector
+ * Step 3: Theta = Perform the dot product between the two RxV normalized vectors
+ * Step 4: ArcCos(Theta) = angle between the planes
+ * @param {Object} pv1 Position and Velocity Vector of Satelltie 1 at Time = x
+ * @param {Object} pv2 Position and velocity Vector of Satellite 2 at Time = x
+ * @return {Number} Angle between the two planes in radians
+ */
+const angleBetweenPlanes = (pv1, pv2) => {
+    // Calculate Cross Products and Normalize
+    const cross1 = cross(
+        [pv1.position.x, pv1.position.y, pv1.position.z],
+        [pv1.velocity.x, pv1.velocity.y, pv1.velocity.z],
+    );
+    const cross1mag = Math.sqrt(
+        cross1[0] * cross1[0]
+        + cross1[1] * cross1[1]
+        + cross1[2] * cross1[2]);
+
+    const cross1Norm = {
+        x: cross1[0] / cross1mag,
+        y: cross1[1] / cross1mag,
+        z: cross1[2] / cross1mag,
+    };
+
+    const cross2 = cross(
+        [pv2.position.x, pv2.position.y, pv2.position.z],
+        [pv2.velocity.x, pv2.velocity.y, pv2.velocity.z],
+    );
+    const cross2Mag = Math.sqrt(
+        cross2[0] * cross2[0]
+        + cross2[1] * cross2[1]
+        + cross2[2] * cross2[2]);
+
+    const cross2Norm = {
+        x: cross2[0] / cross2Mag,
+        y: cross2[1] / cross2Mag,
+        z: cross2[2] / cross2Mag,
+    };
+
+    // Calculate the dot products
+    const dotProducts = cross1Norm.x * cross2Norm.x
+        + cross1Norm.y * cross2Norm.y
+        + cross1Norm.z * cross2Norm.z;
+
+    // If the values are outside -1 to 1, it will clamp it to -1 or 1.
+    const clamped = Math.max(-1, Math.min(1, dotProducts));
+
+    // Extract the angle from the dot products in degrees
+    const angle = Math.acos(clamped) * (180.0 / Math.PI);
+
+    // Round result to 3 decimal points and return
+    return Math.round(angle * 1000) / 1000;
+};
+
+/**
+ * Calculates the position and velocity of a satellite at a point in time using SGP4
+ *
+ * @param {Object} satRec twoline2satrec
+ * @param {Integer} time UNIX time stamp to evaluate at
+ * @return {Object} Tracking position and velocity of satellite at given point of time, or null on error
+ */
+const propTo = (satRec, time) => {
+    const pv = propagate(satRec, new Date(time));
+    if ( !isDefined(pv)) 
+        return null;
+    return {
+        p: pv.position,
+        v: pv.velocity,
+        t: time,
+        meanElements: {
+            semimajor: pv.meanElements.am,
+            eccentricity: pv.meanElements.em,
+            inclination: pv.meanElements.im,
+            raan: pv.meanElements.Om,
+            argp: pv.meanElements.om,
+            meanmotion: pv.meanElements.nm,
+            meananomaly: pv.meanElements.mm,
+        }
+    };
+};
+
+/**
+ * Calculates the position and velocity of a satellite over a period of time (start, end) using SGP4
+ *
+ * @param {Object} elset {Line1, Line2}
+ * @param {Integer} start UNIX time stamp
+ * @param {Integer} end UNIX time stamp
+ * @param {Integer} stepMs The step size in ms
+ * @return {Array} Array of objects tracking positions and velocities of a satellite at given points of time (stepMs apart)
+ */
+const prop = (elset, start, end, stepMs = 1000) => {
+    const ephem = [];
+    const sat = twoline2satrec(elset.Line1, elset.Line2);
+    for (let i = start; i < end; i = i + stepMs) {
+        const pv = propTo(sat, i);
+        if (!isDefined(pv)) {
+            return [];
+        }
+        ephem.push(pv);
+    }
+    return ephem; // Ephemeris
+};
+
+/**
+ * Calculates the geodetic position of a satellite over a period of time (start, end) using SGP4
+ * @param {Object} elset {Line1, Line2}
+ * @param {Integer} start UNIX time stamp
+ * @param {Integer} end UNIX time stamp, inclusive
+ * @param {Integer} stepMs The step size in ms
+ * @return {Array} Array of objects tracking geodetic positions of a satellite at given points of time (stepMs apart)
+ */
+const propGeodetic = (elset, start, end, stepMs = 60000) => {
+    const positions = [];
+    const sat = twoline2satrec(elset.Line1, elset.Line2);
+    for (let t = start; t <= end; t = t + stepMs) {
+        const pv = propagate(sat, new Date(t));
+        if (!isDefined(pv.position)) return [];
+        const gmst = gstime(new Date(t));
+        const positionGd = eciToGeodetic(pv.position, gmst);
+        positions.push({lat: positionGd.latitude*RAD2DEG, lon: positionGd.longitude*RAD2DEG, t: t});
+    }
+    return positions;
+};
+
+const doesLineSegmentSphereIntersect = (linePoint0, linePoint1, circleCenter, circleRadius) => {
+    // From Space Cockpit
+    // http://www.codeproject.com/Articles/19799/Simple-Ray-Tracing-in-C-Part-II-Triangles-Intersec
+
+    // Input validation
+    if (circleRadius < 0) {
+        return false;
+    }
+
+    const cx = circleCenter.x;
+    const cy = circleCenter.y;
+    const cz = circleCenter.z;
+
+    const px = linePoint0.x;
+    const py = linePoint0.y;
+    const pz = linePoint0.z;
+
+    const vx = linePoint1.x - px;
+    const vy = linePoint1.y - py;
+    const vz = linePoint1.z - pz;
+
+    const a = vx * vx + vy * vy + vz * vz;
+
+    // Check for zero-length line segment
+    if (Math.abs(a) < Number.EPSILON) {
+        // If point is on sphere surface, count as intersection
+        const distanceSquared
+            = (px - cx) * (px - cx) + (py - cy) * (py - cy) + (pz - cz) * (pz - cz);
+        return Math.abs(distanceSquared - circleRadius * circleRadius) < Number.EPSILON;
+    }
+
+    const b = 2.0 * (px * vx + py * vy + pz * vz - vx * cx - vy * cy - vz * cz);
+    const c = px * px - 2 * px * cx + cx * cx + py * py - 2 * py * cy + cy * cy
+        + pz * pz - 2 * pz * cz + cz * cz - circleRadius * circleRadius;
+
+    // discriminant
+    const d = b * b - 4 * a * c;
+
+    if (d < 0) {
+        return false;
+    }
+
+    const sqrtD = Math.sqrt(d);
+    const t1 = (-b - sqrtD) / (2.0 * a);
+    const t2 = (-b + sqrtD) / (2.0 * a);
+
+    // Check if either intersection point lies within the line segment bounds [0,1]
+    return (t1 >= 0 && t1 <= 1) || (t2 >= 0 && t2 <= 1);
+};
+
+const doesLineSegmentIntersectEarth = (start, end) => {
+    return doesLineSegmentSphereIntersect(start, end,
+        {x: 0, y: 0, z: 0}, WGS72_EARTH_EQUATORIAL_RADIUS_KM);
+};
+
+/**
+ * Given primary and target ephems, calculate the time-based, radial, intrack, and crosstrack data
+ *
+ * @param {Array} pEphem primary ephems [{p{x,y,z}, v, t}]
+ * @param {Array} tEphem target ephems [{p{x,y,z}, v, t}]
+ * @return {Object} Time, Radial, intrack, crosstrack, absolute distances, sun angles
+ */
+const getTRIC = (pEphem, tEphem) => {
+    // Relative positions in RIC format.
+    const t = []; // Time
+    const r = []; // Radial (X)
+    const i = []; // Intrack (y)
+    const c = []; // CrossTrack (z)
+    const d = []; // Relative Absolute distance
+    const s = []; // Sun Angles
+    const targetVisibility = []; // Target visibility from primary
+    const primaryVisibility = []; // Primary visibility from target
+    const isPrimaryEpoch = []; // Whether point is primary epoch
+    const isTargetEpoch = []; // Whether point is target epoch
+    const sources = []; // Sources
+
+    for (let j = 0; j < pEphem.length; j++) {
+        const prim = pEphem[j];
+        const target = tEphem[j];
+
+        t.push(prim.t);
+        isPrimaryEpoch.push((!!prim.isEpoch)+""); // it can't be a boolean for some reason
+        isTargetEpoch.push((!!target.isEpoch)+"");
+        sources.push(prim.source + ", " + target.source);
+
+        // Calculate RIC values.
+        const deltaR = {
+            x: prim.p.x - target.p.x,
+            y: prim.p.y - target.p.y,
+            z: prim.p.z - target.p.z,
+        };
+        const cartToRICMatrix = cartesianToRIC(prim.p, prim.v);
+        const ricP = multiplyVector(deltaR, cartToRICMatrix);
+        r.push(Math.round(ricP.x * 10000) / 10000);
+        i.push(Math.round(ricP.y * 10000) / 10000);
+        c.push(Math.round(ricP.z * 10000) / 10000);
+
+        const time = new Date(prim.t);
+        s.push(
+            angleBetween3DCoords(
+                prim.p,
+                target.p,
+                getSunDirection(time),
+            ),
+        );
+
+        const earthEclipsed = doesLineSegmentIntersectEarth(prim.p, target.p);
+        const primaryShadow = getEclipseStatus(time, posToArray(prim.p));
+        const targetShadow = getEclipseStatus(time, posToArray(target.p));
+        targetVisibility.push(earthEclipsed ? "EARTH ECLIPSED" : targetShadow);
+        primaryVisibility.push(earthEclipsed ? "EARTH ECLIPSED" : primaryShadow);
+
+        d.push(Math.round(dist(prim.p, target.p) * 1000) / 1000);
+    }
+    return {
+        t,
+        r,
+        i,
+        c,
+        d,
+        s,
+        isPrimaryEpoch,
+        isTargetEpoch,
+        sources,
+        targetVisibility,
+        primaryVisibility,
+    };
+};
+
+/**
+ * Calculates the sun's direction/distance based on a given time to return position relative to center of earth
+ *
+ * @param {Object} time new Date() object generated using the time of interest
+ *
+ * @return {Object} 3 point coordinate in 3D space
+ */
+const getSunDirection = (time) => {
+    const year = time.getUTCFullYear();
+    const month = time.getUTCMonth() + 1; // index 0
+    const day = time.getUTCDate();
+    const hour = time.getUTCHours();
+    const minute = time.getUTCMinutes();
+    const seconds = time.getUTCSeconds();
+    const JD
+        = 367 * year
+        - Math.floor((7.0 * (year + Math.floor((month + 9.0) / 12.0))) / 4.0)
+        + Math.floor((275.0 * month) / 9.0)
+        + day
+        + 1721013.5
+        + hour / 24.0
+        + minute / 1440.0
+        + seconds / 86400.0;
+    const UT1 = (JD - 2451545) / 36525;
+    const longMSUN = 280.4606184 + 36000.77005361 * UT1;
+    const mSUN = 357.5277233 + 35999.05034 * UT1;
+    const ecliptic
+        = longMSUN
+        + 1.914666471 * Math.sin(mSUN * DEG2RAD)
+        + 0.918994643 * Math.sin(2 * mSUN * DEG2RAD);
+    const eccen = 23.439291 - 0.0130042 * UT1;
+
+    // Direction
+    let x = Math.cos(ecliptic * DEG2RAD);
+    let y = Math.cos(eccen * DEG2RAD) * Math.sin(ecliptic * DEG2RAD);
+    let z = Math.sin(eccen * DEG2RAD) * Math.sin(ecliptic * DEG2RAD);
+
+    // Distance
+    const sunDistance = 0.989 * 1.496e8;
+    x = x * sunDistance;
+    y = y * sunDistance;
+    z = z * sunDistance;
+    return {x, y, z};
+};
+
+/**
+ * Converts a Right Ascension & Declination in Sensor Centered Coordinates
+ * into the Latitude and Longitude of a satellite.
+ * Slight error as we are not accounting for polar motion of the Earth, it's about 0.01 deg lat and long and 100km range error.
+ * @param {String} ObTimeUtc, date-time string of the observation
+ * @param {Number} Ra, Right Ascension of the observation
+ * @param {Number} Dec, Declination of the observation
+ * @param {Number} senLat, Sensor's Latitude
+ * @param {Number} senLon, Sensor's Longitude
+ * @param {Number} senAltKm, Sensor's Altitude in Km (defaults to sea-level)
+ * @param {Number} rangeKm, The Range of the observation in Km from the observer
+ * @return {Object} {latitude, longitude, altitude}
+ */
+const RaDecToGeodetic = (
+    ObTimeUtc,
+    Ra,
+    Dec,
+    senLat,
+    senLon,
+    senAltKm,
+    rangeKm,
+) => {
+    // check for nulls
+    if (
+        !isDefined(ObTimeUtc)
+        || !isDefined(Ra)
+        || !isDefined(Dec)
+        || !isDefined(senLat)
+        || !isDefined(senLon)
+        || !isDefined(senAltKm)
+        || !isDefined(rangeKm)
+    ) {
+        return {Altitude: null, Latitude: null, Longitude: null};
+    }
+
+    const time = squid.EpochUTC.fromDateString(
+        dtStrtoJsDt(ObTimeUtc).toISOString(),
+    );
+    const sensorGeo = new squid.Geodetic(
+        senLat * DEG2RAD,
+        senLon * DEG2RAD,
+        senAltKm,
+    );
+    const sensorItrf = sensorGeo.toITRF(time);
+    const sensorGcrf = sensorItrf.toJ2000();
+    const sat = new squid.J2000(
+        time,
+        new squid.Vector3D(
+            rangeKm * Math.cos(Ra * DEG2RAD) * Math.cos(Dec * DEG2RAD),
+            rangeKm * Math.sin(Ra * DEG2RAD) * Math.cos(Dec * DEG2RAD),
+            rangeKm * Math.sin(Dec * DEG2RAD),
+        ),
+    );
+    const satGcrf = new squid.J2000(
+        time,
+        sensorGcrf.position.add(sat.position),
+    );
+    const satItrf = satGcrf.toITRF();
+    const satLatLng = satItrf.toGeodetic();
+    return {
+        Altitude: satLatLng.altitude,
+        Latitude: satLatLng.latitude * RAD2DEG,
+        Longitude: satLatLng.longitude * RAD2DEG,
+    };
+};
+
+/**
+ * This function estimates the slant range from a sensor to an observed satellite in GEO.
+ *
+ * It uses the sine law to first solve for the sat-sensor-earth angle, and then uses
+ * the cosine law to solve for the sat-earth-sensor angle.
+ *
+ * Finally, it uses the sine law again to get the range from sensor to satellite (i.e. the slant range)
+ *
+ * @param {String} obTime The ISO string of the observation time
+ * @param {Number} ra Topocentric Right Ascension of the observation, in degrees
+ * @param {Number} dec Topocentric Declination of the observation, in degrees
+ * @param {Number} senLat Sensor Latitude, in degrees
+ * @param {Number} senLon Sensor Lontitude, in degrees
+ * @param {Number} senAltKm Sensor altitude, in degrees
+ * @return {Number} range The range from the sensor to the satellite
+ */
+const estimateSlantRange = (obTime, ra, dec, senLat, senLon, senAltKm) => {
+    // A very rough initial guess, akso initialization
+    let range = 35786;
+
+    // Convert ra/dec to rectangular coordinates.
+    // It is assumed that ra/dec is topocentric, non-null, and well defined.
+
+    const phi = Math.PI/2 - dec * DEG2RAD;
+    const theta = ra* DEG2RAD;
+    const x = Math.sin(phi)* Math.cos(theta);
+    const y = Math.sin(phi)* Math.sin(theta);
+    const z = Math.cos(phi);
+
+    // A unit vector representing the line-of-site from sensor to sat
+    const slantU = [-x, -y, -z];
+
+    // Sensor coordinates
+    const sensorGeo = new squid.Geodetic(
+        senLat * DEG2RAD,
+        senLon * DEG2RAD,
+        senAltKm,
+    );
+    const time = squid.EpochUTC.fromDateString(obTime);
+    const sensorItrf = sensorGeo.toITRF(time);
+    const sensorGcrf = sensorItrf.toJ2000();
+
+    // Compute the distance of the sensor from the Earth's center
+    const a = norm([sensorGcrf.position.x, sensorGcrf.position.y, sensorGcrf.position.z], 2);
+
+    // Normalize the sensor position to a unit vector
+    const cVec = normalize(
+        {x: sensorGcrf.position.x, y: sensorGcrf.position.y, z: sensorGcrf.position.z});
+    // Get the angle between the slant vector and the sensor vector
+    const beta = getAngle(slantU, [cVec.x, cVec.y, cVec.z]);
+
+    // Distance of a GEO satellite wrt to the Earth's center.
+    const b = 42164;
+    // Law of Sines ratio
+    const delta = b / Math.sin(beta);
+    // Using Law of cosines, isolate and solve the sensor, earth, satellite angle. Always two solutions exist.
+    const roots = polynomialRoot(
+        (Math.pow(a, 2) + Math.pow(b, 2) - Math.pow(delta, 2)), (-2*a*b), Math.pow(delta, 2));
+
+    // The two solutions, only one is valid. Validity check is based on the fact that the sum of triangle angles is 180.
+    const gamma1 = Math.acos(roots[0]);
+    const gamma2 = Math.acos(roots[1]);
+
+    // Compute the sensor-satellite-earth angle
+    const alpha = Math.sin(delta/a);
+    // alpha + beta + gamma NEEDS to be 180
+    // Choose the gamma that best achieves this
+    const targetGamma = Math.PI-alpha-beta;
+    if (Math.abs(targetGamma-gamma1) < Math.abs(targetGamma-gamma2)) {
+        range = delta* Math.sin(gamma1);
+    } else {
+        range = delta* Math.sin(gamma2);
+    }
+    return range;
+};
+
+/**
+ * Converts the Azimuth (az) and Elevation (el) of an object to its Right Ascension
+ * (Ra) and Declination (Declination)
+ * @param {*} ObTimeUtc The datetimestamp in UTC format as a string
+ * @param {*} az Azimuth in degrees
+ * @param {*} el Elevation in degrees
+ * @param {*} lat Latitude of observer in degrees
+ * @param {*} lon Longitude of observer in degrees
+ * @return {Object} {ra, dec} Right Ascension and Declination in degrees.
+ */
+const AzElToRaDec = (ObTimeUtc, az, el, lat, lon) => {
+    // check for nulls
+    if (!isDefined(ObTimeUtc)
+        || !isDefined(az)
+        || !isDefined(el)
+        || !isDefined(lat)
+        || !isDefined(lon)) {
+        return {ra: null, dec: null};
+    }
+
+    const time = squid.EpochUTC.fromDateString(ObTimeUtc);
+
+    // Convert all angles to radians
+    az = az * DEG2RAD;
+    el = el * DEG2RAD;
+    lat = lat * DEG2RAD;
+    lon = lon * DEG2RAD;
+
+    const dec = Math.asin(
+        Math.sin(el) * Math.sin(lat)
+            + Math.cos(el) * Math.cos(lat) * Math.cos(az),
+    );
+
+    const gmst = time.gmstAngle();
+    const lmst = lon + gmst;
+
+    const H = Math.atan2(
+        -Math.sin(az) * Math.cos(el) * Math.cos(lat),
+        Math.sin(el) - Math.sin(lat) * Math.sin(dec),
+    );
+
+    const ra = (lmst - H) % (Math.PI * 2);
+
+    // Return the right ascension and declination as an object
+    return {ra: ra * RAD2DEG, dec: dec * RAD2DEG};
+};
+
+/**
+ * Convert the Right Ascension (RA) and Declination (Dec) of an object in space to its
+ * Azimuth (Az) and Elevation (El) given the object's RaDec, the latitude and longitude of the observer's location,
+ * and the current local sidereal time (LST). The function will return an object with properties az and el representing the
+ * Azimuth and Elevation of the object in degrees.}
+ * @param {*} ObTime The time of the observation in Utc as a string in YYYY-MM-DDThh:mm:ss.ssssssZ
+ * @param {*} Ra Right Ascension in degrees
+ * @param {*} Dec Declination in degrees
+ * @param {*} SenLat Latitude of observer in degrees
+ * @param {*} SenLon Longitude of observer in degrees
+ * @return {Object} {Az, El}
+ */
+const RaDecToAzEl = (ObTime, Ra, Dec, SenLat, SenLon) => {
+    if (!isDefined(ObTime)
+        || !isDefined(Ra)
+        || !isDefined(Dec)
+        || !isDefined(SenLat)
+        || !isDefined(SenLon)) {
+        return {Az: null, El: null};
+    }
+
+    // senAlt and slantRange are ambiguous
+    const SenAlt = 0;
+    const SlantRangeKm = 1;
+
+    const time = squid.EpochUTC.fromDateString(ObTime);
+    const sensorGeo = new squid.Geodetic(
+        SenLat * DEG2RAD,
+        SenLon * DEG2RAD,
+        SenAlt,
+    );
+    const sensorITRF = sensorGeo.toITRF(time);
+    const sensorGCRF = sensorITRF.toJ2000();
+    const satellite = new squid.J2000(
+        time,
+        new squid.Vector3D(
+            SlantRangeKm * Math.cos(Ra * DEG2RAD) * Math.cos(Dec * DEG2RAD),
+            SlantRangeKm * Math.sin(Ra * DEG2RAD) * Math.cos(Dec * DEG2RAD),
+            SlantRangeKm * Math.sin(Dec * DEG2RAD),
+        ),
+    );
+    const satGCRF = new squid.J2000(
+        time,
+        sensorGCRF.position.add(satellite.position),
+    );
+    const satITRF = satGCRF.toITRF();
+    const result = satITRF.toLookAngle(sensorGeo);
+    return {
+        Az: (result.azimuth * 180) / Math.PI,
+        El: (result.elevation * 180) / Math.PI,
+    };
+};
+
+/**
+ * Algorithm to calculate the residual error in Azimuth and Elevation for an array
+ * of Observations from a given TLE.
+ * @param {Array} obs Array of Observations
+ * @param {Object} tle The satellites TLE
+ * @return {Array} Array of residual data objects
+ */
+const GetResiduals = (obs, tle) => {
+    const sat = twoline2satrec(tle.Line1, tle.Line2);
+    const residuals = [];
+    const epochDate = epochToDate(sat.epochdays, 2000 + sat.epochyr);
+
+    if (sat.error > 0) {
+        console.log(sat.error);
+        return residuals; // Can't propegate TLE
+    }
+
+    for (let i = 0; i < obs.length; i++) {
+        const ob = obs[i];
+        const obTimeUtc = dtStrtoJsDt(ob.ObTime);
+        const dt
+            = (obTimeUtc.getTime() - dtStrtoJsDt(epochDate).getTime())
+            / 1000
+            / 60;
+        const pv = sgp4(sat, dt);
+        const gmst = gstime(obTimeUtc);
+        const observerGd = {
+            latitude: degreesToRadians(ob.SenLat),
+            longitude: degreesToRadians(ob.SenLon),
+            height: ob.SenAlt,
+        };
+
+        const pECEF = eciToEcf(pv.position, gmst);
+        const angles = ecfToLookAngles(observerGd, pECEF);
+        residuals.push({
+            SatNo: ob.SatNo,
+            ElErr: (ob.Elevation!==undefined && ob.Elevation!==null)
+                ? ob.Elevation - radiansToDegrees(angles.elevation): null,
+            AzErr: (ob.Azimuth!==undefined && ob.Azimuth!==null)
+                ? getAngleDiffSigned(radiansToDegrees(angles.azimuth), ob.Azimuth): null,
+            RangeErr: (ob.Range!==undefined && ob.Range!==null) ? ob.Range - angles.rangeSat : null,
+            ObTime: ob.ObTime,
+            Source: ob.Source,
+            SensorId: ob.IdSensor,
+            Type: (ob.Type!==undefined && ob.Type!==null) ? ob.Type : null,
+        });
+    }
+    return residuals;
+};
+
+/** Convert a TLE's two lines to a UDL-compatible Elset_Ingested object, ready to be ingested to UDL.
+ *
+ * @param {String} l1 Line 1 of a TLE
+ * @param {String} l2 Line 2 of a TLE
+ * @param {String} dataMode The data mode corresonding to the TLE. Validation is performed,
+ * but it should be one of the allowed UDL enumerated values (REAL, TEST, EXERCISE, SIMULATED).
+ * @param {Boolean} isUct The flag indicating if the object is catalogued or not.
+ * If not sure, leave it empty, UDL allows this to be null, but it is not good practice!
+ * @param {String} descriptor A string with a helpful description message for the consumers.
+ * @return {Object} The Elset json. It should be strictly validated against Elset_Ingested schema.
+ */
+const GetElsetUdlFromTle = (
+    l1,
+    l2,
+    dataMode,
+    isUct = null,
+    descriptor = null,
+) => {
+    try {
+        // Check the TLE lines, or exit early
+        if (!checkTle(l1, l2)) {
+            throw new Error("Input TLE lines have bad format.");
+        }
+
+        const elset = {};
+
+        // Validate and add uct. If not boolean, check if null, since UDL allows it,
+        // and we may be unsure of entering true or false for any reason.
+        if (isBoolean(isUct)) {
+            elset.uct = isUct;
+        } else if (isUct === null || typeof isUct === "undefined") {
+            // Do nothing, do not populate nor put null.
+        } else {
+            throw new Error("Input uct flag is not of type boolean.");
+        }
+
+        // Validate and add dataMode
+        if (isValidDataMode(dataMode)) {
+            elset.dataMode = dataMode;
+        } else {
+            throw new Error("Input dataMode argument is not an allowed type.");
+        }
+
+        // Add U classification marking. Hardcoded Unclassified for now.
+        // Otherwise, CAPCO marking validation shall be performed.
+        // Classification is a required field in the Elset and almost all UDL schemas.
+        elset.classificationMarking = "U";
+
+        // Add the descriptor string, for any comments etc.
+        if (isNonEmptyString(descriptor)) {
+            elset.descriptor = descriptor;
+        }
+
+        // Initialize a satellite record
+        const satrec = twoline2satrec(l1, l2);
+
+        // Now, Populate the elset properties from the satellite record
+
+        // Epoch to ISO-8601
+        const date = julianToGregorian(satrec.jdsatepoch);
+        elset.epoch = date.toISOString();
+
+        elset.satNo = parseInt(satrec.satnum);
+
+        // Eccentricity
+        elset.eccentricity = satrec.ecco;
+
+        // Mean motion conversion from radians per minute to revs per day does not match
+        // the value of mean motion on line 2 exactly! This is an issue of the satellite.js library
+        // So we directly extract this number from line 2.
+        elset.meanMotion = parseFloat(l2.slice(52, 63));
+
+        // According to UDL, period field is the inverse of mean motion, in minutes!
+        // This is added for convenience of the consumer. It is not needed for a successful POST operation.
+        elset.period = (1 / elset.meanMotion) * 24.0 * 60.0;
+
+        // For convenience, we report the ephemeris Type, which is NOT automatically populated by UDL.
+        // Again, this field is not mandatory and POST will succeed if it is ommitted. It is offered for convenience!
+        // UDL suggests to use "SGP4" if orbital period < 225 minutes, and SDP4 otherwise (see ephemType field description in UDL Elset schema)
+        if (elset.period < 225.0) {
+            elset.ephemType = 0;
+        } else {
+            elset.ephemType = 3;
+        }
+
+        // Inclination, converted from radians to degrees
+        elset.inclination = satrec.inclo * RAD2DEG;
+
+        // Source Always saber
+        elset.source = "saber";
+
+        // Raan, converted from radians to degrees
+        elset.raan = satrec.nodeo * RAD2DEG;
+
+        // Argument of perigee, converted from radians to degrees
+        elset.argOfPerigee = satrec.argpo * RAD2DEG;
+
+        // Mean anomaly, converted from radians to degrees
+        elset.meanAnomaly = satrec.mo * RAD2DEG;
+
+        // B-star in inverse earth radii
+        elset.bStar = satrec.bstar;
+
+        // First derivative of mean motion
+        elset.meanMotionDot = satrec.ndot;
+
+        // Second derivative of mean motion
+        elset.meanMotionDDot = satrec.nddot;
+
+        // Revolution number, parsed directly from line 2
+        elset.revNo = parseInt(l2.slice(63, 68));
+
+        // sma
+        elset.semiMajorAxis = (
+            (elset.period * 60)**2 * GRAV_CONST * EARTH_MASS / (4 * Math.PI**2)
+        )**(1/3) / 1000; // km
+
+        // apogee
+        elset.apogee = elset.semiMajorAxis * (1 + elset.eccentricity); // km
+
+        // perigee
+        elset.perigee = elset.semiMajorAxis * (1 - elset.eccentricity); // km
+
+        // Cleanup in the end
+        removeNullUndefined(elset);
+        return elset;
+    } catch (e) {
+        // Return an empty object, which is guaranteed to be invalid
+        // against UDL Elset_Ingested schema.
+        return {};
+    }
+};
+
+/** Calculates the distance between two Geodetic coordinates.
+ * @param {Number} lat1 The latitude of the first coordinate in degrees
+ * @param {Number} lon1 The longitude of the first coordinate in degrees
+ * @param {Number} lat2 The latitude of the second coordinate in degrees
+ * @param {Number} lon2 The longitude of the second coordinate in degrees
+ * @return {Number} The distance between the two coordinates in meters
+ *
+ * Source: https://www.movable-type.co.uk/scripts/latlong.html
+ */
+const distGeodetic = (lat1, lon1, lat2, lon2) => {
+    const R = WGS84_EARTH_EQUATORIAL_RADIUS_KM * 1000.0; // metres
+    const phi1 = lat1 * DEG2RAD; // φ1 in formula
+    const phi2 = lat2 * DEG2RAD; // φ2 in formula
+    const deltaPhi = (lat2 - lat1) * DEG2RAD; // Δφ in formula
+    const deltaLambda = (lon2 - lon1) * DEG2RAD; // Δλ in formula
+    const a
+        = Math.sin(deltaPhi / 2) * Math.sin(deltaPhi / 2)
+        + Math.cos(phi1)
+            * Math.cos(phi2)
+            * Math.sin(deltaLambda / 2)
+            * Math.sin(deltaLambda / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+    const d = R * c; // in metres
+
+    return d;
+};
+
+/** Convert cartesian coordinates in an ECI (J2000, TEME, GCRF) frame to keplerian elements formatted as [ a, e, i, Ω, ω, θ ].
+ * The gravitational parameter is assumed to be Earth's mu.
+ * The function is a translation of Astro Library's OrbitalElementConverter.CartesianToKeplerian method.
+ *
+ * NOTE 1: raan, argument of periapsis, and true anomaly are ALL adjusted to have a domain from 0 to 360!!!
+ * NOTE 2: raan, argument of periapsis, and true anomaly are ALL in degrees!
+ * NOTE 3: SMA (a) is in km
+ *
+ * @param {Array} r Position, in meters
+ * @param {Array} v Velocity, in m/s
+ * @return {Object} An object containing the Keplerian Elements, if successful. Otherwise, an empty object.
+ */
+const cartesianToKeplerian = (r, v) => {
+    try {
+        const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+        const tol = 1e-9;
+
+        const h = cross(r, v);
+        const K = [0, 0, 1];
+        const n = cross(K, h);
+
+        if (norm(r, 2) === 0) throw new Error("Position vector must not be zero.");
+        if (norm(v, 2) === 0) throw new Error("Velocity vector must not be zero.");
+
+        const e = multiply(
+            (1 / mu),
+            subtract(
+                (multiply(Math.pow(norm(v, 2), 2) - (mu / norm(r, 2)), r)),
+                multiply(dot(r, v), v)),
+        );
+
+        const zeta = 0.5 * Math.pow(norm(v), 2) - (mu / norm(r));
+
+        if (zeta === 0) throw new Error("Zeta cannot be zero.");
+        if (Math.abs(1.0 - norm(e)) <= tol) {
+            throw new Error("Parabolic orbit conversion is not supported.");
+        }
+
+        const a = -mu / zeta / 2;
+
+        if (Math.abs(a * (1 - norm(e))) < 1e-3) {
+            throw new Error(`The state results in a singular conic section with 
+                radius of periapsis less than 1 m.`);
+        }
+
+        const i = Math.acos(h[2] / norm(h));
+
+        if (i >= Math.PI - tol) {
+            throw new Error("Cannot convert orbit with inclination of 180 degrees.");
+        }
+
+        let raan = 0;
+        let w = 0;
+        let f = 0;
+
+        // CASE 1: Non-circular, Inclined Orbit
+        if (norm(e) >= 1E-11 && i >= 1E-11 && i <= Math.PI - 1E-11) {
+            if (norm(n) === 0.0) {
+                throw new Error(`Cannot convert from Cartesian to Keplerian,
+                    line-of-nodes vector is a zero vector.`);
+            }
+
+            raan = Math.acos(n[0] / norm(n));
+            if (n[1] < 0) raan = 2 * Math.PI - raan;
+
+            w = Math.acos(dot(n, e) / (norm(n) * norm(e)));
+            if (e[2] < 0) w = (2 * Math.PI) - w;
+
+            f = Math.acos(dot(e, r) / (norm(e) * norm(r)));
+            if (dot(r, v) < 0) f = 2 * Math.PI - f;
+        }
+        // CASE 2: Non-circular, Equatorial Orbit
+        if (norm(e) >= 1E-11 && (i < 1E-11 || i > Math.PI - 1E-11)) {
+            if (norm(e) === 0.0) {
+                throw new Error(`Cannot convert from Cartesian to Keplerian,
+                    eccentricity is zero.`);
+            }
+            raan = 0;
+            w = Math.acos(e[0] / norm(e));
+            if (e[1] < 0) {
+                w = 2 * Math.PI - w;
+            }
+
+            // For GMT-4446 fix (LOJ: 2014.03.21)
+            if (i > Math.PI - 1E-11) {
+                w *= -1.0;
+            }
+            if (w < 0.0) {
+                w += 2 * Math.PI;
+            }
+
+            f = Math.acos(dot(e, r) / (norm(e) * norm(r)));
+            if (r * v < 0) {
+                f = 2 * Math.PI - f;
+            }
+        }
+        // CASE 3: Circular, Inclined Orbit
+        if (norm(e) < 1E-11 && i >= 1E-11 && i <= Math.PI - 1E-11) {
+            if (norm(n) === 0.0) {
+                throw new Error(`Cannot convert from Cartesian to Keplerian, 
+                    line-of-nodes vector is a zero vector.`);
+            }
+            raan = Math.acos(n[0] / norm(n));
+            if (n[1] < 0) {
+                raan = 2 * Math.PI - raan;
+            }
+
+            w = 0;
+            f = Math.acos((dot(n, r) / (norm(n) * norm(r))));
+            if (r[3] < 0) {
+                f = 2 * Math.PI - f;
+            }
+        }
+        // CASE 4: Circular, Equatorial Orbit
+        if (norm(e) < 1E-11 && (i < 1E-11 || i > Math.PI - 1E-11)) {
+            raan = 0;
+            w = 0;
+            f = Math.acos(r[0] / norm(r));
+            if (r[1] < 0) f = 2 * Math.PI - f;
+
+            // For GMT-4446 fix (LOJ: 2014.03.21)
+            if (i > Math.PI - 1E-11) f *= -1.0;
+            if (f < 0.0) {
+                f += 2 * Math.PI;
+            }
+        }
+
+        return {
+            a: a /1000.0, // km
+            e: norm(e),
+            i: i * RAD2DEG, // deg
+            raan: raan * RAD2DEG, // deg
+            w: w * RAD2DEG, // deg
+            f: f * RAD2DEG, // deg
+        };
+    } catch (err) {
+        console.error(err);
+        return {};
+    }
+};
+
+/** Convert cartesian coordinates in an ECI (J2000, TEME, GCRF) frame to keplerian elements formatted as [ a, e, i, Ω, ω, θ ].
+ * The gravitational parameter is assumed to be Earth's mu.
+ * The function is a translation of Astro Library's OrbitalElementConverter.KeplerianToCartesian method.
+ *
+ * NOTE 1: input raan, argument of periapsis, and true anomaly are ALL adjusted to have a domain from 0 to 360!!!
+ * NOTE 2: raan, argument of periapsis, and true anomaly are ALL in degrees!
+ * NOTE 3: SMA (a) is in km
+ *
+ * @param {Array} elset Keplerian elements
+ * @param {Number} mu The gravitational parameter for the celestial object that we orbit, in km based units
+ * @return {Object} An object containing the position and velocity in *meter* based units
+ */
+const keplerianToCartesian = (elset, mu = 398600.4418) => {
+    const INFINITE_TOL = 1e-10;
+    const ORBIT_TOL = 1e-10;
+    try {
+        const [a, e, iDeg, raanDeg, wDeg, fDeg] = elset;
+        const i = iDeg * DEG2RAD;
+        const raan = raanDeg * DEG2RAD;
+        const w = wDeg * DEG2RAD;
+        const f = fDeg * DEG2RAD;
+
+        const p = a * (1 - Math.pow(e, 2));
+
+        if (Math.abs(p) < INFINITE_TOL) {
+            throw new Error("Cannot convert parabolic orbit.");
+        }
+
+        const onePlusECos = 1 + e * Math.cos(f);
+
+        if (onePlusECos < ORBIT_TOL) {
+            throw new Error("Orbital radius is large and may cause singularity.");
+        }
+
+        const rad = p / onePlusECos;
+        const cosPerAnom = Math.cos(w + f);
+        const sinPerAnom = Math.sin(w + f);
+        const cosInc = Math.cos(i);
+        const sinInc = Math.sin(i);
+        const cosRaan = Math.cos(raan);
+        const sinRaan = Math.sin(raan);
+        const sqrtGravP = Math.sqrt(mu / p);
+        const cosAnomPlusE = Math.cos(f) + e;
+        const sinAnom = Math.sin(f);
+        const cosPer = Math.cos(w);
+        const sinPer = Math.sin(w);
+
+        const r = {
+            x: 1000.0 * rad * (cosPerAnom * cosRaan - cosInc * sinPerAnom * sinRaan),
+            y: 1000.0 * rad * (cosPerAnom * sinRaan + cosInc * sinPerAnom * cosRaan),
+            z: 1000.0 * rad * sinPerAnom * sinInc,
+        };
+
+        const v = {
+            x: 1000.0 * (sqrtGravP * cosAnomPlusE * (-sinPer * cosRaan - cosInc * sinRaan * cosPer)
+               - sqrtGravP * sinAnom * (cosPer * cosRaan - cosInc * sinRaan * sinPer)),
+            y: 1000.0 * (sqrtGravP * cosAnomPlusE * (-sinPer * sinRaan + cosInc * cosRaan * cosPer)
+               - sqrtGravP * sinAnom * (cosPer * sinRaan + cosInc * cosRaan * sinPer)),
+            z: 1000.0 * (sqrtGravP * (cosAnomPlusE * sinInc * cosPer - sinAnom * sinInc * sinPer)),
+        };
+
+        return {r, v};
+    } catch (err) {
+        return {};
+    }
+};
+
+/**
+ * Get LEO RPO data for a given target satellite and a set of potential threat satellites.
+ * @param {String} line1, line 1 of the target satellite
+ * @param {String} line2, line 2 of the target satellite
+ * @param {Array<Objects>} sats, array of potential threat satellites and their Elsets
+ * @param {Integer} startTime, start time of the analysis, Unix milliseconds
+ * @param {Integer} endTime, end time of the analysis, Unix milliseconds
+ * @return {Array} Array of RPO data objects
+ */
+const getLeoRpoData = (line1, line2, sats, startTime, endTime) => {
+    const results = [];
+    const pSatRec = checkTle(line1, line2);
+    if (!isDefined(pSatRec)) return results;
+
+    const start = new Date(startTime).getTime();
+    const end = new Date(endTime).getTime();
+    const pElset = {
+        Line1: line1,
+        Line2: line2,
+    };
+    const pEphem = prop(pElset, start, end, 10000);
+
+    sats.forEach( (s) => {
+        const sEphem = prop(s, start, end, 10000);
+        if (!isDefined(pEphem)
+            || !isDefined(sEphem)
+            || pEphem.length !== sEphem.length) {
+            return;
+        }
+
+        const aResult = {
+            line1: s.Line1,
+            line2: s.Line2,
+            epoch: s.Epoch,
+            name: s.CommonName,
+            rank: s.Rank ?? "",
+            satNo: s.SatNo,
+            inclination: s.Inclination,
+            raan: s.Raan,
+            source: s.Source,
+            sma: s.SemiMajorAxis,
+            country: s.CountryId,
+            flag: s.Flag,
+            poca: 9999999999,
+            toca: "",
+            tocaString: "",
+            planeDiff: 0,
+            incDiff: s.incDiff,
+            raanDiff: s.raanDiff,
+            semiMajorDiff: s.semiMajorDiff,
+            raanDrift: s.RaanPrecessionDegreesPerDay,
+        };
+
+        const pv1 = {
+            position: pEphem[0].p,
+            velocity: pEphem[0].v,
+        };
+        const pv2 = {
+            position: sEphem[0].p,
+            velocity: sEphem[0].v,
+        };
+        aResult.di = angleBetweenPlanes(pv1, pv2);
+        aResult.dv = planeChangeDeltaV(pv1, pv2);
+        aResult.dv = {
+            i: Math.round(aResult.dv.i*1000)/1000,
+            c: Math.round(aResult.dv.c*1000)/1000,
+        }; // Round to 3 decimals
+
+        // Find the distance at each time step
+        for (let i=0; i<pEphem.length; i++) {
+            const distKm = dist(pEphem[i].p, sEphem[i].p);
+            if (distKm < aResult.poca) {
+                aResult.poca = distKm;
+                aResult.toca = new Date(pEphem[i].t).toISOString();
+                aResult.tocaString = getTimeDifference(aResult.toca);
+            }
+        }
+
+        // Calc danger score (account for di of 0)
+        aResult.danger = (aResult.di === 0
+                        || aResult.poca === 0) ? 1000 : 1/(aResult.di*aResult.poca);
+        results.push(aResult);
+    });
+    return results;
+};
+
+
+/**
+ * Get GEO RPO data for a given target satellite and a set of potential threat satellites.
+ * @param {String} line1, line 1 of the target satellite
+ * @param {String} line2, line 2 of the target satellite
+ * @param {Array<Objects>} sats, array of potential threat satellites and their Elsets
+ * @param {Integer} startTime, start time of the analysis, Unix milliseconds
+ * @param {Integer} endTime, end time of the analysis, Unix milliseconds
+ * @param {Integer} lonTime, datetime to analyze longitude and lon drift at, Unix milliseconds
+ * @return {Array<Objects>}, Array of RPO data objects
+ */
+const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime) => {
+    const start = new Date(startTime).getTime();
+    const end = new Date(endTime).getTime();
+    const pEphem = prop({
+        Line1: line1,
+        Line2: line2,
+    }, start, end, 60000);
+
+    const lonEvalTime = lonTime ? new Date(lonTime) : new Date(end);
+
+    const pLonAndDrift = getLonAndDrift(line1, line2, lonEvalTime);
+
+    const getLonDiff = (lon1, drift1, lon2, drift2) => {
+        const closing = lon1 > lon2
+            ? (drift1 * drift2 > 0 && drift1 < drift2) || (drift1 * drift2 < 0 && drift1 < 0) // Sat1 is more Eastward
+            : lon2 > lon1
+                ? (drift1 * drift2 > 0 && drift2 < drift1) || (drift1 * drift2 < 0 && drift1 > 0) // Sat2 is more Eastward
+                : false;
+        const difference = drift1 - drift2;
+        return closing ? -1 * Math.abs(difference) : Math.abs(difference);
+    };
+
+    const results = [];
+    sats.forEach((s) => {
+        const aResult = {
+            line1: s.Line1,
+            line2: s.Line2,
+            epoch: s.Epoch,
+            name: s.CommonName,
+            rank: s.Rank ?? "",
+            satNo: s.SatNo,
+            source: s.Source,
+            country: s.CountryId,
+            flag: s.Flag,
+            poca: 9999999999,
+            toca: "",
+            tocaString: "",
+            incDiff: s.incDiff,
+            longitude: null,
+            lonDiff: null,
+            relativeDrift: null,
+            di: null,
+            dv: null,
+            danger: null,
+        };
+
+        const sEphem = prop({
+            Line1: aResult.line1,
+            Line2: aResult.line2,
+        }, start, end, 60000);
+        if (!isDefined(pEphem)
+            || !isDefined(sEphem)
+            || pEphem.length !== sEphem.length) {
+            return;
+        }
+        const sLonAndDrift = getLonAndDrift(s.Line1, s.Line2, lonEvalTime);
+        aResult.longitude = (sLonAndDrift.longitude + 360) % 360; // Normalize to 0-360
+
+        const lonDiff = Math.abs(
+            (pLonAndDrift.longitude + 360.0) % 360
+            - (sLonAndDrift.longitude + 360.0) % 360.0,
+        );
+        // To ensure that the smallest "short-way" lon diff is considered
+        aResult.lonDiff = Math.min(lonDiff, 360 - lonDiff);
+
+        aResult.relativeDrift = getLonDiff(
+            pLonAndDrift.longitude,
+            pLonAndDrift.lonDriftDegreesPerDay,
+            sLonAndDrift.longitude,
+            sLonAndDrift.lonDriftDegreesPerDay);
+        const pv1 = {
+            position: pEphem[0].p,
+            velocity: pEphem[0].v,
+        };
+        const pv2 = {
+            position: sEphem[0].p,
+            velocity: sEphem[0].v,
+        };
+        aResult.di = angleBetweenPlanes(pv1, pv2);
+        aResult.dv = {
+            i: Math.round(planeChangeDeltaV(pv1, pv2).i*1000)/1000,
+            c: Math.round(planeChangeDeltaV(pv1, pv2).c*1000)/1000,
+        }; // Round to 3 decimals
+
+        for (let i=0; i<pEphem.length; i++) {
+            const distKm = dist(pEphem[i].p, sEphem[i].p);
+            if (distKm < aResult.poca) {
+                aResult.poca = distKm;
+                aResult.toca = new Date(pEphem[i].t).toISOString();
+                aResult.tocaString = getTimeDifference(aResult.toca);
+            }
+        }
+        // Calc danger score (account for di of 0)
+        aResult.danger = (aResult.di === 0
+                        || aResult.poca === 0) ? 1000 : 1/(aResult.di*aResult.poca);
+
+        results.push(aResult);
+    });
+
+    return results;
+};
+
+const getGeoShadowZones = (time, accuracySecondsDeg=0.00416*100) => {
+    // Accuracy is 86400 pooints on a 360 circle (i.e. 0.00416 deg per second)
+
+    // Define the TLE parameters of a template TLE in GEO
+    const tleLine1 = "1 00000U 00000A   24079.98445361 -.00000000  00000-0 -00000-0 0 00000";
+    const tleLine2Temp = "2 00000 000.0000 000.0000 0000000 000.0000 XXX.XXXX 01.00000000000000";
+    // Number of steps for the mean anomaly
+    const steps = 360 / accuracySecondsDeg;
+    // Loop over the range of mean anomalies
+    const res = [];
+    for (let i = 0; i < steps; i++) {
+        // Calculate the mean anomaly for this step
+        const meanAnomaly = i * accuracySecondsDeg;
+        // Format the mean anomaly into the TLE line
+        // Round the mean anomaly to two decimal places
+        const roundedMeanAnomaly = meanAnomaly.toFixed(4);
+        // Format the mean anomaly into the TLE line
+        const tleLine2 = tleLine2Temp.replace("XXX.XXXX", roundedMeanAnomaly.padStart(8, "0"));
+        // Generate the satrec object
+        const p = propagate(twoline2satrec(tleLine1, tleLine2), time).position;
+        res.push({
+            ecl: getEclipseStatus(time, [p.x, p.y, p.z]),
+            geolon: eciToGeodetic(p, gstime(time)).longitude*RAD2DEG,
+        });
+    }
+    // Find the sun zone, umbra zone, and two penumbra zones.
+    const ints = [];
+
+    // Open the first zone. Note that this may not be the start of this zone but somewhere in the middle.
+    // It's just the start of the mean anomaly seen as a circular buffer.
+    ints.push({
+        ecl: res[0].ecl,
+    });
+
+    for (let i=1; i<=res.length-1; i++) {
+        // Compare with the previous eclipse state
+        if (res[i].ecl!==res[i-1].ecl) {
+            // Close the previous zone
+            ints[ints.length-1].stopDeg = res[i-1].geolon;
+
+            // Open a new zone
+            ints.push({
+                ecl: res[i].ecl,
+                startDeg: res[i].geolon,
+            });
+        }
+    }
+    // With this process, the first interval will have a stop lon but not a start lon, and
+    // the final interval will have a start lon but not a stop lon.
+    // Stitch the first and last intervals together.
+
+    // If not dates are pushed on the first interval, it means it never closed, so it's a fully lit GEO belt.
+    // If there's only sun, return null values
+    if ( ints.length===1
+        && ints.filter((x)=>x.ecl === "SUN").length===1) {
+        return {
+            penStartWestLon: null,
+            penStartEastLon: null,
+        };
+    }
+
+    ints[0].startDeg = ints[ints.length-1].startDeg;
+    ints.pop();
+
+    if (
+        ints.filter((x)=>x.ecl === "UMBRA").length===0
+        && ints.filter((x)=>x.ecl === "PENUMBRA").length>0) {
+        // If there's no umbra but penumbra exists, return the perumbra values
+
+        // Extract the penumbra interval. In the absence of umbra, a single penumbra interval should exist.
+        const penumbraInt = ints.filter((x)=>x.ecl === "PENUMBRA")[0];
+        return {
+            penStartWestLon: wrapToRange(penumbraInt.startDeg, 0, 360),
+            penStartEastLon: wrapToRange(penumbraInt.stopDeg, 0, 360),
+        };
+    } else {
+        // If sun, umbra, penumbra intervals exist
+
+        const umbra = ints.filter((x)=>x.ecl === "UMBRA")[0];
+
+        const umbraStart360 = wrapToRange(umbra.startDeg, 0, 360);
+        const umbraStop360 = wrapToRange(umbra.stopDeg, 0, 360);
+        // Assuming a spherical earth for this purpose, the two penumbra intervals should be equal.
+        // Compute the angle of one of the penumbra intervals, the one that does not contain the disconituity.
+        const penumbraInts = ints.filter((x)=>x.ecl === "PENUMBRA");
+        const chosenPenumbraInt = penumbraInts[0].startDeg > penumbraInts[0].stopDeg
+            ? penumbraInts[1] : penumbraInts[0];
+        const penumbraAngle = chosenPenumbraInt.stopDeg - chosenPenumbraInt.startDeg;
+        const penumbraStart = umbraStart360 - penumbraAngle;
+        const penumbraStop = umbraStop360 + penumbraAngle;
+
+        return {
+            penStartWestLon: penumbraStart,
+            penStartEastLon: penumbraStop,
+        };
+    }
+};
+
+/** Returns the light intervals of an arbitrary satellite in strict GEO orbit.
+ *
+ * These intervals are generally equal in duration for all other GEO satellites.
+ *
+ * The use-case for this function is to help with the drawing of umbra/penumbra zones in the waterfall plot.
+ *
+ * @param {Date} time The time in UTC
+ * @param {Number} durationSeconds The duration in seconds of the analysis interval. Defaults to 1 day
+ * @param {Number} accuracySeconds The accuracy of the calulations, defaults to 1 sec. The higher, the faster.
+ * @return {Array} An array of objects, each of which represents a contiguous interval of sunlight, penumbra, or umbra.
+  */
+const getGeoLightIntervals = (time, durationSeconds=86400, accuracySeconds=10.0) => {
+    const endTime = new Date(time.getTime() + 1000.0*durationSeconds);
+    // Create an artificial satellite on GEO
+    const satrec = twoline2satrec(
+        "1 00000U 00000A   24079.98445361 -.00000000  00000-0 -00000-0 0 00000",
+        "2 00000 000.0000 000.0000 0000000 000.0000 000.0000 01.00299372000000",
+    );
+    const res = [];
+    while (time.getTime() <= endTime.getTime()) {
+        const p = propagate(satrec, time).position;
+        res.push({
+            t: time.toISOString(),
+            ecl: getEclipseStatus(time, [p.x, p.y, p.z]),
+            geolon: eciToGeodetic(p, gstime(time)).longitude,
+        });
+        time = new Date(time.getTime() + accuracySeconds*1000);
+    }
+    // Group to intervals
+    const ints = [];
+
+    // Create and open the first interval
+    ints.push({
+        ecl: res[0].ecl,
+        start: res[0].t,
+    });
+
+    for (let i=1; i<=res.length-1; i++) {
+        if (res[i].ecl!==res[i-1].ecl) {
+            // Close the previous interval
+            ints[ints.length-1].end = res[i-1].t;
+            // Create a new open interval
+            ints.push({
+                ecl: res[i].ecl,
+                start: res[i].t,
+            });
+        }
+    }
+    // Close the last interval
+    ints[ints.length-1].end = res[res.length-1].t;
+
+    return {
+        ints: ints,
+        meanLonDeg: res.reduce((acc, obj) => acc + obj.geolon, 0) / res.length,
+    };
+};
+
+/** Find if a satellite is in Sun, Umbra, or Penumbra.
+ *
+ * @param {Date} time The time instant of the satellite state
+ * @param {Array} pos The satellite position vector (assumed to be in an inertial frame)
+ * @return {String} SUN if in sunlight, UMBRA if in umbra, PENUMBRA if in penumbra
+ */
+const getEclipseStatus = (time, pos) => {
+    let shadow = "SUN";
+    const aPen = 0.269007205 * DEG2RAD;
+    const aUmb = 0.264121687 * DEG2RAD;
+    const rp = WGS72_EARTH_EQUATORIAL_RADIUS_KM; // Using WGS72 Earth equatorial radius (SGP4 standard) because this function is predominently used by Elset calculations.
+    const rS = getSunDirection(time);
+    const rSun = [rS.x, rS.y, rS.z];
+    const r = pos;
+    const rMag = norm(r);
+
+    if (dot(rSun, r) < 0) {
+        const rSunN = multiply(rSun, -1);
+        const rSunNnorm = normalize({x: rSunN[0], y: rSunN[1], z: rSunN[2]});
+        const rNorm = normalize({x: r[0], y: r[1], z: r[2]});
+        const angle = getAngle(
+            [rSunNnorm.x, rSunNnorm.y, rSunNnorm.z],
+            [rNorm.x, rNorm.y, rNorm.z],
+        );
+        const satHoriz = rMag * Math.cos(angle);
+        const satVert = rMag * Math.sin(angle);
+        const x = rp / Math.sin(aUmb);
+        const penVert = Math.tan(aPen)*(x+satHoriz);
+        if (satVert <= penVert) {
+            shadow = "PENUMBRA";
+            const y = rp / Math.sin(aUmb);
+            const umbVert = Math.tan(aUmb)*(y-satHoriz);
+            if (satVert <= umbVert) {
+                shadow = "UMBRA";
+            }
+        }
+    }
+    return shadow;
+};
+
+/**
+ * Brute-forces GEO crossing points where satellite crosses GEO altitude
+ * @param {*} propagateBetween async propagation function
+ * @param {*} start start time
+ * @param {*} end end time
+ * @param {*} stepMs step in milliseconds
+ * @return {Promise<Array>} array of objects with time (ms), altitude, and direction of crossing
+ */
+const calculateGeoCrossingTimes = async (propagateBetween, start, end, stepMs = 1000) => {
+    const startTime = new Date(start).getTime();
+    const endTime = new Date(end).getTime();
+
+    let lastAltState = 0; // -1 for below, 0 for none, 1 for above
+
+    const crossings = [];
+    const points = await propagateBetween(startTime, endTime, stepMs);
+
+    for (const pv of points) {
+        if (!isDefined(pv)) continue;
+        const time = pv.time;
+
+        const dist = norm(posToArray(pv.position)); // distance from center of the earth, km
+        const altitude = dist - WGS72_EARTH_EQUATORIAL_RADIUS_KM; // altitude, km
+
+        const newAltState = altitude >= GEO_ALTITUDE_KM ? 1 : -1;
+
+        if (lastAltState !== 0 && lastAltState !== newAltState) { // crossed GEO alt
+            const lon = wrapToRange(
+                eciToGeodetic(
+                    pv.position,
+                    gstime(new Date(time))).longitude*RAD2DEG,
+                0, 360);
+
+            crossings.push({
+                t: time,
+                alt: altitude,
+                direction: newAltState > 0 ? 1 : -1, // 1 means we crossed going above, -1 crossed going below1
+                lon,
+            });
+        }
+
+        lastAltState = newAltState;
+    }
+
+    return crossings;
+};
+
+
+/** A function that calculates the next time of an apogee and perigee for an orbit,
+ * and the geodetic longitude at which those occur.
+ *
+ * The 'next' times are with respect to an input date.
+ *
+ * Steps:
+ * 1. Propagate to the reference time.
+ * 2. Get the Cartesian and Keplerian state at the reference time.
+ * 3. At the reference time, compute Eccentric and Mean anomalies, and the time since periapsis.
+ * 4. Compute the time of the next periapsis. Repeat for apoapsis.
+ *
+ * @param {Object} pv Initial position/velocity object
+ * @param {Function<Object>} propagateTo async Date -> PV propagation method for SV or TLE
+ * @param {Date} time The time after which to compute the imediately next apogee and perigee times
+ * @param {Boolean} findApogee Propagate for apogee longitude and state
+ * @param {Boolean} findPerigee Propagate for perigee longitude and state
+ * @return {Object} The object with the next apoapsis/periapsis times, and the geodetic longitudes on which they occur.
+ */
+const calculateNextApogeePerigeeTimesWithPropagation
+    = async (pv, propagateTo, time, findApogee=true, findPerigee=true) => {
+        const r = multiply([pv.position.x, pv.position.y, pv.position.z],
+            1000.0);
+        const v = multiply([pv.velocity.x, pv.velocity.y, pv.velocity.z],
+            1000.0);
+        const el = cartesianToKeplerian(r, v);
+
+        // Compute Eccentric Anomaly from True Anomaly and Eccentricity
+        const E = 2 * Math.atan2(Math.tan(el.f/2 * DEG2RAD) * Math.sqrt(1-el.e), Math.sqrt(1+el.e));
+
+        // Compute Mean Anomaly from Eccentric Anomaly and Eccentricity
+        const M = E - (el.e)*Math.sin(E);
+
+        // Mean motion in radians per second
+        const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+        const n = Math.sqrt(mu/Math.pow((el.a*1000.0), 3));
+
+        // Orbit Period
+        const periodSecs = 2*Math.PI/n;
+
+        // Compute Time of Flight (ToF) since last Periapsis
+        const tofSincePeriapsisSecs = M / n;
+
+        // Time until next periapsis
+        let timeToNextPeriapsisSecs = periodSecs - Math.abs(tofSincePeriapsisSecs);
+
+        if (tofSincePeriapsisSecs < 0) {
+            timeToNextPeriapsisSecs = Math.abs(tofSincePeriapsisSecs);
+        }
+
+        // For next apoapsis, we check the true anomaly of the reference date
+        let timeToNextApoapsisSecs = 0;
+        if (el.f >= 180.0) {
+        // Satellite is past the apoapsis and before the next periapsis
+            timeToNextApoapsisSecs = timeToNextPeriapsisSecs + periodSecs/2;
+        } else {
+        // Satellite is past the periapsis and before the next apoapsis
+            timeToNextApoapsisSecs = periodSecs/2 - tofSincePeriapsisSecs;
+        }
+
+        const nextPeriapsisTimeUtc = new Date(time);
+        nextPeriapsisTimeUtc.setSeconds(new Date(time).getSeconds() + timeToNextPeriapsisSecs);
+
+        let periapsisPV = null;
+        let periLon = null;
+        if (findPerigee) {
+            periapsisPV = await propagateTo(nextPeriapsisTimeUtc);
+            periLon = wrapToRange(
+                eciToGeodetic(
+                    periapsisPV.position,
+                    gstime(nextPeriapsisTimeUtc)).longitude*RAD2DEG,
+                0, 360);
+        }
+
+        const nextApoapsisTimeUtc
+            = new Date(new Date(time).getTime() + (timeToNextApoapsisSecs * 1000));
+
+        let apoapsisPV = null;
+        let apoLon = null;
+        if (findApogee) {
+            apoapsisPV = await propagateTo(nextApoapsisTimeUtc);
+            apoLon = wrapToRange(
+                eciToGeodetic(
+                    apoapsisPV.position,
+                    gstime(nextApoapsisTimeUtc)).longitude*RAD2DEG,
+                0, 360);
+        }
+
+        const res = {
+            nextApoapsisTimeUtc: nextApoapsisTimeUtc.toISOString(),
+            nextApoapsisLonDeg: apoLon,
+            nextApoapsisPV: apoapsisPV,
+            nextPeriapsisTimeUtc: nextPeriapsisTimeUtc.toISOString(),
+            nextPeriapsisLonDeg: periLon,
+            nextPeriapsisPV: periapsisPV,
+        };
+        return res;
+    };
+
+/** A function that calculates the next time of an apogee and perigee for an orbit,
+ * and the geodetic longitude at which those occur.
+ *
+ * The 'next' times are with respect to an input date.
+ *
+ * Steps:
+ * 1. Propagate the TLE to the reference time.
+ * 2. Get the Cartesian and Keplerian state at the reference time.
+ * 3. At the reference time, compute Eccentric and Mean anomalies, and the time since periapsis.
+ * 4. Compute the time of the next periapsis. Repeat for apoapsis.
+ *
+ * @param {String} line1 TLE line 1
+ * @param {String} line2 TLE line 2
+ * @param {Date} time The time after which to compute the imediately next apogee and perigee times
+ * @param {Boolean} findApogee Propagate for apogee longitude and state
+ * @param {Boolean} findPerigee Propagate for perigee longitude and state
+ * @return {Object} The object with the next apoapsis/periapsis times, and the geodetic longitudes on which they occur.
+ */
+const calculateNextApogeePerigeeTimes
+    = async (line1, line2, time, findApogee=true, findPerigee=true) => {
+        const satrec = twoline2satrec(line1, line2);
+        const propagateTo = (t) => propagate(satrec, new Date(t));
+        const pv = propagateTo(time);
+        return await calculateNextApogeePerigeeTimesWithPropagation(
+            pv, propagateTo, time, findApogee, findPerigee,
+        );
+    };
+
+/**
+ * Computes whether target satellite is leading the primary satellite
+ * @param {*} primaryEphem propagated ephemeris for primary satellite
+ * @param {*} targetEphem propagated ephemeris for target satellite
+ * @return {Boolean} true if target is leading primary
+ */
+const isTargetLeading = (primaryEphem, targetEphem) => {
+    const pPos = posToArray(primaryEphem.p);
+    const tPos = posToArray(targetEphem.p);
+
+    const angularMomentum = cross(pPos, posToArray(primaryEphem.v)); // up if ref moving CCW, down if CW
+    const refTargetCross = cross(pPos, tPos); // up if CCW, down if CW (target from ref)
+
+    if (norm(refTargetCross) === 0) {
+        return 1;
+    }
+
+    // if angular momentum and ref target cross product are in same hemisphere (angle < 90 deg)
+    // then the target is leading the ref, otherwise it is trailing
+    const targetLeading = getAngle(angularMomentum, refTargetCross) <= Math.PI / 2;
+    return targetLeading;
+};
+
+/**
+ * Computes phase offset (in degrees) for a given primary (reference) satellite and a target satellite.
+ * Positive phase difference means the target is leading the satellite, negative means trailing
+ * @param {*} pSatRec satRec for primary satellite
+ * @param {*} tSatRec satRec for target satellite
+ * @param {*} time time to evaluate offset at
+ * @return {Number} phase offset in degrees
+ */
+const computePhaseDiff = (pSatRec, tSatRec, time) => {
+    const pEphem = propTo(pSatRec, time);
+    const tEphem = propTo(tSatRec, time);
+
+    if (!isDefined(pEphem) || !isDefined(tEphem)) {
+        return null;
+    }
+
+    const pPos = posToArray(pEphem.p);
+    const tPos = posToArray(tEphem.p);
+
+    const targetLeading = isTargetLeading(pEphem, tEphem);
+
+    const phaseAngleAbs = getAngle(pPos, tPos) * RAD2DEG;
+    const phaseDiff = phaseAngleAbs * (targetLeading ? 1 : -1); // positive for leading
+
+    return phaseDiff;
+};
+
+/**
+ * Computes orbital period in minutes, given TLE line 2
+ * @param {String} line2 TLE line 2 containing mean motion
+ * @return {Number} orbital period in minutes
+ */
+const getOrbitalPeriod = (line2) => {
+    // apparently mean motion should be obtained through TLE instead of satellite.js SatRec (see getElsetUdlFromTle)
+    const meanMotion = parseFloat(line2.slice(52, 63)); // revs per day
+    const period = (1 / meanMotion) * 24.0 * 60.0; // period in minutes
+    return period;
+};
+
+/**
+ * Computes phase offset, delta phase offset, time offset, and delta time offset
+ *      data for a given primary (reference) satellite and a target satellite.
+ * Positive phase difference means the target is leading the satellite, negative means trailing
+ * @param {String} pLine1, line 1 of the primary (reference) satellite
+ * @param {String} pLine2, line 2 of the primary (reference) satellite
+ * @param {String} tLine1, line 1 of the target satellite
+ * @param {String} tLine2, line 2 of the target satellite
+ * @param {Integer} time, time of the analysis, Unix milliseconds
+ * @return {Object} Data object
+ */
+const calculateLeoPhaseDifference = (pLine1, pLine2, tLine1, tLine2, time) => {
+    const pSatRec = twoline2satrec(pLine1, pLine2);
+    const tSatRec = twoline2satrec(tLine1, tLine2);
+
+    const diffNow = computePhaseDiff(pSatRec, tSatRec, time); // degrees
+    const diffFuture = computePhaseDiff(pSatRec, tSatRec, time + MILLIS_PER_DAY);
+
+    if (!isDefined(diffNow) || !isDefined(diffFuture)) {
+        return null;
+    }
+
+    const targetLeading = diffNow > 0;
+
+    const period = getOrbitalPeriod(pLine2) * 60; // period in seconds
+
+    // since time is how long target will take to catch up to reference's current phase,
+    //  positive phase (target leading ref) means negative time
+    let timeOffset = -diffNow * (period / 360); // period/360 gives seconds per degree
+    let timeOffsetFuture = -diffFuture * (period / 360);
+
+    let deltaPhase = diffFuture - diffNow;
+
+    // if we go from 170 to 190, it becomes (-170) - 170 = -340 when the actual change is +20
+    // so add 360 if < -180
+    // if we go from 190 to 170, it becomes 170 - (-170) = 340 when the actual change is -20
+    // so subtract 360 if > 180
+    if (deltaPhase < -180) {
+        deltaPhase += 360;
+        timeOffsetFuture = -(diffFuture+360) * (period / 360);
+    } else if (deltaPhase > 180) {
+        deltaPhase -= 360;
+        timeOffset = -(diffNow+360) * (period / 360);
+    }
+
+    const deltaTime = timeOffsetFuture - timeOffset;
+
+    return {
+        phaseOffset: diffNow,
+        deltaPhase,
+        timeOffset,
+        deltaTime,
+        targetLeading,
+    };
+};
+
+/**
+ * Get LEO waterfall data for a given primary satellite and a set of secondary satellites.
+ * Takes a list of elsets for each satellite, ordered in increasing epoch
+ * @param {Array<Array<Object>>} elsets, list of satellites, each as a list of elsets, with primary sat as first element
+ * @param {Integer} startTime, start time of the analysis, Unix milliseconds
+ * @param {Integer} endTime, end time of the analysis, Unix milliseconds
+ * @param {Integer} stepMs, step time of the analysis in milliseconds, default 10s
+ * @return {Array} Array of data objects
+ */
+const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
+    const results = [];
+
+    const start = new Date(startTime).getTime();
+    const end = new Date(endTime).getTime();
+
+    const currentIndices = elsets.map((sat) => 0);
+    const breakpoints = [{time: start, satIndex: -1}, {time: end, satIndex: -1}];
+    elsets.forEach((satElsets, i) => {
+        breakpoints.push(...satElsets.map((e, j) => ({
+            time: new Date(e.Epoch).getTime(),
+            satIndex: i,
+            elsetIndex: j,
+        })).filter((b) => b.time > start && b.time < end)); // ensure breakpoints are inside time range
+    });
+    breakpoints.sort((a, b) => a.time - b.time);
+
+    const satEphems = elsets.map((sat) => []);
+
+    for (let i = 0; i < breakpoints.length-1; i++) {
+        const bkpoint = breakpoints[i];
+        // if we start at breakpoints, it's irregular (since the epochs aren't in lockstep)
+        // we can force it to Math.ceil(segmentStart/stepMs)*stepMs for even steps but since the discrepancy
+        // is less than 10s in a plot over multiple days it's rather negligible
+        // also this makes it easier since we can check if its an epoch based on the segmentStart
+        const segmentStart = bkpoint.time;
+        const segmentEnd = breakpoints[i+1].time;
+
+        if (bkpoint.satIndex >= 0) { // this is a satellite's elset's epoch
+            currentIndices[bkpoint.satIndex] = bkpoint.elsetIndex;
+        }
+
+        currentIndices.forEach((elsetIndex, satIndex) => {
+            const elset = elsets[satIndex][elsetIndex];
+            const epoch = new Date(elset.Epoch).getTime();
+            const ephem = prop(elset, segmentStart, segmentEnd, stepMs);
+            satEphems[satIndex].push(...ephem.map((point, pointInd) => {
+                const osculatingElements = cartesianToKeplerian(
+                    multiply(posToArray(point.p), 1000.0), // km to m
+                    multiply(posToArray(point.v), 1000.0), // km/s to m/s
+                );
+                return {
+                    ...point,
+                    isEpoch: pointInd === 0 && bkpoint.satIndex === satIndex,
+                    epoch: epoch,
+                    satNo: elset.SatNo,
+                    name: elset.CommonName,
+                    source: elset.Source,
+                    raan: osculatingElements.raan, // deg
+                    raanPrecession: elset.RaanPrecessionDegreesPerDay,
+                    inclination: osculatingElements.i, // deg
+                };
+            }));
+        });
+    }
+
+    const pEphem = satEphems[0];
+
+    satEphems.forEach( (sEphem, satIndex) => {
+        // Find the distance at each time step
+        for (let i = 0; i < pEphem.length; i++) {
+            const pEphemPoint = pEphem[i];
+            const sEphemPoint = sEphem[i];
+
+            const direction = isTargetLeading(pEphemPoint, sEphemPoint) ? 1 : -1;
+            const distKm = direction * dist(pEphemPoint.p, sEphemPoint.p);
+
+            const raanDiff = getRaanDiff(sEphemPoint.raan, pEphemPoint.raan, false);
+            const incDiff = getIncDiff(sEphemPoint.inclination, pEphemPoint.inclination, false);
+
+            const time = new Date(pEphemPoint.t);
+            const epoch = new Date(sEphemPoint.epoch).toISOString();
+
+            let catsAngle = null;
+            let targetVisibility = null;
+
+            if (satIndex > 0) { // not the primary
+                if (areCoordsEqual(pEphemPoint.p, sEphemPoint.p)) {
+                    catsAngle = 180; // they're in the same spot, so just say secondary can see primary
+                } else {
+                    catsAngle = angleBetween3DCoords(
+                        pEphemPoint.p,
+                        sEphemPoint.p,
+                        getSunDirection(time),
+                    );
+                }
+
+                const earthEclipsed = doesLineSegmentIntersectEarth(pEphemPoint.p, sEphemPoint.p);
+                const targetShadow = getEclipseStatus(time, posToArray(sEphemPoint.p));
+                targetVisibility = earthEclipsed ? "EARTH ECLIPSED" : targetShadow;
+            }
+
+            results.push({
+                name: sEphemPoint.name,
+                satNo: sEphemPoint.satNo,
+                epoch: epoch,
+                isEpoch: sEphemPoint.isEpoch,
+                distance: distKm,
+                time: time.toISOString(),
+                source: sEphemPoint.source,
+                raan: sEphemPoint.raan,
+                raanDiff: raanDiff,
+                raanPrecession: sEphemPoint.raanPrecession,
+                inclination: sEphemPoint.inclination,
+                incDiff: incDiff,
+                primary: pEphemPoint,
+                catsAngle,
+                targetVisibility,
+            });
+        }
+    });
+    return results;
+};
+
+/**
+ * Returns the minimum deltaV for a Lambert maneuver between two satellites,
+ * within the given time range.
+ * @param {*} sat1Tle The initial TLE satrec
+ * @param {*} sat2Tle The final TLE satrec
+ * @param {Date} startTime The start time of the maneuver as unix timestamp in milliseconds
+ * @return {Object} An object containing the maneuver properties
+ */
+const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) =>{
+    const mu = 3.986004415e5; // km based
+
+    let minDv = Infinity;
+    let revNum = 0;
+    let minIntercept = [0, 0, 0]; // The minimum dv to intercept the target.
+    let minDt = 0; // The time of flight to intercept the target.
+    let interceptPvEci = {p: [0, 0, 0], v: [0, 0, 0]}; // The position and velocity of the interceptor and intercept time.
+    const sat1Pv = propagate(sat1Tle, new Date(startTime));
+
+    // Sweep across 1 orbit period
+    const sat1Period = parseInt((120*Math.PI)/(sat1Tle.no));
+    const sat2Period = parseInt((120*Math.PI)/(sat2Tle.no));
+    const periodS = sat1Period > sat2Period ? sat1Period : sat2Period;
+
+    for (let rev=0; rev < 10; rev++) {
+        for (let dt=100; dt<=periodS; dt+=100) { // Seconds
+            const sat2Pv = propagate(sat2Tle, new Date(startTime + (dt*1000)));
+            const r1 = [sat1Pv.position.x, sat1Pv.position.y, sat1Pv.position.z]; // km based
+            const v1Before = [sat1Pv.velocity.x, sat1Pv.velocity.y, sat1Pv.velocity.z]; // km/s based
+            const r2 = [sat2Pv.position.x, sat2Pv.position.y, sat2Pv.position.z]; // km based
+
+
+            const {v1, v2, vH1} = lambertThomsonAlgorithm(r1, r2, dt, rev, 0, v1Before, mu);
+            const deltaV1 = isDefined(v1) ? subtract(v1, v1Before) : [0, 0, 0];
+            const deltaVH1 = isDefined(vH1) ? subtract(vH1, v1Before): [0, 0, 0];
+            const v1Mag = norm(deltaV1);
+            const vH1Mag = norm(deltaVH1);
+
+            const areArraysEqual = deltaV1.every((val, idx) => val === deltaVH1[idx]);
+            const isZeroArray = deltaV1.every((val) => val === 0);
+
+            if (areArraysEqual && isZeroArray) {
+                continue;
+            }
+
+            const currentVector = v1Mag <= vH1Mag ? deltaV1 : deltaVH1;
+            const currentNorm = v1Mag <= vH1Mag ? v1Mag : vH1Mag;
+
+            if (currentNorm < minDv) {
+                revNum = rev;
+                minDv = currentNorm;
+                minIntercept = {
+                    x: currentVector[0],
+                    y: currentVector[1],
+                    z: currentVector[2],
+                };
+                minDt = dt;
+                interceptPvEci = {
+                    p: {
+                        x: r2[0],
+                        y: r2[1],
+                        z: r2[2],
+                    },
+                    v: {
+                        x: v2[0],
+                        y: v2[1],
+                        z: v2[2],
+                    }}; // Position and velocity of interceptor and intercept time.
+            }
+            // As N increments, at some point either both or one of the two energy solutions will be NaN.
+            // At that point, the N sweep can safely stop.
+            if (isNaN(v1Mag) || isNaN(vH1Mag)) {
+                break;
+            }
+        }
+    }
+
+    // First Maneuver: Intercept Target
+    const interceptRSW = multiply(
+        cartesianToRIC( sat1Pv.position, sat1Pv.velocity), // Convert the intercept maneuver vector to RSW coordinates.
+        [minIntercept.x, minIntercept.y, minIntercept.z],
+    );
+    const interceptDv = minDv*1000;
+
+    // Second Maneuver: Rendezvous
+    const sat2PvAtIntercept = propagate(sat2Tle, new Date(startTime + (minDt*1000)));
+    const rendezvousECIArray = subtract(
+        [
+            sat2PvAtIntercept.velocity.x,
+            sat2PvAtIntercept.velocity.y,
+            sat2PvAtIntercept.velocity.z,
+        ],
+        [interceptPvEci.v.x, interceptPvEci.v.y, interceptPvEci.v.z],
+    );
+    const rendezvousECI = {
+        x: rendezvousECIArray[0]*1000, // km/s to m/s
+        y: rendezvousECIArray[1]*1000,
+        z: rendezvousECIArray[2]*1000,
+    };
+    const rendezvousDv = norm(rendezvousECIArray)*1000; // km/s to m/s
+    const rendezvousRSW = multiply(
+        cartesianToRIC(interceptPvEci.p, interceptPvEci.v),
+        rendezvousECIArray,
+    );
+    return {
+        startTime: new Date(startTime).toISOString(),
+        revNum,
+        interceptDv_ms: interceptDv,
+        interceptTof_s: minDt,
+        interceptTime: new Date(startTime + (minDt*1000)).toISOString(),
+        interceptManeuverECI_ms: {
+            time: new Date(startTime).toISOString(),
+            x: minIntercept.x*1000, // km/s to m/s
+            y: minIntercept.y*1000,
+            z: minIntercept.z*1000,
+        },
+        interceptManeuverRSW_ms: {
+            time: new Date(startTime).toISOString(),
+            x: interceptRSW[0]*1000,
+            y: interceptRSW[1]*1000,
+            z: interceptRSW[2]*1000,
+        },
+        rendezvousDv_ms: rendezvousDv,
+        rendezvousManeuverECI_ms: rendezvousECI,
+        rendezvousManeuverRSW_ms: {
+            time: new Date(startTime + (minDt*1000)).toISOString(),
+            x: rendezvousRSW[0]*1000,
+            y: rendezvousRSW[1]*1000,
+            z: rendezvousRSW[2]*1000,
+        },
+        totalDv_ms: interceptDv + rendezvousDv,
+    };
+};
+
+
+/**
+ * A function that attempts to perform maneuver recovery (i.e. maneuver deltaV computation) between an initial and final TLE
+ * and return the minimum deltaV possible to perform the maneuver.
+ *
+ * The initial TLE should be the pre-maneuver TLE, and the final TLE should be the post-maneuver TLE.
+ * The computation will work as long as the initial TLE is before the final TLE in terms of epoch, and as long as the satNos match.
+ * Otherwise, a zero vector is retuned.
+ *
+ * The function wraps a parameter sweep strategy and solves a series of Lambert problems.
+ * Each Lambert problem is using the positions of the two TLEs at their respective epochs and the time difference as the time of flight
+ * using the robust method suggested by Thomson:
+ *
+ * *AAS 18-074 Complete Solution of the Lambert Problem with Perturbations and Target State Sensitivity*
+ * by Blair F. Thomson, Denise Brown, and Ryan Cobb
+ *
+ * An outer loop solves Lamberts problem for different values of the number of revolutions, starting from 0 and up to 10.
+ * Inside the loop the core Lambert algorithm return a low-energy solution and a high-energy solution, of which the one with the smallest deltaV magnitude is chosen.
+ *
+ * Once the increments of N start producing NaN results for the deltaV, the loop is broken and the lowest deltaV vector thus far is fetched from the sweep results.
+ *
+ * This parameter sweep is performed because different satellites on various orbits and time of flight periods will yield different deltaV for the same positions and time of flight.
+ *
+ * By varying N lineary from 0 to its breaking point, a basic form of convex convergence on the minimum deltaV is guaranteed.
+ *
+ * @param {Object} initialTLE The initial TLE object
+ * @param {Object} finalTLE The final TLE object
+ * @return {number[]} The minimumDeltaV vector in ECI frame, in units of km/s
+ */
+const detectManeuverMinDv = (initialTLE, finalTLE) => {
+    try {
+        // Silently return zero vector if initial and final TLE have different satNo
+        if (initialTLE.satnum !== finalTLE.satnum) {
+            throw new Error(`Initial satNo ${initialTLE.satnum} and Final satNo ${finalTLE.satnum} do not match.  `);
+        }
+
+        // Silently return zero vector if initial TLE is after final TLE
+        if (initialTLE.jdsatepoch > finalTLE.jdsatepoch) {
+            throw new Error(`Initial TLE epoch ${julianToGregorian(initialTLE.jdsatepoch)} is after Final TLE epoch ${julianToGregorian(finalTLE.jdsatepoch)}`);
+        }
+
+        // Propagate initial TLE to its TLE epoch
+        const pvInitial = propagate(initialTLE, julianToGregorian(initialTLE.jdsatepoch));
+
+        // Propagate final TLE to its own TLE epoch
+        const pvFinal = propagate(finalTLE, julianToGregorian(finalTLE.jdsatepoch));
+
+        // Compute the epoch difference between the two TLEs
+        // This will be the used as the time of flight between initial and final state.
+        const dt = Math.abs((julianToGregorian(finalTLE.jdsatepoch)
+            - julianToGregorian(initialTLE.jdsatepoch)) / 1000);
+
+        // Position of initial TLE at its epoch
+        const r1 = [pvInitial.position.x, pvInitial.position.y, pvInitial.position.z]; // km based
+        // Velocity of initial TLE at TLE epoch
+        const v1Before = [pvInitial.velocity.x, pvInitial.velocity.y, pvInitial.velocity.z]; // km/s based
+
+        // Position of final TLE at its epoch
+        const r2 = [pvFinal.position.x, pvFinal.position.y, pvFinal.position.z]; // km based
+
+        // Earth Gravitational Parameter
+        const mu = 3.986004415e5; // km based
+
+        // Loop for N until NaN
+        let minNorm = Infinity;
+        // let minIndex = -1;
+        let minVector = [0, 0, 0];
+        for (let i=0; i<10; i++) { // loop up to 10 revolutions, it is a safe upper limit to capture impulsive maneuvers
+            const {v1, vH1} = lambertThomsonAlgorithm(r1, r2, dt, i, 0, v1Before, mu);
+
+            const deltaV1 = isDefined(v1) ? subtract(v1, v1Before) : [0, 0, 0];
+            const deltaVH1 = isDefined(vH1) ? subtract(vH1, v1Before): [0, 0, 0];
+            const v1Mag = norm(deltaV1);
+            const vH1Mag = norm(deltaVH1);
+
+            const isZeroArray = deltaV1.every((val) => val === 0);
+
+            if (deltaV1 === deltaVH1 && isZeroArray ) {
+                continue;
+            }
+
+            const currentVector = v1Mag <= vH1Mag ? deltaV1 : deltaVH1;
+            const currentNorm = v1Mag <= vH1Mag ? v1Mag : vH1Mag;
+
+            if (currentNorm < minNorm) {
+                minNorm = currentNorm;
+                // minIndex = i;
+                minVector = currentVector;
+            }
+            // As N increments, at some point either both or one of the two energy solutions will be NaN.
+            // At that point, the N sweep can safely stop.
+            if (isNaN(v1Mag) || isNaN(vH1Mag)) {
+                break;
+            }
+        }
+        return minVector;
+    } catch (err) {
+        console.warn(err);
+        return [0, 0, 0];
+    }
+};
+
+/** This is an implementation of the Lambert Problem using the algorithm described by Thomson in:
+ *
+ * *AAS 18-074 Complete Solution of the Lambert Problem with Perturbations and Target State Sensitivity*
+ * by Blair F. Thomson, Denise Brown, and Ryan Cobb
+ *
+ * The algorithm is a more numerically stable and robust implementation of the Battin algorithm or the Universal Variable formulation.
+ * It is stable for transfers near or at 180 degrees. All benchmark cases of the algorithm are added as tests for this method.
+ *
+ * The algorithm can accept units in both km or meter based, as long as all of the inputs are consistent.
+ * For example, if the initial position vector is in km, the the final position vector, as well as the initial velocity and gravitational parameter must be in km based units (and km/s respectively).
+ *
+ * @param {Array<Number>} r1 The initial position vector
+ * @param {Array<Number>} r2 The final position vector
+ * @param {Number} t The time of flight between initial and final position in seconds
+ * @param {Integer} N The number of revolutions
+ * @param {Integer} D A flag indicating the direction of the transfer. D = 1 for short way transfers, D = -1 for long way transfers. D = 0 will allow the algorithm to decide.
+ * @param {Array<Number>} v1Minus The initial velocity vector prior to the application of the maneuver.
+ * @param {Number} mu The gravitational parameter of the central body. Defaults to the value of the Earth's gravitational parameter in meter based units (so use meter based vectors  if using the default mu!)
+ * @param {Number} outOfPlaneError The out-of-plane error tolerance error to allow if the user wants to restrict the transfer to the initial orbital plane. Defaults to 0 for no initial plane restriction. Tweak this value if you suspect that the resulting deltaV is too large for a relatively small rendevous distance.
+ * @return {Object} An object containing the following properties:
+ *  - {Array<Number>} v1: The initial velocity vector after the application of the maneuver.
+ *  - {Array<Number>} v2: The final velocity vector after the application of the maneuver.
+ *  - {Array<Number>} vH1: The high-energy velocity vector for the first leg of the transfer.
+ *  - {Array<Number>} vH2: The high-energy velocity vector for the second leg of the transfer.
+ *  - {Number} theta: The transfer angle in radians. This is only for information purposes. It does not consider revolutions.
+ *
+ */
+const lambertThomsonAlgorithm
+= (r1, r2, t, N, D = 0, v1Minus, mu = 3.986004415e14, outOfPlaneError = 0) => {
+    // Out-Of-Plane error check
+    const r1Mag = norm(r1);
+    const r2Mag = norm(r2);
+    const r2Scaled = multiply(r2, r1Mag / r2Mag);
+    const r2PlusR1Scaled = add(r2, r2Scaled);
+
+    if (norm(r2PlusR1Scaled) <= outOfPlaneError) {
+        const crossProduct = cross(r1, v1Minus);
+        const nH = normalize({x: crossProduct[0], y: crossProduct[1], z: crossProduct[2]});
+        const f = dot(nH, subtract(r1, r2));
+        r2 = multiply(normalize(add(r2, multiply([nH.x, nH.y, nH.z], f))), r2Mag);
+    }
+
+    // ----- Lines 2-5 -----
+    let A = dot(r1, r2) / (r1Mag * r2Mag);
+    if (A > 1.0) A = 1.0;
+    if (A < -1.0) A = -1.0;
+    let theta = Math.acos(A); // transfer angle
+
+    // ----- Lines 6-8: Determine transfer direction -----
+    const crossR1V1 = cross(r1, v1Minus);
+    const crossR1R2 = cross(r1, r2);
+    if (D === -1 || (D === 0 && dot(crossR1V1, crossR1R2) < 0)) {
+        theta = 2 * Math.PI - theta; // long way transfer
+    }
+
+    // ----- Lines 9-13 -----
+    const c = norm(subtract(r2, r1)); // chord length
+    const s = 0.5 * (r1Mag + r2Mag + c); // semiperimeter
+    const lambda = (1.0 / s) * Math.sqrt(r1Mag * r2Mag) * Math.cos(theta / 2.0);
+    const L = Math.pow((1 - lambda) / (1 + lambda), 2.0);
+    const mVal = 8 * mu * t * t / (Math.pow(s, 3.0) * Math.pow(1 + lambda, 6.0));
+
+    // ----- Line 14: Initial x -----
+    let x = (N > 0) ? (1 + 4 * L) : L;
+    let xdiff = 1.0;
+    let y = 0.0;
+
+    // ----- Lines 15-54: Iteration for x -----
+    while (xdiff > 1e-6) {
+        let h1; let h2;
+        if (N > 0) {
+            // ----- Lines 17-19: Multi-rev (N > 0) branch using Loechler's method -----
+            const numerator = Math.pow(L + x, 2.0);
+            const denominator = 4 * x * x * (1 + 2 * x + L);
+            const sqrtx = Math.sqrt(x);
+            const commonTerm = ((N * Math.PI / 2 + Math.atan(sqrtx)) / sqrtx);
+            // The bracketed term (Loechler p.30 (4.3))
+            const term1 = 3 * Math.pow(1 + x, 2.0) * commonTerm - (3 + 5 * x);
+            h1 = (numerator / denominator) * term1;
+
+            // ----- Line 19: h2 (Loechler p.31 (4.4)) -----
+            const term2 = (x * x - x * (1 + L) - 3 * L) * commonTerm + (3 * L + x);
+            h2 = mVal / denominator * term2;
+        } else {
+            // ----- Lines 20-36: Single-rev branch -----
+            const eta = x / Math.pow(Math.sqrt(1 + x) + 1, 2.0);
+            let bn = 3; let dn = 1; let un = 8 * (Math.sqrt(1 + x) + 1) / bn;
+            let xi = un;
+            let i = 1;
+            while (Math.abs(un) > 1e-12) {
+                const bp = bn; const dp = dn; const up = un;
+                i++;
+                let an;
+                if (i === 2) {
+                    an = -1;
+                    bn = 5 + eta;
+                } else if (i === 3) {
+                    an = -9 * eta / 7;
+                    bn = 1;
+                } else {
+                    an = -eta * i * i / (4 * i * i - 1);
+                    bn = 1;
+                }
+                dn = 1 / (1 - an * dp / bp / bn);
+                un = up * (dn - 1);
+                xi += un;
+            }
+            h1 = (Math.pow(L + x, 2.0) * (1 + 3 * x + xi))
+                / ((1 + 2 * x + L) * (4 * x + xi * (3 + x)));
+            h2 = mVal * (x - L + xi) / ((1 + 2 * x + L) * (4 * x + xi * (3 + x)));
+        }
+
+        // ----- Lines 38-39: Compute B and solve for K -----
+        const BVal = 27.0 * h2 / (4.0 * Math.pow(1 + h1, 3.0));
+        const uVal = BVal / (2.0 * (Math.sqrt(1 + BVal) + 1.0));
+
+        const bn2 = 1.0; let dn2 = 1.0; let un2 = 1.0 / 3.0;
+        let K = un2;
+        let n = 0;
+        let evenflag = 1;
+        while (Math.abs(un2) > 1e-12) {
+            const bp = bn2; const dp = dn2; const up = un2;
+            let an;
+            if (evenflag === 1) {
+                an = -2.0 * uVal * (3 * n + 2) * (6 * n + 1) / (9 * (4 * n + 1) * (4 * n + 3));
+                evenflag = 0;
+                n++;
+            } else {
+                an = -2.0 * uVal * (3 * n + 1) * (6 * n - 1) / 9.0 / (4 * n - 1) / (4 * n + 1);
+                evenflag = 1;
+            }
+            dn2 = 1.0 / (1 - an * dp / bp / bn2);
+            un2 = up * (dn2 - 1.0);
+            K += un2;
+        }
+
+        // ----- Line 50: Compute y -----
+        y = (1 + h1) / 3.0 * (2 + Math.sqrt(1 + BVal) / (1.0 + 2.0 * uVal * K * K));
+        // ----- Line 51: Update xnew (Battin p.335 (7.113))
+        const xnew = Math.sqrt(Math.pow((1.0 - L)/2.0, 2.0) + mVal/(y*y)) - (1.0 + L)/2.0;
+        // ----- Line 52: Compute difference -----
+        xdiff = Math.abs(xnew - x);
+        // ----- Line 53: Update x -----
+        x = xnew;
+    }
+
+    // ----- Lines 55-57: Compute p and eccentricity -----
+    const pVal = 2 * r1Mag * r2Mag * y * y * Math.pow(1 + x, 2.0)
+        * Math.pow(Math.sin(theta / 2), 2.0)
+                   / (mVal * s * Math.pow(1 + lambda, 2.0));
+    const eps = (r2Mag - r1Mag) / r1Mag;
+    const eVal = Math.sqrt(
+        (Math.pow(eps, 2.0) + 4.0 * r2Mag / r1Mag
+        * Math.pow(Math.sin(theta / 2.0), 2.0) * Math.pow((L - x) / (L + x), 2.0))
+        / (Math.pow(eps, 2.0) + (4.0 * r2Mag / r1Mag) * Math.pow(Math.sin(theta / 2.0), 2.0)),
+    );
+
+    // ----- Line 58: Call hodograph velocity algorithm -----
+    const {v1, v2} = hodographVelocityAlgorithm(r1, r2, t, v1Minus, theta, pVal, eVal, mu);
+
+    // ----- Lines 59-84: Multi-rev high-energy solution -----
+    let vH1 = [0, 0, 0];
+    let vH2 = [0, 0, 0];
+
+    if (N > 0) {
+        // Line 61:
+        x = 1e-20;
+        xdiff = 1.0;
+        while (xdiff > 1e-6) {
+            // ----- Line 64: Compute h1 for high-energy solution (Loechler p.35 (5.5)) -----
+            const h1He = (L + x) * (1 + 2 * x + L) / (2 * (L - x * x));
+            // ----- Line 65: Compute h2 for high-energy solution (Loechler p.35 (5.6)) -----
+            const h2He = mVal * Math.sqrt(x) / (2 * (L - x * x))
+                        * ((L - x * x) * ((N * Math.PI / 2 + Math.atan(Math.sqrt(x)))
+                        / Math.sqrt(x)) - (L + x));
+            // ----- Line 66: Compute B for high-energy solution (Loechler p.37 (5.9)) -----
+            const BHe = 27 * h2He / (4 * Math.pow(Math.sqrt(x) * (1 + h1He), 3.0));
+            let F;
+            if (BHe < 0) {
+                // ----- Line 68: Compute F for negative B -----
+                F = 2 * Math.cos(1.0 / 3.0 * Math.acos(Math.sqrt(BHe + 1)));
+            } else {
+                // ----- Lines 70-71: Compute F for nonnegative B -----
+                const AHe = Math.pow(Math.sqrt(BHe) + Math.sqrt(BHe + 1), 1.0 / 3.0);
+                F = AHe + 1 / AHe;
+            }
+            // ----- Line 73: Compute y for high-energy solution (Loechler p.37 (5.10)) -----
+            const yHe = (2.0 / 3.0) * Math.sqrt(x) * (1 + h1He) * (Math.sqrt(BHe+1) / F + 1);
+            // ----- Line 74: Update xnew for high-energy solution (Loechler p.34 (5.3)) -----
+            const temp = (mVal / (yHe * yHe)) - (1 + L);
+            const xnewHe = 0.5 * (temp - Math.sqrt(temp * temp - 4 * L));
+            xdiff = Math.abs(xnewHe - x);
+            x = xnewHe;
+        }
+        // ----- Line 78: Compute semi-major axis a -----
+        const eVal = s * Math.pow(1 + lambda, 2.0) * (1 + x) * (L + x) / (8 * x);
+        // ----- Line 79: Compute p for high-energy solution -----
+        const pHe = 2 * r1Mag * r2Mag * Math.pow(Math.sin(theta / 2), 2.0) * (1 + x)
+                      / (s * Math.pow(1 + lambda, 2.0) * (L + x));
+        // ----- Line 80: Compute eccentricity for high-energy solution -----
+        const eHe = Math.sqrt(1 - pHe / eVal);
+        // ----- Line 81: Compute high-energy velocities -----
+        const highEnergyVels = hodographVelocityAlgorithm(r1, r2, t, v1Minus, theta, pHe, eHe, mu);
+        vH1 = highEnergyVels.v1;
+        vH2 = highEnergyVels.v2;
+    }
+
+    return {v1, v2, vH1, vH2, theta};
+};
+
+/**
+ * Implements the Hodograph Velocity Algorithm.
+ * @param {Array<number>} r1 Initial position vector
+ * @param {Array<number>} r2 Final position vector
+ * @param {number} t Time of flight
+ * @param {Array<number>} v1Minus Initial velocity vector
+ * @param {number} theta Transfer angle in radians
+ * @param {number} p Semi-latus rectum
+ * @param {number} e Eccentricity
+ * @param {number} mu Gravitational parameter
+ * @return {{v1: Array<number>, v2: Array<number>}} Initial and final velocity vectors
+ */
+const hodographVelocityAlgorithm = (r1, r2, t, v1Minus, theta, p, e, mu) => {
+    // Line 2: Define L180 (in meters)
+    const L180 = 1.0;
+
+    const r1Mag = norm(r1);
+    const r2Mag = norm(r2);
+
+    // Line 3: A = mu*(1/r1 - 1/p)
+    const eVal = mu * (1.0 / r1Mag - 1.0 / p);
+
+    // Line 4: B = (mu*e/p)^2 - A^2
+    const BVal = Math.pow(mu * e / p, 2.0) - (eVal * eVal);
+
+    // Line 5: if B <= 0 then x1 = 0 else x1 = -sqrt(B)
+    let x1 = (BVal <= 0) ? 0.0 : -Math.sqrt(BVal);
+
+    let nHat; // unit normal vector
+
+    // Line 6: Check if |sin(theta)| < L180 / r2Mag
+    if (Math.abs(Math.sin(theta)) < L180 / r2Mag) {
+        // Line 7: nHat = (r1 x v1Minus) normalized
+        const crossProduct = cross(r1, v1Minus);
+        nHat = normalize({x: crossProduct[0], y: crossProduct[1], z: crossProduct[2]});
+        nHat = [nHat.x, nHat.y, nHat.z];
+
+        // Line 8: If the orbit is elliptical (e < 1)
+        if (e < 1.0) {
+            // Line 9: P = 2π * sqrt( p^3 / [ mu * (1-e^2)^3 ] )
+            const P = 2 * Math.PI * Math.sqrt(Math.pow(p, 3.0) / (mu * Math.pow(1 - e * e, 3.0)));
+            // Line 10: If (t mod P) > (P/2) then reverse x1
+            const tMod = t % P;
+            if (tMod > P / 2) {
+                x1 = -x1;
+            }
+        }
+    } else {
+        // Line 13: nHat = (r1 x r2) normalized
+        const crossProduct = cross(r1, r2);
+        nHat = normalize({x: crossProduct[0], y: crossProduct[1], z: crossProduct[2]});
+        nHat = [nHat.x, nHat.y, nHat.z];
+
+        // Line 14: If (theta mod 2π) > π then reverse nHat
+        const thetaMod = theta % (2 * Math.PI);
+        if (thetaMod > Math.PI) {
+            nHat = nHat.map((x) => -x);
+        }
+        // Line 15: y2a = mu/p - x1*sin(theta) + A*cos(theta)
+        const y2a = mu / p - x1 * Math.sin(theta) + eVal * Math.cos(theta);
+        // Line 16: y2b = mu/p + x1*sin(theta) + A*cos(theta)
+        const y2b = mu / p + x1 * Math.sin(theta) + eVal * Math.cos(theta);
+        // Line 17: if |mu/r2Mag - y2b| < |mu/r2Mag - y2a| then reverse x1
+        if (Math.abs(mu / r2Mag - y2b) < Math.abs(mu / r2Mag - y2a)) {
+            x1 = -x1;
+        }
+    }
+
+    // Line 19
+    const term1V1 = multiply(r1, x1 / mu);
+    const crossProduct1 = cross(nHat, r1);
+    const term2V1 = multiply(crossProduct1, 1/r1Mag);
+    const v1 = multiply(add(term1V1, term2V1), Math.sqrt(mu * p) / r1Mag);
+
+    // Line 20
+    const x2 = x1 * Math.cos(theta) + eVal * Math.sin(theta);
+
+    // Line 21
+    const term1V2 = multiply(r2, x2 / mu);
+    const crossProduct2 = cross(nHat, r2);
+    const term2V2 = multiply(crossProduct2, 1/r2Mag);
+    const v2 = multiply(add(term1V2, term2V2), Math.sqrt(mu * p) / r2Mag);
+
+    return {v1, v2};
+};
+
+const wrap360 = (r) => {
+    if (r < 0) return r + 360;
+    if (r >= 360) return r - 360;
+    return r;
+};
+
+const inWrappedRange = (val, low, high) => {
+    if (low <= high) {
+        return val >= low && val <= high;
+    }
+
+    // e.g. 350 to 10 -> 350 to 360 OR 0 to 10
+    // since wrapped value cannot be >360 nor <0 this simplifies to >350 or <10
+    return val >= low || val <= high;
+};
+
+const subtractWrapped = (a, b, range=360) => { // a - b, range = 360 for example for 0-360 range
+    const diff = a - b;
+    if (diff > range/2) { // 350 - 10 = 340 => 350 - 370 = -20
+        return diff - range;
+    } else if (diff < -range/2) { // 10 - 350 = -340 => 370 - 350 = 20
+        return diff + range;
+    }
+    return diff;
+};
+
+const propagateRaan = (raan, raanPrecessionPerDay, currentTime, epoch) => {
+    const epochMs = parseDate(epoch).getTime();
+    const currentTimeMs = new Date(currentTime).getTime();
+    const currentRaan
+        = wrap360(raan + (currentTimeMs - epochMs) / MILLIS_PER_DAY * raanPrecessionPerDay);
+    return currentRaan;
+};
+
+const getIncDiff = (incCurrent, incPrimary, absoluteValue=true) => {
+    const diff = subtractWrapped(incCurrent, incPrimary, 180); // Inclination is 0 to 180
+    return absoluteValue ? Math.abs(diff) : diff;
+};
+
+const getRaanDiff = (raanCurrent, raanPrimary, absoluteValue=true) => {
+    const diff = subtractWrapped(raanCurrent, raanPrimary, 360); // RAAN is 0 to 360
+    return absoluteValue ? Math.abs(diff) : diff;
+};
+
+const getRaanClosureRate = (raanPrecessionCurrent, raanPrecessionPrimary) => {
+    return Math.abs(raanPrecessionCurrent - raanPrecessionPrimary); // closure rate should always be positive
+};
+
+const getRaanAlignTime = (raan, raanDrift, raanTarget, raanTargetDrift, currentTime) => {
+    // imagine a circle where positive is counterclockwise
+    const netDrift = raanDrift - raanTargetDrift; // how fast we are drifting along the circle
+    if (netDrift === 0) return null;
+    if (raan === raanTarget) return new Date(currentTime);
+
+    let diff = raanTarget - raan; // the distance along the circle we need to drift to reach the target, might be negative or positive
+
+    if (Math.sign(netDrift) !== Math.sign(diff)) {
+        // we need to transform the distance to be in the same direction as we are drifting
+        if (diff < 0) diff += 360; // target is behind us, e.g. target is 10 and we are 350 (diff -340): get the other part of the circle (+20)
+        else diff -= 360; // diff > 0, so target is ahead of us (+20), but we are going backwards, get the other part of the circle (-340)
+    }
+
+    // diff and netdrift signs should match now
+    const raanAlignMillis = (diff / netDrift) * MILLIS_PER_DAY; // drift is deg/day
+    if (raanAlignMillis > MILLIS_PER_DAY * 365) {
+        return null; // will take over a year to align
+    }
+    return new Date(new Date(currentTime).getTime() + raanAlignMillis);
+};
+
+const getRaanAlignTimeStr = (raan, raanDrift, raanTarget, raanTargetDrift, currentTime) => {
+    const alignTime = getRaanAlignTime(raan, raanDrift, raanTarget, raanTargetDrift, currentTime);
+    return alignTime?.toISOString() ?? "Relatively stationary";
+};
+
+const getRaanDetails = (raan, raanPrecessionDegreesPerDay, epoch,
+    primaryRaan, primaryRaanPrecessionDegreesPerDay, primaryEpoch, currentTime,
+    absoluteValueDiff=true,
+) => {
+    const raanDrift = raanPrecessionDegreesPerDay;
+    const currentRaan = propagateRaan(raan, raanDrift,
+        currentTime, epoch);
+
+    const primaryRaanDrift = primaryRaanPrecessionDegreesPerDay;
+    const currentPrimaryRaan = propagateRaan(primaryRaan, primaryRaanDrift,
+        currentTime, primaryEpoch);
+
+    return {
+        Raan: currentRaan,
+        RaanDrift: raanDrift,
+        RaanDiff: getRaanDiff(currentRaan, currentPrimaryRaan, absoluteValueDiff),
+        RaanClosureRate: getRaanClosureRate(raanDrift, primaryRaanDrift),
+        RaanAlignTime: getRaanAlignTimeStr(currentRaan, raanDrift,
+            currentPrimaryRaan, primaryRaanDrift, currentTime),
+    };
+};
+
+/** Calculates if a satellite is in shadow.
+ * Based on Astro Library's implementation of Algorithm 34 SHADOW from Vallado's Fundamentals of Astrodynamics and Applications.
+ * Astrolibrary's implementation is adding up a few frame transformations from the GCRF to the J2000 frame for the sun position.
+ * Those are implemented below.
+ *
+ * August 2025: An attempt was made to use the pious-squid shadow algorithm SunBody.shadow(...), but the function returns true/false and cannot distinguish between partial and full shadow.
+ * Therefore the astrolibrary implementation is used instead.
+ *
+ * Returns a string:
+ *  - "None": if the satellite is in sunlight, or
+ *  - "Penumbra": if in partial sunlight, or
+ *  - "Umbra": if in full shadow
+ *
+ * @param {Date} epoch UTC time epoch of the measurement
+ * @param {Object} satPos satellite position at the specified epoch
+ * @return {String} type of shadow (None, Penumbra, Umbra)
+ */
+const isSatInShadow = (epoch, satPos) => {
+    // Constants
+    const re = WGS84_EARTH_EQUATORIAL_RADIUS_KM; // Earth radius in km
+    const rs = SUN_RADIUS_KM; // Sun radius in km
+    const arcsec2rad = ARCSEC2RAD;
+    const sec2rad = SEC2RAD;
+    const auDist = AU_KM; // 1 AU in km
+    const alphaUmbra = Math.atan((rs - re) / auDist); // half angle of the umbra
+    const alphaPenumbra = Math.atan((rs + re) / auDist); // half angle of the penumbra
+
+    // Begin with no shadow
+    let shadowType = "None";
+
+    // Getting Sun's apperent longitude and declination at the current epoch
+    const century = solar.century(epoch); // Convert date to Julian centuries since J2000 || equal to var tut1 in GetPosition()
+
+    // Variables to solve for Sun Pos in ___ frame
+    const lamM = (280.460 + 36000.771*century % 360) * DEG2RAD;
+    const M = (357.5291092 + 35999.05034*century % 360) * DEG2RAD;
+    const lamEc = (((lamM * RAD2DEG)
+        + 1.914666471 * Math.sin(M)
+        + 0.019994643 * Math.sin(2*M))) * DEG2RAD;
+    const rMag = 1.000140612
+         - 0.016708617 * Math.cos(M)
+         - 0.000139589 * Math.cos(2*M);
+    const dec = ((23.439291 - 0.0130042 * century) % 360) * DEG2RAD;
+
+    // Mod variable
+    const sunVec = {
+        x: rMag * Math.cos(lamEc) * auDist,
+        y: rMag * Math.cos(dec) * Math.sin(lamEc) * auDist,
+        z: rMag * Math.sin(dec) * Math.sin(lamEc) * auDist,
+    };
+
+    // Convert mod => GCRF using Precession FK5
+    const zeta = (((0.017998 * century + 0.30188) * century + 2306.2181) * century) * sec2rad;
+    const theta = (((-0.041833 * century - 0.42665) * century + 2004.3109) * century) * sec2rad;
+    const z = (((0.018203 * century + 1.09468) * century + 2306.2181) * century) * sec2rad;
+
+    const coszeta = Math.cos(zeta);
+    const sinzeta = Math.sin(zeta);
+    const costheta = Math.cos(theta);
+    const sintheta = Math.sin(theta);
+    const cosz = Math.cos(z);
+    const sinz = Math.sin(z);
+
+    const mod2gcrf = [
+        [coszeta * costheta * cosz - sinzeta * sinz,
+            coszeta * costheta * sinz + sinzeta * cosz,
+            coszeta * sintheta],
+        [-sinzeta * costheta * cosz - coszeta * sinz,
+            -sinzeta * costheta * sinz + coszeta * cosz,
+            -sinzeta * sintheta],
+        [-sintheta * cosz, -sintheta * sinz, costheta],
+    ];
+
+    const sunPosGCRF = multiply(mod2gcrf, posToArray(sunVec)); // Sun Position in GCRF
+    const sunVecGCRF = {
+        x: sunPosGCRF[0],
+        y: sunPosGCRF[1],
+        z: sunPosGCRF[2],
+    };
+
+    // Convert Sun Pos from GCRF to J2000
+    const xi0 = -0.0166170 * arcsec2rad;
+    const eta0 = -0.0068192 * arcsec2rad;
+    const da0 = -0.01460 * arcsec2rad;
+
+    const gcrf2j2000 = [
+        [1.0 - 0.5*(-da0*-da0 + xi0*xi0), da0, -xi0],
+        [-da0, 1.0 - 0.5*(-da0*-da0 + eta0*eta0), -eta0],
+        [xi0, eta0, 1.0 - 0.5*(eta0*eta0 + xi0*xi0)],
+    ];
+
+    const sunVecJ2000 = multiply(gcrf2j2000, posToArray(sunVecGCRF)); // Sun Position in J2000
+    const sunPosVec = sunVecJ2000;
+
+    const sunPos = {
+        x: sunPosVec[0],
+        y: sunPosVec[1],
+        z: sunPosVec[2],
+    }; // create a vector object of the Sun's J2000 position vector
+
+    // perform algorithm 34 from Vallado's Fundamentals of Astrodynamics and Applications
+    if (dot(posToArray(satPos), posToArray(sunPos)) < 0) { // ensure sat is not in the direction of the Sun, which would mean it is opposite the shadow
+        const reverseSunVec = {
+            x: -sunPos.x,
+            y: -sunPos.y,
+            z: -sunPos.z,
+        }; // reverse the Sun vector to obtain the vector to the Umbra cone tip
+
+        // angle between sat position vector and shadow cone vector
+        const theta = Math.acos(
+            dot(posToArray(satPos), posToArray(reverseSunVec))
+            / (norm(posToArray(satPos)) * norm(posToArray(reverseSunVec))));
+
+        const satHorz = norm(posToArray(satPos)) * Math.cos(theta); // horizontal component of sat position
+        const satVert = norm(posToArray(satPos)) * Math.sin(theta); // vertical component of the sat position
+        const x = re / Math.sin(alphaPenumbra);
+        const penumbraVert = Math.tan(alphaPenumbra) * (x + satHorz); // vertical component of the penumbra
+        if (satVert <= penumbraVert) {
+            shadowType = "Penumbra"; // if vertical satellite component < vertical penumbra component, shadow is at least within penumbra
+            const y = re / Math.sin(alphaUmbra);
+            const umbraVert = Math.tan(alphaUmbra) * (y - satHorz); // vertical component of the umbra
+            if (satVert <= umbraVert) {
+                shadowType = "Umbra"; // if vertical satellite component < umbra vertical component, shadow is within umbra
+            }
+        }
+    }
+    return shadowType; // return the shadow type
+};
+
+module.exports.CONSTANTS = require("./constants.js");
+module.exports.REGIMES = REGIMES;
+module.exports.julianToGregorian = julianToGregorian;
+module.exports.calcRegime = calcRegime;
+module.exports.altToRegime = altToRegime;
+module.exports.cartesianToRIC = cartesianToRIC;
+module.exports.multiplyVector = multiplyVector;
+module.exports.dist = dist;
+module.exports.angleBetween3DCoords = angleBetween3DCoords;
+module.exports.prop = prop;
+module.exports.propGeodetic = propGeodetic;
+module.exports.getTRIC = getTRIC;
+module.exports.getSunDirection = getSunDirection;
+module.exports.getLonAndDrift = getLonAndDrift;
+module.exports.getRaanPrecession = getRaanPrecession;
+module.exports.checkTle = checkTle;
+module.exports.sunPosAt = sunPosAt;
+module.exports.raDecToGeodetic = RaDecToGeodetic;
+module.exports.getResiduals = GetResiduals;
+module.exports.raDecToAzEl = RaDecToAzEl;
+module.exports.azElToRaDec = AzElToRaDec;
+module.exports.getElsetUdlFromTle = GetElsetUdlFromTle;
+module.exports.satjs = require("satellite.js");
+module.exports.distGeodetic = distGeodetic;
+module.exports.getSemiMajorAxis = getSemiMajorAxis;
+module.exports.angleBetweenPlanes = angleBetweenPlanes;
+module.exports.propagate = propagate;
+module.exports.planeChangeDeltaV = planeChangeDeltaV;
+module.exports.planeChangePureInclinationDeltaV = planeChangePureInclinationDeltaV;
+module.exports.cartesianToKeplerian = cartesianToKeplerian;
+module.exports.keplerianToCartesian = keplerianToCartesian;
+module.exports.getLeoRpoData = getLeoRpoData;
+module.exports.getGeoRpoData = getGeoRpoData;
+module.exports.getGeoShadowZones = getGeoShadowZones;
+module.exports.getGeoLightIntervals = getGeoLightIntervals;
+module.exports.getEclipseStatus = getEclipseStatus;
+module.exports.estimateSlantRange = estimateSlantRange;
+module.exports.calculateNextApogeePerigeeTimes = calculateNextApogeePerigeeTimes;
+module.exports.calculateNextApogeePerigeeTimesWithPropagation
+    = calculateNextApogeePerigeeTimesWithPropagation;
+module.exports.calculateLeoPhaseDifference = calculateLeoPhaseDifference;
+module.exports.getLeoWaterfallData = getLeoWaterfallData;
+module.exports.lambertThomsonAlgorithm = lambertThomsonAlgorithm;
+module.exports.detectManeuverMinDv = detectManeuverMinDv;
+module.exports.getInterceptRendezvousMinDv = getInterceptRendezvousMinDv;
+
+module.exports.wrap360 = wrap360;
+module.exports.inWrappedRange = inWrappedRange;
+module.exports.subtractWrapped = subtractWrapped;
+module.exports.propagateRaan = propagateRaan;
+module.exports.getIncDiff = getIncDiff;
+module.exports.getRaanDiff = getRaanDiff;
+module.exports.getRaanClosureRate = getRaanClosureRate;
+module.exports.getRaanAlignTime = getRaanAlignTime;
+module.exports.getRaanAlignTimeStr = getRaanAlignTimeStr;
+module.exports.getRaanDetails = getRaanDetails;
+module.exports.isSatInShadow = isSatInShadow;
+
+module.exports.calculateGeoCrossingTimes = calculateGeoCrossingTimes;