gnss-js 1.20.0 → 1.22.0

package/dist/ubx.cjs

@@ -23,6 +23,7 @@ __export(ubx_exports, {
   parseUbxCnav: () => parseUbxCnav,
   parseUbxIonoUtc: () => parseUbxIonoUtc,
   parseUbxNav: () => parseUbxNav,
+  parseUbxRawNav: () => parseUbxRawNav,
   parseUbxRawx: () => parseUbxRawx,
   ubxFrames: () => ubxFrames
 });
@@ -538,9 +539,806 @@ function parseUbxCnav(data) {
   return { ephemerides, badCrc, messages };
 }
 
-// src/ubx/index.ts
+// src/navbits/bds.ts
+var BDT_EPOCH_MS = Date.UTC(2006, 0, 1);
+var SEC_PER_WEEK3 = 7 * 86400;
+var MS_PER_WEEK = SEC_PER_WEEK3 * 1e3;
+var HALF_WEEK2 = 302400;
+var sowOf = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK3;
+var BDS_SUBFRAME_BYTES = 38;
+function getBitU2(b, p1, l1, p2, l2) {
+  return getBitU(b, p1, l1) * 2 ** l2 + getBitU(b, p2, l2);
+}
+function getBitS2(b, p1, l1, p2, l2) {
+  return getBitS(b, p1, l1) * 2 ** l2 + getBitU(b, p2, l2);
+}
+function getBitU3(b, p1, l1, p2, l2, p3, l3) {
+  return getBitU(b, p1, l1) * 2 ** (l2 + l3) + getBitU(b, p2, l2) * 2 ** l3 + getBitU(b, p3, l3);
+}
+function getBitS3(b, p1, l1, p2, l2, p3, l3) {
+  return getBitS(b, p1, l1) * 2 ** (l2 + l3) + getBitU(b, p2, l2) * 2 ** l3 + getBitU(b, p3, l3);
+}
+var mergeS = (hi, lo, n) => hi * 2 ** n + lo;
+function bchOk(cw) {
+  for (let i = 14; i >= 4; i--) {
+    if (cw & 1 << i) cw ^= 19 << i - 4;
+  }
+  return cw === 0;
+}
+function bdsSubframeParityOk(subframe) {
+  if (subframe.length < BDS_SUBFRAME_BYTES) return false;
+  if (!bchOk(getBitU(subframe, 15, 15))) return false;
+  for (let w = 1; w < 10; w++) {
+    const base = 30 * w;
+    const cw1 = getBitU(subframe, base, 11) * 16 + getBitU(subframe, base + 22, 4);
+    const cw2 = getBitU(subframe, base + 11, 11) * 16 + getBitU(subframe, base + 26, 4);
+    if (!bchOk(cw1) || !bchOk(cw2)) return false;
+  }
+  return true;
+}
+function buildBdsEphemeris(prn, f) {
+  let week = f.week;
+  if (f.toes < f.sow - HALF_WEEK2) week++;
+  else if (f.toes > f.sow + HALF_WEEK2) week--;
+  const tocDate = new Date(BDT_EPOCH_MS + week * MS_PER_WEEK + f.tocSec * 1e3);
+  return {
+    system: "C",
+    prn,
+    toc: sowOf(tocDate.getTime()),
+    tocDate,
+    af0: f.af0,
+    af1: f.af1,
+    af2: f.af2,
+    // AODE is not in the ephemeris subframes; RTKLIB derives the RINEX
+    // IODE/AODE slot from toc per the BDS ICD update schedule.
+    iode: Math.floor(f.tocSec / 720) % 240,
+    crs: f.crs,
+    deltaN: f.deltaN,
+    m0: f.m0,
+    cuc: f.cuc,
+    e: f.e,
+    cus: f.cus,
+    sqrtA: f.sqrtA,
+    toe: f.toes,
+    cic: f.cic,
+    omega0: f.omega0,
+    cis: f.cis,
+    i0: f.i0,
+    crc: f.crc,
+    omega: f.omega,
+    omegaDot: f.omegaDot,
+    idot: f.idot,
+    week,
+    // RINEX BDS week field is the BDT week of toe
+    svHealth: f.svh,
+    // SatH1
+    tgd: f.tgd1
+    // TGD1 (B1) — RINEX slot
+  };
+}
+function decodeBdsD1Frame(subframes, opts = {}) {
+  if (subframes.length < 3 * BDS_SUBFRAME_BYTES) return null;
+  const b = subframes;
+  let i = 8 * 38 * 0;
+  const frn1 = getBitU(b, i + 15, 3);
+  const sow1 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const svh = getBitU(b, i + 42, 1);
+  const week = getBitU(b, i + 60, 13);
+  const tocSec = getBitU2(b, i + 73, 9, i + 90, 8) * 8;
+  const tgd1 = getBitS(b, i + 98, 10) * 0.1 * 1e-9;
+  const af2 = getBitS(b, i + 214, 11) * 2 ** -66;
+  const af0 = getBitS2(b, i + 225, 7, i + 240, 17) * 2 ** -33;
+  const af1 = getBitS2(b, i + 257, 5, i + 270, 17) * 2 ** -50;
+  i = 8 * 38 * 1;
+  const frn2 = getBitU(b, i + 15, 3);
+  const sow2 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const deltaN = getBitS2(b, i + 42, 10, i + 60, 6) * 2 ** -43 * GPS_PI;
+  const cuc = getBitS2(b, i + 66, 16, i + 90, 2) * 2 ** -31;
+  const m0 = getBitS2(b, i + 92, 20, i + 120, 12) * 2 ** -31 * GPS_PI;
+  const e = getBitU2(b, i + 132, 10, i + 150, 22) * 2 ** -33;
+  const cus = getBitS(b, i + 180, 18) * 2 ** -31;
+  const crc = getBitS2(b, i + 198, 4, i + 210, 14) * 2 ** -6;
+  const crs = getBitS2(b, i + 224, 8, i + 240, 10) * 2 ** -6;
+  const sqrtA = getBitU2(b, i + 250, 12, i + 270, 20) * 2 ** -19;
+  const toe1 = getBitU(b, i + 290, 2);
+  i = 8 * 38 * 2;
+  const frn3 = getBitU(b, i + 15, 3);
+  const sow3 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const toe2 = getBitU2(b, i + 42, 10, i + 60, 5);
+  const i0 = getBitS2(b, i + 65, 17, i + 90, 15) * 2 ** -31 * GPS_PI;
+  const cic = getBitS2(b, i + 105, 7, i + 120, 11) * 2 ** -31;
+  const omegaDot = getBitS2(b, i + 131, 11, i + 150, 13) * 2 ** -43 * GPS_PI;
+  const cis = getBitS2(b, i + 163, 9, i + 180, 9) * 2 ** -31;
+  const idot = getBitS2(b, i + 189, 13, i + 210, 1) * 2 ** -43 * GPS_PI;
+  const omega0 = getBitS2(b, i + 211, 21, i + 240, 11) * 2 ** -31 * GPS_PI;
+  const omega = getBitS2(b, i + 251, 11, i + 270, 21) * 2 ** -31 * GPS_PI;
+  const toes = (toe1 * 2 ** 15 + toe2) * 8;
+  if (frn1 !== 1 || frn2 !== 2 || frn3 !== 3) return null;
+  if (sow2 !== sow1 + 6 || sow3 !== sow2 + 6) return null;
+  if (tocSec !== toes) return null;
+  return buildBdsEphemeris(opts.prn ?? "C00", {
+    week,
+    sow: sow1,
+    toes,
+    tocSec,
+    svh,
+    tgd1,
+    af0,
+    af1,
+    af2,
+    crs,
+    deltaN,
+    m0,
+    cuc,
+    e,
+    cus,
+    sqrtA,
+    cic,
+    omega0,
+    cis,
+    i0,
+    crc,
+    omega,
+    omegaDot,
+    idot
+  });
+}
+function decodeBdsD2Frame(pages, opts = {}) {
+  if (pages.length < 10 * BDS_SUBFRAME_BYTES) return null;
+  const b = pages;
+  let i = 8 * 38 * 0;
+  const pgn1 = getBitU(b, i + 42, 4);
+  const sow1 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const svh = getBitU(b, i + 46, 1);
+  const week = getBitU(b, i + 64, 13);
+  const tocSec = getBitU2(b, i + 77, 5, i + 90, 12) * 8;
+  const tgd1 = getBitS(b, i + 102, 10) * 0.1 * 1e-9;
+  i = 8 * 38 * 2;
+  const pgn3 = getBitU(b, i + 42, 4);
+  const sow3 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const af0 = getBitS2(b, i + 100, 12, i + 120, 12) * 2 ** -33;
+  const af1p3 = getBitS(b, i + 132, 4);
+  i = 8 * 38 * 3;
+  const pgn4 = getBitU(b, i + 42, 4);
+  const sow4 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const af1p4 = getBitU2(b, i + 46, 6, i + 60, 12);
+  const af2 = getBitS2(b, i + 72, 10, i + 90, 1) * 2 ** -66;
+  const deltaN = getBitS(b, i + 96, 16) * 2 ** -43 * GPS_PI;
+  const cucp4 = getBitS(b, i + 120, 14);
+  i = 8 * 38 * 4;
+  const pgn5 = getBitU(b, i + 42, 4);
+  const sow5 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const cucp5 = getBitU(b, i + 46, 4);
+  const m0 = getBitS3(b, i + 50, 2, i + 60, 22, i + 90, 8) * 2 ** -31 * GPS_PI;
+  const cus = getBitS2(b, i + 98, 14, i + 120, 4) * 2 ** -31;
+  const ep5 = getBitS(b, i + 124, 10);
+  i = 8 * 38 * 5;
+  const pgn6 = getBitU(b, i + 42, 4);
+  const sow6 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const ep6 = getBitU2(b, i + 46, 6, i + 60, 16);
+  const sqrtA = getBitU3(b, i + 76, 6, i + 90, 22, i + 120, 4) * 2 ** -19;
+  const cicp6 = getBitS(b, i + 124, 10);
+  i = 8 * 38 * 6;
+  const pgn7 = getBitU(b, i + 42, 4);
+  const sow7 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const cicp7 = getBitU2(b, i + 46, 6, i + 60, 2);
+  const cis = getBitS(b, i + 62, 18) * 2 ** -31;
+  const toes = getBitU2(b, i + 80, 2, i + 90, 15) * 8;
+  const i0p7 = getBitS2(b, i + 105, 7, i + 120, 14);
+  i = 8 * 38 * 7;
+  const pgn8 = getBitU(b, i + 42, 4);
+  const sow8 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const i0p8 = getBitU2(b, i + 46, 6, i + 60, 5);
+  const crc = getBitS2(b, i + 65, 17, i + 90, 1) * 2 ** -6;
+  const crs = getBitS(b, i + 91, 18) * 2 ** -6;
+  const omegaDotP8 = getBitS2(b, i + 109, 3, i + 120, 16);
+  i = 8 * 38 * 8;
+  const pgn9 = getBitU(b, i + 42, 4);
+  const sow9 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const omegaDotP9 = getBitU(b, i + 46, 5);
+  const omega0 = getBitS3(b, i + 51, 1, i + 60, 22, i + 90, 9) * 2 ** -31 * GPS_PI;
+  const omegaP9 = getBitS2(b, i + 99, 13, i + 120, 14);
+  i = 8 * 38 * 9;
+  const pgn10 = getBitU(b, i + 42, 4);
+  const sow10 = getBitU2(b, i + 18, 8, i + 30, 12);
+  const omegaP10 = getBitU(b, i + 46, 5);
+  const idot = getBitS2(b, i + 51, 1, i + 60, 13) * 2 ** -43 * GPS_PI;
+  if (pgn1 !== 1 || pgn3 !== 3 || pgn4 !== 4 || pgn5 !== 5 || pgn6 !== 6 || pgn7 !== 7 || pgn8 !== 8 || pgn9 !== 9 || pgn10 !== 10) {
+    return null;
+  }
+  if (sow3 !== sow1 + 6 || sow4 !== sow3 + 3 || sow5 !== sow4 + 3 || sow6 !== sow5 + 3 || sow7 !== sow6 + 3 || sow8 !== sow7 + 3 || sow9 !== sow8 + 3 || sow10 !== sow9 + 3) {
+    return null;
+  }
+  if (tocSec !== toes) return null;
+  return buildBdsEphemeris(opts.prn ?? "C00", {
+    week,
+    sow: sow1,
+    toes,
+    tocSec,
+    svh,
+    tgd1,
+    af0,
+    af1: mergeS(af1p3, af1p4, 18) * 2 ** -50,
+    af2,
+    crs,
+    deltaN,
+    m0,
+    cuc: mergeS(cucp4, cucp5, 4) * 2 ** -31,
+    e: mergeS(ep5, ep6, 22) * 2 ** -33,
+    cus,
+    sqrtA,
+    cic: mergeS(cicp6, cicp7, 8) * 2 ** -31,
+    omega0,
+    cis,
+    i0: mergeS(i0p7, i0p8, 11) * 2 ** -31 * GPS_PI,
+    crc,
+    omega: mergeS(omegaP9, omegaP10, 5) * 2 ** -31 * GPS_PI,
+    omegaDot: mergeS(omegaDotP8, omegaDotP9, 5) * 2 ** -43 * GPS_PI,
+    idot
+  });
+}
+function isBdsGeoPrn(prn) {
+  return prn < 6 || prn > 58;
+}
+var BdsAssembler = class {
+  sats = /* @__PURE__ */ new Map();
+  /**
+   * Push one 300-bit subframe (38+ bytes, bit 0 = first bit of the
+   * preamble) for the satellite `prn` ("C06"). Returns the newly
+   * completed ephemeris, or null.
+   */
+  push(prn, subframe) {
+    if (subframe.length < BDS_SUBFRAME_BYTES) return null;
+    const num = parseInt(prn.slice(1), 10);
+    if (!Number.isFinite(num) || num < 1 || num > 63) return null;
+    const id = getBitU(subframe, 15, 3);
+    if (id < 1 || id > 5) return null;
+    let sat = this.sats.get(prn);
+    if (!sat) {
+      sat = { buf: new Uint8Array(10 * BDS_SUBFRAME_BYTES) };
+      this.sats.set(prn, sat);
+    }
+    let eph = null;
+    if (!isBdsGeoPrn(num)) {
+      sat.buf.set(subframe.subarray(0, BDS_SUBFRAME_BYTES), (id - 1) * 38);
+      if (id === 3) eph = decodeBdsD1Frame(sat.buf, { prn });
+    } else {
+      if (id !== 1) return null;
+      const pgn = getBitU(subframe, 42, 4);
+      if (pgn < 1 || pgn > 10) return null;
+      sat.buf.set(subframe.subarray(0, BDS_SUBFRAME_BYTES), (pgn - 1) * 38);
+      if (pgn === 10) eph = decodeBdsD2Frame(sat.buf, { prn });
+    }
+    if (!eph) return null;
+    const key = `${eph.week}:${eph.toe}`;
+    if (key === sat.lastKey) return null;
+    sat.lastKey = key;
+    return eph;
+  }
+};
+
+// src/navbits/gal.ts
 var GPS_EPOCH_MS3 = Date.UTC(1980, 0, 6);
