ootk 6.0.0 → 6.0.2

package/dist/main.cjs

@@ -9857,13 +9857,26 @@ var FormatTle = class _FormatTle {
     const meanaStr = _FormatTle.meanAnomaly(meana);
     const ecenStr = _FormatTle.eccentricity(ecen);
     const intlStr = intl.padEnd(8, " ");
-    let TLE1Ending = tleParams.sat ? tleParams.sat.tle1.substring(32, 71) : " +.00000000 +00000+0 +00000-0 0  9990";
+    const classification = tleParams.classification ?? "U";
+    const elementSetNo = (tleParams.elementSetNo ?? 999).toString().padStart(4, " ");
+    const ephemerisType = (tleParams.ephemerisType ?? 0).toString();
+    const revAtEpoch = (tleParams.revAtEpoch ?? 0).toString().padStart(5, " ");
+    let TLE1Ending;
+    if (tleParams.sat) {
+      TLE1Ending = tleParams.sat.tle1.substring(32, 71);
+    } else {
+      const mmDot = _FormatTle.formatMeanMotionDot(tleParams.meanMotionDot ?? 0);
+      const mmDdot = _FormatTle.formatTleExponential(tleParams.meanMotionDdot ?? 0);
+      const bstarStr = _FormatTle.formatTleExponential(tleParams.bstar ?? 0);
+      TLE1Ending = ` ${mmDot} ${mmDdot} ${bstarStr} ${ephemerisType} ${elementSetNo}0`;
+    }
     TLE1Ending = TLE1Ending[1] === " " ? _FormatTle.setCharAt(TLE1Ending, 1, "+") : TLE1Ending;
     TLE1Ending = TLE1Ending[12] === " " ? _FormatTle.setCharAt(TLE1Ending, 12, "+") : TLE1Ending;
     TLE1Ending = TLE1Ending[21] === " " ? _FormatTle.setCharAt(TLE1Ending, 21, "+") : TLE1Ending;
-    TLE1Ending = TLE1Ending[32] === " " ? _FormatTle.setCharAt(TLE1Ending, 32, "0") : TLE1Ending;
-    const tle1 = `1 ${scc}U ${intlStr} ${epochYrStr}${epochdayStr}${TLE1Ending}`;
-    const tle2 = `2 ${scc} ${incStr} ${rascStr} ${ecenStr} ${argPeStr} ${meanaStr} ${meanmoStr} 00010`;
+    const tle1Pre = `1 ${scc}${classification} ${intlStr} ${epochYrStr}${epochdayStr}${TLE1Ending}`;
+    const tle1 = _FormatTle.setCharAt(tle1Pre, 68, _FormatTle.tleChecksum(tle1Pre).toString());
+    const tle2Pre = `2 ${scc} ${incStr} ${rascStr} ${ecenStr} ${argPeStr} ${meanaStr} ${meanmoStr}${revAtEpoch}0`;
+    const tle2 = _FormatTle.setCharAt(tle2Pre, 68, _FormatTle.tleChecksum(tle2Pre).toString());
     return { tle1, tle2 };
   }
   /**
@@ -9992,6 +10005,61 @@ var FormatTle = class _FormatTle {
     }
     return `${str.substring(0, index)}${chr}${str.substring(index + 1)}`;
   }
+  /**
+   * Format mean motion dot (first derivative / 2) for TLE line 1.
+   * Format: sign + ".NNNNNNNN" = 10 chars total.
+   * @param value - Mean motion dot value (rev/day^2)
+   * @returns Formatted 10-character string
+   */
+  static formatMeanMotionDot(value) {
+    const sign2 = value >= 0 ? " " : "-";
+    return sign2 + Math.abs(value).toFixed(8).substring(1);
+  }
+  /**
+   * Format a value in TLE exponential notation for BSTAR or mean motion ddot.
+   * Format: "sNNNNN±N" (8 chars) where mantissa has implied leading decimal point.
+   * Example: 0.00017507 → " 17507-3" (i.e., .17507 × 10^-3)
+   * @param value - The value to format
+   * @returns Formatted 8-character string
+   */
+  static formatTleExponential(value) {
+    if (value === 0) {
+      return " 00000-0";
+    }
+    const sign2 = value >= 0 ? " " : "-";
+    const absVal = Math.abs(value);
+    let exponent = Math.floor(Math.log10(absVal)) + 1;
+    let mantissa = absVal / Math.pow(10, exponent);
+    if (mantissa >= 1) {
+      mantissa /= 10;
+      exponent++;
+    }
+    if (mantissa < 0.1 && mantissa > 0) {
+      mantissa *= 10;
+      exponent--;
+    }
+    const mantissaStr = Math.round(mantissa * 1e5).toString().padStart(5, "0");
+    const expSign = exponent >= 0 ? "+" : "-";
+    const expStr = Math.abs(exponent).toString();
+    return sign2 + mantissaStr + expSign + expStr;
+  }
+  /**
+   * Compute TLE line checksum (modulo 10 sum of digits, '-' counts as 1).
+   * @param line - TLE line (first 68 characters are summed)
+   * @returns Checksum digit (0-9)
+   */
+  static tleChecksum(line) {
+    let sum = 0;
+    for (let i = 0; i < 68 && i < line.length; i++) {
+      const c = line[i];
+      if (c >= "0" && c <= "9") {
+        sum += parseInt(c);
+      } else if (c === "-") {
+        sum += 1;
+      }
+    }
+    return sum % 10;
+  }
 };
 
 // src/coordinate/RelativeState.ts
