gnss-js 2.11.0 → 2.13.0

package/dist/android.js

@@ -0,0 +1,311 @@
+import {
+  C_LIGHT
+} from "./chunk-FIEWO4J4.js";
+
+// src/android/index.ts
+var NS_PER_WEEK = 604800000000000n;
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var BDT_MINUS_GPST_S = -14;
+var GLO_RANGE = [159e7, 161e7];
+var GLO_G1 = 1602e6;
+var GLO_G1_STEP = 562500;
+var STATE_CODE_LOCK = 1;
+var STATE_TOW_DECODED = 8;
+var STATE_MSEC_AMBIGUOUS = 16;
+var STATE_GLO_TOD_DECODED = 128;
+var STATE_GAL_E1BC_CODE_LOCK = 1024;
+var STATE_GAL_E1C_2ND_CODE_LOCK = 2048;
+var STATE_GAL_E1B_PAGE_SYNC = 4096;
+var STATE_TOW_KNOWN = 16384;
+var STATE_GLO_TOD_KNOWN = 32768;
+var ADR_VALID = 1;
+var ADR_RESET = 2;
+var ADR_CYCLE_SLIP = 4;
+var ADR_HALF_CYCLE_RESOLVED = 8;
+var MAX_PR_UNC_NS = 500;
+var MAX_ADR_UNC_M = 0.1;
+var SYSTEM = {
+  1: "G",
+  2: "S",
+  3: "R",
+  4: "J",
+  5: "C",
+  6: "E",
+  7: "I"
+};
+var BANDS = {
+  G: [
+    [1, 157542e4],
+    [2, 12276e5],
+    [5, 117645e4]
+  ],
+  S: [
+    [1, 157542e4],
+    [5, 117645e4]
+  ],
+  J: [
+    [1, 157542e4],
+    [2, 12276e5],
+    [5, 117645e4],
+    [6, 127875e4]
+  ],
+  E: [
+    [1, 157542e4],
+    [5, 117645e4],
+    [7, 120714e4],
+    [6, 127875e4]
+  ],
+  C: [
+    [2, 1561098e3],
+    [1, 157542e4],
+    [5, 117645e4],
+    [7, 120714e4],
+    [6, 126852e4]
+  ],
+  I: [[5, 117645e4]]
+};
+var DEFAULT_ATTR = {
+  G1: "C",
+  G2: "L",
+  G5: "Q",
+  S1: "C",
+  S5: "I",
+  J1: "C",
+  J2: "L",
+  J5: "Q",
+  E1: "C",
+  E5: "Q",
+  E7: "Q",
+  E6: "C",
+  C2: "I",
+  C1: "P",
+  C5: "P",
+  C7: "I",
+  C6: "I",
+  I5: "A",
+  R1: "C",
+  R2: "C"
+};
+function prnOf(sys, svid) {
+  let n = svid;
+  if (sys === "S")
+    n = svid - 100;
+  else if (sys === "J")
+    n = svid - 192;
+  else if (sys === "R" && svid > 24) return null;
+  if (n < 1 || n > 99) return null;
+  return sys + String(n).padStart(2, "0");
+}
+function bandOf(sys, freqHz) {
+  if (sys === "R") {
+    if (freqHz >= GLO_RANGE[0] && freqHz <= GLO_RANGE[1]) {
+      const k = Math.round((freqHz - GLO_G1) / GLO_G1_STEP);
+      return { band: 1, freq: GLO_G1 + k * GLO_G1_STEP, gloChannel: k };
+    }
+    return null;
+  }
+  for (const [band, f] of BANDS[sys] ?? [])
+    if (Math.abs(freqHz - f) < 1e6) return { band, freq: f, gloChannel: null };
+  return null;
+}
+var cells = (line) => line.split(",");
+function parseAndroidGnssLog(text) {
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  const messageCounts = {};
+  const fixes = [];
+  let device = null;
+  let rawCols = null;
+  let fixCols = null;
+  let leapSeconds = null;
+  let rejected = 0;
+  const groups = [];
+  let curKey = "";
+  for (const line of lines) {
+    if (!line) continue;
+    if (line.startsWith("#")) {
+      const body = line.replace(/^#\s*/, "");
+      if (body.startsWith("Raw,"))
+        rawCols = new Map(cells(body).map((c, i) => [c.trim(), i]));
+      else if (body.startsWith("Fix,"))
+        fixCols = new Map(cells(body).map((c, i) => [c.trim(), i]));
+      else if (/Manufacturer/.test(body)) {
+        const m = (k) => new RegExp(`${k}:\\s*([^:]*?)(?:\\s+\\w+:|$)`).exec(body)?.[1]?.trim() ?? "";
+        device = {
+          manufacturer: m("Manufacturer"),
+          model: m("Model"),
+          version: m("Version").replace(/,$/, "")
+        };
+      }
+      continue;
+    }
+    const type = line.slice(0, line.indexOf(","));
+    if (!type) continue;
+    messageCounts[type] = (messageCounts[type] ?? 0) + 1;
+    if (type === "Raw" && rawCols) {
+      const r = cells(line);
+      const key = r[rawCols.get("TimeNanos")] ?? "";
+      if (key !== curKey) {
+        groups.push([]);
+        curKey = key;
+      }
+      groups[groups.length - 1].push(r);
+    } else if (type === "Fix" && fixCols) {
+      const r = cells(line);
+      const g = (k) => {
+        const i = fixCols.get(k);
+        const v = i === void 0 ? "" : (r[i] ?? "").trim();
+        return v === "" ? null : Number(v);
+      };
+      const lat = g("LatitudeDegrees");
+      const lon = g("LongitudeDegrees");
+      const t = g("UnixTimeMillis");
+      if (lat != null && lon != null && t != null)
+        fixes.push({
+          utcMs: t,
+          provider: (r[fixCols.get("Provider") ?? 1] ?? "").trim(),
+          latDeg: lat,
+          lonDeg: lon,
+          altM: g("AltitudeMeters"),
+          accuracyM: g("AccuracyMeters")
+        });
+    }
+  }
+  const epochs = [];
+  const obsCodes = {};
+  if (!rawCols) {
+    return {
+      epochs,
+      fixes,
+      device,
+      messageCounts,
+      obsCodes,
+      rejected,
+      leapSeconds
+    };
+  }
+  const col = rawCols;
+  const str = (r, k) => {
+    const i = col.get(k);
+    return i === void 0 ? "" : (r[i] ?? "").trim();
+  };
+  const num = (r, k) => {
+    const v = str(r, k);
+    return v === "" ? null : Number(v);
+  };
+  let segment = null;
+  let fullBias = 0n;
+  let bias = 0;
+  const lockStart = /* @__PURE__ */ new Map();
+  for (const rows of groups) {
+    const r0 = rows[0];
+    const timeNanosStr = str(r0, "TimeNanos");
+    const fullBiasStr = str(r0, "FullBiasNanos");
+    if (!timeNanosStr || !fullBiasStr) {
+      rejected += rows.length;
+      continue;
+    }
+    const disc = str(r0, "HardwareClockDiscontinuityCount");
+    if (disc !== segment) {
+      segment = disc;
+      fullBias = BigInt(fullBiasStr.split(".")[0]);
+      bias = num(r0, "BiasNanos") ?? 0;
+    }
+    const leap = num(r0, "LeapSecond");
+    if (leap != null && !Number.isNaN(leap)) leapSeconds = leap;
+    const rxNs = BigInt(timeNanosStr.split(".")[0]) - fullBias;
+    const week = Number(rxNs / NS_PER_WEEK);
+    const rxWeekNs = Number(rxNs % NS_PER_WEEK);
+    const epochWeekNs = Math.round((rxWeekNs - bias) / 100) * 100;
+    const toffNs = rxWeekNs - epochWeekNs - bias;
+    const timeMs = GPS_EPOCH_MS + week * 6048e5 + epochWeekNs / 1e6;
+    const leapNow = leapSeconds ?? 18;
+    const meas = [];
+    for (const r of rows) {
+      const sys = SYSTEM[num(r, "ConstellationType") ?? 1];
+      const svid = num(r, "Svid");
+      if (!sys || svid == null) {
+        rejected++;
+        continue;
+      }
+      const prn = prnOf(sys, svid);
+      const freqHz = num(r, "CarrierFrequencyHz") ?? 157542e4;
+      const b = prn ? bandOf(sys, freqHz) : null;
+      const state = num(r, "State") ?? 0;
+      const towOk = sys === "R" ? (state & (STATE_GLO_TOD_DECODED | STATE_GLO_TOD_KNOWN)) !== 0 : (state & (STATE_TOW_DECODED | STATE_TOW_KNOWN)) !== 0;
+      const codeLock = (state & (STATE_CODE_LOCK | STATE_GAL_E1BC_CODE_LOCK)) !== 0;
+      const prUnc = num(r, "ReceivedSvTimeUncertaintyNanos");
+      const svTimeNs = num(r, "ReceivedSvTimeNanos");
+      if (!prn || !b || !towOk || !codeLock || (state & STATE_MSEC_AMBIGUOUS) !== 0 || svTimeNs == null || prUnc != null && prUnc > MAX_PR_UNC_NS) {
+        rejected++;
+        continue;
+      }
+      const subNs = bias + (num(r, "TimeOffsetNanos") ?? 0);
+      let tauNs;
+      if (sys === "R") {
+        const DAY = 864e11;
+        const tTxNs = svTimeNs - 108e11 + leapNow * 1e9;
+        tauNs = ((rxWeekNs % DAY - tTxNs) % DAY + DAY) % DAY;
+        if (tauNs > DAY / 2) tauNs -= DAY;
+      } else {
+        const tTxNs = svTimeNs - (sys === "C" ? BDT_MINUS_GPST_S * 1e9 : 0);
+        tauNs = rxWeekNs - tTxNs;
+        if (tauNs > 3024e11) tauNs -= 6048e11;
+        else if (tauNs < -3024e11) tauNs += 6048e11;
+      }
+      tauNs -= subNs;
+      if (!(tauNs > 6e7 && tauNs < 16e7)) {
+        rejected++;
+        continue;
+      }
+      const pr = (tauNs - toffNs) * 1e-9 * C_LIGHT;
+      const attrCell = str(r, "CodeType");
+      let attr = attrCell || DEFAULT_ATTR[sys + b.band] || "C";
+      if (!attrCell && sys === "E" && b.band === 1 && (state & STATE_GAL_E1C_2ND_CODE_LOCK) === 0 && (state & STATE_GAL_E1B_PAGE_SYNC) !== 0)
+        attr = "B";
+      const code = `${b.band}${attr}`;
+      const lambda = C_LIGHT / b.freq;
+      const adrState = num(r, "AccumulatedDeltaRangeState") ?? 0;
+      const adr = num(r, "AccumulatedDeltaRangeMeters");
+      const adrUnc = num(r, "AccumulatedDeltaRangeUncertaintyMeters");
+      const lockKey = prn + code;
+      let cp = null;
+      if ((adrState & ADR_VALID) !== 0 && adr != null && adr !== 0 && (adrUnc == null || adrUnc < MAX_ADR_UNC_M)) {
+        cp = adr / lambda - toffNs * 1e-9 * b.freq;
+        if ((adrState & (ADR_RESET | ADR_CYCLE_SLIP)) !== 0 || !lockStart.has(lockKey))
+          lockStart.set(lockKey, timeMs);
+      } else lockStart.delete(lockKey);
+      const prr = num(r, "PseudorangeRateMetersPerSecond");
+      meas.push({
+        prn,
+        code,
+        pr,
+        cp,
+        doppler: prr == null ? null : -prr / lambda,
+        cn0: num(r, "Cn0DbHz"),
+        halfCycleAmbiguous: cp != null && (adrState & ADR_HALF_CYCLE_RESOLVED) === 0,
+        lockTimeMs: cp != null ? timeMs - lockStart.get(lockKey) : 0,
+        gloChannel: b.gloChannel
+      });
+      const list = obsCodes[sys] ??= [];
+      if (!list.includes(code)) list.push(code);
+    }
+    if (meas.length > 0) epochs.push({ timeMs, meas });
+  }
+  return {
+    epochs,
+    fixes,
+    device,
+    messageCounts,
+    obsCodes,
+    rejected,
+    leapSeconds
+  };
+}
+function isAndroidGnssLog(text) {
+  const head = text.slice(0, 16384);
+  return /^#\s*Raw,/m.test(head) || /^Raw,\d+,\d+,/m.test(head);
+}
+export {
+  isAndroidGnssLog,
+  parseAndroidGnssLog
+};

package/dist/{clk-DGVBGRzA.d.cts → bias-sinex-OGMw9xEZ.d.cts}

@@ -93,4 +93,69 @@ declare function parseClk(text: string): ClkFile;
  */
 declare function clkBias(clk: ClkFile, prn: string, tMs: number): number | null;
 
-export { type ClkFile as C, type IonexGrid as I, type Sp3File as S, type Sp3Sample as a, parseIonex as b, clkBias as c, parseSp3 as d, parseClk as p, sp3Position as s };
+/**
+ * Bias-SINEX (`.BIA`) parser — GNSS code/phase biases published by the IGS
+ * analysis centres. Two record kinds matter here:
+ *
+ *   - **DSB** differential signal bias (OBS1−OBS2), the classic inter-code
+ *     bias used for ionosphere/DCB corrections in SPP.
+ *   - **OSB** observable-specific (absolute) bias for a single OBS, the
+ *     ingredient PPP-AR needs: the *phase* OSBs are the satellite
+ *     fractional-cycle biases that make the ambiguities integer-recoverable.
+ *
+ * Values keep their file unit (`ns` for code/most phase biases, `cyc` for
+ * cycle-based phase biases); `biasMetres` converts ns → m via c.
+ */
+interface BiasRecord {
+    /** 'DSB' | 'OSB' | 'ISB' | … */
+    type: string;
+    /** Satellite PRN (e.g. 'G01', 'E11'); '' for a pure station bias. */
+    prn: string;
+    /** Station (9-char), '' for satellite biases. */
+    station: string;
+    /** First observable code (e.g. 'C1W', 'L1C'). */
+    obs1: string;
+    /** Second observable (DSB only; '' for OSB). */
+    obs2: string;
+    /** Validity start / end (GPS-scale ms); ±Infinity when open. */
+    startMs: number;
+    endMs: number;
+    /** Estimated value in the file unit. */
+    value: number;
+    /** File unit ('ns' | 'cyc' | …). */
+    unit: string;
+}
+interface BiasSinex {
+    records: BiasRecord[];
+    /** All satellite records grouped by PRN (station === ''). */
+    bySat: Map<string, BiasRecord[]>;
+}
+/** Parse a Bias-SINEX file. */
+declare function parseBiasSinex(text: string): BiasSinex;
+/** A satellite bias record's value in metres (ns → m via c; cyc left as-is). */
+declare function biasMetres(r: BiasRecord): number;
+/**
+ * Look up a satellite bias: a DSB by its (obs1,obs2) pair, or an OSB by obs1
+ * alone (pass obs2 = undefined), valid at `tMs` (default: any). Returns the
+ * record or null.
+ */
+declare function findSatBias(bias: BiasSinex, prn: string, obs1: string, obs2?: string, tMs?: number): BiasRecord | null;
+/**
+ * Fast time-aware lookup of satellite OSBs (metres) — the form PPP needs.
+ * Products with integer-recoverable clocks (CNES/GFZ "ABS", CODE) publish
+ * phase OSBs that change every 30 s–15 min, so one PRN/observable can carry
+ * thousands of records; they're sorted once and found by binary search.
+ * Values are as published (observed = true + bias), so the corrected
+ * observable is `observed − osb(...)`.
+ */
+declare class SatOsbTable {
+    private readonly byKey;
+    constructor(bias: BiasSinex | BiasRecord[]);
+    /** Whether any phase (L…) OSB is present — i.e. the product supports AR. */
+    get hasPhase(): boolean;
+    /** OSB (m) of `prn`'s observable `obs` (e.g. 'C1W', 'L2W') at `tMs`;
+     *  null when the product has none valid then. */
+    get(prn: string, obs: string, tMs: number): number | null;
+}
+
+export { type BiasRecord as B, type ClkFile as C, type IonexGrid as I, SatOsbTable as S, type BiasSinex as a, type Sp3File as b, type Sp3Sample as c, biasMetres as d, clkBias as e, findSatBias as f, parseClk as g, parseIonex as h, parseSp3 as i, parseBiasSinex as p, sp3Position as s };

package/dist/{clk-DGVBGRzA.d.ts → bias-sinex-OGMw9xEZ.d.ts}

@@ -93,4 +93,69 @@ declare function parseClk(text: string): ClkFile;
  */
 declare function clkBias(clk: ClkFile, prn: string, tMs: number): number | null;
 
-export { type ClkFile as C, type IonexGrid as I, type Sp3File as S, type Sp3Sample as a, parseIonex as b, clkBias as c, parseSp3 as d, parseClk as p, sp3Position as s };
+/**
+ * Bias-SINEX (`.BIA`) parser — GNSS code/phase biases published by the IGS
+ * analysis centres. Two record kinds matter here:
+ *
+ *   - **DSB** differential signal bias (OBS1−OBS2), the classic inter-code
+ *     bias used for ionosphere/DCB corrections in SPP.
+ *   - **OSB** observable-specific (absolute) bias for a single OBS, the
+ *     ingredient PPP-AR needs: the *phase* OSBs are the satellite
+ *     fractional-cycle biases that make the ambiguities integer-recoverable.
+ *
+ * Values keep their file unit (`ns` for code/most phase biases, `cyc` for
+ * cycle-based phase biases); `biasMetres` converts ns → m via c.
+ */
+interface BiasRecord {
+    /** 'DSB' | 'OSB' | 'ISB' | … */
+    type: string;
+    /** Satellite PRN (e.g. 'G01', 'E11'); '' for a pure station bias. */
+    prn: string;
+    /** Station (9-char), '' for satellite biases. */
+    station: string;
+    /** First observable code (e.g. 'C1W', 'L1C'). */
+    obs1: string;
+    /** Second observable (DSB only; '' for OSB). */
+    obs2: string;
+    /** Validity start / end (GPS-scale ms); ±Infinity when open. */
+    startMs: number;
+    endMs: number;
+    /** Estimated value in the file unit. */
+    value: number;
+    /** File unit ('ns' | 'cyc' | …). */
+    unit: string;
+}
+interface BiasSinex {
+    records: BiasRecord[];
+    /** All satellite records grouped by PRN (station === ''). */
+    bySat: Map<string, BiasRecord[]>;
+}
+/** Parse a Bias-SINEX file. */
+declare function parseBiasSinex(text: string): BiasSinex;
+/** A satellite bias record's value in metres (ns → m via c; cyc left as-is). */
+declare function biasMetres(r: BiasRecord): number;
+/**
+ * Look up a satellite bias: a DSB by its (obs1,obs2) pair, or an OSB by obs1
+ * alone (pass obs2 = undefined), valid at `tMs` (default: any). Returns the
+ * record or null.
+ */
+declare function findSatBias(bias: BiasSinex, prn: string, obs1: string, obs2?: string, tMs?: number): BiasRecord | null;
+/**
+ * Fast time-aware lookup of satellite OSBs (metres) — the form PPP needs.
+ * Products with integer-recoverable clocks (CNES/GFZ "ABS", CODE) publish
+ * phase OSBs that change every 30 s–15 min, so one PRN/observable can carry
+ * thousands of records; they're sorted once and found by binary search.
+ * Values are as published (observed = true + bias), so the corrected
+ * observable is `observed − osb(...)`.
+ */
+declare class SatOsbTable {
+    private readonly byKey;
+    constructor(bias: BiasSinex | BiasRecord[]);
+    /** Whether any phase (L…) OSB is present — i.e. the product supports AR. */
+    get hasPhase(): boolean;
+    /** OSB (m) of `prn`'s observable `obs` (e.g. 'C1W', 'L2W') at `tMs`;
+     *  null when the product has none valid then. */
+    get(prn: string, obs: string, tMs: number): number | null;
+}
+
+export { type BiasRecord as B, type ClkFile as C, type IonexGrid as I, SatOsbTable as S, type BiasSinex as a, type Sp3File as b, type Sp3Sample as c, biasMetres as d, clkBias as e, findSatBias as f, parseClk as g, parseIonex as h, parseSp3 as i, parseBiasSinex as p, sp3Position as s };

package/dist/{chunk-MDO77CCC.js → chunk-2DJ4XENO.js}

@@ -1617,6 +1617,50 @@ function findSatBias(bias, prn, obs1, obs2, tMs) {
   }
   return null;
 }
