gnss-js 1.24.0 → 1.26.0

package/dist/{chunk-WZDFZ76K.js → chunk-726LQBGM.js}

@@ -1,147 +1,12 @@
-// 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;
-}
-function setBitU(buff, pos, len, data) {
-  let mask = 2 ** (len - 1);
-  for (let i = pos; i < pos + len; i++, mask /= 2) {
-    if (data >= mask) {
-      buff[i >> 3] |= 1 << 7 - (i & 7);
-      data -= mask;
-    } else {
-      buff[i >> 3] &= ~(1 << 7 - (i & 7));
-    }
-  }
-}
-function decodeGpsLnavFrame(subframes, opts = {}) {
-  if (subframes.length < 90) return null;
-  const b = subframes;
-  let i = 24;
-  const tow1 = getBitU(b, i, 17) * 6;
-  i += 17 + 2;
-  const id1 = getBitU(b, i, 3);
-  i += 3 + 2;
-  const week10 = getBitU(b, i, 10);
-  i += 10;
-  i += 2;
-  i += 4;
-  const svHealth = getBitU(b, i, 6);
-  i += 6;
-  const iodc0 = getBitU(b, i, 2);
-  i += 2;
-  i += 1 + 87;
-  const tgdRaw = getBitS(b, i, 8);
-  i += 8;
-  const iodc1 = getBitU(b, i, 8);
-  i += 8;
-  const tocSec = getBitU(b, i, 16) * 16;
-  i += 16;
-  const af2 = getBitS(b, i, 8) * 2 ** -55;
-  i += 8;
-  const af1 = getBitS(b, i, 16) * 2 ** -43;
-  i += 16;
-  const af0 = getBitS(b, i, 22) * 2 ** -31;
-  i = 240 + 24;
-  i += 17 + 2;
-  const id2 = getBitU(b, i, 3);
-  i += 3 + 2;
-  const iode = getBitU(b, i, 8);
-  i += 8;
-  const crs = getBitS(b, i, 16) * 2 ** -5;
-  i += 16;
-  const deltaN = getBitS(b, i, 16) * 2 ** -43 * GPS_PI;
-  i += 16;
-  const m0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
-  i += 32;
-  const cuc = getBitS(b, i, 16) * 2 ** -29;
-  i += 16;
-  const e = getBitU(b, i, 32) * 2 ** -33;
-  i += 32;
-  const cus = getBitS(b, i, 16) * 2 ** -29;
-  i += 16;
-  const sqrtA = getBitU(b, i, 32) * 2 ** -19;
-  i += 32;
-  const toes = getBitU(b, i, 16) * 16;
-  i = 480 + 24;
-  i += 17 + 2;
-  const id3 = getBitU(b, i, 3);
-  i += 3 + 2;
-  const cic = getBitS(b, i, 16) * 2 ** -29;
-  i += 16;
-  const omega0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
-  i += 32;
-  const cis = getBitS(b, i, 16) * 2 ** -29;
-  i += 16;
-  const i0 = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
-  i += 32;
-  const crc = getBitS(b, i, 16) * 2 ** -5;
-  i += 16;
-  const omega = getBitS(b, i, 32) * 2 ** -31 * GPS_PI;
-  i += 32;
-  const omegaDot = getBitS(b, i, 24) * 2 ** -43 * GPS_PI;
-  i += 24;
-  const iode3 = getBitU(b, i, 8);
-  i += 8;
-  const idot = getBitS(b, i, 14) * 2 ** -43 * GPS_PI;
-  const iodc = iodc0 * 256 + iodc1;
-  if (id1 !== 1 || id2 !== 2 || id3 !== 3) return null;
-  if (iode3 !== iode || iode !== (iodc & 255)) return null;
-  const ref = opts.refWeek ?? Math.floor((Date.now() - GPS_EPOCH_MS) / 1e3 / SEC_PER_WEEK);
-  let week = week10 + 1024 * Math.round((ref - week10) / 1024);
-  if (toes < tow1 - 302400) week++;
-  else if (toes > tow1 + 302400) week--;
-  const prn = opts.prn ?? "G00";
-  const tocDate = new Date(
-    GPS_EPOCH_MS + (week * SEC_PER_WEEK + tocSec) * 1e3
-  );
-  return {
-    system: prn[0] === "J" ? "J" : "G",
-    prn,
-    tocDate,
-    // Same seconds-of-week convention as parseNavFile (rinex/nav.ts).
-    toc: tocDate.getTime() / 1e3 % SEC_PER_WEEK,
-    af0,
-    af1,
-    af2,
-    iode,
-    crs,
-    deltaN,
-    m0,
-    cuc,
-    e,
-    cus,
-    sqrtA,
-    toe: toes,
-    cic,
-    omega0,
-    cis,
-    i0,
-    crc,
-    omega,
-    omegaDot,
-    idot,
-    week,
-    svHealth,
-    tgd: tgdRaw === -128 ? 0 : tgdRaw * 2 ** -31
-    // IS-GPS-200: -128 reserved
-  };
-}
+import {
+  GPS_PI,
+  getBitS,
+  getBitU
+} from "./chunk-IQ5OIMQD.js";
 
 // src/navbits/cnav.ts