@@ -14043,7 +14111,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 +14321,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 +16657,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);
@@ -16616,8 +16693,9 @@ var Satellite = class _Satellite extends SpaceObject {
     this.satrec = Sgp4.createSatrec(tle1, tle2);
   }
   parseOmmAndUpdateOrbit_(omm) {
-    this.sccNum = omm.NORAD_CAT_ID.padStart(5, "0");
-    this.sccNum5 = Tle.convert6DigitToA5(omm.NORAD_CAT_ID);
+    const noradStr = String(omm.NORAD_CAT_ID);
+    this.sccNum = noradStr.padStart(5, "0");
+    this.sccNum5 = Tle.convert6DigitToA5(noradStr);
     this.sccNum6 = Tle.convertA5to6Digit(this.sccNum5);
     this.intlDes = omm.OBJECT_ID;
     const YYYY = omm.EPOCH.slice(0, 4);
@@ -16630,6 +16708,19 @@ var Satellite = class _Satellite extends SpaceObject {
     const dayOfYear = (epochDateObj - Date.UTC(Number(YYYY), 0, 0)) / 864e5;
     const ommParsed = {
       ...omm,
+      NORAD_CAT_ID: noradStr,
+      MEAN_MOTION: String(omm.MEAN_MOTION),
+      ECCENTRICITY: String(omm.ECCENTRICITY),
+      INCLINATION: String(omm.INCLINATION),
+      RA_OF_ASC_NODE: String(omm.RA_OF_ASC_NODE),
+      ARG_OF_PERICENTER: String(omm.ARG_OF_PERICENTER),
+      MEAN_ANOMALY: String(omm.MEAN_ANOMALY),
+      EPHEMERIS_TYPE: String(omm.EPHEMERIS_TYPE),
+      ELEMENT_SET_NO: String(omm.ELEMENT_SET_NO),
+      REV_AT_EPOCH: String(omm.REV_AT_EPOCH),
+      BSTAR: String(omm.BSTAR),
+      MEAN_MOTION_DOT: String(omm.MEAN_MOTION_DOT),
+      MEAN_MOTION_DDOT: String(omm.MEAN_MOTION_DDOT),
       epoch: {
         year: Number(YYYY),
         month: Number(MM),
@@ -16642,20 +16733,41 @@ var Satellite = class _Satellite extends SpaceObject {
     };
     this.epochYear = parseInt(YYYY.slice(2, 4));
     this.epochDay = dayOfYear;
-    this.meanMoDev1 = parseFloat(omm.MEAN_MOTION_DOT);
-    this.meanMoDev2 = parseFloat(omm.MEAN_MOTION_DDOT);
-    this.bstar = parseFloat(omm.BSTAR);
-    this.inclination = parseFloat(omm.INCLINATION);
-    this.rightAscension = parseFloat(omm.RA_OF_ASC_NODE);
-    this.eccentricity = parseFloat(omm.ECCENTRICITY);
-    this.argOfPerigee = parseFloat(omm.ARG_OF_PERICENTER);
-    this.meanAnomaly = parseFloat(omm.MEAN_ANOMALY);
-    this.meanMotion = parseFloat(omm.MEAN_MOTION);
+    this.meanMoDev1 = Number(omm.MEAN_MOTION_DOT);
+    this.meanMoDev2 = Number(omm.MEAN_MOTION_DDOT);
+    this.bstar = Number(omm.BSTAR);
+    this.inclination = Number(omm.INCLINATION);
+    this.rightAscension = Number(omm.RA_OF_ASC_NODE);
+    this.eccentricity = Number(omm.ECCENTRICITY);
+    this.argOfPerigee = Number(omm.ARG_OF_PERICENTER);
+    this.meanAnomaly = Number(omm.MEAN_ANOMALY);
+    this.meanMotion = Number(omm.MEAN_MOTION);
     this.period = 1440 / this.meanMotion;
     this.semiMajorAxis = (8681663653e-3 / this.meanMotion) ** (2 / 3);
     this.semiMinorAxis = this.semiMajorAxis * Math.sqrt(1 - this.eccentricity ** 2);
     this.apogee = this.semiMajorAxis * (1 + this.eccentricity) - 6371;
     this.perigee = this.semiMajorAxis * (1 - this.eccentricity) - 6371;
+    const { tle1, tle2 } = FormatTle.createTle({
+      inc: this.inclination,
+      meanmo: this.meanMotion,
+      rasc: this.rightAscension,
+      argPe: this.argOfPerigee,
+      meana: this.meanAnomaly,
+      ecen: this.eccentricity,
+      epochyr: this.epochYear,
+      epochday: this.epochDay,
+      intl: omm.OBJECT_ID,
+      scc: this.sccNum,
+      bstar: this.bstar,
+      meanMotionDot: this.meanMoDev1,
+      meanMotionDdot: this.meanMoDev2,
+      classification: String(omm.CLASSIFICATION_TYPE) || "U",
+      revAtEpoch: Number(omm.REV_AT_EPOCH) || 0,
+      elementSetNo: Number(omm.ELEMENT_SET_NO) || 999,
+      ephemerisType: Number(omm.EPHEMERIS_TYPE) || 0
+    });
+    this.tle1 = tle1;
+    this.tle2 = tle2;
     this.satrec = Sgp4.createSatrecFromOmm(ommParsed);
   }
   // ==================== Type Checking ====================
@@ -25125,6 +25237,568 @@ 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 a CelesTrak-style flat JSON OMM object into the structured ParsedOmm format.
+   *
+   * CelesTrak's JSON OMM format is a flat object with all fields at the top level,
+   * omitting metadata fields like CENTER_NAME, REF_FRAME, TIME_SYSTEM, and
+   * MEAN_ELEMENT_THEORY (which are always EARTH/TEME/UTC/SGP4 for GP data).
+   *
+   * @param omm - A flat OMM JSON object from CelesTrak
+   * @returns Parsed OMM structure with inferred metadata
+   */
+  static parseJson(omm) {
+    const result = {
+      header: {
+        CCSDS_OMM_VERS: "3.0",
+        CREATION_DATE: (/* @__PURE__ */ new Date()).toISOString(),
+        ORIGINATOR: "CelesTrak"
+      },
+      metadata: {
+        OBJECT_NAME: omm.OBJECT_NAME,
+        OBJECT_ID: omm.OBJECT_ID,
+        CENTER_NAME: "EARTH",
+        REF_FRAME: "TEME",
+        TIME_SYSTEM: "UTC",
+        MEAN_ELEMENT_THEORY: "SGP4"
+      },
+      meanElements: {
+        EPOCH: omm.EPOCH,
+        MEAN_MOTION: Number(omm.MEAN_MOTION),
+        ECCENTRICITY: Number(omm.ECCENTRICITY),
+        INCLINATION: Number(omm.INCLINATION),
+        RA_OF_ASC_NODE: Number(omm.RA_OF_ASC_NODE),
+        ARG_OF_PERICENTER: Number(omm.ARG_OF_PERICENTER),
+        MEAN_ANOMALY: Number(omm.MEAN_ANOMALY)
+      },
+      tleParameters: {
+        EPHEMERIS_TYPE: Number(omm.EPHEMERIS_TYPE),
+        CLASSIFICATION_TYPE: String(omm.CLASSIFICATION_TYPE),
+        NORAD_CAT_ID: Number(omm.NORAD_CAT_ID),
+        ELEMENT_SET_NO: Number(omm.ELEMENT_SET_NO),
+        REV_AT_EPOCH: Number(omm.REV_AT_EPOCH),
+        BSTAR: Number(omm.BSTAR),
+        MEAN_MOTION_DOT: Number(omm.MEAN_MOTION_DOT),
+        MEAN_MOTION_DDOT: Number(omm.MEAN_MOTION_DDOT)
+      }
+    };
+    return result;
+  }
+  /**
+   * Parse an array of CelesTrak-style flat JSON OMM objects.
+   * @param ommArray - Array of flat OMM JSON objects from CelesTrak
+   * @returns Array of parsed OMM structures
+   */
+  static parseJsonArray(ommArray) {
+    return ommArray.map((omm) => _OmmParser.parseJson(omm));
+  }
+  /**
+   * 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 +30041,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;