@saber-usa/node-common 1.7.16 → 1.7.17

package/src/astro.js

@@ -72,6 +72,7 @@ const checkTle = (line1, line2) => {
             return satrec;
         }
     } catch (e) {
+        console.error(e);
         return false; // TLE invalid
     }
 };
@@ -188,6 +189,7 @@ const getRaanPrecession = (line1, line2) => {
         // result is in degrees per day
         return satrec.nodedot * 1440 * RAD2DEG;
     } catch (e) {
+        console.error(e);
         return 0;
     }
 };
@@ -244,6 +246,7 @@ const getLonAndDrift = (line1, line2, datetime) => {
             lonDriftDegreesPerDay: diff,
         };
     } catch (e) {
+        console.error(e);
         return {
             latitude: 0,
             longitude: 0,
@@ -382,7 +385,7 @@ const angleBetween3DCoords = (coord1, coord2, coord3) => {
     // 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 v1mag = Math.hypot(v1.x, v1.y, v1.z);
     const v1norm = {
         x: v1.x / v1mag,
         y: v1.y / v1mag,
@@ -390,7 +393,7 @@ const angleBetween3DCoords = (coord1, coord2, coord3) => {
     };
 
     // Normalize v2
-    const v2mag = Math.sqrt(v2.x * v2.x + v2.y * v2.y + v2.z * v2.z);
+    const v2mag = Math.hypot(v2.x, v2.y, v2.z);
     const v2norm = {
         x: v2.x / v2mag,
         y: v2.y / v2mag,
@@ -402,7 +405,7 @@ const angleBetween3DCoords = (coord1, coord2, coord3) => {
         = 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;
+    const angle = (Math.acos(dotProducts) * 180) / Math.PI;
 
     // Round result to 3 decimal points and return
     return Math.round(angle * 1000) / 1000;
@@ -463,17 +466,17 @@ const planeChangeDeltaV = (pv1, pv2) => {
 
     // 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);
+        1000);
     const v = multiply([pv1.velocity.x, pv1.velocity.y, pv1.velocity.z],
-        1000.0);
+        1000);
     const h1 = cross(r, v);
 
     const vMag = norm(v);
 
     const r2 = multiply([pv2.position.x, pv2.position.y, pv2.position.z],
-        1000.0);
+        1000);
     const v2 = multiply([pv2.velocity.x, pv2.velocity.y, pv2.velocity.z],
-        1000.0);
+        1000);
     const h2 = cross(r2, v2);
 
     // 2. Compute the mutual line of nodes vector
@@ -543,7 +546,7 @@ const planeChangeDeltaV = (pv1, pv2) => {
         r: 0,
         i: dvI,
         c: dvC,
-        mag: (dvAsc <= dvDesc) ? dvAsc: dvDesc,
+        mag: Math.min(dvAsc, dvDesc),
         node: (dvAsc <= dvDesc) ? "asc": "desc",
     };
 };
@@ -581,14 +584,14 @@ 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);
+    const r = multiply([pv1.position.x, pv1.position.y, pv1.position.z], 1000);
+    const v = multiply([pv1.velocity.x, pv1.velocity.y, pv1.velocity.z], 1000);
 
     // 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);
+    const r2 = multiply([pv2.position.x, pv2.position.y, pv2.position.z], 1000);
+    const v2 = multiply([pv2.velocity.x, pv2.velocity.y, pv2.velocity.z], 1000);
 
     // 2. Compute the Keplerian Elements of both satellites.
     const el = cartesianToKeplerian(r, v);
@@ -613,7 +616,7 @@ const planeChangePureInclinationDeltaV = (pv1, pv2)=>{
     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 fAtDesc = fAtAsc + 180;
     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);
@@ -644,16 +647,14 @@ const planeChangePureInclinationDeltaV = (pv1, pv2)=>{
             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 {
-        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));
-        }
+        // 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!
@@ -662,7 +663,7 @@ const planeChangePureInclinationDeltaV = (pv1, pv2)=>{
         r: 0,
         i: dvI,
         c: dvC,
-        mag: (dvAsc <= dvDesc) ? dvAsc: dvDesc,
+        mag: Math.min(dvAsc, dvDesc),
         node: (dvAsc <= dvDesc) ? "asc": "desc",
     };
 };