-var GPS_EPOCH_MS2 = Date.UTC(1980, 0, 6);
-var SEC_PER_WEEK2 = 7 * 86400;
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK = 7 * 86400;
 var HALF_WEEK = 302400;
 var CNAV_PREAMBLE = 139;
 var CNAV_A_REF = 26559710;
@@ -245,7 +110,7 @@ function resolveWeek(week, towSec, sec) {
   return week;
 }
 function gpsDate(week, sec) {
-  return new Date(GPS_EPOCH_MS2 + (week * SEC_PER_WEEK2 + sec) * 1e3);
+  return new Date(GPS_EPOCH_MS + (week * SEC_PER_WEEK + sec) * 1e3);
 }
 var CnavAssembler = class {
   sats = /* @__PURE__ */ new Map();
@@ -336,11 +201,6 @@ var CnavAssembler = class {
 };
 
 export {
-  GPS_PI,
-  getBitU,
-  getBitS,
-  setBitU,
-  decodeGpsLnavFrame,
   CNAV_A_REF,
   CNAV_OMEGA_DOT_REF,
   crc24q,

package/dist/{chunk-PZNVFCKJ.js → chunk-AFEDNWXI.js}

@@ -7,14 +7,16 @@ import {
   galFnavPageCrcOk,
   galInavPageCrcOk,
   testGloString
-} from "./chunk-VTX3VCL4.js";
+} from "./chunk-5AUK42AL.js";
 import {
   CnavAssembler,
   cnavCrcOk,
-  crc24q,
+  crc24q
+} from "./chunk-726LQBGM.js";
+import {
   getBitS,
   getBitU
-} from "./chunk-WZDFZ76K.js";
+} from "./chunk-IQ5OIMQD.js";
 import {
   getGpsLeap
 } from "./chunk-HVXYFUCB.js";

package/dist/chunk-CKRNXZHT.js

