gnss-js 1.20.0 → 1.21.0

package/dist/{chunk-VJEPOC76.js → chunk-K3V3NHWL.js}

@@ -1335,6 +1335,529 @@ function parseSbfGloNav(data) {
   return { ephemerides, badCrc, messages };
 }
 
+// src/navbits/rs255.ts
+var RS255_N = 255;
+var RS255_K = 32;
+var EXP = new Uint8Array(510);
+var LOG = new Int16Array(256).fill(-1);
+{
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    EXP[i] = x;
+    LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 510; i++) EXP[i] = EXP[i - 255];
+}
+var gfMul = (a, b) => a === 0 || b === 0 ? 0 : EXP[LOG[a] + LOG[b]];
+var gfInv = (a) => EXP[255 - LOG[a]];
+var GEN_POLY = (() => {
+  let g = new Uint8Array([1]);
+  for (let i = 1; i <= 223; i++) {
+    const root = EXP[i];
+    const next = new Uint8Array(g.length + 1);
+    for (let j = 0; j < g.length; j++) {
+      next[j] ^= g[j];
+      next[j + 1] ^= gfMul(g[j], root);
+    }
+    g = next;
+  }
+  return g;
+})();
+function rs255Encode(info) {
+  if (info.length > RS255_K)
+    throw new RangeError(`rs255Encode: info length ${info.length} > 32`);
+  const cw = new Uint8Array(RS255_N);
+  cw.set(info, 0);
+  const work = new Uint8Array(RS255_N);
+  work.set(info, 0);
+  for (let i = 0; i < RS255_K; i++) {
+    const coef = work[i];
+    if (coef === 0) continue;
+    for (let j = 1; j < GEN_POLY.length; j++)
+      work[i + j] ^= gfMul(GEN_POLY[j], coef);
+  }
+  cw.set(work.subarray(RS255_K), RS255_K);
+  return cw;
+}
+var genMatrix = null;
+function generatorMatrix() {
+  if (genMatrix) return genMatrix;
+  const rows = [];
+  for (let r = 0; r < RS255_N; r++) rows.push(new Uint8Array(RS255_K));
+  for (let c = 0; c < RS255_K; c++) {
+    const e = new Uint8Array(RS255_K);
+    e[c] = 1;
+    const cw = rs255Encode(e);
+    for (let r = 0; r < RS255_N; r++) rows[r][c] = cw[r];
+  }
+  genMatrix = rows;
+  return rows;
+}
+function rs255DecodeErasures(pages, k) {
+  if (k < 1 || k > RS255_K) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const use = [];
+  for (const p of pages) {
+    if (p.pageId < 1 || p.pageId > RS255_N || seen.has(p.pageId)) continue;
+    seen.add(p.pageId);
+    use.push(p);
+    if (use.length === k) break;
+  }
+  if (use.length < k) return null;
+  const width = use[0].octets.length;
+  if (use.some((p) => p.octets.length !== width)) return null;
+  const G = generatorMatrix();
+  const a = use.map((p) => G[p.pageId - 1].slice(0, k));
+  const inv = use.map((_, r) => {
+    const row = new Uint8Array(k);
+    row[r] = 1;
+    return row;
+  });
+  for (let c = 0; c < k; c++) {
+    let pivot = -1;
+    for (let r = c; r < k; r++)
+      if (a[r][c] !== 0) {
+        pivot = r;
+        break;
+      }
+    if (pivot < 0) return null;
+    [a[c], a[pivot]] = [a[pivot], a[c]];
+    [inv[c], inv[pivot]] = [inv[pivot], inv[c]];
+    const s = gfInv(a[c][c]);
+    for (let j = 0; j < k; j++) {
+      a[c][j] = gfMul(a[c][j], s);
+      inv[c][j] = gfMul(inv[c][j], s);
+    }
+    for (let r = 0; r < k; r++) {
+      if (r === c || a[r][c] === 0) continue;
+      const f = a[r][c];
+      for (let j = 0; j < k; j++) {
+        a[r][j] ^= gfMul(a[c][j], f);
+        inv[r][j] ^= gfMul(inv[c][j], f);
+      }
+    }
+  }
+  const out = new Uint8Array(k * width);
+  for (let r = 0; r < k; r++)
+    for (let c = 0; c < width; c++) {
+      let v = 0;
+      for (let j = 0; j < k; j++) v ^= gfMul(inv[r][j], use[j].octets[c]);
+      out[r * width + c] = v;
+    }
+  return out;
+}
+
+// src/navbits/has.ts
+var HAS_DUMMY_HEADER = 11484099;
+var HAS_VALIDITY_SECONDS = [
+  5,
+  10,
+  15,
+  20,
+  30,
+  60,
+  90,
+  120,
+  180,
+  240,
+  300,
+  600,
+  900,
+  1800,
+  3600,
+  null
+];
+var HAS_GPS_SIGNALS = [
+  "L1 C/A",
+  "Reserved",
+  "Reserved",
+  "L1C(D)",
+  "L1C(P)",
+  "L1C(D+P)",
+  "L2 CM",
+  "L2 CL",
+  "L2 CM+CL",
+  "L2 P",
+  "Reserved",
+  "L5 I",
+  "L5 Q",
+  "L5 I+Q",
+  "Reserved",
+  "Reserved"
+];
+var HAS_GALILEO_SIGNALS = [
+  "E1-B",
+  "E1-C",
+  "E1-B+E1-C",
+  "E5a-I",
+  "E5a-Q",
+  "E5a-I+E5a-Q",
+  "E5b-I",
+  "E5b-Q",
+  "E5b-I+E5b-Q",
+  "E5-I",
+  "E5-Q",
+  "E5-I+E5-Q",
+  "E6-B",
+  "E6-C",
+  "E6-B+E6-C",
+  "Reserved"
+];
+var SYSTEM_OF_GNSS_ID = { 0: "G", 2: "E" };
+var IOD_BITS = { G: 8, E: 10 };
+function hasPageCrcOk(page) {
+  if (page.length < 61) return false;
+  return crc24q(page, 462) === getBitU(page, 462, 24);
+}
+function parseHasPage(page) {
+  if (getBitU(page, 14, 24) === HAS_DUMMY_HEADER) return null;
+  const body = new Uint8Array(53);
+  for (let i = 0; i < 53; i++) body[i] = getBitU(page, 38 + 8 * i, 8);
+  return {
+    status: getBitU(page, 14, 2),
+    messageType: getBitU(page, 18, 2),
+    messageId: getBitU(page, 20, 5),
+    messageSize: getBitU(page, 25, 5) + 1,
+    pageId: getBitU(page, 30, 8),
+    body
+  };
+}
+var Cursor = class {
+  constructor(buf, bits) {
+    this.buf = buf;
+    this.bits = bits;
+  }
+  pos = 0;
+  u(len) {
+    if (this.pos + len > this.bits) throw new RangeError("truncated");
+    const v = getBitU(this.buf, this.pos, len);
+    this.pos += len;
+    return v;
+  }
+  s(len) {
+    if (this.pos + len > this.bits) throw new RangeError("truncated");
+    const v = getBitS(this.buf, this.pos, len);
+    this.pos += len;
+    return v;
+  }
+};
+var prnOf = (system, idx) => `${system}${String(idx + 1).padStart(2, "0")}`;
+function parseMaskBlock(c, maskId) {
+  const nSys = c.u(4);
+  const systems = [];
+  for (let s = 0; s < nSys; s++) {
+    const gnssId = c.u(4);
+    const system = SYSTEM_OF_GNSS_ID[gnssId];
+    if (system === void 0) throw new RangeError(`unknown GNSS ID ${gnssId}`);
+    const prns = [];
+    for (let b = 0; b < 40; b++) if (c.u(1)) prns.push(prnOf(system, b));
+    const signalIndices = [];
+    for (let b = 0; b < 16; b++) if (c.u(1)) signalIndices.push(b);
+    const signalNames = system === "G" ? HAS_GPS_SIGNALS : HAS_GALILEO_SIGNALS;
+    let cellMask = null;
+    if (c.u(1)) {
+      cellMask = prns.map(() => signalIndices.map(() => c.u(1) === 1));
+    }
+    systems.push({
+      gnssId,
+      system,
+      prns,
+      signalIndices,
+      signals: signalIndices.map((i) => signalNames[i]),
+      cellMask,
+      navMessage: c.u(3)
+    });
+  }
+  c.u(6);
+  return { maskId, systems };
+}
+function parseOrbitBlock(c, masks) {
+  const validityIndex = c.u(4);
+  const corrections = [];
+  for (const sys of masks.systems) {
+    for (const prn of sys.prns) {
+      const gnssIod = c.u(IOD_BITS[sys.system]);
+      const rad = c.s(13);
+      const inT = c.s(12);
+      const cross = c.s(12);
+      corrections.push({
+        system: sys.system,
+        prn,
+        gnssIod,
+        deltaRadial: rad === -4096 ? null : rad * 25e-4,
+        deltaInTrack: inT === -2048 ? null : inT * 8e-3,
+        deltaCrossTrack: cross === -2048 ? null : cross * 8e-3
+      });
+    }
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    corrections
+  };
+}
+function clockValue(c, system, prn, multiplier) {
+  const raw = c.s(13);
+  return {
+    system,
+    prn,
+    deltaClock: raw === -4096 || raw === 4095 ? null : raw * 25e-4 * multiplier,
+    notUsable: raw === 4095
+  };
+}
+function parseClockFullBlock(c, masks) {
+  const validityIndex = c.u(4);
+  const multipliers = masks.systems.map((sys) => ({
+    system: sys.system,
+    multiplier: c.u(2) + 1
+  }));
+  const corrections = [];
+  for (let s = 0; s < masks.systems.length; s++) {
+    const sys = masks.systems[s];
+    for (const prn of sys.prns)
+      corrections.push(
+        clockValue(c, sys.system, prn, multipliers[s].multiplier)
+      );
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    multipliers,
+    corrections
+  };
+}
+function parseClockSubsetBlock(c, masks) {
+  const validityIndex = c.u(4);
+  const nSys = c.u(4);
+  const multipliers = [];
+  const corrections = [];
+  for (let s = 0; s < nSys; s++) {
+    const gnssId = c.u(4);
+    const sys = masks.systems.find((m) => m.gnssId === gnssId);
+    if (!sys) throw new RangeError(`subset GNSS ID ${gnssId} not in mask`);
+    const multiplier = c.u(2) + 1;
+    multipliers.push({ system: sys.system, multiplier });
+    const selected = [];
+    for (const prn of sys.prns) if (c.u(1)) selected.push(prn);
+    for (const prn of selected)
+      corrections.push(clockValue(c, sys.system, prn, multiplier));
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    multipliers,
+    corrections
+  };
+}
+function parseBiasBlock(c, masks, kind) {
+  const validityIndex = c.u(4);
+  const biases = [];
+  for (const sys of masks.systems) {
+    for (let s = 0; s < sys.prns.length; s++) {
+      for (let g = 0; g < sys.signalIndices.length; g++) {
+        if (sys.cellMask && !sys.cellMask[s][g]) continue;
+        const raw = c.s(11);
+        const entry = {
+          system: sys.system,
+          prn: sys.prns[s],
+          signalIndex: sys.signalIndices[g],
+          signal: sys.signals[g],
+          bias: raw === -1024 ? null : raw * (kind === "code" ? 0.02 : 0.01)
+        };
+        if (kind === "phase") entry.discontinuity = c.u(2);
+        biases.push(entry);
+      }
+    }
+  }
+  return {
+    validityIndex,
+    validitySeconds: HAS_VALIDITY_SECONDS[validityIndex],
+    biases
+  };
+}
+function parseHasMt1(payload, header, cachedMasks) {
+  const c = new Cursor(payload, payload.length * 8);
+  const toh = c.u(12);
+  const flags = {
+    mask: c.u(1) === 1,
+    orbit: c.u(1) === 1,
+    clockFullSet: c.u(1) === 1,
+    clockSubset: c.u(1) === 1,
+    codeBias: c.u(1) === 1,
+    phaseBias: c.u(1) === 1
+  };
+  c.u(4);
+  const maskId = c.u(5);
+  const iodSetId = c.u(5);
+  const msg = {
+    ...header,
+    toh,
+    maskId,
+    iodSetId,
+    flags,
+    maskFromCache: false,
+    parseError: null
+  };
+  try {
+    let masks;
+    if (flags.mask) {
+      masks = parseMaskBlock(c, maskId);
+    } else if (cachedMasks) {
+      masks = cachedMasks;
+      msg.maskFromCache = true;
+    } else {
+      msg.parseError = "mask-unavailable";
+      return msg;
+    }
+    msg.masks = masks;
+    if (flags.orbit) msg.orbit = parseOrbitBlock(c, masks);
+    if (flags.clockFullSet) msg.clockFullSet = parseClockFullBlock(c, masks);
+    if (flags.clockSubset) msg.clockSubset = parseClockSubsetBlock(c, masks);
+    if (flags.codeBias) msg.codeBias = parseBiasBlock(c, masks, "code");
+    if (flags.phaseBias) msg.phaseBias = parseBiasBlock(c, masks, "phase");
+  } catch (e) {
+    msg.parseError = e instanceof Error ? e.message : String(e);
+  }
+  return msg;
+}
+var HasAssembler = class {
+  slots = /* @__PURE__ */ new Map();
+  lastMessageId = -1;
+  maskCache = /* @__PURE__ */ new Map();
+  /** Pages a message may span before its slot is restarted (s). */
+  timeoutSec;
+  stats = {
+    pages: 0,
+    dummyPages: 0,
+    skippedPages: 0,
+    duplicatePages: 0,
+    resets: 0,
+    messages: 0,
+    parseErrors: 0
+  };
+  constructor(opts = {}) {
+    this.timeoutSec = opts.timeoutSec ?? 30;
+  }
+  /**
+   * Push one 492-bit C/NAV page (≥ 61 bytes; check the CRC first with
+   * `hasPageCrcOk`). `tow` — a receiver time of week in seconds, any
+   * origin as long as it is common to all pages — enables the slot
+   * timeout and is stamped on completed messages.
+   */
+  push(page, tow) {
+    const p = parseHasPage(page);
+    if (!p) {
+      this.stats.dummyPages++;
+      return null;
+    }
+    this.stats.pages++;
+    if (p.messageType !== 1 || p.status > 1 || p.pageId === 0) {
+      this.stats.skippedPages++;
+      return null;
+    }
+    if (p.messageId === this.lastMessageId) return null;
+    let slot = this.slots.get(p.messageId);
+    const timedOut = slot?.firstTow !== void 0 && tow !== void 0 && tow - slot.firstTow > this.timeoutSec;
+    if (slot && (slot.messageSize !== p.messageSize || timedOut)) {
+      this.stats.resets++;
+      slot = void 0;
+    }
+    if (!slot) {
+      slot = {
+        messageSize: p.messageSize,
+        status: p.status,
+        pages: [],
+        bodies: /* @__PURE__ */ new Map(),
+        firstTow: tow
+      };
+      this.slots.set(p.messageId, slot);
+    }
+    const bodyKey = Array.from(
+      p.body,
+      (b) => b.toString(16).padStart(2, "0")
+    ).join("");
+    const existing = slot.bodies.get(p.pageId);
+    if (existing !== void 0) {
+      if (existing === bodyKey) {
+        this.stats.duplicatePages++;
+        return null;
+      }
+      this.stats.resets++;
+      slot.pages = [];
+      slot.bodies.clear();
+      slot.firstTow = tow;
+    }
+    slot.bodies.set(p.pageId, bodyKey);
+    slot.pages.push({ pageId: p.pageId, octets: p.body });
+    if (slot.pages.length < slot.messageSize) return null;
+    const payload = rs255DecodeErasures(slot.pages, slot.messageSize);
+    if (!payload) return null;
+    this.slots.delete(p.messageId);
+    this.lastMessageId = p.messageId;
+    const msg = parseHasMt1(
+      payload,
+      {
+        status: slot.status,
+        messageId: p.messageId,
+        messageSize: slot.messageSize
+      },
+      void 0
+    );
+    const resolved = msg.parseError === "mask-unavailable" && this.maskCache.has(msg.maskId) ? parseHasMt1(
+      payload,
+      {
+        status: slot.status,
+        messageId: p.messageId,
+        messageSize: slot.messageSize
+      },
+      this.maskCache.get(msg.maskId)
+    ) : msg;
+    if (resolved.flags.mask && resolved.masks)
+      this.maskCache.set(resolved.maskId, resolved.masks);
+    if (tow !== void 0) resolved.tow = tow;
+    this.stats.messages++;
+    if (resolved.parseError !== null) this.stats.parseErrors++;
+    return resolved;
+  }
+};
+
+// src/sbf/rawnav-has.ts
+function parseSbfHas(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const assembler = new HasAssembler();
+  const messages = [];
+  let pagesSeen = 0;
+  let pagesBadCrc = 0;
+  scanSbfFrames(data, view, (id, b, len) => {
+    if (id !== 4024 || len < 84) return;
+    pagesSeen++;
+    const page = new Uint8Array(64);
+    for (let k = 0; k < 16; k++) {
+      const w = view.getUint32(b + 20 + 4 * k, true);
+      page[4 * k] = w >>> 24;
+      page[4 * k + 1] = w >>> 16 & 255;
+      page[4 * k + 2] = w >>> 8 & 255;
+      page[4 * k + 3] = w & 255;
+    }
+    if (!hasPageCrcOk(page)) {
+      pagesBadCrc++;
+      return;
+    }
+    const tow = view.getUint32(b + 8, true) / 1e3;
+    const msg = assembler.push(page, tow);
+    if (msg) messages.push({ ...msg, tow, wnc: view.getUint16(b + 12, true) });
+  });
+  return {
+    messages,
+    pagesSeen,
+    pagesBadCrc,
+    pagesDummy: assembler.stats.dummyPages,
+    pagesHas: assembler.stats.pages
+  };
+}
+
 // src/sbf/index.ts
 var CLIGHT = 299792458;
 var GPS_EPOCH_MS5 = Date.UTC(1980, 0, 6);
@@ -2013,5 +2536,6 @@ export {
   parseSbfGalNav,
   parseSbfBdsNav,
   parseSbfGloNav,
+  parseSbfHas,
   parseSbfMeas
 };