@@ -686,10 +687,7 @@ const angleBetweenPlanes = (pv1, pv2) => {
         [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 cross1mag = Math.hypot(cross1[0], cross1[1], cross1[2]);
 
     const cross1Norm = {
         x: cross1[0] / cross1mag,
@@ -701,10 +699,7 @@ const angleBetweenPlanes = (pv1, pv2) => {
         [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 cross2Mag = Math.hypot(cross2[0], cross2[1], cross2[2]);
 
     const cross2Norm = {
         x: cross2[0] / cross2Mag,
@@ -721,7 +716,7 @@ const angleBetweenPlanes = (pv1, pv2) => {
     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);
+    const angle = Math.acos(clamped) * (180 / Math.PI);
 
     // Round result to 3 decimal points and return
     return Math.round(angle * 1000) / 1000;
@@ -829,7 +824,7 @@ const doesLineSegmentSphereIntersect = (linePoint0, linePoint1, circleCenter, ci
         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 b = 2 * (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;
 
@@ -841,8 +836,8 @@ const doesLineSegmentSphereIntersect = (linePoint0, linePoint1, circleCenter, ci
     }
 
     const sqrtD = Math.sqrt(d);
-    const t1 = (-b - sqrtD) / (2.0 * a);
-    const t2 = (-b + sqrtD) / (2.0 * a);
+    const t1 = (-b - sqrtD) / (2 * a);
+    const t2 = (-b + sqrtD) / (2 * a);
 
     // Check if either intersection point lies within the line segment bounds [0,1]
     return (t1 >= 0 && t1 <= 1) || (t2 >= 0 && t2 <= 1);
@@ -946,13 +941,13 @@ const getSunDirection = (time) => {
     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)
+        - Math.floor((7 * (year + Math.floor((month + 9) / 12))) / 4)
+        + Math.floor((275 * month) / 9)
         + day
         + 1721013.5
-        + hour / 24.0
-        + minute / 1440.0
-        + seconds / 86400.0;
+        + hour / 24
+        + minute / 1440
+        + seconds / 86400;
     const UT1 = (JD - 2451545) / 36525;
     const longMSUN = 280.4606184 + 36000.77005361 * UT1;
     const mSUN = 357.5277233 + 35999.05034 * UT1;
@@ -1111,8 +1106,21 @@ const estimateSlantRange = (obTime, ra, dec, senLat, senLon, senAltKm) => {
         (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]);
+    const toRealRoot = (root) => {
+        if (typeof root === "number") {
+            return root;
+        }
+        if (root && typeof root.re === "number" && typeof root.im === "number") {
+            // Accept numerically real roots produced as Complex with negligible imaginary part.
+            if (Math.abs(root.im) <= 1e-12) {
+                return root.re;
+            }
+        }
+        throw new Error("Unable to compute GEO range from non-real polynomial root.");
+    };
+
+    const gamma1 = Math.acos(toRealRoot(roots[0]));
+    const gamma2 = Math.acos(toRealRoot(roots[1]));
 
     // Compute the sensor-satellite-earth angle
     const alpha = Math.sin(delta/a);
@@ -1244,8 +1252,7 @@ const GetResiduals = (obs, tle) => {
         return residuals; // Can't propegate TLE
     }
 
-    for (let i = 0; i < obs.length; i++) {
-        const ob = obs[i];
+    for (const ob of obs) {
         const obTimeUtc = dtStrtoJsDt(ob.ObTime);
         const dt
             = (obTimeUtc.getTime() - dtStrtoJsDt(epochDate).getTime())
@@ -1321,7 +1328,7 @@ const GetElsetUdlFromTle = (
         // 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") {
+        } else if (isUct === null || isUct === undefined) {
             // Do nothing, do not populate nor put null.
         } else {
             throw new Error("Input uct flag is not of type boolean.");
@@ -1353,7 +1360,7 @@ const GetElsetUdlFromTle = (
         const date = julianToGregorian(satrec.jdsatepoch);
         elset.epoch = date.toISOString();
 
-        elset.satNo = parseInt(satrec.satnum);
+        elset.satNo = Number.parseInt(satrec.satnum);
 
         // Eccentricity
         elset.eccentricity = satrec.ecco;
@@ -1361,16 +1368,16 @@ const GetElsetUdlFromTle = (
         // 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));
+        elset.meanMotion = Number.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;
+        elset.period = (1 / elset.meanMotion) * 24 * 60;
 
         // 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) {
+        if (elset.period < 225) {
             elset.ephemType = 0;
         } else {
             elset.ephemType = 3;
@@ -1401,7 +1408,7 @@ const GetElsetUdlFromTle = (
         elset.meanMotionDDot = satrec.nddot * (constants.xpdotp * 1440 * 1440);
 
         // Revolution number, parsed directly from line 2
-        elset.revNo = parseInt(l2.slice(63, 68));
+        elset.revNo = Number.parseInt(l2.slice(63, 68));
 
         // sma
         elset.semiMajorAxis = (
@@ -1418,6 +1425,7 @@ const GetElsetUdlFromTle = (
         removeNullUndefined(elset);
         return elset;
     } catch (e) {
+        console.error(e);
         // Return an empty object, which is guaranteed to be invalid
         // against UDL Elset_Ingested schema.
         return {};
@@ -1434,7 +1442,7 @@ const GetElsetUdlFromTle = (
  * 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 R = WGS84_EARTH_EQUATORIAL_RADIUS_KM * 1000; // metres
     const phi1 = lat1 * DEG2RAD; // φ1 in formula
     const phi2 = lat2 * DEG2RAD; // φ2 in formula
     const deltaPhi = (lat2 - lat1) * DEG2RAD; // Δφ in formula
@@ -1486,7 +1494,7 @@ const cartesianToKeplerian = (r, 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) {
+        if (Math.abs(1 - norm(e)) <= tol) {
             throw new Error("Parabolic orbit conversion is not supported.");
         }
 
@@ -1509,7 +1517,7 @@ const cartesianToKeplerian = (r, v) => {
 
         // CASE 1: Non-circular, Inclined Orbit
         if (norm(e) >= 1E-11 && i >= 1E-11 && i <= Math.PI - 1E-11) {
-            if (norm(n) === 0.0) {
+            if (norm(n) === 0) {
                 throw new Error(`Cannot convert from Cartesian to Keplerian,
                     line-of-nodes vector is a zero vector.`);
             }
@@ -1525,7 +1533,7 @@ const cartesianToKeplerian = (r, v) => {
         }
         // CASE 2: Non-circular, Equatorial Orbit
         if (norm(e) >= 1E-11 && (i < 1E-11 || i > Math.PI - 1E-11)) {
-            if (norm(e) === 0.0) {
+            if (norm(e) === 0) {
                 throw new Error(`Cannot convert from Cartesian to Keplerian,
                     eccentricity is zero.`);
             }
@@ -1537,9 +1545,9 @@ const cartesianToKeplerian = (r, v) => {
 
             // For GMT-4446 fix (LOJ: 2014.03.21)
             if (i > Math.PI - 1E-11) {
-                w *= -1.0;
+                w *= -1;
             }
-            if (w < 0.0) {
+            if (w < 0) {
                 w += 2 * Math.PI;
             }
 
@@ -1550,7 +1558,7 @@ const cartesianToKeplerian = (r, v) => {
         }
         // CASE 3: Circular, Inclined Orbit
         if (norm(e) < 1E-11 && i >= 1E-11 && i <= Math.PI - 1E-11) {
-            if (norm(n) === 0.0) {
+            if (norm(n) === 0) {
                 throw new Error(`Cannot convert from Cartesian to Keplerian, 
                     line-of-nodes vector is a zero vector.`);
             }
@@ -1573,14 +1581,14 @@ const cartesianToKeplerian = (r, v) => {
             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) {
+            if (i > Math.PI - 1E-11) {f *= -1;}
+            if (f < 0) {
                 f += 2 * Math.PI;
             }
         }
 
         return {
-            a: a /1000.0, // km
+            a: a /1000, // km
             e: norm(e),
             i: i * RAD2DEG, // deg
             raan: raan * RAD2DEG, // deg
@@ -1641,21 +1649,22 @@ const keplerianToCartesian = (elset, mu = 398600.4418) => {
         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,
+            x: 1000 * rad * (cosPerAnom * cosRaan - cosInc * sinPerAnom * sinRaan),
+            y: 1000 * rad * (cosPerAnom * sinRaan + cosInc * sinPerAnom * cosRaan),
+            z: 1000 * rad * sinPerAnom * sinInc,
         };
 
         const v = {
-            x: 1000.0 * (sqrtGravP * cosAnomPlusE * (-sinPer * cosRaan - cosInc * sinRaan * cosPer)
+            x: 1000 * (sqrtGravP * cosAnomPlusE * (-sinPer * cosRaan - cosInc * sinRaan * cosPer)
                - sqrtGravP * sinAnom * (cosPer * cosRaan - cosInc * sinRaan * sinPer)),
-            y: 1000.0 * (sqrtGravP * cosAnomPlusE * (-sinPer * sinRaan + cosInc * cosRaan * cosPer)
+            y: 1000 * (sqrtGravP * cosAnomPlusE * (-sinPer * sinRaan + cosInc * cosRaan * cosPer)
                - sqrtGravP * sinAnom * (cosPer * sinRaan + cosInc * cosRaan * sinPer)),
-            z: 1000.0 * (sqrtGravP * (cosAnomPlusE * sinInc * cosPer - sinAnom * sinInc * sinPer)),
+            z: 1000 * (sqrtGravP * (cosAnomPlusE * sinInc * cosPer - sinAnom * sinInc * sinPer)),
         };
 
         return {r, v};
     } catch (err) {
+        console.error(err);
         return {};
     }
 };
@@ -1663,8 +1672,8 @@ const keplerianToCartesian = (elset, mu = 398600.4418) => {
 const cartesianToElsetElements = (pv, epoch) => {
     // sma, eccentricity, inclination, raan, argp, trueAnomaly
     const kepl = cartesianToKeplerian(
-        multiply(posToArray(pv.position), 1000.0), // km to m
-        multiply(posToArray(pv.velocity), 1000.0), // km/s to m/s
+        multiply(posToArray(pv.position), 1000), // km to m
+        multiply(posToArray(pv.velocity), 1000), // km/s to m/s
     );
 
     const elset = {
@@ -1677,7 +1686,7 @@ const cartesianToElsetElements = (pv, epoch) => {
 
     // Mean motion in radians per second
     const mu = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
-    const meanMotion = Math.sqrt(mu/Math.pow((elset.SemiMajorAxis*1000.0), 3));
+    const meanMotion = Math.sqrt(mu/Math.pow((elset.SemiMajorAxis*1000), 3));
 
     elset.MeanMotion = meanMotion / (2*Math.PI) * 60 * 60 * 24; // rads/s to revs per day
 
@@ -1867,8 +1876,8 @@ const getGeoRpoData = (line1, line2, sats, startTime, endTime, lonTime) => {
         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,
+            (pLonAndDrift.longitude + 360) % 360
+            - (sLonAndDrift.longitude + 360) % 360,
         );
         // To ensure that the smallest "short-way" lon diff is considered
         aResult.lonDiff = Math.min(lonDiff, 360 - lonDiff);
@@ -1948,7 +1957,7 @@ const getGeoShadowZones = (time, accuracySecondsDeg=0.00416*100) => {
         // 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;
+            ints.at(-1).stopDeg = res[i-1].geolon;
 
             // Open a new zone
             ints.push({
@@ -1971,16 +1980,16 @@ const getGeoShadowZones = (time, accuracySecondsDeg=0.00416*100) => {
         };
     }
 
-    ints[0].startDeg = ints[ints.length-1].startDeg;
+    ints[0].startDeg = ints.at(-1).startDeg;
     ints.pop();
 
     if (
         ints.filter((x)=>x.ecl === "UMBRA").length===0
-        && ints.filter((x)=>x.ecl === "PENUMBRA").length>0) {
+        && ints.some((x)=>x.ecl === "PENUMBRA")) {
         // 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];
+        const penumbraInt = ints.find((x)=>x.ecl === "PENUMBRA");
         return {
             penStartWestLon: wrapToRange(penumbraInt.startDeg, 0, 360),
             penStartEastLon: wrapToRange(penumbraInt.stopDeg, 0, 360),
@@ -1988,7 +1997,7 @@ const getGeoShadowZones = (time, accuracySecondsDeg=0.00416*100) => {
     } else {
         // If sun, umbra, penumbra intervals exist
 
-        const umbra = ints.filter((x)=>x.ecl === "UMBRA")[0];
+        const umbra = ints.find((x)=>x.ecl === "UMBRA");
 
         const umbraStart360 = wrapToRange(umbra.startDeg, 0, 360);
         const umbraStop360 = wrapToRange(umbra.stopDeg, 0, 360);
@@ -2019,8 +2028,8 @@ const getGeoShadowZones = (time, accuracySecondsDeg=0.00416*100) => {
  * @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);
+const getGeoLightIntervals = (time, durationSeconds=86400, accuracySeconds=10) => {
+    const endTime = new Date(time.getTime() + 1000*durationSeconds);
     // Create an artificial satellite on GEO
     const satrec = twoline2satrec(
         "1 00000U 00000A   24079.98445361 -.00000000  00000-0 -00000-0 0 00000",
@@ -2048,7 +2057,7 @@ const getGeoLightIntervals = (time, durationSeconds=86400, accuracySeconds=10.0)
     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;
+            ints.at(-1).end = res[i-1].t;
             // Create a new open interval
             ints.push({
                 ecl: res[i].ecl,
@@ -2057,7 +2066,7 @@ const getGeoLightIntervals = (time, durationSeconds=86400, accuracySeconds=10.0)
         }
     }
     // Close the last interval
-    ints[ints.length-1].end = res[res.length-1].t;
+    ints.at(-1).end = res.at(-1).t;
 
     return {
         ints: ints,
@@ -2174,9 +2183,9 @@ const calculateGeoCrossingTimes = async (propagateBetween, start, end, stepMs =
 const calculateNextApogeePerigeeTimesWithPropagation
     = async (pv, propagateTo, time, findApogee=true, findPerigee=true) => {
         const r = multiply([pv.position.x, pv.position.y, pv.position.z],
-            1000.0);
+            1000);
         const v = multiply([pv.velocity.x, pv.velocity.y, pv.velocity.z],
-            1000.0);
+            1000);
         const el = cartesianToKeplerian(r, v);
 
         // Compute Eccentric Anomaly from True Anomaly and Eccentricity
@@ -2187,7 +2196,7 @@ const calculateNextApogeePerigeeTimesWithPropagation
 
         // 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));
+        const n = Math.sqrt(mu/Math.pow((el.a*1000), 3));
 
         // Orbit Period
         const periodSecs = 2*Math.PI/n;
@@ -2204,7 +2213,7 @@ const calculateNextApogeePerigeeTimesWithPropagation
 
         // For next apoapsis, we check the true anomaly of the reference date
         let timeToNextApoapsisSecs;
-        if (el.f >= 180.0) {
+        if (el.f >= 180) {
         // Satellite is past the apoapsis and before the next periapsis
             timeToNextApoapsisSecs = timeToNextPeriapsisSecs + periodSecs/2;
         } else {
@@ -2274,7 +2283,7 @@ const calculateNextApogeePerigeeTimes
         const satrec = twoline2satrec(line1, line2);
         const propagateTo = (t) => propagate(satrec, new Date(t));
         const pv = propagateTo(time);
-        return await calculateNextApogeePerigeeTimesWithPropagation(
+        return calculateNextApogeePerigeeTimesWithPropagation(
             pv, propagateTo, time, findApogee, findPerigee,
         );
     };
@@ -2336,8 +2345,8 @@ const computePhaseDiff = (pSatRec, tSatRec, time) => {
  */
 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
+    const meanMotion = Number.parseFloat(line2.slice(52, 63)); // revs per day
+    const period = (1 / meanMotion) * 24 * 60; // period in minutes
     return period;
 };
 
@@ -2444,8 +2453,8 @@ const getLeoWaterfallData = (elsets, startTime, endTime, stepMs = 10000) => {
             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
+                    multiply(posToArray(point.p), 1000), // km to m
+                    multiply(posToArray(point.v), 1000), // km/s to m/s
                 );
                 return {
                     ...point,
@@ -2539,9 +2548,9 @@ const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) =>{
     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;
+    const sat1Period = Number.parseInt((120*Math.PI)/(sat1Tle.no));
+    const sat2Period = Number.parseInt((120*Math.PI)/(sat2Tle.no));
+    const periodS = Math.max(sat1Period, sat2Period);
 
     for (let rev=0; rev < 10; rev++) {
         for (let dt=100; dt<=periodS; dt+=100) { // Seconds
@@ -2565,7 +2574,7 @@ const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) =>{
             }
 
             const currentVector = v1Mag <= vH1Mag ? deltaV1 : deltaVH1;
-            const currentNorm = v1Mag <= vH1Mag ? v1Mag : vH1Mag;
+            const currentNorm = Math.min(v1Mag, vH1Mag);
 
             if (currentNorm < minDv) {
                 revNum = rev;
@@ -2590,7 +2599,7 @@ const getInterceptRendezvousMinDv = (sat1Tle, sat2Tle, startTime) =>{
             }
             // 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)) {
+            if (Number.isNaN(v1Mag) || Number.isNaN(vH1Mag)) {
                 break;
             }
         }
@@ -2718,7 +2727,6 @@ const detectManeuverMinDv = (initialTLE, finalTLE) => {
 
         // 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);
@@ -2735,16 +2743,15 @@ const detectManeuverMinDv = (initialTLE, finalTLE) => {
             }
 
             const currentVector = v1Mag <= vH1Mag ? deltaV1 : deltaVH1;
-            const currentNorm = v1Mag <= vH1Mag ? v1Mag : vH1Mag;
+            const currentNorm = Math.min(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)) {
+            if (Number.isNaN(v1Mag) || Number.isNaN(vH1Mag)) {
                 break;
             }
         }
@@ -2799,8 +2806,8 @@ const lambertThomsonAlgorithm
 
     // ----- Lines 2-5 -----
     let A = dot(r1, r2) / (r1Mag * r2Mag);
-    if (A > 1.0) {A = 1.0;}
-    if (A < -1.0) {A = -1.0;}
+    if (A > 1) {A = 1;}
+    if (A < -1) {A = -1;}
     let theta = Math.acos(A); // transfer angle
 
     // ----- Lines 6-8: Determine transfer direction -----
@@ -2813,26 +2820,26 @@ const lambertThomsonAlgorithm
     // ----- 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));
+    const lambda = (1 / s) * Math.sqrt(r1Mag * r2Mag) * Math.cos(theta / 2);
+    const L = Math.pow((1 - lambda) / (1 + lambda), 2);
+    const mVal = 8 * mu * t * t / (Math.pow(s, 3) * Math.pow(1 + lambda, 6));
 
     // ----- Line 14: Initial x -----
     let x = (N > 0) ? (1 + 4 * L) : L;
-    let xdiff = 1.0;
-    let y = 0.0;
+    let xdiff = 1;
+    let y = 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 numerator = Math.pow(L + x, 2);
             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);
+            const term1 = 3 * Math.pow(1 + x, 2) * commonTerm - (3 + 5 * x);
             h1 = (numerator / denominator) * term1;
 
             // ----- Line 19: h2 (Loechler p.31 (4.4)) -----
@@ -2840,7 +2847,7 @@ const lambertThomsonAlgorithm
             h2 = mVal / denominator * term2;
         } else {
             // ----- Lines 20-36: Single-rev branch -----
-            const eta = x / Math.pow(Math.sqrt(1 + x) + 1, 2.0);
+            const eta = x / Math.pow(Math.sqrt(1 + x) + 1, 2);
             let bn = 3; let dn = 1; let un = 8 * (Math.sqrt(1 + x) + 1) / bn;
             let xi = un;
             let i = 1;
@@ -2862,16 +2869,16 @@ const lambertThomsonAlgorithm
                 un = up * (dn - 1);
                 xi += un;
             }
-            h1 = (Math.pow(L + x, 2.0) * (1 + 3 * x + xi))
+            h1 = (Math.pow(L + x, 2) * (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 BVal = 27 * h2 / (4 * Math.pow(1 + h1, 3));
+        const uVal = BVal / (2 * (Math.sqrt(1 + BVal) + 1));
 
-        const bn2 = 1.0; let dn2 = 1.0; let un2 = 1.0 / 3.0;
+        const bn2 = 1; let dn2 = 1; let un2 = 1 / 3;
         let K = un2;
         let n = 0;
         let evenflag = 1;
@@ -2879,22 +2886,22 @@ const lambertThomsonAlgorithm
             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));
+                an = -2 * 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);
+                an = -2 * uVal * (3 * n + 1) * (6 * n - 1) / 9 / (4 * n - 1) / (4 * n + 1);
                 evenflag = 1;
             }
-            dn2 = 1.0 / (1 - an * dp / bp / bn2);
-            un2 = up * (dn2 - 1.0);
+            dn2 = 1 / (1 - an * dp / bp / bn2);
+            un2 = up * (dn2 - 1);
             K += un2;
         }
 
         // ----- Line 50: Compute y -----
-        y = (1 + h1) / 3.0 * (2 + Math.sqrt(1 + BVal) / (1.0 + 2.0 * uVal * K * K));
+        y = (1 + h1) / 3 * (2 + Math.sqrt(1 + BVal) / (1 + 2 * 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;
+        const xnew = Math.sqrt(Math.pow((1 - L)/2, 2) + mVal/(y*y)) - (1 + L)/2;
         // ----- Line 52: Compute difference -----
         xdiff = Math.abs(xnew - x);
         // ----- Line 53: Update x -----
@@ -2902,14 +2909,14 @@ const lambertThomsonAlgorithm
     }
 
     // ----- 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 pVal = 2 * r1Mag * r2Mag * y * y * Math.pow(1 + x, 2)
+        * Math.pow(Math.sin(theta / 2), 2)
+                   / (mVal * s * Math.pow(1 + lambda, 2));
     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)),
+        (Math.pow(eps, 2) + 4 * r2Mag / r1Mag
+        * Math.pow(Math.sin(theta / 2), 2) * Math.pow((L - x) / (L + x), 2))
+        / (Math.pow(eps, 2) + (4 * r2Mag / r1Mag) * Math.pow(Math.sin(theta / 2), 2)),
     );
 
     // ----- Line 58: Call hodograph velocity algorithm -----
@@ -2922,7 +2929,7 @@ const lambertThomsonAlgorithm
     if (N > 0) {
         // Line 61:
         x = 1e-20;
-        xdiff = 1.0;
+        xdiff = 1;
         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));
@@ -2931,18 +2938,18 @@ const lambertThomsonAlgorithm
                         * ((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));
+            const BHe = 27 * h2He / (4 * Math.pow(Math.sqrt(x) * (1 + h1He), 3));
             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)));
+                F = 2 * Math.cos(1 / 3 * 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);
+                const AHe = Math.pow(Math.sqrt(BHe) + Math.sqrt(BHe + 1), 1 / 3);
                 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 73: Compute y for high-energy solution (Loechler p.37 (5.1)) -----
+            const yHe = (2 / 3) * 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));
@@ -2950,10 +2957,10 @@ const lambertThomsonAlgorithm
             x = xnewHe;
         }
         // ----- Line 78: Compute semi-major axis a -----
-        const eVal = s * Math.pow(1 + lambda, 2.0) * (1 + x) * (L + x) / (8 * x);
+        const eVal = s * Math.pow(1 + lambda, 2) * (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));
+        const pHe = 2 * r1Mag * r2Mag * Math.pow(Math.sin(theta / 2), 2) * (1 + x)
+                      / (s * Math.pow(1 + lambda, 2) * (L + x));
         // ----- Line 80: Compute eccentricity for high-energy solution -----
         const eHe = Math.sqrt(1 - pHe / eVal);
         // ----- Line 81: Compute high-energy velocities -----
@@ -2979,19 +2986,19 @@ const lambertThomsonAlgorithm
  */
 const hodographVelocityAlgorithm = (r1, r2, t, v1Minus, theta, p, e, mu) => {
     // Line 2: Define L180 (in meters)
-    const L180 = 1.0;
+    const L180 = 1;
 
     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);
+    const eVal = mu * (1 / r1Mag - 1 / p);
 
     // Line 4: B = (mu*e/p)^2 - A^2
-    const BVal = Math.pow(mu * e / p, 2.0) - (eVal * eVal);
+    const BVal = Math.pow(mu * e / p, 2) - (eVal * eVal);
 
     // Line 5: if B <= 0 then x1 = 0 else x1 = -sqrt(B)
-    let x1 = (BVal <= 0) ? 0.0 : -Math.sqrt(BVal);
+    let x1 = (BVal <= 0) ? 0 : -Math.sqrt(BVal);
 
     let nHat; // unit normal vector
 
@@ -3003,9 +3010,9 @@ const hodographVelocityAlgorithm = (r1, r2, t, v1Minus, theta, p, e, mu) => {
         nHat = [nHat.x, nHat.y, nHat.z];
 
         // Line 8: If the orbit is elliptical (e < 1)
-        if (e < 1.0) {
+        if (e < 1) {
             // 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)));
+            const P = 2 * Math.PI * Math.sqrt(Math.pow(p, 3) / (mu * Math.pow(1 - e * e, 3)));
             // Line 10: If (t mod P) > (P/2) then reverse x1
             const tMod = t % P;
             if (tMod > P / 2) {
@@ -3182,7 +3189,7 @@ const isSatInShadow = (epoch, satPos) => {
     const century = _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 lamM = (280.46 + 36000.771*century % 360) * DEG2RAD;
     const M = (357.5291092 + 35999.05034*century % 360) * DEG2RAD;
     const lamEc = (((lamM * RAD2DEG)
         + 1.914666471 * Math.sin(M)
@@ -3229,14 +3236,14 @@ const isSatInShadow = (epoch, satPos) => {
     };
 
     // Convert Sun Pos from GCRF to J2000
-    const xi0 = -0.0166170 * arcsec2rad;
+    const xi0 = -0.016617 * arcsec2rad;
     const eta0 = -0.0068192 * arcsec2rad;
-    const da0 = -0.01460 * arcsec2rad;
+    const da0 = -0.0146 * 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)],
+        [1 - 0.5*(-da0*-da0 + xi0*xi0), da0, -xi0],
+        [-da0, 1 - 0.5*(-da0*-da0 + eta0*eta0), -eta0],
+        [xi0, eta0, 1 - 0.5*(eta0*eta0 + xi0*xi0)],
     ];
 
     const sunVecJ2000 = multiply(gcrf2j2000, posToArray(sunVecGCRF)); // Sun Position in J2000
@@ -3277,15 +3284,26 @@ const isSatInShadow = (epoch, satPos) => {
     return shadowType; // return the shadow type
 };
 
-import * as CONSTANTS from "./constants.js";
-export {CONSTANTS};
-export {REGIMES,
-    julianToGregorian,
+export * as CONSTANTS from "./constants.js";
+export {REGIMES} from "./constants.js";
+export {julianToGregorian, multiplyVector, dist} from "./utils.js";
+export {
+    twoline2satrec,
+    sgp4,
+    gstime,
+    eciToGeodetic,
+    eciToEcf,
+    ecfToLookAngles,
+    degreesToRadians,
+    radiansToDegrees,
+    degreesLong,
+    degreesLat,
+    propagate,
+} from "satellite.js";
+export {
     calcRegime,
     altToRegime,
     cartesianToRIC,
-    multiplyVector,
-    dist,
     angleBetween3DCoords,
     prop,
     propGeodetic,
@@ -3298,7 +3316,6 @@ export {REGIMES,
     distGeodetic,
     getSemiMajorAxis,
     angleBetweenPlanes,
-    propagate,
     planeChangeDeltaV,
     planeChangePureInclinationDeltaV,
     cartesianToKeplerian,
@@ -3330,21 +3347,10 @@ export {REGIMES,
     isSatInShadow,
     calculateGeoCrossingTimes,
     tryPropagateSatrec,
-    twoline2satrec,
-    sgp4,
-    gstime,
-    eciToGeodetic,
-    eciToEcf,
-    ecfToLookAngles,
-    degreesToRadians,
-    radiansToDegrees,
-    degreesLong,
-    degreesLat,
 };
 export const raDecToGeodetic = RaDecToGeodetic;
 export const getResiduals = GetResiduals;
 export const raDecToAzEl = RaDecToAzEl;
 export const azElToRaDec = AzElToRaDec;
 export const getElsetUdlFromTle = GetElsetUdlFromTle;
-import * as satjs from "satellite.js";
-export {satjs};
+export * as satjs from "satellite.js";