ootk 6.0.0 → 6.0.1

package/dist/main.cjs

@@ -14043,7 +14043,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);
@@ -14253,7 +14253,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");
     }
@@ -16588,6 +16589,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);
@@ -25125,6 +25134,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";
@@ -29367,6 +29883,7 @@ exports.MoonBody = MoonBody;
 exports.Neptune = Neptune;
 exports.OdmExporter = OdmExporter;
 exports.OemParser = OemParser;
+exports.OmmParser = OmmParser;
 exports.OotkError = OotkError;
 exports.OpticalSensor = OpticalSensor;
 exports.OrbitDeterminationError = OrbitDeterminationError;