gnss-js 0.1.2 → 1.0.1

package/dist/rinex.cjs

@@ -0,0 +1,1469 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rinex/index.ts
+var rinex_exports = {};
+__export(rinex_exports, {
+  EMPTY_WARNINGS: () => EMPTY_WARNINGS,
+  SYSTEM_ORDER: () => SYSTEM_ORDER,
+  WarningAccumulator: () => WarningAccumulator,
+  crxDecompress: () => crxDecompress,
+  crxRepair: () => crxRepair,
+  fmtF: () => fmtF,
+  hdrLine: () => hdrLine,
+  padL: () => padL,
+  padR: () => padR,
+  parseCrxDataLine: () => parseCrxDataLine,
+  parseNavFile: () => parseNavFile,
+  parseRinexStream: () => parseRinexStream,
+  systemCmp: () => systemCmp,
+  systemName: () => systemName,
+  writeRinexNav: () => writeRinexNav
+});
+module.exports = __toCommonJS(rinex_exports);
+
+// src/rinex/crx.ts
+function crxRepair(old, diff) {
+  const chars = old.split("");
+  for (let i = 0; i < diff.length; i++) {
+    const dc = diff[i];
+    if (dc === " ") {
+    } else if (dc === "&") {
+      chars[i] = " ";
+    } else {
+      chars[i] = dc;
+    }
+  }
+  if (diff.length > chars.length) {
+    for (let i = chars.length; i < diff.length; i++) {
+      chars[i] = diff[i] === "&" ? " " : diff[i];
+    }
+  }
+  return chars.join("");
+}
+function parseCrxDataLine(line, ntype) {
+  const fields = [];
+  let pos = 0;
+  for (let j = 0; j < ntype; j++) {
+    if (pos >= line.length || line[pos] === "\0") {
+      fields.push({ empty: true, init: false, arcOrder: -1, value: 0 });
+      pos++;
+      continue;
+    }
+    if (line[pos] === " ") {
+      fields.push({ empty: true, init: false, arcOrder: -1, value: 0 });
+      pos++;
+      continue;
+    }
+    const start = pos;
+    while (pos < line.length && line[pos] !== " ") pos++;
+    const token = line.substring(start, pos);
+    if (pos < line.length && line[pos] === " ") pos++;
+    if (token.length >= 3 && token[1] === "&") {
+      const arcOrder = parseInt(token[0]);
+      const value = parseInt(token.substring(2));
+      fields.push({
+        empty: false,
+        init: true,
+        arcOrder,
+        value: isNaN(value) ? 0 : value
+      });
+    } else {
+      const value = parseInt(token);
+      fields.push({
+        empty: false,
+        init: false,
+        arcOrder: -1,
+        value: isNaN(value) ? 0 : value
+      });
+    }
+  }
+  const flagStr = pos < line.length ? line.substring(pos) : "";
+  return { fields, flagStr };
+}
+function crxDecompress(prev, field) {
+  if (field.init) {
+    const a = new Array(Math.max(field.arcOrder + 1, 1)).fill(0);
+    a[0] = field.value;
+    return {
+      state: { accum: a, order: 0, arcOrder: field.arcOrder },
+      result: field.value
+    };
+  }
+  if (!prev) {
+    return { state: { accum: [0], order: 0, arcOrder: 0 }, result: 0 };
+  }
+  let order = prev.order;
+  if (order < prev.arcOrder) order++;
+  const accum = [...prev.accum];
+  while (accum.length <= order) accum.push(0);
+  accum[order] = field.value;
+  for (let k = order; k >= 1; k--) {
+    accum[k - 1] += accum[k];
+  }
+  return {
+    state: { accum, order, arcOrder: prev.arcOrder },
+    result: accum[0]
+  };
+}
+
+// src/rinex/format.ts
+function padL(s, w) {
+  return s.length >= w ? s.slice(0, w) : s + " ".repeat(w - s.length);
+}
+function padR(s, w) {
+  return s.length >= w ? s.slice(0, w) : " ".repeat(w - s.length) + s;
+}
+function fmtF(val, width, dec) {
+  return padR(val.toFixed(dec), width);
+}
+function hdrLine(content, label) {
+  return padL(content, 60) + padL(label, 20);
+}
+
+// src/constants/gnss.ts
+var SYSTEM_NAMES = {
+  G: "GPS",
+  R: "GLONASS",
+  E: "Galileo",
+  C: "BeiDou",
+  J: "QZSS",
+  I: "NavIC",
+  S: "SBAS"
+};
+
+// src/rinex/parser.ts
+var CHUNK_SIZE = 2 * 1024 * 1024;
+var yieldToMain = () => new Promise((r) => setTimeout(r, 0));
+var noYield = () => Promise.resolve();
+var SYSTEM_ORDER = ["G", "R", "E", "C", "J", "I", "S"];
+var SYSTEM_RANK = Object.fromEntries(
+  SYSTEM_ORDER.map((s, i) => [s, i])
+);
+function systemCmp(a, b) {
+  const ra = SYSTEM_RANK[a.charAt(0)] ?? 99;
+  const rb = SYSTEM_RANK[b.charAt(0)] ?? 99;
+  if (ra !== rb) return ra - rb;
+  return a.localeCompare(b);
+}
+function systemName(code) {
+  return SYSTEM_NAMES[code] ?? code;
+}
+function parseHeader(lines) {
+  const h = {
+    version: 0,
+    type: "",
+    satSystem: "",
+    markerName: "",
+    markerType: "",
+    observer: "",
+    agency: "",
+    receiverNumber: "",
+    receiverType: "",
+    receiverVersion: "",
+    antNumber: "",
+    antType: "",
+    approxPosition: null,
+    antDelta: null,
+    interval: null,
+    timeOfFirstObs: null,
+    timeOfLastObs: null,
+    obsTypes: {},
+    glonassSlots: {},
+    isCrx: false,
+    crxVersion: 0
+  };
+  let currentObsSys = "";
+  for (const raw of lines) {
+    const label = raw.substring(60).trim();
+    const data = raw.substring(0, 60);
+    switch (label) {
+      case "CRINEX VERS   / TYPE": {
+        h.isCrx = true;
+        h.crxVersion = parseFloat(data.substring(0, 9)) || 0;
+        break;
+      }
+      case "RINEX VERSION / TYPE": {
+        h.version = parseFloat(data.substring(0, 9));
+        h.type = data.substring(20, 21).trim();
+        h.satSystem = data.substring(40, 41).trim();
+        break;
+      }
+      case "MARKER NAME":
+        h.markerName = data.trim();
+        break;
+      case "MARKER TYPE":
+        h.markerType = data.trim();
+        break;
+      case "OBSERVER / AGENCY":
+        h.observer = data.substring(0, 20).trim();
+        h.agency = data.substring(20).trim();
+        break;
+      case "REC # / TYPE / VERS":
+        h.receiverNumber = data.substring(0, 20).trim();
+        h.receiverType = data.substring(20, 40).trim();
+        h.receiverVersion = data.substring(40, 60).trim();
+        break;
+      case "ANT # / TYPE":
+        h.antNumber = data.substring(0, 20).trim();
+        h.antType = data.substring(20).trim();
+        break;
+      case "ANTENNA: DELTA H/E/N": {
+        const d = data.trim().split(/\s+/).map(Number);
+        if (d.length >= 3 && !d.slice(0, 3).some(isNaN)) {
+          h.antDelta = [d[0], d[1], d[2]];
+        }
+        break;
+      }
+      case "APPROX POSITION XYZ": {
+        const p = data.trim().split(/\s+/).map(Number);
+        if (p.length >= 3 && p[0] !== void 0 && p[1] !== void 0 && p[2] !== void 0 && !isNaN(p[0]) && !isNaN(p[1]) && !isNaN(p[2])) {
+          h.approxPosition = [p[0], p[1], p[2]];
+        }
+        break;
+      }
+      case "INTERVAL":
+        h.interval = parseFloat(data);
+        break;
+      case "TIME OF FIRST OBS":
+        h.timeOfFirstObs = parseHeaderTime(data);
+        break;
+      case "TIME OF LAST OBS":
+        h.timeOfLastObs = parseHeaderTime(data);
+        break;
+      case "SYS / # / OBS TYPES": {
+        const sys = data[0]?.trim();
+        if (sys) {
+          currentObsSys = sys;
+          const count = parseInt(data.substring(3, 6));
+          const codes = data.substring(7, 60).trim().split(/\s+/).filter(Boolean);
+          h.obsTypes[currentObsSys] = codes;
+          void count;
+        } else if (currentObsSys && h.obsTypes[currentObsSys]) {
+          const codes = data.substring(7, 60).trim().split(/\s+/).filter(Boolean);
+          h.obsTypes[currentObsSys].push(...codes);
+        }
+        break;
+      }
+      case "GLONASS SLOT / FRQ #": {
+        const nSats = parseInt(data.substring(0, 3));
+        void nSats;
+        for (let i = 0; i < 8; i++) {
+          const off = 4 + i * 7;
+          const sat = data.substring(off, off + 3).trim();
+          const ch = data.substring(off + 3, off + 7).trim();
+          if (sat && sat[0] === "R" && ch) {
+            const slot = parseInt(sat.substring(1));
+            const k = parseInt(ch);
+            if (!isNaN(slot) && !isNaN(k)) h.glonassSlots[slot] = k;
+          }
+        }
+        break;
+      }
+      case "# / TYPES OF OBSERV": {
+        const existing = h.obsTypes["_v2"];
+        const codes = data.substring(6, 60).trim().split(/\s+/).filter(Boolean);
+        if (!existing || existing.length === 0) {
+          h.obsTypes["_v2"] = codes;
+        } else {
+          existing.push(...codes);
+        }
+        break;
+      }
+    }
+  }
+  return h;
+}
+function parseHeaderTime(data) {
+  const p = data.trim().split(/\s+/).map(Number);
+  if (p.length < 6) return null;
+  const yr = p[0], mo = p[1], dy = p[2], hr = p[3], mn = p[4], sc = p[5];
+  if ([yr, mo, dy, hr, mn, sc].some(isNaN)) return null;
+  const wholeSec = Math.floor(sc);
+  const ms = Math.round((sc - wholeSec) * 1e3);
+  return new Date(Date.UTC(yr, mo - 1, dy, hr, mn, wholeSec, ms));
+}
+function snrIndicesWithBand(obsTypes, system) {
+  const codes = obsTypes[system];
+  if (!codes) return [];
+  const result = [];
+  for (let i = 0; i < codes.length; i++) {
+    const c = codes[i];
+    if (c.startsWith("S")) result.push({ idx: i, band: c[1] });
+  }
+  return result;
+}
+function snrIndicesWithBandV2(obsTypes) {
+  const codes = obsTypes["_v2"];
+  if (!codes) return [];
+  const result = [];
+  for (let i = 0; i < codes.length; i++) {
+    const c = codes[i];
+    if (c.startsWith("S")) result.push({ idx: i, band: c[1] });
+  }
+  return result;
+}
+function readObsValue(line, index) {
+  const start = index * 16;
+  if (start + 14 > line.length) return null;
+  const raw = line.substring(start, start + 14).trim();
+  if (!raw) return null;
+  const v = parseFloat(raw);
+  return isNaN(v) ? null : v;
+}
+function parseEpochLine3(line) {
+  if (line[0] !== ">") return null;
+  const yr = parseInt(line.substring(2, 6));
+  const mo = parseInt(line.substring(7, 9));
+  const dy = parseInt(line.substring(10, 12));
+  const hr = parseInt(line.substring(13, 15));
+  const mn = parseInt(line.substring(16, 18));
+  const sc = parseFloat(line.substring(19, 29));
+  const flag = parseInt(line.substring(31, 32));
+  const numSats = parseInt(line.substring(32, 35));
+  if ([yr, mo, dy, hr, mn].some(isNaN) || isNaN(sc)) return null;
+  const wholeSec = Math.floor(sc);
+  const ms = Math.round((sc - wholeSec) * 1e3);
+  const time = Date.UTC(yr, mo - 1, dy, hr, mn, wholeSec, ms);
+  return {
+    time,
+    flag: isNaN(flag) ? 0 : flag,
+    numSats: isNaN(numSats) ? 0 : numSats
+  };
+}
+function parseEpochLine2(line) {
+  const yr2 = parseInt(line.substring(1, 3));
+  const mo = parseInt(line.substring(4, 6));
+  const dy = parseInt(line.substring(7, 9));
+  const hr = parseInt(line.substring(10, 12));
+  const mn = parseInt(line.substring(13, 15));
+  const sc = parseFloat(line.substring(15, 26));
+  const flag = parseInt(line.substring(28, 29));
+  const numSats = parseInt(line.substring(29, 32));
+  if ([yr2, mo, dy, hr, mn].some(isNaN) || isNaN(sc)) return null;
+  const yr = yr2 >= 80 ? 1900 + yr2 : 2e3 + yr2;
+  const wholeSec = Math.floor(sc);
+  const ms = Math.round((sc - wholeSec) * 1e3);
+  const time = Date.UTC(yr, mo - 1, dy, hr, mn, wholeSec, ms);
+  const satIds = [];
+  const satPart = line.substring(32);
+  for (let i = 0; i + 3 <= satPart.length; i += 3) {
+    const id = satPart.substring(i, i + 3).trim();
+    if (id) satIds.push(id);
+  }
+  return {
+    time,
+    flag: isNaN(flag) ? 0 : flag,
+    numSats: isNaN(numSats) ? 0 : numSats,
+    satIds
+  };
+}
+async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode) {
+  const skipEpochs = !!workerMode;
+  const yield_ = workerMode ? noYield : yieldToMain;
+  const decoder = new TextDecoder("ascii");
+  let buffer = "";
+  let header = null;
+  const headerLines = [];
+  const epochs = [];
+  const satellitesSeen = {};
+  let epochInfo = null;
+  let satsPerSystem = {};
+  let snrValues = [];
+  let snrPerSystemAccum = {};
+  let snrPerSatAccum = {};
+  let snrPerSatBandAccum = {};
+  let satLinesRemaining = 0;
+  let eventSkipLines = 0;
+  let v2SatIds = [];
+  let v2SatIndex = 0;
+  let v2LinesPerSat = 0;
+  let v2CurrentSatLine = 0;
+  let v2SnrBandInfo = [];
+  let v2ContinuationSatsRemaining = 0;
+  let crxPhase = "epoch";
+  let crxSatList = [];
+  let crxSatIndex = 0;
+  let crxPrevEpochLine = "";
+  const crxDiffStates = /* @__PURE__ */ new Map();
+  function trackSat(sys, prn) {
+    if (!satellitesSeen[sys]) satellitesSeen[sys] = /* @__PURE__ */ new Set();
+    satellitesSeen[sys].add(prn);
+    satsPerSystem[sys] = (satsPerSystem[sys] ?? 0) + 1;
+  }
+  function pushSnr(sys, prn, val, band) {
+    if (skipEpochs) return;
+    snrValues.push(val);
+    if (!snrPerSystemAccum[sys]) snrPerSystemAccum[sys] = [];
+    snrPerSystemAccum[sys].push(val);
+    if (!snrPerSatAccum[prn]) snrPerSatAccum[prn] = [];
+    snrPerSatAccum[prn].push(val);
+    if (band) {
+      const key = `${prn}:${band}`;
+      if (!snrPerSatBandAccum[key]) snrPerSatBandAccum[key] = [];
+      snrPerSatBandAccum[key].push(val);
+    }
+  }
+  function finishEpoch() {
+    if (!epochInfo) return;
+    if (!skipEpochs) {
+      const snrBySys = {};
+      for (const [sys, vals] of Object.entries(snrPerSystemAccum)) {
+        if (vals.length > 0)
+          snrBySys[sys] = vals.reduce((a, b) => a + b, 0) / vals.length;
+      }
+      const meanSnr = snrValues.length > 0 ? snrValues.reduce((a, b) => a + b, 0) / snrValues.length : null;
+      const snrPerSat = {};
+      for (const [prn, vals] of Object.entries(snrPerSatAccum)) {
+        if (vals.length > 0)
+          snrPerSat[prn] = vals.reduce((a, b) => a + b, 0) / vals.length;
+      }
+      const snrPerSatBand = {};
+      for (const [key, vals] of Object.entries(snrPerSatBandAccum)) {
+        if (vals.length > 0)
+          snrPerSatBand[key] = vals.reduce((a, b) => a + b, 0) / vals.length;
+      }
+      epochs.push({
+        time: epochInfo.time,
+        totalSats: Object.values(satsPerSystem).reduce((a, b) => a + b, 0),
+        satsPerSystem: { ...satsPerSystem },
+        meanSnr,
+        snrPerSystem: snrBySys,
+        snrPerSat,
+        snrPerSatBand
+      });
+    }
+    epochInfo = null;
+    satsPerSystem = {};
+    snrValues = [];
+    snrPerSystemAccum = {};
+    snrPerSatAccum = {};
+    snrPerSatBandAccum = {};
+  }
+  function resetEpochAccum(info) {
+    epochInfo = info;
+    satsPerSystem = {};
+    snrValues = [];
+    snrPerSystemAccum = {};
+    snrPerSatAccum = {};
+    snrPerSatBandAccum = {};
+  }
+  const snrCache = /* @__PURE__ */ new Map();
+  function getSnrIndices(sys) {
+    let cached = snrCache.get(sys);
+    if (!cached) {
+      cached = snrIndicesWithBand(header.obsTypes, sys);
+      snrCache.set(sys, cached);
+    }
+    return cached;
+  }
+  function processSatLineV3(line) {
+    if (!header || line.length < 3) return;
+    const sys = line[0];
+    const prn = line.substring(0, 3);
+    trackSat(sys, prn);
+    const obsLine = line.substring(3);
+    const codes = header.obsTypes[sys] ?? [];
+    if (onSatObs && epochInfo) {
+      const values = new Array(codes.length);
+      for (let i = 0; i < codes.length; i++)
+        values[i] = readObsValue(obsLine, i);
+      if (!skipEpochs) {
+        for (const { idx, band } of getSnrIndices(sys)) {
+          const val = values[idx] ?? null;
+          if (val !== null && val > 0) pushSnr(sys, prn, val, band);
+        }
+      }
+      onSatObs(epochInfo.time, prn, codes, values);
+    } else if (!skipEpochs) {
+      for (const { idx, band } of getSnrIndices(sys)) {
+        const val = readObsValue(obsLine, idx);
+        if (val !== null && val > 0) pushSnr(sys, prn, val, band);
+      }
+    }
+  }
+  let v2ObsAccum = [];
+  function processSatLineV2(line) {
+    if (!header || v2SatIndex >= v2SatIds.length) return;
+    const satId = v2SatIds[v2SatIndex];
+    let sys = satId[0];
+    if (sys === " " || /\d/.test(sys)) sys = "G";
+    const prn = sys + satId.substring(1).padStart(2, "0");
+    if (v2CurrentSatLine === 0) {
+      trackSat(sys, prn);
+      if (onSatObs) v2ObsAccum = [];
+    }
+    const lineOffset = v2CurrentSatLine * 5;
+    for (const { idx, band } of v2SnrBandInfo) {
+      if (idx >= lineOffset && idx < lineOffset + 5) {
+        const val = readObsValue(line, idx - lineOffset);
+        if (val !== null && val > 0) pushSnr(sys, prn, val, band);
+      }
+    }
+    if (onSatObs) {
+      for (let i = 0; i < 5; i++) {
+        if (lineOffset + i < (header.obsTypes["_v2"] ?? []).length) {
+          v2ObsAccum.push(readObsValue(line, i));
+        }
+      }
+    }
+    v2CurrentSatLine++;
+    if (v2CurrentSatLine >= v2LinesPerSat) {
+      if (onSatObs && epochInfo) {
+        const codes = header.obsTypes["_v2"] ?? [];
+        onSatObs(epochInfo.time, prn, codes, v2ObsAccum);
+      }
+      v2CurrentSatLine = 0;
+      v2SatIndex++;
+    }
+  }
+  function processCrxSatDataLine(prn, line) {
+    if (!header) return;
+    const sys = prn[0];
+    trackSat(sys, prn);
+    const ntype = header.version >= 3 ? (header.obsTypes[sys] ?? []).length : (header.obsTypes["_v2"] ?? []).length;
+    if (ntype === 0) return;
+    const { fields } = parseCrxDataLine(line, ntype);
+    let states = crxDiffStates.get(prn);
+    if (!states) {
+      states = new Array(ntype).fill(null);
+      crxDiffStates.set(prn, states);
+    }
+    while (states.length < ntype) states.push(null);
+    const sBandMap = skipEpochs ? null : new Map(
+      (header.version >= 3 ? getSnrIndices(sys) : snrIndicesWithBandV2(header.obsTypes)).map((s) => [s.idx, s.band])
+    );
+    const obsValues = onSatObs ? new Array(ntype).fill(null) : [];
+    for (let j = 0; j < ntype; j++) {
+      const field = fields[j];
+      if (field.empty) continue;
+      const { state, result } = crxDecompress(states[j] ?? null, field);
+      states[j] = state;
+      if (onSatObs) obsValues[j] = result / 1e3;
+      if (sBandMap) {
+        const band = sBandMap.get(j);
+        if (band !== void 0) {
+          const snrFloat = result / 1e3;
+          if (snrFloat > 0) pushSnr(sys, prn, snrFloat, band);
+        }
+      }
+    }
+    if (onSatObs && epochInfo) {
+      const codes = header.version >= 3 ? header.obsTypes[sys] ?? [] : header.obsTypes["_v2"] ?? [];
+      onSatObs(epochInfo.time, prn, codes, obsValues);
+    }
+  }
+  let crxEpochTopFrom = ">";
+  let crxEpochTopTo = ">";
+  let crxEventSkipLines = 0;
+  function processCrxLine(line) {
+    if (!header) return;
+    const isV3 = header.version >= 3;
+    if (header.crxVersion < 3) {
+      crxEpochTopFrom = "&";
+      crxEpochTopTo = " ";
+    }
+    if (crxEventSkipLines > 0) {
+      crxEventSkipLines--;
+      return;
+    }
+    if (crxPhase === "epoch") {
+      if (header.crxVersion >= 3 && line[0] === "&") return;
+      const isInitEpoch = line[0] === crxEpochTopFrom;
+      const isTextDiff = !isInitEpoch && crxPrevEpochLine.length > 0;
+      if (isInitEpoch || isTextDiff) {
+        let epochLine;
+        if (isInitEpoch) {
+          epochLine = crxEpochTopTo + line.substring(1);
+          crxPrevEpochLine = "";
+        } else {
+          epochLine = crxRepair(crxPrevEpochLine, line);
+        }
+        if (isV3) {
+          if (epochLine[0] !== ">") return;
+          const info = parseEpochLine3(epochLine);
+          if (!info) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          if (info.flag >= 2) {
+            crxPrevEpochLine = epochLine;
+            crxEventSkipLines = info.numSats;
+            return;
+          }
+          if (info.flag !== 0) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          resetEpochAccum(info);
+          const satPart = epochLine.substring(41).replace(/\s+$/, "");
+          crxSatList = [];
+          for (let i = 0; i + 3 <= satPart.length; i += 3) {
+            crxSatList.push(satPart.substring(i, i + 3));
+          }
+          crxSatIndex = 0;
+          crxPrevEpochLine = epochLine;
+          crxPhase = "clock";
+        } else {
+          const info = parseEpochLine2(epochLine);
+          if (!info) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          if (info.flag >= 2) {
+            crxPrevEpochLine = epochLine;
+            crxEventSkipLines = info.numSats;
+            return;
+          }
+          if (info.flag !== 0) {
+            crxPrevEpochLine = epochLine;
+            return;
+          }
+          resetEpochAccum(info);
+          crxSatList = (info.satIds ?? []).map((id) => {
+            let sys = id[0];
+            if (sys === " " || /\d/.test(sys)) sys = "G";
+            return sys + id.substring(1).padStart(2, "0");
+          });
+          crxSatIndex = 0;
+          crxPrevEpochLine = epochLine;
+          crxPhase = "clock";
+        }
+      }
+    } else if (crxPhase === "clock") {
+      if (crxSatList.length > 0) {
+        crxPhase = "satdata";
+      } else {
+        crxPhase = "epoch";
+        finishEpoch();
+      }
+    } else if (crxPhase === "satdata") {
+      const prn = crxSatList[crxSatIndex];
+      processCrxSatDataLine(prn, line);
+      crxSatIndex++;
+      if (crxSatIndex >= crxSatList.length) {
+        crxPhase = "epoch";
+        finishEpoch();
+      }
+    }
+  }
+  function processRinexLine(line) {
+    if (!header) return;
+    if (eventSkipLines > 0) {
+      eventSkipLines--;
+      return;
+    }
+    if (header.version >= 3) {
+      if (satLinesRemaining > 0) {
+        processSatLineV3(line);
+        satLinesRemaining--;
+        if (satLinesRemaining === 0) finishEpoch();
+      } else if (line[0] === ">") {
+        const info = parseEpochLine3(line);
+        if (!info) return;
+        if (info.flag >= 2 && info.flag <= 5) {
+          eventSkipLines = info.numSats;
+          return;
+        }
+        if (info.flag === 0) {
+          resetEpochAccum(info);
+          satLinesRemaining = info.numSats;
+          if (info.numSats === 0) finishEpoch();
+        }
+      }
+    } else {
+      if (v2ContinuationSatsRemaining > 0) {
+        const satPart = line.substring(32);
+        for (let i = 0; i + 3 <= satPart.length; i += 3) {
+          const id = satPart.substring(i, i + 3).trim();
+          if (id) v2SatIds.push(id);
+        }
+        v2ContinuationSatsRemaining--;
+        if (v2ContinuationSatsRemaining === 0) {
+          v2SatIndex = 0;
+          v2CurrentSatLine = 0;
+          satLinesRemaining = v2SatIds.length * v2LinesPerSat;
+          if (satLinesRemaining === 0) finishEpoch();
+        }
+      } else if (satLinesRemaining > 0) {
+        processSatLineV2(line);
+        satLinesRemaining--;
+        if (satLinesRemaining === 0) finishEpoch();
+      } else {
+        const info = parseEpochLine2(line);
+        if (!info) return;
+        if (info.flag >= 2 && info.flag <= 5) {
+          eventSkipLines = info.numSats;
+          return;
+        }
+        if (info.flag === 0) {
+          resetEpochAccum(info);
+          v2SatIds = info.satIds ?? [];
+          const v2ObsPerSat = (header.obsTypes["_v2"] ?? []).length;
+          v2LinesPerSat = Math.ceil(v2ObsPerSat / 5) || 1;
+          v2SnrBandInfo = snrIndicesWithBandV2(header.obsTypes);
+          v2SatIndex = 0;
+          v2CurrentSatLine = 0;
+          const continuationLines = Math.max(
+            0,
+            Math.ceil((info.numSats - 12) / 12)
+          );
+          if (continuationLines > 0) {
+            v2ContinuationSatsRemaining = continuationLines;
+          } else {
+            satLinesRemaining = v2SatIds.length * v2LinesPerSat;
+            if (satLinesRemaining === 0) finishEpoch();
+          }
+        }
+      }
+    }
+  }
+  function processLine(line) {
+    if (!header) return;
+    if (header.isCrx) {
+      processCrxLine(line);
+    } else {
+      processRinexLine(line);
+    }
+  }
+  function processChunkText(text, isLast) {
+    buffer += text;
+    const lastNl = buffer.lastIndexOf("\n");
+    if (lastNl === -1 && !isLast) return;
+    const chunk = isLast ? buffer : buffer.substring(0, lastNl);
+    buffer = isLast ? "" : buffer.substring(lastNl + 1);
+    const lines = chunk.split("\n");
+    for (const rawLine of lines) {
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      if (!line && !header) continue;
+      if (!header) {
+        headerLines.push(line);
+        if (line.includes("END OF HEADER")) header = parseHeader(headerLines);
+        continue;
+      }
+      processLine(line);
+    }
+  }
+  const magic = new Uint8Array(await file.slice(0, 2).arrayBuffer());
+  const isGz = magic[0] === 31 && magic[1] === 139;
+  if (magic[0] === 31 && magic[1] === 157) {
+    throw new Error(
+      "Unix compress (.Z) files are not supported. Please decompress first (e.g. uncompress or gzip -d)."
+    );
+  }
+  if (isGz) {
+    let bytesRead = 0;
+    const raw = file.stream();
+    const decompressed = raw.pipeThrough(new DecompressionStream("gzip"));
+    const reader = decompressed.getReader();
+    for (; ; ) {
+      if (signal?.aborted) {
+        reader.cancel();
+        throw new DOMException("Aborted", "AbortError");
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytesRead += value.byteLength;
+      processChunkText(decoder.decode(value, { stream: true }), false);
+      onProgress?.(
+        Math.min(99, Math.round(bytesRead / (file.size * 4) * 100))
+      );
+      await yield_();
+    }
+    processChunkText(decoder.decode(), true);
+  } else {
+    for (let offset = 0; offset < file.size; offset += CHUNK_SIZE) {
+      if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+      const end = Math.min(offset + CHUNK_SIZE, file.size);
+      const slice = file.slice(offset, end);
+      const arrayBuf = await slice.arrayBuffer();
+      processChunkText(
+        decoder.decode(arrayBuf, { stream: end < file.size }),
+        false
+      );
+      onProgress?.(Math.min(99, Math.round(end / file.size * 100)));
+      await yield_();
+    }
+    if (buffer.length > 0) {
+      processChunkText("", true);
+    }
+  }
+  if (epochInfo && satLinesRemaining === 0 && crxPhase === "epoch")
+    finishEpoch();
+  if (!header)
+    throw new Error("No valid RINEX header found (missing END OF HEADER).");
+  onProgress?.(100);
+  return {
+    header,
+    epochs,
+    stats: computeStats(header, epochs, satellitesSeen)
+  };
+}
+function computeStats(header, epochs, satellitesSeen) {
+  const n = epochs.length;
+  const startTime = n > 0 ? new Date(epochs[0].time) : header.timeOfFirstObs;
+  const endTime = n > 0 ? new Date(epochs[n - 1].time) : header.timeOfLastObs;
+  let duration = null;
+  if (startTime && endTime)
+    duration = (endTime.getTime() - startTime.getTime()) / 1e3;
+  let interval = header.interval;
+  if (interval === null && n >= 2)
+    interval = (epochs[1].time - epochs[0].time) / 1e3;
+  const uniqueSatsPerSystem = {};
+  let totalUnique = 0;
+  const systems = [];
+  for (const [sys, prns] of Object.entries(satellitesSeen)) {
+    uniqueSatsPerSystem[sys] = prns.size;
+    totalUnique += prns.size;
+    systems.push(sys);
+  }
+  systems.sort(systemCmp);
+  const meanSatellites = n > 0 ? epochs.reduce((s, e) => s + e.totalSats, 0) / n : 0;
+  const snrEpochs = epochs.filter((e) => e.meanSnr !== null);
+  const meanSnr = snrEpochs.length > 0 ? snrEpochs.reduce((s, e) => s + e.meanSnr, 0) / snrEpochs.length : null;
+  return {
+    totalEpochs: n,
+    validEpochs: n,
+    duration,
+    startTime,
+    endTime,
+    interval,
+    uniqueSatellites: totalUnique,
+    uniqueSatsPerSystem,
+    systems,
+    meanSatellites,
+    meanSnr
+  };
+}
+
+// src/rinex/warnings.ts
+var EMPTY_WARNINGS = {
+  items: [],
+  errorCount: 0,
+  warningCount: 0,
+  infoCount: 0
+};
+var MAX_EXAMPLES = 3;
+var WarningAccumulator = class {
+  items = /* @__PURE__ */ new Map();
+  // Epoch-level state
+  prevEpochTime = null;
+  epochTimes = /* @__PURE__ */ new Set();
+  intervalMs = null;
+  flagCounts = /* @__PURE__ */ new Map();
+  seenPrns = /* @__PURE__ */ new Set();
+  /* ── Header checks ──────────────────────────────────────────── */
+  checkHeader(header) {
+    const pos = header.approxPosition;
+    if (!pos || pos[0] === 0 && pos[1] === 0 && pos[2] === 0) {
+      this.add(
+        "MISSING_POSITION",
+        "warning",
+        "Missing or zero approximate position (APPROX POSITION XYZ)"
+      );
+    }
+    if (!header.antType) {
+      this.add(
+        "MISSING_ANT_TYPE",
+        "info",
+        "Missing antenna type (ANT # / TYPE)"
+      );
+    }
+    if (!header.receiverType) {
+      this.add(
+        "MISSING_REC_TYPE",
+        "info",
+        "Missing receiver type (REC # / TYPE / VERS)"
+      );
+    }
+    if (!header.markerName) {
+      this.add("MISSING_MARKER", "info", "Missing marker name (MARKER NAME)");
+    }
+    if (header.interval == null) {
+      this.add("MISSING_INTERVAL", "info", "No observation interval in header");
+    }
+    if (Object.keys(header.obsTypes).length === 0) {
+      this.add(
+        "NO_OBS_TYPES",
+        "error",
+        "No observation types defined in header"
+      );
+    }
+  }
+  setInterval(intervalMs) {
+    this.intervalMs = intervalMs;
+  }
+  /* ── Epoch checks ───────────────────────────────────────────── */
+  onEpoch(time, flag) {
+    if (flag !== 0) {
+      this.flagCounts.set(flag, (this.flagCounts.get(flag) ?? 0) + 1);
+    }
+    if (flag !== 0) return;
+    if (this.epochTimes.has(time)) {
+      const d = new Date(time);
+      this.add(
+        "DUPLICATE_EPOCH",
+        "warning",
+        "Duplicate epoch timestamps",
+        d.toISOString().replace("T", " ").replace(".000Z", "")
+      );
+    }
+    this.epochTimes.add(time);
+    if (this.prevEpochTime !== null && time < this.prevEpochTime) {
+      const d = new Date(time);
+      this.add(
+        "OUT_OF_ORDER",
+        "warning",
+        "Epochs not in chronological order",
+        d.toISOString().replace("T", " ").replace(".000Z", "")
+      );
+    }
+    if (this.prevEpochTime !== null) {
+      const gap = time - this.prevEpochTime;
+      const threshold = this.intervalMs ? this.intervalMs * 10 : 36e5;
+      if (gap > threshold && gap > 0) {
+        const gapMin = (gap / 6e4).toFixed(1);
+        this.add(
+          "LARGE_GAP",
+          "info",
+          "Large time gaps between epochs",
+          `${gapMin} min gap at ${new Date(this.prevEpochTime).toISOString().slice(11, 19)}`
+        );
+      }
+    }
+    this.prevEpochTime = time;
+  }
+  /* ── PRN checks ─────────────────────────────────────────────── */
+  onPrn(prn) {
+    if (this.seenPrns.has(prn)) return;
+    this.seenPrns.add(prn);
+    const sys = prn[0];
+    const num = parseInt(prn.slice(1), 10);
+    if (!sys || isNaN(num)) {
+      this.add("INVALID_PRN", "warning", "Invalid PRN format", prn);
+      return;
+    }
+    const ranges = {
+      G: [1, 32],
+      R: [1, 27],
+      E: [1, 50],
+      C: [1, 63],
+      J: [1, 10],
+      I: [1, 14],
+      S: [20, 59]
+    };
+    const range = ranges[sys];
+    if (!range) {
+      this.add(
+        "UNKNOWN_SYSTEM",
+        "info",
+        "Unknown satellite system letter",
+        prn
+      );
+    } else if (num < range[0] || num > range[1]) {
+      this.add(
+        "PRN_OUT_OF_RANGE",
+        "info",
+        `PRN number outside expected range`,
+        `${prn} (expected ${sys}${String(range[0]).padStart(2, "0")}-${sys}${String(range[1]).padStart(2, "0")})`
+      );
+    }
+  }
+  /* ── Finalize ───────────────────────────────────────────────── */
+  finalize() {
+    for (const [flag, count] of this.flagCounts) {
+      const labels = {
+        1: "Receiver clock reset",
+        2: "Moving antenna event",
+        3: "Header information follows",
+        4: "External event",
+        5: "Cycle slip records",
+        6: "Power failure recovery"
+      };
+      const label = labels[flag] ?? `Flag ${flag}`;
+      this.add(
+        `EPOCH_FLAG_${flag}`,
+        "info",
+        `${label} events (flag ${flag})`,
+        `${count} epoch(s)`
+      );
+    }
+    const items = [...this.items.values()];
+    const order = { error: 0, warning: 1, info: 2 };
+    items.sort((a, b) => (order[a.severity] ?? 9) - (order[b.severity] ?? 9));
+    return {
+      items,
+      errorCount: items.filter((w) => w.severity === "error").length,
+      warningCount: items.filter((w) => w.severity === "warning").length,
+      infoCount: items.filter((w) => w.severity === "info").length
+    };
+  }
+  /* ── Internal ───────────────────────────────────────────────── */
+  add(code, severity, message, example) {
+    let w = this.items.get(code);
+    if (!w) {
+      w = { code, severity, message, count: 0 };
+      this.items.set(code, w);
+    }
+    w.count++;
+    if (example) {
+      if (!w.examples) w.examples = [];
+      if (w.examples.length < MAX_EXAMPLES) w.examples.push(example);
+    }
+  }
+};
+
+// src/rinex/nav.ts
+var DATA_LINES = {
+  G: 7,
+  E: 7,
+  C: 7,
+  J: 7,
+  // Keplerian
+  R: 3,
+  // GLONASS state vector
+  S: 3,
+  I: 7
+  // SBAS / NavIC
+};
+var R4_MSG_LINES = {
+  // EPH types we parse (same Keplerian/state-vector layout as RINEX 3)
+  LNAV: 8,
+  INAV: 8,
+  FNAV: 8,
+  D1: 8,
+  D2: 8,
+  SBAS: 4,
+  FDMA: 5,
+  // RINEX 4 adds orbit-4 (status flags) vs 3 in RINEX 3
+  // EPH types we skip (different field layout)
+  CNAV: 9,
+  CNV1: 10,
+  CNV2: 10,
+  CNV3: 9,
+  L1NV: 8,
+  L1OC: 9,
+  L3OC: 9,
+  // Non-EPH records
+  STO: 2,
+  EOP: 3,
+  ION: 3
+};
+var SUPPORTED_EPH_MSGS = /* @__PURE__ */ new Set([
+  "LNAV",
+  "INAV",
+  "FNAV",
+  "D1",
+  "D2",
+  "SBAS",
+  "FDMA"
+]);
+function parseFloat19(s) {
+  return parseFloat(s.trim().replace(/[dD]/g, "E"));
+}
+function parseNavEpochV3(line) {
+  const prn = line.substring(0, 3).trim();
+  const yr = parseInt(line.substring(3, 8));
+  const mo = parseInt(line.substring(8, 11));
+  const dy = parseInt(line.substring(11, 14));
+  const hr = parseInt(line.substring(14, 17));
+  const mn = parseInt(line.substring(17, 20));
+  const sc = parseInt(line.substring(20, 23));
+  const date = new Date(Date.UTC(yr, mo - 1, dy, hr, mn, sc));
+  const values = [];
+  for (let i = 0; i < 3; i++) {
+    const start = 23 + i * 19;
+    if (start < line.length) {
+      values.push(parseFloat19(line.substring(start, start + 19)));
+    }
+  }
+  return { prn, date, values };
+}
+function parseNavEpochV2(line, defaultSys) {
+  const prnNum = parseInt(line.substring(0, 2));
+  const yr = parseInt(line.substring(2, 5));
+  const mo = parseInt(line.substring(5, 8));
+  const dy = parseInt(line.substring(8, 11));
+  const hr = parseInt(line.substring(11, 14));
+  const mn = parseInt(line.substring(14, 17));
+  const sc = parseFloat(line.substring(17, 22));
+  const fullYr = yr < 80 ? 2e3 + yr : 1900 + yr;
+  const date = new Date(Date.UTC(fullYr, mo - 1, dy, hr, mn, Math.floor(sc)));
+  const prn = `${defaultSys}${String(prnNum).padStart(2, "0")}`;
+  const values = [];
+  for (let i = 0; i < 3; i++) {
+    const start = 22 + i * 19;
+    if (start < line.length) {
+      values.push(parseFloat19(line.substring(start, start + 19)));
+    }
+  }
+  return { prn, date, values };
+}
+function parseDataLine(line, colOffset = 4) {
+  const values = [];
+  for (let i = 0; i < 4; i++) {
+    const start = colOffset + i * 19;
+    if (start >= line.length) break;
+    const s = line.substring(start, start + 19).trim();
+    if (s.length > 0) {
+      const v = parseFloat19(s);
+      values.push(Number.isFinite(v) ? v : 0);
+    }
+  }
+  return values;
+}
+function buildKeplerEphemeris(sys, prn, date, epochVals, data) {
+  const d = [];
+  for (const line of data) {
+    for (let i = 0; i < 4; i++) d.push(line[i] ?? 0);
+  }
+  return {
+    system: sys,
+    prn,
+    tocDate: date,
+    toc: date.getTime() / 1e3 % (7 * 86400),
+    // seconds of week approx
+    af0: epochVals[0] ?? 0,
+    af1: epochVals[1] ?? 0,
+    af2: epochVals[2] ?? 0,
+    iode: d[0] ?? 0,
+    crs: d[1] ?? 0,
+    deltaN: d[2] ?? 0,
+    m0: d[3] ?? 0,
+    cuc: d[4] ?? 0,
+    e: d[5] ?? 0,
+    cus: d[6] ?? 0,
+    sqrtA: d[7] ?? 0,
+    toe: d[8] ?? 0,
+    cic: d[9] ?? 0,
+    omega0: d[10] ?? 0,
+    cis: d[11] ?? 0,
+    i0: d[12] ?? 0,
+    crc: d[13] ?? 0,
+    omega: d[14] ?? 0,
+    omegaDot: d[15] ?? 0,
+    idot: d[16] ?? 0,
+    // d[17] = codes on L2 (GPS) or data sources (GAL)
+    week: d[18] ?? 0,
+    // d[19] = L2P flag (GPS) or spare
+    // d[20] = SV accuracy (URA index for GPS, SISA for GAL)
+    svHealth: d[21] ?? 0,
+    tgd: d[22] ?? 0
+    // d[23] = BGD (GAL) or IODC (GPS)
+  };
+}
+function buildStateVectorEphemeris(sys, prn, date, epochVals, data) {
+  const d = data.flat();
+  return {
+    system: sys,
+    prn,
+    tocDate: date,
+    tauN: epochVals[0] ?? 0,
+    gammaN: epochVals[1] ?? 0,
+    messageFrameTime: epochVals[2] ?? 0,
+    x: d[0] ?? 0,
+    xDot: d[1] ?? 0,
+    xAcc: d[2] ?? 0,
+    health: d[3] ?? 0,
+    y: d[4] ?? 0,
+    yDot: d[5] ?? 0,
+    yAcc: d[6] ?? 0,
+    freqNum: d[7] ?? 0,
+    z: d[8] ?? 0,
+    zDot: d[9] ?? 0,
+    zAcc: d[10] ?? 0
+  };
+}
+function parseNavFile(text) {
+  const lines = text.split("\n");
+  const header = {
+    version: 0,
+    type: "",
+    leapSeconds: null,
+    ionoCorrections: {}
+  };
+  const ephemerides = [];
+  let inHeader = true;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const label = line.substring(60).trim();
+    if (label === "END OF HEADER") {
+      inHeader = false;
+      i++;
+      break;
+    }
+    if (label === "RINEX VERSION / TYPE") {
+      header.version = parseFloat(line.substring(0, 9));
+      header.type = line.substring(20, 40).trim();
+    } else if (label === "LEAP SECONDS") {
+      header.leapSeconds = parseInt(line.substring(0, 6));
+    } else if (label === "IONOSPHERIC CORR") {
+      const corrType = line.substring(0, 4).trim();
+      const vals = [];
+      for (let j = 0; j < 4; j++) {
+        const s = line.substring(5 + j * 12, 5 + (j + 1) * 12).trim();
+        if (s) vals.push(parseFloat19(s));
+      }
+      header.ionoCorrections[corrType] = vals;
+    } else if (label === "ION ALPHA") {
+      const vals = [];
+      for (let j = 0; j < 4; j++) {
+        const s = line.substring(2 + j * 12, 2 + (j + 1) * 12).trim();
+        if (s) vals.push(parseFloat19(s));
+      }
+      header.ionoCorrections["GPSA"] = vals;
+    } else if (label === "ION BETA") {
+      const vals = [];
+      for (let j = 0; j < 4; j++) {
+        const s = line.substring(2 + j * 12, 2 + (j + 1) * 12).trim();
+        if (s) vals.push(parseFloat19(s));
+      }
+      header.ionoCorrections["GPSB"] = vals;
+    }
+    i++;
+  }
+  if (inHeader) return { header, ephemerides };
+  const isV2 = header.version > 0 && header.version < 3;
+  let defaultSys = "G";
+  if (isV2) {
+    const ht = header.type.toUpperCase();
+    if (ht.includes("GLONASS")) defaultSys = "R";
+    else if (ht.includes("GEO")) defaultSys = "S";
+    else if (ht.includes("GALILEO")) defaultSys = "E";
+    else if (ht.includes("BEIDOU") || ht.includes("BDS")) defaultSys = "C";
+  }
+  const isV4 = header.version >= 4;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim().length === 0) {
+      i++;
+      continue;
+    }
+    if (isV4 && line.charAt(0) === ">") {
+      const parts = line.substring(2).trim().split(/\s+/);
+      const recType = parts[0] ?? "";
+      const msgType = parts[2] ?? recType;
+      if (recType !== "EPH" || !SUPPORTED_EPH_MSGS.has(msgType)) {
+        const totalLines = R4_MSG_LINES[msgType] ?? 2;
+        i += totalLines + 1;
+        continue;
+      }
+      const numDataLines2 = (R4_MSG_LINES[msgType] ?? 8) - 1;
+      i++;
+      if (i >= lines.length) break;
+      const epochLine = lines[i];
+      const sys2 = epochLine.charAt(0);
+      const parsed = parseNavEpochV3(epochLine);
+      const prn2 = `${sys2}${parsed.prn.substring(1)}`;
+      const dataLines2 = [];
+      for (let j = 0; j < numDataLines2; j++) {
+        i++;
+        if (i >= lines.length) break;
+        dataLines2.push(parseDataLine(lines[i], 4));
+      }
+      if (dataLines2.length === numDataLines2) {
+        if (sys2 === "R" || sys2 === "S") {
+          ephemerides.push(
+            buildStateVectorEphemeris(
+              sys2,
+              prn2,
+              parsed.date,
+              parsed.values,
+              dataLines2
+            )
+          );
+        } else if (sys2 === "G" || sys2 === "E" || sys2 === "C" || sys2 === "J" || sys2 === "I") {
+          ephemerides.push(
+            buildKeplerEphemeris(
+              sys2,
+              prn2,
+              parsed.date,
+              parsed.values,
+              dataLines2
+            )
+          );
+        }
+      }
+      i++;
+      continue;
+    }
+    let sys;
+    let prn;
+    let date;
+    let epochVals;
+    if (isV2) {
+      const parsed = parseNavEpochV2(line, defaultSys);
+      sys = defaultSys;
+      prn = parsed.prn;
+      date = parsed.date;
+      epochVals = parsed.values;
+    } else {
+      sys = line.charAt(0);
+      const parsed = parseNavEpochV3(line);
+      prn = `${sys}${parsed.prn.substring(1)}`;
+      date = parsed.date;
+      epochVals = parsed.values;
+    }
+    const numDataLines = DATA_LINES[sys];
+    if (numDataLines == null) {
+      i++;
+      continue;
+    }
+    const dataLines = [];
+    for (let j = 0; j < numDataLines; j++) {
+      i++;
+      if (i >= lines.length) break;
+      dataLines.push(parseDataLine(lines[i], isV2 ? 3 : 4));
+    }
+    if (dataLines.length === numDataLines) {
+      if (sys === "R" || sys === "S") {
+        ephemerides.push(
+          buildStateVectorEphemeris(sys, prn, date, epochVals, dataLines)
+        );
+      } else if (sys === "G" || sys === "E" || sys === "C" || sys === "J" || sys === "I") {
+        ephemerides.push(
+          buildKeplerEphemeris(sys, prn, date, epochVals, dataLines)
+        );
+      }
+    }
+    i++;
+  }
+  return { header, ephemerides };
+}
+
+// src/rinex/nav-writer.ts
+function fmtD(val) {
+  if (val === 0) return " 0.000000000000E+00";
+  const sign = val < 0 ? "-" : " ";
+  const abs = Math.abs(val);
+  const exp = Math.floor(Math.log10(abs));
+  const mantissa = abs / 10 ** exp;
+  const mStr = mantissa.toFixed(12);
+  const expSign = exp >= 0 ? "+" : "-";
+  const expStr = String(Math.abs(exp)).padStart(2, "0");
+  return `${sign}${mStr}E${expSign}${expStr}`;
+}
+function fmtEpoch(d) {
+  const Y = padR(String(d.getUTCFullYear()), 4);
+  const M = padR(String(d.getUTCMonth() + 1), 3);
+  const D = padR(String(d.getUTCDate()), 3);
+  const h = padR(String(d.getUTCHours()), 3);
+  const m = padR(String(d.getUTCMinutes()), 3);
+  const s = padR(String(d.getUTCSeconds()), 3);
+  return `${Y}${M}${D}${h}${m}${s}`;
+}
+function isKepler(eph) {
+  return "af0" in eph;
+}
+function writeHeader(nav) {
+  const lines = [];
+  lines.push(
+    hdrLine(
+      padL("     3.04", 9) + "           " + padL("NAVIGATION DATA", 20) + padL("M", 20),
+      "RINEX VERSION / TYPE"
+    )
+  );
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.getUTCFullYear().toString() + String(now.getUTCMonth() + 1).padStart(2, "0") + String(now.getUTCDate()).padStart(2, "0") + " " + String(now.getUTCHours()).padStart(2, "0") + String(now.getUTCMinutes()).padStart(2, "0") + String(now.getUTCSeconds()).padStart(2, "0") + " UTC";
+  lines.push(
+    hdrLine(
+      padL("GNSSCalc", 20) + padL("", 20) + padL(dateStr, 20),
+      "PGM / RUN BY / DATE"
+    )
+  );
+  const ionoOrder = ["GPSA", "GPSB", "GAL", "BDSA", "BDSB"];
+  for (const key of ionoOrder) {
+    const vals = nav.header.ionoCorrections[key];
+    if (!vals) continue;
+    const valStr = vals.map((v) => fmtD(v)).join("");
+    lines.push(hdrLine(padL(key, 5) + valStr, "IONOSPHERIC CORR"));
+  }
+  for (const key of Object.keys(nav.header.ionoCorrections)) {
+    if (ionoOrder.includes(key)) continue;
+    const vals = nav.header.ionoCorrections[key];
+    if (!vals) continue;
+    const valStr = vals.map((v) => fmtD(v)).join("");
+    lines.push(hdrLine(padL(key, 5) + valStr, "IONOSPHERIC CORR"));
+  }
+  if (nav.header.leapSeconds != null) {
+    lines.push(
+      hdrLine(padR(String(nav.header.leapSeconds), 6), "LEAP SECONDS")
+    );
+  }
+  lines.push(hdrLine("", "END OF HEADER"));
+  return lines.join("\n") + "\n";
+}
+function orbitLine(values) {
+  return "    " + values.map(fmtD).join("");
+}
+function writeKeplerRecord(eph) {
+  const lines = [];
+  lines.push(
+    `${padL(eph.prn, 3)} ${fmtEpoch(eph.tocDate)}${fmtD(eph.af0)}${fmtD(eph.af1)}${fmtD(eph.af2)}`
+  );
+  lines.push(orbitLine([eph.iode, eph.crs, eph.deltaN, eph.m0]));
+  lines.push(orbitLine([eph.cuc, eph.e, eph.cus, eph.sqrtA]));
+  lines.push(orbitLine([eph.toe, eph.cic, eph.omega0, eph.cis]));
+  lines.push(orbitLine([eph.i0, eph.crc, eph.omega, eph.omegaDot]));
+  lines.push(orbitLine([eph.idot, 0, eph.week, 0]));
+  lines.push(orbitLine([0, eph.svHealth, eph.tgd, 0]));
+  lines.push(orbitLine([eph.toe, 0, 0, 0]));
+  return lines.join("\n");
+}
+function writeGlonassRecord(eph) {
+  const lines = [];
+  lines.push(
+    `${padL(eph.prn, 3)} ${fmtEpoch(eph.tocDate)}${fmtD(-eph.tauN)}${fmtD(eph.gammaN)}${fmtD(eph.messageFrameTime)}`
+  );
+  lines.push(orbitLine([eph.x, eph.xDot, eph.xAcc, eph.health]));
+  lines.push(orbitLine([eph.y, eph.yDot, eph.yAcc, eph.freqNum]));
+  lines.push(orbitLine([eph.z, eph.zDot, eph.zAcc, 0]));
+  return lines.join("\n");
+}
+function writeRinexNav(nav) {
+  const header = writeHeader(nav);
+  const sorted = [...nav.ephemerides].sort((a, b) => {
+    const prnCmp = a.prn.localeCompare(b.prn);
+    if (prnCmp !== 0) return prnCmp;
+    return a.tocDate.getTime() - b.tocDate.getTime();
+  });
+  const records = sorted.map(
+    (eph) => isKepler(eph) ? writeKeplerRecord(eph) : writeGlonassRecord(eph)
+  );
+  return header + records.join("\n") + "\n";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMPTY_WARNINGS,
+  SYSTEM_ORDER,
+  WarningAccumulator,
+  crxDecompress,
+  crxRepair,
+  fmtF,
+  hdrLine,
+  padL,
+  padR,
+  parseCrxDataLine,
+  parseNavFile,
+  parseRinexStream,
+  systemCmp,
+  systemName,
+  writeRinexNav
+});