gnss-js 0.1.2 → 1.0.0

package/dist/chunk-Y3R57B5P.js

@@ -0,0 +1,473 @@
+import {
+  parseRinexStream
+} from "./chunk-CB6EOOLA.js";
+import {
+  ARC_GAP_FACTOR,
+  BAND_LABELS,
+  C_LIGHT,
+  DUAL_FREQ_PAIRS,
+  FREQ,
+  SYSTEM_NAMES,
+  buildGloChannelMap,
+  buildObsIndices,
+  getFreq
+} from "./chunk-354IRDOG.js";
+
+// src/analysis/multipath.ts
+var MIN_ARC_LENGTH = 10;
+var MultipathAccumulator = class {
+  state = /* @__PURE__ */ new Map();
+  results = [];
+  interval;
+  obsIndices;
+  gloChannels;
+  constructor(header) {
+    this.interval = header.interval ?? 30;
+    this.obsIndices = buildObsIndices(header);
+    this.gloChannels = buildGloChannelMap(header.glonassSlots);
+  }
+  /** Observation callback — wire this into parseRinexStream. */
+  onObservation = (time, prn, _codes, values) => {
+    const sys = prn[0];
+    const bandMap = this.obsIndices.get(sys) ?? this.obsIndices.get("_v2");
+    if (!bandMap) return;
+    const bandData = /* @__PURE__ */ new Map();
+    for (const [band, { C, L }] of bandMap) {
+      if (C === null) continue;
+      const cVal = values[C];
+      const lVal = values[L];
+      const freq = getFreq(this.gloChannels, prn, band);
+      if (cVal != null && cVal !== 0 && lVal != null && lVal !== 0 && freq) {
+        bandData.set(band, { C: cVal, L: lVal, f: freq });
+      }
+    }
+    if (bandData.size < 2) return;
+    const pairs = DUAL_FREQ_PAIRS[sys] ?? [];
+    for (const [bi, bj] of pairs) {
+      const di = bandData.get(bi);
+      const dj = bandData.get(bj);
+      if (!di || !dj) continue;
+      const \u03BBi = C_LIGHT / di.f;
+      const \u03BBj = C_LIGHT / dj.f;
+      const \u03B1 = di.f * di.f / (dj.f * dj.f);
+      const coeff = 2 / (\u03B1 - 1);
+      const mp = di.C - (1 + coeff) * di.L * \u03BBi + coeff * dj.L * \u03BBj;
+      this.pushMp(prn, bi, bj, time, mp);
+    }
+  };
+  pushMp(prn, band, refBand, time, mp) {
+    if (!isFinite(mp)) return;
+    const pairKey = `${band}-${refBand}`;
+    let satStates = this.state.get(prn);
+    if (!satStates) {
+      satStates = /* @__PURE__ */ new Map();
+      this.state.set(prn, satStates);
+    }
+    let bandState = satStates.get(pairKey);
+    if (!bandState) {
+      bandState = { arc: { times: [], rawMp: [] }, lastTime: 0 };
+      satStates.set(pairKey, bandState);
+    }
+    const gap = bandState.lastTime > 0 ? (time - bandState.lastTime) / 1e3 : 0;
+    if (bandState.lastTime > 0 && gap > this.interval * ARC_GAP_FACTOR) {
+      this.closeArc(prn, band, refBand, bandState);
+    }
+    bandState.arc.times.push(time);
+    bandState.arc.rawMp.push(mp);
+    bandState.lastTime = time;
+  }
+  /** External cycle-slip notification — close affected arcs for this PRN. */
+  notifySlip(_time, prn, bands) {
+    const satStates = this.state.get(prn);
+    if (!satStates) return;
+    for (const [pairKey, bandState] of satStates) {
+      const [band, refBand] = pairKey.split("-");
+      if (bands.has(band) || bands.has(refBand)) {
+        this.closeArc(prn, band, refBand, bandState);
+      }
+    }
+  }
+  closeArc(prn, band, refBand, state) {
+    const arc = state.arc;
+    if (arc.times.length >= MIN_ARC_LENGTH) {
+      const mean = arc.rawMp.reduce((a, b) => a + b, 0) / arc.rawMp.length;
+      const sys = prn[0];
+      const bLabel = BAND_LABELS[sys]?.[band] ?? band;
+      const rLabel = BAND_LABELS[sys]?.[refBand] ?? refBand;
+      const label = `${prn} MP ${bLabel}-${rLabel}`;
+      const points = arc.times.map((t, i) => ({
+        time: t,
+        mp: arc.rawMp[i] - mean
+      }));
+      const rms = Math.sqrt(points.reduce((s, p) => s + p.mp * p.mp, 0) / points.length);
+      this.results.push({ prn, system: sys, band, refBand, label, points, rms });
+    }
+    state.arc = { times: [], rawMp: [] };
+  }
+  /** Finalize: close remaining arcs and compute statistics. */
+  finalize() {
+    for (const [prn, satStates] of this.state) {
+      for (const [pairKey, bandState] of satStates) {
+        const [band, refBand] = pairKey.split("-");
+        this.closeArc(prn, band, refBand, bandState);
+      }
+    }
+    const signalGroups = /* @__PURE__ */ new Map();
+    for (const series of this.results) {
+      const key = `${series.system}-${series.band}-${series.refBand}`;
+      if (!signalGroups.has(key)) signalGroups.set(key, []);
+      signalGroups.get(key).push(series);
+    }
+    const signalStats = [];
+    for (const [, seriesList] of signalGroups) {
+      const { system, band, refBand } = seriesList[0];
+      let sumSq = 0;
+      let count = 0;
+      for (const s of seriesList) {
+        for (const p of s.points) {
+          sumSq += p.mp * p.mp;
+          count++;
+        }
+      }
+      const rms = count > 0 ? Math.sqrt(sumSq / count) : 0;
+      const bLabel = BAND_LABELS[system]?.[band] ?? band;
+      const rLabel = BAND_LABELS[system]?.[refBand] ?? refBand;
+      const sysName = SYSTEM_NAMES[system] ?? system;
+      signalStats.push({
+        label: `MP ${bLabel}-${rLabel} (${sysName})`,
+        system,
+        band,
+        refBand,
+        rms,
+        count,
+        satellites: seriesList.length
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.band.localeCompare(b.band);
+    });
+    return { series: this.results, signalStats };
+  }
+};
+
+// src/analysis/cycle-slip.ts
+var MW_MIN_THRESHOLD = 0.5;
+var MW_SIGMA_FACTOR = 4;
+var MW_MIN_EPOCHS = 3;
+var GF_THRESHOLD_M = 0.15;
+var SF_THRESHOLD_M = 3;
+function mwSmoothInit(value) {
+  return { mean: value, m2: 0, n: 1 };
+}
+function mwSmoothUpdate(s, value) {
+  const n = s.n + 1;
+  const delta = value - s.mean;
+  const mean = s.mean + delta / n;
+  const delta2 = value - mean;
+  return { mean, m2: s.m2 + delta * delta2, n };
+}
+function mwSmoothStddev(s) {
+  return s.n > 1 ? Math.sqrt(s.m2 / (s.n - 1)) : Infinity;
+}
+var CycleSlipAccumulator = class {
+  obsIndices;
+  prev = /* @__PURE__ */ new Map();
+  events = [];
+  interval;
+  /** GLONASS PRN → channel k for FDMA frequency computation. */
+  gloChannels;
+  onSlip;
+  // Per-signal epoch/slip counting
+  signalEpochs = /* @__PURE__ */ new Map();
+  signalSlips = /* @__PURE__ */ new Map();
+  signalSats = /* @__PURE__ */ new Map();
+  constructor(header, onSlip) {
+    this.interval = header.interval ?? 30;
+    this.obsIndices = buildObsIndices(header);
+    this.gloChannels = buildGloChannelMap(header.glonassSlots);
+    this.onSlip = onSlip;
+  }
+  recordSlip(sigKey, time, prn, signal, magnitude, bands) {
+    this.events.push({ time, prn, signal, magnitude });
+    this.signalSlips.set(sigKey, (this.signalSlips.get(sigKey) ?? 0) + 1);
+    if (!this.signalSats.has(sigKey)) this.signalSats.set(sigKey, /* @__PURE__ */ new Set());
+    this.signalSats.get(sigKey).add(prn);
+    this.onSlip?.(time, prn, bands);
+  }
+  countEpoch(sigKey) {
+    this.signalEpochs.set(sigKey, (this.signalEpochs.get(sigKey) ?? 0) + 1);
+  }
+  /** Resolve frequency for a given PRN + band. Handles GLONASS FDMA. */
+  getFreqForPrn(prn, band) {
+    return getFreq(this.gloChannels, prn, band);
+  }
+  onObservation = (time, prn, _codes, values) => {
+    const sys = prn[0];
+    const idxMap = this.obsIndices.get(sys) ?? this.obsIndices.get("_v2");
+    if (!idxMap) return;
+    if (sys !== "R" && !FREQ[sys]) return;
+    const phaseM = /* @__PURE__ */ new Map();
+    const codeM = /* @__PURE__ */ new Map();
+    for (const [band, { L, C }] of idxMap) {
+      const freq = this.getFreqForPrn(prn, band);
+      if (!freq) continue;
+      const lVal = values[L];
+      if (lVal != null && lVal !== 0) phaseM.set(band, lVal * (C_LIGHT / freq));
+      if (C !== null) {
+        const cVal = values[C];
+        if (cVal != null && cVal !== 0) codeM.set(band, cVal);
+      }
+    }
+    if (phaseM.size === 0) return;
+    const prev = this.prev.get(prn);
+    const gap = prev ? (time - prev.time) / 1e3 : 0;
+    const isArcBreak = !prev || gap > this.interval * ARC_GAP_FACTOR;
+    const mwSmooth = /* @__PURE__ */ new Map();
+    const gfMap = /* @__PURE__ */ new Map();
+    const pairs = DUAL_FREQ_PAIRS[sys] ?? [];
+    for (const [b1, b2] of pairs) {
+      const l1 = phaseM.get(b1);
+      const l2 = phaseM.get(b2);
+      const f1 = this.getFreqForPrn(prn, b1);
+      const f2 = this.getFreqForPrn(prn, b2);
+      if (!f1 || !f2) continue;
+      const pairKey = `${b1}-${b2}`;
+      if (l1 !== void 0 && l2 !== void 0) {
+        gfMap.set(pairKey, l1 - l2);
+      }
+      const c1 = codeM.get(b1);
+      const c2 = codeM.get(b2);
+      if (l1 !== void 0 && l2 !== void 0 && c1 !== void 0 && c2 !== void 0) {
+        const lambda_wl = C_LIGHT / (f1 - f2);
+        const phi_wl = (f1 * l1 - f2 * l2) / C_LIGHT;
+        const P_nl = (f1 * c1 + f2 * c2) / ((f1 + f2) * lambda_wl);
+        const mw = phi_wl - P_nl;
+        const prevSmooth = isArcBreak ? void 0 : prev?.mwSmooth.get(pairKey);
+        if (prevSmooth && prevSmooth.n >= MW_MIN_EPOCHS) {
+          const lbl1 = BAND_LABELS[sys]?.[b1] ?? b1;
+          const lbl2 = BAND_LABELS[sys]?.[b2] ?? b2;
+          const signal = `MW ${lbl1}-${lbl2}`;
+          const sigKey = `${sys}:${signal}`;
+          this.countEpoch(sigKey);
+          const stddev = mwSmoothStddev(prevSmooth);
+          const threshold = Math.max(MW_MIN_THRESHOLD, MW_SIGMA_FACTOR * stddev);
+          const deviation = Math.abs(mw - prevSmooth.mean);
+          if (deviation > threshold) {
+            this.recordSlip(sigKey, time, prn, signal, deviation, /* @__PURE__ */ new Set([b1, b2]));
+            mwSmooth.set(pairKey, mwSmoothInit(mw));
+          } else {
+            mwSmooth.set(pairKey, mwSmoothUpdate(prevSmooth, mw));
+          }
+        } else if (prevSmooth) {
+          mwSmooth.set(pairKey, mwSmoothUpdate(prevSmooth, mw));
+        } else {
+          mwSmooth.set(pairKey, mwSmoothInit(mw));
+        }
+      }
+    }
+    if (!isArcBreak && prev) {
+      const dualChecked = /* @__PURE__ */ new Set();
+      for (const [b1, b2] of pairs) {
+        const pairKey = `${b1}-${b2}`;
+        const lbl1 = BAND_LABELS[sys]?.[b1] ?? b1;
+        const lbl2 = BAND_LABELS[sys]?.[b2] ?? b2;
+        if (mwSmooth.has(pairKey)) {
+          dualChecked.add(b1);
+          dualChecked.add(b2);
+          continue;
+        }
+        const curGf = gfMap.get(pairKey);
+        const prevGf = prev.gf.get(pairKey);
+        if (curGf !== void 0 && prevGf !== void 0) {
+          const signal = `GF ${lbl1}-${lbl2}`;
+          const sigKey = `${sys}:${signal}`;
+          this.countEpoch(sigKey);
+          const jump = Math.abs(curGf - prevGf);
+          if (jump > GF_THRESHOLD_M) {
+            this.recordSlip(sigKey, time, prn, signal, jump, /* @__PURE__ */ new Set([b1, b2]));
+          }
+          dualChecked.add(b1);
+          dualChecked.add(b2);
+        }
+      }
+      for (const [band, lm] of phaseM) {
+        if (dualChecked.has(band)) continue;
+        const prevLm = prev.phase.get(band);
+        if (prevLm === void 0) continue;
+        const cm = codeM.get(band);
+        const prevCm = prev.code.get(band);
+        if (cm === void 0 || prevCm === void 0) continue;
+        const dPhase = lm - prevLm;
+        const dCode = cm - prevCm;
+        const jumpM = Math.abs(dPhase - dCode);
+        const lbl = BAND_LABELS[sys]?.[band] ?? band;
+        const sigKey = `${sys}:${lbl}`;
+        this.countEpoch(sigKey);
+        if (jumpM > SF_THRESHOLD_M) {
+          this.recordSlip(sigKey, time, prn, lbl, jumpM, /* @__PURE__ */ new Set([band]));
+        }
+      }
+    }
+    this.prev.set(prn, { time, mwSmooth, gf: gfMap, phase: phaseM, code: codeM });
+  };
+  finalize() {
+    const satSlipCounts = {};
+    for (const ev of this.events) {
+      satSlipCounts[ev.prn] = (satSlipCounts[ev.prn] ?? 0) + 1;
+    }
+    const signalStats = [];
+    const allKeys = /* @__PURE__ */ new Set([...this.signalEpochs.keys(), ...this.signalSlips.keys()]);
+    for (const sigKey of allKeys) {
+      const [sys, ...rest] = sigKey.split(":");
+      const signal = rest.join(":");
+      const totalEpochs = this.signalEpochs.get(sigKey) ?? 0;
+      const totalSlips = this.signalSlips.get(sigKey) ?? 0;
+      const sysName = SYSTEM_NAMES[sys] ?? sys;
+      signalStats.push({
+        label: `${signal} (${sysName})`,
+        system: sys,
+        totalSlips,
+        satellites: this.signalSats.get(sigKey)?.size ?? 0,
+        totalEpochs,
+        slipRate: totalEpochs > 0 ? totalSlips / totalEpochs * 1e3 : 0
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.label.localeCompare(b.label);
+    });
+    return { events: this.events, signalStats, satSlipCounts };
+  }
+};
+
+// src/analysis/completeness.ts
+var CompletenessAccumulator = class {
+  // PRN → code → { seen, expected, present }
+  // "seen" gates counting: expected only increments after a satellite has transmitted
+  // the signal at least once (avoids inflating expected for signals a sat doesn't have,
+  // e.g. L5 on GPS Block IIR).
+  data = /* @__PURE__ */ new Map();
+  header;
+  constructor(header) {
+    this.header = header;
+  }
+  onObservation = (_time, prn, codes, values) => {
+    let satMap = this.data.get(prn);
+    if (!satMap) {
+      satMap = /* @__PURE__ */ new Map();
+      this.data.set(prn, satMap);
+    }
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const hasValue = values[i] != null && values[i] !== 0;
+      let cell = satMap.get(code);
+      if (!cell) {
+        cell = { seen: false, expected: 0, present: 0 };
+        satMap.set(code, cell);
+      }
+      if (hasValue) cell.seen = true;
+      if (cell.seen) cell.expected++;
+      if (hasValue) cell.present++;
+    }
+  };
+  finalize() {
+    const cells = [];
+    const systemSet = /* @__PURE__ */ new Set();
+    for (const [prn, satMap] of this.data) {
+      const sys = prn[0];
+      systemSet.add(sys);
+      for (const [code, { seen, expected, present }] of satMap) {
+        if (!seen) continue;
+        const band = code[1] ?? "?";
+        cells.push({
+          prn,
+          system: sys,
+          code,
+          band,
+          expected,
+          present,
+          percent: expected > 0 ? present / expected * 100 : 0
+        });
+      }
+    }
+    const sigAgg = /* @__PURE__ */ new Map();
+    for (const c of cells) {
+      const key = `${c.system}:${c.code}`;
+      let agg = sigAgg.get(key);
+      if (!agg) {
+        agg = { expected: 0, present: 0, sats: /* @__PURE__ */ new Set() };
+        sigAgg.set(key, agg);
+      }
+      agg.expected += c.expected;
+      agg.present += c.present;
+      agg.sats.add(c.prn);
+    }
+    const signalStats = [];
+    for (const [key, agg] of sigAgg) {
+      const [sys, code] = key.split(":");
+      const band = code[1] ?? "?";
+      const bandLabel = BAND_LABELS[sys]?.[band] ?? `Band ${band}`;
+      const sysName = SYSTEM_NAMES[sys] ?? sys;
+      signalStats.push({
+        code,
+        system: sys,
+        label: `${code} (${sysName} ${bandLabel})`,
+        expected: agg.expected,
+        present: agg.present,
+        percent: agg.expected > 0 ? agg.present / agg.expected * 100 : 0,
+        satellites: agg.sats.size
+      });
+    }
+    const sysOrder = "GRECIJS";
+    signalStats.sort((a, b) => {
+      const da = sysOrder.indexOf(a.system);
+      const db = sysOrder.indexOf(b.system);
+      if (da !== db) return (da === -1 ? 99 : da) - (db === -1 ? 99 : db);
+      return a.code.localeCompare(b.code);
+    });
+    const systems = [...systemSet].sort((a, b) => {
+      return (sysOrder.indexOf(a) === -1 ? 99 : sysOrder.indexOf(a)) - (sysOrder.indexOf(b) === -1 ? 99 : sysOrder.indexOf(b));
+    });
+    return { cells, signalStats, systems };
+  }
+};
+
+// src/analysis/quality-analysis.ts
+async function analyzeQuality(file, header, onProgress, signal) {
+  const mpAccum = new MultipathAccumulator(header);
+  const csAccum = new CycleSlipAccumulator(header, (time, prn, bands) => {
+    mpAccum.notifySlip(time, prn, bands);
+  });
+  const compAccum = new CompletenessAccumulator(header);
+  await parseRinexStream(
+    file,
+    onProgress,
+    signal,
+    (time, prn, codes, values) => {
+      csAccum.onObservation(time, prn, codes, values);
+      mpAccum.onObservation(time, prn, codes, values);
+      compAccum.onObservation(time, prn, codes, values);
+    },
+    true
+    /* workerMode: skip EpochSummary construction */
+  );
+  return {
+    cycleSlips: csAccum.finalize(),
+    completeness: compAccum.finalize(),
+    multipath: mpAccum.finalize()
+  };
+}
+
+export {
+  MultipathAccumulator,
+  CycleSlipAccumulator,
+  CompletenessAccumulator,
+  analyzeQuality
+};

package/dist/chunk-YDMYO3YK.js

@@ -0,0 +1,220 @@
+// src/nmea/index.ts
+function nmeaCoordToDecimal(raw, direction) {
+  if (!raw || !direction) return NaN;
+  const isLon = direction === "E" || direction === "W";
+  const degLen = isLon ? 3 : 2;
+  const degrees = parseInt(raw.substring(0, degLen), 10);
+  const minutes = parseFloat(raw.substring(degLen));
+  const decimal = degrees + minutes / 60;
+  return direction === "S" || direction === "W" ? -decimal : decimal;
+}
+function verifyChecksum(sentence) {
+  const starIdx = sentence.indexOf("*");
+  if (starIdx === -1) return false;
+  const body = sentence.substring(sentence.indexOf("$") + 1, starIdx);
+  let xor = 0;
+  for (let i = 0; i < body.length; i++) xor ^= body.charCodeAt(i);
+  const expected = parseInt(sentence.substring(starIdx + 1, starIdx + 3), 16);
+  return xor === expected;
+}
+function buildDate(timeStr, dateStr) {
+  if (!timeStr || timeStr.length < 6) return null;
+  const h = parseInt(timeStr.substring(0, 2), 10);
+  const m = parseInt(timeStr.substring(2, 4), 10);
+  const s = parseFloat(timeStr.substring(4));
+  if (isNaN(h) || isNaN(m) || isNaN(s)) return null;
+  let year = 2e3, month = 0, day = 1;
+  if (dateStr && dateStr.length >= 6) {
+    day = parseInt(dateStr.substring(0, 2), 10);
+    month = parseInt(dateStr.substring(2, 4), 10) - 1;
+    const yy = parseInt(dateStr.substring(4, 6), 10);
+    year = yy < 80 ? 2e3 + yy : 1900 + yy;
+  }
+  const ms = Math.round(s % 1 * 1e3);
+  return new Date(Date.UTC(year, month, day, h, m, Math.floor(s), ms));
+}
+function parseGGA(fields) {
+  if (fields.length < 10) return null;
+  const quality = parseInt(fields[6], 10);
+  if (isNaN(quality) || quality === 0) return null;
+  const lat = nmeaCoordToDecimal(fields[2], fields[3]);
+  const lon = nmeaCoordToDecimal(fields[4], fields[5]);
+  if (isNaN(lat) || isNaN(lon)) return null;
+  return {
+    time: buildDate(fields[1]),
+    timeKey: fields[1],
+    lat,
+    lon,
+    alt: fields[9] ? parseFloat(fields[9]) : null,
+    satellites: fields[7] ? parseInt(fields[7], 10) : null,
+    fixQuality: quality
+  };
+}
+function parseRMC(fields) {
+  if (fields.length < 10) return null;
+  if (fields[2] !== "A") return null;
+  const lat = nmeaCoordToDecimal(fields[3], fields[4]);
+  const lon = nmeaCoordToDecimal(fields[5], fields[6]);
+  if (isNaN(lat) || isNaN(lon)) return null;
+  return {
+    time: buildDate(fields[1], fields[9]),
+    timeKey: fields[1],
+    lat,
+    lon,
+    speed: fields[7] ? parseFloat(fields[7]) : null,
+    course: fields[8] ? parseFloat(fields[8]) : null,
+    hasDate: true
+  };
+}
+function computeStats(fixes) {
+  const valid = fixes.filter((f) => f.fixQuality > 0);
+  const withTime = valid.filter((f) => f.time !== null);
+  const withSat = valid.filter((f) => f.satellites !== null).map((f) => f.satellites);
+  let startTime = null;
+  let endTime = null;
+  let duration = null;
+  if (withTime.length >= 2) {
+    startTime = withTime[0].time;
+    endTime = withTime[withTime.length - 1].time;
+    duration = (endTime.getTime() - startTime.getTime()) / 1e3;
+  } else if (withTime.length === 1) {
+    startTime = endTime = withTime[0].time;
+  }
+  let totalDistance = null;
+  if (valid.length >= 2) {
+    let dist = 0;
+    for (let i = 1; i < valid.length; i++) {
+      const prev = valid[i - 1], curr = valid[i];
+      dist += haversine(prev.lat, prev.lon, curr.lat, curr.lon);
+    }
+    totalDistance = dist;
+  }
+  const speeds = valid.filter((f) => f.speed !== null).map((f) => f.speed * 1.852);
+  const maxSpeed = speeds.length > 0 ? Math.max(...speeds) : null;
+  let cep = null;
+  let drms2 = null;
+  let hRms = null;
+  let vRms = null;
+  if (valid.length >= 2) {
+    const toRad = (d) => d * Math.PI / 180;
+    const R = 6378137;
+    const e2 = 0.00669437999014;
+    const ecef = valid.map((f) => {
+      const lat = toRad(f.lat), lon = toRad(f.lon), h = f.alt ?? 0;
+      const N = R / Math.sqrt(1 - e2 * Math.sin(lat) ** 2);
+      return [
+        (N + h) * Math.cos(lat) * Math.cos(lon),
+        (N + h) * Math.cos(lat) * Math.sin(lon),
+        ((1 - e2) * N + h) * Math.sin(lat)
+      ];
+    });
+    const n = ecef.length;
+    const mx = ecef.reduce((s, p) => s + p[0], 0) / n;
+    const my = ecef.reduce((s, p) => s + p[1], 0) / n;
+    const mz = ecef.reduce((s, p) => s + p[2], 0) / n;
+    const refLon = Math.atan2(my, mx);
+    const refP = Math.sqrt(mx * mx + my * my);
+    const refLat = Math.atan2(mz, refP * (1 - e2));
+    const sinLat = Math.sin(refLat), cosLat = Math.cos(refLat);
+    const sinLon = Math.sin(refLon), cosLon = Math.cos(refLon);
+    const enu = ecef.map((p) => {
+      const dx = p[0] - mx, dy = p[1] - my, dz = p[2] - mz;
+      return {
+        e: -sinLon * dx + cosLon * dy,
+        n: -cosLon * sinLat * dx - sinLon * sinLat * dy + cosLat * dz,
+        u: cosLon * cosLat * dx + sinLon * cosLat * dy + sinLat * dz
+      };
+    });
+    const hDist = enu.map((p) => Math.sqrt(p.e * p.e + p.n * p.n));
+    hDist.sort((a, b) => a - b);
+    const medIdx = Math.floor(hDist.length * 0.5);
+    cep = hDist[medIdx];
+    const hSqSum = enu.reduce((s, p) => s + p.e * p.e + p.n * p.n, 0);
+    hRms = Math.sqrt(hSqSum / n);
+    drms2 = 2 * hRms;
+    const vSqSum = enu.reduce((s, p) => s + p.u * p.u, 0);
+    vRms = Math.sqrt(vSqSum / n);
+  }
+  return {
+    totalFixes: fixes.length,
+    validFixes: valid.length,
+    duration,
+    startTime,
+    endTime,
+    totalDistance,
+    maxSpeed,
+    cep,
+    drms2,
+    hRms,
+    vRms,
+    avgSatellites: withSat.length > 0 ? withSat.reduce((a, b) => a + b, 0) / withSat.length : null
+  };
+}
+function haversine(lat1, lon1, lat2, lon2) {
+  const toRad = (d) => d * Math.PI / 180;
+  const dLat = toRad(lat2 - lat1);
+  const dLon = toRad(lon2 - lon1);
+  const a = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
+  return 6371e3 * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+function parseNmeaFile(content) {
+  const lines = content.split(/\r?\n/);
+  const fixMap = /* @__PURE__ */ new Map();
+  const fixOrder = [];
+  let lastDate;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line.startsWith("$")) continue;
+    if (line.includes("*") && !verifyChecksum(line)) continue;
+    const fields = line.split("*")[0].split(",");
+    const sentenceId = fields[0].substring(3);
+    let partial = null;
+    if (sentenceId === "GGA") partial = parseGGA(fields);
+    else if (sentenceId === "RMC") partial = parseRMC(fields);
+    if (!partial) continue;
+    const key = partial.timeKey || `line-${fixOrder.length}`;
+    if (partial.hasDate && partial.time) {
+      const d = partial.time;
+      lastDate = `${String(d.getUTCDate()).padStart(2, "0")}${String(d.getUTCMonth() + 1).padStart(2, "0")}${String(d.getUTCFullYear() % 100).padStart(2, "0")}`;
+    }
+    const existing = fixMap.get(key);
+    if (existing) {
+      if (partial.alt !== void 0 && partial.alt !== null)
+        existing.alt = partial.alt;
+      if (partial.satellites !== void 0 && partial.satellites !== null)
+        existing.satellites = partial.satellites;
+      if (partial.fixQuality !== void 0)
+        existing.fixQuality = partial.fixQuality;
+      if (partial.speed !== void 0 && partial.speed !== null)
+        existing.speed = partial.speed;
+      if (partial.course !== void 0 && partial.course !== null)
+        existing.course = partial.course;
+      if (partial.hasDate && partial.time) existing.time = partial.time;
+    } else {
+      let time = partial.time;
+      if (!partial.hasDate && time && lastDate) {
+        time = buildDate(partial.timeKey, lastDate);
+      }
+      fixMap.set(key, {
+        time,
+        lat: partial.lat ?? 0,
+        lon: partial.lon ?? 0,
+        alt: partial.alt ?? null,
+        satellites: partial.satellites ?? null,
+        fixQuality: partial.fixQuality ?? 0,
+        speed: partial.speed ?? null,
+        course: partial.course ?? null
+      });
+      fixOrder.push(key);
+    }
+  }
+  const fixes = fixOrder.map((k) => fixMap.get(k));
+  return { fixes, stats: computeStats(fixes) };
+}
+
+export {
+  nmeaCoordToDecimal,
+  verifyChecksum,
+  computeStats,
+  parseNmeaFile
+};