ootk 6.0.0 → 6.0.2

package/dist/main.js

@@ -9855,13 +9855,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 };
   }
   /**
@@ -9990,6 +10003,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
@@ -14041,7 +14109,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 +14319,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 +16655,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);
@@ -16614,8 +16691,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);
@@ -16628,6 +16706,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),
@@ -16640,20 +16731,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 ====================
@@ -25123,6 +25235,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";
@@ -29261,4 +29935,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 };