gnss-js 0.1.2 → 1.0.0

package/dist/chunk-CB6EOOLA.js

@@ -0,0 +1,753 @@
+import {
+  SYSTEM_NAMES
+} from "./chunk-354IRDOG.js";
+
+// 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/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
+  };
+}
+
+export {
+  crxRepair,
+  parseCrxDataLine,
+  crxDecompress,
+  SYSTEM_ORDER,
+  systemCmp,
+  systemName,
+  parseRinexStream
+};