ootk 6.0.0 → 6.0.1

package/dist/main.js

@@ -14041,7 +14041,7 @@ ${this.line2}`;
     bstar1 *= 10 ** exponent;
     if (bstarSymbol === "-") {
       bstar1 *= -1;
-    } else if (bstarSymbol === "+" || bstarSymbol === " ") ; else {
+    } else if (bstarSymbol === "+" || bstarSymbol === " " || bstarSymbol === "0") ; else {
       throw new ParseError(`Invalid BSTAR symbol: ${bstarSymbol}`, "TLE");
     }
     return toPrecision(bstar1, 14);
@@ -14251,7 +14251,8 @@ ${this.line2}`;
    * @returns The first derivative of the mean motion.
    */
   static meanMoDev1(tleLine1) {
-    const meanMoDev1 = parseFloat(tleLine1.substring(_Tle.meanMoDev1_.start, _Tle.meanMoDev1_.stop));
+    const raw = tleLine1.substring(_Tle.meanMoDev1_.start, _Tle.meanMoDev1_.stop).trim();
+    const meanMoDev1 = parseFloat(raw.startsWith("+") ? raw.substring(1) : raw);
     if (isNaN(meanMoDev1)) {
       throw new ParseError("Invalid first derivative of mean motion", "TLE");
     }
@@ -16586,6 +16587,14 @@ var Satellite = class _Satellite extends SpaceObject {
       name
     });
   }
+  /**
+   * Creates a Satellite from an OMM (Orbit Mean-elements Message) data object.
+   * @param omm - The OMM data in flat format
+   * @param name - Optional satellite name (overrides OMM OBJECT_NAME)
+   */
+  static fromOmm(omm, name) {
+    return new _Satellite({ omm, name: name ?? omm.OBJECT_NAME });
+  }
   // ==================== TLE/OMM Parsing ====================
   parseTleAndUpdateOrbit_(tle1, tle2, sccNum) {
     const tleData = Tle.parse(tle1, tle2);
@@ -25123,6 +25132,513 @@ var OdmExporter = class _OdmExporter {
   }
 };
 
