gnss-js 1.19.0 → 1.21.0

package/dist/index.cjs

@@ -104,6 +104,8 @@ __export(src_exports, {
   WGS84_SEMI_MAJOR_AXIS: () => WGS84_SEMI_MAJOR_AXIS,
   WGS84_SEMI_MINOR_AXIS: () => WGS84_SEMI_MINOR_AXIS,
   WarningAccumulator: () => WarningAccumulator,
+  almanacEpochMs: () => almanacEpochMs,
+  almanacSatPosition: () => almanacSatPosition,
   analyzeQuality: () => analyzeQuality,
   applyHelmert: () => applyHelmert,
   applyIonoDcb: () => applyIonoDcb,
@@ -200,6 +202,8 @@ __export(src_exports, {
   getWeekNumber: () => getWeekNumber,
   getWeekOfYear: () => getWeekOfYear,
   gloFreq: () => gloFreq,
+  glonassAlmanacEpochMs: () => glonassAlmanacEpochMs,
+  glonassAlmanacPosition: () => glonassAlmanacPosition,
   glonassPosition: () => glonassPosition,
   greatCircleMidpoint: () => greatCircleMidpoint,
   hdrLine: () => hdrLine,
@@ -223,7 +227,11 @@ __export(src_exports, {
   parseNovatelRange: () => parseNovatelRange,
   parseRinexStream: () => parseRinexStream,
   parseSbfAlmanac: () => parseSbfAlmanac,
+  parseSbfBdsNav: () => parseSbfBdsNav,
   parseSbfCnav: () => parseSbfCnav,
+  parseSbfGalNav: () => parseSbfGalNav,
+  parseSbfGloNav: () => parseSbfGloNav,
+  parseSbfHas: () => parseSbfHas,
   parseSbfIonoUtc: () => parseSbfIonoUtc,
   parseSbfMeas: () => parseSbfMeas,
   parseSbfNav: () => parseSbfNav,
@@ -5414,20 +5422,20 @@ var SIGNALS = {
   // GLONASS L1OF, L2OF
 };
 function prnFor(gnssId, svId) {
-  const two3 = (n) => String(n).padStart(2, "0");
+  const two4 = (n) => String(n).padStart(2, "0");
   switch (gnssId) {
     case 0:
-      return svId >= 1 && svId <= 32 ? `G${two3(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `G${two4(svId)}` : null;
     case 1:
-      return svId >= 120 && svId <= 158 ? `S${two3(svId - 100)}` : null;
+      return svId >= 120 && svId <= 158 ? `S${two4(svId - 100)}` : null;
     case 2:
-      return svId >= 1 && svId <= 36 ? `E${two3(svId)}` : null;
+      return svId >= 1 && svId <= 36 ? `E${two4(svId)}` : null;
     case 3:
-      return svId >= 1 && svId <= 63 ? `C${two3(svId)}` : null;
+      return svId >= 1 && svId <= 63 ? `C${two4(svId)}` : null;
     case 5:
-      return svId >= 1 && svId <= 10 ? `J${two3(svId)}` : null;
+      return svId >= 1 && svId <= 10 ? `J${two4(svId)}` : null;
     case 6:
-      return svId >= 1 && svId <= 32 ? `R${two3(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `R${two4(svId)}` : null;
     default:
       return null;
   }
@@ -5927,10 +5935,1419 @@ function parseSbfCnav(data) {
   return { ephemerides, badCrc, messages };
 }
 
+// src/navbits/gal.ts
+var GPS_EPOCH_MS6 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK5 = 7 * 86400;
+var HALF_WEEK2 = 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 galFnavPageCrcOk(page) {
+  if (page.length < 30) return false;
+  return crc24q(page, 214) === getBitU(page, 214, 24);
+}
+function gpsDate2(week, sec) {
+  return new Date(GPS_EPOCH_MS6 + (week * SEC_PER_WEEK5 + sec) * 1e3);
+}
+function weekOfToe(week, tow, toe) {
+  if (toe - tow > HALF_WEEK2) return week - 1;
+  if (toe - tow < -HALF_WEEK2) return week + 1;
+  return week;
+}
+var two2 = (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${two2(svid)}`,
+    toc: tocDate.getTime() / 1e3 % SEC_PER_WEEK5,
+    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
+  };
+}
+function decodeGalFnavPages(pages) {
+  if (pages.length < 124) return null;
+  const b = pages;
+  let i = 0;
+  const type1 = getBitU(b, i, 6);
+  i += 6;
+  const svid = getBitU(b, i, 6);
+  i += 6;
+  const iodNav1 = getBitU(b, i, 10);
+  i += 10;
+  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 += 6;
+  i += 8 + 11 + 11 + 14 + 5;
+  const bgdE5a = getBitS(b, i, 10) * 2 ** -32;
+  i += 10;
+  const e5aHs = getBitU(b, i, 2);
+  i += 2;
+  const gstWeek = getBitU(b, i, 12);
+  i += 12;
+  const tow = getBitU(b, i, 20);
+  i += 20;
+  const e5aDvs = getBitU(b, i, 1);
+  i = 31 * 8;
+  const type2 = getBitU(b, i, 6);
+  i += 6;
+  const iodNav2 = getBitU(b, i, 10);
+  i += 10;
+  const m0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const omegaDot = getBitS(b, i, 24) * 2 ** -43 * GPS_PI;
+  i += 24;
+  const e = getBitU(b, i, 32) * 2 ** -33;
+  i += 32;
+  const sqrtA = getBitU(b, i, 32) * 2 ** -19;
+  i += 32;
+  const omega0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
+  i += 32;
+  const idot = getBitS(b, i, 14) * 2 ** -43 * GPS_PI;
+  i = 62 * 8;
+  const type3 = getBitU(b, i, 6);
+  i += 6;
+  const iodNav3 = getBitU(b, i, 10);
+  i += 10;
+  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 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 += 16;
+  const toes = getBitU(b, i, 14) * 60;
+  i = 93 * 8;
+  const type4 = getBitU(b, i, 6);
+  i += 6;
+  const iodNav4 = getBitU(b, i, 10);
+  i += 10;
+  const cic = getBitS(b, i, 16) * 2 ** -29;
+  i += 16;
+  const cis = getBitS(b, i, 16) * 2 ** -29;
+  if (type1 !== 1 || type2 !== 2 || type3 !== 3 || type4 !== 4) 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${two2(svid)}`,
+    toc: tocDate.getTime() / 1e3 % SEC_PER_WEEK5,
+    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: e5aHs << 4 | e5aDvs << 3,
+    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${two2(prn)}`) return null;
+    const key = dedupKey(eph);
+    if (key === sat.lastKey) return null;
+    sat.lastKey = key;
+    return eph;
+  }
+};
+var GalFnavAssembler = class {
+  sats = /* @__PURE__ */ new Map();
+  /**
+   * Push one F/NAV page for satellite `prn` (1-36): 244 bits with the
+   * sync field stripped, bit 0 = first page-type bit (≥ 31 bytes).
+   * Returns the newly completed ephemeris, or null. Dummy pages
+   * (type 63) and page types outside 1-4 are ignored.
+   */
+  push(prn, page) {
+    if (prn < 1 || prn > 36 || page.length < 31) return null;
+    const type = getBitU(page, 0, 6);
+    if (type < 1 || type > 4) return null;
+    let sat = this.sats.get(prn);
+    if (!sat) {
+      sat = { words: new Uint8Array(124) };
+      this.sats.set(prn, sat);
+    }
+    sat.words.set(page.subarray(0, 31), (type - 1) * 31);
+    if (type !== 4) return null;
+    const eph = decodeGalFnavPages(sat.words);
+    if (!eph || eph.prn !== `E${two2(prn)}`) return null;
+    const key = dedupKey(eph);
+    if (key === sat.lastKey) return null;
+    sat.lastKey = key;
+    return eph;
+  }
+};
+
+// src/sbf/rawnav-gal.ts
+var INAV_SOURCES = [17, 21, 22];
+var FNAV_SOURCES = [20, 22];
+function parseSbfGalNav(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  const inav = new GalInavAssembler();
+  const fnav = new GalFnavAssembler();
+  let badCrc = 0;
+  let messages = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4022 && id !== 4023 || len < 52) return;
+    messages++;
+    const prnStr = svidToPrn(data[b + 14]);
+    if (!prnStr || prnStr[0] !== "E") return;
+    const prn = parseInt(prnStr.slice(1), 10);
+    const source = data[b + 17] & 31;
+    const page = new Uint8Array(32);
+    for (let k = 0; k < 8; k++) {
+      const w = view.getUint32(b + 20 + 4 * k, true);
+      page[4 * k] = w >>> 24;
+      page[4 * k + 1] = w >>> 16 & 255;
+      page[4 * k + 2] = w >>> 8 & 255;
+      page[4 * k + 3] = w & 255;
+    }
+    let eph;
+    let src;
+    if (id === 4023) {
+      src = "inav";
+      if (!INAV_SOURCES.includes(source)) return;
+      if (getBitU2(page, 0) !== 0 || getBitU2(page, 114) !== 1) return;
+      if (!galInavPageCrcOk(page)) {
+        badCrc++;
+        return;
+      }
+      eph = inav.push(prn, page);
+    } else {
+      src = "fnav";
+      if (!FNAV_SOURCES.includes(source)) return;
+      if (isFnavDummy(page)) return;
+      if (!galFnavPageCrcOk(page)) {
+        badCrc++;
+        return;
+      }
+      eph = fnav.push(prn, page);
+    }
+    if (eph) ephemerides.push({ ...eph, source: src });
+  });
+  return { ephemerides, badCrc, messages };
+}
+function getBitU2(buff, pos) {
+  return buff[pos >> 3] >> 7 - (pos & 7) & 1;
+}
+function isFnavDummy(page) {
+  return page[0] >> 2 === 63;
+}
+
+// src/navbits/bds.ts
+var BDT_EPOCH_MS2 = Date.UTC(2006, 0, 1);
+var SEC_PER_WEEK6 = 7 * 86400;
+var MS_PER_WEEK4 = SEC_PER_WEEK6 * 1e3;
+var HALF_WEEK3 = 302400;
+var sowOf2 = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK6;
+var BDS_SUBFRAME_BYTES = 38;
+function getBitU22(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_WEEK3) week++;
+  else if (f.toes > f.sow + HALF_WEEK3) week--;
+  const tocDate = new Date(BDT_EPOCH_MS2 + week * MS_PER_WEEK4 + f.tocSec * 1e3);
+  return {
+    system: "C",
+    prn,
+    toc: sowOf2(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 = getBitU22(b, i + 18, 8, i + 30, 12);
+  const svh = getBitU(b, i + 42, 1);
+  const week = getBitU(b, i + 60, 13);
+  const tocSec = getBitU22(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 = getBitU22(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 = getBitU22(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 = getBitU22(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 = getBitU22(b, i + 18, 8, i + 30, 12);
+  const toe2 = getBitU22(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 = getBitU22(b, i + 18, 8, i + 30, 12);
+  const svh = getBitU(b, i + 46, 1);
+  const week = getBitU(b, i + 64, 13);
+  const tocSec = getBitU22(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 = getBitU22(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 = getBitU22(b, i + 18, 8, i + 30, 12);
+  const af1p4 = getBitU22(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 = getBitU22(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 = getBitU22(b, i + 18, 8, i + 30, 12);
+  const ep6 = getBitU22(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 = getBitU22(b, i + 18, 8, i + 30, 12);
+  const cicp7 = getBitU22(b, i + 46, 6, i + 60, 2);
+  const cis = getBitS(b, i + 62, 18) * 2 ** -31;
+  const toes = getBitU22(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 = getBitU22(b, i + 18, 8, i + 30, 12);
+  const i0p8 = getBitU22(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 = getBitU22(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 = getBitU22(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/glo.ts
+var GPS_EPOCH_MS7 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK7 = 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_MS7) / 1e3;
+  const week = Math.floor(utcSec / SEC_PER_WEEK7);
+  let tow = utcSec - week * SEC_PER_WEEK7;
+  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_MS7 + (week * SEC_PER_WEEK7 + 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_WEEK7 + SEC_PER_WEEK7) % SEC_PER_WEEK7,
+    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/sbf/rawnav-bds.ts
+var GPS_EPOCH_MS8 = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK5 = 7 * 86400 * 1e3;
+var TOW_DNU = 4294967295;
+var WNC_DNU = 65535;
+function parseSbfBdsNav(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  const assembler = new BdsAssembler();
+  let badCrc = 0;
+  let messages = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4047 || len < 60) return;
+    messages++;
+    const prn = svidToPrn(view.getUint8(b + 14));
+    if (!prn || prn[0] !== "C") return;
+    const sf = new Uint8Array(38);
+    for (let k = 0; k < 10; k++) {
+      const w = view.getUint32(b + 20 + 4 * k, true);
+      sf[4 * k] = w >>> 24;
+      if (k < 9) {
+        sf[4 * k + 1] = w >>> 16 & 255;
+        sf[4 * k + 2] = w >>> 8 & 255;
+        sf[4 * k + 3] = w & 255;
+      } else {
+        sf[37] = w >>> 16 & 240;
+      }
+    }
+    if (!bdsSubframeParityOk(sf)) {
+      badCrc++;
+      return;
+    }
+    const eph = assembler.push(prn, sf);
+    if (eph) ephemerides.push(eph);
+  });
+  return { ephemerides, badCrc, messages };
+}
+function parseSbfGloNav(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ephemerides = [];
+  const assembler = new GloStringAssembler();
+  let badCrc = 0;
+  let messages = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4026 || len < 32) return;
+    messages++;
+    const prn = svidToPrn(view.getUint8(b + 14));
+    if (!prn || prn[0] !== "R") return;
+    const towMs = view.getUint32(b + 8, true);
+    const wnc = view.getUint16(b + 12, true);
+    if (towMs === TOW_DNU || wnc === WNC_DNU) return;
+    const str = new Uint8Array(11);
+    for (let k = 0; k < 3; k++) {
+      const w = view.getUint32(b + 20 + 4 * k, true);
+      str[4 * k] = w >>> 24;
+      if (k < 2) {
+        str[4 * k + 1] = w >>> 16 & 255;
+        str[4 * k + 2] = w >>> 8 & 255;
+        str[4 * k + 3] = w & 255;
+      } else {
+        str[9] = w >>> 16 & 255;
+        str[10] = w >>> 8 & 248;
+      }
+    }
+    if (!testGloString(str)) {
+      badCrc++;
+      return;
+    }
+    const eph = assembler.push(
+      prn,
+      str,
+      new Date(GPS_EPOCH_MS8 + wnc * MS_PER_WEEK5 + towMs),
+      view.getUint8(b + 18) - 8
+      // FreqNr, offset by 8
+    );
+    if (eph) ephemerides.push(eph);
+  });
+  return { ephemerides, badCrc, messages };
+}
+
+// src/navbits/rs255.ts
+var RS255_N = 255;
+var RS255_K = 32;
+var EXP = new Uint8Array(510);
+var LOG = new Int16Array(256).fill(-1);
+{
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    EXP[i] = x;
+    LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 510; i++) EXP[i] = EXP[i - 255];
+}
+var gfMul = (a, b) => a === 0 || b === 0 ? 0 : EXP[LOG[a] + LOG[b]];
+var gfInv = (a) => EXP[255 - LOG[a]];
+var GEN_POLY = (() => {
+  let g = new Uint8Array([1]);
+  for (let i = 1; i <= 223; i++) {
+    const root = EXP[i];
+    const next = new Uint8Array(g.length + 1);
+    for (let j = 0; j < g.length; j++) {
+      next[j] ^= g[j];
+      next[j + 1] ^= gfMul(g[j], root);
+    }
+    g = next;
+  }
+  return g;
+})();
+function rs255Encode(info) {
+  if (info.length > RS255_K)
+    throw new RangeError(`rs255Encode: info length ${info.length} > 32`);
+  const cw = new Uint8Array(RS255_N);
+  cw.set(info, 0);
+  const work = new Uint8Array(RS255_N);
+  work.set(info, 0);
+  for (let i = 0; i < RS255_K; i++) {
+    const coef = work[i];
+    if (coef === 0) continue;
+    for (let j = 1; j < GEN_POLY.length; j++)
+      work[i + j] ^= gfMul(GEN_POLY[j], coef);
+  }
+  cw.set(work.subarray(RS255_K), RS255_K);
+  return cw;
+}
+var genMatrix = null;
+function generatorMatrix() {
+  if (genMatrix) return genMatrix;
+  const rows = [];
+  for (let r = 0; r < RS255_N; r++) rows.push(new Uint8Array(RS255_K));
+  for (let c = 0; c < RS255_K; c++) {
+    const e = new Uint8Array(RS255_K);
+    e[c] = 1;
+    const cw = rs255Encode(e);
+    for (let r = 0; r < RS255_N; r++) rows[r][c] = cw[r];
+  }
+  genMatrix = rows;
+  return rows;
+}
+function rs255DecodeErasures(pages, k) {
+  if (k < 1 || k > RS255_K) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const use = [];
+  for (const p of pages) {
+    if (p.pageId < 1 || p.pageId > RS255_N || seen.has(p.pageId)) continue;
+    seen.add(p.pageId);
+    use.push(p);
+    if (use.length === k) break;
+  }
+  if (use.length < k) return null;
+  const width = use[0].octets.length;
+  if (use.some((p) => p.octets.length !== width)) return null;
+  const G = generatorMatrix();
+  const a = use.map((p) => G[p.pageId - 1].slice(0, k));
+  const inv = use.map((_, r) => {
+    const row = new Uint8Array(k);
+    row[r] = 1;
+    return row;
+  });
+  for (let c = 0; c < k; c++) {
+    let pivot = -1;
+    for (let r = c; r < k; r++)
+      if (a[r][c] !== 0) {
+        pivot = r;
+        break;
+      }
+    if (pivot < 0) return null;
+    [a[c], a[pivot]] = [a[pivot], a[c]];
+    [inv[c], inv[pivot]] = [inv[pivot], inv[c]];
+    const s = gfInv(a[c][c]);
+    for (let j = 0; j < k; j++) {
+      a[c][j] = gfMul(a[c][j], s);
+      inv[c][j] = gfMul(inv[c][j], s);
+    }
+    for (let r = 0; r < k; r++) {
+      if (r === c || a[r][c] === 0) continue;
+      const f = a[r][c];
+      for (let j = 0; j < k; j++) {
+        a[r][j] ^= gfMul(a[c][j], f);
+        inv[r][j] ^= gfMul(inv[c][j], f);
+      }
+    }
+  }
+  const out = new Uint8Array(k * width);
+  for (let r = 0; r < k; r++)
+    for (let c = 0; c < width; c++) {
+      let v = 0;
+      for (let j = 0; j < k; j++) v ^= gfMul(inv[r][j], use[j].octets[c]);
+      out[r * width + c] = v;
+    }
+  return out;
+}
+
+// src/navbits/has.ts
+var HAS_DUMMY_HEADER = 11484099;
+var HAS_VALIDITY_SECONDS = [
+  5,
+  10,
+  15,
+  20,
+  30,
+  60,
+  90,
+  120,
+  180,
+  240,
+  300,
+  600,
+  900,
+  1800,
+  3600,
+  null
+];
+var HAS_GPS_SIGNALS = [
+  "L1 C/A",
+  "Reserved",
+  "Reserved",
+  "L1C(D)",
+  "L1C(P)",
+  "L1C(D+P)",
+  "L2 CM",
+  "L2 CL",
+  "L2 CM+CL",
+  "L2 P",
+  "Reserved",
+  "L5 I",
+  "L5 Q",
+  "L5 I+Q",
+  "Reserved",
+  "Reserved"
+];
+var HAS_GALILEO_SIGNALS = [
+  "E1-B",
+  "E1-C",
+  "E1-B+E1-C",
+  "E5a-I",
+  "E5a-Q",
+  "E5a-I+E5a-Q",
+  "E5b-I",
+  "E5b-Q",
+  "E5b-I+E5b-Q",
+  "E5-I",
+  "E5-Q",
+  "E5-I+E5-Q",
+  "E6-B",
+  "E6-C",
+  "E6-B+E6-C",
+  "Reserved"
+];
+var SYSTEM_OF_GNSS_ID = { 0: "G", 2: "E" };
+var IOD_BITS = { G: 8, E: 10 };
+function hasPageCrcOk(page) {
+  if (page.length < 61) return false;
+  return crc24q(page, 462) === getBitU(page, 462, 24);
+}
+function parseHasPage(page) {
+  if (getBitU(page, 14, 24) === HAS_DUMMY_HEADER) return null;
+  const body = new Uint8Array(53);
+  for (let i = 0; i < 53; i++) body[i] = getBitU(page, 38 + 8 * i, 8);
+  return {
+    status: getBitU(page, 14, 2),
+    messageType: getBitU(page, 18, 2),
+    messageId: getBitU(page, 20, 5),
+    messageSize: getBitU(page, 25, 5) + 1,
+    pageId: getBitU(page, 30, 8),
+    body
+  };
+}
+var Cursor = class {
+  constructor(buf, bits) {
+    this.buf = buf;
+    this.bits = bits;
+  }
+  pos = 0;
+  u(len) {
+    if (this.pos + len > this.bits) throw new RangeError("truncated");
+    const v = getBitU(this.buf, this.pos, len);
+    this.pos += len;
+    return v;
+  }
+  s(len) {
+    if (this.pos + len > this.bits) throw new RangeError("truncated");
+    const v = getBitS(this.buf, this.pos, len);
+    this.pos += len;
+    return v;
+  }
+};
+var prnOf = (system, idx) => `${system}${String(idx + 1).padStart(2, "0")}`;
+function parseMaskBlock(c, maskId) {
+  const nSys = c.u(4);
+  const systems = [];
+  for (let s = 0; s < nSys; s++) {
+    const gnssId = c.u(4);
+    const system = SYSTEM_OF_GNSS_ID[gnssId];
+    if (system === void 0) throw new RangeError(`unknown GNSS ID ${gnssId}`);
+    const prns = [];
+    for (let b = 0; b < 40; b++) if (c.u(1)) prns.push(prnOf(system, b));
+    const signalIndices = [];
+    for (let b = 0; b < 16; b++) if (c.u(1)) signalIndices.push(b);
+    const signalNames = system === "G" ? HAS_GPS_SIGNALS : HAS_GALILEO_SIGNALS;
+    let cellMask = null;
+    if (c.u(1)) {
+      cellMask = prns.map(() => signalIndices.map(() => c.u(1) === 1));
+    }
+    systems.push({
+      gnssId,
+      system,
+      prns,
+      signalIndices,
+      signals: signalIndices.map((i) => signalNames[i]),
+      cellMask,
+      navMessage: c.u(3)
+    });
+  }
+  c.u(6);
+  return { maskId, systems };
+}
+function parseOrbitBlock(c, masks) {
+  const validityIndex = c.u(4);
+  const corrections = [];
+  for (const sys of masks.systems) {
+    for (const prn of sys.prns) {
+      const gnssIod = c.u(IOD_BITS[sys.system]);
+      const rad = c.s(13);
+      const inT = c.s(12);
+      const cross = c.s(12);
+      corrections.push({
+        system: sys.system,
+        prn,
+        gnssIod,
+        deltaRadial: rad === -4096 ? null : rad * 25e-4,
+        deltaInTrack: inT === -2048 ? null : inT * 8e-3,
+        deltaCrossTrack: cross === -2048 ? null : cross * 8e-3
+      });
+    }
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    corrections
+  };
+}
+function clockValue(c, system, prn, multiplier) {
+  const raw = c.s(13);
+  return {
+    system,
+    prn,
+    deltaClock: raw === -4096 || raw === 4095 ? null : raw * 25e-4 * multiplier,
+    notUsable: raw === 4095
+  };
+}
+function parseClockFullBlock(c, masks) {
+  const validityIndex = c.u(4);
+  const multipliers = masks.systems.map((sys) => ({
+    system: sys.system,
+    multiplier: c.u(2) + 1
+  }));
+  const corrections = [];
+  for (let s = 0; s < masks.systems.length; s++) {
+    const sys = masks.systems[s];
+    for (const prn of sys.prns)
+      corrections.push(
+        clockValue(c, sys.system, prn, multipliers[s].multiplier)
+      );
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    multipliers,
+    corrections
+  };
+}
+function parseClockSubsetBlock(c, masks) {
+  const validityIndex = c.u(4);
+  const nSys = c.u(4);
+  const multipliers = [];
+  const corrections = [];
+  for (let s = 0; s < nSys; s++) {
+    const gnssId = c.u(4);
+    const sys = masks.systems.find((m) => m.gnssId === gnssId);
+    if (!sys) throw new RangeError(`subset GNSS ID ${gnssId} not in mask`);
+    const multiplier = c.u(2) + 1;
+    multipliers.push({ system: sys.system, multiplier });
+    const selected = [];
+    for (const prn of sys.prns) if (c.u(1)) selected.push(prn);
+    for (const prn of selected)
+      corrections.push(clockValue(c, sys.system, prn, multiplier));
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    multipliers,
+    corrections
+  };
+}
+function parseBiasBlock(c, masks, kind) {
+  const validityIndex = c.u(4);
+  const biases = [];
+  for (const sys of masks.systems) {
+    for (let s = 0; s < sys.prns.length; s++) {
+      for (let g = 0; g < sys.signalIndices.length; g++) {
+        if (sys.cellMask && !sys.cellMask[s][g]) continue;
+        const raw = c.s(11);
+        const entry = {
+          system: sys.system,
+          prn: sys.prns[s],
+          signalIndex: sys.signalIndices[g],
+          signal: sys.signals[g],
+          bias: raw === -1024 ? null : raw * (kind === "code" ? 0.02 : 0.01)
+        };
+        if (kind === "phase") entry.discontinuity = c.u(2);
+        biases.push(entry);
+      }
+    }
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    biases
+  };
+}
+function parseHasMt1(payload, header, cachedMasks) {
+  const c = new Cursor(payload, payload.length * 8);
+  const toh = c.u(12);
+  const flags = {
+    mask: c.u(1) === 1,
+    orbit: c.u(1) === 1,
+    clockFullSet: c.u(1) === 1,
+    clockSubset: c.u(1) === 1,
+    codeBias: c.u(1) === 1,
+    phaseBias: c.u(1) === 1
+  };
+  c.u(4);
+  const maskId = c.u(5);
+  const iodSetId = c.u(5);
+  const msg = {
+    ...header,
+    toh,
+    maskId,
+    iodSetId,
+    flags,
+    maskFromCache: false,
+    parseError: null
+  };
+  try {
+    let masks;
+    if (flags.mask) {
+      masks = parseMaskBlock(c, maskId);
+    } else if (cachedMasks) {
+      masks = cachedMasks;
+      msg.maskFromCache = true;
+    } else {
+      msg.parseError = "mask-unavailable";
+      return msg;
+    }
+    msg.masks = masks;
+    if (flags.orbit) msg.orbit = parseOrbitBlock(c, masks);
+    if (flags.clockFullSet) msg.clockFullSet = parseClockFullBlock(c, masks);
+    if (flags.clockSubset) msg.clockSubset = parseClockSubsetBlock(c, masks);
+    if (flags.codeBias) msg.codeBias = parseBiasBlock(c, masks, "code");
+    if (flags.phaseBias) msg.phaseBias = parseBiasBlock(c, masks, "phase");
+  } catch (e) {
+    msg.parseError = e instanceof Error ? e.message : String(e);
+  }
+  return msg;
+}
+var HasAssembler = class {
+  slots = /* @__PURE__ */ new Map();
+  lastMessageId = -1;
+  maskCache = /* @__PURE__ */ new Map();
+  /** Pages a message may span before its slot is restarted (s). */
+  timeoutSec;
+  stats = {
+    pages: 0,
+    dummyPages: 0,
+    skippedPages: 0,
+    duplicatePages: 0,
+    resets: 0,
+    messages: 0,
+    parseErrors: 0
+  };
+  constructor(opts = {}) {
+    this.timeoutSec = opts.timeoutSec ?? 30;
+  }
+  /**
+   * Push one 492-bit C/NAV page (≥ 61 bytes; check the CRC first with
+   * `hasPageCrcOk`). `tow` — a receiver time of week in seconds, any
+   * origin as long as it is common to all pages — enables the slot
+   * timeout and is stamped on completed messages.
+   */
+  push(page, tow) {
+    const p = parseHasPage(page);
+    if (!p) {
+      this.stats.dummyPages++;
+      return null;
+    }
+    this.stats.pages++;
+    if (p.messageType !== 1 || p.status > 1 || p.pageId === 0) {
+      this.stats.skippedPages++;
+      return null;
+    }
+    if (p.messageId === this.lastMessageId) return null;
+    let slot = this.slots.get(p.messageId);
+    const timedOut = slot?.firstTow !== void 0 && tow !== void 0 && tow - slot.firstTow > this.timeoutSec;
+    if (slot && (slot.messageSize !== p.messageSize || timedOut)) {
+      this.stats.resets++;
+      slot = void 0;
+    }
+    if (!slot) {
+      slot = {
+        messageSize: p.messageSize,
+        status: p.status,
+        pages: [],
+        bodies: /* @__PURE__ */ new Map(),
+        firstTow: tow
+      };
+      this.slots.set(p.messageId, slot);
+    }
+    const bodyKey = Array.from(
+      p.body,
+      (b) => b.toString(16).padStart(2, "0")
+    ).join("");
+    const existing = slot.bodies.get(p.pageId);
+    if (existing !== void 0) {
+      if (existing === bodyKey) {
+        this.stats.duplicatePages++;
+        return null;
+      }
+      this.stats.resets++;
+      slot.pages = [];
+      slot.bodies.clear();
+      slot.firstTow = tow;
+    }
+    slot.bodies.set(p.pageId, bodyKey);
+    slot.pages.push({ pageId: p.pageId, octets: p.body });
+    if (slot.pages.length < slot.messageSize) return null;
+    const payload = rs255DecodeErasures(slot.pages, slot.messageSize);
+    if (!payload) return null;
+    this.slots.delete(p.messageId);
+    this.lastMessageId = p.messageId;
+    const msg = parseHasMt1(
+      payload,
+      {
+        status: slot.status,
+        messageId: p.messageId,
+        messageSize: slot.messageSize
+      },
+      void 0
+    );
+    const resolved = msg.parseError === "mask-unavailable" && this.maskCache.has(msg.maskId) ? parseHasMt1(
+      payload,
+      {
+        status: slot.status,
+        messageId: p.messageId,
+        messageSize: slot.messageSize
+      },
+      this.maskCache.get(msg.maskId)
+    ) : msg;
+    if (resolved.flags.mask && resolved.masks)
+      this.maskCache.set(resolved.maskId, resolved.masks);
+    if (tow !== void 0) resolved.tow = tow;
+    this.stats.messages++;
+    if (resolved.parseError !== null) this.stats.parseErrors++;
+    return resolved;
+  }
+};
+
+// src/sbf/rawnav-has.ts
+function parseSbfHas(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const assembler = new HasAssembler();
+  const messages = [];
+  let pagesSeen = 0;
+  let pagesBadCrc = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4024 || len < 84) return;
+    pagesSeen++;
+    const page = new Uint8Array(64);
+    for (let k = 0; k < 16; k++) {
+      const w = view.getUint32(b + 20 + 4 * k, true);
+      page[4 * k] = w >>> 24;
+      page[4 * k + 1] = w >>> 16 & 255;
+      page[4 * k + 2] = w >>> 8 & 255;
+      page[4 * k + 3] = w & 255;
+    }
+    if (!hasPageCrcOk(page)) {
+      pagesBadCrc++;
+      return;
+    }
+    const tow = view.getUint32(b + 8, true) / 1e3;
+    const msg = assembler.push(page, tow);
+    if (msg) messages.push({ ...msg, tow, wnc: view.getUint16(b + 12, true) });
+  });
+  return {
+    messages,
+    pagesSeen,
+    pagesBadCrc,
+    pagesDummy: assembler.stats.dummyPages,
+    pagesHas: assembler.stats.pages
+  };
+}
+
 // src/sbf/index.ts
 var CLIGHT = 299792458;
-var GPS_EPOCH_MS6 = Date.UTC(1980, 0, 6);
-var MS_PER_WEEK4 = 7 * 864e5;
+var GPS_EPOCH_MS9 = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK6 = 7 * 864e5;
 var M3_SYS = ["G", "R", "E", "C", "S", "J", "I"];
 var M3_PR_BASE = [19e6, 19e6, 22e6, 2e7, 34e6, 34e6, 34e6];
 var M3_INTERVALS = [
@@ -6029,23 +7446,23 @@ var MEAS2_SIG = [
   ["J", "1E"],
   ["J", "5P"]
 ];
-var two2 = (n) => String(n).padStart(2, "0");
+var two3 = (n) => String(n).padStart(2, "0");
 function m3Prn(navsys, svid) {
   switch (navsys) {
     case 0:
-      return svid < 32 ? `G${two2(svid + 1)}` : null;
+      return svid < 32 ? `G${two3(svid + 1)}` : null;
     case 1:
-      return svid < 27 ? `R${two2(svid + 1)}` : null;
+      return svid < 27 ? `R${two3(svid + 1)}` : null;
     case 2:
-      return svid < 36 ? `E${two2(svid + 1)}` : null;
+      return svid < 36 ? `E${two3(svid + 1)}` : null;
     case 3:
-      return svid < 50 ? `C${two2(svid + 1)}` : null;
+      return svid < 50 ? `C${two3(svid + 1)}` : null;
     case 4:
-      return svid <= 38 ? `S${two2(svid + 20)}` : null;
+      return svid <= 38 ? `S${two3(svid + 20)}` : null;
     case 5:
-      return svid < 10 ? `J${two2(svid + 1)}` : null;
+      return svid < 10 ? `J${two3(svid + 1)}` : null;
     case 6:
-      return svid < 14 ? `I${two2(svid + 1)}` : null;
+      return svid < 14 ? `I${two3(svid + 1)}` : null;
     default:
       return null;
   }
@@ -6583,7 +8000,7 @@ function parseSbfMeas(data) {
       const tow = view.getUint32(i + 8, true);
       const wnc = view.getUint16(i + 12, true);
       if (tow !== 4294967295 && wnc !== 65535) {
-        ensureEpoch(GPS_EPOCH_MS6 + wnc * MS_PER_WEEK4 + tow);
+        ensureEpoch(GPS_EPOCH_MS9 + wnc * MS_PER_WEEK6 + tow);
         if (id === 4109) decodeMeas3Ranges(i, tow);
         else if (id === 4110) decodeMeas3CN0(i, len);
         else if (id === 4111) decodeMeas3Doppler(i, len);
@@ -6641,24 +8058,25 @@ function* oem4Frames(data, view, stats) {
 
 // src/novatel/nav.ts
 var ID_IONUTC = 8;
+var ID_RAWCNAVFRAME = 1066;
 var ID_RAWEPHEM = 41;
 var ID_GLOEPHEMERIS = 723;
 var ID_GALEPHEMERIS = 1122;
 var ID_QZSSEPHEMERIS = 1336;
 var ID_GPSEPHEM = 7;
 var ID_BDSEPHEMERIS = 1696;
-var GPS_EPOCH_MS7 = Date.UTC(1980, 0, 6);
-var BDT_EPOCH_MS2 = Date.UTC(2006, 0, 1);
-var SEC_PER_WEEK5 = 7 * 86400;
-var SEC_PER_DAY = 86400;
-var MS_PER_WEEK5 = SEC_PER_WEEK5 * 1e3;
-var gpsMs2 = (week, sec) => GPS_EPOCH_MS7 + week * MS_PER_WEEK5 + sec * 1e3;
-var sowOf2 = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK5;
+var GPS_EPOCH_MS10 = Date.UTC(1980, 0, 6);
+var BDT_EPOCH_MS3 = Date.UTC(2006, 0, 1);
+var SEC_PER_WEEK8 = 7 * 86400;
+var SEC_PER_DAY2 = 86400;
+var MS_PER_WEEK7 = SEC_PER_WEEK8 * 1e3;
+var gpsMs2 = (week, sec) => GPS_EPOCH_MS10 + week * MS_PER_WEEK7 + sec * 1e3;
+var sowOf3 = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK8;
 function nearWeekMs(refMs, sow) {
-  const refWeek = Math.floor((refMs - GPS_EPOCH_MS7) / MS_PER_WEEK5);
+  const refWeek = Math.floor((refMs - GPS_EPOCH_MS10) / MS_PER_WEEK7);
   let ms = gpsMs2(refWeek, sow);
-  if (ms < refMs - MS_PER_WEEK5 / 2) ms += MS_PER_WEEK5;
-  else if (ms > refMs + MS_PER_WEEK5 / 2) ms -= MS_PER_WEEK5;
+  if (ms < refMs - MS_PER_WEEK7 / 2) ms += MS_PER_WEEK7;
+  else if (ms > refMs + MS_PER_WEEK7 / 2) ms -= MS_PER_WEEK7;
   return ms;
 }
 function decodeRawEphem(data, view, p) {
@@ -6679,12 +8097,12 @@ function decodeGloEphemeris(view, p) {
   const toff = view.getUint32(p + 12, true);
   const health = view.getUint32(p + 24, true) < 4 ? 0 : 1;
   let tof = view.getUint32(p + 124, true) - toff;
-  tof += Math.floor(tow / SEC_PER_DAY) * SEC_PER_DAY;
-  if (tof < tow - 43200) tof += SEC_PER_DAY;
-  else if (tof > tow + 43200) tof -= SEC_PER_DAY;
-  const toeGpsMs = GPS_EPOCH_MS7 + (week * SEC_PER_WEEK5 + tow) * 1e3;
-  const tofGpsMs = GPS_EPOCH_MS7 + (week * SEC_PER_WEEK5 + tof) * 1e3;
-  const tofUtcSec = (getUtcDate(new Date(tofGpsMs)).getTime() - GPS_EPOCH_MS7) / 1e3;
+  tof += Math.floor(tow / SEC_PER_DAY2) * SEC_PER_DAY2;
+  if (tof < tow - 43200) tof += SEC_PER_DAY2;
+  else if (tof > tow + 43200) tof -= SEC_PER_DAY2;
+  const toeGpsMs = GPS_EPOCH_MS10 + (week * SEC_PER_WEEK8 + tow) * 1e3;
+  const tofGpsMs = GPS_EPOCH_MS10 + (week * SEC_PER_WEEK8 + tof) * 1e3;
+  const tofUtcSec = (getUtcDate(new Date(tofGpsMs)).getTime() - GPS_EPOCH_MS10) / 1e3;
   return {
     system: "R",
     prn: `R${String(slot).padStart(2, "0")}`,
@@ -6692,7 +8110,7 @@ function decodeGloEphemeris(view, p) {
     tauN: -view.getFloat64(p + 100, true),
     // RINEX stores −τ_n
     gammaN: view.getFloat64(p + 116, true),
-    messageFrameTime: (tofUtcSec % SEC_PER_WEEK5 + SEC_PER_WEEK5) % SEC_PER_WEEK5,
+    messageFrameTime: (tofUtcSec % SEC_PER_WEEK8 + SEC_PER_WEEK8) % SEC_PER_WEEK8,
     x: view.getFloat64(p + 28, true) / 1e3,
     y: view.getFloat64(p + 36, true) / 1e3,
     z: view.getFloat64(p + 44, true) / 1e3,
@@ -6727,7 +8145,7 @@ function decodeGalEphemeris(view, p, headerMs) {
     eph: {
       system: "E",
       prn: `E${String(prn).padStart(2, "0")}`,
-      toc: sowOf2(tocDate.getTime()),
+      toc: sowOf3(tocDate.getTime()),
       tocDate,
       af0: view.getFloat64(c + 4, true),
       af1: view.getFloat64(c + 12, true),
@@ -6749,7 +8167,7 @@ function decodeGalEphemeris(view, p, headerMs) {
       omega: view.getFloat64(p + 60, true),
       omegaDot: view.getFloat64(p + 140, true),
       idot: view.getFloat64(p + 124, true),
-      week: Math.floor((toeMs - GPS_EPOCH_MS7) / MS_PER_WEEK5),
+      week: Math.floor((toeMs - GPS_EPOCH_MS10) / MS_PER_WEEK7),
       // RINEX Galileo SVH bit layout (E1B DVS/HS in bits 0-2, E5a in
       // 3-5, E5b in 6-8) — same packing as RTKLIB.
       svHealth: svhE5b << 7 | dvsE5b << 6 | svhE5a << 4 | dvsE5a << 3 | svhE1b << 1 | dvsE1b,
@@ -6766,11 +8184,11 @@ function decodeBdsEphemeris2(view, p) {
   const tgd1 = view.getFloat64(p + 20, true);
   const tocs = view.getUint32(p + 40, true);
   const toes = view.getUint32(p + 72, true);
-  const tocDate = new Date(BDT_EPOCH_MS2 + week * MS_PER_WEEK5 + tocs * 1e3);
+  const tocDate = new Date(BDT_EPOCH_MS3 + week * MS_PER_WEEK7 + tocs * 1e3);
   return {
     system: "C",
     prn: `C${String(prn).padStart(2, "0")}`,
-    toc: sowOf2(tocDate.getTime()),
+    toc: sowOf3(tocDate.getTime()),
     tocDate,
     af0: view.getFloat64(p + 44, true),
     af1: view.getFloat64(p + 52, true),
@@ -6814,7 +8232,7 @@ function decodeGpsQzssEphemeris(view, p, sys) {
   return {
     system: sys,
     prn: `${sys}${String(sys === "J" ? prn - 192 : prn).padStart(2, "0")}`,
-    toc: sowOf2(tocDate.getTime()),
+    toc: sowOf3(tocDate.getTime()),
     tocDate,
     af0: view.getFloat64(p + 180, true),
     af1: view.getFloat64(p + 188, true),
@@ -6847,6 +8265,9 @@ function parseNovatelNav(data) {
   const ephemerides = [];
   const ionoCorrections = {};
   let leapSeconds = null;
+  const cnav = [];
+  const cnavAssembler = new CnavAssembler();
+  let cnavBadCrc = 0;
   const lastKep = /* @__PURE__ */ new Map();
   const lastGlo = /* @__PURE__ */ new Map();
   const pushKepler = (key, eph) => {
@@ -6877,6 +8298,14 @@ function parseNovatelNav(data) {
     } else if (frame.id === ID_QZSSEPHEMERIS && frame.msgLen >= 204) {
       const eph = decodeGpsQzssEphemeris(view, frame.payload, "J");
       if (eph) pushKepler(eph.prn, eph);
+    } else if (frame.id === ID_RAWCNAVFRAME && frame.msgLen >= 50) {
+      const msg = data.subarray(frame.payload + 12, frame.payload + 50);
+      if (!cnavCrcOk(msg)) {
+        cnavBadCrc++;
+      } else {
+        const eph = cnavAssembler.push(msg);
+        if (eph) cnav.push(eph);
+      }
     } else if (frame.id === ID_IONUTC && frame.msgLen >= 108) {
       const p = frame.payload;
       const alpha = [];
@@ -6899,12 +8328,19 @@ function parseNovatelNav(data) {
       ephemerides.push(eph);
     }
   }
-  return { ephemerides, ionoCorrections, leapSeconds, badCrc: stats.badCrc };
+  return {
+    ephemerides,
+    ionoCorrections,
+    leapSeconds,
+    cnav,
+    cnavBadCrc,
+    badCrc: stats.badCrc
+  };
 }
 
 // src/novatel/index.ts
-var GPS_EPOCH_MS8 = Date.UTC(1980, 0, 6);
-var MS_PER_WEEK6 = 7 * 864e5;
+var GPS_EPOCH_MS11 = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK8 = 7 * 864e5;
 var HDR = 28;
 var ID_RANGE = 43;
 var ID_RANGECMP = 140;
@@ -7073,7 +8509,7 @@ function parseNovatelRange(data) {
           if (!codes.includes(code)) codes.push(code);
         }
         epochs.push({
-          timeMs: GPS_EPOCH_MS8 + week * MS_PER_WEEK6 + towMs,
+          timeMs: GPS_EPOCH_MS11 + week * MS_PER_WEEK8 + towMs,
           meas
         });
       }
@@ -7125,7 +8561,7 @@ function parseNovatelRange(data) {
           if (!codes.includes(code)) codes.push(code);
         }
         epochs.push({
-          timeMs: GPS_EPOCH_MS8 + week * MS_PER_WEEK6 + towMs,
+          timeMs: GPS_EPOCH_MS11 + week * MS_PER_WEEK8 + towMs,
           meas
         });
       }
@@ -7135,10 +8571,184 @@ function parseNovatelRange(data) {
   return { epochs, messageCounts, obsCodes, badCrc };
 }
 
-// src/orbit/index.ts
+// src/orbit/almanac.ts
 var GM_GPS = 3986005e8;
 var GM_GAL = 3986004418e5;
 var GM_BDS = 3986004418e5;
+var GPS_EPOCH_MS12 = Date.UTC(1980, 0, 6);
+var BDT_EPOCH_MS4 = 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 GPS_EPOCH_MS12 + 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;
+  const a = alm.sqrtA * alm.sqrtA;
+  const n0 = Math.sqrt(GM / (a * a * a));
+  const tk = (timeMs - almanacEpochMs(alm)) / 1e3;
+  const Mk = alm.m0 + n0 * tk;
+  let Ek = Mk;
+  for (let i = 0; i < 12; i++) {
+    const dE = (Mk - (Ek - alm.e * Math.sin(Ek))) / (1 - alm.e * Math.cos(Ek));
+    Ek += dE;
+    if (Math.abs(dE) < 1e-12) break;
+  }
+  const sinE = Math.sin(Ek);
+  const cosE = Math.cos(Ek);
+  const vk = Math.atan2(Math.sqrt(1 - alm.e * alm.e) * sinE, cosE - alm.e);
+  const uk = vk + alm.omega;
+  const rk = a * (1 - alm.e * cosE);
+  const ik = alm.i0OrDeltaI;
+  const xp = rk * Math.cos(uk);
+  const yp = rk * Math.sin(uk);
+  const clockBias = alm.af0 + alm.af1 * tk;
+  const isGeo = alm.system === "C" && BDS_GEO_PRNS.has(Number(alm.prn.slice(1)));
+  if (isGeo) {
+    const omegak2 = alm.omega0 + alm.omegaDot * tk - OMEGA_E * alm.toaSec;
+    const cosO2 = Math.cos(omegak2);
+    const sinO2 = Math.sin(omegak2);
+    const cosI2 = Math.cos(ik);
+    const sinI2 = Math.sin(ik);
+    const xg = xp * cosO2 - yp * cosI2 * sinO2;
+    const yg = xp * sinO2 + yp * cosI2 * cosO2;
+    const zg = yp * sinI2;
+    const phi = OMEGA_E * tk;
+    const cosPhi = Math.cos(phi);
+    const sinPhi = Math.sin(phi);
+    const COS5 = Math.cos(-5 * Math.PI / 180);
+    const SIN5 = Math.sin(-5 * Math.PI / 180);
+    return {
+      prn: alm.prn,
+      x: xg * cosPhi + yg * sinPhi * COS5 + zg * sinPhi * SIN5,
+      y: -xg * sinPhi + yg * cosPhi * COS5 + zg * cosPhi * SIN5,
+      z: -yg * SIN5 + zg * COS5,
+      clockBias
+    };
+  }
+  const omegak = alm.omega0 + (alm.omegaDot - OMEGA_E) * tk - OMEGA_E * alm.toaSec;
+  const cosO = Math.cos(omegak);
+  const sinO = Math.sin(omegak);
+  const cosI = Math.cos(ik);
+  const sinI = Math.sin(ik);
+  return {
+    prn: alm.prn,
+    x: xp * cosO - yp * cosI * sinO,
+    y: xp * sinO + yp * cosI * cosO,
+    z: yp * sinI,
+    clockBias
+  };
+}
+
+// src/orbit/almanac-glo.ts
+var C20 = -108263e-8;
+var J = -1.5 * C20;
+var AE = 6378.136;
+var MU = 398600.44;
+var OMEGA_Z = 7292115e-11;
+var I_MEAN = 63 * Math.PI / 180;
+var T_MEAN = 43200;
+var GLO_1996_UTC_MS = Date.UTC(1996, 0, 1) - 108e5;
+var DAY_MS = 864e5;
+var FOUR_YEARS_DAYS = 1461;
+function glonassAlmanacEpochMs(alm) {
+  const utcMs = GLO_1996_UTC_MS + ((alm.n4 - 1) * FOUR_YEARS_DAYS + (alm.nDay - 1)) * DAY_MS + alm.tLambda * 1e3;
+  return utcMs + getGpsLeap(new Date(utcMs)) * 1e3;
+}
+function c20Deltas(lam, tau, B, h, l, n, sinI, cosI) {
+  const sin2i = sinI * sinI;
+  const cos2i = cosI * cosI;
+  const s1 = Math.sin(lam);
+  const c1 = Math.cos(lam);
+  const s2 = Math.sin(2 * lam);
+  const c2 = Math.cos(2 * lam);
+  const s3 = Math.sin(3 * lam);
+  const c3 = Math.cos(3 * lam);
+  const s4 = Math.sin(4 * lam);
+  const c4 = Math.cos(4 * lam);
+  const daOverA = 2 * B * (1 - 1.5 * sin2i) * (l * c1 + h * s1) + B * sin2i * (0.5 * h * s1 - 0.5 * l * c1 + c2 + 3.5 * l * c3 + 3.5 * h * s3);
+  const dh = B * (1 - 1.5 * sin2i) * (l * n * tau + s1 + 1.5 * l * s2 - 1.5 * h * c2) - 0.25 * B * sin2i * (s1 - 7 / 3 * s3 + 5 * l * s2 - 8.5 * l * s4 + 8.5 * h * c4 + h * c2) + B * cos2i * (l * n * tau - 0.5 * l * s2);
+  const dl = B * (1 - 1.5 * sin2i) * (-h * n * tau + c1 + 1.5 * l * c2 + 1.5 * h * s2) - 0.25 * B * sin2i * (-c1 - 7 / 3 * c3 - 5 * h * s2 - 8.5 * l * c4 - 8.5 * h * s4 + l * c2) + B * cos2i * (-h * n * tau + 0.5 * h * s2);
+  const nodeBracket = n * tau + 3.5 * l * s1 - 2.5 * h * c1 - 0.5 * s2 - 7 / 6 * l * s3 + 7 / 6 * h * c3;
+  const dOmega = -B * cosI * nodeBracket;
+  const di = 0.5 * B * sinI * cosI * (-l * c1 + h * s1 + c2 + 7 / 3 * l * c3 + 7 / 3 * h * s3);
+  const dLambda = 2 * B * (1 - 1.5 * sin2i) * (n * tau + 1.75 * l * s1 - 1.75 * h * c1) + 3 * B * sin2i * (-(7 / 24) * h * c1 - 7 / 24 * l * s1 - 49 / 72 * h * c3 + 49 / 72 * l * s3 + 0.25 * s2) + B * cos2i * nodeBracket;
+  return { daOverA, dh, dl, dOmega, di, dLambda };
+}
+function glonassAlmanacPosition(alm, timeMs) {
+  const i = I_MEAN + alm.deltaI;
+  const sinI = Math.sin(i);
+  const cosI = Math.cos(i);
+  const sin2i = sinI * sinI;
+  const e = alm.epsilon;
+  const oneMinusE2 = 1 - e * e;
+  const Tdr = T_MEAN + alm.deltaT;
+  const n = 2 * Math.PI / Tdr;
+  const cosW = Math.cos(alm.omega);
+  let a = Math.cbrt((Tdr / (2 * Math.PI)) ** 2 * MU);
+  for (let k = 0; k < 10; k++) {
+    const p = a * oneMinusE2;
+    const tOsc = Tdr / (1 + 1.5 * C20 * (AE / p) ** 2 * ((2 - 2.5 * sin2i) * (Math.pow(oneMinusE2, 1.5) / (1 + e * cosW) ** 2) + (1 + e * cosW) ** 3 / oneMinusE2));
+    const aNext = Math.cbrt((tOsc / (2 * Math.PI)) ** 2 * MU);
+    const converged = Math.abs(aNext - a) < 1e-3;
+    a = aNext;
+    if (converged) break;
+  }
+  const tStar = (timeMs - glonassAlmanacEpochMs(alm)) / 1e3;
+  const W = Math.floor(tStar / Tdr);
+  const nodeShift = Tdr * W + alm.deltaTDot * W * W;
+  const omegaDot = 1.5 * C20 * n * (AE / a) ** 2 * cosI * oneMinusE2 ** -2;
+  const lambdaK = alm.lambda + (omegaDot - OMEGA_Z) * nodeShift;
+  const tau = tStar - nodeShift;
+  const h = e * Math.sin(alm.omega);
+  const l = e * cosW;
+  const E0 = 2 * Math.atan(Math.sqrt((1 - e) / (1 + e)) * Math.tan(-alm.omega / 2));
+  const M = E0 - e * Math.sin(E0);
+  const B = J * (AE / a) ** 2;
+  const d1 = c20Deltas(M + alm.omega, 0, B, h, l, n, sinI, cosI);
+  const d2 = c20Deltas(M + alm.omega + n * tau, tau, B, h, l, n, sinI, cosI);
+  const hi = h + (d2.dh - d1.dh);
+  const li = l + (d2.dl - d1.dl);
+  const epsI = Math.hypot(hi, li);
+  const omegaI = epsI === 0 ? 0 : Math.atan2(hi, li);
+  const aI = a + a * (d2.daOverA - d1.daOverA);
+  const iI = i + (d2.di - d1.di);
+  const omegaG = lambdaK + (d2.dOmega - d1.dOmega) - OMEGA_Z * tau;
+  const lambdaStar = M + alm.omega + n * tau + (d2.dLambda - d1.dLambda);
+  const Mi = lambdaStar - omegaI;
+  let E = Mi;
+  for (let k = 0; k < 30; k++) {
+    const next = Mi + epsI * Math.sin(E);
+    const converged = Math.abs(next - E) < 1e-12;
+    E = next;
+    if (converged) break;
+  }
+  const v = 2 * Math.atan(Math.sqrt((1 + epsI) / (1 - epsI)) * Math.tan(E / 2));
+  const u = v + omegaI;
+  const rKm = aI * (1 - epsI * Math.cos(E));
+  const cosU = Math.cos(u);
+  const sinU = Math.sin(u);
+  const cosO = Math.cos(omegaG);
+  const sinO = Math.sin(omegaG);
+  const cosIi = Math.cos(iI);
+  const sinIi = Math.sin(iI);
+  return {
+    prn: alm.prn,
+    x: 1e3 * rKm * (cosU * cosO - sinU * sinO * cosIi),
+    y: 1e3 * rKm * (cosU * sinO + sinU * cosO * cosIi),
+    z: 1e3 * rKm * sinU * sinIi,
+    clockBias: -alm.tau
+  };
+}
+
+// src/orbit/index.ts
+var GM_GPS2 = 3986005e8;
+var GM_GAL2 = 3986004418e5;
+var GM_BDS2 = 3986004418e5;
 var GM_GLO = 39860044e7;
 var BDS_GEO_MAX_INCLINATION_RAD = 0.1;
 var BDS_GEO_MIN_SEMIMAJOR_AXIS_M = 4e7;
@@ -7146,9 +8756,9 @@ var AE_GLO = 6378136;
 var J2_GLO = 108263e-8;
 var TWO_PI = 2 * Math.PI;
 function gmForSystem(sys) {
-  if (sys === "E") return GM_GAL;
-  if (sys === "C") return GM_BDS;
-  return GM_GPS;
+  if (sys === "E") return GM_GAL2;
+  if (sys === "C") return GM_BDS2;
+  return GM_GPS2;
 }
 var geoVelocityPass = false;
 function keplerPosition(eph, t) {
@@ -7484,10 +9094,10 @@ function selectBest(ephs, timeMs) {
   }
   return best;
 }
-var GPS_EPOCH_MS9 = START_GPS_TIME.getTime();
-var MS_PER_WEEK7 = 7 * 864e5;
+var GPS_EPOCH_MS13 = START_GPS_TIME.getTime();
+var MS_PER_WEEK9 = 7 * 864e5;
 var BDS_EPOCH_MS = START_BDS_TIME.getTime();
-var GAL_EPOCH_MS = GPS_EPOCH_MS9 + 1024 * MS_PER_WEEK7;
+var GAL_EPOCH_MS = GPS_EPOCH_MS13 + 1024 * MS_PER_WEEK9;
 function ephInfoToEphemeris(info) {
   const sys = info.prn.charAt(0);
   if (sys === "R") {
@@ -7538,11 +9148,11 @@ function ephInfoToEphemeris(info) {
   } else if (sys === "E") {
     epochMs = GAL_EPOCH_MS;
   } else {
-    epochMs = GPS_EPOCH_MS9;
-    const weeksNow = (info.lastReceived - GPS_EPOCH_MS9) / MS_PER_WEEK7;
+    epochMs = GPS_EPOCH_MS13;
+    const weeksNow = (info.lastReceived - GPS_EPOCH_MS13) / MS_PER_WEEK9;
     week += 1024 * Math.round((weeksNow - week) / 1024);
   }
-  const tocDate = new Date(epochMs + week * MS_PER_WEEK7 + tocSec * 1e3);
+  const tocDate = new Date(epochMs + week * MS_PER_WEEK9 + tocSec * 1e3);
   return {
     system: sys,
     prn: info.prn,
@@ -7968,7 +9578,7 @@ function klobucharDelay(coeffs, latRad, lonRad, azRad, elRad, gpsTowSec) {
 }
 
 // src/positioning/index.ts
-var GM_GPS2 = 3986005e8;
+var GM_GPS3 = 3986005e8;
 var F_REL = -4442807633e-19;
 function satClockCorrection(eph, tMs) {
   if (eph.system === "R" || eph.system === "S") {
@@ -7979,7 +9589,7 @@ function satClockCorrection(eph, tMs) {
   const dt = (tMs - k.tocDate.getTime()) / 1e3;
   const poly = k.af0 + k.af1 * dt + k.af2 * dt * dt;
   const a = k.sqrtA * k.sqrtA;
-  const n = Math.sqrt(GM_GPS2 / (a * a * a)) + k.deltaN;
+  const n = Math.sqrt(GM_GPS3 / (a * a * a)) + k.deltaN;
   const tk = dt;
   const Mk = k.m0 + n * tk;
   let Ek = Mk;
@@ -10523,6 +12133,8 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   WGS84_SEMI_MAJOR_AXIS,
   WGS84_SEMI_MINOR_AXIS,
   WarningAccumulator,
+  almanacEpochMs,
+  almanacSatPosition,
   analyzeQuality,
   applyHelmert,
   applyIonoDcb,
@@ -10619,6 +12231,8 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   getWeekNumber,
   getWeekOfYear,
   gloFreq,
+  glonassAlmanacEpochMs,
+  glonassAlmanacPosition,
   glonassPosition,
   greatCircleMidpoint,
   hdrLine,
@@ -10642,7 +12256,11 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   parseNovatelRange,
   parseRinexStream,
   parseSbfAlmanac,
+  parseSbfBdsNav,
   parseSbfCnav,
+  parseSbfGalNav,
+  parseSbfGloNav,
+  parseSbfHas,
   parseSbfIonoUtc,
   parseSbfMeas,
   parseSbfNav,