gnss-js 0.1.2 → 1.0.1

package/dist/rtcm3.cjs

@@ -0,0 +1,1512 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rtcm3/index.ts
+var rtcm3_exports = {};
+__export(rtcm3_exports, {
+  BitReader: () => BitReader,
+  RTCM3_MESSAGE_NAMES: () => RTCM3_MESSAGE_NAMES,
+  Rtcm3Decoder: () => Rtcm3Decoder,
+  createStationMeta: () => createStationMeta,
+  createStreamStats: () => createStreamStats,
+  decodeEphemeris: () => decodeEphemeris,
+  decodeMsmFull: () => decodeMsmFull,
+  msmEpochToDate: () => msmEpochToDate,
+  readString: () => readString,
+  resetGloFreqCache: () => resetGloFreqCache,
+  rtcm3Constellation: () => rtcm3Constellation,
+  updateStationMeta: () => updateStationMeta,
+  updateStreamStats: () => updateStreamStats
+});
+module.exports = __toCommonJS(rtcm3_exports);
+
+// src/rtcm3/decoder.ts
+var BitReader = class {
+  data;
+  bitPos = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  /** Read `n` bits as unsigned integer (max 53). */
+  readU(n) {
+    if (n === 0) return 0;
+    let val = 0;
+    for (let i = 0; i < n; i++) {
+      const byteIdx = this.bitPos + i >> 3;
+      const bitIdx = 7 - (this.bitPos + i & 7);
+      const bit = byteIdx < this.data.length ? this.data[byteIdx] >> bitIdx & 1 : 0;
+      val = val * 2 + bit;
+    }
+    this.bitPos += n;
+    return val;
+  }
+  /** Read `n` bits as signed (two's complement) integer. */
+  readS(n) {
+    const val = this.readU(n);
+    const half = 2 ** (n - 1);
+    return val >= half ? val - 2 ** n : val;
+  }
+  /** Read `n` bits as sign-magnitude integer (MSB = sign, rest = magnitude). */
+  readSM(n) {
+    const val = this.readU(n);
+    const half = 2 ** (n - 1);
+    const mag = val % half;
+    return val >= half ? -mag : mag;
+  }
+  /** Skip `n` bits. */
+  skip(n) {
+    this.bitPos += n;
+  }
+  get bitsLeft() {
+    return this.data.length * 8 - this.bitPos;
+  }
+};
+function crc24q(data, length) {
+  let crc = 0;
+  for (let i = 0; i < length; i++) {
+    crc ^= data[i] << 16;
+    for (let j = 0; j < 8; j++) {
+      crc <<= 1;
+      if (crc & 16777216) crc ^= 25578747;
+    }
+  }
+  return crc & 16777215;
+}
+var Rtcm3Decoder = class {
+  buffer = new Uint8Array(0);
+  /** Feed raw bytes and extract any complete RTCM3 frames. */
+  decode(data) {
+    const combined = new Uint8Array(this.buffer.length + data.length);
+    combined.set(this.buffer);
+    combined.set(data, this.buffer.length);
+    this.buffer = combined;
+    const frames = [];
+    while (this.buffer.length >= 6) {
+      const syncIdx = this.buffer.indexOf(211);
+      if (syncIdx === -1) {
+        this.buffer = new Uint8Array(0);
+        break;
+      }
+      if (syncIdx > 0) {
+        this.buffer = this.buffer.slice(syncIdx);
+      }
+      if (this.buffer.length < 3) break;
+      const reservedBits = this.buffer[1] >> 2 & 63;
+      if (reservedBits !== 0) {
+        this.buffer = this.buffer.slice(1);
+        continue;
+      }
+      const length = (this.buffer[1] & 3) << 8 | this.buffer[2];
+      if (length > 1023) {
+        this.buffer = this.buffer.slice(1);
+        continue;
+      }
+      const frameSize = 3 + length + 3;
+      if (this.buffer.length < frameSize) break;
+      const crcComputed = crc24q(this.buffer, 3 + length);
+      const crcReceived = this.buffer[3 + length] << 16 | this.buffer[3 + length + 1] << 8 | this.buffer[3 + length + 2];
+      if (crcComputed !== crcReceived) {
+        this.buffer = this.buffer.slice(1);
+        continue;
+      }
+      const payload = this.buffer.slice(3, 3 + length);
+      if (length >= 2) {
+        const messageType = payload[0] << 4 | payload[1] >> 4;
+        frames.push({ messageType, length, payload });
+      }
+      this.buffer = this.buffer.slice(frameSize);
+    }
+    if (this.buffer.length > 16384) {
+      const nextSync = this.buffer.indexOf(211, 1);
+      this.buffer = nextSync !== -1 ? this.buffer.slice(nextSync) : new Uint8Array(0);
+    }
+    return frames;
+  }
+  reset() {
+    this.buffer = new Uint8Array(0);
+  }
+};
+
+// src/rtcm3/ephemeris.ts
+var PI = Math.PI;
+function readString(r, nChars) {
+  const bytes = [];
+  for (let i = 0; i < nChars; i++) bytes.push(r.readU(8));
+  return String.fromCharCode(...bytes).replace(/\0+$/, "").trim();
+}
+function decodeGpsEphemeris(payload) {
+  if (payload.length < 60) return null;
+  const r = new BitReader(payload);
+  r.skip(12);
+  const svId = r.readU(6);
+  const week = r.readU(10);
+  const ura = r.readU(4);
+  const l2Codes = r.readU(2);
+  const idot = r.readS(14) * 2 ** -43 * PI;
+  const iode = r.readU(8);
+  const toc = r.readU(16) * 16;
+  const af2 = r.readS(8) * 2 ** -55;
+  const af1 = r.readS(16) * 2 ** -43;
+  const af0 = r.readS(22) * 2 ** -31;
+  const iodc = r.readU(10);
+  const crs = r.readS(16) * 2 ** -5;
+  const deltaN = r.readS(16) * 2 ** -43 * PI;
+  const m0 = r.readS(32) * 2 ** -31 * PI;
+  const cuc = r.readS(16) * 2 ** -29;
+  const e = r.readU(32) * 2 ** -33;
+  const cus = r.readS(16) * 2 ** -29;
+  const sqrtA = r.readU(32) * 2 ** -19;
+  const toe = r.readU(16) * 16;
+  const cic = r.readS(16) * 2 ** -29;
+  const omega0 = r.readS(32) * 2 ** -31 * PI;
+  const cis = r.readS(16) * 2 ** -29;
+  const i0 = r.readS(32) * 2 ** -31 * PI;
+  const crc = r.readS(16) * 2 ** -5;
+  const argPerigee = r.readS(32) * 2 ** -31 * PI;
+  const omegaDot = r.readS(24) * 2 ** -43 * PI;
+  const tgd = r.readS(8) * 2 ** -31;
+  const health = r.readU(6);
+  const l2PFlag = r.readU(1);
+  const fitInterval = r.readU(1);
+  return {
+    prn: `G${String(svId).padStart(2, "0")}`,
+    constellation: "GPS",
+    health,
+    lastReceived: Date.now(),
+    messageType: 1019,
+    week,
+    ura,
+    toc,
+    toe,
+    sqrtA,
+    eccentricity: e,
+    inclination: i0,
+    omega0,
+    omegaDot,
+    argPerigee,
+    meanAnomaly: m0,
+    deltaN,
+    idot,
+    crs,
+    crc,
+    cuc,
+    cus,
+    cic,
+    cis,
+    af0,
+    af1,
+    af2,
+    iode,
+    iodc,
+    tgd,
+    l2Codes,
+    l2PFlag,
+    fitInterval
+  };
+}
+function decodeGlonassEphemeris(payload) {
+  if (payload.length < 43) return null;
+  const r = new BitReader(payload);
+  r.skip(12);
+  const slot = r.readU(6);
+  const freqChannel = r.readU(5) - 7;
+  r.skip(1 + 1 + 2);
+  const tkHours = r.readU(5);
+  const tkMins = r.readU(6);
+  const tk30s = r.readU(1);
+  const tkMoscow = tkHours * 3600 + tkMins * 60 + tk30s * 30;
+  const tk = ((tkMoscow - 3 * 3600) % 86400 + 86400) % 86400;
+  const healthBn = r.readU(1);
+  r.skip(1);
+  const tb = r.readU(7) * 15;
+  const vx = r.readSM(24) * 2 ** -20;
+  const x = r.readSM(27) * 2 ** -11;
+  const ax = r.readSM(5) * 2 ** -30;
+  const vy = r.readSM(24) * 2 ** -20;
+  const y = r.readSM(27) * 2 ** -11;
+  const ay = r.readSM(5) * 2 ** -30;
+  const vz = r.readSM(24) * 2 ** -20;
+  const z = r.readSM(27) * 2 ** -11;
+  const azz = r.readSM(5) * 2 ** -30;
+  r.skip(1);
+  const gammaN = r.readSM(11) * 2 ** -40;
+  r.skip(2);
+  r.skip(1);
+  const tauN = r.readSM(22) * 2 ** -30;
+  const deltaTauN = r.readSM(5) * 2 ** -30;
+  const en = r.readU(5);
+  const p4 = r.readU(1);
+  const ft = r.readU(4);
+  const nt = r.readU(11);
+  const satType = r.readU(2);
+  const additionalData = r.readU(1);
+  const tauC = additionalData ? r.readSM(32) * 2 ** -31 : void 0;
+  const n4 = additionalData ? r.readU(5) : void 0;
+  const tauGPS = additionalData ? r.readSM(22) * 2 ** -30 : void 0;
+  return {
+    prn: `R${String(slot).padStart(2, "0")}`,
+    constellation: "GLONASS",
+    health: healthBn,
+    lastReceived: Date.now(),
+    messageType: 1020,
+    freqChannel,
+    tk,
+    x,
+    y,
+    z,
+    vx,
+    vy,
+    vz,
+    ax,
+    ay,
+    az: azz,
+    tb,
+    gammaN,
+    af0: tauN,
+    deltaTauN,
+    en,
+    p4,
+    ft,
+    nt,
+    satType,
+    tauC,
+    n4,
+    tauGPS
+  };
+}
+function decodeGalileoEphemeris(payload, msgType) {
+  if (payload.length < 62) return null;
+  const r = new BitReader(payload);
+  r.skip(12);
+  const svId = r.readU(6);
+  const week = r.readU(12);
+  const iode = r.readU(10);
+  const sisa = r.readU(8);
+  const idot = r.readS(14) * 2 ** -43 * PI;
+  const toc = r.readU(14) * 60;
+  const af2 = r.readS(6) * 2 ** -59;
+  const af1 = r.readS(21) * 2 ** -46;
+  const af0 = r.readS(31) * 2 ** -34;
+  const crs = r.readS(16) * 2 ** -5;
+  const deltaN = r.readS(16) * 2 ** -43 * PI;
+  const m0 = r.readS(32) * 2 ** -31 * PI;
+  const cuc = r.readS(16) * 2 ** -29;
+  const e = r.readU(32) * 2 ** -33;
+  const cus = r.readS(16) * 2 ** -29;
+  const sqrtA = r.readU(32) * 2 ** -19;
+  const toe = r.readU(14) * 60;
+  const cic = r.readS(16) * 2 ** -29;
+  const omega0 = r.readS(32) * 2 ** -31 * PI;
+  const cis = r.readS(16) * 2 ** -29;
+  const i0 = r.readS(32) * 2 ** -31 * PI;
+  const crc = r.readS(16) * 2 ** -5;
+  const argPerigee = r.readS(32) * 2 ** -31 * PI;
+  const omegaDot = r.readS(24) * 2 ** -43 * PI;
+  const bgdE5aE1 = r.readS(10) * 2 ** -32;
+  let health;
+  let bgdE5bE1;
+  let e5aDataInvalid;
+  let e5bDataInvalid;
+  let e1bHealth;
+  let e1bDataInvalid;
+  if (msgType === 1045) {
+    health = r.readU(2);
+    e5aDataInvalid = r.readU(1);
+  } else {
+    bgdE5bE1 = r.readS(10) * 2 ** -32;
+    health = r.readU(2);
+    e5bDataInvalid = r.readU(1);
+    e1bHealth = r.readU(2);
+    e1bDataInvalid = r.readU(1);
+  }
+  return {
+    prn: `E${String(svId).padStart(2, "0")}`,
+    constellation: "Galileo",
+    health,
+    lastReceived: Date.now(),
+    messageType: msgType,
+    week,
+    ura: sisa,
+    toc,
+    toe,
+    sqrtA,
+    eccentricity: e,
+    inclination: i0,
+    omega0,
+    omegaDot,
+    argPerigee,
+    meanAnomaly: m0,
+    deltaN,
+    idot,
+    crs,
+    crc,
+    cuc,
+    cus,
+    cic,
+    cis,
+    af0,
+    af1,
+    af2,
+    iode,
+    bgdE5aE1,
+    bgdE5bE1,
+    e5aDataInvalid,
+    e5bDataInvalid,
+    e1bHealth,
+    e1bDataInvalid
+  };
+}
+function decodeBdsEphemeris(payload) {
+  if (payload.length < 63) return null;
+  const r = new BitReader(payload);
+  r.skip(12);
+  const svId = r.readU(6);
+  const week = r.readU(13);
+  const ura = r.readU(4);
+  const idot = r.readS(14) * 2 ** -43 * PI;
+  const iode = r.readU(5);
+  const toc = r.readU(17) * 8;
+  const af2 = r.readS(11) * 2 ** -66;
+  const af1 = r.readS(22) * 2 ** -50;
+  const af0 = r.readS(24) * 2 ** -33;
+  const aodc = r.readU(5);
+  const crs = r.readS(18) * 2 ** -6;
+  const deltaN = r.readS(16) * 2 ** -43 * PI;
+  const m0 = r.readS(32) * 2 ** -31 * PI;
+  const cuc = r.readS(18) * 2 ** -31;
+  const e = r.readU(32) * 2 ** -33;
+  const cus = r.readS(18) * 2 ** -31;
+  const sqrtA = r.readU(32) * 2 ** -19;
+  const toe = r.readU(17) * 8;
+  const cic = r.readS(18) * 2 ** -31;
+  const omega0 = r.readS(32) * 2 ** -31 * PI;
+  const cis = r.readS(18) * 2 ** -31;
+  const i0 = r.readS(32) * 2 ** -31 * PI;
+  const crc = r.readS(18) * 2 ** -6;
+  const argPerigee = r.readS(32) * 2 ** -31 * PI;
+  const omegaDot = r.readS(24) * 2 ** -43 * PI;
+  const tgd1 = r.readS(10) * 1e-10;
+  const tgd2 = r.readS(10) * 1e-10;
+  const health = r.readU(1);
+  return {
+    prn: `C${String(svId).padStart(2, "0")}`,
+    constellation: "BeiDou",
+    health,
+    lastReceived: Date.now(),
+    messageType: 1042,
+    week,
+    ura,
+    toc,
+    toe,
+    sqrtA,
+    eccentricity: e,
+    inclination: i0,
+    omega0,
+    omegaDot,
+    argPerigee,
+    meanAnomaly: m0,
+    deltaN,
+    idot,
+    crs,
+    crc,
+    cuc,
+    cus,
+    cic,
+    cis,
+    af0,
+    af1,
+    af2,
+    iode,
+    aodc,
+    tgd1,
+    tgd2
+  };
+}
+function decodeSbasEphemeris(payload) {
+  if (payload.length < 29) return null;
+  const r = new BitReader(payload);
+  r.skip(12);
+  const svId = r.readU(6);
+  const iodn = r.readU(8);
+  const t0 = r.readU(13) * 16;
+  const ura = r.readU(4);
+  const xg = r.readS(30) * 0.08;
+  const yg = r.readS(30) * 0.08;
+  const zg = r.readS(25) * 0.4;
+  const dxg = r.readS(17) * 625e-6;
+  const dyg = r.readS(17) * 625e-6;
+  const dzg = r.readS(18) * 4e-3;
+  const ddxg = r.readS(10) * 125e-7;
+  const ddyg = r.readS(10) * 125e-7;
+  const ddzg = r.readS(10) * 625e-7;
+  const af0 = r.readS(12) * 2 ** -31;
+  const af1 = r.readS(8) * 2 ** -40;
+  const prn = 120 + svId;
+  return {
+    prn: `S${String(prn).padStart(3, "0")}`,
+    constellation: "SBAS",
+    health: 0,
+    // SBAS 1043 has no explicit health bit
+    lastReceived: Date.now(),
+    messageType: 1043,
+    iode: iodn,
+    toc: t0,
+    ura,
+    // Store SBAS geo position as GLONASS-like state vector (km, km/s, km/s²)
+    x: xg / 1e3,
+    y: yg / 1e3,
+    z: zg / 1e3,
+    vx: dxg / 1e3,
+    vy: dyg / 1e3,
+    vz: dzg / 1e3,
+    ax: ddxg / 1e3,
+    ay: ddyg / 1e3,
+    az: ddzg / 1e3,
+    af0,
+    af1
+  };
+}
+function decodeQzssEphemeris(payload) {
+  if (payload.length < 60) return null;
+  const r = new BitReader(payload);
+  r.skip(12);
+  const svId = r.readU(4);
+  if (svId < 1 || svId > 10) return null;
+  const toc = r.readU(16) * 16;
+  const af2 = r.readS(8) * 2 ** -55;
+  const af1 = r.readS(16) * 2 ** -43;
+  const af0 = r.readS(22) * 2 ** -31;
+  const iode = r.readU(8);
+  const crs = r.readS(16) * 2 ** -5;
+  const deltaN = r.readS(16) * 2 ** -43 * PI;
+  const m0 = r.readS(32) * 2 ** -31 * PI;
+  const cuc = r.readS(16) * 2 ** -29;
+  const e = r.readU(32) * 2 ** -33;
+  const cus = r.readS(16) * 2 ** -29;
+  const sqrtA = r.readU(32) * 2 ** -19;
+  const toe = r.readU(16) * 16;
+  const cic = r.readS(16) * 2 ** -29;
+  const omega0 = r.readS(32) * 2 ** -31 * PI;
+  const cis = r.readS(16) * 2 ** -29;
+  const i0 = r.readS(32) * 2 ** -31 * PI;
+  const crc = r.readS(16) * 2 ** -5;
+  const argPerigee = r.readS(32) * 2 ** -31 * PI;
+  const omegaDot = r.readS(24) * 2 ** -43 * PI;
+  const idot = r.readS(14) * 2 ** -43 * PI;
+  const l2Codes = r.readU(2);
+  const week = r.readU(10);
+  const ura = r.readU(4);
+  const health = r.readU(6);
+  const tgd = r.readS(8) * 2 ** -31;
+  const iodc = r.readU(10);
+  const fitInterval = r.readU(1);
+  return {
+    prn: `J${String(svId).padStart(2, "0")}`,
+    constellation: "QZSS",
+    health,
+    lastReceived: Date.now(),
+    messageType: 1044,
+    week,
+    ura,
+    toc,
+    toe,
+    sqrtA,
+    eccentricity: e,
+    inclination: i0,
+    omega0,
+    omegaDot,
+    argPerigee,
+    meanAnomaly: m0,
+    deltaN,
+    idot,
+    crs,
+    crc,
+    cuc,
+    cus,
+    cic,
+    cis,
+    af0,
+    af1,
+    af2,
+    iode,
+    iodc,
+    tgd,
+    l2Codes,
+    fitInterval
+  };
+}
+function decodeEphemeris(frame) {
+  try {
+    switch (frame.messageType) {
+      case 1019:
+        return decodeGpsEphemeris(frame.payload);
+      case 1020:
+        return decodeGlonassEphemeris(frame.payload);
+      case 1042:
+        return decodeBdsEphemeris(frame.payload);
+      case 1043:
+        return decodeSbasEphemeris(frame.payload);
+      case 1044:
+        return decodeQzssEphemeris(frame.payload);
+      case 1045:
+        return decodeGalileoEphemeris(frame.payload, 1045);
+      case 1046:
+        return decodeGalileoEphemeris(frame.payload, 1046);
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+// src/constants/gnss.ts
+var C_LIGHT = 299792458;
+var GLO_F1_BASE = 1602e6;
+var GLO_F1_STEP = 562500;
+var GLO_F2_BASE = 1246e6;
+var GLO_F2_STEP = 437500;
+
+// src/rtcm3/msm.ts
+var GPS_L1 = 157542e4;
+var GPS_L2 = 12276e5;
+var GPS_L5 = 117645e4;
+var GLO_L1a = 1600995e3;
+var GLO_L2a = 124806e4;
+var GLO_L3 = 1202025e3;
+var GAL_E1 = 157542e4;
+var GAL_E5a = 117645e4;
+var GAL_E5b = 120714e4;
+var GAL_E5 = 1191795e3;
+var GAL_E6 = 127875e4;
+var BDS_B1 = 1561098e3;
+var BDS_B3 = 126852e4;
+var BDS_B2 = 120714e4;
+var BDS_B1C = 157542e4;
+var BDS_B2a = 117645e4;
+var BDS_B2b = 120714e4;
+var QZSS_L6 = 127875e4;
+var NAVIC_S = 2492028e3;
+var EMPTY = { code: "", freq: 0 };
+function sd(code, freq) {
+  return { code, freq };
+}
+var GPS_SIGNALS = [
+  EMPTY,
+  sd("1C", GPS_L1),
+  sd("1P", GPS_L1),
+  sd("1W", GPS_L1),
+  // 1-3
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 4-6
+  sd("2C", GPS_L2),
+  sd("2P", GPS_L2),
+  sd("2W", GPS_L2),
+  // 7-9
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 10-13
+  sd("2S", GPS_L2),
+  sd("2L", GPS_L2),
+  sd("2X", GPS_L2),
+  // 14-16
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 17-20
+  sd("5I", GPS_L5),
+  sd("5Q", GPS_L5),
+  sd("5X", GPS_L5),
+  // 21-23
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 24-28
+  sd("1S", GPS_L1),
+  sd("1L", GPS_L1),
+  sd("1X", GPS_L1)
+  // 29-31
+];
+var GLO_SIGNALS = [
+  EMPTY,
+  sd("1C", 0),
+  sd("1P", 0),
+  EMPTY,
+  // 1-3 (L1, freq per-sat)
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 4-6
+  sd("2C", 1),
+  sd("2P", 1),
+  // 7-8 (L2, marker=1)
+  sd("4A", GLO_L1a),
+  sd("4B", GLO_L1a),
+  sd("4X", GLO_L1a),
+  // 9-11
+  sd("6A", GLO_L2a),
+  sd("6B", GLO_L2a),
+  sd("6X", GLO_L2a),
+  // 12-14
+  sd("3I", GLO_L3),
+  sd("3Q", GLO_L3),
+  sd("3X", GLO_L3),
+  // 15-17
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 18-24
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY
+  // 25-31
+];
+var GAL_SIGNALS = [
+  EMPTY,
+  sd("1C", GAL_E1),
+  sd("1A", GAL_E1),
+  sd("1B", GAL_E1),
+  // 1-3
+  sd("1X", GAL_E1),
+  sd("1Z", GAL_E1),
+  EMPTY,
+  // 4-6
+  sd("6C", GAL_E6),
+  sd("6A", GAL_E6),
+  sd("6B", GAL_E6),
+  // 7-9
+  sd("6X", GAL_E6),
+  sd("6Z", GAL_E6),
+  EMPTY,
+  // 10-12
+  sd("7I", GAL_E5b),
+  sd("7Q", GAL_E5b),
+  sd("7X", GAL_E5b),
+  // 13-15
+  EMPTY,
+  // 16
+  sd("8I", GAL_E5),
+  sd("8Q", GAL_E5),
+  sd("8X", GAL_E5),
+  // 17-19
+  EMPTY,
+  // 20
+  sd("5I", GAL_E5a),
+  sd("5Q", GAL_E5a),
+  sd("5X", GAL_E5a),
+  // 21-23
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY
+  // 24-31
+];
+var BDS_SIGNALS = [
+  EMPTY,
+  sd("2I", BDS_B1),
+  sd("2Q", BDS_B1),
+  sd("2X", BDS_B1),
+  // 1-3
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 4-6
+  sd("6I", BDS_B3),
+  sd("6Q", BDS_B3),
+  sd("6X", BDS_B3),
+  // 7-9
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 10-12
+  sd("7I", BDS_B2),
+  sd("7Q", BDS_B2),
+  sd("7X", BDS_B2),
+  // 13-15
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 16-20
+  sd("5D", BDS_B2a),
+  sd("5P", BDS_B2a),
+  sd("5X", BDS_B2a),
+  // 21-23
+  sd("7D", BDS_B2b),
+  // 24
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 25-28
+  sd("1D", BDS_B1C),
+  sd("1P", BDS_B1C),
+  sd("1X", BDS_B1C)
+  // 29-31
+];
+var QZSS_SIGNALS = [
+  EMPTY,
+  sd("1C", GPS_L1),
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 1-6
+  EMPTY,
+  sd("6S", QZSS_L6),
+  sd("6L", QZSS_L6),
+  sd("6X", QZSS_L6),
+  // 8-10
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 11-13
+  sd("2S", GPS_L2),
+  sd("2L", GPS_L2),
+  sd("2X", GPS_L2),
+  // 14-16
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 17-20
+  sd("5I", GPS_L5),
+  sd("5Q", GPS_L5),
+  sd("5X", GPS_L5),
+  // 21-23
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  // 24-28
+  sd("1S", GPS_L1),
+  sd("1L", GPS_L1),
+  sd("1X", GPS_L1)
+  // 29-31
+];
+var NAVIC_SIGNALS = [
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  EMPTY,
+  sd("9A", NAVIC_S),
+  ...Array.from({ length: 24 }, () => EMPTY)
+];
+var SBAS_SIGNALS = GPS_SIGNALS;
+function signalTable(sys) {
+  switch (sys) {
+    case "G":
+      return GPS_SIGNALS;
+    case "R":
+      return GLO_SIGNALS;
+    case "E":
+      return GAL_SIGNALS;
+    case "C":
+      return BDS_SIGNALS;
+    case "J":
+      return QZSS_SIGNALS;
+    case "I":
+      return NAVIC_SIGNALS;
+    case "S":
+      return SBAS_SIGNALS;
+    default:
+      return GPS_SIGNALS;
+  }
+}
+var BitReader2 = class {
+  data;
+  pos;
+  constructor(data, startBit = 0) {
+    this.data = data;
+    this.pos = startBit;
+  }
+  /** Read unsigned value of numBits bits (max 53) */
+  u(numBits) {
+    let val = 0;
+    for (let i = 0; i < numBits; i++) {
+      const byteIdx = this.pos + i >>> 3;
+      const bitIdx = 7 - (this.pos + i & 7);
+      const bit = byteIdx < this.data.length ? this.data[byteIdx] >>> bitIdx & 1 : 0;
+      val = val * 2 + bit;
+    }
+    this.pos += numBits;
+    return val;
+  }
+  /** Read signed value (two's complement) */
+  s(numBits) {
+    const raw = this.u(numBits);
+    const half = 2 ** (numBits - 1);
+    return raw >= half ? raw - 2 ** numBits : raw;
+  }
+  /** Skip bits */
+  skip(n) {
+    this.pos += n;
+  }
+  /** Current bit position */
+  get position() {
+    return this.pos;
+  }
+};
+var gloFreqNum = new Int8Array(64).fill(-128);
+function gloWavelength(satIdx, freqMarker) {
+  const k = gloFreqNum[satIdx];
+  if (k === -128) return 0;
+  if (freqMarker === 0) {
+    return C_LIGHT / (GLO_F1_BASE + k * GLO_F1_STEP);
+  } else if (freqMarker === 1) {
+    return C_LIGHT / (GLO_F2_BASE + k * GLO_F2_STEP);
+  }
+  return freqMarker > 0 ? C_LIGHT / freqMarker : 0;
+}
+var LTI_TABLE_4BIT = [
+  0,
+  0.032,
+  0.064,
+  0.128,
+  0.256,
+  0.512,
+  1.024,
+  2.048,
+  4.096,
+  8.192,
+  16.384,
+  32.768,
+  65.536,
+  131.072,
+  262.144,
+  524.288
+];
+function lockTimeSec(msmType, lti) {
+  const variant = msmType % 10;
+  if (variant <= 5) {
+    return LTI_TABLE_4BIT[lti] ?? 0;
+  }
+  if (lti < 64) return lti;
+  if (lti < 96) return (lti - 64) * 2 + 64;
+  if (lti < 128) return (lti - 96) * 4 + 128;
+  if (lti < 160) return (lti - 128) * 8 + 256;
+  if (lti < 192) return (lti - 160) * 16 + 512;
+  if (lti < 224) return (lti - 192) * 32 + 1024;
+  if (lti < 256) return (lti - 224) * 64 + 2048;
+  if (lti < 288) return (lti - 256) * 128 + 4096;
+  if (lti < 320) return (lti - 288) * 256 + 8192;
+  if (lti < 352) return (lti - 320) * 512 + 16384;
+  if (lti < 384) return (lti - 352) * 1024 + 32768;
+  if (lti < 416) return (lti - 384) * 2048 + 65536;
+  if (lti < 448) return (lti - 416) * 4096 + 131072;
+  if (lti < 480) return (lti - 448) * 8192 + 262144;
+  if (lti < 512) return (lti - 480) * 16384 + 524288;
+  if (lti < 544) return (lti - 512) * 32768 + 1048576;
+  if (lti < 576) return (lti - 544) * 65536 + 2097152;
+  if (lti < 608) return (lti - 576) * 131072 + 4194304;
+  if (lti < 640) return (lti - 608) * 262144 + 8388608;
+  if (lti < 672) return (lti - 640) * 524288 + 16777216;
+  if (lti < 704) return (lti - 672) * 1048576 + 33554432;
+  return (lti - 704) * 2097152 + 67108864;
+}
+function msmSystem(type) {
+  if (type >= 1071 && type <= 1077) return "G";
+  if (type >= 1081 && type <= 1087) return "R";
+  if (type >= 1091 && type <= 1097) return "E";
+  if (type >= 1101 && type <= 1107) return "S";
+  if (type >= 1111 && type <= 1117) return "J";
+  if (type >= 1121 && type <= 1127) return "C";
+  if (type >= 1131 && type <= 1137) return "I";
+  return "";
+}
+function satPrn(sys, satIdx1) {
+  const prefix = sys === "S" ? "S" : sys;
+  const num = sys === "S" ? satIdx1 + 119 : satIdx1;
+  return `${prefix}${String(num).padStart(2, "0")}`;
+}
+function decodeMsmFull(frame) {
+  const type = frame.messageType;
+  const sys = msmSystem(type);
+  if (!sys) return null;
+  const variant = type % 10;
+  if (variant < 4 || variant > 7) return null;
+  const payload = frame.payload;
+  if (!payload || payload.length < 10) return null;
+  try {
+    const bits = new BitReader2(payload);
+    bits.skip(12);
+    bits.skip(12);
+    const epochMs = bits.u(30);
+    bits.skip(1);
+    bits.skip(3);
+    bits.skip(7);
+    bits.skip(2);
+    bits.skip(2);
+    bits.skip(1);
+    bits.skip(3);
+    const satMaskHi = bits.u(32) >>> 0;
+    const satMaskLo = bits.u(32) >>> 0;
+    const satIndices = [];
+    for (let i = 0; i < 32; i++) {
+      if (satMaskHi & 1 << 31 - i) satIndices.push(i + 1);
+    }
+    for (let i = 0; i < 32; i++) {
+      if (satMaskLo & 1 << 31 - i) satIndices.push(i + 33);
+    }
+    const numSat = satIndices.length;
+    if (numSat === 0) return null;
+    const sigMask = bits.u(32) >>> 0;
+    const sigIndices = [];
+    for (let i = 0; i < 32; i++) {
+      if (sigMask & 1 << 31 - i) sigIndices.push(i);
+    }
+    const numSig = sigIndices.length;
+    if (numSig === 0) return null;
+    const numCells = numSat * numSig;
+    const cellMask = [];
+    for (let i = 0; i < numCells; i++) {
+      cellMask.push(bits.u(1) === 1);
+    }
+    let activeCells = 0;
+    for (const c of cellMask) if (c) activeCells++;
+    if (activeCells === 0) return null;
+    const rrint = new Float64Array(numSat);
+    const rrmod = new Float64Array(numSat);
+    const extsat = new Int8Array(numSat);
+    const rdop = new Float64Array(numSat);
+    if (variant === 4 || variant === 6) {
+      for (let j = 0; j < numSat; j++) rrint[j] = bits.u(8);
+      for (let j = 0; j < numSat; j++) rrmod[j] = bits.u(10) / 1024;
+    } else {
+      for (let j = 0; j < numSat; j++) rrint[j] = bits.u(8);
+      for (let j = 0; j < numSat; j++) extsat[j] = bits.u(4);
+      for (let j = 0; j < numSat; j++) rrmod[j] = bits.u(10) / 1024;
+      for (let j = 0; j < numSat; j++) rdop[j] = bits.s(14) * 1;
+    }
+    if (sys === "R") {
+      for (let j = 0; j < numSat; j++) {
+        const slot = satIndices[j];
+        if (extsat[j] !== 0) {
+          gloFreqNum[slot - 1] = extsat[j] - 7;
+        }
+      }
+    }
+    const psr = new Float64Array(activeCells);
+    const cp = new Float64Array(activeCells);
+    const ll = new Uint16Array(activeCells);
+    const hc = new Uint8Array(activeCells);
+    const cnr = new Float64Array(activeCells);
+    const dop = new Float64Array(activeCells);
+    psr.fill(-1e30);
+    cp.fill(-1e30);
+    dop.fill(-1e30);
+    if (variant === 4) {
+      for (let i = 0; i < activeCells; i++) psr[i] = bits.s(15) / 2 ** 24;
+      for (let i = 0; i < activeCells; i++) cp[i] = bits.s(22) / 2 ** 29;
+      for (let i = 0; i < activeCells; i++) ll[i] = bits.u(4);
+      for (let i = 0; i < activeCells; i++) hc[i] = bits.u(1);
+      for (let i = 0; i < activeCells; i++) cnr[i] = bits.u(6);
+    } else if (variant === 5) {
+      for (let i = 0; i < activeCells; i++) psr[i] = bits.s(15) / 2 ** 24;
+      for (let i = 0; i < activeCells; i++) cp[i] = bits.s(22) / 2 ** 29;
+      for (let i = 0; i < activeCells; i++) ll[i] = bits.u(4);
+      for (let i = 0; i < activeCells; i++) hc[i] = bits.u(1);
+      for (let i = 0; i < activeCells; i++) cnr[i] = bits.u(6);
+      for (let i = 0; i < activeCells; i++) dop[i] = bits.s(15) * 1e-4;
+    } else if (variant === 6) {
+      for (let i = 0; i < activeCells; i++) psr[i] = bits.s(20) / 2 ** 29;
+      for (let i = 0; i < activeCells; i++) cp[i] = bits.s(24) / 2 ** 31;
+      for (let i = 0; i < activeCells; i++) ll[i] = bits.u(10);
+      for (let i = 0; i < activeCells; i++) hc[i] = bits.u(1);
+      for (let i = 0; i < activeCells; i++) cnr[i] = bits.u(10) / 16;
+    } else {
+      for (let i = 0; i < activeCells; i++) psr[i] = bits.s(20) / 2 ** 29;
+      for (let i = 0; i < activeCells; i++) cp[i] = bits.s(24) / 2 ** 31;
+      for (let i = 0; i < activeCells; i++) ll[i] = bits.u(10);
+      for (let i = 0; i < activeCells; i++) hc[i] = bits.u(1);
+      for (let i = 0; i < activeCells; i++) cnr[i] = bits.u(10) / 16;
+      for (let i = 0; i < activeCells; i++) dop[i] = bits.s(15) * 1e-4;
+    }
+    const sigTable = signalTable(sys);
+    const observations = [];
+    let cellIdx = 0;
+    for (let s = 0; s < numSat; s++) {
+      const satIdx1 = satIndices[s];
+      const prn = satPrn(sys, satIdx1);
+      const roughRange_ms = rrint[s] + rrmod[s];
+      const roughRange_m = roughRange_ms * C_LIGHT / 1e3;
+      const roughRate_ms = rdop[s];
+      const signals = [];
+      for (let g = 0; g < numSig; g++) {
+        const maskIdx = s * numSig + g;
+        if (!cellMask[maskIdx]) continue;
+        const sigIdx = sigIndices[g];
+        const sigDef = sigTable[sigIdx] ?? EMPTY;
+        if (!sigDef.code) {
+          cellIdx++;
+          continue;
+        }
+        let wavelength;
+        if (sys === "R" && (sigDef.freq === 0 || sigDef.freq === 1)) {
+          wavelength = gloWavelength(satIdx1 - 1, sigDef.freq);
+        } else if (sigDef.freq > 0) {
+          wavelength = C_LIGHT / sigDef.freq;
+        } else {
+          wavelength = 0;
+        }
+        const signal = {
+          rinexCode: sigDef.code,
+          wavelength
+        };
+        const psrVal = psr[cellIdx];
+        if (psrVal > -1 / (1 << 10)) {
+          signal.pseudorange = psrVal * C_LIGHT / 1e3 + roughRange_m;
+        }
+        const cpVal = cp[cellIdx];
+        if (cpVal > -1 / (1 << 8) && wavelength > 0) {
+          signal.phase = cpVal * C_LIGHT / 1e3 / wavelength + roughRange_m / wavelength;
+        }
+        if (variant === 5 || variant === 7) {
+          const dopVal = dop[cellIdx];
+          if (dopVal > -1.6384 && wavelength > 0) {
+            signal.doppler = -(dopVal + roughRate_ms) / wavelength;
+          }
+        }
+        const cnrVal = cnr[cellIdx];
+        if (cnrVal > 0) {
+          signal.cn0 = cnrVal;
+        }
+        signal.lockTime = lockTimeSec(type, ll[cellIdx]);
+        signal.halfCycle = hc[cellIdx] === 1;
+        signals.push(signal);
+        cellIdx++;
+      }
+      if (signals.length > 0) {
+        observations.push({ prn, system: sys, signals });
+      }
+    }
+    return {
+      messageType: type,
+      epochMs,
+      system: sys,
+      observations
+    };
+  } catch {
+    return null;
+  }
+}
+var GPS_EPOCH = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK = 6048e5;
+function msmEpochToDate(sys, epochMs, refTime = /* @__PURE__ */ new Date()) {
+  const refMs = refTime.getTime();
+  if (sys === "R") {
+    const dayOfWeek = epochMs >>> 27 & 7;
+    const msOfDay = epochMs & 134217727;
+    const utcDay = new Date(refMs).getUTCDay();
+    const diff = dayOfWeek - utcDay;
+    const dayMs = 864e5;
+    let t2 = refMs - refMs % dayMs + diff * dayMs + msOfDay - 3 * 36e5;
+    while (t2 - refMs > 3 * dayMs) t2 -= 7 * dayMs;
+    while (refMs - t2 > 3 * dayMs) t2 += 7 * dayMs;
+    return new Date(t2);
+  }
+  if (sys === "C") {
+    const BDS_EPOCH = Date.UTC(2006, 0, 1) - 14e3;
+    const weeksSinceEpoch2 = Math.floor((refMs - BDS_EPOCH) / MS_PER_WEEK);
+    let t2 = BDS_EPOCH + weeksSinceEpoch2 * MS_PER_WEEK + epochMs;
+    if (t2 - refMs > MS_PER_WEEK / 2) t2 -= MS_PER_WEEK;
+    else if (refMs - t2 > MS_PER_WEEK / 2) t2 += MS_PER_WEEK;
+    return new Date(t2);
+  }
+  const weeksSinceEpoch = Math.floor((refMs - GPS_EPOCH) / MS_PER_WEEK);
+  let t = GPS_EPOCH + weeksSinceEpoch * MS_PER_WEEK + epochMs;
+  if (t - refMs > MS_PER_WEEK / 2) t -= MS_PER_WEEK;
+  else if (refMs - t > MS_PER_WEEK / 2) t += MS_PER_WEEK;
+  t -= 18e3;
+  return new Date(t);
+}
+function resetGloFreqCache() {
+  gloFreqNum.fill(-128);
+}
+
+// src/rtcm3/station.ts
+function createStationMeta() {
+  return {
+    stationId: null,
+    itrf: null,
+    position: null,
+    antennaHeight: null,
+    antennaType: null,
+    antennaSerial: null,
+    antennaSetupId: null,
+    receiverType: null,
+    receiverFirmware: null,
+    receiverSerial: null,
+    description: null
+  };
+}
+function decodeStationARP(payload, msgType, meta) {
+  if (payload.length < 19) return;
+  const r = new BitReader(payload);
+  r.skip(12);
+  meta.stationId = r.readU(12);
+  meta.itrf = r.readU(6);
+  r.skip(4);
+  const x = r.readS(38) * 1e-4;
+  r.skip(1);
+  r.skip(1);
+  const y = r.readS(38) * 1e-4;
+  r.skip(2);
+  const z = r.readS(38) * 1e-4;
+  if (x !== 0 || y !== 0 || z !== 0) {
+    meta.position = [x, y, z];
+  }
+  if (msgType === 1006) {
+    meta.antennaHeight = r.readU(16) * 1e-4;
+  }
+}
+function decodeAntennaDescriptor(payload, msgType, meta) {
+  if (payload.length < 5) return;
+  const r = new BitReader(payload);
+  r.skip(12);
+  meta.stationId = r.readU(12);
+  const descLen = r.readU(8);
+  if (descLen > 0 && descLen <= 31) {
+    meta.antennaType = readString(r, descLen);
+  }
+  meta.antennaSetupId = r.readU(8);
+  if (msgType === 1008) {
+    const serialLen = r.readU(8);
+    if (serialLen > 0 && serialLen <= 31) {
+      meta.antennaSerial = readString(r, serialLen);
+    }
+  }
+}
+function decodeReceiverAntennaDescriptor(payload, meta) {
+  if (payload.length < 8) return;
+  const r = new BitReader(payload);
+  r.skip(12);
+  meta.stationId = r.readU(12);
+  const antDescLen = r.readU(8);
+  if (antDescLen > 0 && antDescLen <= 31) {
+    meta.antennaType = readString(r, antDescLen);
+  } else {
+    r.skip(antDescLen * 8);
+  }
+  meta.antennaSetupId = r.readU(8);
+  const antSerLen = r.readU(8);
+  if (antSerLen > 0 && antSerLen <= 31) {
+    meta.antennaSerial = readString(r, antSerLen);
+  } else {
+    r.skip(antSerLen * 8);
+  }
+  const rcvTypeLen = r.readU(8);
+  if (rcvTypeLen > 0 && rcvTypeLen <= 31) {
+    meta.receiverType = readString(r, rcvTypeLen);
+  } else {
+    r.skip(rcvTypeLen * 8);
+  }
+  const rcvFwLen = r.readU(8);
+  if (rcvFwLen > 0 && rcvFwLen <= 31) {
+    meta.receiverFirmware = readString(r, rcvFwLen);
+  } else {
+    r.skip(rcvFwLen * 8);
+  }
+  const rcvSerLen = r.readU(8);
+  if (rcvSerLen > 0 && rcvSerLen <= 31) {
+    meta.receiverSerial = readString(r, rcvSerLen);
+  } else {
+    r.skip(rcvSerLen * 8);
+  }
+}
+function decodeTextString(payload, meta) {
+  if (payload.length < 6) return;
+  const r = new BitReader(payload);
+  r.skip(12);
+  meta.stationId = r.readU(12);
+  r.skip(16);
+  r.skip(17);
+  r.skip(7);
+  const nBytes = r.readU(8);
+  if (nBytes > 0 && nBytes <= 127) {
+    const bytes = [];
+    for (let i = 0; i < nBytes; i++) bytes.push(r.readU(8));
+    try {
+      meta.description = new TextDecoder("utf-8").decode(new Uint8Array(bytes)).trim();
+    } catch {
+      meta.description = String.fromCharCode(...bytes).trim();
+    }
+  }
+}
+function updateStationMeta(meta, frame) {
+  try {
+    switch (frame.messageType) {
+      case 1005:
+      case 1006:
+        decodeStationARP(frame.payload, frame.messageType, meta);
+        return true;
+      case 1007:
+      case 1008:
+        decodeAntennaDescriptor(frame.payload, frame.messageType, meta);
+        return true;
+      case 1033:
+        decodeReceiverAntennaDescriptor(frame.payload, meta);
+        return true;
+      case 1029:
+        decodeTextString(frame.payload, meta);
+        return true;
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
+// src/rtcm3/stats.ts
+var RTCM3_MESSAGE_NAMES = {
+  // GPS
+  1001: "GPS L1 Code",
+  1002: "GPS L1 Code+Phase",
+  1003: "GPS L1/L2 Code",
+  1004: "GPS L1/L2 Code+Phase",
+  1005: "Station ARP (no height)",
+  1006: "Station ARP (with height)",
+  1007: "Antenna Descriptor",
+  1008: "Antenna Descriptor+Serial",
+  1009: "GLONASS L1 Code",
+  1010: "GLONASS L1 Code+Phase",
+  1011: "GLONASS L1/L2 Code",
+  1012: "GLONASS L1/L2 Code+Phase",
+  1013: "System Parameters",
+  1014: "Network Aux Station Data",
+  1015: "GPS Ionospheric Corrections",
+  1016: "GPS Geometric Corrections",
+  1017: "GPS Combined Corrections",
+  1019: "GPS Ephemeris",
+  1020: "GLONASS Ephemeris",
+  1029: "Unicode Text String",
+  1030: "GPS Network RTK Residual",
+  1031: "GLONASS Network RTK Residual",
+  1032: "Physical Reference Station",
+  1033: "Receiver+Antenna Descriptor",
+  1042: "BeiDou Ephemeris",
+  1043: "SBAS Ephemeris",
+  1044: "QZSS Ephemeris",
+  1045: "Galileo F/NAV Ephemeris",
+  1046: "Galileo I/NAV Ephemeris",
+  // MSM
+  1071: "GPS MSM1",
+  1072: "GPS MSM2",
+  1073: "GPS MSM3",
+  1074: "GPS MSM4",
+  1075: "GPS MSM5",
+  1076: "GPS MSM6",
+  1077: "GPS MSM7",
+  1081: "GLONASS MSM1",
+  1082: "GLONASS MSM2",
+  1083: "GLONASS MSM3",
+  1084: "GLONASS MSM4",
+  1085: "GLONASS MSM5",
+  1086: "GLONASS MSM6",
+  1087: "GLONASS MSM7",
+  1091: "Galileo MSM1",
+  1092: "Galileo MSM2",
+  1093: "Galileo MSM3",
+  1094: "Galileo MSM4",
+  1095: "Galileo MSM5",
+  1096: "Galileo MSM6",
+  1097: "Galileo MSM7",
+  1101: "SBAS MSM1",
+  1102: "SBAS MSM2",
+  1103: "SBAS MSM3",
+  1104: "SBAS MSM4",
+  1105: "SBAS MSM5",
+  1106: "SBAS MSM6",
+  1107: "SBAS MSM7",
+  1111: "QZSS MSM1",
+  1112: "QZSS MSM2",
+  1113: "QZSS MSM3",
+  1114: "QZSS MSM4",
+  1115: "QZSS MSM5",
+  1116: "QZSS MSM6",
+  1117: "QZSS MSM7",
+  1121: "BeiDou MSM1",
+  1122: "BeiDou MSM2",
+  1123: "BeiDou MSM3",
+  1124: "BeiDou MSM4",
+  1125: "BeiDou MSM5",
+  1126: "BeiDou MSM6",
+  1127: "BeiDou MSM7",
+  1131: "NavIC MSM1",
+  1132: "NavIC MSM2",
+  1133: "NavIC MSM3",
+  1134: "NavIC MSM4",
+  1135: "NavIC MSM5",
+  1136: "NavIC MSM6",
+  1137: "NavIC MSM7",
+  // SSR
+  1057: "GPS SSR Orbit",
+  1058: "GPS SSR Clock",
+  1059: "GPS SSR Code Bias",
+  1060: "GPS SSR Orbit+Clock",
+  1063: "GLONASS SSR Orbit",
+  1064: "GLONASS SSR Clock",
+  1065: "GLONASS SSR Code Bias",
+  1066: "GLONASS SSR Orbit+Clock",
+  // IGS SSR
+  4076: "IGS SSR"
+};
+function rtcm3Constellation(msgType) {
+  if (msgType >= 1001 && msgType <= 1004) return "GPS";
+  if (msgType >= 1009 && msgType <= 1012) return "GLONASS";
+  if (msgType === 1019) return "GPS";
+  if (msgType === 1020) return "GLONASS";
+  if (msgType === 1042) return "BeiDou";
+  if (msgType === 1043) return "SBAS";
+  if (msgType === 1044) return "QZSS";
+  if (msgType === 1045 || msgType === 1046) return "Galileo";
+  if (msgType >= 1071 && msgType <= 1077) return "GPS";
+  if (msgType >= 1081 && msgType <= 1087) return "GLONASS";
+  if (msgType >= 1091 && msgType <= 1097) return "Galileo";
+  if (msgType >= 1101 && msgType <= 1107) return "SBAS";
+  if (msgType >= 1111 && msgType <= 1117) return "QZSS";
+  if (msgType >= 1121 && msgType <= 1127) return "BeiDou";
+  if (msgType >= 1131 && msgType <= 1137) return "NavIC";
+  return null;
+}
+function createStreamStats() {
+  return {
+    totalBytes: 0,
+    totalFrames: 0,
+    startTime: Date.now(),
+    messageTypes: /* @__PURE__ */ new Map(),
+    bytesPerSecond: 0,
+    framesPerSecond: 0,
+    satellites: /* @__PURE__ */ new Map(),
+    ephemerides: /* @__PURE__ */ new Map(),
+    obsTypes: {},
+    stationMeta: createStationMeta()
+  };
+}
+function updateStreamStats(stats, frames, rawBytes) {
+  const now = Date.now();
+  stats.totalBytes += rawBytes;
+  stats.totalFrames += frames.length;
+  for (const frame of frames) {
+    let entry = stats.messageTypes.get(frame.messageType);
+    if (!entry) {
+      entry = {
+        messageType: frame.messageType,
+        name: RTCM3_MESSAGE_NAMES[frame.messageType] ?? `Unknown (${frame.messageType})`,
+        count: 0,
+        lastSeen: now,
+        constellation: rtcm3Constellation(frame.messageType),
+        totalBytes: 0
+      };
+      stats.messageTypes.set(frame.messageType, entry);
+    }
+    entry.count++;
+    entry.lastSeen = now;
+    entry.totalBytes += frame.length + 6;
+    const msmEpoch = decodeMsmFull(frame);
+    if (msmEpoch) {
+      const now2 = Date.now();
+      for (const obs of msmEpoch.observations) {
+        const signals = [];
+        let bestCn0 = 0;
+        for (const sig of obs.signals) {
+          if (sig.cn0 !== void 0 && sig.cn0 > 0) {
+            signals.push({ code: sig.rinexCode, cn0: sig.cn0 });
+            if (sig.cn0 > bestCn0) bestCn0 = sig.cn0;
+          }
+        }
+        if (signals.length > 0) {
+          stats.satellites.set(obs.prn, {
+            prn: obs.prn,
+            system: obs.system,
+            cn0: bestCn0,
+            lastSeen: now2,
+            signals
+          });
+        }
+        let sysSet = stats.obsTypes[obs.system];
+        if (!sysSet) {
+          sysSet = /* @__PURE__ */ new Set();
+          stats.obsTypes[obs.system] = sysSet;
+        }
+        for (const sig of obs.signals) {
+          if (sig.pseudorange !== void 0) sysSet.add(`C${sig.rinexCode}`);
+          if (sig.phase !== void 0) sysSet.add(`L${sig.rinexCode}`);
+          if (sig.doppler !== void 0) sysSet.add(`D${sig.rinexCode}`);
+          if (sig.cn0 !== void 0) sysSet.add(`S${sig.rinexCode}`);
+        }
+      }
+    }
+    const eph = decodeEphemeris(frame);
+    if (eph) {
+      stats.ephemerides.set(eph.prn, eph);
+    }
+    updateStationMeta(stats.stationMeta, frame);
+  }
+  for (const [prn, sat] of stats.satellites) {
+    if (now - sat.lastSeen > 3e4) stats.satellites.delete(prn);
+  }
+  const elapsed = (now - stats.startTime) / 1e3;
+  if (elapsed > 0) {
+    stats.bytesPerSecond = stats.totalBytes / elapsed;
+    stats.framesPerSecond = stats.totalFrames / elapsed;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BitReader,
+  RTCM3_MESSAGE_NAMES,
+  Rtcm3Decoder,
+  createStationMeta,
+  createStreamStats,
+  decodeEphemeris,
+  decodeMsmFull,
+  msmEpochToDate,
+  readString,
+  resetGloFreqCache,
+  rtcm3Constellation,
+  updateStationMeta,
+  updateStreamStats
+});