gnss-js 1.25.0 → 1.26.0

package/dist/index.cjs

@@ -111,6 +111,10 @@ __export(src_exports, {
   analyzeQuality: () => analyzeQuality,
   applyHelmert: () => applyHelmert,
   applyIonoDcb: () => applyIonoDcb,
+  binexCrc16: () => binexCrc16,
+  binexCrc32: () => binexCrc32,
+  binexCsum8: () => binexCsum8,
+  binexRecords: () => binexRecords,
   buildGloChannelMap: () => buildGloChannelMap,
   buildObsIndices: () => buildObsIndices,
   clampUnit: () => clampUnit,
@@ -131,6 +135,7 @@ __export(src_exports, {
   crxDecompress: () => crxDecompress,
   crxRepair: () => crxRepair,
   dateToEpoch: () => dateToEpoch,
+  decodeBinexEph: () => decodeBinexEph,
   decodeEphemeris: () => decodeEphemeris,
   decodeMsmFull: () => decodeMsmFull,
   deg2dms: () => deg2dms,
@@ -152,6 +157,7 @@ __export(src_exports, {
   geodeticToUtm: () => geodeticToUtm,
   getAer: () => getAer,
   getBdsTime: () => getBdsTime,
+  getBnxi: () => getBnxi,
   getDateFromBdsTime: () => getDateFromBdsTime,
   getDateFromDayOfWeek: () => getDateFromDayOfWeek,
   getDateFromDayOfYear: () => getDateFromDayOfYear,
@@ -225,6 +231,7 @@ __export(src_exports, {
   padL: () => padL,
   padR: () => padR,
   parseAntex: () => parseAntex,
+  parseBinex: () => parseBinex,
   parseCrxDataLine: () => parseCrxDataLine,
   parseIonex: () => parseIonex,
   parseNavFile: () => parseNavFile,
@@ -244,6 +251,8 @@ __export(src_exports, {
   parseSinexBiasDcb: () => parseSinexBiasDcb,
   parseSourcetable: () => parseSourcetable,
   parseSp3: () => parseSp3,
+  parseTrimble: () => parseTrimble,
+  parseTrimbleNav: () => parseTrimbleNav,
   parseUbxCnav: () => parseUbxCnav,
   parseUbxIonoUtc: () => parseUbxIonoUtc,
   parseUbxNav: () => parseUbxNav,
@@ -274,6 +283,7 @@ __export(src_exports, {
   systemName: () => systemName,
   toRtkEpoch: () => toRtkEpoch,
   transformFrame: () => transformFrame,
+  trimbleFrames: () => trimbleFrames,
   ubxFrames: () => ubxFrames,
   updateStationMeta: () => updateStationMeta,
   updateStreamStats: () => updateStreamStats,
@@ -6280,20 +6290,20 @@ var SIGNALS = {
   // GLONASS L1OF, L2OF
 };
 function prnFor(gnssId, svId) {
-  const two5 = (n) => String(n).padStart(2, "0");
+  const two7 = (n) => String(n).padStart(2, "0");
   switch (gnssId) {
     case 0:
-      return svId >= 1 && svId <= 32 ? `G${two5(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `G${two7(svId)}` : null;
     case 1:
-      return svId >= 120 && svId <= 158 ? `S${two5(svId - 100)}` : null;
+      return svId >= 120 && svId <= 158 ? `S${two7(svId - 100)}` : null;
     case 2:
-      return svId >= 1 && svId <= 36 ? `E${two5(svId)}` : null;
+      return svId >= 1 && svId <= 36 ? `E${two7(svId)}` : null;
     case 3:
-      return svId >= 1 && svId <= 63 ? `C${two5(svId)}` : null;
+      return svId >= 1 && svId <= 63 ? `C${two7(svId)}` : null;
     case 5:
-      return svId >= 1 && svId <= 10 ? `J${two5(svId)}` : null;
+      return svId >= 1 && svId <= 10 ? `J${two7(svId)}` : null;
     case 6:
-      return svId >= 1 && svId <= 32 ? `R${two5(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `R${two7(svId)}` : null;
     default:
       return null;
   }
@@ -8680,20 +8690,1180 @@ function parseNovatelRange(data) {
   return { epochs, messageCounts, obsCodes, badCrc };
 }
 
+// src/trimble/frame.ts
+var STX = 2;
+var ETX = 3;
+var RAWDATA = 87;
+var RETSVDATA = 85;
+function* trimbleFrames(data, stats) {
+  let i = 0;
+  while (i + 6 <= data.length) {
+    if (data[i] !== STX) {
+      i++;
+      continue;
+    }
+    const len = data[i + 3];
+    const total = 4 + len + 2;
+    if (i + total > data.length) {
+      i++;
+      continue;
+    }
+    if (data[i + total - 1] !== ETX) {
+      i++;
+      continue;
+    }
+    let cs = 0;
+    for (let k = 1; k <= 3 + len; k++) cs = cs + data[i + k] & 255;
+    if (cs !== data[i + 4 + len]) {
+      stats.badChecksum++;
+      i++;
+      continue;
+    }
+    yield {
+      start: i,
+      status: data[i + 1],
+      type: data[i + 2],
+      len,
+      payload: i + 4
+    };
+    i += total;
+  }
+}
+
+// src/trimble/nav.ts
+var GPS_EPOCH_MS13 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK10 = 7 * 86400;
+var MS_PER_WEEK9 = SEC_PER_WEEK10 * 1e3;
+var GPS_PI2 = 3.1415926535898;
+var gpsMs3 = (week, sec) => GPS_EPOCH_MS13 + week * MS_PER_WEEK9 + sec * 1e3;
+var sowOf4 = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK10;
+var SUB_GPS_EPHEMERIS = 1;
+var SUB_ION_UTC = 3;
+function decodeGpsEphemeris2(data, view, base) {
+  const prn = data[base + 5];
+  if (prn < 1 || prn > 32) return null;
+  const week = view.getUint16(base + 6, false);
+  const iode = data[base + 11];
+  const toc = view.getInt32(base + 16, false);
+  const toe = view.getUint32(base + 20, false);
+  const tgd = view.getFloat64(base + 24, false);
+  const af2 = view.getFloat64(base + 32, false);
+  const af1 = view.getFloat64(base + 40, false);
+  const af0 = view.getFloat64(base + 48, false);
+  const crs = view.getFloat64(base + 56, false);
+  const deltaN = view.getFloat64(base + 64, false) * GPS_PI2;
+  const m0 = view.getFloat64(base + 72, false) * GPS_PI2;
+  const cuc = view.getFloat64(base + 80, false) * GPS_PI2;
+  const e = view.getFloat64(base + 88, false);
+  const cus = view.getFloat64(base + 96, false) * GPS_PI2;
+  const sqrtA = view.getFloat64(base + 104, false);
+  const cic = view.getFloat64(base + 112, false) * GPS_PI2;
+  const omega0 = view.getFloat64(base + 120, false) * GPS_PI2;
+  const cis = view.getFloat64(base + 128, false) * GPS_PI2;
+  const i0 = view.getFloat64(base + 136, false) * GPS_PI2;
+  const crc = view.getFloat64(base + 144, false);
+  const omega = view.getFloat64(base + 152, false) * GPS_PI2;
+  const omegaDot = view.getFloat64(base + 160, false) * GPS_PI2;
+  const idot = view.getFloat64(base + 168, false) * GPS_PI2;
+  const flags = view.getUint32(base + 176, false);
+  return {
+    system: "G",
+    prn: `G${String(prn).padStart(2, "0")}`,
+    toc: sowOf4(gpsMs3(week, toc)),
+    tocDate: new Date(gpsMs3(week, toc)),
+    af0,
+    af1,
+    af2,
+    iode,
+    crs,
+    deltaN,
+    m0,
+    cuc,
+    e,
+    cus,
+    sqrtA,
+    toe,
+    cic,
+    omega0,
+    cis,
+    i0,
+    crc,
+    omega,
+    omegaDot,
+    idot,
+    week,
+    svHealth: flags >>> 4 & 127,
+    tgd
+  };
+}
+function parseTrimbleNav(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const stats = { badChecksum: 0 };
+  const ephemerides = [];
+  const ionoCorrections = {};
+  const retsvCounts = {};
+  let leapSeconds = null;
+  const lastIode = /* @__PURE__ */ new Map();
+  for (const f of trimbleFrames(data, stats)) {
+    if (f.type !== RETSVDATA) continue;
+    const sub = data[f.payload];
+    retsvCounts[sub] = (retsvCounts[sub] ?? 0) + 1;
+    if (sub === SUB_GPS_EPHEMERIS && f.len >= 178) {
+      const eph = decodeGpsEphemeris2(data, view, f.start);
+      if (!eph) continue;
+      if (lastIode.get(eph.prn) === eph.iode) continue;
+      lastIode.set(eph.prn, eph.iode);
+      ephemerides.push(eph);
+    } else if (sub === SUB_ION_UTC && f.len >= 125) {
+      const p = f.start;
+      const alpha = [];
+      const beta = [];
+      for (let i = 0; i < 4; i++) {
+        alpha.push(view.getFloat64(p + 6 + i * 8, false));
+        beta.push(view.getFloat64(p + 38 + i * 8, false));
+      }
+      ionoCorrections["GPSA"] = alpha;
+      ionoCorrections["GPSB"] = beta;
+      leapSeconds = Math.trunc(view.getFloat64(p + 94, false));
+    }
+  }
+  return {
+    ephemerides,
+    ionoCorrections,
+    leapSeconds,
+    retsvCounts,
+    badChecksum: stats.badChecksum
+  };
+}
+
+// src/trimble/index.ts
+var GPS_EPOCH_MS14 = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK10 = 7 * 864e5;
+var REC_TYPE_27 = 6;
+var SYS = {
+  0: "G",
+  // GPS
+  1: "S",
+  // SBAS
+  2: "R",
+  // GLONASS
+  3: "E",
+  // Galileo
+  4: "J",
+  // QZSS
+  5: "C",
+  // BeiDou (pre-ICD numbering)
+  7: "C",
+  // BeiDou (ICD numbering)
+  9: "I",
+  // NavIC / IRNSS
+  10: "C"
+  // BeiDou
+};
+var CODES = {
+  "G0-0": "1C",
+  "G0-20": "1L",
+  "G1-2": "2W",
+  "G1-5": "2L",
+  "G2-6": "5I",
+  "G2-7": "5Q",
+  "G2-8": "5X",
+  "R0-0": "1C",
+  "R0-1": "1P",
+  "R1-0": "2C",
+  "R1-1": "2P",
+  "E0-23": "1C",
+  "E2-11": "5Q",
+  "E3-11": "7Q",
+  "E4-14": "8Q",
+  "E5-36": "6C",
+  "C0-20": "1P",
+  "C2-8": "5P",
+  "C3-6": "7D",
+  "C6-26": "2I",
+  "C7-29": "6I",
+  "S0-0": "1C",
+  "S2-6": "5I",
+  "J0-0": "1C"
+};
+var BAND_DIGIT = {
+  0: "1",
+  // L1 / E1 / B1C (1575.42)
+  1: "2",
+  // L2 / G2 (1227.6)
+  2: "5",
+  // L5 / E5a (1176.45)
+  3: "7",
+  // E5b / B2b (1207.14)
+  4: "8",
+  // E5 AltBOC (1191.795)
+  5: "6",
+  // E6 (1278.75)
+  6: "2",
+  // B1I (1561.098)
+  7: "6",
+  // B3I (1268.52)
+  8: "1",
+  // BeiDou E1 (1589.742)
+  9: "3",
+  // GLONASS G3 CDMA (1202.025)
+  11: "9"
+  // NavIC S-band (2492.028)
+};
+function rinexCode(sys, band, track) {
+  const key = `${sys}${band}-${track}`;
+  return CODES[key] ?? `${BAND_DIGIT[band] ?? "?"}X`;
+}
+function rinexPrn(sys, svid) {
+  let n = svid;
+  if (sys === "S")
+    n = svid - 100;
+  else if (sys === "J" && svid >= 193) n = svid - 192;
+  return `${sys}${String(n).padStart(2, "0")}`;
+}
+var readS16 = (dv, o) => dv.getInt16(o, false);
+function readS24(d, o) {
+  const v = d[o] << 16 | d[o + 1] << 8 | d[o + 2];
+  return v & 8388608 ? v - 16777216 : v;
+}
+function readS48(d, dv, o) {
+  const hi = d[o] << 8 | d[o + 1];
+  const lo = dv.getUint32(o + 2, false);
+  const v = hi * 4294967296 + lo;
+  return hi & 32768 ? v - 281474976710656 : v;
+}
+function parseTrimble(data) {
+  const stats = { badChecksum: 0 };
+  const epochs = [];
+  const obsCodes = {};
+  const recordCounts = {};
+  const retsvCounts = {};
+  let pages = [];
+  let msgReply = -1;
+  let lastPage = 0;
+  let msgPages = 0;
+  let epoch = null;
+  const finalize = () => {
+    if (epoch) decodeEpoch(epoch, epochs, obsCodes);
+    epoch = null;
+  };
+  const onMessage = (content, reply) => {
+    if (epoch && reply === epoch.reply) {
+      epoch.chunks.push(content);
+      return;
+    }
+    finalize();
+    if (content.length < 12) return;
+    const dv = new DataView(
+      content.buffer,
+      content.byteOffset,
+      content.byteLength
+    );
+    const headerLen = content[0];
+    const week = dv.getUint16(1, false);
+    const towMs = dv.getUint32(3, false);
+    const nsv = content[10];
+    const eflags = content[11];
+    if (week < 1024 || week > 4096 || headerLen < 12 || nsv === 0) return;
+    let svStart = headerLen;
+    if (eflags & 32 && svStart < content.length) svStart += content[svStart];
+    epoch = {
+      reply,
+      week,
+      towMs,
+      nsv,
+      chunks: [content.subarray(svStart)]
+    };
+  };
+  const completeMessage = () => {
+    const total = pages.reduce((a, c) => a + c.length, 0);
+    const content = new Uint8Array(total);
+    let o = 0;
+    for (const c of pages) {
+      content.set(c, o);
+      o += c.length;
+    }
+    const reply = msgReply;
+    pages = [];
+    onMessage(content, reply);
+  };
+  for (const f of trimbleFrames(data, stats)) {
+    if (f.type !== RAWDATA) {
+      if (f.type === 85) {
+        const sub = data[f.payload];
+        retsvCounts[sub] = (retsvCounts[sub] ?? 0) + 1;
+      }
+      continue;
+    }
+    const recType = data[f.payload];
+    recordCounts[recType] = (recordCounts[recType] ?? 0) + 1;
+    if (recType !== REC_TYPE_27) continue;
+    const pageByte = data[f.payload + 1];
+    const page = pageByte >> 4;
+    const pagesTotal = pageByte & 15;
+    const reply = data[f.payload + 2];
+    const content = data.subarray(f.payload + 4, f.payload + f.len);
+    if (page === 1) {
+      pages = [content];
+      msgReply = reply;
+      msgPages = pagesTotal;
+      lastPage = 1;
+    } else if (reply === msgReply && page === lastPage + 1) {
+      pages.push(content);
+      lastPage = page;
+    } else {
+      pages = [];
+      continue;
+    }
+    if (lastPage === msgPages) completeMessage();
+  }
+  finalize();
+  return {
+    epochs,
+    obsCodes,
+    recordCounts,
+    retsvCounts,
+    badChecksum: stats.badChecksum
+  };
+}
+function decodeEpoch(epoch, epochs, obsCodes) {
+  const total = epoch.chunks.reduce((a, c) => a + c.length, 0);
+  const M = new Uint8Array(total);
+  let o = 0;
+  for (const c of epoch.chunks) {
+    M.set(c, o);
+    o += c.length;
+  }
+  const dv = new DataView(M.buffer, M.byteOffset, M.byteLength);
+  const timeMs = GPS_EPOCH_MS14 + epoch.week * MS_PER_WEEK10 + epoch.towMs;
+  const meas = [];
+  let q = 0;
+  for (let sv = 0; sv < epoch.nsv && q + 8 <= M.length; sv++) {
+    const svLen = M[q];
+    if (svLen < 8 || q + svLen > M.length) break;
+    const svid = M[q + 1];
+    const sys = SYS[M[q + 2] & 63];
+    const chan = M[q + 3] << 24 >> 24;
+    const nblk = M[q + 4];
+    const prn = sys ? rinexPrn(sys, svid) : null;
+    const gloChannel = sys === "R" ? chan : null;
+    let r = q + svLen;
+    let pr0 = 0;
+    for (let b = 0; b < nblk; b++) {
+      if (r + 5 > M.length) break;
+      const mLen = M[r];
+      if (mLen < 5 || r + mLen > M.length) break;
+      const band = M[r + 1];
+      const track = M[r + 2];
+      const cn0 = dv.getUint16(r + 3, false) / 10;
+      let p = r + 5;
+      let pr;
+      if (b === 0) {
+        const scale = sys === "S" || sys === "J" ? 64 : 128;
+        pr = dv.getUint32(p, false) / scale;
+        p += 4;
+        pr0 = pr;
+      } else {
+        pr = pr0 + readS16(dv, p) / 256;
+        p += 2;
+      }
+      const cp = -readS48(M, dv, p) / 32768;
+      p += 6;
+      const cycleSlipCount = M[p];
+      p += 1;
+      const mf = M[p];
+      p += 1;
+      let mf2 = 0;
+      if (mf & 128) {
+        mf2 = M[p];
+        p += 1;
+        let f = mf2;
+        while (f & 128) {
+          f = M[p];
+          p += 1;
+        }
+      }
+      if (mf2 & 1) p += 1;
+      let doppler = null;
+      if (mf & 4) doppler = readS24(M, p) / 256;
+      if (prn && sys) {
+        const code = rinexCode(sys, band, track);
+        meas.push({
+          prn,
+          code,
+          pr: mf & 2 ? pr : null,
+          cp: mf & 1 ? cp : null,
+          doppler: mf & 1 ? doppler : null,
+          cn0,
+          cycleSlipCount,
+          cycleSlip: (mf & 8) !== 0,
+          gloChannel
+        });
+        const list = obsCodes[sys] ??= [];
+        if (!list.includes(code)) list.push(code);
+      }
+      r += mLen;
+    }
+    q = r;
+  }
+  epochs.push({ timeMs, meas });
+}
+
+// src/binex/frame.ts
+var CRC16_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 binexCrc16(data, start, end) {
+  let crc = 0;
+  for (let i = start; i < end; i++)
+    crc = (crc << 8 ^ CRC16_TABLE[(crc >> 8 ^ data[i]) & 255]) & 65535;
+  return crc;
+}
+var CRC32_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n << 24;
+    for (let k = 0; k < 8; k++)
+      c = c & 2147483648 ? c << 1 ^ 79764919 : c << 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function binexCrc32(data, start, end) {
+  let crc = 0;
+  for (let i = start; i < end; i++)
+    crc = (crc << 8 ^ CRC32_TABLE[(crc >>> 24 ^ data[i]) & 255]) >>> 0;
+  return crc >>> 0;
+}
+function binexCsum8(data, start, end) {
+  let cs = 0;
+  for (let i = start; i < end; i++) cs ^= data[i];
+  return cs & 255;
+}
+function getBnxi(data, pos) {
+  let value = 0;
+  for (let i = 0; i < 3; i++) {
+    const b = data[pos + i] ?? 0;
+    value = value * 128 + (b & 127);
+    if (!(b & 128)) return { value, size: i + 1 };
+  }
+  value = value * 256 + (data[pos + 3] ?? 0);
+  return { value, size: 4 };
+}
+var SYNC = /* @__PURE__ */ new Map([
+  [226, { littleEndian: false, enhanced: false }],
+  [194, { littleEndian: true, enhanced: false }],
+  [232, { littleEndian: false, enhanced: true }],
+  [200, { littleEndian: true, enhanced: true }]
+]);
+function csumWidth(covered, enhanced) {
+  if (enhanced) {
+    if (covered < 128) return 2;
+    if (covered < 1048576) return 4;
+    return 16;
+  }
+  if (covered < 128) return 1;
+  if (covered < 4096) return 2;
+  if (covered < 1048576) return 4;
+  return 16;
+}
+function checksumOk(data, view, covStart, covEnd, width) {
+  switch (width) {
+    case 1:
+      return binexCsum8(data, covStart, covEnd) === (data[covEnd] ?? -1);
+    case 2:
+      return binexCrc16(data, covStart, covEnd) === view.getUint16(covEnd);
+    case 4:
+      return binexCrc32(data, covStart, covEnd) === view.getUint32(covEnd);
+    default:
+      return false;
+  }
+}
+function* binexRecords(data, view, stats) {
+  let i = 0;
+  while (i + 2 <= data.length) {
+    const sync = SYNC.get(data[i]);
+    if (!sync) {
+      i++;
+      continue;
+    }
+    const id = data[i + 1];
+    const { value: len, size: lenH } = getBnxi(data, i + 2);
+    const body = i + 2 + lenH;
+    const covStart = i + 1;
+    const covEnd = body + len;
+    const covered = covEnd - covStart;
+    const width = csumWidth(covered, sync.enhanced);
+    if (width === 16 || covEnd + width > data.length) {
+      i++;
+      continue;
+    }
+    if (!checksumOk(data, view, covStart, covEnd, width)) {
+      stats.badCrc++;
+      i++;
+      continue;
+    }
+    yield { id, start: i, body, len, ...sync };
+    i = covEnd + width;
+  }
+}
+
+// src/binex/nav.ts
+var GPS_EPOCH_MS15 = Date.UTC(1980, 0, 6);
+var GLO_DAY0_MS = Date.UTC(1980, 0, 1);
+var BDT_EPOCH_MS4 = Date.UTC(2006, 0, 1);
+var SEC_PER_WEEK11 = 7 * 86400;
+var MS_PER_WEEK11 = SEC_PER_WEEK11 * 1e3;
+var SC2RAD = GPS_PI;
+var gpsMs4 = (week, sec) => GPS_EPOCH_MS15 + week * MS_PER_WEEK11 + sec * 1e3;
+var sowOf5 = (dateMs) => (dateMs / 1e3 % SEC_PER_WEEK11 + SEC_PER_WEEK11) % SEC_PER_WEEK11;
+var two5 = (n) => String(n).padStart(2, "0");
+var Reader = class {
+  constructor(view, start, le) {
+    this.view = view;
+    this.le = le;
+    this.p = start;
+  }
+  p;
+  u1() {
+    return this.view.getUint8(this.p++);
+  }
+  i1() {
+    return this.view.getInt8(this.p++);
+  }
+  u2() {
+    const v = this.view.getUint16(this.p, this.le);
+    this.p += 2;
+    return v;
+  }
+  i4() {
+    const v = this.view.getInt32(this.p, this.le);
+    this.p += 4;
+    return v;
+  }
+  u4() {
+    const v = this.view.getUint32(this.p, this.le);
+    this.p += 4;
+    return v;
+  }
+  r4() {
+    const v = this.view.getFloat32(this.p, this.le);
+    this.p += 4;
+    return v;
+  }
+  r8() {
+    const v = this.view.getFloat64(this.p, this.le);
+    this.p += 8;
+    return v;
+  }
+};
+function readKeplerCore(r) {
+  const deltaN = r.r4() * SC2RAD;
+  const m0 = r.r8();
+  const e = r.r8();
+  const sqrtA = r.r8();
+  const cic = r.r4();
+  const crc = r.r4();
+  const cis = r.r4();
+  const crs = r.r4();
+  const cuc = r.r4();
+  const cus = r.r4();
+  const omega0 = r.r8();
+  const omega = r.r8();
+  const i0 = r.r8();
+  const omegaDot = r.r4() * SC2RAD;
+  const idot = r.r4() * SC2RAD;
+  return {
+    deltaN,
+    m0,
+    e,
+    sqrtA,
+    cic,
+    crc,
+    cis,
+    crs,
+    cuc,
+    cus,
+    omega0,
+    omega,
+    i0,
+    omegaDot,
+    idot
+  };
+}
+function decodeGpsQzss(view, p, le, sys) {
+  const r = new Reader(view, p, le);
+  const prnRaw = r.u1() + (sys === "G" ? 1 : 0);
+  const prn = sys === "G" ? prnRaw : prnRaw - 192;
+  if (sys === "G" && (prn < 1 || prn > 32)) return null;
+  if (sys === "J" && (prn < 1 || prn > 10)) return null;
+  const week = r.u2();
+  r.i4();
+  const toes = r.i4();
+  const tgd = r.r4();
+  r.i4();
+  const af2 = r.r4();
+  const af1 = r.r4();
+  const af0 = r.r4();
+  const iode = r.i4();
+  const core = readKeplerCore(r);
+  r.r4();
+  const svHealth = r.u2();
+  const tocDate = new Date(gpsMs4(week, toes));
+  return {
+    system: sys,
+    prn: `${sys}${two5(prn)}`,
+    toc: sowOf5(tocDate.getTime()),
+    tocDate,
+    af0,
+    af1,
+    af2,
+    iode,
+    ...core,
+    toe: toes,
+    week,
+    svHealth,
+    tgd
+  };
+}
+function decodeGalileo(view, p, le) {
+  const r = new Reader(view, p, le);
+  const prn = r.u1() + 1;
+  if (prn < 1 || prn > 36) return null;
+  const week = r.u2();
+  r.i4();
+  const toes = r.i4();
+  const tgd = r.r4();
+  r.r4();
+  const iode = r.i4();
+  const af2 = r.r4();
+  const af1 = r.r4();
+  const af0 = r.r4();
+  const core = readKeplerCore(r);
+  r.r4();
+  const svHealth = r.u2();
+  const tocDate = new Date(gpsMs4(week, toes));
+  return {
+    system: "E",
+    prn: `E${two5(prn)}`,
+    toc: sowOf5(tocDate.getTime()),
+    tocDate,
+    af0,
+    af1,
+    af2,
+    iode,
+    ...core,
+    toe: toes,
+    week,
+    svHealth,
+    tgd
+  };
+}
+function bdsTgd(tgd) {
+  tgd &= 1023;
+  return tgd & 512 ? -1e-10 * (~tgd & 511) : 1e-10 * (tgd & 511);
+}
+function decodeBeidou(view, p, le) {
+  const r = new Reader(view, p, le);
+  const prn = r.u1();
+  if (prn < 1 || prn > 63) return null;
+  const week = r.u2();
+  r.i4();
+  r.i4();
+  const toes = r.i4();
+  const af2 = r.r4();
+  const af1 = r.r4();
+  const af0 = r.r4();
+  const core = readKeplerCore(r);
+  const flag1 = r.u2();
+  const flag2 = r.u4();
+  const iode = flag1 >> 6 & 31;
+  const svHealth = flag1 & 1;
+  const tgd = bdsTgd(flag2 >> 4);
+  const tocDate = new Date(BDT_EPOCH_MS4 + week * MS_PER_WEEK11 + toes * 1e3);
+  return {
+    system: "C",
+    prn: `C${two5(prn)}`,
+    toc: sowOf5(tocDate.getTime()),
+    tocDate,
+    af0,
+    af1,
+    af2,
+    iode,
+    ...core,
+    toe: toes,
+    week,
+    // RINEX BDS week field is the BDT week
+    svHealth,
+    tgd
+  };
+}
+function decodeGlonass(view, p, le) {
+  const r = new Reader(view, p, le);
+  const slot = r.u1() + 1;
+  if (slot < 1 || slot > 27) return null;
+  const day = r.u2();
+  const tod = r.u4();
+  const tauN = r.r8();
+  const gammaN = r.r8();
+  const tof = r.u4();
+  const x = r.r8();
+  const xDot = r.r8();
+  const xAcc = r.r8();
+  const y = r.r8();
+  const yDot = r.r8();
+  const yAcc = r.r8();
+  const z = r.r8();
+  const zDot = r.r8();
+  const zAcc = r.r8();
+  const health = r.u1() & 1;
+  const freqNum = r.i1();
+  const tocDate = new Date(
+    GLO_DAY0_MS + (day - 1) * 864e5 + (tod - 10800) * 1e3
+  );
+  return {
+    system: "R",
+    prn: `R${two5(slot)}`,
+    tocDate,
+    tauN,
+    gammaN,
+    messageFrameTime: tof,
+    x,
+    y,
+    z,
+    xDot,
+    yDot,
+    zDot,
+    xAcc,
+    yAcc,
+    zAcc,
+    health,
+    freqNum
+  };
+}
+function decodeSbas(view, p, le) {
+  const r = new Reader(view, p, le);
+  const prn = r.u1();
+  const week = r.u2();
+  const tow = r.u4();
+  const af0 = r.r8();
+  const af1 = r.r4();
+  const toe = r.u4();
+  const x = r.r8();
+  const xDot = r.r8();
+  const xAcc = r.r8();
+  const y = r.r8();
+  const yDot = r.r8();
+  const yAcc = r.r8();
+  const z = r.r8();
+  const zDot = r.r8();
+  const zAcc = r.r8();
+  const health = r.u1();
+  if (prn < 120 || prn > 158) return null;
+  return {
+    system: "S",
+    prn: `S${two5(prn - 100)}`,
+    tocDate: new Date(gpsMs4(week, toe)),
+    tauN: af0,
+    gammaN: af1,
+    messageFrameTime: tow,
+    x,
+    y,
+    z,
+    xDot,
+    yDot,
+    zDot,
+    xAcc,
+    yAcc,
+    zAcc,
+    health,
+    freqNum: 0
+  };
+}
+function decodeBinexEph(view, body, len, le) {
+  const sub = view.getUint8(body);
+  const p = body + 1;
+  const n = len - 1;
+  switch (sub) {
+    case 1:
+      return n >= 127 ? decodeGpsQzss(view, p, le, "G") : null;
+    case 2:
+      return n >= 119 ? decodeGlonass(view, p, le) : null;
+    case 3:
+      return n >= 98 ? decodeSbas(view, p, le) : null;
+    case 4:
+      return n >= 127 ? decodeGalileo(view, p, le) : null;
+    case 5:
+      return n >= 117 ? decodeBeidou(view, p, le) : null;
+    case 6:
+      return n >= 127 ? decodeGpsQzss(view, p, le, "J") : null;
+    default:
+      return null;
+  }
+}
+
+// src/binex/index.ts
+var GPS_EPOCH_MS16 = Date.UTC(1980, 0, 6);
+var CLIGHT2 = 299792458;
+var OBS_CODES = {
+  0: [
+    "1C",
+    "1C",
+    "1P",
+    "1W",
+    "1Y",
+    "1M",
+    "1X",
+    "1N",
+    "",
+    "",
+    "2W",
+    "2C",
+    "2D",
+    "2S",
+    "2L",
+    "2X",
+    "2P",
+    "2W",
+    "2Y",
+    "2M",
+    "2N",
+    "",
+    "",
+    "5X",
+    "5I",
+    "5Q",
+    "5X"
+  ],
+  // GPS
+  1: [
+    "1C",
+    "1C",
+    "1P",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "2C",
+    "2C",
+    "2P",
+    "3X",
+    "3I",
+    "3Q",
+    "3X"
+  ],
+  // GLONASS
+  3: [
+    "1C",
+    "1A",
+    "1B",
+    "1C",
+    "1X",
+    "1Z",
+    "5X",
+    "5I",
+    "5Q",
+    "5X",
+    "7X",
+    "7I",
+    "7Q",
+    "7X",
+    "8X",
+    "8I",
+    "8Q",
+    "8X",
+    "6X",
+    "6A",
+    "6B",
+    "6C",
+    "6X",
+    "6Z"
+  ],
+  // Galileo
+  2: ["1C", "1C", "", "", "", "", "5X", "5I", "5Q", "5X"],
+  // SBAS
+  4: [
+    "2X",
+    "2I",
+    "2Q",
+    "2X",
+    "7X",
+    "7I",
+    "7Q",
+    "7X",
+    "6X",
+    "6I",
+    "6Q",
+    "6X",
+    "1X",
+    "1S",
+    "1L",
+    "1X"
+  ],
+  // BeiDou
+  5: [
+    "1C",
+    "1C",
+    "1S",
+    "1L",
+    "1X",
+    "",
+    "",
+    "2X",
+    "2S",
+    "2L",
+    "2X",
+    "",
+    "",
+    "5X",
+    "5I",
+    "5Q",
+    "5X",
+    "",
+    "",
+    "6X",
+    "6S",
+    "6L",
+    "6X",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "1Z"
+  ]
+  // QZSS
+};
+var two6 = (n) => String(n).padStart(2, "0");
+function obsPrn(sys, prn) {
+  switch (sys) {
+    case 0:
+      return prn >= 1 && prn <= 32 ? `G${two6(prn)}` : null;
+    case 1:
+      return prn >= 1 && prn <= 27 ? `R${two6(prn)}` : null;
+    case 2:
+      return prn >= 120 && prn <= 158 ? `S${two6(prn - 100)}` : null;
+    case 3:
+      return prn >= 1 && prn <= 36 ? `E${two6(prn)}` : null;
+    case 4:
+      return prn >= 1 && prn <= 63 ? `C${two6(prn)}` : null;
+    case 5:
+      if (prn >= 193 && prn <= 202) return `J${two6(prn - 192)}`;
+      return prn >= 1 && prn <= 10 ? `J${two6(prn)}` : null;
+    default:
+      return null;
+  }
+}
+function carrierFreq3(sys, code, fcn) {
+  const band = code.charCodeAt(0) - 48;
+  switch (sys) {
+    case "G":
+    case "J":
+      if (band === 1) return 157542e4;
+      if (band === 2) return 12276e5;
+      if (band === 5) return 117645e4;
+      if (band === 6) return 127875e4;
+      return 0;
+    case "R":
+      if (band === 1) return fcn >= -7 ? 1602e6 + fcn * 562500 : 0;
+      if (band === 2) return fcn >= -7 ? 1246e6 + fcn * 437500 : 0;
+      if (band === 3) return 1202025e3;
+      return 0;
+    case "E":
+      if (band === 1) return 157542e4;
+      if (band === 5) return 117645e4;
+      if (band === 6) return 127875e4;
+      if (band === 7) return 120714e4;
+      if (band === 8) return 1191795e3;
+      return 0;
+    case "C":
+      if (band === 1) return 157542e4;
+      if (band === 2) return 1561098e3;
+      if (band === 5) return 117645e4;
+      if (band === 6) return 126852e4;
+      if (band === 7) return 120714e4;
+      if (band === 8) return 1191795e3;
+      return 0;
+    case "S":
+      if (band === 1) return 157542e4;
+      if (band === 5) return 117645e4;
+      return 0;
+    default:
+      return 0;
+  }
+}
+var FCN_UNKNOWN = -100;
+function decodeObsSat(data, start, nobs, sys) {
+  let p = start;
+  let fcn = FCN_UNKNOWN;
+  const obs = [];
+  const block0Flags = [0, 0, 0, 0];
+  let refRange = 0;
+  for (let b = 0; b < nobs; b++) {
+    const flags = b === 0 ? block0Flags : block0Flags.slice();
+    const b0 = data[p++];
+    const code = b0 & 31;
+    const slip = (b0 >> 5 & 1) === 1;
+    let more = b0 >> 7 & 1;
+    while (more) {
+      const fb = data[p++];
+      flags[fb & 3] = fb & 127;
+      more = fb & 128;
+    }
+    if (sys === 1 && flags[2] > 0 && (code === 1 || code === 2 || code === 11 || code === 12)) {
+      fcn = getBitS(Uint8Array.of(flags[2]), 2, 4);
+    }
+    const acc = flags[0] & 32 ? 1e-4 : 2e-5;
+    let cn0 = data[p++] * 0.4;
+    let range;
+    if (b === 0) {
+      cn0 += getBitS(data, p * 8, 2) * 0.1;
+      range = getBitU(data, p * 8 + 2, 38) * 1e-3;
+      p += 5;
+      refRange = range;
+    } else if (flags[0] & 64) {
+      cn0 += getBitS(data, p * 8, 2) * 0.1;
+      range = refRange + getBitS(data, p * 8 + 4, 20) * 1e-3;
+      p += 3;
+    } else {
+      range = refRange + getBitS(data, p * 8, 16) * 1e-3;
+      p += 2;
+    }
+    let phase;
+    if (flags[0] & 64) {
+      phase = range + getBitS(data, p * 8, 24) * acc;
+      p += 3;
+    } else {
+      cn0 += getBitS(data, p * 8, 2) * 0.1;
+      phase = range + getBitS(data, p * 8 + 2, 22) * acc;
+      p += 3;
+    }
+    let doppler = null;
+    if (flags[0] & 4) {
+      doppler = getBitS(data, p * 8, 24) / 256;
+      p += 3;
+    }
+    if (flags[0] & 8) {
+      p += flags[0] & 16 ? 2 : 1;
+    }
+    obs.push({ code, slip, pr: range, phase, cn0, doppler });
+  }
+  return { obs, fcn, next: p };
+}
+function decodeObsRecord(data, view, body, len, obsCodes) {
+  let p = body + 1;
+  const min = view.getUint32(p);
+  p += 4;
+  const msec = view.getUint16(p);
+  p += 2;
+  const timeMs = GPS_EPOCH_MS16 + min * 6e4 + msec;
+  const flag = data[p++];
+  const nsat = (flag & 63) + 1;
+  if (flag & 128) p += 3;
+  if (flag & 64) {
+    const nsys = getBitU(data, p * 8, 4);
+    p += 1;
+    p += nsys * 4;
+  }
+  const end = body + len;
+  const meas = [];
+  for (let i = 0; i < nsat && p < end; i++) {
+    const prn = data[p++];
+    const b = data[p++];
+    const nobs = b >> 4 & 7;
+    const sys = b & 15;
+    const sat = obsPrn(sys, prn);
+    const { obs, fcn, next } = decodeObsSat(data, p, nobs, sys);
+    p = next;
+    if (p > end) return null;
+    if (!sat) continue;
+    const table = OBS_CODES[sys];
+    const sysL = sat[0];
+    for (const o of obs) {
+      const code = table?.[o.code & 63] ?? "";
+      if (!code) continue;
+      const freq = carrierFreq3(sysL, code, fcn);
+      meas.push({
+        prn: sat,
+        code,
+        pr: o.pr,
+        cp: freq > 0 ? o.phase * freq / CLIGHT2 : null,
+        doppler: o.doppler,
+        cn0: o.cn0,
+        slip: o.slip
+      });
+      const codes = obsCodes[sysL] ??= [];
+      if (!codes.includes(code)) codes.push(code);
+    }
+  }
+  return { timeMs, meas };
+}
+function parseBinex(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const epochs = [];
+  const ephemerides = [];
+  const messageCounts = {};
+  const obsCodes = {};
+  const stats = { badCrc: 0 };
+  const lastKep = /* @__PURE__ */ new Map();
+  const lastState = /* @__PURE__ */ new Map();
+  const hex = (n) => `0x${n.toString(16).padStart(2, "0")}`;
+  for (const rec of binexRecords(data, view, stats)) {
+    const sub = rec.len > 0 ? data[rec.body] : 0;
+    const key = rec.id === 1 || rec.id === 127 ? `${hex(rec.id)}-${sub.toString(16).padStart(2, "0")}` : hex(rec.id);
+    messageCounts[key] = (messageCounts[key] ?? 0) + 1;
+    if (rec.id === 127 && sub === 5 && rec.len >= 8 && !rec.littleEndian) {
+      const epoch = decodeObsRecord(data, view, rec.body, rec.len, obsCodes);
+      if (epoch) epochs.push(epoch);
+    } else if (rec.id === 1 && rec.len >= 2) {
+      const eph = decodeBinexEph(view, rec.body, rec.len, rec.littleEndian);
+      if (!eph) continue;
+      if ("iode" in eph) {
+        const prev = lastKep.get(eph.prn);
+        if (prev && prev.iode === eph.iode && prev.toe === eph.toe && prev.tocDate.getTime() === eph.tocDate.getTime()) {
+          continue;
+        }
+        lastKep.set(eph.prn, eph);
+        ephemerides.push(eph);
+      } else {
+        const prev = lastState.get(eph.prn);
+        if (prev && Math.abs(prev.tocDate.getTime() - eph.tocDate.getTime()) < 1e3 && prev.health === eph.health) {
+          continue;
+        }
+        lastState.set(eph.prn, eph);
+        ephemerides.push(eph);
+      }
+    }
+  }
+  return { epochs, ephemerides, messageCounts, obsCodes, badCrc: stats.badCrc };
+}
+
 // src/orbit/almanac.ts
 var GM_GPS = 3986005e8;
 var GM_GAL = 3986004418e5;
 var GM_BDS = 3986004418e5;
-var GPS_EPOCH_MS13 = Date.UTC(1980, 0, 6);
-var BDT_EPOCH_MS4 = Date.UTC(2006, 0, 1);
+var GPS_EPOCH_MS17 = Date.UTC(1980, 0, 6);
+var BDT_EPOCH_MS5 = Date.UTC(2006, 0, 1);
 var WEEK_MS = 6048e5;
 var BDT_MINUS_GPST_MS = 14e3;
 var BDS_GEO_PRNS = /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 59, 60, 61, 62, 63]);
 function almanacEpochMs(alm) {
   if (alm.system === "C") {
-    return BDT_EPOCH_MS4 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3 + BDT_MINUS_GPST_MS;
+    return BDT_EPOCH_MS5 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3 + BDT_MINUS_GPST_MS;
   }
-  return GPS_EPOCH_MS13 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3;
+  return GPS_EPOCH_MS17 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3;
 }
 function almanacSatPosition(alm, timeMs) {
   const GM = alm.system === "E" ? GM_GAL : alm.system === "C" ? GM_BDS : GM_GPS;
@@ -9202,10 +10372,10 @@ function selectBest(ephs, timeMs) {
   }
   return best;
 }
-var GPS_EPOCH_MS14 = START_GPS_TIME.getTime();
-var MS_PER_WEEK9 = 7 * 864e5;
+var GPS_EPOCH_MS18 = START_GPS_TIME.getTime();
+var MS_PER_WEEK12 = 7 * 864e5;
 var BDS_EPOCH_MS = START_BDS_TIME.getTime();
-var GAL_EPOCH_MS = GPS_EPOCH_MS14 + 1024 * MS_PER_WEEK9;
+var GAL_EPOCH_MS = GPS_EPOCH_MS18 + 1024 * MS_PER_WEEK12;
 function ephInfoToEphemeris(info) {
   const sys = info.prn.charAt(0);
   if (sys === "R") {
@@ -9256,11 +10426,11 @@ function ephInfoToEphemeris(info) {
   } else if (sys === "E") {
     epochMs = GAL_EPOCH_MS;
   } else {
-    epochMs = GPS_EPOCH_MS14;
-    const weeksNow = (info.lastReceived - GPS_EPOCH_MS14) / MS_PER_WEEK9;
+    epochMs = GPS_EPOCH_MS18;
+    const weeksNow = (info.lastReceived - GPS_EPOCH_MS18) / MS_PER_WEEK12;
     week += 1024 * Math.round((weeksNow - week) / 1024);
   }
-  const tocDate = new Date(epochMs + week * MS_PER_WEEK9 + tocSec * 1e3);
+  const tocDate = new Date(epochMs + week * MS_PER_WEEK12 + tocSec * 1e3);
   return {
     system: sys,
     prn: info.prn,
@@ -13314,6 +14484,10 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   analyzeQuality,
   applyHelmert,
   applyIonoDcb,
+  binexCrc16,
+  binexCrc32,
+  binexCsum8,
+  binexRecords,
   buildGloChannelMap,
   buildObsIndices,
   clampUnit,
@@ -13334,6 +14508,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   crxDecompress,
   crxRepair,
   dateToEpoch,
+  decodeBinexEph,
   decodeEphemeris,
   decodeMsmFull,
   deg2dms,
@@ -13355,6 +14530,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   geodeticToUtm,
   getAer,
   getBdsTime,
+  getBnxi,
   getDateFromBdsTime,
   getDateFromDayOfWeek,
   getDateFromDayOfYear,
@@ -13428,6 +14604,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   padL,
   padR,
   parseAntex,
+  parseBinex,
   parseCrxDataLine,
   parseIonex,
   parseNavFile,
@@ -13447,6 +14624,8 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   parseSinexBiasDcb,
   parseSourcetable,
   parseSp3,
+  parseTrimble,
+  parseTrimbleNav,
   parseUbxCnav,
   parseUbxIonoUtc,
   parseUbxNav,
@@ -13477,6 +14656,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   systemName,
   toRtkEpoch,
   transformFrame,
+  trimbleFrames,
   ubxFrames,
   updateStationMeta,
   updateStreamStats,