-var MS_PER_WEEK = 7 * 864e5;
+var SEC_PER_WEEK4 = 7 * 86400;
+var HALF_WEEK3 = 302400;
+var GST_GPS_WEEK_OFFSET = 1024;
+function galInavPageCrcOk(page) {
+  if (page.length < 28) return false;
+  return crc24q(page, 196) === getBitU(page, 196, 24);
+}
+function gpsDate2(week, sec) {
+  return new Date(GPS_EPOCH_MS3 + (week * SEC_PER_WEEK4 + sec) * 1e3);
+}
+function weekOfToe(week, tow, toe) {
+  if (toe - tow > HALF_WEEK3) return week - 1;
+  if (toe - tow < -HALF_WEEK3) return week + 1;
+  return week;
+}
+var two = (n) => String(n).padStart(2, "0");
+function decodeGalInavWords(words) {
+  if (words.length < 96) return null;
+  const b = words;
+  let i = 128;
+  const type1 = getBitU(b, i, 6);
+  i += 6;
+  const iodNav1 = getBitU(b, i, 10);
+  i += 10;
+  const toes = getBitU(b, i, 14) * 60;
+  i += 14;
+  const m0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const e = getBitU(b, i, 32) * 2 ** -33;
+  i += 32;
+  const sqrtA = getBitU(b, i, 32) * 2 ** -19;
+  i = 128 * 2;
+  const type2 = getBitU(b, i, 6);
+  i += 6;
+  const iodNav2 = getBitU(b, i, 10);
+  i += 10;
+  const omega0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const i0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const omega = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const idot = getBitS(b, i, 14) * 2 ** -43 * GPS_PI;
+  i = 128 * 3;
+  const type3 = getBitU(b, i, 6);
+  i += 6;
+  const iodNav3 = getBitU(b, i, 10);
+  i += 10;
+  const omegaDot = getBitS(b, i, 24) * 2 ** -43 * GPS_PI;
+  i += 24;
+  const deltaN = getBitS(b, i, 16) * 2 ** -43 * GPS_PI;
+  i += 16;
+  const cuc = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const cus = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const crc = getBitS(b, i, 16) * 2 ** -5;
+  i += 16;
+  const crs = getBitS(b, i, 16) * 2 ** -5;
+  i = 128 * 4;
+  const type4 = getBitU(b, i, 6);
+  i += 6;
+  const iodNav4 = getBitU(b, i, 10);
+  i += 10;
+  const svid = getBitU(b, i, 6);
+  i += 6;
+  const cic = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const cis = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const tocs = getBitU(b, i, 14) * 60;
+  i += 14;
+  const af0 = getBitS(b, i, 31) * 2 ** -34;
+  i += 31;
+  const af1 = getBitS(b, i, 21) * 2 ** -46;
+  i += 21;
+  const af2 = getBitS(b, i, 6) * 2 ** -59;
+  i = 128 * 5;
+  const type5 = getBitU(b, i, 6);
+  i += 6 + 11 + 11 + 14 + 5;
+  const bgdE5a = getBitS(b, i, 10) * 2 ** -32;
+  i += 10;
+  i += 10;
+  const e5bHs = getBitU(b, i, 2);
+  i += 2;
+  const e1bHs = getBitU(b, i, 2);
+  i += 2;
+  const e5bDvs = getBitU(b, i, 1);
+  i += 1;
+  const e1bDvs = getBitU(b, i, 1);
+  i += 1;
+  const gstWeek = getBitU(b, i, 12);
+  i += 12;
+  const tow = getBitU(b, i, 20);
+  if (type1 !== 1 || type2 !== 2 || type3 !== 3 || type4 !== 4 || type5 !== 5)
+    return null;
+  if (iodNav1 !== iodNav2 || iodNav1 !== iodNav3 || iodNav1 !== iodNav4)
+    return null;
+  if (svid < 1 || svid > 36) return null;
+  const week = weekOfToe(gstWeek, tow, toes) + GST_GPS_WEEK_OFFSET;
+  const tocDate = gpsDate2(week, tocs);
+  return {
+    system: "E",
+    prn: `E${two(svid)}`,
+    toc: tocDate.getTime() / 1e3 % SEC_PER_WEEK4,
+    tocDate,
+    af0,
+    af1,
+    af2,
+    iode: iodNav1,
+    crs,
+    deltaN,
+    m0,
+    cuc,
+    e,
+    cus,
+    sqrtA,
+    toe: toes,
+    cic,
+    omega0,
+    cis,
+    i0,
+    crc,
+    omega,
+    omegaDot,
+    idot,
+    week,
+    svHealth: e5bHs << 7 | e5bDvs << 6 | e1bHs << 1 | e1bDvs,
+    tgd: bgdE5a
+  };
+}
+var dedupKey = (eph) => `${eph.iode}:${eph.toe}:${eph.tocDate.getTime()}`;
+var GalInavAssembler = class {
+  sats = /* @__PURE__ */ new Map();
+  /**
+   * Push one I/NAV page pair for satellite `prn` (1-36): the 234-bit
+   * even+odd concatenation, even part first with its 6 tail bits
+   * removed, bit 0 = the even part's Even/Odd bit (≥ 17 bytes).
+   * Returns the newly completed ephemeris, or null. Pages that are
+   * not an even/odd nominal pair, alert pages and word types outside
+   * 1-5 are ignored.
+   */
+  push(prn, page) {
+    if (prn < 1 || prn > 36 || page.length < 17) return null;
+    if (getBitU(page, 0, 1) !== 0 || getBitU(page, 114, 1) !== 1) return null;
+    if (getBitU(page, 1, 1) === 1 || getBitU(page, 115, 1) === 1) return null;
+    const type = getBitU(page, 2, 6);
+    if (type < 1 || type > 5) return null;
+    let sat = this.sats.get(prn);
+    if (!sat) {
+      sat = { words: new Uint8Array(96) };
+      this.sats.set(prn, sat);
+    }
+    for (let k = 0; k < 14; k++)
+      sat.words[type * 16 + k] = getBitU(page, 2 + 8 * k, 8);
+    sat.words[type * 16 + 14] = getBitU(page, 116, 8);
+    sat.words[type * 16 + 15] = getBitU(page, 124, 8);
+    if (type !== 5) return null;
+    const eph = decodeGalInavWords(sat.words);
+    if (!eph || eph.prn !== `E${two(prn)}`) return null;
+    const key = dedupKey(eph);
+    if (key === sat.lastKey) return null;
+    sat.lastKey = key;
+    return eph;
+  }
+};
+
+// src/constants/time.ts
+var MILLISECONDS_IN_SECOND = 1e3;
+var MILLISECONDS_GPS_TAI = 19e3;
+var START_NTP_TIME = /* @__PURE__ */ new Date("1900-01-01T00:00:00Z");
+
+// src/time/gnss.ts
+function getTaiDate(date) {
+  return new Date(date.getTime() + MILLISECONDS_GPS_TAI);
+}
+function getNtpTime(date) {
+  return getTaiDate(date).getTime() - START_NTP_TIME.getTime();
+}
+
+// src/time/utc.ts
+var LEAP_SECONDS_TABLE = [
+  [3692217600, 37],
+  // 1 Jan 2017
+  [3644697600, 36],
+  // 1 Jul 2015
+  [3550089600, 35],
+  // 1 Jul 2012
+  [3439756800, 34],
+  // 1 Jan 2009
+  [3345062400, 33],
+  // 1 Jan 2006
+  [3124137600, 32],
+  // 1 Jan 1999
+  [3076704e3, 31],
+  // 1 Jul 1997
+  [3029443200, 30],
+  // 1 Jan 1996
+  [2982009600, 29],
+  // 1 Jul 1994
+  [2950473600, 28],
+  // 1 Jul 1993
+  [2918937600, 27],
+  // 1 Jul 1992
+  [2871676800, 26],
+  // 1 Jan 1991
+  [2840140800, 25],
+  // 1 Jan 1990
+  [2776982400, 24],
+  // 1 Jan 1988
+  [2698012800, 23],
+  // 1 Jul 1985
+  [2634854400, 22],
+  // 1 Jul 1983
+  [2603318400, 21],
+  // 1 Jul 1982
+  [2571782400, 20],
+  // 1 Jul 1981
+  [2524521600, 19],
+  // 1 Jan 1980
+  [2492985600, 18],
+  // 1 Jan 1979
+  [2461449600, 17],
+  // 1 Jan 1978
+  [2429913600, 16],
+  // 1 Jan 1977
+  [2398291200, 15],
+  // 1 Jan 1976
+  [2366755200, 14],
+  // 1 Jan 1975
+  [2335219200, 13],
+  // 1 Jan 1974
+  [2303683200, 12],
+  // 1 Jan 1973
+  [2287785600, 11],
+  // 1 Jul 1972
+  [2272060800, 10]
+  // 1 Jan 1972
+];
+function getLeap(date) {
+  const ntp_time = getNtpTime(date);
+  for (const [timestamp, leapSeconds] of LEAP_SECONDS_TABLE) {
+    if (ntp_time / MILLISECONDS_IN_SECOND - leapSeconds >= timestamp) {
+      return leapSeconds;
+    }
+  }
+  return 8;
+}
+function getUtcDate(date) {
+  const tai_date = getTaiDate(date);
+  const leap_seconds = getLeap(date);
+  return new Date(tai_date.getTime() - leap_seconds * MILLISECONDS_IN_SECOND);
+}
+
+// src/navbits/glo.ts
+var GPS_EPOCH_MS4 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK5 = 7 * 86400;
+var SEC_PER_DAY = 86400;
+var GLO_STRING_BYTES = 10;
+function getBitG(b, pos, len) {
+  const value = getBitU(b, pos + 1, len - 1);
+  return getBitU(b, pos, 1) && value !== 0 ? -value : value;
+}
+var HAMMING_MASKS = [
+  [85, 85, 90, 170, 170, 170, 181, 85, 106, 216, 8],
+  [102, 102, 108, 204, 204, 204, 217, 153, 179, 104, 16],
+  [135, 135, 143, 15, 15, 15, 30, 30, 60, 112, 32],
+  [7, 248, 15, 240, 15, 240, 31, 224, 63, 128, 64],
+  [248, 0, 15, 255, 240, 0, 31, 255, 192, 0, 128],
+  [0, 0, 15, 255, 255, 255, 224, 0, 0, 1, 0],
+  [255, 255, 240, 0, 0, 0, 0, 0, 0, 2, 0],
+  [255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 248]
+];
+function testGloString(buff) {
+  if (buff.length < 11) return false;
+  let n = 0;
+  let cs = 0;
+  for (const mask of HAMMING_MASKS) {
+    cs = 0;
+    for (let j = 0; j < 11; j++) {
+      let x = buff[j] & mask[j];
+      x ^= x >> 4;
+      x ^= x >> 2;
+      x ^= x >> 1;
+      cs ^= x & 1;
+    }
+    if (cs) n++;
+  }
+  return n === 0 || n === 2 && cs === 1;
+}
+function decodeGloStrings(strings, refDate, opts = {}) {
+  if (strings.length < 4 * GLO_STRING_BYTES) return null;
+  const b = strings;
+  let i = 1;
+  const frn1 = getBitU(b, i, 4);
+  i += 4 + 2;
+  i += 2;
+  const tkH = getBitU(b, i, 5);
+  i += 5;
+  const tkM = getBitU(b, i, 6);
+  i += 6;
+  const tkS = getBitU(b, i, 1) * 30;
+  i += 1;
+  const xDot = getBitG(b, i, 24) * 2 ** -20;
+  i += 24;
+  const xAcc = getBitG(b, i, 5) * 2 ** -30;
+  i += 5;
+  const x = getBitG(b, i, 27) * 2 ** -11;
+  i = 80 + 1;
+  const frn2 = getBitU(b, i, 4);
+  i += 4;
+  const bn = getBitU(b, i, 1);
+  i += 1 + 2;
+  i += 1;
+  const tb = getBitU(b, i, 7);
+  i += 7 + 5;
+  const yDot = getBitG(b, i, 24) * 2 ** -20;
+  i += 24;
+  const yAcc = getBitG(b, i, 5) * 2 ** -30;
+  i += 5;
+  const y = getBitG(b, i, 27) * 2 ** -11;
+  i = 160 + 1;
+  const frn3 = getBitU(b, i, 4);
+  i += 4;
+  i += 1;
+  const gammaN = getBitG(b, i, 11) * 2 ** -40;
+  i += 11 + 1;
+  i += 2;
+  i += 1;
+  const zDot = getBitG(b, i, 24) * 2 ** -20;
+  i += 24;
+  const zAcc = getBitG(b, i, 5) * 2 ** -30;
+  i += 5;
+  const z = getBitG(b, i, 27) * 2 ** -11;
+  i = 240 + 1;
+  const frn4 = getBitU(b, i, 4);
+  i += 4;
+  const tauN = getBitG(b, i, 22) * 2 ** -30;
+  i += 22;
+  i += 5;
+  i += 5;
+  i += 14;
+  i += 1;
+  i += 4;
+  i += 3;
+  i += 11;
+  const slot = getBitU(b, i, 5);
+  if (frn1 !== 1 || frn2 !== 2 || frn3 !== 3 || frn4 !== 4) return null;
+  if (slot < 1 || slot > 27) return null;
+  const utcSec = (getUtcDate(refDate).getTime() - GPS_EPOCH_MS4) / 1e3;
+  const week = Math.floor(utcSec / SEC_PER_WEEK5);
+  let tow = utcSec - week * SEC_PER_WEEK5;
+  const tod = tow % SEC_PER_DAY;
+  tow -= tod;
+  let tof = tkH * 3600 + tkM * 60 + tkS - 10800;
+  if (tof < tod - 43200) tof += SEC_PER_DAY;
+  else if (tof > tod + 43200) tof -= SEC_PER_DAY;
+  let toe = tb * 900 - 10800;
+  if (toe < tod - 43200) toe += SEC_PER_DAY;
+  else if (toe > tod + 43200) toe -= SEC_PER_DAY;
+  return {
+    system: "R",
+    prn: `R${String(slot).padStart(2, "0")}`,
+    // RINEX GLONASS epochs are UTC: build the UTC toe Date directly.
+    tocDate: new Date(GPS_EPOCH_MS4 + (week * SEC_PER_WEEK5 + tow + toe) * 1e3),
+    tauN: -tauN,
+    // RINEX stores −τn; the SIS carries τn (ICD sign)
+    gammaN,
+    // v3 message frame time: seconds of the UTC week (RTKLIB tof).
+    messageFrameTime: ((tow + tof) % SEC_PER_WEEK5 + SEC_PER_WEEK5) % SEC_PER_WEEK5,
+    x,
+    xDot,
+    xAcc,
+    y,
+    yDot,
+    yAcc,
+    z,
+    zDot,
+    zAcc,
+    // MSB of the 3-bit Bn word — the unhealthy flag RINEX carries
+    health: bn,
+    freqNum: opts.freqNum ?? 0
+  };
+}
+var GloStringAssembler = class {
+  sats = /* @__PURE__ */ new Map();
+  /**
+   * Push one navigation string (10+ bytes, bit 0 = string bit 85) for
+   * the satellite `prn` ("R09"), received at the GPS-scale `time`.
+   * Returns the newly completed ephemeris, or null. The decoded
+   * string-4 slot number must match `prn`, or nothing is emitted.
+   */
+  push(prn, str, time, freqNum = 0) {
+    if (str.length < GLO_STRING_BYTES) return null;
+    const m = getBitU(str, 1, 4);
+    if (m < 1) return null;
+    const sec = Math.floor(time.getTime() / 1e3);
+    let sat = this.sats.get(prn);
+    if (!sat) {
+      sat = { buf: new Uint8Array(4 * GLO_STRING_BYTES), batchSec: sec };
+      this.sats.set(prn, sat);
+    } else if (Math.abs(sec - sat.batchSec) > 30) {
+      sat.buf.fill(0);
+      sat.batchSec = sec;
+    }
+    if (m > 4) return null;
+    sat.buf.set(str.subarray(0, GLO_STRING_BYTES), (m - 1) * 10);
+    if (m !== 4) return null;
+    const eph = decodeGloStrings(sat.buf, time, { freqNum });
+    if (!eph || eph.prn !== prn) return null;
+    const key = `${eph.tocDate.getTime()}:${eph.health}`;
+    if (key === sat.lastKey) return null;
+    sat.lastKey = key;
+    return eph;
+  }
+};
+
+// src/ubx/rawnav.ts
+var GPS_EPOCH_MS5 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK6 = 7 * 86400;
+var two2 = (n) => String(n).padStart(2, "0");
+function parseUbxRawNav(data, opts = {}) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  const counts = { gal: 0, bds: 0, glo: 0 };
+  let badParity = 0;
+  const inav = new GalInavAssembler();
+  const bds = new BdsAssembler();
+  const glo = new GloStringAssembler();
+  let refDate = null;
+  for (const f of ubxFrames(data)) {
+    if (f.msgClass !== 2) continue;
+    if (f.msgId === 21 && f.payload.length >= 16) {
+      const rcvTow = view.getFloat64(f.payloadStart, true);
+      let week = view.getUint16(f.payloadStart + 8, true);
+      if (week === 0 && opts.refWeek !== void 0) week = opts.refWeek;
+      if (week > 0) {
+        refDate = new Date(
+          GPS_EPOCH_MS5 + (week * SEC_PER_WEEK6 + rcvTow) * 1e3
+        );
+      }
+      continue;
+    }
+    if (f.msgId !== 19) continue;
+    const p = f.payload;
+    if (p.length < 8) continue;
+    const gnssId = p[0];
+    const svId = p[1];
+    const sigId = p[2];
+    const base = f.payloadStart + 8;
+    if (gnssId === 2) {
+      if (sigId === 3 || sigId === 8) continue;
+      if (p.length < 8 + 32) continue;
+      counts.gal++;
+      if (svId < 1 || svId > 36) continue;
+      const buff = new Uint8Array(32);
+      for (let k = 0; k < 8; k++) {
+        const w = view.getUint32(base + 4 * k, true);
+        buff[4 * k] = w >>> 24;
+        buff[4 * k + 1] = w >>> 16 & 255;
+        buff[4 * k + 2] = w >>> 8 & 255;
+        buff[4 * k + 3] = w & 255;
+      }
+      const page = new Uint8Array(30);
+      for (let k = 0; k < 14; k++) page[k] = buff[k];
+      setBitU(page, 112, 2, getBitU(buff, 112, 2));
+      for (let k = 0; k < 15; k++) {
+        setBitU(page, 114 + 8 * k, 8, getBitU(buff, 128 + 8 * k, 8));
+      }
+      if (getBitU(page, 0, 1) !== 0 || getBitU(page, 114, 1) !== 1) continue;
+      if (getBitU(page, 1, 1) === 1 || getBitU(page, 115, 1) === 1) continue;
+      if (!galInavPageCrcOk(page)) {
+        badParity++;
+        continue;
+      }
+      const eph = inav.push(svId, page);
+      if (eph) ephemerides.push(eph);
+    } else if (gnssId === 3) {
+      if (sigId === 6 || sigId === 8) continue;
+      if (p.length < 8 + 40) continue;
+      counts.bds++;
+      if (svId < 1 || svId > 63) continue;
+      const sf = new Uint8Array(38);
+      for (let k = 0; k < 10; k++) {
+        const w = view.getUint32(base + 4 * k, true);
+        setBitU(sf, 30 * k, 30, w & 1073741823);
+      }
+      if (!bdsSubframeParityOk(sf)) {
+        badParity++;
+        continue;
+      }
+      const eph = bds.push(`C${two2(svId)}`, sf);
+      if (eph) ephemerides.push(eph);
+    } else if (gnssId === 6) {
+      if (p.length < 8 + 16) continue;
+      counts.glo++;
+      if (svId < 1 || svId > 32) continue;
+      const str = new Uint8Array(16);
+      for (let k = 0; k < 4; k++) {
+        const w = view.getUint32(base + 4 * k, true);
+        str[4 * k] = w >>> 24;
+        str[4 * k + 1] = w >>> 16 & 255;
+        str[4 * k + 2] = w >>> 8 & 255;
+        str[4 * k + 3] = w & 255;
+      }
+      if (!testGloString(str)) {
+        badParity++;
+        continue;
+      }
+      if (!refDate) continue;
+      const eph = glo.push(`R${two2(svId)}`, str, refDate, p[3] - 7);
+      if (eph) ephemerides.push(eph);
+    }
+  }
+  return { ephemerides, counts, badParity };
+}
+
+// src/ubx/index.ts
+var GPS_EPOCH_MS6 = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK2 = 7 * 864e5;
 var SIGNALS = {
   0: { 0: ["G", "1C"], 3: ["G", "2X"], 4: ["G", "2X"] },
   // GPS L1C/A, L2CL, L2CM
@@ -556,20 +1354,20 @@ var SIGNALS = {
   // GLONASS L1OF, L2OF
 };
 function prnFor(gnssId, svId) {
-  const two = (n) => String(n).padStart(2, "0");
+  const two3 = (n) => String(n).padStart(2, "0");
   switch (gnssId) {
     case 0:
-      return svId >= 1 && svId <= 32 ? `G${two(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `G${two3(svId)}` : null;
     case 1:
-      return svId >= 120 && svId <= 158 ? `S${two(svId - 100)}` : null;
+      return svId >= 120 && svId <= 158 ? `S${two3(svId - 100)}` : null;
     case 2:
-      return svId >= 1 && svId <= 36 ? `E${two(svId)}` : null;
+      return svId >= 1 && svId <= 36 ? `E${two3(svId)}` : null;
     case 3:
-      return svId >= 1 && svId <= 63 ? `C${two(svId)}` : null;
+      return svId >= 1 && svId <= 63 ? `C${two3(svId)}` : null;
     case 5:
-      return svId >= 1 && svId <= 10 ? `J${two(svId)}` : null;
+      return svId >= 1 && svId <= 10 ? `J${two3(svId)}` : null;
     case 6:
-      return svId >= 1 && svId <= 32 ? `R${two(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `R${two3(svId)}` : null;
     default:
       return null;
   }
@@ -622,7 +1420,7 @@ function parseUbxRawx(data) {
         if (!codes.includes(sig[1])) codes.push(sig[1]);
       }
       epochs.push({
-        timeMs: GPS_EPOCH_MS3 + week * MS_PER_WEEK + Math.round(rcvTow * 1e3),
+        timeMs: GPS_EPOCH_MS6 + week * MS_PER_WEEK2 + Math.round(rcvTow * 1e3),
         leapS: leapValid ? leapS : null,
         meas
       });
@@ -635,6 +1433,7 @@ function parseUbxRawx(data) {
   parseUbxCnav,
   parseUbxIonoUtc,
   parseUbxNav,
+  parseUbxRawNav,
   parseUbxRawx,
   ubxFrames
 });