@@ -0,0 +1,424 @@
+// src/trimble/frame.ts
+var STX = 2;
+var ETX = 3;
+var RAWDATA = 87;
+var RETSVDATA = 85;
+function* trimbleFrames(data, stats) {
+  let i = 0;
+  while (i + 6 <= data.length) {
+    if (data[i] !== STX) {
+      i++;
+      continue;
+    }
+    const len = data[i + 3];
+    const total = 4 + len + 2;
+    if (i + total > data.length) {
+      i++;
+      continue;
+    }
+    if (data[i + total - 1] !== ETX) {
+      i++;
+      continue;
+    }
+    let cs = 0;
+    for (let k = 1; k <= 3 + len; k++) cs = cs + data[i + k] & 255;
+    if (cs !== data[i + 4 + len]) {
+      stats.badChecksum++;
+      i++;
+      continue;
+    }
+    yield {
+      start: i,
+      status: data[i + 1],
+      type: data[i + 2],
+      len,
+      payload: i + 4
+    };
+    i += total;
+  }
+}
+
+// src/trimble/nav.ts
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK = 7 * 86400;
+var MS_PER_WEEK = SEC_PER_WEEK * 1e3;
+var GPS_PI = 3.1415926535898;
+var gpsMs = (week, sec) => GPS_EPOCH_MS + week * MS_PER_WEEK + sec * 1e3;
+var sowOf = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK;
+var SUB_GPS_EPHEMERIS = 1;
+var SUB_ION_UTC = 3;
+function decodeGpsEphemeris(data, view, base) {
+  const prn = data[base + 5];
+  if (prn < 1 || prn > 32) return null;
+  const week = view.getUint16(base + 6, false);
+  const iode = data[base + 11];
+  const toc = view.getInt32(base + 16, false);
+  const toe = view.getUint32(base + 20, false);
+  const tgd = view.getFloat64(base + 24, false);
+  const af2 = view.getFloat64(base + 32, false);
+  const af1 = view.getFloat64(base + 40, false);
+  const af0 = view.getFloat64(base + 48, false);
+  const crs = view.getFloat64(base + 56, false);
+  const deltaN = view.getFloat64(base + 64, false) * GPS_PI;
+  const m0 = view.getFloat64(base + 72, false) * GPS_PI;
+  const cuc = view.getFloat64(base + 80, false) * GPS_PI;
+  const e = view.getFloat64(base + 88, false);
+  const cus = view.getFloat64(base + 96, false) * GPS_PI;
+  const sqrtA = view.getFloat64(base + 104, false);
+  const cic = view.getFloat64(base + 112, false) * GPS_PI;
+  const omega0 = view.getFloat64(base + 120, false) * GPS_PI;
+  const cis = view.getFloat64(base + 128, false) * GPS_PI;
+  const i0 = view.getFloat64(base + 136, false) * GPS_PI;
+  const crc = view.getFloat64(base + 144, false);
+  const omega = view.getFloat64(base + 152, false) * GPS_PI;
+  const omegaDot = view.getFloat64(base + 160, false) * GPS_PI;
+  const idot = view.getFloat64(base + 168, false) * GPS_PI;
+  const flags = view.getUint32(base + 176, false);
+  return {
+    system: "G",
+    prn: `G${String(prn).padStart(2, "0")}`,
+    toc: sowOf(gpsMs(week, toc)),
+    tocDate: new Date(gpsMs(week, toc)),
+    af0,
+    af1,
+    af2,
+    iode,
+    crs,
+    deltaN,
+    m0,
+    cuc,
+    e,
+    cus,
+    sqrtA,
+    toe,
+    cic,
+    omega0,
+    cis,
+    i0,
+    crc,
+    omega,
+    omegaDot,
+    idot,
+    week,
+    svHealth: flags >>> 4 & 127,
+    tgd
+  };
+}
+function parseTrimbleNav(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const stats = { badChecksum: 0 };
+  const ephemerides = [];
+  const ionoCorrections = {};
+  const retsvCounts = {};
+  let leapSeconds = null;
+  const lastIode = /* @__PURE__ */ new Map();
+  for (const f of trimbleFrames(data, stats)) {
+    if (f.type !== RETSVDATA) continue;
+    const sub = data[f.payload];
+    retsvCounts[sub] = (retsvCounts[sub] ?? 0) + 1;
+    if (sub === SUB_GPS_EPHEMERIS && f.len >= 178) {
+      const eph = decodeGpsEphemeris(data, view, f.start);
+      if (!eph) continue;
+      if (lastIode.get(eph.prn) === eph.iode) continue;
+      lastIode.set(eph.prn, eph.iode);
+      ephemerides.push(eph);
+    } else if (sub === SUB_ION_UTC && f.len >= 125) {
+      const p = f.start;
+      const alpha = [];
+      const beta = [];
+      for (let i = 0; i < 4; i++) {
+        alpha.push(view.getFloat64(p + 6 + i * 8, false));
+        beta.push(view.getFloat64(p + 38 + i * 8, false));
+      }
+      ionoCorrections["GPSA"] = alpha;
+      ionoCorrections["GPSB"] = beta;
+      leapSeconds = Math.trunc(view.getFloat64(p + 94, false));
+    }
+  }
+  return {
+    ephemerides,
+    ionoCorrections,
+    leapSeconds,
+    retsvCounts,
+    badChecksum: stats.badChecksum
+  };
+}
+
+// src/trimble/index.ts
+var GPS_EPOCH_MS2 = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK2 = 7 * 864e5;
+var REC_TYPE_27 = 6;
+var SYS = {
+  0: "G",
+  // GPS
+  1: "S",
+  // SBAS
+  2: "R",
+  // GLONASS
+  3: "E",
+  // Galileo
+  4: "J",
+  // QZSS
+  5: "C",
+  // BeiDou (pre-ICD numbering)
+  7: "C",
+  // BeiDou (ICD numbering)
+  9: "I",
+  // NavIC / IRNSS
+  10: "C"
+  // BeiDou
+};
+var CODES = {
+  "G0-0": "1C",
+  "G0-20": "1L",
+  "G1-2": "2W",
+  "G1-5": "2L",
+  "G2-6": "5I",
+  "G2-7": "5Q",
+  "G2-8": "5X",
+  "R0-0": "1C",
+  "R0-1": "1P",
+  "R1-0": "2C",
+  "R1-1": "2P",
+  "E0-23": "1C",
+  "E2-11": "5Q",
+  "E3-11": "7Q",
+  "E4-14": "8Q",
+  "E5-36": "6C",
+  "C0-20": "1P",
+  "C2-8": "5P",
+  "C3-6": "7D",
+  "C6-26": "2I",
+  "C7-29": "6I",
+  "S0-0": "1C",
+  "S2-6": "5I",
+  "J0-0": "1C"
+};
+var BAND_DIGIT = {
+  0: "1",
+  // L1 / E1 / B1C (1575.42)
+  1: "2",
+  // L2 / G2 (1227.6)
+  2: "5",
+  // L5 / E5a (1176.45)
+  3: "7",
+  // E5b / B2b (1207.14)
+  4: "8",
+  // E5 AltBOC (1191.795)
+  5: "6",
+  // E6 (1278.75)
+  6: "2",
+  // B1I (1561.098)
+  7: "6",
+  // B3I (1268.52)
+  8: "1",
+  // BeiDou E1 (1589.742)
+  9: "3",
+  // GLONASS G3 CDMA (1202.025)
+  11: "9"
+  // NavIC S-band (2492.028)
+};
+function rinexCode(sys, band, track) {
+  const key = `${sys}${band}-${track}`;
+  return CODES[key] ?? `${BAND_DIGIT[band] ?? "?"}X`;
+}
+function rinexPrn(sys, svid) {
+  let n = svid;
+  if (sys === "S")
+    n = svid - 100;
+  else if (sys === "J" && svid >= 193) n = svid - 192;
+  return `${sys}${String(n).padStart(2, "0")}`;
+}
+var readS16 = (dv, o) => dv.getInt16(o, false);
+function readS24(d, o) {
+  const v = d[o] << 16 | d[o + 1] << 8 | d[o + 2];
+  return v & 8388608 ? v - 16777216 : v;
+}
+function readS48(d, dv, o) {
+  const hi = d[o] << 8 | d[o + 1];
+  const lo = dv.getUint32(o + 2, false);
+  const v = hi * 4294967296 + lo;
+  return hi & 32768 ? v - 281474976710656 : v;
+}
+function parseTrimble(data) {
+  const stats = { badChecksum: 0 };
+  const epochs = [];
+  const obsCodes = {};
+  const recordCounts = {};
+  const retsvCounts = {};
+  let pages = [];
+  let msgReply = -1;
+  let lastPage = 0;
+  let msgPages = 0;
+  let epoch = null;
+  const finalize = () => {
+    if (epoch) decodeEpoch(epoch, epochs, obsCodes);
+    epoch = null;
+  };
+  const onMessage = (content, reply) => {
+    if (epoch && reply === epoch.reply) {
+      epoch.chunks.push(content);
+      return;
+    }
+    finalize();
+    if (content.length < 12) return;
+    const dv = new DataView(
+      content.buffer,
+      content.byteOffset,
+      content.byteLength
+    );
+    const headerLen = content[0];
+    const week = dv.getUint16(1, false);
+    const towMs = dv.getUint32(3, false);
+    const nsv = content[10];
+    const eflags = content[11];
+    if (week < 1024 || week > 4096 || headerLen < 12 || nsv === 0) return;
+    let svStart = headerLen;
+    if (eflags & 32 && svStart < content.length) svStart += content[svStart];
+    epoch = {
+      reply,
+      week,
+      towMs,
+      nsv,
+      chunks: [content.subarray(svStart)]
+    };
+  };
+  const completeMessage = () => {
+    const total = pages.reduce((a, c) => a + c.length, 0);
+    const content = new Uint8Array(total);
+    let o = 0;
+    for (const c of pages) {
+      content.set(c, o);
+      o += c.length;
+    }
+    const reply = msgReply;
+    pages = [];
+    onMessage(content, reply);
+  };
+  for (const f of trimbleFrames(data, stats)) {
+    if (f.type !== RAWDATA) {
+      if (f.type === 85) {
+        const sub = data[f.payload];
+        retsvCounts[sub] = (retsvCounts[sub] ?? 0) + 1;
+      }
+      continue;
+    }
+    const recType = data[f.payload];
+    recordCounts[recType] = (recordCounts[recType] ?? 0) + 1;
+    if (recType !== REC_TYPE_27) continue;
+    const pageByte = data[f.payload + 1];
+    const page = pageByte >> 4;
+    const pagesTotal = pageByte & 15;
+    const reply = data[f.payload + 2];
+    const content = data.subarray(f.payload + 4, f.payload + f.len);
+    if (page === 1) {
+      pages = [content];
+      msgReply = reply;
+      msgPages = pagesTotal;
+      lastPage = 1;
+    } else if (reply === msgReply && page === lastPage + 1) {
+      pages.push(content);
+      lastPage = page;
+    } else {
+      pages = [];
+      continue;
+    }
+    if (lastPage === msgPages) completeMessage();
+  }
+  finalize();
+  return {
+    epochs,
+    obsCodes,
+    recordCounts,
+    retsvCounts,
+    badChecksum: stats.badChecksum
+  };
+}
+function decodeEpoch(epoch, epochs, obsCodes) {
+  const total = epoch.chunks.reduce((a, c) => a + c.length, 0);
+  const M = new Uint8Array(total);
+  let o = 0;
+  for (const c of epoch.chunks) {
+    M.set(c, o);
+    o += c.length;
+  }
+  const dv = new DataView(M.buffer, M.byteOffset, M.byteLength);
+  const timeMs = GPS_EPOCH_MS2 + epoch.week * MS_PER_WEEK2 + epoch.towMs;
+  const meas = [];
+  let q = 0;
+  for (let sv = 0; sv < epoch.nsv && q + 8 <= M.length; sv++) {
+    const svLen = M[q];
+    if (svLen < 8 || q + svLen > M.length) break;
+    const svid = M[q + 1];
+    const sys = SYS[M[q + 2] & 63];
+    const chan = M[q + 3] << 24 >> 24;
+    const nblk = M[q + 4];
+    const prn = sys ? rinexPrn(sys, svid) : null;
+    const gloChannel = sys === "R" ? chan : null;
+    let r = q + svLen;
+    let pr0 = 0;
+    for (let b = 0; b < nblk; b++) {
+      if (r + 5 > M.length) break;
+      const mLen = M[r];
+      if (mLen < 5 || r + mLen > M.length) break;
+      const band = M[r + 1];
+      const track = M[r + 2];
+      const cn0 = dv.getUint16(r + 3, false) / 10;
+      let p = r + 5;
+      let pr;
+      if (b === 0) {
+        const scale = sys === "S" || sys === "J" ? 64 : 128;
+        pr = dv.getUint32(p, false) / scale;
+        p += 4;
+        pr0 = pr;
+      } else {
+        pr = pr0 + readS16(dv, p) / 256;
+        p += 2;
+      }
+      const cp = -readS48(M, dv, p) / 32768;
+      p += 6;
+      const cycleSlipCount = M[p];
+      p += 1;
+      const mf = M[p];
+      p += 1;
+      let mf2 = 0;
+      if (mf & 128) {
+        mf2 = M[p];
+        p += 1;
+        let f = mf2;
+        while (f & 128) {
+          f = M[p];
+          p += 1;
+        }
+      }
+      if (mf2 & 1) p += 1;
+      let doppler = null;
+      if (mf & 4) doppler = readS24(M, p) / 256;
+      if (prn && sys) {
+        const code = rinexCode(sys, band, track);
+        meas.push({
+          prn,
+          code,
+          pr: mf & 2 ? pr : null,
+          cp: mf & 1 ? cp : null,
+          doppler: mf & 1 ? doppler : null,
+          cn0,
+          cycleSlipCount,
+          cycleSlip: (mf & 8) !== 0,
+          gloChannel
+        });
+        const list = obsCodes[sys] ??= [];
+        if (!list.includes(code)) list.push(code);
+      }
+      r += mLen;
+    }
+    q = r;
+  }
+  epochs.push({ timeMs, meas });
+}
+
+export {
+  trimbleFrames,
+  parseTrimbleNav,
+  parseTrimble
+};

