gnss-js 1.25.0 → 1.27.0

package/dist/index.cjs

@@ -111,6 +111,10 @@ __export(src_exports, {
   analyzeQuality: () => analyzeQuality,
   applyHelmert: () => applyHelmert,
   applyIonoDcb: () => applyIonoDcb,
+  binexCrc16: () => binexCrc16,
+  binexCrc32: () => binexCrc32,
+  binexCsum8: () => binexCsum8,
+  binexRecords: () => binexRecords,
   buildGloChannelMap: () => buildGloChannelMap,
   buildObsIndices: () => buildObsIndices,
   clampUnit: () => clampUnit,
@@ -131,6 +135,7 @@ __export(src_exports, {
   crxDecompress: () => crxDecompress,
   crxRepair: () => crxRepair,
   dateToEpoch: () => dateToEpoch,
+  decodeBinexEph: () => decodeBinexEph,
   decodeEphemeris: () => decodeEphemeris,
   decodeMsmFull: () => decodeMsmFull,
   deg2dms: () => deg2dms,
@@ -152,6 +157,7 @@ __export(src_exports, {
   geodeticToUtm: () => geodeticToUtm,
   getAer: () => getAer,
   getBdsTime: () => getBdsTime,
+  getBnxi: () => getBnxi,
   getDateFromBdsTime: () => getDateFromBdsTime,
   getDateFromDayOfWeek: () => getDateFromDayOfWeek,
   getDateFromDayOfYear: () => getDateFromDayOfYear,
@@ -225,6 +231,7 @@ __export(src_exports, {
   padL: () => padL,
   padR: () => padR,
   parseAntex: () => parseAntex,
+  parseBinex: () => parseBinex,
   parseCrxDataLine: () => parseCrxDataLine,
   parseIonex: () => parseIonex,
   parseNavFile: () => parseNavFile,
@@ -244,6 +251,8 @@ __export(src_exports, {
   parseSinexBiasDcb: () => parseSinexBiasDcb,
   parseSourcetable: () => parseSourcetable,
   parseSp3: () => parseSp3,
+  parseTrimble: () => parseTrimble,
+  parseTrimbleNav: () => parseTrimbleNav,
   parseUbxCnav: () => parseUbxCnav,
   parseUbxIonoUtc: () => parseUbxIonoUtc,
   parseUbxNav: () => parseUbxNav,
@@ -274,11 +283,13 @@ __export(src_exports, {
   systemName: () => systemName,
   toRtkEpoch: () => toRtkEpoch,
   transformFrame: () => transformFrame,
+  trimbleFrames: () => trimbleFrames,
   ubxFrames: () => ubxFrames,
   updateStationMeta: () => updateStationMeta,
   updateStreamStats: () => updateStreamStats,
   verifyChecksum: () => verifyChecksum,
   vincenty: () => vincenty,
+  writeCrx: () => writeCrx,
   writeModernObsBlob: () => writeModernObsBlob,
   writeRinex2ObsBlob: () => writeRinex2ObsBlob,
   writeRinex4ObsBlob: () => writeRinex4ObsBlob,
@@ -1309,6 +1320,442 @@ function crxDecompress(prev, field) {
   };
 }
 
+// src/rinex/crx-writer.ts
+var ARC_ORDER = 3;
+function emptyData() {
+  return { u: [0, 0, 0, 0], l: [0, 0, 0, 0], order: -1 };
+}
+function cAtol(s) {
+  let i = 0;
+  while (i < s.length && (s[i] === " " || s[i] === "	")) i++;
+  let sign = 1;
+  if (s[i] === "+" || s[i] === "-") {
+    if (s[i] === "-") sign = -1;
+    i++;
+  }
+  let n = 0;
+  let any = false;
+  while (i < s.length && s[i] >= "0" && s[i] <= "9") {
+    n = n * 10 + (s.charCodeAt(i) - 48);
+    i++;
+    any = true;
+  }
+  return any ? sign * n : 0;
+}
+function strdiff(s1, s2) {
+  let ds = "";
+  const n = Math.min(s1.length, s2.length);
+  let i = 0;
+  for (; i < n; i++) {
+    if (s2[i] === s1[i]) ds += " ";
+    else if (s2[i] === " ") ds += "&";
+    else ds += s2[i];
+  }
+  if (s1.length > s2.length) {
+    for (let k = i; k < s1.length; k++) ds += s1[k] === " " ? " " : "&";
+  } else if (s2.length > s1.length) {
+    ds += s2.slice(i);
+  }
+  let end = ds.length;
+  while (end > 0 && ds[end - 1] === " ") end--;
+  return ds.slice(0, end);
+}
+function readValue(field14) {
+  const c = field14.padEnd(14, " ").split("");
+  const p7 = c[7];
+  c[10] = c[9];
+  c[9] = c[8];
+  let l = cAtol(c.slice(9, 14).join(""));
+  let u;
+  if (p7 === " ") {
+    u = 0;
+  } else if (p7 === "-") {
+    u = 0;
+    l = -l;
+  } else {
+    c[8] = ".";
+    u = cAtol(c.slice(0, 14).join(""));
+    if (u < 0) l = -l;
+  }
+  return { u, l };
+}
+function putdiff(dddu, dddl) {
+  dddu += Math.trunc(dddl / 1e5);
+  dddl %= 1e5;
+  if (dddu < 0 && dddl > 0) {
+    dddu++;
+    dddl -= 1e5;
+  } else if (dddu > 0 && dddl < 0) {
+    dddu--;
+    dddl += 1e5;
+  }
+  if (dddu === 0) return String(dddl);
+  return `${dddu}${String(Math.abs(dddl)).padStart(5, "0")}`;
+}
+function putClock(du, dl, cOrder) {
+  du += Math.trunc(dl / 1e8);
+  dl %= 1e8;
+  if (du < 0 && dl > 0) {
+    du++;
+    dl -= 1e8;
+  } else if (du > 0 && dl < 0) {
+    du--;
+    dl += 1e8;
+  }
+  let out = "";
+  if (cOrder === 0) out += `${ARC_ORDER}&`;
+  if (du === 0) out += String(dl);
+  else out += `${du}${String(Math.abs(dl)).padStart(8, "0")}`;
+  return out;
+}
+function chop(line) {
+  let end = line.length;
+  if (end > 0 && line[end - 1] === "\r") end--;
+  while (end > 0 && line[end - 1] === " ") end--;
+  return line.slice(0, end);
+}
+function readSat(lines, cursor, rinexVersion, ntype, ntypeGnss) {
+  let line = chop(lines[cursor.li++] ?? "");
+  let maxField;
+  let ntypeRec;
+  let firstRec;
+  let satId = "";
+  if (rinexVersion === 2) {
+    maxField = 5;
+    ntypeRec = ntype;
+    firstRec = 0;
+  } else {
+    satId = line.slice(0, 3);
+    const sys = line[0];
+    maxField = ntypeRec = ntypeGnss[sys] ?? -1;
+    if (maxField < 0) return null;
+    firstRec = 3;
+  }
+  const data = [];
+  let flag = "";
+  for (let i = 0; i < ntypeRec; i += maxField) {
+    const nfield = Math.min(ntypeRec - i, maxField);
+    const need = firstRec + 16 * nfield;
+    let body = line;
+    if (body.length < need) body = body.padEnd(need, " ");
+    for (let j = 0; j < nfield; j++) {
+      const p = firstRec + j * 16;
+      const rec = body.slice(p, p + 16);
+      const d = emptyData();
+      if (rec[10] === ".") {
+        flag += rec[14] ?? " ";
+        flag += rec[15] ?? " ";
+        const v = readValue(rec.slice(0, 14));
+        d.u[0] = v.u;
+        d.l[0] = v.l;
+        d.order = 0;
+      } else if (rec.slice(0, 14).trim() === "") {
+        flag += rec[14] ?? " ";
+        flag += rec[15] ?? " ";
+        d.order = -1;
+      } else {
+        return null;
+      }
+      data.push(d);
+    }
+    if (i + maxField < ntypeRec) {
+      line = chop(lines[cursor.li++] ?? "");
+    }
+  }
+  return { sat: { data, flag, ntypeRec }, satId };
+}
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function crinexDate() {
+  const d = /* @__PURE__ */ new Date();
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  const mon = MONTHS[d.getUTCMonth()];
+  const yy = String(d.getUTCFullYear() % 100).padStart(2, "0");
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  return `${dd}-${mon}-${yy} ${hh}:${mm}`;
+}
+function writeCrx(rinexText, opts = {}) {
+  const rawLines = rinexText.split("\n");
+  const cursor = { li: 0 };
+  const out = [];
+  const firstLine = chop(rawLines[cursor.li++] ?? "");
+  if (firstLine.slice(60, 80) !== "RINEX VERSION / TYPE" || firstLine[20] !== "O") {
+    throw new Error("writeCrx: not a RINEX observation file");
+  }
+  const rinexVersion = parseInt(firstLine, 10);
+  const rinexVersionFull = readVersionFull(firstLine);
+  if (rinexVersionFull < 0) throw new Error("writeCrx: invalid RINEX version");
+  const crxVersion = rinexVersionFull >= 402 ? "3.1" : rinexVersion === 2 ? "1.0" : "3.0";
+  out.push(
+    `${crxVersion.padEnd(20)}${"COMPACT RINEX FORMAT".padEnd(40)}${"CRINEX VERS   / TYPE".padEnd(20)}`
+  );
+  const prog = (opts.prog ?? "gnss-js writeCrx").slice(0, 40);
+  const date = opts.date ?? crinexDate();
+  out.push(`${prog.padEnd(40)}${date.padEnd(20)}CRINEX PROG / DATE`);
+  out.push(firstLine);
+  let ntype = 0;
+  const ntypeGnss = {};
+  let line;
+  do {
+    line = chop(rawLines[cursor.li++] ?? "");
+    out.push(line);
+    const label2 = line.slice(60).trimStart();
+    if (label2.startsWith("# / TYPES OF OBSERV") && line[5] !== " ") {
+      ntype = parseInt(line, 10);
+    } else if (label2.startsWith("SYS / # / OBS TYPES") && line[0] !== " ") {
+      ntypeGnss[line[0]] = parseInt(line.slice(3), 10);
+    }
+    if (cursor.li >= rawLines.length) break;
+  } while (!line.slice(60).trimStart().startsWith("END OF HEADER"));
+  const v2 = rinexVersion === 2;
+  const off = v2 ? { event: 28, nsat: 29, satlst: 32, clock: 68, satOld: 32, shiftClk: 1 } : {
+    event: 31,
+    nsat: 32,
+    satlst: 41,
+    clock: 41,
+    satOld: 41,
+    shiftClk: 4,
+    psec: 57
+  };
+  let oldline = "&";
+  let nsatOld = 0;
+  let clk0 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+  let dy0 = [];
+  let flag0 = [];
+  let oldpsec = "";
+  let clkOrderPrev = -1;
+  const resetArcs = () => {
+    oldline = "&";
+    nsatOld = 0;
+    clkOrderPrev = -1;
+  };
+  for (; ; ) {
+    if (cursor.li >= rawLines.length) break;
+    let epoch = rawLines[cursor.li];
+    if (epoch === void 0) break;
+    if (epoch === "" && cursor.li === rawLines.length - 1) break;
+    cursor.li++;
+    epoch = chop(epoch);
+    if (epoch === "") continue;
+    let newline;
+    if (v2) {
+      newline = epoch;
+    } else {
+      newline = epoch.length < 41 ? epoch.padEnd(41, " ") : epoch;
+    }
+    const eventFlag = parseInt(newline[off.event] ?? "0", 10) || 0;
+    if (eventFlag > 1) {
+      putEventData(rawLines, cursor, v2, newline, out, ntypeGnss, (n) => {
+        ntype = n;
+      });
+      resetArcs();
+      clk0 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+      dy0 = [];
+      flag0 = [];
+      continue;
+    }
+    let newpsec = "";
+    if (rinexVersionFull >= 402 && newline.length === 62) {
+      const psec = newline.slice(off.psec, off.psec + 5);
+      if (/^\d{5}$/.test(psec)) newpsec = psec;
+      newline = newline.slice(0, off.psec).replace(/\s+$/, "");
+    }
+    let clkOrder = -1;
+    const clk1 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+    if (newline.length > off.clock) {
+      clkOrder = readClock(
+        newline.slice(off.clock),
+        off.shiftClk,
+        clk1,
+        clkOrderPrev
+      );
+      if (clkOrder > -1) {
+        newline = newline.slice(0, off.clock).replace(/\s+$/, "");
+        if (!v2 && newline.length < 41) newline = newline.padEnd(41, " ");
+      }
+    }
+    clkOrderPrev = clkOrder;
+    const nsat = parseInt((newline.slice(off.nsat) || "0").trim(), 10) || 0;
+    if (v2 && nsat > 12) {
+      newline = readMoreSat(rawLines, cursor, nsat, newline);
+    }
+    const sats = [];
+    const satIds = [];
+    let bad = false;
+    let satlist = v2 ? newline.slice(off.satlst, off.satlst + nsat * 3) : "";
+    for (let i = 0; i < nsat; i++) {
+      const r = readSat(rawLines, cursor, rinexVersion, ntype, ntypeGnss);
+      if (!r) {
+        bad = true;
+        break;
+      }
+      sats.push(r.sat);
+      satIds.push(v2 ? satlist.slice(i * 3, i * 3 + 3) : r.satId);
+    }
+    if (bad) continue;
+    if (!v2) satlist = satIds.join("");
+    const fullNew = v2 ? newline : newline.slice(0, 41) + satlist;
+    const oldSatList = v2 ? oldline.slice(off.satOld, off.satOld + nsatOld * 3) : oldline.slice(off.satOld);
+    const sattbl = [];
+    const dup = /* @__PURE__ */ new Set();
+    for (let i = 0; i < nsat; i++) {
+      const id = satIds[i];
+      if (dup.has(id)) {
+        bad = true;
+        break;
+      }
+      dup.add(id);
+      let found = -1;
+      for (let j = 0; j < nsatOld; j++) {
+        if (oldSatList.slice(j * 3, j * 3 + 3) === id) {
+          found = j;
+          break;
+        }
+      }
+      sattbl.push(found);
+    }
+    if (bad) continue;
+    out.push(strdiff(oldline, fullNew));
+    let clockLine = "";
+    if (clkOrder > -1) {
+      if (clkOrder > 0) processClock(clk1, clk0, clkOrder);
+      clockLine += putClock(clk1.u[clkOrder], clk1.l[clkOrder], clkOrder);
+    }
+    if (newpsec.length === 5) {
+      clockLine += " " + strdiff(oldpsec, newpsec);
+    }
+    out.push(clockLine);
+    const dataLines = buildData(sats, sattbl, dy0, flag0, rinexVersion);
+    for (const dl of dataLines) out.push(dl);
+    oldline = fullNew;
+    nsatOld = nsat;
+    clk0 = clk1;
+    oldpsec = newpsec;
+    dy0 = sats.map((s) => s.data);
+    flag0 = sats.map((s) => s.flag);
+  }
+  return out.join("\n") + "\n";
+}
+function readClock(field, shiftClk, clk1, prevOrder) {
+  const c = field.split("");
+  if (c[2] !== ".") return -1;
+  for (let k = 0; k < shiftClk; k++) c[2 + k] = c[3 + k];
+  c[2 + shiftClk] = ".";
+  const s = c.join("");
+  const m = /(-?\d+)\.(\d+)/.exec(s);
+  if (!m) return -1;
+  clk1.u[0] = parseInt(m[1], 10);
+  clk1.l[0] = parseInt(m[2], 10);
+  if (c[0] === "-" || c[1] === "-") clk1.l[0] = -clk1.l[0];
+  return Math.min(prevOrder + 1, ARC_ORDER);
+}
+function processClock(clk1, clk0, clkOrder) {
+  for (let i = 0; i < clkOrder; i++) {
+    clk1.u[i + 1] = clk1.u[i] - clk0.u[i];
+    clk1.l[i + 1] = clk1.l[i] - clk0.l[i];
+  }
+}
+function takeDiff(py1, py0) {
+  py1.order = py0.order;
+  if (py1.order < ARC_ORDER) py1.order++;
+  for (let k = 0; k < py1.order; k++) {
+    py1.u[k + 1] = py1.u[k] - py0.u[k];
+    py1.l[k + 1] = py1.l[k] - py0.l[k];
+  }
+}
+function buildData(sats, sattbl, dy0, flag0, rinexVersion) {
+  const lines = [];
+  for (let i = 0; i < sats.length; i++) {
+    const sat = sats[i];
+    const i0 = sattbl[i];
+    const prevFlag = (i0 >= 0 ? flag0[i0] ?? "" : "").split("");
+    let line = "";
+    for (let j = 0; j < sat.ntypeRec; j++) {
+      const py1 = sat.data[j];
+      if (py1.order >= 0) {
+        if (i0 < 0 || dy0[i0]?.[j]?.order === -1) {
+          py1.order = 0;
+          line += `${ARC_ORDER}&`;
+        } else {
+          takeDiff(py1, dy0[i0][j]);
+          if (Math.abs(py1.u[py1.order]) > 1e5) {
+            py1.order = 0;
+            line += `${ARC_ORDER}&`;
+          }
+        }
+        line += putdiff(py1.u[py1.order], py1.l[py1.order]);
+      } else if (i0 >= 0 && rinexVersion === 2) {
+        prevFlag[j * 2] = " ";
+        prevFlag[j * 2 + 1] = " ";
+      }
+      line += " ";
+    }
+    if (i0 < 0 && rinexVersion !== 2) {
+      for (const ch of sat.flag) line += ch === " " ? "&" : ch;
+    } else {
+      line += i0 < 0 ? strdiff("", sat.flag) : strdiff(prevFlag.join(""), sat.flag);
+      line = line.replace(/ +$/, "");
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function putEventData(lines, cursor, v2, epochLine, out, ntypeGnss, setNtype) {
+  if (v2) {
+    out.push("&" + epochLine.slice(1));
+    if (epochLine.length > 29) {
+      const n = parseInt(epochLine.slice(29), 10) || 0;
+      for (let i = 0; i < n; i++) {
+        const l = chop(lines[cursor.li++] ?? "");
+        out.push(l);
+        if (l.slice(60).trimStart().startsWith("# / TYPES OF OBSERV") && l[5] !== " ") {
+          setNtype(parseInt(l, 10));
+        }
+      }
+    }
+  } else {
+    out.push(epochLine.replace(/\s+$/, ""));
+    const n = parseInt(epochLine.slice(32), 10) || 0;
+    for (let i = 0; i < n; i++) {
+      const l = chop(lines[cursor.li++] ?? "");
+      out.push(l);
+      if (l.slice(60).trimStart().startsWith("SYS / # / OBS TYPES") && l[0] !== " ") {
+        ntypeGnss[l[0]] = parseInt(l.slice(3), 10);
+      }
+    }
+  }
+}
+function readMoreSat(lines, cursor, n, epochLine) {
+  let result = epochLine;
+  let remaining = n;
+  while (remaining > 12) {
+    const l = lines[cursor.li++] ?? "";
+    const chopped = chop(l);
+    result += chopped[2] === " " ? chopped.slice(32) : chopped;
+    remaining -= 12;
+  }
+  return result;
+}
+function readVersionFull(line) {
+  if (line[5] === "2" && line[6] === " ") return 200;
+  const d = (c) => c !== void 0 && c >= "0" && c <= "9";
+  if (!d(line[5]) || line[6] !== "." || !d(line[7]) || !d(line[8])) return -1;
+  return (line.charCodeAt(5) - 48) * 100 + (line.charCodeAt(7) - 48) * 10 + (line.charCodeAt(8) - 48);
+}
+
 // src/rinex/format.ts
 function padL(s, w) {
   return s.length >= w ? s.slice(0, w) : s + " ".repeat(w - s.length);
@@ -6280,20 +6727,20 @@ var SIGNALS = {
   // GLONASS L1OF, L2OF
 };
 function prnFor(gnssId, svId) {
-  const two5 = (n) => String(n).padStart(2, "0");
+  const two7 = (n) => String(n).padStart(2, "0");
   switch (gnssId) {
     case 0:
-      return svId >= 1 && svId <= 32 ? `G${two5(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `G${two7(svId)}` : null;
     case 1:
-      return svId >= 120 && svId <= 158 ? `S${two5(svId - 100)}` : null;
+      return svId >= 120 && svId <= 158 ? `S${two7(svId - 100)}` : null;
     case 2:
-      return svId >= 1 && svId <= 36 ? `E${two5(svId)}` : null;
+      return svId >= 1 && svId <= 36 ? `E${two7(svId)}` : null;
     case 3:
-      return svId >= 1 && svId <= 63 ? `C${two5(svId)}` : null;
+      return svId >= 1 && svId <= 63 ? `C${two7(svId)}` : null;
     case 5:
-      return svId >= 1 && svId <= 10 ? `J${two5(svId)}` : null;
+      return svId >= 1 && svId <= 10 ? `J${two7(svId)}` : null;
     case 6:
-      return svId >= 1 && svId <= 32 ? `R${two5(svId)}` : null;
+      return svId >= 1 && svId <= 32 ? `R${two7(svId)}` : null;
     default:
       return null;
   }
@@ -8680,20 +9127,1180 @@ function parseNovatelRange(data) {
   return { epochs, messageCounts, obsCodes, badCrc };
 }
 
+// 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_MS13 = Date.UTC(1980, 0, 6);
+var SEC_PER_WEEK10 = 7 * 86400;
+var MS_PER_WEEK9 = SEC_PER_WEEK10 * 1e3;
+var GPS_PI2 = 3.1415926535898;
+var gpsMs3 = (week, sec) => GPS_EPOCH_MS13 + week * MS_PER_WEEK9 + sec * 1e3;
+var sowOf4 = (dateMs) => dateMs / 1e3 % SEC_PER_WEEK10;
+var SUB_GPS_EPHEMERIS = 1;
+var SUB_ION_UTC = 3;
+function decodeGpsEphemeris2(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_PI2;
+  const m0 = view.getFloat64(base + 72, false) * GPS_PI2;
+  const cuc = view.getFloat64(base + 80, false) * GPS_PI2;
+  const e = view.getFloat64(base + 88, false);
+  const cus = view.getFloat64(base + 96, false) * GPS_PI2;
+  const sqrtA = view.getFloat64(base + 104, false);
+  const cic = view.getFloat64(base + 112, false) * GPS_PI2;
+  const omega0 = view.getFloat64(base + 120, false) * GPS_PI2;
+  const cis = view.getFloat64(base + 128, false) * GPS_PI2;
+  const i0 = view.getFloat64(base + 136, false) * GPS_PI2;
+  const crc = view.getFloat64(base + 144, false);
+  const omega = view.getFloat64(base + 152, false) * GPS_PI2;
+  const omegaDot = view.getFloat64(base + 160, false) * GPS_PI2;
+  const idot = view.getFloat64(base + 168, false) * GPS_PI2;
+  const flags = view.getUint32(base + 176, false);
+  return {
+    system: "G",
+    prn: `G${String(prn).padStart(2, "0")}`,
+    toc: sowOf4(gpsMs3(week, toc)),
+    tocDate: new Date(gpsMs3(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 = decodeGpsEphemeris2(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_MS14 = Date.UTC(1980, 0, 6);
+var MS_PER_WEEK10 = 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_MS14 + epoch.week * MS_PER_WEEK10 + 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 });
+}
+
+// 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_MS15 = Date.UTC(1980, 0, 6);
+var GLO_DAY0_MS = Date.UTC(1980, 0, 1);
+var BDT_EPOCH_MS4 = Date.UTC(2006, 0, 1);
+var SEC_PER_WEEK11 = 7 * 86400;
+var MS_PER_WEEK11 = SEC_PER_WEEK11 * 1e3;
+var SC2RAD = GPS_PI;
+var gpsMs4 = (week, sec) => GPS_EPOCH_MS15 + week * MS_PER_WEEK11 + sec * 1e3;
+var sowOf5 = (dateMs) => (dateMs / 1e3 % SEC_PER_WEEK11 + SEC_PER_WEEK11) % SEC_PER_WEEK11;
+var two5 = (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(gpsMs4(week, toes));
+  return {
+    system: sys,
+    prn: `${sys}${two5(prn)}`,
+    toc: sowOf5(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(gpsMs4(week, toes));
+  return {
+    system: "E",
+    prn: `E${two5(prn)}`,
+    toc: sowOf5(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_MS4 + week * MS_PER_WEEK11 + toes * 1e3);
+  return {
+    system: "C",
+    prn: `C${two5(prn)}`,
+    toc: sowOf5(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${two5(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${two5(prn - 100)}`,
+    tocDate: new Date(gpsMs4(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_MS16 = Date.UTC(1980, 0, 6);
+var CLIGHT2 = 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 two6 = (n) => String(n).padStart(2, "0");
+function obsPrn(sys, prn) {
+  switch (sys) {
+    case 0:
+      return prn >= 1 && prn <= 32 ? `G${two6(prn)}` : null;
+    case 1:
+      return prn >= 1 && prn <= 27 ? `R${two6(prn)}` : null;
+    case 2:
+      return prn >= 120 && prn <= 158 ? `S${two6(prn - 100)}` : null;
+    case 3:
+      return prn >= 1 && prn <= 36 ? `E${two6(prn)}` : null;
+    case 4:
+      return prn >= 1 && prn <= 63 ? `C${two6(prn)}` : null;
+    case 5:
+      if (prn >= 193 && prn <= 202) return `J${two6(prn - 192)}`;
+      return prn >= 1 && prn <= 10 ? `J${two6(prn)}` : null;
+    default:
+      return null;
+  }
+}
+function carrierFreq3(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_MS16 + 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 = carrierFreq3(sysL, code, fcn);
+      meas.push({
+        prn: sat,
+        code,
+        pr: o.pr,
+        cp: freq > 0 ? o.phase * freq / CLIGHT2 : 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 };
+}
+
 // src/orbit/almanac.ts
 var GM_GPS = 3986005e8;
 var GM_GAL = 3986004418e5;
 var GM_BDS = 3986004418e5;
-var GPS_EPOCH_MS13 = Date.UTC(1980, 0, 6);
-var BDT_EPOCH_MS4 = Date.UTC(2006, 0, 1);
+var GPS_EPOCH_MS17 = Date.UTC(1980, 0, 6);
+var BDT_EPOCH_MS5 = Date.UTC(2006, 0, 1);
 var WEEK_MS = 6048e5;
 var BDT_MINUS_GPST_MS = 14e3;
 var BDS_GEO_PRNS = /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 59, 60, 61, 62, 63]);
 function almanacEpochMs(alm) {
   if (alm.system === "C") {
-    return BDT_EPOCH_MS4 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3 + BDT_MINUS_GPST_MS;
+    return BDT_EPOCH_MS5 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3 + BDT_MINUS_GPST_MS;
   }
-  return GPS_EPOCH_MS13 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3;
+  return GPS_EPOCH_MS17 + alm.weekAlm * WEEK_MS + alm.toaSec * 1e3;
 }
 function almanacSatPosition(alm, timeMs) {
   const GM = alm.system === "E" ? GM_GAL : alm.system === "C" ? GM_BDS : GM_GPS;
@@ -9202,10 +10809,10 @@ function selectBest(ephs, timeMs) {
   }
   return best;
 }
-var GPS_EPOCH_MS14 = START_GPS_TIME.getTime();
-var MS_PER_WEEK9 = 7 * 864e5;
+var GPS_EPOCH_MS18 = START_GPS_TIME.getTime();
+var MS_PER_WEEK12 = 7 * 864e5;
 var BDS_EPOCH_MS = START_BDS_TIME.getTime();
-var GAL_EPOCH_MS = GPS_EPOCH_MS14 + 1024 * MS_PER_WEEK9;
+var GAL_EPOCH_MS = GPS_EPOCH_MS18 + 1024 * MS_PER_WEEK12;
 function ephInfoToEphemeris(info) {
   const sys = info.prn.charAt(0);
   if (sys === "R") {
@@ -9256,11 +10863,11 @@ function ephInfoToEphemeris(info) {
   } else if (sys === "E") {
     epochMs = GAL_EPOCH_MS;
   } else {
-    epochMs = GPS_EPOCH_MS14;
-    const weeksNow = (info.lastReceived - GPS_EPOCH_MS14) / MS_PER_WEEK9;
+    epochMs = GPS_EPOCH_MS18;
+    const weeksNow = (info.lastReceived - GPS_EPOCH_MS18) / MS_PER_WEEK12;
     week += 1024 * Math.round((weeksNow - week) / 1024);
   }
-  const tocDate = new Date(epochMs + week * MS_PER_WEEK9 + tocSec * 1e3);
+  const tocDate = new Date(epochMs + week * MS_PER_WEEK12 + tocSec * 1e3);
   return {
     system: sys,
     prn: info.prn,
@@ -13314,6 +14921,10 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   analyzeQuality,
   applyHelmert,
   applyIonoDcb,
+  binexCrc16,
+  binexCrc32,
+  binexCsum8,
+  binexRecords,
   buildGloChannelMap,
   buildObsIndices,
   clampUnit,
@@ -13334,6 +14945,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   crxDecompress,
   crxRepair,
   dateToEpoch,
+  decodeBinexEph,
   decodeEphemeris,
   decodeMsmFull,
   deg2dms,
@@ -13355,6 +14967,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   geodeticToUtm,
   getAer,
   getBdsTime,
+  getBnxi,
   getDateFromBdsTime,
   getDateFromDayOfWeek,
   getDateFromDayOfYear,
@@ -13428,6 +15041,7 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   padL,
   padR,
   parseAntex,
+  parseBinex,
   parseCrxDataLine,
   parseIonex,
   parseNavFile,
@@ -13447,6 +15061,8 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   parseSinexBiasDcb,
   parseSourcetable,
   parseSp3,
+  parseTrimble,
+  parseTrimbleNav,
   parseUbxCnav,
   parseUbxIonoUtc,
   parseUbxNav,
@@ -13477,11 +15093,13 @@ function computePsdDb(centerMHz, halfSpanChips, numPoints, psdFn, f0 = 1023e3, f
   systemName,
   toRtkEpoch,
   transformFrame,
+  trimbleFrames,
   ubxFrames,
   updateStationMeta,
   updateStreamStats,
   verifyChecksum,
   vincenty,
+  writeCrx,
   writeModernObsBlob,
   writeRinex2ObsBlob,
   writeRinex4ObsBlob,