gnss-js 1.1.0 → 1.2.0

package/dist/frames.cjs

@@ -0,0 +1,250 @@
+"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/frames/index.ts
+var frames_exports = {};
+__export(frames_exports, {
+  REFERENCE_FRAMES: () => REFERENCE_FRAMES,
+  applyHelmert: () => applyHelmert,
+  dateToEpoch: () => dateToEpoch,
+  transformFrame: () => transformFrame
+});
+module.exports = __toCommonJS(frames_exports);
+var H = (t, d, r, tDot, dDot, rDot, epoch) => ({ t, d, r, tDot, dDot, rDot, epoch });
+var Z = [0, 0, 0];
+var FROM_ITRF2020 = {
+  ITRF2014: H([-1.4, -0.9, 1.4], -0.42, Z, [0, -0.1, 0.2], 0, Z, 2015),
+  ITRF2008: H([0.2, 1, 3.3], -0.29, Z, [0, -0.1, 0.1], 0.03, Z, 2015),
+  ITRF2005: H([2.7, 0.1, -1.4], 0.65, Z, [0.3, -0.1, 0.1], 0.03, Z, 2015),
+  ITRF2000: H([-0.2, 0.8, -34.2], 2.25, Z, [0.1, 0, -1.7], 0.11, Z, 2015),
+  ITRF97: H(
+    [6.5, -3.9, -77.9],
+    3.98,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF96: H(
+    [6.5, -3.9, -77.9],
+    3.98,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF94: H(
+    [6.5, -3.9, -77.9],
+    3.98,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF93: H(
+    [-65.8, 1.9, -71.3],
+    4.47,
+    [-3.36, -4.33, 0.75],
+    [-2.8, -0.2, -2.3],
+    0.12,
+    [-0.11, -0.19, 0.07],
+    2015
+  ),
+  ITRF92: H(
+    [14.5, -1.9, -85.9],
+    3.27,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF91: H(
+    [26.5, 12.1, -91.9],
+    4.67,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF90: H(
+    [24.5, 8.1, -107.9],
+    4.97,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF89: H(
+    [29.5, 32.1, -145.9],
+    8.37,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF88: H(
+    [24.5, -3.9, -169.9],
+    11.47,
+    [0.1, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  /** ITRF2020 → ETRF2020, EPSG:10572 (epoch-1989 variant) */
+  ETRF2020: H(Z, 0, Z, Z, 0, [0.086, 0.519, -0.753], 1989)
+};
+var ITRF2014_TO_ETRF2014 = H(Z, 0, Z, Z, 0, [0.085, 0.531, -0.77], 1989);
+var ITRF2014_TO_ETRF2000 = H(
+  [54.7, 52.2, -74.1],
+  2.12,
+  [1.701, 10.29, -16.632],
+  [0.1, 0.1, -1.9],
+  0.11,
+  [0.081, 0.49, -0.792],
+  2010
+);
+var ITRF2014_TO_NAD83_2011 = H(
+  [1005.3, -1909.21, -541.57],
+  0.36891,
+  [-26.78138, 0.42027, -10.93206],
+  [0.79, -0.6, -1.44],
+  -0.07201,
+  [-0.06667, 0.75744, 0.05133],
+  2010
+);
+var MAS_TO_RAD = Math.PI / (180 * 3600 * 1e3);
+function applyHelmert(xyz, p, epoch, inverse = false) {
+  const dt = epoch - p.epoch;
+  const sign = inverse ? -1 : 1;
+  const tx = sign * (p.t[0] + p.tDot[0] * dt) / 1e3;
+  const ty = sign * (p.t[1] + p.tDot[1] * dt) / 1e3;
+  const tz = sign * (p.t[2] + p.tDot[2] * dt) / 1e3;
+  const d = sign * (p.d + p.dDot * dt) * 1e-9;
+  const rx = sign * (p.r[0] + p.rDot[0] * dt) * MAS_TO_RAD;
+  const ry = sign * (p.r[1] + p.rDot[1] * dt) * MAS_TO_RAD;
+  const rz = sign * (p.r[2] + p.rDot[2] * dt) * MAS_TO_RAD;
+  const [x, y, z] = xyz;
+  return [
+    x + tx + d * x - rz * y + ry * z,
+    y + ty + rz * x + d * y - rx * z,
+    z + tz - ry * x + rx * y + d * z
+  ];
+}
+var EDGES = [
+  ...Object.entries(FROM_ITRF2020).map(([to, p]) => ({
+    from: "ITRF2020",
+    to,
+    p
+  })),
+  { from: "ITRF2014", to: "ETRF2014", p: ITRF2014_TO_ETRF2014 },
+  { from: "ITRF2014", to: "ETRF2000", p: ITRF2014_TO_ETRF2000 },
+  { from: "ITRF2014", to: "NAD83(2011)", p: ITRF2014_TO_NAD83_2011 }
+];
+var REFERENCE_FRAMES = [
+  "WGS84",
+  "ITRF2020",
+  "ITRF2014",
+  "ITRF2008",
+  "ITRF2005",
+  "ITRF2000",
+  "ITRF97",
+  "ITRF96",
+  "ITRF94",
+  "ITRF93",
+  "ITRF92",
+  "ITRF91",
+  "ITRF90",
+  "ITRF89",
+  "ITRF88",
+  "ETRF2020",
+  "ETRF2014",
+  "ETRF2000",
+  "NAD83(2011)"
+];
+function resolveAlias(f) {
+  return f === "WGS84" ? "ITRF2020" : f;
+}
+function findPath(from, to) {
+  if (from === to) return [];
+  const queue = [from];
+  const cameFrom = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set([from]);
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    for (const edge of EDGES) {
+      let next = null;
+      let inverse = false;
+      if (edge.from === cur) {
+        next = edge.to;
+      } else if (edge.to === cur) {
+        next = edge.from;
+        inverse = true;
+      }
+      if (next === null || seen.has(next)) continue;
+      seen.add(next);
+      cameFrom.set(next, { prev: cur, edge, inverse });
+      if (next === to) {
+        const path = [];
+        let node = to;
+        while (node !== from) {
+          const step = cameFrom.get(node);
+          path.unshift({ edge: step.edge, inverse: step.inverse });
+          node = step.prev;
+        }
+        return path;
+      }
+      queue.push(next);
+    }
+  }
+  return null;
+}
+function transformFrame(xyz, from, to, epoch) {
+  const src = resolveAlias(from);
+  const dst = resolveAlias(to);
+  const path = findPath(src, dst);
+  if (!path) {
+    throw new Error(`No transformation path from ${from} to ${to}`);
+  }
+  let out = [xyz[0], xyz[1], xyz[2]];
+  for (const { edge, inverse } of path) {
+    out = applyHelmert(out, edge.p, epoch, inverse);
+  }
+  return out;
+}
+function dateToEpoch(date) {
+  const year = date.getUTCFullYear();
+  const start = Date.UTC(year, 0, 1);
+  const end = Date.UTC(year + 1, 0, 1);
+  return year + (date.getTime() - start) / (end - start);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REFERENCE_FRAMES,
+  applyHelmert,
+  dateToEpoch,
+  transformFrame
+});

package/dist/frames.d.cts

@@ -0,0 +1,56 @@
+/**
+ * Terrestrial reference frame transformations.
+ *
+ * Time-dependent 14-parameter Helmert transformations between ITRF
+ * realizations, the ETRS89 realizations (ETRF2000/2014/2020), and
+ * NAD83(2011). All parameters are taken verbatim from authoritative
+ * sources — IERS/IGN for ITRF↔ITRF, EPSG registry entries for the
+ * rest — never re-derived. Each parameter set cites its source.
+ *
+ * Conventions: parameters are stored in the IERS "Position Vector"
+ * convention (rotations describe the rotation of the position vector,
+ * CRS source→target:  Xs = X + T + D·X + R·X  with
+ *   R·X = (−R3·y + R2·z,  R3·x − R1·z,  −R2·x + R1·y) ).
+ * EPSG entries published in the opposite "Coordinate Frame rotation"
+ * convention (NAD83) have their rotations negated at definition time.
+ *
+ * WGS84 note: the current WGS84 realization (G2296) is aligned to
+ * ITRF2020 at the few-cm level; this module treats 'WGS84' as an alias
+ * of ITRF2020, which is the standard GNSS practice.
+ */
+type ReferenceFrame = 'ITRF2020' | 'ITRF2014' | 'ITRF2008' | 'ITRF2005' | 'ITRF2000' | 'ITRF97' | 'ITRF96' | 'ITRF94' | 'ITRF93' | 'ITRF92' | 'ITRF91' | 'ITRF90' | 'ITRF89' | 'ITRF88' | 'ETRF2020' | 'ETRF2014' | 'ETRF2000' | 'NAD83(2011)' | 'WGS84';
+/**
+ * 14-parameter Helmert set (Position Vector convention).
+ * Units: translations mm (rates mm/yr), scale ppb (ppb/yr),
+ * rotations mas (mas/yr); epoch in decimal years.
+ */
+interface Helmert14 {
+    t: [number, number, number];
+    d: number;
+    r: [number, number, number];
+    tDot: [number, number, number];
+    dDot: number;
+    rDot: [number, number, number];
+    epoch: number;
+}
+/**
+ * Apply a time-dependent Helmert transformation (Position Vector
+ * convention) to geocentric coordinates, evaluated at `epoch`
+ * (decimal years). Pass `inverse` to go target → source.
+ */
+declare function applyHelmert(xyz: readonly [number, number, number], p: Helmert14, epoch: number, inverse?: boolean): [number, number, number];
+/** Frames supported by transformFrame (WGS84 is an ITRF2020 alias). */
+declare const REFERENCE_FRAMES: ReferenceFrame[];
+/**
+ * Transform geocentric coordinates between reference frames at a given
+ * coordinate epoch (decimal years, e.g. 2010.5).
+ *
+ * The epoch is the epoch of the coordinates themselves — the same
+ * physical location is expressed in both frames at that instant; no
+ * intra-plate velocity propagation is applied.
+ */
+declare function transformFrame(xyz: readonly [number, number, number], from: ReferenceFrame, to: ReferenceFrame, epoch: number): [number, number, number];
+/** Convert a Date to the decimal-year epoch used by transformFrame. */
+declare function dateToEpoch(date: Date): number;
+
+export { type Helmert14, REFERENCE_FRAMES, type ReferenceFrame, applyHelmert, dateToEpoch, transformFrame };

package/dist/frames.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Terrestrial reference frame transformations.
+ *
+ * Time-dependent 14-parameter Helmert transformations between ITRF
+ * realizations, the ETRS89 realizations (ETRF2000/2014/2020), and
+ * NAD83(2011). All parameters are taken verbatim from authoritative
+ * sources — IERS/IGN for ITRF↔ITRF, EPSG registry entries for the
+ * rest — never re-derived. Each parameter set cites its source.
+ *
+ * Conventions: parameters are stored in the IERS "Position Vector"
+ * convention (rotations describe the rotation of the position vector,
+ * CRS source→target:  Xs = X + T + D·X + R·X  with
+ *   R·X = (−R3·y + R2·z,  R3·x − R1·z,  −R2·x + R1·y) ).
+ * EPSG entries published in the opposite "Coordinate Frame rotation"
+ * convention (NAD83) have their rotations negated at definition time.
+ *
+ * WGS84 note: the current WGS84 realization (G2296) is aligned to
+ * ITRF2020 at the few-cm level; this module treats 'WGS84' as an alias
+ * of ITRF2020, which is the standard GNSS practice.
+ */
+type ReferenceFrame = 'ITRF2020' | 'ITRF2014' | 'ITRF2008' | 'ITRF2005' | 'ITRF2000' | 'ITRF97' | 'ITRF96' | 'ITRF94' | 'ITRF93' | 'ITRF92' | 'ITRF91' | 'ITRF90' | 'ITRF89' | 'ITRF88' | 'ETRF2020' | 'ETRF2014' | 'ETRF2000' | 'NAD83(2011)' | 'WGS84';
+/**
+ * 14-parameter Helmert set (Position Vector convention).
+ * Units: translations mm (rates mm/yr), scale ppb (ppb/yr),
+ * rotations mas (mas/yr); epoch in decimal years.
+ */
+interface Helmert14 {
+    t: [number, number, number];
+    d: number;
+    r: [number, number, number];
+    tDot: [number, number, number];
+    dDot: number;
+    rDot: [number, number, number];
+    epoch: number;
+}
+/**
+ * Apply a time-dependent Helmert transformation (Position Vector
+ * convention) to geocentric coordinates, evaluated at `epoch`
+ * (decimal years). Pass `inverse` to go target → source.
+ */
+declare function applyHelmert(xyz: readonly [number, number, number], p: Helmert14, epoch: number, inverse?: boolean): [number, number, number];
+/** Frames supported by transformFrame (WGS84 is an ITRF2020 alias). */
+declare const REFERENCE_FRAMES: ReferenceFrame[];
+/**
+ * Transform geocentric coordinates between reference frames at a given
+ * coordinate epoch (decimal years, e.g. 2010.5).
+ *
+ * The epoch is the epoch of the coordinates themselves — the same
+ * physical location is expressed in both frames at that instant; no
+ * intra-plate velocity propagation is applied.
+ */
+declare function transformFrame(xyz: readonly [number, number, number], from: ReferenceFrame, to: ReferenceFrame, epoch: number): [number, number, number];
+/** Convert a Date to the decimal-year epoch used by transformFrame. */
+declare function dateToEpoch(date: Date): number;
+
+export { type Helmert14, REFERENCE_FRAMES, type ReferenceFrame, applyHelmert, dateToEpoch, transformFrame };

package/dist/frames.js

@@ -0,0 +1,222 @@
+// src/frames/index.ts
+var H = (t, d, r, tDot, dDot, rDot, epoch) => ({ t, d, r, tDot, dDot, rDot, epoch });
+var Z = [0, 0, 0];
+var FROM_ITRF2020 = {
+  ITRF2014: H([-1.4, -0.9, 1.4], -0.42, Z, [0, -0.1, 0.2], 0, Z, 2015),
+  ITRF2008: H([0.2, 1, 3.3], -0.29, Z, [0, -0.1, 0.1], 0.03, Z, 2015),
+  ITRF2005: H([2.7, 0.1, -1.4], 0.65, Z, [0.3, -0.1, 0.1], 0.03, Z, 2015),
+  ITRF2000: H([-0.2, 0.8, -34.2], 2.25, Z, [0.1, 0, -1.7], 0.11, Z, 2015),
+  ITRF97: H(
+    [6.5, -3.9, -77.9],
+    3.98,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF96: H(
+    [6.5, -3.9, -77.9],
+    3.98,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF94: H(
+    [6.5, -3.9, -77.9],
+    3.98,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF93: H(
+    [-65.8, 1.9, -71.3],
+    4.47,
+    [-3.36, -4.33, 0.75],
+    [-2.8, -0.2, -2.3],
+    0.12,
+    [-0.11, -0.19, 0.07],
+    2015
+  ),
+  ITRF92: H(
+    [14.5, -1.9, -85.9],
+    3.27,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF91: H(
+    [26.5, 12.1, -91.9],
+    4.67,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF90: H(
+    [24.5, 8.1, -107.9],
+    4.97,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF89: H(
+    [29.5, 32.1, -145.9],
+    8.37,
+    [0, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  ITRF88: H(
+    [24.5, -3.9, -169.9],
+    11.47,
+    [0.1, 0, 0.36],
+    [0.1, -0.6, -3.1],
+    0.12,
+    [0, 0, 0.02],
+    2015
+  ),
+  /** ITRF2020 → ETRF2020, EPSG:10572 (epoch-1989 variant) */
+  ETRF2020: H(Z, 0, Z, Z, 0, [0.086, 0.519, -0.753], 1989)
+};
+var ITRF2014_TO_ETRF2014 = H(Z, 0, Z, Z, 0, [0.085, 0.531, -0.77], 1989);
+var ITRF2014_TO_ETRF2000 = H(
+  [54.7, 52.2, -74.1],
+  2.12,
+  [1.701, 10.29, -16.632],
+  [0.1, 0.1, -1.9],
+  0.11,
+  [0.081, 0.49, -0.792],
+  2010
+);
+var ITRF2014_TO_NAD83_2011 = H(
+  [1005.3, -1909.21, -541.57],
+  0.36891,
+  [-26.78138, 0.42027, -10.93206],
+  [0.79, -0.6, -1.44],
+  -0.07201,
+  [-0.06667, 0.75744, 0.05133],
+  2010
+);
+var MAS_TO_RAD = Math.PI / (180 * 3600 * 1e3);
+function applyHelmert(xyz, p, epoch, inverse = false) {
+  const dt = epoch - p.epoch;
+  const sign = inverse ? -1 : 1;
+  const tx = sign * (p.t[0] + p.tDot[0] * dt) / 1e3;
+  const ty = sign * (p.t[1] + p.tDot[1] * dt) / 1e3;
+  const tz = sign * (p.t[2] + p.tDot[2] * dt) / 1e3;
+  const d = sign * (p.d + p.dDot * dt) * 1e-9;
+  const rx = sign * (p.r[0] + p.rDot[0] * dt) * MAS_TO_RAD;
+  const ry = sign * (p.r[1] + p.rDot[1] * dt) * MAS_TO_RAD;
+  const rz = sign * (p.r[2] + p.rDot[2] * dt) * MAS_TO_RAD;
+  const [x, y, z] = xyz;
+  return [
+    x + tx + d * x - rz * y + ry * z,
+    y + ty + rz * x + d * y - rx * z,
+    z + tz - ry * x + rx * y + d * z
+  ];
+}
+var EDGES = [
+  ...Object.entries(FROM_ITRF2020).map(([to, p]) => ({
+    from: "ITRF2020",
+    to,
+    p
+  })),
+  { from: "ITRF2014", to: "ETRF2014", p: ITRF2014_TO_ETRF2014 },
+  { from: "ITRF2014", to: "ETRF2000", p: ITRF2014_TO_ETRF2000 },
+  { from: "ITRF2014", to: "NAD83(2011)", p: ITRF2014_TO_NAD83_2011 }
+];
+var REFERENCE_FRAMES = [
+  "WGS84",
+  "ITRF2020",
+  "ITRF2014",
+  "ITRF2008",
+  "ITRF2005",
+  "ITRF2000",
+  "ITRF97",
+  "ITRF96",
+  "ITRF94",
+  "ITRF93",
+  "ITRF92",
+  "ITRF91",
+  "ITRF90",
+  "ITRF89",
+  "ITRF88",
+  "ETRF2020",
+  "ETRF2014",
+  "ETRF2000",
+  "NAD83(2011)"
+];
+function resolveAlias(f) {
+  return f === "WGS84" ? "ITRF2020" : f;
+}
+function findPath(from, to) {
+  if (from === to) return [];
+  const queue = [from];
+  const cameFrom = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set([from]);
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    for (const edge of EDGES) {
+      let next = null;
+      let inverse = false;
+      if (edge.from === cur) {
+        next = edge.to;
+      } else if (edge.to === cur) {
+        next = edge.from;
+        inverse = true;
+      }
+      if (next === null || seen.has(next)) continue;
+      seen.add(next);
+      cameFrom.set(next, { prev: cur, edge, inverse });
+      if (next === to) {
+        const path = [];
+        let node = to;
+        while (node !== from) {
+          const step = cameFrom.get(node);
+          path.unshift({ edge: step.edge, inverse: step.inverse });
+          node = step.prev;
+        }
+        return path;
+      }
+      queue.push(next);
+    }
+  }
+  return null;
+}
+function transformFrame(xyz, from, to, epoch) {
+  const src = resolveAlias(from);
+  const dst = resolveAlias(to);
+  const path = findPath(src, dst);
+  if (!path) {
+    throw new Error(`No transformation path from ${from} to ${to}`);
+  }
+  let out = [xyz[0], xyz[1], xyz[2]];
+  for (const { edge, inverse } of path) {
+    out = applyHelmert(out, edge.p, epoch, inverse);
+  }
+  return out;
+}
+function dateToEpoch(date) {
+  const year = date.getUTCFullYear();
+  const start = Date.UTC(year, 0, 1);
+  const end = Date.UTC(year + 1, 0, 1);
+  return year + (date.getTime() - start) / (end - start);
+}
+export {
+  REFERENCE_FRAMES,
+  applyHelmert,
+  dateToEpoch,
+  transformFrame
+};

package/dist/index.cjs

@@ -4201,7 +4201,8 @@ function selectEphemeris(ephemerides, prn, timeMs) {
 }
 function computeSatPosition(eph, timeMs) {
   if (eph.system === "R" || eph.system === "S") {
-    return glonassPosition(eph, timeMs / 1e3);
+    const leapMs = getGpsLeap(new Date(timeMs)) * 1e3;
+    return glonassPosition(eph, (timeMs - leapMs) / 1e3);
   }
   const GPS_EPOCH2 = START_GPS_TIME.getTime();
   const gpsSeconds = (timeMs - GPS_EPOCH2) / 1e3;
@@ -4374,7 +4375,7 @@ function ephInfoToEphemeris(info) {
   };
 }
 function computeLiveSkyPositions(ephemerides, rxPos, cn0Map) {
-  const now = Date.now();
+  const now = Date.now() + getGpsLeap(/* @__PURE__ */ new Date()) * 1e3;
   const result = [];
   const [rxX, rxY, rxZ] = rxPos;
   const [rxLat, rxLon] = ecefToGeodetic(rxX, rxY, rxZ);