ootk 6.0.0-rc.4 → 6.0.0

package/dist/sgp4/sgp4.js

@@ -1,3170 +0,0 @@
-/**
- * @author Theodore Kruczek
- * @description Orbital Object ToolKit (ootk) is a collection of tools for working
- * with satellites and other orbital objects.
- * @license AGPL-3.0-or-later
- * @copyright (c) 2025 Kruczek Labs LLC
- *
- * This class was ported from the python-sgp4 library by Brandon Rhodes. That library
- * is licensed under the MIT license and he maintains the copyright for that work.
- *
- * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Affero General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License along with
- * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
- */
-// NOTE: This file is meant to maintain as much of the original format as possible.
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-/* eslint-disable max-lines-per-function */
-/* eslint-disable max-lines */
-/* eslint-disable @typescript-eslint/no-loss-of-precision */
-import { Sgp4OpsMode } from '../enums/Sgp4OpsMode';
-import { Tle } from '../main';
-import { DEG2RAD, PI, TAU, temp4, x2o3 } from '../utils/constants';
-import { Sgp4ErrorCode } from './sgp4-error';
-export var Sgp4GravConstants;
-(function (Sgp4GravConstants) {
-    Sgp4GravConstants["wgs72old"] = "wgs72old";
-    Sgp4GravConstants["wgs72"] = "wgs72";
-    Sgp4GravConstants["wgs84"] = "wgs84";
-})(Sgp4GravConstants || (Sgp4GravConstants = {}));
-export var Sgp4Methods;
-(function (Sgp4Methods) {
-    Sgp4Methods["NEAR_EARTH"] = "n";
-    Sgp4Methods["DEEP_SPACE"] = "d";
-})(Sgp4Methods || (Sgp4Methods = {}));
-/** Ootk -- Some variables imported from outside the class at the top */
-const fasx2 = 0.13130908;
-const fasx4 = 2.8843198;
-const fasx6 = 0.37448087;
-const g22 = 5.7686396;
-const g32 = 0.95240898;
-const g44 = 1.8014998;
-const g52 = 1.050833;
-const g54 = 4.4108898;
-const rptim = 4.37526908801129966e-3; // Equates to 7.29211514668855e-5 rad/sec
-const stepp = 720.0;
-const stepn = -720.0;
-const step2 = 259200.0;
-/*
- *     ----------------------------------------------------------------
- *
- *                               sgp4unit.cpp
- *
- *    this file contains the sgp4 procedures for analytical propagation
- *    of a satellite. the code was originally released in the 1980 and 1986
- *    spacetrack papers. a detailed discussion of the theory and history
- *    may be found in the 2006 aiaa paper by vallado, crawford, hujsak,
- *    and kelso.
- *
- *                            companion code for
- *               fundamentals of astrodynamics and applications
- *                                    2013
- *                              by david vallado
- *
- *     (w) 719-573-2600, email dvallado@agi.com, davallado@gmail.com
- *
- *    current :
- *              12 mar 20  david vallado
- *                           chg satnum to string for alpha 5 or 9-digit
- *    changes :
- *               7 dec 15  david vallado
- *                           fix jd, jdfrac
- *               3 nov 14  david vallado
- *                           update to msvs2013 c++
- *              30 aug 10  david vallado
- *                           delete unused variables in initl
- *                           replace pow integer 2, 3 with multiplies for speed
- *               3 nov 08  david vallado
- *                           put returns in for error codes
- *              29 sep 08  david vallado
- *                           fix atime for faster operation in dspace
- *                           add operationmode for afspc (a) or improved (i)
- *                           performance mode
- *              16 jun 08  david vallado
- *                           update small eccentricity check
- *              16 nov 07  david vallado
- *                           misc fixes for better compliance
- *              20 apr 07  david vallado
- *                           misc fixes for constants
- *              11 aug 06  david vallado
- *                           chg lyddane choice back to strn3, constants, misc doc
- *              15 dec 05  david vallado
- *                           misc fixes
- *              26 jul 05  david vallado
- *                           fixes for paper
- *                           note that each fix is preceded by a
- *                           comment with "sgp4fix" and an explanation of
- *                           what was changed
- *              10 aug 04  david vallado
- *                           2nd printing baseline working
- *              14 may 01  david vallado
- *                           2nd edition baseline
- *                     80  norad
- *                           original baseline
- *       ----------------------------------------------------------------
- */
-export class Sgp4 {
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           procedure angle_SGP4
-     *
-     *  this procedure calculates the angle between two vectors.  the output is
-     *    set to 999999.1 to indicate an undefined value.  be sure to check for
-     *    this at the output phase.
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    vec1        - vector number 1
-     *    vec2        - vector number 2
-     *
-     *  outputs       :
-     *    theta       - angle between the two vectors  -pi to pi
-     *
-     *  locals        :
-     *    temp        - temporary real variable
-     *
-     *  coupling      :
-     *    dot           dot product of two vectors
-     * ---------------------------------------------------------------------------
-     */
-    static angle_(vec1, vec2) {
-        const small = 0.00000001;
-        const unknown = 999999.1; /** Ootk -- original 'undefined' is protected in JS */
-        const magv1 = Sgp4.mag_(vec1);
-        const magv2 = Sgp4.mag_(vec2);
-        const magnitudeProduct = magv1 * magv2;
-        if (magnitudeProduct > small * small) {
-            let temp = Sgp4.dot_(vec1, vec2) / (magnitudeProduct);
-            // Clamp to [-1, 1] to avoid NaN from floating point errors
-            if (temp > 1.0) {
-                temp = 1.0;
-            }
-            if (temp < -1.0) {
-                temp = -1.0;
-            }
-            return Math.acos(temp);
-        }
-        return unknown;
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function asinh_SGP4
-     *
-     *  this function evaluates the inverse hyperbolic sine function.
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    xval        - angle value                                  any real
-     *
-     *  outputs       :
-     *    arcsinh     - result                                       any real
-     *
-     *  locals        :
-     *    none.
-     *
-     *  coupling      :
-     *    none.
-     * ---------------------------------------------------------------------------
-     */
-    static asinh_(xval) {
-        return Math.log(xval + Math.sqrt(xval * xval + 1.0));
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function twoline2rv
-     *
-     *  this function converts the two line element set character string data to
-     *    variables and initializes the sgp4 variables. several intermediate varaibles
-     *    and quantities are determined. note that the result is a structure so multiple
-     *    satellites can be processed simultaneously without having to reinitialize. the
-     *    verification mode is an important option that permits quick checks of any
-     *    changes to the underlying technical theory. this option works using a
-     *    modified tle file in which the start, stop, and delta time values are
-     *    included at the end of the second line of data. this only works with the
-     *    verification mode. the catalog mode simply propagates from -1440 to 1440 min
-     *    from epoch and is useful when performing entire catalog runs.
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs        :
-     *    longstr1    - first line of the tle
-     *    longstr2    - second line of the tle
-     *    typerun     - type of run                    verification 'v', catalog 'c',
-     *                                                 manual 'm'
-     *    typeinput   - type of manual input           mfe 'm', epoch 'e', dayofyr 'd'
-     *    opsmode     - mode of operation afspc or improved 'a', 'i'
-     *    whichconst  - which set of constants to use  72, 84
-     *
-     *  outputs       :
-     *    satrec      - structure containing all the sgp4 satellite information
-     *
-     *  coupling      :
-     *    getgravconst-
-     *    days2mdhms  - conversion of days to month, day, hour, minute, second
-     *    jday        - convert day month year hour minute second into julian date
-     *    sgp4init    - initialize the sgp4 variables
-     *
-     *  references    :
-     *    norad spacetrack report #3
-     *    vallado, crawford, hujsak, kelso  2006
-     * ---------------------------------------------------------------------------
-     */
-    static createSatrec(tleLine1, tleLine2, whichconst = Sgp4GravConstants.wgs72, opsmode = Sgp4OpsMode.IMPROVED) {
-        let year = 0;
-        const satrec = {
-            error: Sgp4ErrorCode.NO_ERROR,
-        };
-        /*
-         * Sgp4fix no longer needed
-         * getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-         */
-        const xpdotp = 1440.0 / (2.0 * PI); // 229.1831180523293;
-        satrec.satnum = tleLine1.substring(2, 7);
-        satrec.epochyr = parseInt(tleLine1.substring(18, 20));
-        satrec.epochdays = parseFloat(tleLine1.substring(20, 32));
-        satrec.ndot = parseFloat(tleLine1.substring(33, 43));
-        satrec.nddot = parseFloat(`${tleLine1.substring(44, 45)}.${tleLine1.substring(45, 50)}E${tleLine1.substring(50, 52)}`);
-        satrec.bstar = parseFloat(`${tleLine1.substring(53, 54)}.${tleLine1.substring(54, 59)}E${tleLine1.substring(59, 61)}`);
-        satrec.inclo = parseFloat(tleLine2.substring(8, 16));
-        satrec.nodeo = parseFloat(tleLine2.substring(17, 25));
-        satrec.ecco = parseFloat(`.${tleLine2.substring(26, 33)}`);
-        satrec.argpo = parseFloat(tleLine2.substring(34, 42));
-        satrec.mo = parseFloat(tleLine2.substring(43, 51));
-        satrec.no = parseFloat(tleLine2.substring(52, 63));
-        // ---- find no, ndot, nddot ----
-        satrec.no /= xpdotp; //   Rad/min
-        /** Ootk -- nexp and ibexp are calculated above using template literals */
-        /*
-         * Satrec.nddot = satrec.nddot * Math.pow(10.0, nexp);
-         * satrec.bstar = satrec.bstar * Math.pow(10.0, ibexp);
-         */
-        /*
-         * ---- convert to sgp4 units ----
-         * satrec.a = (satrec.no * tumin) ** (-2.0 / 3.0);
-         */
-        /** Ootk -- Not sure why the following two lines are added. 1st and 2nd derivatives aren't even used anymore */
-        /*
-         * Satrec.ndot /= xpdotp * 1440.0; // ? * minperday
-         * satrec.nddot /= xpdotp * 1440.0 * 1440;
-         */
-        // ---- find standard orbital elements ----
-        satrec.inclo *= DEG2RAD;
-        satrec.nodeo *= DEG2RAD;
-        satrec.argpo *= DEG2RAD;
-        satrec.mo *= DEG2RAD;
-        /*
-         * Sgp4fix not needed here
-         * satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
-         * satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
-         */
-        /*
-         * ----------------------------------------------------------------
-         * find sgp4epoch time of element set
-         * remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
-         * and minutes from the epoch (time)
-         * ----------------------------------------------------------------
-         */
-        /*
-         * ---------------- temp fix for years from 1957-2056 -------------------
-         * --------- correct fix will occur when year is 4-digit in tle ---------
-         */
-        if (satrec.epochyr < 57) {
-            year = satrec.epochyr + 2000;
-        }
-        else {
-            year = satrec.epochyr + 1900;
-        }
-        const { mon, day, hr, min, sec } = Sgp4.days2mdhms(year, satrec.epochdays);
-        const jdayRes = Sgp4.jday(year, mon, day, hr, min, sec);
-        satrec.jdsatepoch = jdayRes.jd + jdayRes.jdFrac;
-        //  ---------------- initialize the orbit at sgp4epoch -------------------
-        Sgp4.sgp4init_(satrec, {
-            whichconst,
-            opsmode,
-            satn: satrec.satnum,
-            epoch: satrec.jdsatepoch - 2433281.5,
-            xbstar: satrec.bstar,
-            xecco: satrec.ecco,
-            xargpo: satrec.argpo,
-            xinclo: satrec.inclo,
-            xndot: satrec.ndot,
-            xnddot: satrec.nddot,
-            xmo: satrec.mo,
-            xno: satrec.no,
-            xnodeo: satrec.nodeo,
-        });
-        return satrec;
-    }
-    static createSatrecFromOmm(omm, whichconst = Sgp4GravConstants.wgs72, opsmode = Sgp4OpsMode.IMPROVED) {
-        let year = 0;
-        const satrec = {
-            error: Sgp4ErrorCode.NO_ERROR,
-        };
-        const xpdotp = 1440.0 / (2.0 * PI); // 229.1831180523293;
-        satrec.error = Sgp4ErrorCode.NO_ERROR;
-        satrec.satnum = omm.NORAD_CAT_ID;
-        satrec.epochyr = parseInt(omm.epoch.year.toString().slice(-2));
-        satrec.epochdays = omm.epoch.doy;
-        satrec.ndot = parseFloat(omm.MEAN_MOTION_DOT);
-        satrec.nddot = parseFloat(omm.MEAN_MOTION_DDOT);
-        satrec.bstar = parseFloat(omm.BSTAR);
-        satrec.inclo = parseFloat(omm.INCLINATION);
-        satrec.nodeo = parseFloat(omm.RA_OF_ASC_NODE);
-        satrec.ecco = parseFloat(omm.ECCENTRICITY);
-        satrec.argpo = parseFloat(omm.ARG_OF_PERICENTER);
-        satrec.mo = parseFloat(omm.MEAN_ANOMALY);
-        satrec.no = parseFloat(omm.MEAN_MOTION);
-        // ---- find no, ndot, nddot ----
-        satrec.no /= xpdotp; //   Rad/min
-        /** Ootk -- nexp and ibexp are calculated above using template literals */
-        /*
-         * Satrec.nddot = satrec.nddot * Math.pow(10.0, nexp);
-         * satrec.bstar = satrec.bstar * Math.pow(10.0, ibexp);
-         */
-        /*
-         * ---- convert to sgp4 units ----
-         * satrec.a = (satrec.no * tumin) ** (-2.0 / 3.0);
-         */
-        /** Ootk -- Not sure why the following two lines are added. 1st and 2nd derivatives aren't even used anymore */
-        /*
-         * Satrec.ndot /= xpdotp * 1440.0; // ? * minperday
-         * satrec.nddot /= xpdotp * 1440.0 * 1440;
-         */
-        // ---- find standard orbital elements ----
-        satrec.inclo *= DEG2RAD;
-        satrec.nodeo *= DEG2RAD;
-        satrec.argpo *= DEG2RAD;
-        satrec.mo *= DEG2RAD;
-        /*
-         * Sgp4fix not needed here
-         * satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
-         * satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
-         */
-        /*
-         * ----------------------------------------------------------------
-         * find sgp4epoch time of element set
-         * remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
-         * and minutes from the epoch (time)
-         * ----------------------------------------------------------------
-         */
-        /*
-         * ---------------- temp fix for years from 1957-2056 -------------------
-         * --------- correct fix will occur when year is 4-digit in tle ---------
-         */
-        if (satrec.epochyr < 57) {
-            year = satrec.epochyr + 2000;
-        }
-        else {
-            year = satrec.epochyr + 1900;
-        }
-        const { mon, day, hr, min, sec } = Sgp4.days2mdhms(year, satrec.epochdays);
-        const jdayRes = Sgp4.jday(year, mon, day, hr, min, sec);
-        satrec.jdsatepoch = jdayRes.jd + jdayRes.jdFrac;
-        //  ---------------- initialize the orbit at sgp4epoch -------------------
-        Sgp4.sgp4init_(satrec, {
-            whichconst,
-            opsmode,
-            satn: satrec.satnum,
-            epoch: satrec.jdsatepoch - 2433281.5,
-            xbstar: satrec.bstar,
-            xecco: satrec.ecco,
-            xargpo: satrec.argpo,
-            xinclo: satrec.inclo,
-            xndot: satrec.ndot,
-            xnddot: satrec.nddot,
-            xmo: satrec.mo,
-            xno: satrec.no,
-            xnodeo: satrec.nodeo,
-        });
-        return satrec;
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           procedure cross_SGP4
-     *
-     *  this procedure crosses two vectors.
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    vec1        - vector number 1
-     *    vec2        - vector number 2
-     *
-     *  outputs       :
-     *    outvec      - vector result of a x b
-     *
-     *  locals        :
-     *    none.
-     *
-     *  coupling      :
-     *    mag           magnitude of a vector
-     * ----------------------------------------------------------------------------
-     */
-    static cross_(vec1, vec2) {
-        return [
-            vec1[1] * vec2[2] - vec1[2] * vec2[1],
-            vec1[2] * vec2[0] - vec1[0] * vec2[2],
-            vec1[0] * vec2[1] - vec1[1] * vec2[0],
-        ];
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           procedure days2mdhms
-     *
-     *  this procedure converts the day of the year, days, to the equivalent month
-     *    day, hour, minute and second.
-     *
-     *  algorithm     : set up array for the number of days per month
-     *                  find leap year - use 1900 because 2000 is a leap year
-     *                  loop through a temp value while the value is < the days
-     *                  perform int conversions to the correct day and month
-     *                  convert remainder into h m s using type conversions
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    year        - year                           1900 .. 2100
-     *    days        - julian day of the year         0.0  .. 366.0
-     *
-     *  outputs       :
-     *    mon         - month                          1 .. 12
-     *    day         - day                            1 .. 28,29,30,31
-     *    hr          - hour                           0 .. 23
-     *    min         - minute                         0 .. 59
-     *    sec         - second                         0.0 .. 59.999
-     *
-     *  locals        :
-     *    dayofyr     - day of year
-     *    temp        - temporary extended values
-     *    inttemp     - temporary int value
-     *    i           - index
-     *    lmonth[13]  - int array containing the number of days per month
-     *
-     *  coupling      :
-     *    none.
-     * ---------------------------------------------------------------------------
-     */
-    static days2mdhms(year, days) {
-        const lmonth = [31, year % 4 === 0 ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        const dayofyr = Math.floor(days);
-        //  ----------------- find month and day of month ----------------
-        /** Ootk -- Incorporated in the above declaration */
-        /*
-         * If ((year % 4) == 0)
-         * lmonth[2] = 29;
-         */
-        let i = 1;
-        let inttemp = 0;
-        while (dayofyr > inttemp + (lmonth[i - 1]) && i < 12) {
-            inttemp += (lmonth[i - 1]);
-            i += 1;
-        }
-        const mon = i;
-        const day = dayofyr - inttemp;
-        //  ----------------- find hours minutes and seconds -------------
-        let temp = (days - dayofyr) * 24.0;
-        const hr = Math.floor(temp);
-        temp = (temp - hr) * 60.0;
-        const min = Math.floor(temp);
-        const sec = (temp - min) * 60.0;
-        return {
-            mon,
-            day,
-            hr,
-            min,
-            sec,
-        };
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function dot_SGP4
-     *
-     *  this function finds the dot product of two vectors.
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    vec1        - vector number 1
-     *    vec2        - vector number 2
-     *
-     *  outputs       :
-     *    dot         - result
-     *
-     *  locals        :
-     *    none.
-     *
-     *  coupling      :
-     *    none.
-     * ---------------------------------------------------------------------------
-     */
-    static dot_(v1, v2) {
-        return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function gstime
-     *
-     *  this function finds the greenwich sidereal time.
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    jdut1       - julian date in ut1             days from 4713 bc
-     *
-     *  outputs       :
-     *    gstime      - greenwich sidereal time        0 to 2PI rad
-     *
-     *  locals        :
-     *    temp        - temporary variable for doubles   rad
-     *    tut1        - julian centuries from the
-     *                  jan 1, 2000 12 h epoch (ut1)
-     *
-     *  coupling      :
-     *    none
-     *
-     *  references    :
-     *    vallado       2004, 191, eq 3-45
-     * ---------------------------------------------------------------------------
-     */
-    static gstime(jdut1) {
-        const tut1 = (jdut1 - 2451545.0) / 36525.0;
-        let temp = -6.2e-6 * tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1 +
-            (876600.0 * 3600 + 8640184.812866) * tut1 + 67310.54841; // Sec
-        temp = ((temp * DEG2RAD) / 240.0) % TAU; // 360/86400 = 1/240, to deg, to rad
-        //  ------------------------ check quadrants ---------------------
-        if (temp < 0.0) {
-            temp += TAU;
-        }
-        return temp;
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           procedure invjday
-     *
-     *  this procedure finds the year, month, day, hour, minute and second
-     *  given the julian date. tu can be ut1, tdt, tdb, etc.
-     *
-     *  algorithm     : set up starting values
-     *                  find leap year - use 1900 because 2000 is a leap year
-     *                  find the elapsed days through the year in a loop
-     *                  call routine to find each individual value
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    jd          - julian date                    days from 4713 bc
-     *    jdfrac      - julian date fraction into day  days from 4713 bc
-     *
-     *  outputs       :
-     *    year        - year                           1900 .. 2100
-     *    mon         - month                          1 .. 12
-     *    day         - day                            1 .. 28,29,30,31
-     *    hr          - hour                           0 .. 23
-     *    min         - minute                         0 .. 59
-     *    sec         - second                         0.0 .. 59.999
-     *
-     *  locals        :
-     *    days        - day of year plus fractional
-     *                  portion of a day               days
-     *    tu          - julian centuries from 0 h
-     *                  jan 0, 1900
-     *    temp        - temporary double values
-     *    leapyrs     - number of leap years from 1900
-     *
-     *  coupling      :
-     *    days2mdhms  - finds month, day, hour, minute and second given days and year
-     *
-     *  references    :
-     *    vallado       2013, 203, alg 22, ex 3-13
-     * ---------------------------------------------------------------------------
-     */
-    static invjday(jd, jdfrac) {
-        let leapyrs;
-        let days;
-        // Check jdfrac for multiple days
-        if (Math.abs(jdfrac) >= 1.0) {
-            jd += Math.floor(jdfrac);
-            jdfrac -= Math.floor(jdfrac);
-        }
-        // Check for fraction of a day included in the jd
-        const dt = jd - Math.floor(jd) - 0.5;
-        if (Math.abs(dt) > 0.00000001) {
-            jd -= dt;
-            jdfrac += dt;
-        }
-        /* --------------- find year and days of the year --------------- */
-        const temp = jd - 2415019.5;
-        const tu = temp / 365.25;
-        let year = 1900 + Math.floor(tu);
-        leapyrs = Math.floor((year - 1901) * 0.25);
-        days = Math.floor(temp - ((year - 1900) * 365.0 + leapyrs));
-        /* ------------ check for case of beginning of a year ----------- */
-        if (days + jdfrac < 1.0) {
-            year -= 1;
-            leapyrs = Math.floor((year - 1901) * 0.25);
-            days = Math.floor(temp - ((year - 1900) * 365.0 + leapyrs));
-        }
-        /* ----------------- find remaining data  ------------------------- */
-        const { mon, day, hr, min, sec } = Sgp4.days2mdhms(year, days + jdfrac);
-        return {
-            year,
-            mon,
-            day,
-            hr,
-            min,
-            sec,
-        };
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           procedure jday
-     *
-     *  this procedure finds the julian date given the year, month, day, and time.
-     *    the julian date is defined by each elapsed day since noon, jan 1, 4713 bc.
-     *
-     *  algorithm     : calculate the answer in one step for efficiency
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    year        - year                           1900 .. 2100
-     *    mon         - month                          1 .. 12
-     *    day         - day                            1 .. 28,29,30,31
-     *    hr          - universal time hour            0 .. 23
-     *    min         - universal time min             0 .. 59
-     *    sec         - universal time sec             0.0 .. 59.999
-     *
-     *  outputs       :
-     *    jd          - julian date                    days from 4713 bc
-     *    jdfrac      - julian date fraction into day  days from 4713 bc
-     *
-     *  locals        :
-     *    none.
-     *
-     *  coupling      :
-     *    none.
-     *
-     *  references    :
-     *    vallado       2013, 183, alg 14, ex 3-4
-     *
-     * ---------------------------------------------------------------------------
-     */
-    static jday(year, mon = 0, day = 0, hr = 0, min = 0, sec = 0, ms = 0) {
-        if (year instanceof Date) {
-            mon = year.getUTCMonth() + 1;
-            day = year.getUTCDate();
-            hr = year.getUTCHours();
-            min = year.getUTCMinutes();
-            sec = year.getUTCSeconds();
-            ms = year.getUTCMilliseconds();
-            year = year.getUTCFullYear();
-        }
-        let jd = 367.0 * year -
-            Math.floor(7 * (year + Math.floor((mon + 9) / 12.0)) * 0.25) +
-            Math.floor((275 * mon) / 9.0) +
-            day +
-            1721013.5; // Use - 678987.0 to go to mjd directly
-        let jdFrac = (ms / 1000 + sec + min * 60.0 + hr * 3600.0) / 86400.0;
-        // Check that the day and fractional day are correct
-        if (Math.abs(jdFrac) > 1.0) {
-            const dtt = Math.floor(jdFrac);
-            jd += dtt;
-            jdFrac -= dtt;
-        }
-        // - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
-        return { jd, jdFrac };
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function mag
-     *
-     *  this procedure finds the magnitude of a vector.
-     *
-     *  author        : david vallado                  719-573-2600    1 mar 2001
-     *
-     *  inputs          description                    range / units
-     *    vec         - vector
-     *
-     *  outputs       :
-     *    mag         - answer
-     *
-     *  locals        :
-     *    none.
-     *
-     *  coupling      :
-     *    none.
-     * ---------------------------------------------------------------------------
-     */
-    static mag_(v) {
-        return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function newtonnu_SGP4
-     *
-     *  this function solves keplers equation when the true anomaly is known.
-     *    the mean and eccentric, parabolic, or hyperbolic anomaly is also found.
-     *    the parabolic limit at 168ø is arbitrary. the hyperbolic anomaly is also
-     *    limited. the hyperbolic sine is used because it's not double valued.
-     *
-     *  author        : david vallado                  719-573-2600   27 may 2002
-     *
-     *  revisions
-     *    vallado     - fix small                                     24 sep 2002
-     *
-     *  inputs          description                    range / units
-     *    ecc         - eccentricity                   0.0  to
-     *    nu          - true anomaly                   -2pi to 2pi rad
-     *
-     *  outputs       :
-     *    e0          - eccentric anomaly              0.0  to 2pi rad       153.02 ø
-     *    m           - mean anomaly                   0.0  to 2pi rad       151.7425 ø
-     *
-     *  locals        :
-     *    e1          - eccentric anomaly, next value  rad
-     *    sine        - sine of e
-     *    cose        - cosine of e
-     *    ktr         - index
-     *
-     *  coupling      :
-     *    asinh       - arc hyperbolic sine
-     *
-     *  references    :
-     *    vallado       2013, 77, alg 5
-     * ---------------------------------------------------------------------------
-     */
-    static newtonnu_(ecc, nu) {
-        // ---------------------  implementation   ---------------------
-        let e0 = 999999.9;
-        let m = 999999.9;
-        const small = 0.00000001;
-        if (Math.abs(ecc) < small) {
-            // --------------------------- circular ------------------------
-            m = nu;
-            e0 = nu;
-        }
-        else if (ecc < 1.0 - small) {
-            // ---------------------- elliptical -----------------------
-            const sine = (Math.sqrt(1.0 - ecc * ecc) * Math.sin(nu)) / (1.0 + ecc * Math.cos(nu));
-            const cose = (ecc + Math.cos(nu)) / (1.0 + ecc * Math.cos(nu));
-            e0 = Math.atan2(sine, cose);
-            m = e0 - ecc * Math.sin(e0);
-        }
-        else if (ecc > 1.0 + small) {
-            // -------------------- hyperbolic  --------------------
-            if (ecc > 1.0 && Math.abs(nu) + 0.00001 < PI - Math.acos(1.0 / ecc)) {
-                const sine = (Math.sqrt(ecc * ecc - 1.0) * Math.sin(nu)) / (1.0 + ecc * Math.cos(nu));
-                e0 = Sgp4.asinh_(sine);
-                m = ecc * Sgp4.sinh_(e0) - e0;
-            }
-        }
-        else if (Math.abs(nu) < (168.0 * PI) / 180.0) {
-            // ----------------- parabolic ---------------------
-            e0 = Math.tan(nu * 0.5);
-            m = e0 + (e0 * e0 * e0) / 3.0;
-        }
-        if (ecc < 1.0) {
-            m %= 2.0 * PI;
-            if (m < 0.0) {
-                m += 2.0 * PI;
-            }
-            e0 %= 2.0 * PI;
-        }
-        return {
-            e0,
-            m,
-        };
-    }
-    /*
-     *----------------------------------------------------------------------------
-     *
-     *                             procedure sgp4
-     *
-     *  this procedure is the sgp4 prediction model from space command. this is an
-     *    updated and combined version of sgp4 and sdp4, which were originally
-     *    published separately in spacetrack report //3. this version follows the
-     *    methodology from the aiaa paper (2006) describing the history and
-     *    development of the code.
-     *
-     *  author        : david vallado                  719-573-2600   28 jun 2005
-     *
-     *  inputs        :
-     *    satrec  - initialised structure from sgp4init() call.
-     *    tsince  - time since epoch (minutes)
-     *
-     *  outputs       :
-     *    r           - position vector                     km
-     *    v           - velocity                            km/sec
-     *  return code - non-zero on error.
-     *                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
-     *                   2 - mean motion less than 0.0
-     *                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
-     *                   4 - semi-latus rectum < 0.0
-     *                   5 - epoch elements are sub-orbital
-     *                   6 - satellite has decayed
-     *
-     *  locals        :
-     *    am          -
-     *    axnl, aynl        -
-     *    betal       -
-     *    cosim   , sinim   , cosomm  , sinomm  , cnod    , snod    , cos2u   ,
-     *    sin2u   , coseo1  , sineo1  , cosi    , sini    , cosip   , sinip   ,
-     *    cosisq  , cossu   , sinsu   , cosu    , sinu
-     *    delm        -
-     *    delomg      -
-     *    dndt        -
-     *    eccm        -
-     *    emsq        -
-     *    ecose       -
-     *    el2         -
-     *    eo1         -
-     *    eccp        -
-     *    esine       -
-     *    argpm       -
-     *    argpp       -
-     *    omgadf      -
-     *    pl          -
-     *    r           -
-     *    rtemsq      -
-     *    rdotl       -
-     *    rl          -
-     *    rvdot       -
-     *    rvdotl      -
-     *    su          -
-     *    t2  , t3   , t4    , tc
-     *    tem5, temp , temp1 , temp2  , tempa  , tempe  , templ
-     *    u   , ux   , uy    , uz     , vx     , vy     , vz
-     *    inclm       - inclination
-     *    mm          - mean anomaly
-     *    nm          - mean motion
-     *    nodem       - right asc of ascending node
-     *    xinc        -
-     *    xincp       -
-     *    xl          -
-     *    xlm         -
-     *    mp          -
-     *    xmdf        -
-     *    xmx         -
-     *    xmy         -
-     *    nodedf      -
-     *    xnode       -
-     *    nodep       -
-     *    np          -
-     *
-     *  coupling      :
-     *    getgravconst-
-     *    dpper
-     *    dspace
-     *
-     *  references    :
-     *    hoots, roehrich, norad spacetrack report //3 1980
-     *    hoots, norad spacetrack report //6 1986
-     *    hoots, schumacher and glover 2004
-     *    vallado, crawford, hujsak, kelso  2006
-     *----------------------------------------------------------------------------
-     */
-    static propagate(satrec, tsince) {
-        /* ------------------ set mathematical constants --------------- */
-        /*
-         * Sgp4fix divisor for divide by zero check on inclination
-         * the old check used 1.0 + cos(PI-1.0e-9), but then compared it to
-         * 1.5 e-12, so the threshold was changed to 1.5e-12 for consistency
-         */
-        /*
-         * Sgp4fix identify constants and allow alternate values
-         * getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-         */
-        const { xke, j2, j3oj2, vkmpersec } = satrec;
-        // --------------------- clear sgp4 error flag -----------------
-        satrec.t = tsince;
-        satrec.error = Sgp4ErrorCode.NO_ERROR;
-        //  ------- update for secular gravity and atmospheric drag -----
-        const xmdf = satrec.mo + satrec.mdot * satrec.t;
-        const argpdf = satrec.argpo + satrec.argpdot * satrec.t;
-        const nodedf = satrec.nodeo + satrec.nodedot * satrec.t;
-        let argpm = argpdf;
-        let mm = xmdf;
-        const t2 = satrec.t * satrec.t;
-        let nodem = nodedf + satrec.nodecf * t2;
-        let tempa = 1.0 - satrec.cc1 * satrec.t;
-        let tempe = satrec.bstar * satrec.cc4 * satrec.t;
-        let templ = satrec.t2cof * t2;
-        if (!satrec.isimp) {
-            const delomg = satrec.omgcof * satrec.t;
-            //  Sgp4fix use mutliply for speed instead of pow
-            const delmtemp = 1.0 + satrec.eta * Math.cos(xmdf);
-            const delm = satrec.xmcof * (delmtemp * delmtemp * delmtemp - satrec.delmo);
-            const temp = delomg + delm;
-            mm = xmdf + temp;
-            argpm = argpdf - temp;
-            const t3 = t2 * satrec.t;
-            const t4 = t3 * satrec.t;
-            tempa = tempa - satrec.d2 * t2 - satrec.d3 * t3 - satrec.d4 * t4;
-            tempe += satrec.bstar * satrec.cc5 * (Math.sin(mm) - satrec.sinmao);
-            templ = templ + satrec.t3cof * t3 + t4 * (satrec.t4cof + satrec.t * satrec.t5cof);
-        }
-        let nm = satrec.no;
-        let em = satrec.ecco;
-        let inclm = satrec.inclo;
-        if (satrec.method === Sgp4Methods.DEEP_SPACE) {
-            [em, argpm, inclm, mm, nodem, nm] = Sgp4.dspace_(em, argpm, inclm, mm, nodem, nm, satrec);
-        }
-        if (nm <= 0.0) {
-            satrec.error = Sgp4ErrorCode.MEAN_MOTION_NEGATIVE;
-            return { position: false, velocity: false };
-        }
-        const am = (xke / nm) ** x2o3 * tempa * tempa;
-        nm = xke / am ** 1.5;
-        em -= tempe;
-        /*
-         * Fix tolerance for error recognition
-         * sgp4fix am is fixed from the previous nm check
-         */
-        /* istanbul ignore next | This is no longer possible*/
-        if (em >= 1.0 || em < -0.001) {
-            satrec.error = Sgp4ErrorCode.MEAN_MOTION_NEGATIVE;
-            return { position: false, velocity: false };
-        }
-        //  Sgp4fix fix tolerance to avoid a divide by zero
-        if (em < 1.0e-6) {
-            em = 1.0e-6;
-        }
-        mm += satrec.no * templ;
-        let xlm = mm + argpm + nodem;
-        nodem %= TAU;
-        argpm %= TAU;
-        xlm %= TAU;
-        mm = (xlm - argpm - nodem) % TAU;
-        /*
-         * Sgp4fix recover singly averaged mean elements
-         * satrec.am = am;
-         * satrec.em = em;
-         * satrec.im = inclm;
-         * satrec.Om = nodem;
-         * satrec.om = argpm;
-         * satrec.mm = mm;
-         * satrec.nm = nm;
-         */
-        // ----------------- compute extra mean quantities -------------
-        const sinim = Math.sin(inclm);
-        const cosim = Math.cos(inclm);
-        // -------------------- add lunar-solar periodics --------------
-        let ep = em;
-        let xincp = inclm;
-        let argpp = argpm;
-        let nodep = nodem;
-        let mp = mm;
-        let sinip = sinim;
-        let cosip = cosim;
-        if (satrec.method === Sgp4Methods.DEEP_SPACE) {
-            const dpperParameters = {
-                inclo: satrec.inclo,
-                init: false,
-                ep,
-                inclp: xincp,
-                nodep,
-                argpp,
-                mp,
-                opsmode: satrec.operationmode,
-                satrec,
-            };
-            ({ ep, nodep, argpp, mp, inclp: xincp } = Sgp4.dpper_(dpperParameters));
-            if (xincp < 0.0) {
-                xincp = -xincp;
-                nodep += PI;
-                argpp -= PI;
-            }
-            if (ep < 0.0 || ep > 1.0) {
-                satrec.error = Sgp4ErrorCode.PERT_ELEMENTS_INVALID;
-                return { position: false, velocity: false };
-            }
-        }
-        //  -------------------- long period periodics ------------------
-        if (satrec.method === Sgp4Methods.DEEP_SPACE) {
-            sinip = Math.sin(xincp);
-            cosip = Math.cos(xincp);
-            satrec.aycof = -0.5 * j3oj2 * sinip;
-            //  Sgp4fix for divide by zero for xincp = 180 deg
-            if (Math.abs(cosip + 1.0) > 1.5e-12) {
-                satrec.xlcof = (-0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip)) / (1.0 + cosip);
-            }
-            else {
-                satrec.xlcof = (-0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip)) / temp4;
-            }
-        }
-        const axnl = ep * Math.cos(argpp);
-        let temp = 1.0 / (am * (1.0 - ep * ep));
-        const aynl = ep * Math.sin(argpp) + temp * satrec.aycof;
-        const xl = mp + argpp + nodep + temp * satrec.xlcof * axnl;
-        // --------------------- solve kepler's equation ---------------
-        const u = (xl - nodep) % TAU;
-        let eo1 = u;
-        let tem5 = 9999.9;
-        let ktr = 1;
-        /*
-         *    Sgp4fix for kepler iteration
-         *    the following iteration needs better limits on corrections
-         */
-        let coseo1 = 0;
-        let sineo1 = 0;
-        while (Math.abs(tem5) >= 1.0e-12 && ktr <= 10) {
-            sineo1 = Math.sin(eo1);
-            coseo1 = Math.cos(eo1);
-            tem5 = 1.0 - coseo1 * axnl - sineo1 * aynl;
-            tem5 = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5;
-            if (Math.abs(tem5) >= 0.95) {
-                if (tem5 > 0.0) {
-                    tem5 = 0.95;
-                }
-                else {
-                    tem5 = -0.95;
-                }
-            }
-            eo1 += tem5;
-            ktr += 1;
-        }
-        //  ------------- short period preliminary quantities -----------
-        const ecose = axnl * coseo1 + aynl * sineo1;
-        const esine = axnl * sineo1 - aynl * coseo1;
-        const el2 = axnl * axnl + aynl * aynl;
-        const pl = am * (1.0 - el2);
-        if (pl < 0.0) {
-            satrec.error = Sgp4ErrorCode.SEMI_LATUS_RECTUM_NEGATIVE;
-            return { position: false, velocity: false };
-        }
-        const rl = am * (1.0 - ecose);
-        const rdotl = (Math.sqrt(am) * esine) / rl;
-        const rvdotl = Math.sqrt(pl) / rl;
-        const betal = Math.sqrt(1.0 - el2);
-        temp = esine / (1.0 + betal);
-        const sinu = (am / rl) * (sineo1 - aynl - axnl * temp);
-        const cosu = (am / rl) * (coseo1 - axnl + aynl * temp);
-        let su = Math.atan2(sinu, cosu);
-        const sin2u = (cosu + cosu) * sinu;
-        const cos2u = 1.0 - 2.0 * sinu * sinu;
-        temp = 1.0 / pl;
-        const temp1 = 0.5 * j2 * temp;
-        const temp2 = temp1 * temp;
-        // -------------- update for short period periodics ------------
-        if (satrec.method === Sgp4Methods.DEEP_SPACE) {
-            const cosisq = cosip * cosip;
-            satrec.con41 = 3.0 * cosisq - 1.0;
-            satrec.x1mth2 = 1.0 - cosisq;
-            satrec.x7thm1 = 7.0 * cosisq - 1.0;
-        }
-        const mrt = rl * (1.0 - 1.5 * temp2 * betal * satrec.con41) + 0.5 * temp1 * satrec.x1mth2 * cos2u;
-        /** Moved this up to reduce unnecessary computation if you are going to return false anyway */
-        // Sgp4fix for decaying satellites
-        if (mrt < 1.0) {
-            satrec.error = Sgp4ErrorCode.SATELLITE_DECAYED;
-            return {
-                position: false,
-                velocity: false,
-            };
-        }
-        su -= 0.25 * temp2 * satrec.x7thm1 * sin2u;
-        const xnode = nodep + 1.5 * temp2 * cosip * sin2u;
-        const xinc = xincp + 1.5 * temp2 * cosip * sinip * cos2u;
-        const mvt = rdotl - (nm * temp1 * satrec.x1mth2 * sin2u) / xke;
-        const rvdot = rvdotl + (nm * temp1 * (satrec.x1mth2 * cos2u + 1.5 * satrec.con41)) / xke;
-        // --------------------- orientation vectors -------------------
-        const sinsu = Math.sin(su);
-        const cossu = Math.cos(su);
-        const snod = Math.sin(xnode);
-        const cnod = Math.cos(xnode);
-        const sini = Math.sin(xinc);
-        const cosi = Math.cos(xinc);
-        const xmx = -snod * cosi;
-        const xmy = cnod * cosi;
-        const ux = xmx * sinsu + cnod * cossu;
-        const uy = xmy * sinsu + snod * cossu;
-        const uz = sini * sinsu;
-        const vx = xmx * cossu - cnod * sinsu;
-        const vy = xmy * cossu - snod * sinsu;
-        const vz = sini * cossu;
-        // --------- position and velocity (in km and km/sec) ----------
-        const r = {
-            x: mrt * ux * satrec.radiusearthkm,
-            y: mrt * uy * satrec.radiusearthkm,
-            z: mrt * uz * satrec.radiusearthkm,
-        };
-        const v = {
-            x: (mvt * ux + rvdot * vx) * vkmpersec,
-            y: (mvt * uy + rvdot * vy) * vkmpersec,
-            z: (mvt * uz + rvdot * vz) * vkmpersec,
-        };
-        return {
-            position: r,
-            velocity: v,
-        };
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function rv2coe_SGP4
-     *
-     *  this function finds the classical orbital elements given the geocentric
-     *    equatorial position and velocity vectors.
-     *
-     *  author        : david vallado                  719-573-2600   21 jun 2002
-     *
-     *  revisions
-     *    vallado     - fix special cases                              5 sep 2002
-     *    vallado     - delete extra check in inclination code        16 oct 2002
-     *    vallado     - add constant file use                         29 jun 2003
-     *    vallado     - add mu                                         2 apr 2007
-     *
-     *  inputs          description                    range / units
-     *    r           - ijk position vector            km
-     *    v           - ijk velocity vector            km / s
-     *    mu          - gravitational parameter        km3 / s2
-     *
-     *  outputs       :
-     *    p           - semilatus rectum               km
-     *    a           - semimajor axis                 km
-     *    ecc         - eccentricity
-     *    incl        - inclination                    0.0  to pi rad
-     *    omega       - right ascension of ascending node    0.0  to 2pi rad
-     *    argp        - argument of perigee            0.0  to 2pi rad
-     *    nu          - true anomaly                   0.0  to 2pi rad
-     *    m           - mean anomaly                   0.0  to 2pi rad
-     *    arglat      - argument of latitude      (ci) 0.0  to 2pi rad
-     *    truelon     - true longitude            (ce) 0.0  to 2pi rad
-     *    lonper      - longitude of periapsis    (ee) 0.0  to 2pi rad
-     *
-     *  locals        :
-     *    hbar        - angular momentum h vector      km2 / s
-     *    ebar        - eccentricity     e vector
-     *    nbar        - line of nodes    n vector
-     *    c1          - v**2 - u/r
-     *    rdotv       - r dot v
-     *    hk          - hk unit vector
-     *    sme         - specfic mechanical energy      km2 / s2
-     *    i           - index
-     *    e           - eccentric, parabolic,
-     *                  hyperbolic anomaly             rad
-     *    temp        - temporary variable
-     *    typeorbit   - type of orbit                  ee, ei, ce, ci
-     *
-     *  coupling      :
-     *    mag         - magnitude of a vector
-     *    cross       - cross product of two vectors
-     *    angle       - find the angle between two vectors
-     *    newtonnu    - find the mean anomaly
-     *
-     *  references    :
-     *    vallado       2013, 113, alg 9, ex 2-5
-     * ---------------------------------------------------------------------------
-     */
-    static rv2coe(r, v, mus) {
-        const nbar = [0, 0, 0];
-        const ebar = [0, 0, 0];
-        let p;
-        let a;
-        let ecc;
-        let incl;
-        let omega;
-        let argp;
-        let nu;
-        let m = 0;
-        let arglat;
-        let truelon;
-        let lonper;
-        let rdotv;
-        let magn;
-        let hk;
-        let sme;
-        let i;
-        /*
-         *  Switch this to an integer msvs seems to have probelms with this and strncpy_s
-         * char typeorbit[2];
-         */
-        let typeorbit;
-        /*
-         * Here
-         * typeorbit = 1 = 'ei'
-         * typeorbit = 2 = 'ce'
-         * typeorbit = 3 = 'ci'
-         * typeorbit = 4 = 'ee'
-         */
-        const halfpi = 0.5 * PI;
-        const small = 0.00000001;
-        const unknown = 999999.1; /** Ootk -- original undefined is illegal in JS */
-        const infinite = 999999.9;
-        // -------------------------  implementation   -----------------
-        const magr = Sgp4.mag_(r);
-        const magv = Sgp4.mag_(v);
-        // ------------------  find h n and e vectors   ----------------
-        const hbar = Sgp4.cross_(r, v);
-        const magh = Sgp4.mag_(hbar);
-        if (magh > small) {
-            nbar[0] = -hbar[1];
-            nbar[1] = hbar[0];
-            nbar[2] = 0.0;
-            magn = Sgp4.mag_(nbar);
-            const c1 = magv * magv - mus / magr;
-            rdotv = Sgp4.dot_(r, v);
-            for (i = 0; i <= 2; i++) {
-                ebar[i] = (c1 * (r[i]) - rdotv * (v[i])) / mus;
-            }
-            ecc = Sgp4.mag_(ebar);
-            // ------------  find a e and semi-latus rectum   ----------
-            sme = magv * magv * 0.5 - mus / magr;
-            if (Math.abs(sme) > small) {
-                a = -mus / (2.0 * sme);
-            }
-            else {
-                a = infinite;
-            }
-            p = (magh * magh) / mus;
-            // -----------------  find inclination   -------------------
-            hk = hbar[2] / magh;
-            incl = Math.acos(hk);
-            /*
-             * --------  determine type of orbit for later use  --------
-             * ------ elliptical, parabolic, hyperbolic inclined -------
-             */
-            typeorbit = 1;
-            if (ecc < small) {
-                // ----------------  circular equatorial ---------------
-                if (incl < small || Math.abs(incl - PI) < small) {
-                    typeorbit = 2;
-                }
-                else {
-                    // --------------  circular inclined ---------------
-                    typeorbit = 3;
-                }
-                // - elliptical, parabolic, hyperbolic equatorial --
-            }
-            else if (incl < small || Math.abs(incl - PI) < small) {
-                typeorbit = 4;
-            }
-            // ----------  find right ascension of the ascending node ------------
-            if (magn > small) {
-                let temp = nbar[0] / magn;
-                if (Math.abs(temp) > 1.0) {
-                    temp = Sgp4.sgn_(temp);
-                }
-                omega = Math.acos(temp);
-                if (nbar[1] < 0.0) {
-                    omega = TAU - omega;
-                }
-            }
-            else {
-                omega = unknown;
-            }
-            // ---------------- find argument of perigee ---------------
-            if (typeorbit === 1) {
-                argp = Sgp4.angle_(nbar, ebar);
-                if (ebar[2] < 0.0) {
-                    argp = TAU - argp;
-                }
-            }
-            else {
-                argp = unknown;
-            }
-            // ------------  find true anomaly at epoch    -------------
-            if (typeorbit === 1 || typeorbit === 4) {
-                nu = Sgp4.angle_(ebar, r);
-                if (rdotv < 0.0) {
-                    nu = TAU - nu;
-                }
-            }
-            else {
-                nu = unknown;
-            }
-            // ----  find argument of latitude - circular inclined -----
-            if (typeorbit === 3) {
-                arglat = Sgp4.angle_(nbar, r);
-                if (r[2] < 0.0) {
-                    arglat = TAU - arglat;
-                }
-                m = arglat;
-            }
-            else {
-                arglat = unknown;
-            }
-            if (ecc > small && typeorbit === 4) {
-                let temp = ebar[0] / ecc;
-                if (Math.abs(temp) > 1.0) {
-                    temp = Sgp4.sgn_(temp);
-                }
-                lonper = Math.acos(temp);
-                if (ebar[1] < 0.0) {
-                    lonper = TAU - lonper;
-                }
-                if (incl > halfpi) {
-                    lonper = TAU - lonper;
-                }
-            }
-            else {
-                lonper = unknown;
-            }
-            // -------- find true longitude - circular equatorial ------
-            if (magr > small && typeorbit === 2) {
-                let temp = r[0] / magr;
-                if (Math.abs(temp) > 1.0) {
-                    temp = Sgp4.sgn_(temp);
-                }
-                truelon = Math.acos(temp);
-                if (r[1] < 0.0) {
-                    truelon = TAU - truelon;
-                }
-                if (incl > halfpi) {
-                    truelon = TAU - truelon;
-                }
-                m = truelon;
-            }
-            else {
-                truelon = unknown;
-            }
-            // ------------ find mean anomaly for all orbits -----------
-            if (typeorbit === 1 || typeorbit === 4) {
-                m = Sgp4.newtonnu_(ecc, nu).m;
-            }
-        }
-        else {
-            p = unknown;
-            a = unknown;
-            ecc = unknown;
-            incl = unknown;
-            omega = unknown;
-            argp = unknown;
-            nu = unknown;
-            m = unknown;
-            arglat = unknown;
-            truelon = unknown;
-            lonper = unknown;
-        }
-        return {
-            p,
-            a,
-            ecc,
-            incl,
-            omega,
-            argp,
-            nu,
-            m,
-            arglat,
-            truelon,
-            lonper,
-        };
-    }
-    /**
-     * Determines the sign of a given number.
-     * @param x - The input number to evaluate.
-     * @returns `-1.0` if the input number is less than `0.0`, otherwise `1.0`.
-     */
-    static sgn_(x) {
-        if (x < 0.0) {
-            return -1.0;
-        }
-        return 1.0;
-    }
-    /**
-     * Computes the hyperbolic sine of a given number.
-     *
-     * The hyperbolic sine is calculated using the formula:
-     * sinh(x) = (e^x - e^(-x)) / 2
-     * @param x - The input number for which to calculate the hyperbolic sine.
-     * @returns The hyperbolic sine of the input number.
-     */
-    static sinh_(x) {
-        return (Math.exp(x) - Math.exp(-x)) / 2;
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           procedure dpper
-     *
-     *  this procedure provides deep space long period periodic contributions
-     *    to the mean elements.  by design, these periodics are zero at epoch.
-     *    this used to be dscom which included initialization, but it's really a
-     *    recurring function.
-     *
-     *  author        : david vallado                  719-573-2600   28 jun 2005
-     *
-     *  inputs        :
-     *    e3          -
-     *    ee2         -
-     *    peo         -
-     *    pgho        -
-     *    pho         -
-     *    PInco       -
-     *    plo         -
-     *    se2 , se3 , sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4 -
-     *    t           -
-     *    xh2, xh3, xi2, xi3, xl2, xl3, xl4 -
-     *    zmol        -
-     *    zmos        -
-     *    ep          - eccentricity                           0.0 - 1.0
-     *    inclo       - inclination - needed for lyddane modification
-     *    nodep       - right ascension of ascending node
-     *    argpp       - argument of perigee
-     *    mp          - mean anomaly
-     *
-     *  outputs       :
-     *    ep          - eccentricity                           0.0 - 1.0
-     *    inclp       - inclination
-     *    nodep        - right ascension of ascending node
-     *    argpp       - argument of perigee
-     *    mp          - mean anomaly
-     *
-     *  locals        :
-     *    alfdp       -
-     *    betdp       -
-     *    cosip  , sinip  , cosop  , sinop  ,
-     *    dalf        -
-     *    dbet        -
-     *    dls         -
-     *    f2, f3      -
-     *    pe          -
-     *    pgh         -
-     *    ph          -
-     *    PInc        -
-     *    pl          -
-     *    sel   , ses   , sghl  , sghs  , shl   , shs   , sil   , sinzf , sis   ,
-     *    sll   , sls
-     *    xls         -
-     *    xnoh        -
-     *    zf          -
-     *    zm          -
-     *
-     *  coupling      :
-     *    none.
-     *
-     *  references    :
-     *    hoots, roehrich, norad spacetrack report #3 1980
-     *    hoots, norad spacetrack report #6 1986
-     *    hoots, schumacher and glover 2004
-     *    vallado, crawford, hujsak, kelso  2006
-     * ----------------------------------------------------------------------------
-     */
-    static dpper_(options) {
-        const { e3, ee2, peo, pgho, pho, PInco, plo, se2, se3, sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4, t, xgh2, xgh3, xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4, zmol, zmos, } = options.satrec;
-        let { ep, inclp, nodep, argpp, mp } = options;
-        const { opsmode = Sgp4OpsMode.IMPROVED, init } = options;
-        //  ---------------------- constants -----------------------------
-        /** Ootk -- Some variables imported from outside the class at the top */
-        const zns = 1.19459e-5;
-        const zes = 0.01675;
-        const znl = 1.5835218e-4;
-        const zel = 0.0549;
-        //  --------------- calculate time varying periodics -----------
-        let zm = zmos + zns * t;
-        // Be sure that the initial call has time set to zero
-        if (init) {
-            zm = zmos;
-        }
-        let zf = zm + 2.0 * zes * Math.sin(zm);
-        let sinzf = Math.sin(zf);
-        let f2 = 0.5 * sinzf * sinzf - 0.25;
-        let f3 = -0.5 * sinzf * Math.cos(zf);
-        const ses = se2 * f2 + se3 * f3;
-        const sis = si2 * f2 + si3 * f3;
-        const sls = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
-        const sghs = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
-        const shs = sh2 * f2 + sh3 * f3;
-        zm = zmol + znl * t;
-        if (init) {
-            zm = zmol;
-        }
-        zf = zm + 2.0 * zel * Math.sin(zm);
-        sinzf = Math.sin(zf);
-        f2 = 0.5 * sinzf * sinzf - 0.25;
-        f3 = -0.5 * sinzf * Math.cos(zf);
-        const sel = ee2 * f2 + e3 * f3;
-        const sil = xi2 * f2 + xi3 * f3;
-        const sll = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
-        const sghl = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
-        const shll = xh2 * f2 + xh3 * f3;
-        let pe = ses + sel;
-        let PInc = sis + sil;
-        let pl = sls + sll;
-        let pgh = sghs + sghl;
-        let ph = shs + shll;
-        if (!init) {
-            pe -= peo;
-            PInc -= PInco;
-            pl -= plo;
-            pgh -= pgho;
-            ph -= pho;
-            inclp += PInc;
-            ep += pe;
-            const sinip = Math.sin(inclp);
-            const cosip = Math.cos(inclp);
-            /* ----------------- apply periodics directly ------------ */
-            /*
-             * Sgp4fix for lyddane choice
-             * strn3 used original inclination - this is technically feasible
-             * gsfc used perturbed inclination - also technically feasible
-             * probably best to readjust the 0.2 limit value and limit discontinuity
-             * 0.2 rad = 11.45916 deg
-             * use next line for original strn3 approach and original inclination
-             * if (inclo >= 0.2)
-             * use next line for gsfc version and perturbed inclination
-             */
-            if (inclp >= 0.2) {
-                ph /= sinip;
-                pgh -= cosip * ph;
-                argpp += pgh;
-                nodep += ph;
-                mp += pl;
-            }
-            else {
-                //  ---- apply periodics with lyddane modification ----
-                const sinop = Math.sin(nodep);
-                const cosop = Math.cos(nodep);
-                let alfdp = sinip * sinop;
-                let betdp = sinip * cosop;
-                const dalf = ph * cosop + PInc * cosip * sinop;
-                const dbet = -ph * sinop + PInc * cosip * cosop;
-                alfdp += dalf;
-                betdp += dbet;
-                nodep %= TAU;
-                /*
-                 *  Sgp4fix for afspc written intrinsic functions
-                 *  nodep used without a trigonometric function ahead
-                 */
-                /* istanbul ignore next */
-                if (nodep < 0.0 && opsmode === 'a') {
-                    nodep += TAU;
-                }
-                let xls = mp + argpp + cosip * nodep;
-                const dls = pl + pgh - PInc * nodep * sinip;
-                xls += dls;
-                const xnoh = nodep;
-                nodep = Math.atan2(alfdp, betdp);
-                /*
-                 *  Sgp4fix for afspc written intrinsic functions
-                 *  nodep used without a trigonometric function ahead
-                 */
-                /* istanbul ignore next */
-                if (nodep < 0.0 && opsmode === 'a') {
-                    nodep += TAU;
-                }
-                if (Math.abs(xnoh - nodep) > PI) {
-                    /* istanbul ignore next */
-                    if (nodep < xnoh) {
-                        nodep += TAU;
-                    }
-                    else {
-                        nodep -= TAU;
-                    }
-                }
-                mp += pl;
-                argpp = xls - mp - cosip * nodep;
-            }
-        } // If !init
-        return {
-            ep,
-            inclp,
-            nodep,
-            argpp,
-            mp,
-        };
-    }
-    /*
-     *-----------------------------------------------------------------------------
-     *
-     *                           procedure dscom
-     *
-     *  this procedure provides deep space common items used by both the secular
-     *    and periodics subroutines.  input is provided as shown. this routine
-     *    used to be called dpper, but the functions inside weren't well organized.
-     *
-     *  author        : david vallado                  719-573-2600   28 jun 2005
-     *
-     *  inputs        :
-     *    epoch       -
-     *    ep          - eccentricity
-     *    argpp       - argument of perigee
-     *    tc          -
-     *    inclp       - inclination
-     *    nodep       - right ascension of ascending node
-     *    np          - mean motion
-     *
-     *  outputs       :
-     *    sinim  , cosim  , sinomm , cosomm , snodm  , cnodm
-     *    day         -
-     *    e3          -
-     *    ee2         -
-     *    em          - eccentricity
-     *    emsq        - eccentricity squared
-     *    gam         -
-     *    peo         -
-     *    pgho        -
-     *    pho         -
-     *    PInco       -
-     *    plo         -
-     *    rtemsq      -
-     *    se2, se3         -
-     *    sgh2, sgh3, sgh4        -
-     *    sh2, sh3, si2, si3, sl2, sl3, sl4         -
-     *    s1, s2, s3, s4, s5, s6, s7          -
-     *    ss1, ss2, ss3, ss4, ss5, ss6, ss7, sz1, sz2, sz3         -
-     *    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
-     *    xgh2, xgh3, xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4         -
-     *    nm          - mean motion
-     *    z1, z2, z3, z11, z12, z13, z21, z22, z23, z31, z32, z33         -
-     *    zmol        -
-     *    zmos        -
-     *
-     *  locals        :
-     *    a1, a2, a3, a4, a5, a6, a7, a8, a9, a10         -
-     *    betasq      -
-     *    cc          -
-     *    ctem, stem        -
-     *    x1, x2, x3, x4, x5, x6, x7, x8          -
-     *    xnodce      -
-     *    xnoi        -
-     *    zcosg  , zsing  , zcosgl , zsingl , zcosh  , zsinh  , zcoshl , zsinhl ,
-     *    zcosi  , zsini  , zcosil , zsinil ,
-     *    zx          -
-     *    zy          -
-     *
-     *  coupling      :
-     *    none.
-     *
-     *  references    :
-     *    hoots, roehrich, norad spacetrack report #3 1980
-     *    hoots, norad spacetrack report #6 1986
-     *    hoots, schumacher and glover 2004
-     *    vallado, crawford, hujsak, kelso  2006
-     *----------------------------------------------------------------------------
-     */
-    static dscom_(options) {
-        const { epoch, ep, argpp, tc, inclp, nodep, np } = options;
-        // -------------------------- constants -------------------------
-        /** Ootk -- Some variables imported from outside the class at the top */
-        const zes = 0.01675;
-        const zel = 0.0549;
-        const c1ss = 2.9864797e-6;
-        const c1l = 4.7968065e-7;
-        const zsinis = 0.39785416;
-        const zcosis = 0.91744867;
-        const zcosgs = 0.1945905;
-        const zsings = -0.98088458;
-        //  --------------------- local variables ------------------------
-        let s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0, s6 = 0, s7 = 0, ss1 = 0, ss2 = 0, ss3 = 0, ss4 = 0, ss5 = 0, ss6 = 0, ss7 = 0, sz1 = 0, sz11 = 0, sz12 = 0, sz13 = 0, sz2 = 0, sz21 = 0, sz22 = 0, sz23 = 0, sz3 = 0, sz31 = 0, sz32 = 0, sz33 = 0, z1 = 0, z11 = 0, z12 = 0, z13 = 0, z2 = 0, z21 = 0, z22 = 0, z23 = 0, z3 = 0, z31 = 0, z32 = 0, z33 = 0;
-        const nm = np;
-        const em = ep;
-        const snodm = Math.sin(nodep);
-        const cnodm = Math.cos(nodep);
-        const sinomm = Math.sin(argpp);
-        const cosomm = Math.cos(argpp);
-        const sinim = Math.sin(inclp);
-        const cosim = Math.cos(inclp);
-        const emsq = em * em;
-        const betasq = 1.0 - emsq;
-        const rtemsq = Math.sqrt(betasq);
-        //  ----------------- initialize lunar solar terms ---------------
-        const peo = 0.0;
-        const PInco = 0.0;
-        const plo = 0.0;
-        const pgho = 0.0;
-        const pho = 0.0;
-        const day = epoch + 18261.5 + tc / 1440.0;
-        const xnodce = (4.523602 - 9.2422029e-4 * day) % TAU;
-        const stem = Math.sin(xnodce);
-        const ctem = Math.cos(xnodce);
-        const zcosil = 0.91375164 - 0.03568096 * ctem;
-        const zsinil = Math.sqrt(1.0 - zcosil * zcosil);
-        const zsinhl = (0.089683511 * stem) / zsinil;
-        const zcoshl = Math.sqrt(1.0 - zsinhl * zsinhl);
-        const gam = 5.8351514 + 0.001944368 * day;
-        let zx = (0.39785416 * stem) / zsinil;
-        const zy = zcoshl * ctem + 0.91744867 * zsinhl * stem;
-        zx = Math.atan2(zx, zy);
-        zx += gam - xnodce;
-        const zcosgl = Math.cos(zx);
-        const zsingl = Math.sin(zx);
-        //  ------------------------- do solar terms ---------------------
-        let zcosg = zcosgs;
-        let zsing = zsings;
-        let zcosi = zcosis;
-        let zsini = zsinis;
-        let zcosh = cnodm;
-        let zsinh = snodm;
-        let cc = c1ss;
-        const xnoi = 1.0 / nm;
-        for (let lsflg = 1; lsflg <= 2; lsflg++) {
-            const a1 = zcosg * zcosh + zsing * zcosi * zsinh;
-            const a3 = -zsing * zcosh + zcosg * zcosi * zsinh;
-            const a7 = -zcosg * zsinh + zsing * zcosi * zcosh;
-            const a8 = zsing * zsini;
-            const a9 = zsing * zsinh + zcosg * zcosi * zcosh;
-            const a10 = zcosg * zsini;
-            const a2 = cosim * a7 + sinim * a8;
-            const a4 = cosim * a9 + sinim * a10;
-            const a5 = -sinim * a7 + cosim * a8;
-            const a6 = -sinim * a9 + cosim * a10;
-            const x1 = a1 * cosomm + a2 * sinomm;
-            const x2 = a3 * cosomm + a4 * sinomm;
-            const x3 = -a1 * sinomm + a2 * cosomm;
-            const x4 = -a3 * sinomm + a4 * cosomm;
-            const x5 = a5 * sinomm;
-            const x6 = a6 * sinomm;
-            const x7 = a5 * cosomm;
-            const x8 = a6 * cosomm;
-            z31 = 12.0 * x1 * x1 - 3.0 * x3 * x3;
-            z32 = 24.0 * x1 * x2 - 6.0 * x3 * x4;
-            z33 = 12.0 * x2 * x2 - 3.0 * x4 * x4;
-            z1 = 3.0 * (a1 * a1 + a2 * a2) + z31 * emsq;
-            z2 = 6.0 * (a1 * a3 + a2 * a4) + z32 * emsq;
-            z3 = 3.0 * (a3 * a3 + a4 * a4) + z33 * emsq;
-            z11 = -6.0 * a1 * a5 + emsq * (-24.0 * x1 * x7 - 6.0 * x3 * x5);
-            z12 = -6.0 * (a1 * a6 + a3 * a5) + emsq * (-24.0 * (x2 * x7 + x1 * x8) + -6.0 * (x3 * x6 + x4 * x5));
-            z13 = -6.0 * a3 * a6 + emsq * (-24.0 * x2 * x8 - 6.0 * x4 * x6);
-            z21 = 6.0 * a2 * a5 + emsq * (24.0 * x1 * x5 - 6.0 * x3 * x7);
-            z22 = 6.0 * (a4 * a5 + a2 * a6) + emsq * (24.0 * (x2 * x5 + x1 * x6) - 6.0 * (x4 * x7 + x3 * x8));
-            z23 = 6.0 * a4 * a6 + emsq * (24.0 * x2 * x6 - 6.0 * x4 * x8);
-            z1 = z1 + z1 + betasq * z31;
-            z2 = z2 + z2 + betasq * z32;
-            z3 = z3 + z3 + betasq * z33;
-            s3 = cc * xnoi;
-            s2 = (-0.5 * s3) / rtemsq;
-            s4 = s3 * rtemsq;
-            s1 = -15.0 * em * s4;
-            s5 = x1 * x3 + x2 * x4;
-            s6 = x2 * x3 + x1 * x4;
-            s7 = x2 * x4 - x1 * x3;
-            //  ----------------------- do lunar terms -------------------
-            if (lsflg === 1) {
-                ss1 = s1;
-                ss2 = s2;
-                ss3 = s3;
-                ss4 = s4;
-                ss5 = s5;
-                ss6 = s6;
-                ss7 = s7;
-                sz1 = z1;
-                sz2 = z2;
-                sz3 = z3;
-                sz11 = z11;
-                sz12 = z12;
-                sz13 = z13;
-                sz21 = z21;
-                sz22 = z22;
-                sz23 = z23;
-                sz31 = z31;
-                sz32 = z32;
-                sz33 = z33;
-                zcosg = zcosgl;
-                zsing = zsingl;
-                zcosi = zcosil;
-                zsini = zsinil;
-                zcosh = zcoshl * cnodm + zsinhl * snodm;
-                zsinh = snodm * zcoshl - cnodm * zsinhl;
-                cc = c1l;
-            }
-        }
-        const zmol = (4.7199672 + (0.2299715 * day - gam)) % TAU;
-        const zmos = (6.2565837 + 0.017201977 * day) % TAU;
-        //  ------------------------ do solar terms ----------------------
-        const se2 = 2.0 * ss1 * ss6;
-        const se3 = 2.0 * ss1 * ss7;
-        const si2 = 2.0 * ss2 * sz12;
-        const si3 = 2.0 * ss2 * (sz13 - sz11);
-        const sl2 = -2.0 * ss3 * sz2;
-        const sl3 = -2.0 * ss3 * (sz3 - sz1);
-        const sl4 = -2.0 * ss3 * (-21.0 - 9.0 * emsq) * zes;
-        const sgh2 = 2.0 * ss4 * sz32;
-        const sgh3 = 2.0 * ss4 * (sz33 - sz31);
-        const sgh4 = -18.0 * ss4 * zes;
-        const sh2 = -2.0 * ss2 * sz22;
-        const sh3 = -2.0 * ss2 * (sz23 - sz21);
-        //  ------------------------ do lunar terms ----------------------
-        const ee2 = 2.0 * s1 * s6;
-        const e3 = 2.0 * s1 * s7;
-        const xi2 = 2.0 * s2 * z12;
-        const xi3 = 2.0 * s2 * (z13 - z11);
-        const xl2 = -2.0 * s3 * z2;
-        const xl3 = -2.0 * s3 * (z3 - z1);
-        const xl4 = -2.0 * s3 * (-21.0 - 9.0 * emsq) * zel;
-        const xgh2 = 2.0 * s4 * z32;
-        const xgh3 = 2.0 * s4 * (z33 - z31);
-        const xgh4 = -18.0 * s4 * zel;
-        const xh2 = -2.0 * s2 * z22;
-        const xh3 = -2.0 * s2 * (z23 - z21);
-        return {
-            snodm,
-            cnodm,
-            sinim,
-            cosim,
-            sinomm,
-            cosomm,
-            day,
-            e3,
-            ee2,
-            em,
-            emsq,
-            gam,
-            peo,
-            pgho,
-            pho,
-            PInco,
-            plo,
-            rtemsq,
-            se2,
-            se3,
-            sgh2,
-            sgh3,
-            sgh4,
-            sh2,
-            sh3,
-            si2,
-            si3,
-            sl2,
-            sl3,
-            sl4,
-            s1,
-            s2,
-            s3,
-            s4,
-            s5,
-            s6,
-            s7,
-            ss1,
-            ss2,
-            ss3,
-            ss4,
-            ss5,
-            ss6,
-            ss7,
-            sz1,
-            sz2,
-            sz3,
-            sz11,
-            sz12,
-            sz13,
-            sz21,
-            sz22,
-            sz23,
-            sz31,
-            sz32,
-            sz33,
-            xgh2,
-            xgh3,
-            xgh4,
-            xh2,
-            xh3,
-            xi2,
-            xi3,
-            xl2,
-            xl3,
-            xl4,
-            nm,
-            z1,
-            z2,
-            z3,
-            z11,
-            z12,
-            z13,
-            z21,
-            z22,
-            z23,
-            z31,
-            z32,
-            z33,
-            zmol,
-            zmos,
-        };
-    }
-    /*
-     *-----------------------------------------------------------------------------
-     *
-     *                           procedure dsinit
-     *
-     *  this procedure provides deep space contributions to mean motion dot due
-     *    to geopotential resonance with half day and one day orbits.
-     *
-     *  author        : david vallado                  719-573-2600   28 jun 2005
-     *
-     *  inputs        :
-     *    cosim, sinim-
-     *    emsq        - eccentricity squared
-     *    argpo       - argument of perigee
-     *    s1, s2, s3, s4, s5      -
-     *    ss1, ss2, ss3, ss4, ss5 -
-     *    sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33 -
-     *    t           - time
-     *    tc          -
-     *    gsto        - greenwich sidereal time                   rad
-     *    mo          - mean anomaly
-     *    mdot        - mean anomaly dot (rate)
-     *    no          - mean motion
-     *    nodeo       - right ascension of ascending node
-     *    nodedot     - right ascension of ascending node dot (rate)
-     *    xPIdot      -
-     *    z1, z3, z11, z13, z21, z23, z31, z33 -
-     *    eccm        - eccentricity
-     *    argpm       - argument of perigee
-     *    inclm       - inclination
-     *    mm          - mean anomaly
-     *    xn          - mean motion
-     *    nodem       - right ascension of ascending node
-     *
-     *  outputs       :
-     *    em          - eccentricity
-     *    argpm       - argument of perigee
-     *    inclm       - inclination
-     *    mm          - mean anomaly
-     *    nm          - mean motion
-     *    nodem       - right ascension of ascending node
-     *    irez        - flag for resonance           0-none, 1-one day, 2-half day
-     *    atime       -
-     *    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433    -
-     *    dedt        -
-     *    didt        -
-     *    dmdt        -
-     *    dndt        -
-     *    dnodt       -
-     *    domdt       -
-     *    del1, del2, del3        -
-     *    ses  , sghl , sghs , sgs  , shl  , shs  , sis  , sls
-     *    theta       -
-     *    xfact       -
-     *    xlamo       -
-     *    xli         -
-     *    xni
-     *
-     *  locals        :
-     *    ainv2       -
-     *    aonv        -
-     *    cosisq      -
-     *    eoc         -
-     *    f220, f221, f311, f321, f322, f330, f441, f442, f522, f523, f542, f543  -
-     *    g200, g201, g211, g300, g310, g322, g410, g422, g520, g521, g532, g533  -
-     *    sini2       -
-     *    temp        -
-     *    temp1       -
-     *    theta       -
-     *    xno2        -
-     *
-     *  coupling      :
-     *    getgravconst
-     *
-     *  references    :
-     *    hoots, roehrich, norad spacetrack report #3 1980
-     *    hoots, norad spacetrack report #6 1986
-     *    hoots, schumacher and glover 2004
-     *    vallado, crawford, hujsak, kelso  2006
-     *----------------------------------------------------------------------------
-     */
-    static dsinit_(options) {
-        /*
-         * Sgp4fix just send in xke as a constant and eliminate getgravconst call
-         * gravconsttype whichconst,
-         */
-        const { xke, cosim, argpo, s1, s2, s3, s4, s5, sinim, ss1, ss2, ss3, ss4, ss5, sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33, t, tc, gsto, mo, mdot, no, nodeo, nodedot, xPIdot, z1, z3, z11, z13, z21, z23, z31, z33, ecco, eccsq, } = options;
-        let { emsq, em, argpm, inclm, mm, nm, nodem, atime, d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433, del1, del2, del3, xfact, xlamo, xli, xni, } = options;
-        /* --------------------- local variables ------------------------ */
-        /** Ootk -- Some variables imported from outside the class at the top */
-        const q22 = 1.7891679e-6;
-        const q31 = 2.1460748e-6;
-        const q33 = 2.2123015e-7;
-        const root22 = 1.7891679e-6;
-        const root44 = 7.3636953e-9;
-        const root54 = 2.1765803e-9;
-        const rptim = 4.37526908801129966e-3; // Equates to 7.29211514668855e-5 rad/sec
-        const root32 = 3.7393792e-7;
-        const root52 = 1.1428639e-7;
-        const x2o3 = 2.0 / 3.0;
-        const znl = 1.5835218e-4;
-        const zns = 1.19459e-5;
-        /*
-         * Sgp4fix identify constants and allow alternate values
-         * just xke is used here so pass it in rather than have multiple calls
-         * getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-         */
-        // -------------------- deep space initialization ------------
-        let irez = 0;
-        if (nm < 0.0052359877 && nm > 0.0034906585) {
-            irez = 1;
-        }
-        if (nm >= 8.26e-3 && nm <= 9.24e-3 && em >= 0.5) {
-            irez = 2;
-        }
-        // ------------------------ do solar terms -------------------
-        const ses = ss1 * zns * ss5;
-        const sis = ss2 * zns * (sz11 + sz13);
-        const sls = -zns * ss3 * (sz1 + sz3 - 14.0 - 6.0 * emsq);
-        const sghs = ss4 * zns * (sz31 + sz33 - 6.0);
-        let shs = -zns * ss2 * (sz21 + sz23);
-        // Sgp4fix for 180 deg incl
-        if (inclm < 5.2359877e-2 || inclm > PI - 5.2359877e-2) {
-            shs = 0.0;
-        }
-        if (sinim !== 0.0) {
-            shs /= sinim;
-        }
-        const sgs = sghs - cosim * shs;
-        // ------------------------- do lunar terms ------------------
-        const dedt = ses + s1 * znl * s5;
-        const didt = sis + s2 * znl * (z11 + z13);
-        const dmdt = sls - znl * s3 * (z1 + z3 - 14.0 - 6.0 * emsq);
-        const sghl = s4 * znl * (z31 + z33 - 6.0);
-        let shll = -znl * s2 * (z21 + z23);
-        // Sgp4fix for 180 deg incl
-        if (inclm < 5.2359877e-2 || inclm > PI - 5.2359877e-2) {
-            shll = 0.0;
-        }
-        let domdt = sgs + sghl;
-        let dnodt = shs;
-        if (sinim !== 0.0) {
-            domdt -= (cosim / sinim) * shll;
-            dnodt += shll / sinim;
-        }
-        // ----------- calculate deep space resonance effects --------
-        const dndt = 0.0;
-        const theta = (gsto + tc * rptim) % TAU;
-        em += dedt * t;
-        inclm += didt * t;
-        argpm += domdt * t;
-        nodem += dnodt * t;
-        mm += dmdt * t;
-        /*
-         * Sgp4fix for negative inclinations
-         * the following if statement should be commented out
-         * if (inclm < 0.0)
-         * {
-         *   inclm  = -inclm;
-         *   argpm  = argpm - PI;
-         *   nodem = nodem + PI;
-         * }
-         */
-        // -------------- initialize the resonance terms -------------
-        if (irez !== 0) {
-            const aonv = (nm / xke) ** x2o3;
-            // ---------- geopotential resonance for 12 hour orbits ------
-            if (irez === 2) {
-                const cosisq = cosim * cosim;
-                const emo = em;
-                em = ecco;
-                const emsqo = emsq;
-                emsq = eccsq;
-                const eoc = em * emsq;
-                const g201 = -0.306 - (em - 0.64) * 0.44;
-                let g211, g310, g322, g410, g422, g520, g521, g532, g533;
-                if (em <= 0.65) {
-                    g211 = 3.616 - 13.247 * em + 16.29 * emsq;
-                    g310 = -19.302 + 117.39 * em - 228.419 * emsq + 156.591 * eoc;
-                    g322 = -18.9068 + 109.7927 * em - 214.6334 * emsq + 146.5816 * eoc;
-                    g410 = -41.122 + 242.694 * em - 471.094 * emsq + 313.953 * eoc;
-                    g422 = -146.407 + 841.88 * em - 1629.014 * emsq + 1083.435 * eoc;
-                    g520 = -532.114 + 3017.977 * em - 5740.032 * emsq + 3708.276 * eoc;
-                }
-                else {
-                    g211 = -72.099 + 331.819 * em - 508.738 * emsq + 266.724 * eoc;
-                    g310 = -346.844 + 1582.851 * em - 2415.925 * emsq + 1246.113 * eoc;
-                    g322 = -342.585 + 1554.908 * em - 2366.899 * emsq + 1215.972 * eoc;
-                    g410 = -1052.797 + 4758.686 * em - 7193.992 * emsq + 3651.957 * eoc;
-                    g422 = -3581.69 + 16178.11 * em - 24462.77 * emsq + 12422.52 * eoc;
-                    if (em > 0.715) {
-                        g520 = -5149.66 + 29936.92 * em - 54087.36 * emsq + 31324.56 * eoc;
-                    }
-                    else {
-                        g520 = 1464.74 - 4664.75 * em + 3763.64 * emsq;
-                    }
-                }
-                if (em < 0.7) {
-                    g533 = -919.2277 + 4988.61 * em - 9064.77 * emsq + 5542.21 * eoc;
-                    g521 = -822.71072 + 4568.6173 * em - 8491.4146 * emsq + 5337.524 * eoc;
-                    g532 = -853.666 + 4690.25 * em - 8624.77 * emsq + 5341.4 * eoc;
-                }
-                else {
-                    g533 = -37995.78 + 161616.52 * em - 229838.2 * emsq + 109377.94 * eoc;
-                    g521 = -51752.104 + 218913.95 * em - 309468.16 * emsq + 146349.42 * eoc;
-                    g532 = -40023.88 + 170470.89 * em - 242699.48 * emsq + 115605.82 * eoc;
-                }
-                const sini2 = sinim * sinim;
-                const f220 = 0.75 * (1.0 + 2.0 * cosim + cosisq);
-                const f221 = 1.5 * sini2;
-                const f321 = 1.875 * sinim * (1.0 - 2.0 * cosim - 3.0 * cosisq);
-                const f322 = -1.875 * sinim * (1.0 + 2.0 * cosim - 3.0 * cosisq);
-                const f441 = 35.0 * sini2 * f220;
-                const f442 = 39.375 * sini2 * sini2;
-                const f522 = 9.84375 *
-                    sinim *
-                    (sini2 * (1.0 - 2.0 * cosim - 5.0 * cosisq) + 0.33333333 * (-2.0 + 4.0 * cosim + 6.0 * cosisq));
-                const f523 = sinim *
-                    (4.92187512 * sini2 * (-2.0 - 4.0 * cosim + 10.0 * cosisq) + 6.56250012 * (1.0 + 2.0 * cosim - 3.0 * cosisq));
-                const f542 = 29.53125 * sinim * (2.0 - 8.0 * cosim + cosisq * (-12.0 + 8.0 * cosim + 10.0 * cosisq));
-                const f543 = 29.53125 * sinim * (-2.0 - 8.0 * cosim + cosisq * (12.0 + 8.0 * cosim - 10.0 * cosisq));
-                const xno2 = nm * nm;
-                const ainv2 = aonv * aonv;
-                let temp1 = 3.0 * xno2 * ainv2;
-                let temp = temp1 * root22;
-                d2201 = temp * f220 * g201;
-                d2211 = temp * f221 * g211;
-                temp1 *= aonv;
-                temp = temp1 * root32;
-                d3210 = temp * f321 * g310;
-                d3222 = temp * f322 * g322;
-                temp1 *= aonv;
-                temp = 2.0 * temp1 * root44;
-                d4410 = temp * f441 * g410;
-                d4422 = temp * f442 * g422;
-                temp1 *= aonv;
-                temp = temp1 * root52;
-                d5220 = temp * f522 * g520;
-                d5232 = temp * f523 * g532;
-                temp = 2.0 * temp1 * root54;
-                d5421 = temp * f542 * g521;
-                d5433 = temp * f543 * g533;
-                xlamo = (mo + nodeo + nodeo - (theta + theta)) % TAU;
-                xfact = mdot + dmdt + 2.0 * (nodedot + dnodt - rptim) - no;
-                em = emo;
-                emsq = emsqo;
-            }
-            //  ---------------- synchronous resonance terms --------------
-            if (irez === 1) {
-                const g200 = 1.0 + emsq * (-2.5 + 0.8125 * emsq);
-                const g310 = 1.0 + 2.0 * emsq;
-                const g300 = 1.0 + emsq * (-6.0 + 6.60937 * emsq);
-                const f220 = 0.75 * (1.0 + cosim) * (1.0 + cosim);
-                const f311 = 0.9375 * sinim * sinim * (1.0 + 3.0 * cosim) - 0.75 * (1.0 + cosim);
-                let f330 = 1.0 + cosim;
-                f330 *= 1.875 * f330 * f330;
-                del1 = 3.0 * nm * nm * aonv * aonv;
-                del2 = 2.0 * del1 * f220 * g200 * q22;
-                del3 = 3.0 * del1 * f330 * g300 * q33 * aonv;
-                del1 = del1 * f311 * g310 * q31 * aonv;
-                xlamo = (mo + nodeo + argpo - theta) % TAU;
-                xfact = mdot + xPIdot + dmdt + domdt + dnodt - (no + rptim);
-            }
-            //  ------------ for sgp4, initialize the integrator ----------
-            xli = xlamo;
-            xni = no;
-            atime = 0.0;
-            nm = no + dndt;
-        }
-        return {
-            em,
-            argpm,
-            inclm,
-            mm,
-            nm,
-            nodem,
-            irez,
-            atime,
-            d2201,
-            d2211,
-            d3210,
-            d3222,
-            d4410,
-            d4422,
-            d5220,
-            d5232,
-            d5421,
-            d5433,
-            dedt,
-            didt,
-            dmdt,
-            dndt,
-            dnodt,
-            domdt,
-            del1,
-            del2,
-            del3,
-            xfact,
-            xlamo,
-            xli,
-            xni,
-        };
-    }
-    /*
-     *-----------------------------------------------------------------------------
-     *
-     *                           procedure dspace
-     *
-     *  this procedure provides deep space contributions to mean elements for
-     *    perturbing third body.  these effects have been averaged over one
-     *    revolution of the sun and moon.  for earth resonance effects, the
-     *    effects have been averaged over no revolutions of the satellite.
-     *    (mean motion)
-     *
-     *  author        : david vallado                  719-573-2600   28 jun 2005
-     *
-     *  inputs        :
-     *    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433 -
-     *    dedt        -
-     *    del1, del2, del3  -
-     *    didt        -
-     *    dmdt        -
-     *    dnodt       -
-     *    domdt       -
-     *    irez        - flag for resonance           0-none, 1-one day, 2-half day
-     *    argpo       - argument of perigee
-     *    argpdot     - argument of perigee dot (rate)
-     *    t           - time
-     *    tc          -
-     *    gsto        - gst
-     *    xfact       -
-     *    xlamo       -
-     *    no          - mean motion
-     *    atime       -
-     *    em          - eccentricity
-     *    ft          -
-     *    argpm       - argument of perigee
-     *    inclm       - inclination
-     *    xli         -
-     *    mm          - mean anomaly
-     *    xni         - mean motion
-     *    nodem       - right ascension of ascending node
-     *
-     *  outputs       :
-     *    atime       -
-     *    em          - eccentricity
-     *    argpm       - argument of perigee
-     *    inclm       - inclination
-     *    xli         -
-     *    mm          - mean anomaly
-     *    xni         -
-     *    nodem       - right ascension of ascending node
-     *    dndt        -
-     *    nm          - mean motion
-     *
-     *  locals        :
-     *    delt        -
-     *    ft          -
-     *    theta       -
-     *    x2li        -
-     *    x2omi       -
-     *    xl          -
-     *    xldot       -
-     *    xnddt       -
-     *    xndt        -
-     *    xomi        -
-     *
-     *  coupling      :
-     *    none        -
-     *
-     *  references    :
-     *    hoots, roehrich, norad spacetrack report #3 1980
-     *    hoots, norad spacetrack report #6 1986
-     *    hoots, schumacher and glover 2004
-     *    vallado, crawford, hujsak, kelso  2006
-     *----------------------------------------------------------------------------
-     */
-    static dspace_(em, argpm, inclm, mm, nodem, nm, satrec) {
-        let { atime, xli, xni, } = satrec;
-        const { dedt, didt, dmdt, dnodt, domdt, irez, d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433, xfact, xlamo, gsto, argpo, t, no, argpdot, del1, del2, del3, } = satrec;
-        //  ----------- calculate deep space resonance effects -----------
-        let dndt = 0.0;
-        const theta = (gsto + t * rptim) % TAU;
-        // Apply time-dependent perturbations
-        em += dedt * t;
-        inclm += didt * t;
-        argpm += domdt * t;
-        nodem += dnodt * t;
-        mm += dmdt * t;
-        if (irez !== 0) {
-            // Simplified deep space resonance handling
-            if (atime === 0.0 || t * atime <= 0.0 || Math.abs(t) < Math.abs(atime)) {
-                atime = 0.0;
-                xni = no;
-                xli = xlamo;
-            }
-            const delt = t > 0.0 ? stepp : stepn;
-            let ft = 0;
-            let x2li = 0;
-            let x2omi = 0;
-            let xldot = 0;
-            let xnddt = 0;
-            let xndt = 0;
-            let xomi = 0;
-            let iretn = true; // Added for do loop
-            while (iretn) {
-                /*
-                 *  ------------------- dot terms calculated -------------
-                 *  ----------- near - synchronous resonance terms -------
-                 */
-                if (irez !== 2) {
-                    xndt =
-                        del1 * Math.sin(xli - fasx2) + del2 * Math.sin(2.0 * (xli - fasx4)) + del3 * Math.sin(3.0 * (xli - fasx6));
-                    xldot = xni + xfact;
-                    xnddt =
-                        del1 * Math.cos(xli - fasx2) +
-                            2.0 * del2 * Math.cos(2.0 * (xli - fasx4)) +
-                            3.0 * del3 * Math.cos(3.0 * (xli - fasx6));
-                    xnddt *= xldot;
-                }
-                else {
-                    // --------- near - half-day resonance terms --------
-                    xomi = argpo + argpdot * atime;
-                    x2omi = xomi + xomi;
-                    x2li = xli + xli;
-                    xndt =
-                        d2201 * Math.sin(x2omi + xli - g22) +
-                            d2211 * Math.sin(xli - g22) +
-                            d3210 * Math.sin(xomi + xli - g32) +
-                            d3222 * Math.sin(-xomi + xli - g32) +
-                            d4410 * Math.sin(x2omi + x2li - g44) +
-                            d4422 * Math.sin(x2li - g44) +
-                            d5220 * Math.sin(xomi + xli - g52) +
-                            d5232 * Math.sin(-xomi + xli - g52) +
-                            d5421 * Math.sin(xomi + x2li - g54) +
-                            d5433 * Math.sin(-xomi + x2li - g54);
-                    xldot = xni + xfact;
-                    xnddt =
-                        d2201 * Math.cos(x2omi + xli - g22) +
-                            d2211 * Math.cos(xli - g22) +
-                            d3210 * Math.cos(xomi + xli - g32) +
-                            d3222 * Math.cos(-xomi + xli - g32) +
-                            d5220 * Math.cos(xomi + xli - g52) +
-                            d5232 * Math.cos(-xomi + xli - g52) +
-                            2.0 *
-                                (d4410 * Math.cos(x2omi + x2li - g44) +
-                                    d4422 * Math.cos(x2li - g44) +
-                                    d5421 * Math.cos(xomi + x2li - g54) +
-                                    d5433 * Math.cos(-xomi + x2li - g54));
-                    xnddt *= xldot;
-                }
-                /*
-                 *  ----------------------- integrator -------------------
-                 *  sgp4fix move end checks to end of routine
-                 */
-                if (Math.abs(t - atime) < stepp) {
-                    ft = t - atime;
-                    iretn = false;
-                }
-                else {
-                    xli += xldot * delt + xndt * step2;
-                    xni += xndt * delt + xnddt * step2;
-                    atime += delt;
-                }
-            }
-            nm = xni + xndt * ft + xnddt * ft * ft * 0.5;
-            const xl = xli + xldot * ft + xndt * ft * ft * 0.5;
-            if (irez !== 1) {
-                mm = xl - 2.0 * nodem + 2.0 * theta;
-                dndt = nm - no;
-            }
-            else {
-                mm = xl - nodem - argpm + theta;
-                dndt = nm - no;
-            }
-            nm = no + dndt;
-        }
-        return [em, argpm, inclm, mm, nodem, nm];
-    }
-    /*
-     * -----------------------------------------------------------------------------
-     *
-     *                           function getgravconst
-     *
-     *  this function gets constants for the propagator. note that mu is identified to
-     *    facilitiate comparisons with newer models. the common useage is wgs72.
-     *
-     *  author        : david vallado                  719-573-2600   21 jul 2006
-     *
-     *  inputs        :
-     *    whichconst  - which set of constants to use  wgs72old, wgs72, wgs84
-     *
-     *  outputs       :
-     *    tumin       - minutes in one time unit
-     *    mu          - earth gravitational parameter
-     *    radiusearthkm - radius of the earth in km
-     *    xke         - reciprocal of tumin
-     *    j2, j3, j4  - un-normalized zonal harmonic values
-     *    j3oj2       - j3 divided by j2
-     *
-     *  locals        :
-     *
-     *  coupling      :
-     *    none
-     *
-     *  references    :
-     *    norad spacetrack report #3
-     *    vallado, crawford, hujsak, kelso  2006
-     * ---------------------------------------------------------------------------
-     */
-    static getgravconst_(whichconst) {
-        let j2, j3, j3oj2, j4, mus, radiusearthkm, tumin, xke;
-        switch (whichconst) {
-            // -- wgs-72 low precision str#3 constants --
-            case 'wgs72old':
-                mus = 398600.79964; // In km3 / s2
-                radiusearthkm = 6378.135; // Km
-                xke = 0.0743669161; // Reciprocal of tumin
-                tumin = 1.0 / xke;
-                j2 = 0.001082616;
-                j3 = -0.00000253881;
-                j4 = -0.00000165597;
-                j3oj2 = j3 / j2;
-                break;
-            // ------------ wgs-72 constants ------------
-            case 'wgs72':
-                mus = 398600.8; // In km3 / s2
-                radiusearthkm = 6378.135; // Km
-                xke = 60.0 / Math.sqrt((radiusearthkm * radiusearthkm * radiusearthkm) / mus);
-                tumin = 1.0 / xke;
-                j2 = 0.001082616;
-                j3 = -0.00000253881;
-                j4 = -0.00000165597;
-                j3oj2 = j3 / j2;
-                break;
-            case 'wgs84':
-                // ------------ wgs-84 constants ------------
-                mus = 398600.5; // In km3 / s2
-                radiusearthkm = 6378.137; // Km
-                xke = 60.0 / Math.sqrt((radiusearthkm * radiusearthkm * radiusearthkm) / mus);
-                tumin = 1.0 / xke;
-                j2 = 0.00108262998905;
-                j3 = -0.00000253215306;
-                j4 = -0.00000161098761;
-                j3oj2 = j3 / j2;
-                break;
-            default:
-                throw new Error(`unknown gravity option ${whichconst}`);
-        }
-        return {
-            tumin,
-            mus,
-            radiusearthkm,
-            xke,
-            j2,
-            j3,
-            j4,
-            j3oj2,
-        };
-    }
-    /*
-     *-----------------------------------------------------------------------------
-     *
-     *                           procedure initl
-     *
-     *  this procedure initializes the sgp4 propagator. all the initialization is
-     *    consolidated here instead of having multiple loops inside other routines.
-     *
-     *  author        : david vallado                  719-573-2600   28 jun 2005
-     *
-     *  inputs        :
-     *    satn        - satellite number - not needed, placed in satrec
-     *    xke         - reciprocal of tumin
-     *    j2          - j2 zonal harmonic
-     *    ecco        - eccentricity                           0.0 - 1.0
-     *    epoch       - epoch time in days from jan 0, 1950. 0 hr
-     *    inclo       - inclination of satellite
-     *    no          - mean motion of satellite
-     *
-     *  outputs       :
-     *    ainv        - 1.0 / a
-     *    ao          - semi major axis
-     *    con41       -
-     *    con42       - 1.0 - 5.0 cos(i)
-     *    cosio       - cosine of inclination
-     *    cosio2      - cosio squared
-     *    eccsq       - eccentricity squared
-     *    method      - flag for deep space                    'd', 'n'
-     *    omeosq      - 1.0 - ecco * ecco
-     *    posq        - semi-parameter squared
-     *    rp          - radius of perigee
-     *    rteosq      - square root of (1.0 - ecco*ecco)
-     *    sinio       - sine of inclination
-     *    gsto        - gst at time of observation               rad
-     *    no          - mean motion of satellite
-     *
-     *  locals        :
-     *    ak          -
-     *    d1          -
-     *    del         -
-     *    adel        -
-     *    po          -
-     *
-     *  coupling      :
-     *    getgravconst- no longer used
-     *    gstime      - find greenwich sidereal time from the julian date
-     *
-     *  references    :
-     *    hoots, roehrich, norad spacetrack report #3 1980
-     *    hoots, norad spacetrack report #6 1986
-     *    hoots, schumacher and glover 2004
-     *    vallado, crawford, hujsak, kelso  2006
-     *----------------------------------------------------------------------------
-     */
-    static initl_(satrec, epoch) {
-        /*
-         * Sgp4fix satn not needed. include in satrec in case needed later
-         * int satn,
-         * sgp4fix just pass in xke and j2
-         * gravconsttype whichconst,
-         */
-        const { operationmode, ecco, inclo, xke, j2 } = satrec;
-        let { no } = satrec;
-        /* --------------------- local variables ------------------------ */
-        const x2o3 = 2.0 / 3.0;
-        // Sgp4fix use old way of finding gst
-        /** Ootk -- Some variables imported from outside the class at the top */
-        /*
-         * ----------------------- earth constants ---------------------
-         * sgp4fix identify constants and allow alternate values
-         * only xke and j2 are used here so pass them in directly
-         * getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 )
-         */
-        // ------------- calculate auxillary epoch quantities ----------
-        const eccsq = ecco * ecco;
-        const omeosq = 1.0 - eccsq;
-        const rteosq = Math.sqrt(omeosq);
-        const cosio = Math.cos(inclo);
-        const cosio2 = cosio * cosio;
-        // ------------------ un-kozai the mean motion -----------------
-        const ak = (xke / no) ** x2o3;
-        const d1 = (0.75 * j2 * (3.0 * cosio2 - 1.0)) / (rteosq * omeosq);
-        let delPrime = d1 / (ak * ak);
-        const adel = ak * (1.0 - delPrime * delPrime - delPrime * (1.0 / 3.0 + (134.0 * delPrime * delPrime) / 81.0));
-        delPrime = d1 / (adel * adel);
-        no /= 1.0 + delPrime;
-        const ao = (xke / no) ** x2o3;
-        const sinio = Math.sin(inclo);
-        const po = ao * omeosq;
-        const con42 = 1.0 - 5.0 * cosio2;
-        const con41 = -con42 - cosio2 - cosio2;
-        const ainv = 1.0 / ao;
-        const posq = po * po;
-        const rp = ao * (1.0 - ecco);
-        //  Sgp4fix modern approach to finding sidereal time
-        /** Ootk -- Continue allowing AFSPC mode for SGP4 Validation */
-        let gsto;
-        if (operationmode === Sgp4OpsMode.AFSPC) {
-            /*
-             *  Sgp4fix use old way of finding gst
-             *  count integer number of days from 0 jan 1970
-             */
-            const ts70 = epoch - 7305.0;
-            const ds70 = Math.floor(ts70 + 1.0e-8);
-            const tfrac = ts70 - ds70;
-            //  Find greenwich location at epoch
-            const c1 = 1.72027916940703639e-2;
-            const thgr70 = 1.7321343856509374;
-            const fk5r = 5.07551419432269442e-15;
-            const c1p2p = c1 + TAU;
-            gsto = (thgr70 + c1 * ds70 + c1p2p * tfrac + ts70 * ts70 * fk5r) % TAU;
-            /* istanbul ignore next | This is no longer possible*/
-            if (gsto < 0.0) {
-                gsto += TAU;
-            }
-        }
-        else {
-            const jdut1 = epoch + 2433281.5;
-            const tut1 = (jdut1 - 2451545.0) / 36525.0;
-            gsto = -6.2e-6 * tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1 +
-                (876600.0 * 3600 + 8640184.812866) * tut1 + 67310.54841; // Sec
-            gsto = ((gsto * DEG2RAD) / 240.0) % TAU; // 360/86400 = 1/240, to deg, to rad
-            //  ------------------------ check quadrants ---------------------
-            if (gsto < 0.0) {
-                gsto += TAU;
-            }
-        }
-        return {
-            no,
-            ainv,
-            ao,
-            con41,
-            con42,
-            cosio,
-            cosio2,
-            eccsq,
-            omeosq,
-            posq,
-            rp,
-            rteosq,
-            sinio,
-            gsto,
-        };
-    }
-    /*
-     *-----------------------------------------------------------------------------
-     *
-     *                             procedure sgp4init
-     *
-     *  this procedure initializes variables for sgp4.
-     *
-     *  author        : david vallado                  719-573-2600   28 jun 2005
-     *
-     *  inputs        :
-     *    opsmode     - mode of operation afspc or improved 'a', 'i'
-     *    whichconst  - which set of constants to use  72, 84
-     *    satn        - satellite number
-     *    bstar       - sgp4 type drag coefficient              kg/m2er
-     *    ecco        - eccentricity
-     *    epoch       - epoch time in days from jan 0, 1950. 0 hr
-     *    argpo       - argument of perigee (output if ds)
-     *    inclo       - inclination
-     *    mo          - mean anomaly (output if ds)
-     *    no          - mean motion
-     *    nodeo       - right ascension of ascending node
-     *
-     *  outputs       :
-     *    rec      - common values for subsequent calls
-     *    return code - non-zero on error.
-     *                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
-     *                   2 - mean motion less than 0.0
-     *                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
-     *                   4 - semi-latus rectum < 0.0
-     *                   5 - epoch elements are sub-orbital
-     *                   6 - satellite has decayed
-     *
-     *  locals        :
-     *    cnodm  , snodm  , cosim  , sinim  , cosomm , sinomm
-     *    cc1sq  , cc2    , cc3
-     *    coef   , coef1
-     *    cosio4      -
-     *    day         -
-     *    dndt        -
-     *    em          - eccentricity
-     *    emsq        - eccentricity squared
-     *    eeta        -
-     *    etasq       -
-     *    gam         -
-     *    argpm       - argument of perigee
-     *    nodem       -
-     *    inclm       - inclination
-     *    mm          - mean anomaly
-     *    nm          - mean motion
-     *    perige      - perigee
-     *    PInvsq      -
-     *    psisq       -
-     *    qzms24      -
-     *    rtemsq      -
-     *    s1, s2, s3, s4, s5, s6, s7          -
-     *    sfour       -
-     *    ss1, ss2, ss3, ss4, ss5, ss6, ss7         -
-     *    sz1, sz2, sz3
-     *    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
-     *    tc          -
-     *    temp        -
-     *    temp1, temp2, temp3       -
-     *    tsi         -
-     *    xPIdot      -
-     *    xhdot1      -
-     *    z1, z2, z3          -
-     *    z11, z12, z13, z21, z22, z23, z31, z32, z33         -
-     *
-     *  coupling      :
-     *    getgravconst-
-     *    initl       -
-     *    dscom       -
-     *    dpper       -
-     *    dsinit      -
-     *    sgp4        -
-     *
-     *  references    :
-     *    hoots, roehrich, norad spacetrack report #3 1980
-     *    hoots, norad spacetrack report #6 1986
-     *    hoots, schumacher and glover 2004
-     *    vallado, crawford, hujsak, kelso  2006
-     *----------------------------------------------------------------------------
-     */
-    static sgp4init_(satrec, options) {
-        const { whichconst = Sgp4GravConstants.wgs72, opsmode = Sgp4OpsMode.IMPROVED, satn = satrec.satnum, epoch, xbstar, xecco, xargpo, xinclo, xndot, xnddot, xmo, xno, xnodeo, } = options;
-        /* ------------------------ initialization --------------------- */
-        /*
-         * Sgp4fix divisor for divide by zero check on inclination
-         * the old check used 1.0 + Math.cos(PI-1.0e-9), but then compared it to
-         * 1.5 e-12, so the threshold was changed to 1.5e-12 for consistency
-         */
-        // ----------- set all near earth variables to zero ------------
-        satrec.isimp = false;
-        satrec.method = Sgp4Methods.NEAR_EARTH;
-        satrec.aycof = 0.0;
-        satrec.con41 = 0.0;
-        satrec.cc1 = 0.0;
-        satrec.cc4 = 0.0;
-        satrec.cc5 = 0.0;
-        satrec.d2 = 0.0;
-        satrec.d3 = 0.0;
-        satrec.d4 = 0.0;
-        satrec.delmo = 0.0;
-        satrec.eta = 0.0;
-        satrec.argpdot = 0.0;
-        satrec.omgcof = 0.0;
-        satrec.sinmao = 0.0;
-        satrec.t = 0.0;
-        satrec.t2cof = 0.0;
-        satrec.t3cof = 0.0;
-        satrec.t4cof = 0.0;
-        satrec.t5cof = 0.0;
-        satrec.x1mth2 = 0.0;
-        satrec.x7thm1 = 0.0;
-        satrec.mdot = 0.0;
-        satrec.nodedot = 0.0;
-        satrec.xlcof = 0.0;
-        satrec.xmcof = 0.0;
-        satrec.nodecf = 0.0;
-        // ----------- set all deep space variables to zero ------------
-        satrec.irez = 0;
-        satrec.d2201 = 0.0;
-        satrec.d2211 = 0.0;
-        satrec.d3210 = 0.0;
-        satrec.d3222 = 0.0;
-        satrec.d4410 = 0.0;
-        satrec.d4422 = 0.0;
-        satrec.d5220 = 0.0;
-        satrec.d5232 = 0.0;
-        satrec.d5421 = 0.0;
-        satrec.d5433 = 0.0;
-        satrec.dedt = 0.0;
-        satrec.del1 = 0.0;
-        satrec.del2 = 0.0;
-        satrec.del3 = 0.0;
-        satrec.didt = 0.0;
-        satrec.dmdt = 0.0;
-        satrec.dnodt = 0.0;
-        satrec.domdt = 0.0;
-        satrec.e3 = 0.0;
-        satrec.ee2 = 0.0;
-        satrec.peo = 0.0;
-        satrec.pgho = 0.0;
-        satrec.pho = 0.0;
-        satrec.PInco = 0.0;
-        satrec.plo = 0.0;
-        satrec.se2 = 0.0;
-        satrec.se3 = 0.0;
-        satrec.sgh2 = 0.0;
-        satrec.sgh3 = 0.0;
-        satrec.sgh4 = 0.0;
-        satrec.sh2 = 0.0;
-        satrec.sh3 = 0.0;
-        satrec.si2 = 0.0;
-        satrec.si3 = 0.0;
-        satrec.sl2 = 0.0;
-        satrec.sl3 = 0.0;
-        satrec.sl4 = 0.0;
-        satrec.gsto = 0.0;
-        satrec.xfact = 0.0;
-        satrec.xgh2 = 0.0;
-        satrec.xgh3 = 0.0;
-        satrec.xgh4 = 0.0;
-        satrec.xh2 = 0.0;
-        satrec.xh3 = 0.0;
-        satrec.xi2 = 0.0;
-        satrec.xi3 = 0.0;
-        satrec.xl2 = 0.0;
-        satrec.xl3 = 0.0;
-        satrec.xl4 = 0.0;
-        satrec.xlamo = 0.0;
-        satrec.zmol = 0.0;
-        satrec.zmos = 0.0;
-        satrec.atime = 0.0;
-        satrec.xli = 0.0;
-        satrec.xni = 0.0;
-        /* ------------------------ earth constants ----------------------- */
-        /*
-         * Sgp4fix identify constants and allow alternate values
-         * this is now the only call for the constants
-         */
-        const gravResults = Sgp4.getgravconst_(whichconst);
-        satrec.tumin = gravResults.tumin;
-        satrec.mus = gravResults.mus;
-        satrec.radiusearthkm = gravResults.radiusearthkm;
-        satrec.xke = gravResults.xke;
-        satrec.j2 = gravResults.j2;
-        satrec.j3 = gravResults.j3;
-        satrec.j4 = gravResults.j4;
-        satrec.j3oj2 = gravResults.j3oj2;
-        satrec.vkmpersec = (satrec.radiusearthkm * satrec.xke) / 60.0;
-        const { j2 } = gravResults;
-        const { j4 } = gravResults;
-        const { xke } = gravResults;
-        const { j3oj2 } = gravResults;
-        // -------------------------------------------------------------------------
-        satrec.error = Sgp4ErrorCode.NO_ERROR;
-        satrec.operationmode = opsmode;
-        // New alpha5 or 9-digit number
-        /**
-         * Ootk -- Using JS code for string manipulation but same effect
-         * Ex. A2525 = 102525
-         * Ex. Z1234 = 351234
-         */
-        satrec.satnum = Tle.convertA5to6Digit(satn);
-        /*
-         * Sgp4fix - note the following variables are also passed directly via satrec.
-         * it is possible to streamline the sgp4init call by deleting the "x"
-         * variables, but the user would need to set the satrec.* values first. we
-         * include the additional assignments in case twoline2rv is not used.
-         */
-        satrec.bstar = xbstar;
-        // Sgp4fix allow additional parameters in the struct
-        satrec.ndot = xndot;
-        satrec.nddot = xnddot;
-        satrec.ecco = xecco;
-        satrec.argpo = xargpo;
-        satrec.inclo = xinclo;
-        satrec.mo = xmo;
-        // Sgp4fix rename variables to clarify which mean motion is intended
-        satrec.no = xno;
-        satrec.nodeo = xnodeo;
-        /*
-         * Single averaged mean elements
-         * satrec.am = satrec.em = satrec.im = satrec.Om = satrec.mm = satrec.nm = 0.0;
-         */
-        /*
-         * ------------------------ earth constants -----------------------
-         * sgp4fix identify constants and allow alternate values
-         * getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-         */
-        const ss = 78.0 / satrec.radiusearthkm + 1.0;
-        // Sgp4fix use multiply for speed instead of pow
-        const qzms2ttemp = (120.0 - 78.0) / satrec.radiusearthkm;
-        const qzms2t = qzms2ttemp * qzms2ttemp * qzms2ttemp * qzms2ttemp;
-        satrec.init = true;
-        satrec.t = 0.0;
-        // Sgp4fix remove satn as it is not needed in initl
-        const initlResult = Sgp4.initl_(satrec, epoch);
-        const { ao, con42, cosio, cosio2, eccsq, omeosq, posq, rp, rteosq, sinio } = initlResult;
-        satrec.no = initlResult.no;
-        satrec.con41 = initlResult.con41;
-        satrec.gsto = initlResult.gsto;
-        satrec.a = (satrec.no * satrec.tumin) ** (-2.0 / 3.0);
-        satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
-        satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
-        satrec.error = Sgp4ErrorCode.NO_ERROR;
-        /*
-         * Sgp4fix remove this check as it is unnecessary
-         * the mrt check in sgp4 handles decaying satellite cases even if the starting
-         * condition is below the surface of te earth
-         * if (rp < 1.0)
-         * {
-         *   printf("// *** satn%d epoch elts sub-orbital ***\n", satn);
-         *   satrec.error = 5;
-         * }
-         */
-        if (omeosq >= 0.0 || satrec.no >= 0.0) {
-            satrec.isimp = false;
-            if (rp < 220.0 / satrec.radiusearthkm + 1.0) {
-                satrec.isimp = true;
-            }
-            let sfour = ss;
-            let qzms24 = qzms2t;
-            const perigee = (rp - 1.0) * satrec.radiusearthkm;
-            // - for perigees below 156 km, s and qoms2t are altered -
-            if (perigee < 156.0) {
-                sfour = perigee - 78.0;
-                if (perigee < 98.0) {
-                    sfour = 20.0;
-                }
-                // Sgp4fix use multiply for speed instead of pow
-                const qzms24temp = (120.0 - sfour) / satrec.radiusearthkm;
-                qzms24 = qzms24temp * qzms24temp * qzms24temp * qzms24temp;
-                sfour = sfour / satrec.radiusearthkm + 1.0;
-            }
-            const PInvsq = 1.0 / posq;
-            const tsi = 1.0 / (ao - sfour);
-            satrec.eta = ao * satrec.ecco * tsi;
-            const etasq = satrec.eta * satrec.eta;
-            const eeta = satrec.ecco * satrec.eta;
-            const psisq = Math.abs(1.0 - etasq);
-            const coef = qzms24 * tsi ** 4.0;
-            const coef1 = coef / psisq ** 3.5;
-            const cc2 = coef1 *
-                satrec.no *
-                (ao * (1.0 + 1.5 * etasq + eeta * (4.0 + etasq)) +
-                    ((0.375 * j2 * tsi) / psisq) * satrec.con41 * (8.0 + 3.0 * etasq * (8.0 + etasq)));
-            satrec.cc1 = satrec.bstar * cc2;
-            let cc3 = 0.0;
-            if (satrec.ecco > 1.0e-4) {
-                cc3 = (-2.0 * coef * tsi * j3oj2 * satrec.no * sinio) / satrec.ecco;
-            }
-            satrec.x1mth2 = 1.0 - cosio2;
-            satrec.cc4 =
-                2.0 *
-                    satrec.no *
-                    coef1 *
-                    ao *
-                    omeosq *
-                    (satrec.eta * (2.0 + 0.5 * etasq) +
-                        satrec.ecco * (0.5 + 2.0 * etasq) -
-                        ((j2 * tsi) / (ao * psisq)) *
-                            (-3.0 * satrec.con41 * (1.0 - 2.0 * eeta + etasq * (1.5 - 0.5 * eeta)) +
-                                0.75 * satrec.x1mth2 * (2.0 * etasq - eeta * (1.0 + etasq)) * Math.cos(2.0 * satrec.argpo)));
-            satrec.cc5 = 2.0 * coef1 * ao * omeosq * (1.0 + 2.75 * (etasq + eeta) + eeta * etasq);
-            const cosio4 = cosio2 * cosio2;
-            const temp1 = 1.5 * j2 * PInvsq * satrec.no;
-            const temp2 = 0.5 * temp1 * j2 * PInvsq;
-            const temp3 = -0.46875 * j4 * PInvsq * PInvsq * satrec.no;
-            satrec.mdot =
-                satrec.no +
-                    0.5 * temp1 * rteosq * satrec.con41 +
-                    0.0625 * temp2 * rteosq * (13.0 - 78.0 * cosio2 + 137.0 * cosio4);
-            satrec.argpdot =
-                -0.5 * temp1 * con42 +
-                    0.0625 * temp2 * (7.0 - 114.0 * cosio2 + 395.0 * cosio4) +
-                    temp3 * (3.0 - 36.0 * cosio2 + 49.0 * cosio4);
-            const xhdot1 = -temp1 * cosio;
-            satrec.nodedot = xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * cosio2) + 2.0 * temp3 * (3.0 - 7.0 * cosio2)) * cosio;
-            const xPIdot = satrec.argpdot + satrec.nodedot;
-            satrec.omgcof = satrec.bstar * cc3 * Math.cos(satrec.argpo);
-            satrec.xmcof = 0.0;
-            if (satrec.ecco > 1.0e-4) {
-                satrec.xmcof = (-x2o3 * coef * satrec.bstar) / eeta;
-            }
-            satrec.nodecf = 3.5 * omeosq * xhdot1 * satrec.cc1;
-            satrec.t2cof = 1.5 * satrec.cc1;
-            // Sgp4fix for divide by zero with xinco = 180 deg
-            if (Math.abs(cosio + 1.0) > 1.5e-12) {
-                satrec.xlcof = (-0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio)) / (1.0 + cosio);
-            }
-            else {
-                satrec.xlcof = (-0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio)) / temp4;
-            }
-            satrec.aycof = -0.5 * j3oj2 * sinio;
-            // Sgp4fix use multiply for speed instead of pow
-            const delmotemp = 1.0 + satrec.eta * Math.cos(satrec.mo);
-            satrec.delmo = delmotemp * delmotemp * delmotemp;
-            satrec.sinmao = Math.sin(satrec.mo);
-            satrec.x7thm1 = 7.0 * cosio2 - 1.0;
-            // --------------- deep space initialization -------------
-            if (TAU / satrec.no >= 225.0) {
-                satrec.method = Sgp4Methods.DEEP_SPACE;
-                satrec.isimp = true;
-                const tc = 0.0;
-                const inclm = satrec.inclo;
-                const dscomOptions = {
-                    epoch,
-                    ep: satrec.ecco,
-                    argpp: satrec.argpo,
-                    tc,
-                    inclp: satrec.inclo,
-                    nodep: satrec.nodeo,
-                    np: satrec.no,
-                    e3: satrec.e3,
-                    ee2: satrec.ee2,
-                    peo: satrec.peo,
-                    pgho: satrec.pgho,
-                    pho: satrec.pho,
-                    PInco: satrec.PInco,
-                    plo: satrec.plo,
-                    se2: satrec.se2,
-                    se3: satrec.se3,
-                    sgh2: satrec.sgh2,
-                    sgh3: satrec.sgh3,
-                    sgh4: satrec.sgh4,
-                    sh2: satrec.sh2,
-                    sh3: satrec.sh3,
-                    si2: satrec.si2,
-                    si3: satrec.si3,
-                    sl2: satrec.sl2,
-                    sl3: satrec.sl3,
-                    sl4: satrec.sl4,
-                    xgh2: satrec.xgh2,
-                    xgh3: satrec.xgh3,
-                    xgh4: satrec.xgh4,
-                    xh2: satrec.xh2,
-                    xh3: satrec.xh3,
-                    xi2: satrec.xi2,
-                    xi3: satrec.xi3,
-                    xl2: satrec.xl2,
-                    xl3: satrec.xl3,
-                    xl4: satrec.xl4,
-                    zmol: satrec.zmol,
-                    zmos: satrec.zmos,
-                };
-                const dscomResult = Sgp4.dscom_(dscomOptions);
-                satrec.e3 = dscomResult.e3;
-                satrec.ee2 = dscomResult.ee2;
-                satrec.peo = dscomResult.peo;
-                satrec.pgho = dscomResult.pgho;
-                satrec.pho = dscomResult.pho;
-                satrec.PInco = dscomResult.PInco;
-                satrec.plo = dscomResult.plo;
-                satrec.se2 = dscomResult.se2;
-                satrec.se3 = dscomResult.se3;
-                satrec.sgh2 = dscomResult.sgh2;
-                satrec.sgh3 = dscomResult.sgh3;
-                satrec.sgh4 = dscomResult.sgh4;
-                satrec.sh2 = dscomResult.sh2;
-                satrec.sh3 = dscomResult.sh3;
-                satrec.si2 = dscomResult.si2;
-                satrec.si3 = dscomResult.si3;
-                satrec.sl2 = dscomResult.sl2;
-                satrec.sl3 = dscomResult.sl3;
-                satrec.sl4 = dscomResult.sl4;
-                const { sinim, cosim, em, emsq, s1, s2, s3, s4, s5, ss1, ss2, ss3, ss4, ss5, sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33, } = dscomResult;
-                satrec.xgh2 = dscomResult.xgh2;
-                satrec.xgh3 = dscomResult.xgh3;
-                satrec.xgh4 = dscomResult.xgh4;
-                satrec.xh2 = dscomResult.xh2;
-                satrec.xh3 = dscomResult.xh3;
-                satrec.xi2 = dscomResult.xi2;
-                satrec.xi3 = dscomResult.xi3;
-                satrec.xl2 = dscomResult.xl2;
-                satrec.xl3 = dscomResult.xl3;
-                satrec.xl4 = dscomResult.xl4;
-                satrec.zmol = dscomResult.zmol;
-                satrec.zmos = dscomResult.zmos;
-                const { nm, z1, z3, z11, z13, z21, z23, z31, z33 } = dscomResult;
-                const dpperOptions = {
-                    inclo: inclm,
-                    init: satrec.init,
-                    ep: satrec.ecco,
-                    inclp: satrec.inclo,
-                    nodep: satrec.nodeo,
-                    argpp: satrec.argpo,
-                    mp: satrec.mo,
-                    opsmode: satrec.operationmode,
-                    satrec,
-                };
-                const dpperResult = Sgp4.dpper_(dpperOptions);
-                satrec.ecco = dpperResult.ep;
-                satrec.inclo = dpperResult.inclp;
-                satrec.nodeo = dpperResult.nodep;
-                satrec.argpo = dpperResult.argpp;
-                satrec.mo = dpperResult.mp;
-                const argpm = 0.0;
-                const nodem = 0.0;
-                const mm = 0.0;
-                const dsinitOptions = {
-                    xke,
-                    cosim,
-                    emsq,
-                    argpo: satrec.argpo,
-                    s1,
-                    s2,
-                    s3,
-                    s4,
-                    s5,
-                    sinim,
-                    ss1,
-                    ss2,
-                    ss3,
-                    ss4,
-                    ss5,
-                    sz1,
-                    sz3,
-                    sz11,
-                    sz13,
-                    sz21,
-                    sz23,
-                    sz31,
-                    sz33,
-                    t: satrec.t,
-                    tc,
-                    gsto: satrec.gsto,
-                    mo: satrec.mo,
-                    mdot: satrec.mdot,
-                    no: satrec.no,
-                    nodeo: satrec.nodeo,
-                    nodedot: satrec.nodedot,
-                    xPIdot,
-                    z1,
-                    z3,
-                    z11,
-                    z13,
-                    z21,
-                    z23,
-                    z31,
-                    z33,
-                    ecco: satrec.ecco,
-                    eccsq,
-                    em,
-                    argpm,
-                    inclm,
-                    mm,
-                    nm,
-                    nodem,
-                    irez: satrec.irez,
-                    atime: satrec.atime,
-                    d2201: satrec.d2201,
-                    d2211: satrec.d2211,
-                    d3210: satrec.d3210,
-                    d3222: satrec.d3222,
-                    d4410: satrec.d4410,
-                    d4422: satrec.d4422,
-                    d5220: satrec.d5220,
-                    d5232: satrec.d5232,
-                    d5421: satrec.d5421,
-                    d5433: satrec.d5433,
-                    dedt: satrec.dedt,
-                    didt: satrec.didt,
-                    dmdt: satrec.dmdt,
-                    dnodt: satrec.dnodt,
-                    domdt: satrec.domdt,
-                    del1: satrec.del1,
-                    del2: satrec.del2,
-                    del3: satrec.del3,
-                    xfact: satrec.xfact,
-                    xlamo: satrec.xlamo,
-                    xli: satrec.xli,
-                    xni: satrec.xni,
-                };
-                const dsinitResult = Sgp4.dsinit_(dsinitOptions);
-                satrec.irez = dsinitResult.irez;
-                satrec.atime = dsinitResult.atime;
-                satrec.d2201 = dsinitResult.d2201;
-                satrec.d2211 = dsinitResult.d2211;
-                satrec.d3210 = dsinitResult.d3210;
-                satrec.d3222 = dsinitResult.d3222;
-                satrec.d4410 = dsinitResult.d4410;
-                satrec.d4422 = dsinitResult.d4422;
-                satrec.d5220 = dsinitResult.d5220;
-                satrec.d5232 = dsinitResult.d5232;
-                satrec.d5421 = dsinitResult.d5421;
-                satrec.d5433 = dsinitResult.d5433;
-                satrec.dedt = dsinitResult.dedt;
-                satrec.didt = dsinitResult.didt;
-                satrec.dmdt = dsinitResult.dmdt;
-                satrec.dnodt = dsinitResult.dnodt;
-                satrec.domdt = dsinitResult.domdt;
-                satrec.del1 = dsinitResult.del1;
-                satrec.del2 = dsinitResult.del2;
-                satrec.del3 = dsinitResult.del3;
-                satrec.xfact = dsinitResult.xfact;
-                satrec.xlamo = dsinitResult.xlamo;
-                satrec.xli = dsinitResult.xli;
-                satrec.xni = dsinitResult.xni;
-            }
-            // ----------- set variables if not deep space -----------
-            if (!satrec.isimp) {
-                const cc1sq = satrec.cc1 * satrec.cc1;
-                satrec.d2 = 4.0 * ao * tsi * cc1sq;
-                const temp = (satrec.d2 * tsi * satrec.cc1) / 3.0;
-                satrec.d3 = (17.0 * ao + sfour) * temp;
-                satrec.d4 = 0.5 * temp * ao * tsi * (221.0 * ao + 31.0 * sfour) * satrec.cc1;
-                satrec.t3cof = satrec.d2 + 2.0 * cc1sq;
-                satrec.t4cof = 0.25 * (3.0 * satrec.d3 + satrec.cc1 * (12.0 * satrec.d2 + 10.0 * cc1sq));
-                satrec.t5cof =
-                    0.2 *
-                        (3.0 * satrec.d4 +
-                            12.0 * satrec.cc1 * satrec.d3 +
-                            6.0 * satrec.d2 * satrec.d2 +
-                            15.0 * cc1sq * (2.0 * satrec.d2 + cc1sq));
-            } // If omeosq = 0 ...
-            /* Finally propogate to zero epoch to initialize all others. */
-            /*
-             * Sgp4fix take out check to let satellites process until they are actually below earth surface
-             * if(satrec.error == 0)
-             */
-        }
-        Sgp4.propagate(satrec, 0);
-        satrec.init = false;
-        /*
-         * Sgp4fix return boolean. satrec.error contains any error codes
-         *  return satrec; -- no reason to return anything in JS
-         */
-    }
-}
-//# sourceMappingURL=sgp4.js.map