gnss-js 1.25.0 → 1.27.0

package/dist/binex.cjs

@@ -0,0 +1,799 @@
+"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/binex/index.ts
+var binex_exports = {};
+__export(binex_exports, {
+  binexCrc16: () => binexCrc16,
+  binexCrc32: () => binexCrc32,
+  binexCsum8: () => binexCsum8,
+  binexRecords: () => binexRecords,
+  decodeBinexEph: () => decodeBinexEph,
+  getBnxi: () => getBnxi,
+  parseBinex: () => parseBinex
+});
+module.exports = __toCommonJS(binex_exports);
+
+// src/navbits/index.ts
+var GPS_PI = 3.1415926535898;
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK = 7 * 86400;
+function getBitU(buff, pos, len) {
+  let bits = 0;
+  for (let i = pos; i < pos + len; i++) {
+    bits = bits * 2 + (buff[i >> 3] >> 7 - (i & 7) & 1);
+  }
+  return bits;
+}
+function getBitS(buff, pos, len) {
+  const bits = getBitU(buff, pos, len);
+  if (len <= 0 || bits < 2 ** (len - 1)) return bits;
+  return bits - 2 ** len;
+}
+
+// src/binex/frame.ts
+var CRC16_TABLE = (() => {
+  const t = new Uint16Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n << 8;
+    for (let k = 0; k < 8; k++)
+      c = c & 32768 ? (c << 1 ^ 4129) & 65535 : c << 1 & 65535;
+    t[n] = c;
+  }
+  return t;
+})();
+function binexCrc16(data, start, end) {
+  let crc = 0;
+  for (let i = start; i < end; i++)
+    crc = (crc << 8 ^ CRC16_TABLE[(crc >> 8 ^ data[i]) & 255]) & 65535;
+  return crc;
+}
+var CRC32_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n << 24;
+    for (let k = 0; k < 8; k++)
+      c = c & 2147483648 ? c << 1 ^ 79764919 : c << 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function binexCrc32(data, start, end) {
+  let crc = 0;
+  for (let i = start; i < end; i++)
+    crc = (crc << 8 ^ CRC32_TABLE[(crc >>> 24 ^ data[i]) & 255]) >>> 0;
+  return crc >>> 0;
+}
+function binexCsum8(data, start, end) {
+  let cs = 0;
+  for (let i = start; i < end; i++) cs ^= data[i];
+  return cs & 255;
+}
+function getBnxi(data, pos) {
+  let value = 0;
+  for (let i = 0; i < 3; i++) {
+    const b = data[pos + i] ?? 0;
+    value = value * 128 + (b & 127);
+    if (!(b & 128)) return { value, size: i + 1 };
+  }
+  value = value * 256 + (data[pos + 3] ?? 0);
+  return { value, size: 4 };
+}
+var SYNC = /* @__PURE__ */ new Map([
+  [226, { littleEndian: false, enhanced: false }],
+  [194, { littleEndian: true, enhanced: false }],
+  [232, { littleEndian: false, enhanced: true }],
+  [200, { littleEndian: true, enhanced: true }]
+]);
+function csumWidth(covered, enhanced) {
+  if (enhanced) {
+    if (covered < 128) return 2;
+    if (covered < 1048576) return 4;
+    return 16;
+  }
+  if (covered < 128) return 1;
+  if (covered < 4096) return 2;
+  if (covered < 1048576) return 4;
+  return 16;
+}
+function checksumOk(data, view, covStart, covEnd, width) {
+  switch (width) {
+    case 1:
+      return binexCsum8(data, covStart, covEnd) === (data[covEnd] ?? -1);
+    case 2:
+      return binexCrc16(data, covStart, covEnd) === view.getUint16(covEnd);
+    case 4:
+      return binexCrc32(data, covStart, covEnd) === view.getUint32(covEnd);
+    default:
+      return false;
+  }
+}
+function* binexRecords(data, view, stats) {
+  let i = 0;
+  while (i + 2 <= data.length) {
+    const sync = SYNC.get(data[i]);
+    if (!sync) {
+      i++;
+      continue;
+    }
+    const id = data[i + 1];
+    const { value: len, size: lenH } = getBnxi(data, i + 2);
+    const body = i + 2 + lenH;
+    const covStart = i + 1;
+    const covEnd = body + len;
+    const covered = covEnd - covStart;
+    const width = csumWidth(covered, sync.enhanced);
+    if (width === 16 || covEnd + width > data.length) {
+      i++;
+      continue;
+    }
+    if (!checksumOk(data, view, covStart, covEnd, width)) {
+      stats.badCrc++;
+      i++;
+      continue;
+    }
+    yield { id, start: i, body, len, ...sync };
+    i = covEnd + width;
+  }
+}
+
+// src/binex/nav.ts
+var GPS_EPOCH_MS2 = Date.UTC(1980, 0, 6);
+var GLO_DAY0_MS = Date.UTC(1980, 0, 1);
+var BDT_EPOCH_MS = Date.UTC(2006, 0, 1);
+var SEC_PER_WEEK2 = 7 * 86400;
+var MS_PER_WEEK = SEC_PER_WEEK2 * 1e3;
+var SC2RAD = GPS_PI;
+var gpsMs = (week, sec) => GPS_EPOCH_MS2 + week * MS_PER_WEEK + sec * 1e3;
+var sowOf = (dateMs) => (dateMs / 1e3 % SEC_PER_WEEK2 + SEC_PER_WEEK2) % SEC_PER_WEEK2;
+var two = (n) => String(n).padStart(2, "0");
+var Reader = class {
+  constructor(view, start, le) {
+    this.view = view;
+    this.le = le;
+    this.p = start;
+  }
+  p;
+  u1() {
+    return this.view.getUint8(this.p++);
+  }
+  i1() {
+    return this.view.getInt8(this.p++);
+  }
+  u2() {
+    const v = this.view.getUint16(this.p, this.le);
+    this.p += 2;
+    return v;
+  }
+  i4() {
+    const v = this.view.getInt32(this.p, this.le);
+    this.p += 4;
+    return v;
+  }
+  u4() {
+    const v = this.view.getUint32(this.p, this.le);
+    this.p += 4;
+    return v;
+  }
+  r4() {
+    const v = this.view.getFloat32(this.p, this.le);
+    this.p += 4;
+    return v;
+  }
+  r8() {
+    const v = this.view.getFloat64(this.p, this.le);
+    this.p += 8;
+    return v;
+  }
+};
+function readKeplerCore(r) {
+  const deltaN = r.r4() * SC2RAD;
+  const m0 = r.r8();
+  const e = r.r8();
+  const sqrtA = r.r8();
+  const cic = r.r4();
+  const crc = r.r4();
+  const cis = r.r4();
+  const crs = r.r4();
+  const cuc = r.r4();
+  const cus = r.r4();
+  const omega0 = r.r8();
+  const omega = r.r8();
+  const i0 = r.r8();
+  const omegaDot = r.r4() * SC2RAD;
+  const idot = r.r4() * SC2RAD;
+  return {
+    deltaN,
+    m0,
+    e,
+    sqrtA,
+    cic,
+    crc,
+    cis,
+    crs,
+    cuc,
+    cus,
+    omega0,
+    omega,
+    i0,
+    omegaDot,
+    idot
+  };
+}
+function decodeGpsQzss(view, p, le, sys) {
+  const r = new Reader(view, p, le);
+  const prnRaw = r.u1() + (sys === "G" ? 1 : 0);
+  const prn = sys === "G" ? prnRaw : prnRaw - 192;
+  if (sys === "G" && (prn < 1 || prn > 32)) return null;
+  if (sys === "J" && (prn < 1 || prn > 10)) return null;
+  const week = r.u2();
+  r.i4();
+  const toes = r.i4();
+  const tgd = r.r4();
+  r.i4();
+  const af2 = r.r4();
+  const af1 = r.r4();
+  const af0 = r.r4();
+  const iode = r.i4();
+  const core = readKeplerCore(r);
+  r.r4();
+  const svHealth = r.u2();
+  const tocDate = new Date(gpsMs(week, toes));
+  return {
+    system: sys,
+    prn: `${sys}${two(prn)}`,
+    toc: sowOf(tocDate.getTime()),
+    tocDate,
+    af0,
+    af1,
+    af2,
+    iode,
+    ...core,
+    toe: toes,
+    week,
+    svHealth,
+    tgd
+  };
+}
+function decodeGalileo(view, p, le) {
+  const r = new Reader(view, p, le);
+  const prn = r.u1() + 1;
+  if (prn < 1 || prn > 36) return null;
+  const week = r.u2();
+  r.i4();
+  const toes = r.i4();
+  const tgd = r.r4();
+  r.r4();
+  const iode = r.i4();
+  const af2 = r.r4();
+  const af1 = r.r4();
+  const af0 = r.r4();
+  const core = readKeplerCore(r);
+  r.r4();
+  const svHealth = r.u2();
+  const tocDate = new Date(gpsMs(week, toes));
+  return {
+    system: "E",
+    prn: `E${two(prn)}`,
+    toc: sowOf(tocDate.getTime()),
+    tocDate,
+    af0,
+    af1,
+    af2,
+    iode,
+    ...core,
+    toe: toes,
+    week,
+    svHealth,
+    tgd
+  };
+}
+function bdsTgd(tgd) {
+  tgd &= 1023;
+  return tgd & 512 ? -1e-10 * (~tgd & 511) : 1e-10 * (tgd & 511);
+}
+function decodeBeidou(view, p, le) {
+  const r = new Reader(view, p, le);
+  const prn = r.u1();
+  if (prn < 1 || prn > 63) return null;
+  const week = r.u2();
+  r.i4();
+  r.i4();
+  const toes = r.i4();
+  const af2 = r.r4();
+  const af1 = r.r4();
+  const af0 = r.r4();
+  const core = readKeplerCore(r);
+  const flag1 = r.u2();
+  const flag2 = r.u4();
+  const iode = flag1 >> 6 & 31;
+  const svHealth = flag1 & 1;
+  const tgd = bdsTgd(flag2 >> 4);
+  const tocDate = new Date(BDT_EPOCH_MS + week * MS_PER_WEEK + toes * 1e3);
+  return {
+    system: "C",
+    prn: `C${two(prn)}`,
+    toc: sowOf(tocDate.getTime()),
+    tocDate,
+    af0,
+    af1,
+    af2,
+    iode,
+    ...core,
+    toe: toes,
+    week,
+    // RINEX BDS week field is the BDT week
+    svHealth,
+    tgd
+  };
+}
+function decodeGlonass(view, p, le) {
+  const r = new Reader(view, p, le);
+  const slot = r.u1() + 1;
+  if (slot < 1 || slot > 27) return null;
+  const day = r.u2();
+  const tod = r.u4();
+  const tauN = r.r8();
+  const gammaN = r.r8();
+  const tof = r.u4();
+  const x = r.r8();
+  const xDot = r.r8();
+  const xAcc = r.r8();
+  const y = r.r8();
+  const yDot = r.r8();
+  const yAcc = r.r8();
+  const z = r.r8();
+  const zDot = r.r8();
+  const zAcc = r.r8();
+  const health = r.u1() & 1;
+  const freqNum = r.i1();
+  const tocDate = new Date(
+    GLO_DAY0_MS + (day - 1) * 864e5 + (tod - 10800) * 1e3
+  );
+  return {
+    system: "R",
+    prn: `R${two(slot)}`,
+    tocDate,
+    tauN,
+    gammaN,
+    messageFrameTime: tof,
+    x,
+    y,
+    z,
+    xDot,
+    yDot,
+    zDot,
+    xAcc,
+    yAcc,
+    zAcc,
+    health,
+    freqNum
+  };
+}
+function decodeSbas(view, p, le) {
+  const r = new Reader(view, p, le);
+  const prn = r.u1();
+  const week = r.u2();
+  const tow = r.u4();
+  const af0 = r.r8();
+  const af1 = r.r4();
+  const toe = r.u4();
+  const x = r.r8();
+  const xDot = r.r8();
+  const xAcc = r.r8();
+  const y = r.r8();
+  const yDot = r.r8();
+  const yAcc = r.r8();
+  const z = r.r8();
+  const zDot = r.r8();
+  const zAcc = r.r8();
+  const health = r.u1();
+  if (prn < 120 || prn > 158) return null;
+  return {
+    system: "S",
+    prn: `S${two(prn - 100)}`,
+    tocDate: new Date(gpsMs(week, toe)),
+    tauN: af0,
+    gammaN: af1,
+    messageFrameTime: tow,
+    x,
+    y,
+    z,
+    xDot,
+    yDot,
+    zDot,
+    xAcc,
+    yAcc,
+    zAcc,
+    health,
+    freqNum: 0
+  };
+}
+function decodeBinexEph(view, body, len, le) {
+  const sub = view.getUint8(body);
+  const p = body + 1;
+  const n = len - 1;
+  switch (sub) {
+    case 1:
+      return n >= 127 ? decodeGpsQzss(view, p, le, "G") : null;
+    case 2:
+      return n >= 119 ? decodeGlonass(view, p, le) : null;
+    case 3:
+      return n >= 98 ? decodeSbas(view, p, le) : null;
+    case 4:
+      return n >= 127 ? decodeGalileo(view, p, le) : null;
+    case 5:
+      return n >= 117 ? decodeBeidou(view, p, le) : null;
+    case 6:
+      return n >= 127 ? decodeGpsQzss(view, p, le, "J") : null;
+    default:
+      return null;
+  }
+}
+
+// src/binex/index.ts
+var GPS_EPOCH_MS3 = Date.UTC(1980, 0, 6);
+var CLIGHT = 299792458;
+var OBS_CODES = {
+  0: [
+    "1C",
+    "1C",
+    "1P",
+    "1W",
+    "1Y",
+    "1M",
+    "1X",
+    "1N",
+    "",
+    "",
+    "2W",
+    "2C",
+    "2D",
+    "2S",
+    "2L",
+    "2X",
+    "2P",
+    "2W",
+    "2Y",
+    "2M",
+    "2N",
+    "",
+    "",
+    "5X",
+    "5I",
+    "5Q",
+    "5X"
+  ],
+  // GPS
+  1: [
+    "1C",
+    "1C",
+    "1P",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "2C",
+    "2C",
+    "2P",
+    "3X",
+    "3I",
+    "3Q",
+    "3X"
+  ],
+  // GLONASS
+  3: [
+    "1C",
+    "1A",
+    "1B",
+    "1C",
+    "1X",
+    "1Z",
+    "5X",
+    "5I",
+    "5Q",
+    "5X",
+    "7X",
+    "7I",
+    "7Q",
+    "7X",
+    "8X",
+    "8I",
+    "8Q",
+    "8X",
+    "6X",
+    "6A",
+    "6B",
+    "6C",
+    "6X",
+    "6Z"
+  ],
+  // Galileo
+  2: ["1C", "1C", "", "", "", "", "5X", "5I", "5Q", "5X"],
+  // SBAS
+  4: [
+    "2X",
+    "2I",
+    "2Q",
+    "2X",
+    "7X",
+    "7I",
+    "7Q",
+    "7X",
+    "6X",
+    "6I",
+    "6Q",
+    "6X",
+    "1X",
+    "1S",
+    "1L",
+    "1X"
+  ],
+  // BeiDou
+  5: [
+    "1C",
+    "1C",
+    "1S",
+    "1L",
+    "1X",
+    "",
+    "",
+    "2X",
+    "2S",
+    "2L",
+    "2X",
+    "",
+    "",
+    "5X",
+    "5I",
+    "5Q",
+    "5X",
+    "",
+    "",
+    "6X",
+    "6S",
+    "6L",
+    "6X",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "1Z"
+  ]
+  // QZSS
+};
+var two2 = (n) => String(n).padStart(2, "0");
+function obsPrn(sys, prn) {
+  switch (sys) {
+    case 0:
+      return prn >= 1 && prn <= 32 ? `G${two2(prn)}` : null;
+    case 1:
+      return prn >= 1 && prn <= 27 ? `R${two2(prn)}` : null;
+    case 2:
+      return prn >= 120 && prn <= 158 ? `S${two2(prn - 100)}` : null;
+    case 3:
+      return prn >= 1 && prn <= 36 ? `E${two2(prn)}` : null;
+    case 4:
+      return prn >= 1 && prn <= 63 ? `C${two2(prn)}` : null;
+    case 5:
+      if (prn >= 193 && prn <= 202) return `J${two2(prn - 192)}`;
+      return prn >= 1 && prn <= 10 ? `J${two2(prn)}` : null;
+    default:
+      return null;
+  }
+}
+function carrierFreq(sys, code, fcn) {
+  const band = code.charCodeAt(0) - 48;
+  switch (sys) {
+    case "G":
+    case "J":
+      if (band === 1) return 157542e4;
+      if (band === 2) return 12276e5;
+      if (band === 5) return 117645e4;
+      if (band === 6) return 127875e4;
+      return 0;
+    case "R":
+      if (band === 1) return fcn >= -7 ? 1602e6 + fcn * 562500 : 0;
+      if (band === 2) return fcn >= -7 ? 1246e6 + fcn * 437500 : 0;
+      if (band === 3) return 1202025e3;
+      return 0;
+    case "E":
+      if (band === 1) return 157542e4;
+      if (band === 5) return 117645e4;
+      if (band === 6) return 127875e4;
+      if (band === 7) return 120714e4;
+      if (band === 8) return 1191795e3;
+      return 0;
+    case "C":
+      if (band === 1) return 157542e4;
+      if (band === 2) return 1561098e3;
+      if (band === 5) return 117645e4;
+      if (band === 6) return 126852e4;
+      if (band === 7) return 120714e4;
+      if (band === 8) return 1191795e3;
+      return 0;
+    case "S":
+      if (band === 1) return 157542e4;
+      if (band === 5) return 117645e4;
+      return 0;
+    default:
+      return 0;
+  }
+}
+var FCN_UNKNOWN = -100;
+function decodeObsSat(data, start, nobs, sys) {
+  let p = start;
+  let fcn = FCN_UNKNOWN;
+  const obs = [];
+  const block0Flags = [0, 0, 0, 0];
+  let refRange = 0;
+  for (let b = 0; b < nobs; b++) {
+    const flags = b === 0 ? block0Flags : block0Flags.slice();
+    const b0 = data[p++];
+    const code = b0 & 31;
+    const slip = (b0 >> 5 & 1) === 1;
+    let more = b0 >> 7 & 1;
+    while (more) {
+      const fb = data[p++];
+      flags[fb & 3] = fb & 127;
+      more = fb & 128;
+    }
+    if (sys === 1 && flags[2] > 0 && (code === 1 || code === 2 || code === 11 || code === 12)) {
+      fcn = getBitS(Uint8Array.of(flags[2]), 2, 4);
+    }
+    const acc = flags[0] & 32 ? 1e-4 : 2e-5;
+    let cn0 = data[p++] * 0.4;
+    let range;
+    if (b === 0) {
+      cn0 += getBitS(data, p * 8, 2) * 0.1;
+      range = getBitU(data, p * 8 + 2, 38) * 1e-3;
+      p += 5;
+      refRange = range;
+    } else if (flags[0] & 64) {
+      cn0 += getBitS(data, p * 8, 2) * 0.1;
+      range = refRange + getBitS(data, p * 8 + 4, 20) * 1e-3;
+      p += 3;
+    } else {
+      range = refRange + getBitS(data, p * 8, 16) * 1e-3;
+      p += 2;
+    }
+    let phase;
+    if (flags[0] & 64) {
+      phase = range + getBitS(data, p * 8, 24) * acc;
+      p += 3;
+    } else {
+      cn0 += getBitS(data, p * 8, 2) * 0.1;
+      phase = range + getBitS(data, p * 8 + 2, 22) * acc;
+      p += 3;
+    }
+    let doppler = null;
+    if (flags[0] & 4) {
+      doppler = getBitS(data, p * 8, 24) / 256;
+      p += 3;
+    }
+    if (flags[0] & 8) {
+      p += flags[0] & 16 ? 2 : 1;
+    }
+    obs.push({ code, slip, pr: range, phase, cn0, doppler });
+  }
+  return { obs, fcn, next: p };
+}
+function decodeObsRecord(data, view, body, len, obsCodes) {
+  let p = body + 1;
+  const min = view.getUint32(p);
+  p += 4;
+  const msec = view.getUint16(p);
+  p += 2;
+  const timeMs = GPS_EPOCH_MS3 + min * 6e4 + msec;
+  const flag = data[p++];
+  const nsat = (flag & 63) + 1;
+  if (flag & 128) p += 3;
+  if (flag & 64) {
+    const nsys = getBitU(data, p * 8, 4);
+    p += 1;
+    p += nsys * 4;
+  }
+  const end = body + len;
+  const meas = [];
+  for (let i = 0; i < nsat && p < end; i++) {
+    const prn = data[p++];
+    const b = data[p++];
+    const nobs = b >> 4 & 7;
+    const sys = b & 15;
+    const sat = obsPrn(sys, prn);
+    const { obs, fcn, next } = decodeObsSat(data, p, nobs, sys);
+    p = next;
+    if (p > end) return null;
+    if (!sat) continue;
+    const table = OBS_CODES[sys];
+    const sysL = sat[0];
+    for (const o of obs) {
+      const code = table?.[o.code & 63] ?? "";
+      if (!code) continue;
+      const freq = carrierFreq(sysL, code, fcn);
+      meas.push({
+        prn: sat,
+        code,
+        pr: o.pr,
+        cp: freq > 0 ? o.phase * freq / CLIGHT : null,
+        doppler: o.doppler,
+        cn0: o.cn0,
+        slip: o.slip
+      });
+      const codes = obsCodes[sysL] ??= [];
+      if (!codes.includes(code)) codes.push(code);
+    }
+  }
+  return { timeMs, meas };
+}
+function parseBinex(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const epochs = [];
+  const ephemerides = [];
+  const messageCounts = {};
+  const obsCodes = {};
+  const stats = { badCrc: 0 };
+  const lastKep = /* @__PURE__ */ new Map();
+  const lastState = /* @__PURE__ */ new Map();
+  const hex = (n) => `0x${n.toString(16).padStart(2, "0")}`;
+  for (const rec of binexRecords(data, view, stats)) {
+    const sub = rec.len > 0 ? data[rec.body] : 0;
+    const key = rec.id === 1 || rec.id === 127 ? `${hex(rec.id)}-${sub.toString(16).padStart(2, "0")}` : hex(rec.id);
+    messageCounts[key] = (messageCounts[key] ?? 0) + 1;
+    if (rec.id === 127 && sub === 5 && rec.len >= 8 && !rec.littleEndian) {
+      const epoch = decodeObsRecord(data, view, rec.body, rec.len, obsCodes);
+      if (epoch) epochs.push(epoch);
+    } else if (rec.id === 1 && rec.len >= 2) {
+      const eph = decodeBinexEph(view, rec.body, rec.len, rec.littleEndian);
+      if (!eph) continue;
+      if ("iode" in eph) {
+        const prev = lastKep.get(eph.prn);
+        if (prev && prev.iode === eph.iode && prev.toe === eph.toe && prev.tocDate.getTime() === eph.tocDate.getTime()) {
+          continue;
+        }
+        lastKep.set(eph.prn, eph);
+        ephemerides.push(eph);
+      } else {
+        const prev = lastState.get(eph.prn);
+        if (prev && Math.abs(prev.tocDate.getTime() - eph.tocDate.getTime()) < 1e3 && prev.health === eph.health) {
+          continue;
+        }
+        lastState.set(eph.prn, eph);
+        ephemerides.push(eph);
+      }
+    }
+  }
+  return { epochs, ephemerides, messageCounts, obsCodes, badCrc: stats.badCrc };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  binexCrc16,
+  binexCrc32,
+  binexCsum8,
+  binexRecords,
+  decodeBinexEph,
+  getBnxi,
+  parseBinex
+});