+// src/parsers/OmmParser.ts
+var OmmParser = class _OmmParser {
+  constructor() {
+  }
+  /**
+   * Parse OMM KVN format text into structured data.
+   * @param content - The raw OMM file content as a string
+   * @returns Parsed OMM structure with all sections
+   * @throws ParseError if the file cannot be parsed or is missing required fields
+   */
+  static parse(content) {
+    const lines = content.split(/\r?\n/u).map((l) => l.trim()).filter((l) => l.length > 0);
+    const keyValues = _OmmParser.parseKeyValues_(lines);
+    const comments = _OmmParser.parseComments_(lines);
+    const header = _OmmParser.parseHeader_(keyValues, comments.header);
+    const metadata = _OmmParser.parseMetadata_(keyValues, comments.metadata);
+    const meanElements = _OmmParser.parseMeanElements_(keyValues, comments.meanElements);
+    const result = { header, metadata, meanElements };
+    const spacecraftParameters = _OmmParser.parseSpacecraftParameters_(keyValues, comments.spacecraft);
+    if (spacecraftParameters) {
+      result.spacecraftParameters = spacecraftParameters;
+    }
+    const tleParameters = _OmmParser.parseTleParameters_(keyValues, comments.tle);
+    if (tleParameters) {
+      result.tleParameters = tleParameters;
+    }
+    const covarianceMatrix = _OmmParser.parseCovarianceMatrix_(keyValues, comments.covariance);
+    if (covarianceMatrix) {
+      result.covarianceMatrix = covarianceMatrix;
+    }
+    const userDefined = _OmmParser.parseUserDefined_(keyValues);
+    if (userDefined) {
+      result.userDefined = userDefined;
+    }
+    _OmmParser.validate_(result);
+    return result;
+  }
+  /**
+   * Check if a parsed OMM represents TLE-compatible data.
+   * @param omm - Parsed OMM structure
+   * @returns true if the OMM uses SGP, SGP4, or SGP4-XP mean element theory
+   */
+  static isTleCompatible(omm) {
+    const theory = omm.metadata.MEAN_ELEMENT_THEORY.toUpperCase();
+    return theory === "SGP" || theory === "SGP4" || theory === "SGP4-XP";
+  }
+  /**
+   * Parse all key-value pairs from OMM lines (excluding COMMENT lines).
+   */
+  static parseKeyValues_(lines) {
+    const keyValues = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      if (line.startsWith("COMMENT")) {
+        continue;
+      }
+      if (!line.includes("=")) {
+        continue;
+      }
+      const eqIndex = line.indexOf("=");
+      const key = line.substring(0, eqIndex).trim();
+      const value = line.substring(eqIndex + 1).trim();
+      keyValues.set(key, value);
+    }
+    return keyValues;
+  }
+  /**
+   * Parse COMMENT lines and assign them to sections based on position.
+   *
+   * Comments are assigned to sections based on the keywords that follow them.
+   * The OMM KVN format allows comments at the beginning of each section.
+   */
+  static parseComments_(lines) {
+    const result = {
+      header: [],
+      metadata: [],
+      meanElements: [],
+      spacecraft: [],
+      tle: [],
+      covariance: []
+    };
+    let section = "header";
+    const pendingComments = [];
+    for (const line of lines) {
+      if (line.startsWith("COMMENT")) {
+        pendingComments.push(line.substring(7).trim());
+        continue;
+      }
+      if (!line.includes("=")) {
+        continue;
+      }
+      const eqIndex = line.indexOf("=");
+      const key = line.substring(0, eqIndex).trim();
+      if (key === "OBJECT_NAME") {
+        section = "metadata";
+      } else if (key === "EPOCH") {
+        section = "meanElements";
+      } else if (key === "MASS" || key === "SOLAR_RAD_AREA") {
+        section = "spacecraft";
+      } else if (key === "EPHEMERIS_TYPE" || key === "CLASSIFICATION_TYPE" || key === "NORAD_CAT_ID") {
+        section = "tle";
+      } else if (key === "COV_REF_FRAME" || key === "CX_X") {
+        section = "covariance";
+      }
+      if (pendingComments.length > 0) {
+        result[section].push(...pendingComments);
+        pendingComments.length = 0;
+      }
+    }
+    if (pendingComments.length > 0) {
+      result[section].push(...pendingComments);
+    }
+    return result;
+  }
+  /**
+   * Parse header section.
+   * @see CCSDS 502.0-B-3 Table 4-1
+   */
+  static parseHeader_(kv, comments) {
+    const version = kv.get("CCSDS_OMM_VERS");
+    if (!version) {
+      throw new ParseError("Missing required CCSDS_OMM_VERS field", "OMM");
+    }
+    const creationDate = kv.get("CREATION_DATE");
+    if (!creationDate) {
+      throw new ParseError("Missing required CREATION_DATE field", "OMM");
+    }
+    const originator = kv.get("ORIGINATOR");
+    if (!originator) {
+      throw new ParseError("Missing required ORIGINATOR field", "OMM");
+    }
+    const header = {
+      CCSDS_OMM_VERS: version,
+      CREATION_DATE: creationDate,
+      ORIGINATOR: originator
+    };
+    const messageId = kv.get("MESSAGE_ID");
+    if (messageId) {
+      header.MESSAGE_ID = messageId;
+    }
+    const classification = kv.get("CLASSIFICATION");
+    if (classification) {
+      header.CLASSIFICATION = classification;
+    }
+    if (comments.length > 0) {
+      header.COMMENT = comments;
+    }
+    return header;
+  }
+  /**
+   * Parse metadata section.
+   * @see CCSDS 502.0-B-3 Table 4-2
+   */
+  static parseMetadata_(kv, comments) {
+    const objectName = kv.get("OBJECT_NAME");
+    if (!objectName) {
+      throw new ParseError("Missing required OBJECT_NAME field", "OMM");
+    }
+    const objectId = kv.get("OBJECT_ID");
+    if (!objectId) {
+      throw new ParseError("Missing required OBJECT_ID field", "OMM");
+    }
+    const centerName = kv.get("CENTER_NAME");
+    if (!centerName) {
+      throw new ParseError("Missing required CENTER_NAME field", "OMM");
+    }
+    const refFrame = kv.get("REF_FRAME");
+    if (!refFrame) {
+      throw new ParseError("Missing required REF_FRAME field", "OMM");
+    }
+    const timeSystem = kv.get("TIME_SYSTEM");
+    if (!timeSystem) {
+      throw new ParseError("Missing required TIME_SYSTEM field", "OMM");
+    }
+    const meanElementTheory = kv.get("MEAN_ELEMENT_THEORY");
+    if (!meanElementTheory) {
+      throw new ParseError("Missing required MEAN_ELEMENT_THEORY field", "OMM");
+    }
+    const metadata = {
+      OBJECT_NAME: objectName,
+      OBJECT_ID: objectId,
+      CENTER_NAME: centerName,
+      REF_FRAME: refFrame,
+      TIME_SYSTEM: timeSystem,
+      MEAN_ELEMENT_THEORY: meanElementTheory
+    };
+    const refFrameEpoch = kv.get("REF_FRAME_EPOCH");
+    if (refFrameEpoch) {
+      metadata.REF_FRAME_EPOCH = refFrameEpoch;
+    }
+    if (comments.length > 0) {
+      metadata.COMMENT = comments;
+    }
+    return metadata;
+  }
+  /**
+   * Parse mean Keplerian elements section.
+   * @see CCSDS 502.0-B-3 Table 4-3
+   */
+  static parseMeanElements_(kv, comments) {
+    const epoch = kv.get("EPOCH");
+    if (!epoch) {
+      throw new ParseError("Missing required EPOCH field", "OMM");
+    }
+    const semiMajorAxis = _OmmParser.parseOptionalFloat_(kv, "SEMI_MAJOR_AXIS");
+    const meanMotion = _OmmParser.parseOptionalFloat_(kv, "MEAN_MOTION");
+    if (semiMajorAxis === void 0 && meanMotion === void 0) {
+      throw new ParseError("Either SEMI_MAJOR_AXIS or MEAN_MOTION must be provided", "OMM");
+    }
+    const eccentricity = _OmmParser.parseRequiredFloat_(kv, "ECCENTRICITY");
+    const inclination = _OmmParser.parseRequiredFloat_(kv, "INCLINATION");
+    const raOfAscNode = _OmmParser.parseRequiredFloat_(kv, "RA_OF_ASC_NODE");
+    const argOfPericenter = _OmmParser.parseRequiredFloat_(kv, "ARG_OF_PERICENTER");
+    const meanAnomaly = _OmmParser.parseRequiredFloat_(kv, "MEAN_ANOMALY");
+    const elements = {
+      EPOCH: epoch,
+      ECCENTRICITY: eccentricity,
+      INCLINATION: inclination,
+      RA_OF_ASC_NODE: raOfAscNode,
+      ARG_OF_PERICENTER: argOfPericenter,
+      MEAN_ANOMALY: meanAnomaly
+    };
+    if (semiMajorAxis !== void 0) {
+      elements.SEMI_MAJOR_AXIS = semiMajorAxis;
+    }
+    if (meanMotion !== void 0) {
+      elements.MEAN_MOTION = meanMotion;
+    }
+    const gm = _OmmParser.parseOptionalFloat_(kv, "GM");
+    if (gm !== void 0) {
+      elements.GM = gm;
+    }
+    if (comments.length > 0) {
+      elements.COMMENT = comments;
+    }
+    return elements;
+  }
+  /**
+   * Parse optional spacecraft parameters section.
+   * @see CCSDS 502.0-B-3 Table 4-3
+   */
+  static parseSpacecraftParameters_(kv, comments) {
+    const mass = _OmmParser.parseOptionalFloat_(kv, "MASS");
+    const solarRadArea = _OmmParser.parseOptionalFloat_(kv, "SOLAR_RAD_AREA");
+    const solarRadCoeff = _OmmParser.parseOptionalFloat_(kv, "SOLAR_RAD_COEFF");
+    const dragArea = _OmmParser.parseOptionalFloat_(kv, "DRAG_AREA");
+    const dragCoeff = _OmmParser.parseOptionalFloat_(kv, "DRAG_COEFF");
+    if (mass === void 0 && solarRadArea === void 0 && solarRadCoeff === void 0 && dragArea === void 0 && dragCoeff === void 0 && comments.length === 0) {
+      return null;
+    }
+    const params = {};
+    if (mass !== void 0) {
+      params.MASS = mass;
+    }
+    if (solarRadArea !== void 0) {
+      params.SOLAR_RAD_AREA = solarRadArea;
+    }
+    if (solarRadCoeff !== void 0) {
+      params.SOLAR_RAD_COEFF = solarRadCoeff;
+    }
+    if (dragArea !== void 0) {
+      params.DRAG_AREA = dragArea;
+    }
+    if (dragCoeff !== void 0) {
+      params.DRAG_COEFF = dragCoeff;
+    }
+    if (comments.length > 0) {
+      params.COMMENT = comments;
+    }
+    return params;
+  }
+  /**
+   * Parse optional TLE-related parameters section.
+   * @see CCSDS 502.0-B-3 Table 4-3
+   */
+  static parseTleParameters_(kv, comments) {
+    const ephemerisType = _OmmParser.parseOptionalInt_(kv, "EPHEMERIS_TYPE");
+    const classificationType = kv.get("CLASSIFICATION_TYPE");
+    const noradCatId = _OmmParser.parseOptionalInt_(kv, "NORAD_CAT_ID");
+    const elementSetNo = _OmmParser.parseOptionalInt_(kv, "ELEMENT_SET_NO");
+    const revAtEpoch = _OmmParser.parseOptionalInt_(kv, "REV_AT_EPOCH");
+    const bstar = _OmmParser.parseOptionalFloat_(kv, "BSTAR");
+    const bterm = _OmmParser.parseOptionalFloat_(kv, "BTERM");
+    const meanMotionDot = _OmmParser.parseOptionalFloat_(kv, "MEAN_MOTION_DOT");
+    const meanMotionDdot = _OmmParser.parseOptionalFloat_(kv, "MEAN_MOTION_DDOT");
+    const agom = _OmmParser.parseOptionalFloat_(kv, "AGOM");
+    if (ephemerisType === void 0 && classificationType === void 0 && noradCatId === void 0 && elementSetNo === void 0 && revAtEpoch === void 0 && bstar === void 0 && bterm === void 0 && meanMotionDot === void 0 && meanMotionDdot === void 0 && agom === void 0 && comments.length === 0) {
+      return null;
+    }
+    const params = {};
+    if (ephemerisType !== void 0) {
+      params.EPHEMERIS_TYPE = ephemerisType;
+    }
+    if (classificationType !== void 0) {
+      params.CLASSIFICATION_TYPE = classificationType;
+    }
+    if (noradCatId !== void 0) {
+      params.NORAD_CAT_ID = noradCatId;
+    }
+    if (elementSetNo !== void 0) {
+      params.ELEMENT_SET_NO = elementSetNo;
+    }
+    if (revAtEpoch !== void 0) {
+      params.REV_AT_EPOCH = revAtEpoch;
+    }
+    if (bstar !== void 0) {
+      params.BSTAR = bstar;
+    }
+    if (bterm !== void 0) {
+      params.BTERM = bterm;
+    }
+    if (meanMotionDot !== void 0) {
+      params.MEAN_MOTION_DOT = meanMotionDot;
+    }
+    if (meanMotionDdot !== void 0) {
+      params.MEAN_MOTION_DDOT = meanMotionDdot;
+    }
+    if (agom !== void 0) {
+      params.AGOM = agom;
+    }
+    if (comments.length > 0) {
+      params.COMMENT = comments;
+    }
+    return params;
+  }
+  /**
+   * Parse optional covariance matrix section.
+   * @see CCSDS 502.0-B-3 Table 4-3
+   */
+  static parseCovarianceMatrix_(kv, comments) {
+    const cxX = _OmmParser.parseOptionalFloat_(kv, "CX_X");
+    if (cxX === void 0) {
+      return null;
+    }
+    const cov = {
+      CX_X: cxX,
+      CY_X: _OmmParser.parseOptionalFloat_(kv, "CY_X"),
+      CY_Y: _OmmParser.parseOptionalFloat_(kv, "CY_Y"),
+      CZ_X: _OmmParser.parseOptionalFloat_(kv, "CZ_X"),
+      CZ_Y: _OmmParser.parseOptionalFloat_(kv, "CZ_Y"),
+      CZ_Z: _OmmParser.parseOptionalFloat_(kv, "CZ_Z"),
+      CX_DOT_X: _OmmParser.parseOptionalFloat_(kv, "CX_DOT_X"),
+      CX_DOT_Y: _OmmParser.parseOptionalFloat_(kv, "CX_DOT_Y"),
+      CX_DOT_Z: _OmmParser.parseOptionalFloat_(kv, "CX_DOT_Z"),
+      CX_DOT_X_DOT: _OmmParser.parseOptionalFloat_(kv, "CX_DOT_X_DOT"),
+      CY_DOT_X: _OmmParser.parseOptionalFloat_(kv, "CY_DOT_X"),
+      CY_DOT_Y: _OmmParser.parseOptionalFloat_(kv, "CY_DOT_Y"),
+      CY_DOT_Z: _OmmParser.parseOptionalFloat_(kv, "CY_DOT_Z"),
+      CY_DOT_X_DOT: _OmmParser.parseOptionalFloat_(kv, "CY_DOT_X_DOT"),
+      CY_DOT_Y_DOT: _OmmParser.parseOptionalFloat_(kv, "CY_DOT_Y_DOT"),
+      CZ_DOT_X: _OmmParser.parseOptionalFloat_(kv, "CZ_DOT_X"),
+      CZ_DOT_Y: _OmmParser.parseOptionalFloat_(kv, "CZ_DOT_Y"),
+      CZ_DOT_Z: _OmmParser.parseOptionalFloat_(kv, "CZ_DOT_Z"),
+      CZ_DOT_X_DOT: _OmmParser.parseOptionalFloat_(kv, "CZ_DOT_X_DOT"),
+      CZ_DOT_Y_DOT: _OmmParser.parseOptionalFloat_(kv, "CZ_DOT_Y_DOT"),
+      CZ_DOT_Z_DOT: _OmmParser.parseOptionalFloat_(kv, "CZ_DOT_Z_DOT")
+    };
+    const covRefFrame = kv.get("COV_REF_FRAME");
+    if (covRefFrame) {
+      cov.COV_REF_FRAME = covRefFrame;
+    }
+    if (comments.length > 0) {
+      cov.COMMENT = comments;
+    }
+    return cov;
+  }
+  /**
+   * Parse user-defined parameters section.
+   */
+  static parseUserDefined_(kv) {
+    const userDefined = {};
+    let found = false;
+    for (const [key, value] of kv) {
+      if (key.startsWith("USER_DEFINED_")) {
+        userDefined[key] = value;
+        found = true;
+      }
+    }
+    return found ? userDefined : null;
+  }
+  /**
+   * Parse a required float field.
+   * @throws ParseError if the field is missing or not a valid number
+   */
+  static parseRequiredFloat_(kv, key) {
+    const value = kv.get(key);
+    if (value === void 0) {
+      throw new ParseError(`Missing required ${key} field`, "OMM");
+    }
+    const parsed = parseFloat(value);
+    if (isNaN(parsed)) {
+      throw new ParseError(`Invalid numeric value for ${key}: ${value}`, "OMM");
+    }
+    return parsed;
+  }
+  /**
+   * Parse an optional float field.
+   */
+  static parseOptionalFloat_(kv, key) {
+    const value = kv.get(key);
+    if (value === void 0) {
+      return void 0;
+    }
+    const parsed = parseFloat(value);
+    return isNaN(parsed) ? void 0 : parsed;
+  }
+  /**
+   * Parse an optional integer field.
+   */
+  static parseOptionalInt_(kv, key) {
+    const value = kv.get(key);
+    if (value === void 0) {
+      return void 0;
+    }
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? void 0 : parsed;
+  }
+  /**
+   * Validate parsed OMM for required fields and consistency.
+   * @throws ParseError if validation fails
+   */
+  static validate_(omm) {
+    const errors = [];
+    if (!omm.header.CCSDS_OMM_VERS) {
+      errors.push("Missing CCSDS_OMM_VERS");
+    }
+    if (!omm.header.CREATION_DATE) {
+      errors.push("Missing CREATION_DATE");
+    }
+    if (!omm.header.ORIGINATOR) {
+      errors.push("Missing ORIGINATOR");
+    }
+    if (!omm.metadata.OBJECT_NAME) {
+      errors.push("Missing OBJECT_NAME");
+    }
+    if (!omm.metadata.OBJECT_ID) {
+      errors.push("Missing OBJECT_ID");
+    }
+    if (!omm.metadata.CENTER_NAME) {
+      errors.push("Missing CENTER_NAME");
+    }
+    if (!omm.metadata.REF_FRAME) {
+      errors.push("Missing REF_FRAME");
+    }
+    if (!omm.metadata.TIME_SYSTEM) {
+      errors.push("Missing TIME_SYSTEM");
+    }
+    if (!omm.metadata.MEAN_ELEMENT_THEORY) {
+      errors.push("Missing MEAN_ELEMENT_THEORY");
+    }
+    if (!omm.meanElements.EPOCH) {
+      errors.push("Missing EPOCH");
+    }
+    if (omm.meanElements.SEMI_MAJOR_AXIS === void 0 && omm.meanElements.MEAN_MOTION === void 0) {
+      errors.push("Either SEMI_MAJOR_AXIS or MEAN_MOTION must be provided");
+    }
+    const theory = omm.metadata.MEAN_ELEMENT_THEORY?.toUpperCase();
+    if (theory === "SGP" || theory === "SGP4") {
+      if (omm.meanElements.MEAN_MOTION === void 0) {
+        errors.push("MEAN_MOTION is required when MEAN_ELEMENT_THEORY is SGP/SGP4");
+      }
+    }
+    if (theory === "SGP" || theory === "SGP4" || theory === "SGP4-XP") {
+      if (omm.metadata.CENTER_NAME !== "EARTH") {
+        errors.push("CENTER_NAME must be EARTH for SGP/SGP4/SGP4-XP mean element theory");
+      }
+      if (omm.metadata.REF_FRAME !== "TEME") {
+        errors.push("REF_FRAME must be TEME for SGP/SGP4/SGP4-XP mean element theory");
+      }
+      if (omm.metadata.TIME_SYSTEM !== "UTC") {
+        errors.push("TIME_SYSTEM must be UTC for SGP/SGP4/SGP4-XP mean element theory");
+      }
+    }
+    if (omm.covarianceMatrix) {
+      const covKeys = [
+        "CX_X",
+        "CY_X",
+        "CY_Y",
+        "CZ_X",
+        "CZ_Y",
+        "CZ_Z",
+        "CX_DOT_X",
+        "CX_DOT_Y",
+        "CX_DOT_Z",
+        "CX_DOT_X_DOT",
+        "CY_DOT_X",
+        "CY_DOT_Y",
+        "CY_DOT_Z",
+        "CY_DOT_X_DOT",
+        "CY_DOT_Y_DOT",
+        "CZ_DOT_X",
+        "CZ_DOT_Y",
+        "CZ_DOT_Z",
+        "CZ_DOT_X_DOT",
+        "CZ_DOT_Y_DOT",
+        "CZ_DOT_Z_DOT"
+      ];
+      const missing = covKeys.filter((k) => omm.covarianceMatrix[k] === void 0);
+      if (missing.length > 0 && missing.length < covKeys.length) {
+        errors.push(`Incomplete covariance matrix: missing ${missing.join(", ")}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new ParseError(`OMM validation failed: ${errors.join(", ")}`, "OMM");
+    }
+  }
+};
+
 // src/comm/CommTypes.ts
 var ModulationType = /* @__PURE__ */ ((ModulationType3) => {
   ModulationType3["BPSK"] = "BPSK";
@@ -29261,4 +29777,4 @@ astronomy-engine/esm/astronomy.js:
    *)
 */
 
-export { AccessCalculator, AngularDiameterMethod, AngularDistanceMethod, Antenna, AtmosphericDrag, BaseObject, BatchLeastSquaresOD, BatchLeastSquaresResult, Beacon, BoxMuller, CatalogScreener, CatalogSource, CdmExporter, CdmParser, CelestialBody, CelestialBodyType, CenterBody, CenterBodyMu, ChebyshevCoefficients, ChebyshevCompressor, ChebyshevInterpolator, ClassicalElements, CommDeviceType, CommLink, CommunicationDevice, ConjunctionAssessment, ConjunctionEvent, ConstellationGenerator, ContactScheduler, ContactSelectionStrategy, CovarianceFrame, CovarianceRealism, CovarianceSample, CubicSpline, CubicSplineInterpolator, DEFAULT_INTERPOLATOR, DEFAULT_LAGRANGE_ORDER, DEG2RAD, DataHandler, DormandPrince54Propagator, DownhillSimplex, DynamicGroundObject, Earth, EarthGravity, EphemerisBody, EphemerisSatellite, Epoch, EpochGPS, EpochTAI, EpochTDB, EpochTT, EpochUTC, EpochWindow, EquinoctialElements, EulerAngles, FieldInterpolator, FieldOfView, Force, ForceModel, FormatTle, FovFrame, FovShape, Geodetic, GibbsIOD, GoldenSection, GoodingIOD, Gravity, GroundObject, GroundStation, HerrickGibbsIOD, Hill, History, HorizonsParser, ITRF, Interpolator, InterpolatorType, J20002 as J2000, Jupiter, KM_PER_AU, KeplerPropagator, LagrangeInterpolator, LambertIOD, LandObject, LaserRangingSensor, LaunchTrajectoryGenerator, LevenbergMarquardtOD, LevenbergMarquardtResult, MILLISECONDS_PER_DAY, MILLISECONDS_PER_SECOND, MILLISECONDS_TO_DAYS, MINUTES_PER_DAY, MS_PER_DAY, Marker, Mars, Matrix, MechanicalRadar, Mercury, ModifiedGoodingIOD, ModulationType, Moon, MoonBody, Neptune, OdmExporter, OemParser, OotkError, OpticalSensor, OrbitDeterminationError, OrbitFinder, OrbitRegime, PI, ParseError, PassType, PassiveRFSensor, PayloadStatus, PhasedArrayRadar, PlaneChangeBurn, PlanetBody, Pluto, PolynomialRegression, ProbabilityOfCollision, PropagationError, Propagator, PropagatorType, Quaternion, RAD2DEG, RADIUS_OF_EARTH, RAE, RIC, RadarSensor, RadecGeocentric, RadecTopocentric, Random, RandomGaussianSource, Receiver, RelativeState, RepeatGroundTrack, RkCheckpoint, RkResult, RungeKutta4Propagator, RungeKutta89Propagator, RungeKuttaAdaptive, SLR_WAVELENGTHS, SPEED_OF_LIGHT_KM_S, Satellite, Saturn, ScheduledContact, ScreeningFilter, SegmentedLagrangeInterpolator, Sensor, SensorType, Sgp4, Sgp4Error, Sgp4ErrorCode, Sgp4OpsMode, Sgp4Propagator, SimpleLinearRegression, SolarRadiationPressure, SolarSystem, SpaceObject, SpaceObjectType, Star, StateCovariance, StateInterpolator, StateVector2 as StateVector, Sun, SunBody, SunStatus, TAU, TEME, ThirdBodyGravity, Thrust, TimeStamped, Tle, Transmitter, Transponder, TwoBurnOrbitTransfer, Uranus, ValidationError, Vector, Vector3D, Venus, VerletBlendInterpolator, VisualizationHelpers, Waypoint, ZoomValue, acoth, acsch, angularDiameter, angularDistance, angularVelocityOfEarth, array2d, asec2rad, asech, azel2uv, bodyTypeLookup, boresightFrameFromAzElRoll, cKmPerMs, cKmPerSec, cMPerSec, calcGmst, calcIncFromAz, calcInertAz, calculateFspl, calculatePropagationDelay, clamp, concat, copySign, covariance, createCovarianceFromTle, createSampleCovarianceFromTle, createVec, csch, dbmToDbw, dbwToDbm, dbwToWatts, deg2rad, derivative, dopplerFactor, earthGravityParam, ecef2eci, ecef2enu, ecef2rae, ecefRad2rae, eci2ecef, eci2lla, eci2rae, enu2rf, estimateRcs, evalPoly, factorial, gamma, getDayOfYear, getDegLat, getDegLon, getRadLat, getRadLon, halfPi, isLeapYear, jacobian, jday, linearDistance, linearInterpolate, lla2ecef, lla2eci, lla2sez, llaRad2ecef, log10, mag2db, masec2rad, matchHalfPlane, mean, msec2sec, newtonM, newtonNu, normalizeAngle, observationDerivative, observationNoiseFromSigmas, parseCenterBody, rad2deg, radecToPosition, radecToVelocity, rae2ecef, rae2eci, rae2enu, rae2raeOffBoresight, rae2ruv, rae2sez, relativeVelocity, sec2day, sec2deg, sec2min, sech, secondsPerDay, secondsPerSiderealDay, secondsPerWeek, sez2rae, sign, spaceObjType2Str, std, temp4, toPrecision, ttasec2rad, uv2azel, wattsToDbw, wrapAngle, x2o3 };
+export { AccessCalculator, AngularDiameterMethod, AngularDistanceMethod, Antenna, AtmosphericDrag, BaseObject, BatchLeastSquaresOD, BatchLeastSquaresResult, Beacon, BoxMuller, CatalogScreener, CatalogSource, CdmExporter, CdmParser, CelestialBody, CelestialBodyType, CenterBody, CenterBodyMu, ChebyshevCoefficients, ChebyshevCompressor, ChebyshevInterpolator, ClassicalElements, CommDeviceType, CommLink, CommunicationDevice, ConjunctionAssessment, ConjunctionEvent, ConstellationGenerator, ContactScheduler, ContactSelectionStrategy, CovarianceFrame, CovarianceRealism, CovarianceSample, CubicSpline, CubicSplineInterpolator, DEFAULT_INTERPOLATOR, DEFAULT_LAGRANGE_ORDER, DEG2RAD, DataHandler, DormandPrince54Propagator, DownhillSimplex, DynamicGroundObject, Earth, EarthGravity, EphemerisBody, EphemerisSatellite, Epoch, EpochGPS, EpochTAI, EpochTDB, EpochTT, EpochUTC, EpochWindow, EquinoctialElements, EulerAngles, FieldInterpolator, FieldOfView, Force, ForceModel, FormatTle, FovFrame, FovShape, Geodetic, GibbsIOD, GoldenSection, GoodingIOD, Gravity, GroundObject, GroundStation, HerrickGibbsIOD, Hill, History, HorizonsParser, ITRF, Interpolator, InterpolatorType, J20002 as J2000, Jupiter, KM_PER_AU, KeplerPropagator, LagrangeInterpolator, LambertIOD, LandObject, LaserRangingSensor, LaunchTrajectoryGenerator, LevenbergMarquardtOD, LevenbergMarquardtResult, MILLISECONDS_PER_DAY, MILLISECONDS_PER_SECOND, MILLISECONDS_TO_DAYS, MINUTES_PER_DAY, MS_PER_DAY, Marker, Mars, Matrix, MechanicalRadar, Mercury, ModifiedGoodingIOD, ModulationType, Moon, MoonBody, Neptune, OdmExporter, OemParser, OmmParser, OotkError, OpticalSensor, OrbitDeterminationError, OrbitFinder, OrbitRegime, PI, ParseError, PassType, PassiveRFSensor, PayloadStatus, PhasedArrayRadar, PlaneChangeBurn, PlanetBody, Pluto, PolynomialRegression, ProbabilityOfCollision, PropagationError, Propagator, PropagatorType, Quaternion, RAD2DEG, RADIUS_OF_EARTH, RAE, RIC, RadarSensor, RadecGeocentric, RadecTopocentric, Random, RandomGaussianSource, Receiver, RelativeState, RepeatGroundTrack, RkCheckpoint, RkResult, RungeKutta4Propagator, RungeKutta89Propagator, RungeKuttaAdaptive, SLR_WAVELENGTHS, SPEED_OF_LIGHT_KM_S, Satellite, Saturn, ScheduledContact, ScreeningFilter, SegmentedLagrangeInterpolator, Sensor, SensorType, Sgp4, Sgp4Error, Sgp4ErrorCode, Sgp4OpsMode, Sgp4Propagator, SimpleLinearRegression, SolarRadiationPressure, SolarSystem, SpaceObject, SpaceObjectType, Star, StateCovariance, StateInterpolator, StateVector2 as StateVector, Sun, SunBody, SunStatus, TAU, TEME, ThirdBodyGravity, Thrust, TimeStamped, Tle, Transmitter, Transponder, TwoBurnOrbitTransfer, Uranus, ValidationError, Vector, Vector3D, Venus, VerletBlendInterpolator, VisualizationHelpers, Waypoint, ZoomValue, acoth, acsch, angularDiameter, angularDistance, angularVelocityOfEarth, array2d, asec2rad, asech, azel2uv, bodyTypeLookup, boresightFrameFromAzElRoll, cKmPerMs, cKmPerSec, cMPerSec, calcGmst, calcIncFromAz, calcInertAz, calculateFspl, calculatePropagationDelay, clamp, concat, copySign, covariance, createCovarianceFromTle, createSampleCovarianceFromTle, createVec, csch, dbmToDbw, dbwToDbm, dbwToWatts, deg2rad, derivative, dopplerFactor, earthGravityParam, ecef2eci, ecef2enu, ecef2rae, ecefRad2rae, eci2ecef, eci2lla, eci2rae, enu2rf, estimateRcs, evalPoly, factorial, gamma, getDayOfYear, getDegLat, getDegLon, getRadLat, getRadLon, halfPi, isLeapYear, jacobian, jday, linearDistance, linearInterpolate, lla2ecef, lla2eci, lla2sez, llaRad2ecef, log10, mag2db, masec2rad, matchHalfPlane, mean, msec2sec, newtonM, newtonNu, normalizeAngle, observationDerivative, observationNoiseFromSigmas, parseCenterBody, rad2deg, radecToPosition, radecToVelocity, rae2ecef, rae2eci, rae2enu, rae2raeOffBoresight, rae2ruv, rae2sez, relativeVelocity, sec2day, sec2deg, sec2min, sech, secondsPerDay, secondsPerSiderealDay, secondsPerWeek, sez2rae, sign, spaceObjType2Str, std, temp4, toPrecision, ttasec2rad, uv2azel, wattsToDbw, wrapAngle, x2o3 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ootk",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "type": "module",
   "description": "Orbital Object Toolkit including Multiple Propagators, Initial Orbit Determination, and Maneuver Calculations.",
   "exports": {