+var SatOsbTable = class {
+  byKey = /* @__PURE__ */ new Map();
+  constructor(bias) {
+    const recs = Array.isArray(bias) ? bias : bias.records;
+    const groups = /* @__PURE__ */ new Map();
+    for (const r of recs) {
+      if (r.type !== "OSB" || !r.prn || r.station) continue;
+      if (r.unit !== "ns") continue;
+      const k = `${r.prn} ${r.obs1}`;
+      let g = groups.get(k);
+      if (!g) groups.set(k, g = []);
+      g.push(r);
+    }
+    for (const [k, g] of groups) {
+      g.sort((a, b) => a.startMs - b.startMs);
+      this.byKey.set(k, {
+        start: Float64Array.from(g, (r) => r.startMs),
+        end: Float64Array.from(g, (r) => r.endMs),
+        m: Float64Array.from(g, biasMetres)
+      });
+    }
+  }
+  /** Whether any phase (L…) OSB is present — i.e. the product supports AR. */
+  get hasPhase() {
+    for (const k of this.byKey.keys())
+      if (k.split(" ")[1][0] === "L") return true;
+    return false;
+  }
+  /** OSB (m) of `prn`'s observable `obs` (e.g. 'C1W', 'L2W') at `tMs`;
+   *  null when the product has none valid then. */
+  get(prn, obs, tMs) {
+    const e = this.byKey.get(`${prn} ${obs}`) ?? this.byKey.get(`${prn} ${obs.slice(0, 2)}X`);
+    if (!e) return null;
+    let lo = 0;
+    let hi = e.start.length - 1;
+    if (tMs < e.start[0]) return null;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (e.start[mid] <= tMs) lo = mid;
+      else hi = mid - 1;
+    }
+    return tMs <= e.end[lo] ? e.m[lo] : null;
+  }
+};
 
 // src/rinex/obs-writer-common.ts
 function createGzipLineSink() {
@@ -2021,6 +2065,7 @@ export {
   parseBiasSinex,
   biasMetres,
   findSatBias,
+  SatOsbTable,
   createGzipLineSink,
   stationHeaderLines,
   writeRinexObsBlob,

package/dist/{chunk-IQHQHUOB.js → chunk-2KQMCJ5Z.js}

@@ -1,11 +1,13 @@
 import {
   BdsAssembler,
-  GalInavAssembler,
   GloStringAssembler,
   bdsSubframeParityOk,
-  galInavPageCrcOk,
   testGloString
-} from "./chunk-SSWFX3P3.js";
+} from "./chunk-NIJ6WFQJ.js";
+import {
+  GalInavAssembler,
+  galInavPageCrcOk
+} from "./chunk-TWGZTRBL.js";
 import {
   decodeSbasGeoNav,
   sbasCrcOk

package/dist/chunk-E3Y6YKQM.js

@@ -0,0 +1,65 @@
+// src/sbf/frame.ts
+var CRC_TABLE = (() => {
+  const t = new Uint16Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n << 8;
+    for (let k = 0; k < 8; k++)
+      c = c & 32768 ? (c << 1 ^ 4129) & 65535 : c << 1 & 65535;
+    t[n] = c;
+  }
+  return t;
+})();
+function crc16(data, start, end) {
+  let crc = 0;
+  for (let i = start; i < end; i++)
+    crc = (crc << 8 ^ CRC_TABLE[(crc >> 8 ^ data[i]) & 255]) & 65535;
+  return crc;
+}
+function scanSbfFrames(data, view, onBlock) {
+  let badCrc = 0;
+  let i = 0;
+  while (i + 8 <= data.length) {
+    if (data[i] !== 36 || data[i + 1] !== 64) {
+      i++;
+      continue;
+    }
+    const len = view.getUint16(i + 6, true);
+    if (len < 8 || len % 4 !== 0) {
+      i++;
+      continue;
+    }
+    if (i + len > data.length) break;
+    if (crc16(data, i + 4, i + len) !== view.getUint16(i + 2, true)) {
+      badCrc++;
+      i++;
+      continue;
+    }
+    onBlock(view.getUint16(i + 4, true) & 8191, i, len);
+    i += len;
+  }
+  return badCrc;
+}
+var two = (n) => String(n).padStart(2, "0");
+function svidToPrn(svid) {
+  if (svid >= 1 && svid <= 37) return svid <= 32 ? `G${two(svid)}` : null;
+  if (svid <= 61) return svid - 37 <= 27 ? `R${two(svid - 37)}` : null;
+  if (svid <= 62) return null;
+  if (svid <= 68) return svid - 38 <= 27 ? `R${two(svid - 38)}` : null;
+  if (svid <= 70) return null;
+  if (svid <= 106) return svid - 70 <= 36 ? `E${two(svid - 70)}` : null;
+  if (svid <= 119) return null;
+  if (svid <= 140) return `S${two(svid - 100)}`;
+  if (svid <= 180) return svid - 140 <= 50 ? `C${two(svid - 140)}` : null;
+  if (svid <= 190) return `J${two(svid - 180)}`;
+  if (svid <= 197) return svid - 190 <= 14 ? `I${two(svid - 190)}` : null;
+  if (svid <= 215) return `S${two(svid - 157)}`;
+  if (svid <= 222) return svid - 208 <= 14 ? `I${two(svid - 208)}` : null;
+  if (svid <= 245) return svid - 182 <= 50 ? `C${two(svid - 182)}` : null;
+  return null;
+}
+
+export {
+  crc16,
+  scanSbfFrames,
+  svidToPrn
+};

package/dist/{chunk-3U5AX7PY.js → chunk-FEABDV5P.js}

@@ -5,20 +5,14 @@ import {
 // src/rinex/crx.ts
 function crxRepair(old, diff) {
   const chars = old.split("");
-  for (let i = 0; i < diff.length; i++) {
+  const n = Math.min(old.length, diff.length);
+  for (let i = 0; i < n; 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];
-    }
+    if (dc === " ") continue;
+    chars[i] = dc === "&" ? " " : dc;
   }
+  for (let i = old.length; i < diff.length; i++)
+    chars[i] = diff[i] === "&" ? " " : diff[i];
   return chars.join("");
 }
 function parseCrxDataLine(line, ntype) {
@@ -266,6 +260,15 @@ function readObsValue(line, index) {
   const v = parseFloat(raw);
   return isNaN(v) ? null : v;
 }
+function normalizePrn(id) {
+  let sys = id[0];
+  let num = id.substring(1);
+  if (sys === " " || /\d/.test(sys)) {
+    num = id;
+    sys = "G";
+  }
+  return sys + num.replace(/\s/g, "").padStart(2, "0");
+}
 function parseEpochLine3(line) {
   if (line[0] !== ">") return null;
   const yr = parseInt(line.substring(2, 6));
@@ -415,7 +418,7 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
   function processSatLineV3(line) {
     if (!header || line.length < 3) return;
     const sys = line[0];
-    const prn = line.substring(0, 3);
+    const prn = normalizePrn(line.substring(0, 3));
     trackSat(sys, prn);
     const obsLine = line.substring(3);
     const codes = header.obsTypes[sys] ?? [];
@@ -440,10 +443,8 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
   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");
+    const prn = normalizePrn(v2SatIds[v2SatIndex]);
+    const sys = prn[0];
     if (v2CurrentSatLine === 0) {
       trackSat(sys, prn);
       if (onSatObs) v2ObsAccum = [];
@@ -534,6 +535,7 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
         } else {
           epochLine = crxRepair(crxPrevEpochLine, line);
         }
+        epochLine = epochLine.replace(/ +$/, "");
         if (isV3) {
           if (epochLine[0] !== ">") return;
           const info = parseEpochLine3(epochLine);
@@ -551,10 +553,11 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
             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));
+          for (let k = 0; k < info.numSats; k++) {
+            crxSatList.push(
+              normalizePrn(epochLine.substring(41 + 3 * k, 44 + 3 * k))
+            );
           }
           crxSatIndex = 0;
           crxPrevEpochLine = epochLine;
@@ -575,11 +578,7 @@ async function parseRinexStream(file, onProgress, signal, onSatObs, workerMode)
             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");
-          });
+          crxSatList = (info.satIds ?? []).slice(0, info.numSats).map(normalizePrn);
           crxSatIndex = 0;
           crxPrevEpochLine = epochLine;
           crxPhase = "clock";