gnss-js 1.13.0 → 1.14.0

package/dist/sbf.cjs

@@ -0,0 +1,747 @@
+"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/sbf/index.ts
+var sbf_exports = {};
+__export(sbf_exports, {
+  parseSbfMeas: () => parseSbfMeas
+});
+module.exports = __toCommonJS(sbf_exports);
+var CLIGHT = 299792458;
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK = 7 * 864e5;
+var CRC_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 crc16(data, start, end) {
+  let crc = 0;
+  for (let i = start; i < end; i++)
+    crc = (crc << 8 ^ CRC_TABLE[(crc >> 8 ^ data[i]) & 255]) & 65535;
+  return crc;
+}
+var M3_SYS = ["G", "R", "E", "C", "S", "J", "I"];
+var M3_PR_BASE = [19e6, 19e6, 22e6, 2e7, 34e6, 34e6, 34e6];
+var M3_INTERVALS = [
+  1,
+  500,
+  1e3,
+  2e3,
+  5e3,
+  1e4,
+  15e3,
+  3e4,
+  6e4,
+  12e4,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1
+];
+var M3_LOCK_TIME = [
+  0,
+  6e4,
+  3e4,
+  15e3,
+  1e4,
+  5e3,
+  2e3,
+  1e3,
+  500,
+  200,
+  100,
+  50,
+  40,
+  20,
+  10,
+  0
+];
+var M3_SIG_DEFAULT = [
+  ["1C", "2L", "5Q", "1W", "2W", "1L"],
+  // GPS
+  ["1C", "2C", "1P", "2P", "3Q"],
+  // GLONASS
+  ["1C", "5Q", "7Q", "6C", "8Q"],
+  // Galileo
+  ["2I", "7I", "6I", "1P", "5P", "7D"],
+  // BeiDou
+  ["1C", "5I"],
+  // SBAS
+  ["1C", "2L", "5Q", "6L", "1L", "1Z", "5P", "1E"],
+  // QZSS
+  ["5A", "1E", "9A"]
+  // NavIC
+];
+var MEAS2_SIG = [
+  ["G", "1C"],
+  ["G", "1W"],
+  ["G", "2W"],
+  ["G", "2L"],
+  ["G", "5Q"],
+  ["G", "1L"],
+  ["J", "1C"],
+  ["J", "2L"],
+  ["R", "1C"],
+  ["R", "1P"],
+  ["R", "2P"],
+  ["R", "2C"],
+  ["R", "3Q"],
+  ["C", "1P"],
+  ["C", "5P"],
+  ["I", "5A"],
+  null,
+  ["E", "1C"],
+  null,
+  ["E", "6C"],
+  ["E", "5Q"],
+  ["E", "7Q"],
+  ["E", "8Q"],
+  null,
+  // L-band
+  ["S", "1C"],
+  ["S", "5I"],
+  ["J", "5Q"],
+  ["J", "6L"],
+  ["C", "2I"],
+  ["C", "7I"],
+  ["C", "6I"],
+  null,
+  ["J", "1L"],
+  ["J", "1Z"],
+  ["C", "7D"],
+  null,
+  ["I", "9A"],
+  null,
+  // NavIC L1 (no obs code assigned)
+  ["J", "1E"],
+  ["J", "5P"]
+];
+var two = (n) => String(n).padStart(2, "0");
+function m3Prn(navsys, svid) {
+  switch (navsys) {
+    case 0:
+      return svid < 32 ? `G${two(svid + 1)}` : null;
+    case 1:
+      return svid < 27 ? `R${two(svid + 1)}` : null;
+    case 2:
+      return svid < 36 ? `E${two(svid + 1)}` : null;
+    case 3:
+      return svid < 50 ? `C${two(svid + 1)}` : null;
+    case 4:
+      return svid <= 38 ? `S${two(svid + 20)}` : null;
+    case 5:
+      return svid < 10 ? `J${two(svid + 1)}` : null;
+    case 6:
+      return svid < 14 ? `I${two(svid + 1)}` : null;
+    default:
+      return null;
+  }
+}
+function svidToPrn(svid) {
+  if (svid >= 1 && svid <= 37) return svid <= 32 ? `G${two(svid)}` : null;
+  if (svid <= 61) return svid - 37 <= 27 ? `R${two(svid - 37)}` : null;
+  if (svid <= 62) return null;
+  if (svid <= 68) return svid - 38 <= 27 ? `R${two(svid - 38)}` : null;
+  if (svid <= 70) return null;
+  if (svid <= 106) return svid - 70 <= 36 ? `E${two(svid - 70)}` : null;
+  if (svid <= 119) return null;
+  if (svid <= 140) return `S${two(svid - 100)}`;
+  if (svid <= 180) return svid - 140 <= 50 ? `C${two(svid - 140)}` : null;
+  if (svid <= 190) return `J${two(svid - 180)}`;
+  if (svid <= 197) return svid - 190 <= 14 ? `I${two(svid - 190)}` : null;
+  if (svid <= 215) return `S${two(svid - 157)}`;
+  if (svid <= 222) return svid - 208 <= 14 ? `I${two(svid - 208)}` : null;
+  if (svid <= 245) return svid - 182 <= 50 ? `C${two(svid - 182)}` : null;
+  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 1602e6 + fcn * 562500;
+      if (band === 2) return 1246e6 + fcn * 437500;
+      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;
+    case "I":
+      if (band === 1) return 157542e4;
+      if (band === 5) return 117645e4;
+      if (band === 9) return 2492028e3;
+      return 0;
+    default:
+      return 0;
+  }
+}
+var ZERO_REF_SLOT = {
+  sigIdx: 0,
+  pr: 0,
+  cp: 0,
+  cn0: 0,
+  lockTimeMs: null
+};
+function freshRefEpoch(tow) {
+  return {
+    tow,
+    headers: new Array(7).fill(null),
+    sats: Array.from({ length: 7 }, () => new Array(64))
+  };
+}
+function parseSbfMeas(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const epochs = [];
+  const messageCounts = {};
+  const obsCodes = {};
+  let badCrc = 0;
+  let ref = freshRefEpoch(-1);
+  let curTime = NaN;
+  let curMeas = [];
+  let curSats = [];
+  const flush = () => {
+    if (curMeas.length > 0) {
+      const meas = curMeas.map((m) => {
+        const codes = obsCodes[m.sys] ??= [];
+        if (!codes.includes(m.code)) codes.push(m.code);
+        return {
+          prn: m.prn,
+          code: m.code,
+          pr: m.pr !== 0 ? m.pr : null,
+          cp: m.cp !== 0 ? m.cp : null,
+          doppler: m.doppler,
+          cn0: m.cn0,
+          lockTimeMs: m.lockTimeMs
+        };
+      });
+      epochs.push({ timeMs: curTime, meas });
+    }
+    curMeas = [];
+    curSats = [];
+  };
+  const ensureEpoch = (timeMs) => {
+    if (timeMs !== curTime) {
+      flush();
+      curTime = timeMs;
+    }
+  };
+  const decodeMeas3Ranges = (i2, tow) => {
+    const o = i2 + 8;
+    const constellations = view.getUint16(o + 8, true) & 127;
+    const misc = data[o + 10];
+    const version = data[o + 11];
+    if (version > 31) return;
+    if ((misc & 7) !== 0) return;
+    const prrAvailable = (misc & 8) !== 0;
+    const interval = M3_INTERVALS[misc >> 4];
+    const isRef = tow % interval === 0;
+    const dtow = tow % interval;
+    if (isRef) {
+      ref = freshRefEpoch(tow);
+    } else if (ref.tow !== Math.floor(tow / interval) * interval) {
+      curMeas = [];
+      curSats = [];
+      return;
+    }
+    let idx = o + 12;
+    for (let navsys = 0; navsys < 7; navsys++) {
+      if ((constellations & 1 << navsys) === 0) continue;
+      const sys = M3_SYS[navsys];
+      const useRefHeader = data[idx] === 0;
+      const hdr = useRefHeader ? ref.headers[navsys] ?? new Uint8Array(0) : data.subarray(idx, idx + 32);
+      const BF1 = hdr[0] ?? 0;
+      let nB = BF1 & 7;
+      if (nB === 7) nB = 8;
+      const sigIdxMasterShort = BF1 >> 3 & 15;
+      const sigExclPresent = BF1 >> 7 !== 0;
+      let h = 1;
+      const maskBytes = hdr.subarray(h, h + nB);
+      let nSats = 0;
+      for (const b of maskBytes)
+        for (let k = 0; k < 8; k++) nSats += b >> k & 1;
+      h += nB;
+      let gloFncs = new Uint8Array(0);
+      let bdsLongRange = 0;
+      if (navsys === 1) {
+        gloFncs = hdr.subarray(h, h + (nSats + 1 >> 1));
+        h += nSats + 1 >> 1;
+      } else if (navsys === 3) {
+        bdsLongRange = (hdr[h] ?? 0) | (hdr[h + 1] ?? 0) << 8;
+        h += 2;
+      }
+      const sigExcluded = sigExclPresent ? hdr[h++] ?? 0 : 0;
+      if (isRef) ref.headers[navsys] = data.slice(idx, idx + h);
+      idx += useRefHeader ? 1 : h;
+      const sigTable = [];
+      for (let s = 0; s < 16; s++)
+        if ((sigExcluded & 1 << s) === 0)
+          sigTable.push(M3_SIG_DEFAULT[navsys][s] ?? null);
+      while (sigTable.length < 16) sigTable.push(null);
+      let satCnt = 0;
+      for (let svid = 0; svid < 64 && satCnt < nSats; svid++) {
+        if (((maskBytes[svid >> 3] ?? 0) >> (svid & 7) & 1) === 0) continue;
+        const glofnc = navsys === 1 ? ((gloFncs[satCnt >> 1] ?? 0) >> 4 * (satCnt % 2) & 15) - 8 : 0;
+        const prn = m3Prn(navsys, svid);
+        const prbase = navsys === 3 && (bdsLongRange & 1 << satCnt) !== 0 ? 34e6 : M3_PR_BASE[navsys];
+        const refSat = ref.sats[navsys][svid];
+        const refSlot = (k) => refSat?.slots[k] ?? ZERO_REF_SLOT;
+        const entry = { navsys, svid, prn, slots: [] };
+        const bt = data[idx];
+        let masterSigIdx;
+        let slaveMask;
+        let prRate = 0;
+        let mPr = 0;
+        let mCp = 0;
+        let mCn0 = 0;
+        let mLock = null;
+        let masterCode;
+        let mFreq = 0;
+        if ((bt & 1) === 1) {
+          const BF1m = view.getUint32(idx, true);
+          const prLsb = view.getUint32(idx + 4, true);
+          const cmc = BF1m >>> 1 & 262143;
+          const prMsb = BF1m >>> 19 & 1;
+          const lti3 = BF1m >>> 20 & 7;
+          const cn0 = BF1m >>> 23 & 31;
+          const signalList = BF1m >>> 28 & 15;
+          masterSigIdx = sigIdxMasterShort;
+          slaveMask = signalList << masterSigIdx + 1;
+          masterCode = sigTable[masterSigIdx] ?? null;
+          if (masterCode) {
+            mFreq = carrierFreq(sys, masterCode, glofnc);
+            mPr = prbase + (prLsb + 4294967296 * prMsb) * 1e-3;
+            mCn0 = cn0 + 24;
+            if (cmc !== 0) mCp = mPr / (CLIGHT / mFreq) - 131.072 + cmc * 1e-3;
+            mLock = M3_LOCK_TIME[lti3];
+          }
+          prRate = prrAvailable ? view.getInt16(idx + 8, true) : 0;
+          idx += prrAvailable ? 10 : 8;
+        } else if ((bt & 3) === 0) {
+          const BF1m = view.getUint32(idx, true);
+          const prLsb = view.getUint32(idx + 4, true);
+          const BF2 = view.getUint16(idx + 8, true);
+          const BF3 = data[idx + 10];
+          const prMsb = BF1m >>> 2 & 15;
+          const cmc = BF1m >>> 6 & 4194303;
+          const lti4 = BF1m >>> 28 & 15;
+          const cn0 = BF2 & 63;
+          let signalMask = BF2 >>> 6 & 511;
+          const cont = BF2 >>> 15 & 1;
+          if (cont !== 0) signalMask |= (BF3 & 127) << 9;
+          masterSigIdx = 0;
+          while (masterSigIdx < 32 && (signalMask >> masterSigIdx & 1) === 0)
+            masterSigIdx++;
+          slaveMask = signalMask !== 0 ? signalMask ^ 1 << masterSigIdx : 0;
+          masterCode = sigTable[masterSigIdx] ?? null;
+          if (masterCode) {
+            mFreq = carrierFreq(sys, masterCode, glofnc);
+            const isGpsPCode = navsys === 0 && (masterCode === "1W" || masterCode === "2W");
+            mPr = (prLsb + 4294967296 * prMsb) * 1e-3;
+            mCn0 = isGpsPCode ? cn0 : cn0 + 10;
+            if (cmc !== 0)
+              mCp = mPr / (CLIGHT / mFreq) - 2097.152 + cmc * 1e-3;
+            mLock = M3_LOCK_TIME[lti4];
+          }
+          prRate = prrAvailable ? view.getInt16(idx + 10, true) : 0;
+          idx += (prrAvailable ? 12 : 10) + cont;
+        } else if ((bt & 12) === 12) {
+          const BF1m = data[idx];
+          const BF2 = view.getUint32(idx + 1, true);
+          const prDelta = BF1m >> 4 << 13 | BF2 & 8191;
+          const cn0Delta = BF2 >>> 13 & 7;
+          const cmc = BF2 >>> 16;
+          masterSigIdx = refSlot(0).sigIdx;
+          slaveMask = refSat?.slaveMask ?? 0;
+          masterCode = sigTable[masterSigIdx] ?? null;
+          if (masterCode) {
+            const r = refSlot(0);
+            mFreq = carrierFreq(sys, masterCode, glofnc);
+            mPr = r.pr + Math.trunc((refSat?.prRate ?? 0) * 64 * dtow / 1e3) * 1e-3 + prDelta * 1e-3 - 65.536;
+            mCn0 = r.cn0 - 4 + cn0Delta;
+            if (cmc !== 0)
+              mCp = (mPr - r.pr) / (CLIGHT / mFreq) + r.cp - 32.768 + cmc * 1e-3;
+            mLock = r.lockTimeMs;
+          }
+          idx += 5;
+        } else {
+          const BF1m = view.getUint32(idx, true);
+          const prDelta = BF1m >>> 4 & 16383;
+          const cmc = BF1m >>> 18 & 16383;
+          const cn0Delta = BF1m >>> 2 & 3;
+          masterSigIdx = refSlot(0).sigIdx;
+          slaveMask = refSat?.slaveMask ?? 0;
+          masterCode = sigTable[masterSigIdx] ?? null;
+          if (masterCode) {
+            const r = refSlot(0);
+            mFreq = carrierFreq(sys, masterCode, glofnc);
+            mPr = r.pr + Math.trunc((refSat?.prRate ?? 0) * 64 * dtow / 1e3) * 1e-3 + prDelta * 1e-3 - 8.192;
+            mCn0 = r.cn0 - 1 + cn0Delta;
+            if (cmc !== 0)
+              mCp = (mPr - r.pr) / (CLIGHT / mFreq) + r.cp - 8.192 + cmc * 1e-3;
+            mLock = r.lockTimeMs;
+          }
+          idx += 4;
+        }
+        let masterMeas = null;
+        if (masterCode && prn) {
+          masterMeas = {
+            prn,
+            sys,
+            code: masterCode,
+            freq: mFreq,
+            pr: mPr,
+            cp: mCp,
+            cn0: mCn0,
+            doppler: null,
+            lockTimeMs: mLock
+          };
+          curMeas.push(masterMeas);
+        }
+        entry.slots.push(masterMeas);
+        let newRefSat = null;
+        if (isRef && prn) {
+          newRefSat = {
+            slaveMask,
+            prRate,
+            slots: [
+              {
+                sigIdx: masterSigIdx,
+                pr: mPr,
+                cp: mCp,
+                cn0: mCn0,
+                lockTimeMs: mLock
+              }
+            ]
+          };
+          ref.sats[navsys][svid] = newRefSat;
+        }
+        let slaveCnt = 0;
+        let mask = slaveMask;
+        for (let s = 1; s < 16 && mask !== 0; s++) {
+          if ((mask & 1 << s) === 0) continue;
+          const bt2 = data[idx];
+          const code = sigTable[s] ?? null;
+          const freq = code ? carrierFreq(sys, code, glofnc) : 0;
+          let sPr = 0;
+          let sCp = 0;
+          let sCn0 = 0;
+          let sLock = null;
+          if ((bt2 & 1) === 1) {
+            const BF1s = view.getUint32(idx, true);
+            const BF2s = data[idx + 4];
+            const cmcRes = BF1s >>> 1 & 65535;
+            const prRel = BF1s >>> 17;
+            const lti3 = BF2s & 7;
+            const cn0 = BF2s >> 3;
+            if (code) {
+              sPr = mFreq > freq ? mPr + prRel * 1e-3 - 10 : mPr - prRel * 1e-3 + 10;
+              if (cmcRes !== 0)
+                sCp = sPr / (CLIGHT / freq) + (mCp - mPr / (CLIGHT / mFreq)) * (mFreq / freq) - 32.768 + cmcRes * 1e-3;
+              sCn0 = navsys === 0 && (code === "1W" || code === "2W") ? mCn0 - 3 - cn0 : cn0 + 24;
+              sLock = M3_LOCK_TIME[lti3];
+            }
+            idx += 5;
+          } else if ((bt2 & 3) === 0) {
+            const BF1s = view.getUint32(idx, true);
+            const prLsbRel = view.getUint16(idx + 4, true);
+            const BF3s = data[idx + 6];
+            const cmc = BF1s >>> 2 & 4194303;
+            const lti4 = BF1s >>> 24 & 15;
+            const prMsbRel = BF1s >>> 28 & 7;
+            const cn0 = BF3s & 63;
+            if (code) {
+              sPr = mPr + (prMsbRel * 65536 + prLsbRel) * 1e-3 - 262.144;
+              if (cmc !== 0)
+                sCp = sPr / (CLIGHT / freq) - 2097.152 + cmc * 1e-3;
+              sCn0 = navsys === 0 && (code === "1W" || code === "2W") ? cn0 : cn0 + 10;
+              sLock = M3_LOCK_TIME[lti4];
+            }
+            idx += 7;
+          } else {
+            const BF1s = view.getUint16(idx, true);
+            const dC = data[idx + 2];
+            const dPr = BF1s >>> 2 & 4095;
+            const cn0Delta = BF1s >>> 14;
+            if (code) {
+              const rS = refSlot(slaveCnt + 1);
+              const rM = refSlot(0);
+              sCp = rS.cp + (mCp - rM.cp) * (freq / mFreq) - 0.128 + dC * 1e-3;
+              sPr = rS.pr + (sCp - rS.cp) * (CLIGHT / freq) - 2.048 + dPr * 1e-3;
+              sCn0 = rS.cn0 - 2 + cn0Delta;
+              sLock = rS.lockTimeMs;
+            }
+            idx += 3;
+          }
+          let slaveMeas = null;
+          if (code && prn) {
+            slaveMeas = {
+              prn,
+              sys,
+              code,
+              freq,
+              pr: sPr,
+              cp: sCp,
+              cn0: sCn0,
+              doppler: null,
+              lockTimeMs: sLock
+            };
+            curMeas.push(slaveMeas);
+          }
+          entry.slots.push(slaveMeas);
+          if (newRefSat)
+            newRefSat.slots[slaveCnt + 1] = {
+              sigIdx: s,
+              pr: sPr,
+              cp: sCp,
+              cn0: sCn0,
+              lockTimeMs: sLock
+            };
+          slaveCnt++;
+          mask &= ~(1 << s);
+        }
+        curSats.push(entry);
+        satCnt++;
+      }
+    }
+  };
+  const decodeMeas3CN0 = (i2, len) => {
+    const flags = view.getUint16(i2 + 14, true);
+    if ((flags & 7) !== 0) return;
+    const maxNibbles = (len - 16) * 2;
+    let off = 0;
+    for (const e of curSats) {
+      if (off >= maxNibbles) break;
+      if (!e.prn) continue;
+      for (let k = 0; k < e.slots.length; k++) {
+        const slot = e.slots[k];
+        if (k > 0 && !slot) break;
+        const nib = (data[i2 + 16 + (off >> 1)] ?? 0) >> (off & 1) * 4 & 15;
+        if (slot && slot.cn0 !== null) slot.cn0 += nib * 0.0625 - 0.5;
+        off++;
+      }
+    }
+  };
+  const readPrRate = (base, off) => {
+    const byteAt = (k) => data[base + off + k] ?? 0;
+    const v = (byteAt(0) | byteAt(1) << 8 | byteAt(2) << 16 | byteAt(3) << 24) >>> 0;
+    let value;
+    let size;
+    if ((v & 2) === 0) {
+      value = (v & 255) >>> 2;
+      size = 1;
+    } else if ((v & 6) === 2) {
+      value = (v & 65535) >>> 3;
+      size = 2;
+    } else if ((v & 14) === 6) {
+      value = (v & 16777215) >>> 4;
+      size = 3;
+    } else {
+      value = v >>> 4;
+      size = 4;
+    }
+    if ((v & 1) === 1) value = -value;
+    return { value, size };
+  };
+  const decodeMeas3Doppler = (i2, len) => {
+    const flags = view.getUint16(i2 + 14, true);
+    if ((flags & 7) !== 0) return;
+    let off = 0;
+    for (const e of curSats) {
+      if (off + 16 >= len) break;
+      if (!e.prn) continue;
+      const master = readPrRate(i2 + 16, off);
+      off += master.size;
+      if (master.value === -268435455) continue;
+      const refPrRate = ref.sats[e.navsys][e.svid]?.prRate ?? 0;
+      const m = e.slots[0];
+      const mD = m ? -(master.value + refPrRate * 64) * 1e-3 / (CLIGHT / m.freq) : 0;
+      if (m) m.doppler = mD;
+      for (let k = 1; k < e.slots.length; k++) {
+        const slot = e.slots[k];
+        if (!slot) break;
+        const slave = readPrRate(i2 + 16, off);
+        off += slave.size;
+        if (m)
+          slot.doppler = (mD * (CLIGHT / m.freq) * 1e3 - slave.value) * 1e-3 / (CLIGHT / slot.freq);
+      }
+    }
+  };
+  const decodeMeasEpoch = (i2, len) => {
+    const n1 = data[i2 + 14];
+    const len1 = data[i2 + 15];
+    const len2 = data[i2 + 16];
+    if ((data[i2 + 17] & 128) !== 0) return;
+    const end = i2 + len;
+    let p = i2 + 20;
+    for (let b1 = 0; b1 < n1 && p + 20 <= end; b1++) {
+      const ant = data[p + 1] >> 5;
+      let sig = data[p + 1] & 31;
+      const svid = data[p + 2];
+      const misc = data[p + 3];
+      const info = data[p + 18];
+      const n2 = data[p + 19];
+      let fcn = 0;
+      if (sig === 31) sig = (info >> 3) + 32;
+      else if (sig >= 8 && sig <= 11) fcn = (info >> 3) - 8;
+      const prn = svidToPrn(svid);
+      const sigDef = MEAS2_SIG[sig] ?? null;
+      if (ant !== 0 || !prn || !sigDef || sigDef[0] !== prn[0]) {
+        p += len1 + len2 * n2;
+        continue;
+      }
+      const [sys, code] = sigDef;
+      const freq1 = carrierFreq(sys, code, fcn);
+      const codeLsb = view.getUint32(p + 4, true);
+      const dopplerRaw = view.getInt32(p + 8, true);
+      const carrierLsb = view.getUint16(p + 12, true);
+      const carrierMsb = view.getInt8(p + 14);
+      const cn0Raw = data[p + 15];
+      const lock = view.getUint16(p + 16, true);
+      let p1 = 0;
+      if ((misc & 15) !== 0 || codeLsb !== 0)
+        p1 = (misc & 15) * 4294967296e-3 + codeLsb * 1e-3;
+      const d1 = dopplerRaw !== -2147483648 ? dopplerRaw * 1e-4 : null;
+      let l1 = 0;
+      if (p1 !== 0 && freq1 > 0 && lock !== 65535 && (carrierMsb !== -128 || carrierLsb !== 0))
+        l1 = p1 * freq1 / CLIGHT + carrierMsb * 65.536 + carrierLsb * 1e-3;
+      const cn0 = cn0Raw !== 255 ? cn0Raw * 0.25 + (sig === 1 || sig === 2 ? 0 : 10) : null;
+      curMeas.push({
+        prn,
+        sys,
+        code,
+        freq: freq1,
+        pr: p1,
+        cp: l1,
+        cn0,
+        doppler: d1,
+        lockTimeMs: lock !== 65535 ? lock * 1e3 : null
+      });
+      p += len1;
+      for (let b2 = 0; b2 < n2 && p + 12 <= end; b2++, p += len2) {
+        let sig2 = data[p] & 31;
+        const ant2 = data[p] >> 5;
+        const lock2 = data[p + 1];
+        const cn0Raw2 = data[p + 2];
+        const offsetsMsb = data[p + 3];
+        const carrierMsb2 = view.getInt8(p + 4);
+        const info2 = data[p + 5];
+        if (sig2 === 31) sig2 = (info2 >> 3) + 32;
+        const sigDef2 = MEAS2_SIG[sig2] ?? null;
+        if (ant2 !== 0 || !sigDef2 || sigDef2[0] !== prn[0]) continue;
+        const code2 = sigDef2[1];
+        const freq2 = carrierFreq(sys, code2, fcn);
+        const codeOffMsb = (offsetsMsb & 7) << 29 >> 29;
+        const dopplerOffMsb = offsetsMsb >> 3 << 27 >> 27;
+        const codeOffLsb = view.getUint16(p + 6, true);
+        const carrierLsb2 = view.getUint16(p + 8, true);
+        const dopplerOffLsb = view.getUint16(p + 10, true);
+        let p2 = 0;
+        if (p1 !== 0 && (codeOffMsb !== -4 || codeOffLsb !== 0))
+          p2 = p1 + codeOffMsb * 65.536 + codeOffLsb * 1e-3;
+        let l2 = 0;
+        if (p2 !== 0 && freq2 > 0 && (carrierMsb2 !== -128 || carrierLsb2 !== 0))
+          l2 = p2 * freq2 / CLIGHT + carrierMsb2 * 65.536 + carrierLsb2 * 1e-3;
+        let d2 = null;
+        if (d1 !== null && freq1 > 0 && freq2 > 0 && (dopplerOffMsb !== -16 || dopplerOffLsb !== 0))
+          d2 = d1 * freq2 / freq1 + dopplerOffMsb * 6.5536 + dopplerOffLsb * 1e-4;
+        const cn02 = cn0Raw2 !== 255 ? cn0Raw2 * 0.25 + (sig2 === 1 || sig2 === 2 ? 0 : 10) : null;
+        curMeas.push({
+          prn,
+          sys,
+          code: code2,
+          freq: freq2,
+          pr: p2,
+          cp: l2,
+          cn0: cn02,
+          doppler: d2,
+          lockTimeMs: lock2 !== 255 ? lock2 * 1e3 : null
+        });
+      }
+    }
+  };
+  let i = 0;
+  while (i + 8 <= data.length) {
+    if (data[i] !== 36 || data[i + 1] !== 64) {
+      i++;
+      continue;
+    }
+    const len = view.getUint16(i + 6, true);
+    if (len < 8 || len % 4 !== 0) {
+      i++;
+      continue;
+    }
+    if (i + len > data.length) break;
+    if (crc16(data, i + 4, i + len) !== view.getUint16(i + 2, true)) {
+      badCrc++;
+      i++;
+      continue;
+    }
+    const id = view.getUint16(i + 4, true) & 8191;
+    const key = String(id);
+    messageCounts[key] = (messageCounts[key] ?? 0) + 1;
+    if ((id === 4027 || id === 4109 || id === 4110 || id === 4111) && len >= 16) {
+      const tow = view.getUint32(i + 8, true);
+      const wnc = view.getUint16(i + 12, true);
+      if (tow !== 4294967295 && wnc !== 65535) {
+        ensureEpoch(GPS_EPOCH_MS + wnc * MS_PER_WEEK + tow);
+        if (id === 4109) decodeMeas3Ranges(i, tow);
+        else if (id === 4110) decodeMeas3CN0(i, len);
+        else if (id === 4111) decodeMeas3Doppler(i, len);
+        else decodeMeasEpoch(i, len);
+      }
+    }
+    i += len;
+  }
+  flush();
+  return { epochs, messageCounts, obsCodes, badCrc };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSbfMeas
+});