package/dist/{chunk-7RKLWE6R.js → chunk-F4CM6Q4F.js}

@@ -1,8 +1,10 @@
 import {
   CnavAssembler,
-  cnavCrcOk,
+  cnavCrcOk
+} from "./chunk-726LQBGM.js";
+import {
   decodeGpsLnavFrame
-} from "./chunk-WZDFZ76K.js";
+} from "./chunk-IQ5OIMQD.js";
 import {
   getUtcDate
 } from "./chunk-HVXYFUCB.js";

package/dist/{chunk-MCAVU3XL.js → chunk-FEOMYZEU.js}

@@ -5,15 +5,17 @@ import {
   bdsSubframeParityOk,
   galInavPageCrcOk,
   testGloString
-} from "./chunk-VTX3VCL4.js";
+} from "./chunk-5AUK42AL.js";
 import {
   CnavAssembler,
-  cnavCrcOk,
+  cnavCrcOk
+} from "./chunk-726LQBGM.js";
+import {
   decodeGpsLnavFrame,
   getBitS,
   getBitU,
   setBitU
-} from "./chunk-WZDFZ76K.js";
+} from "./chunk-IQ5OIMQD.js";
 
 // src/ubx/frame.ts
 function* ubxFrames(data, stats = { badChecksums: 0 }) {