gnss-js 0.1.2 → 1.0.1

package/dist/antex.d.cts

@@ -0,0 +1,77 @@
+/**
+ * ANTEX 1.4 (Antenna Exchange Format) parser.
+ * Parses receiver and satellite antenna calibration files containing
+ * Phase Center Offsets (PCO) and Phase Center Variations (PCV).
+ */
+interface FrequencyData {
+    /** Frequency code, e.g. "G01", "E05" */
+    frequency: string;
+    /** Phase Center Offset — North/X component (mm) */
+    pcoN: number;
+    /** Phase Center Offset — East/Y component (mm) */
+    pcoE: number;
+    /** Phase Center Offset — Up/Z component (mm) */
+    pcoU: number;
+    /** Non-azimuth-dependent PCV values (mm), length = numZen */
+    pcvNoazi: number[];
+    /**
+     * Azimuth-dependent PCV grid (mm).
+     * Rows = azimuths (0..360 step dazi), cols = zenith angles.
+     * Empty when dazi === 0 (no azimuth dependence).
+     */
+    pcv: number[][];
+}
+interface AntennaEntry {
+    /** Antenna type name (20 chars, e.g. "LEIAR20         LEIM") */
+    type: string;
+    /** Serial number or satellite code (e.g. "G05", or blank for type-mean) */
+    serialNo: string;
+    /** SVN code (satellites only, optional) */
+    svnCode: string;
+    /** COSPAR ID (satellites only, optional) */
+    cosparId: string;
+    /** Whether this is a satellite antenna (vs receiver) */
+    isSatellite: boolean;
+    /** Calibration method */
+    method: string;
+    /** Agency that performed calibration */
+    agency: string;
+    /** Number of individual antennas calibrated */
+    numCalibrated: number;
+    /** Calibration date string */
+    date: string;
+    /** Azimuth increment (degrees). 0 = no azimuth dependence. */
+    dazi: number;
+    /** Zenith/nadir start angle (degrees) */
+    zen1: number;
+    /** Zenith/nadir end angle (degrees) */
+    zen2: number;
+    /** Zenith/nadir increment (degrees) */
+    dzen: number;
+    /** SINEX code (optional) */
+    sinexCode: string;
+    /** Valid-from date (optional) */
+    validFrom: string;
+    /** Valid-until date (optional) */
+    validUntil: string;
+    /** Per-frequency calibration data */
+    frequencies: FrequencyData[];
+}
+interface AntexFile {
+    /** Format version (e.g. 1.4) */
+    version: number;
+    /** Satellite system flag ('G','R','E','C','J','S','M') */
+    system: string;
+    /** PCV type: 'A' (absolute) or 'R' (relative) */
+    pcvType: string;
+    /** Reference antenna type (for relative values) */
+    refAntenna: string;
+    /** Header comments */
+    comments: string[];
+    /** All antenna entries in the file */
+    antennas: AntennaEntry[];
+}
+declare function parseAntex(text: string): AntexFile;
+declare function frequencyLabel(code: string): string;
+
+export { type AntennaEntry, type AntexFile, type FrequencyData, frequencyLabel, parseAntex };

package/dist/antex.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ANTEX 1.4 (Antenna Exchange Format) parser.
+ * Parses receiver and satellite antenna calibration files containing
+ * Phase Center Offsets (PCO) and Phase Center Variations (PCV).
+ */
+interface FrequencyData {
+    /** Frequency code, e.g. "G01", "E05" */
+    frequency: string;
+    /** Phase Center Offset — North/X component (mm) */
+    pcoN: number;
+    /** Phase Center Offset — East/Y component (mm) */
+    pcoE: number;
+    /** Phase Center Offset — Up/Z component (mm) */
+    pcoU: number;
+    /** Non-azimuth-dependent PCV values (mm), length = numZen */
+    pcvNoazi: number[];
+    /**
+     * Azimuth-dependent PCV grid (mm).
+     * Rows = azimuths (0..360 step dazi), cols = zenith angles.
+     * Empty when dazi === 0 (no azimuth dependence).
+     */
+    pcv: number[][];
+}
+interface AntennaEntry {
+    /** Antenna type name (20 chars, e.g. "LEIAR20         LEIM") */
+    type: string;
+    /** Serial number or satellite code (e.g. "G05", or blank for type-mean) */
+    serialNo: string;
+    /** SVN code (satellites only, optional) */
+    svnCode: string;
+    /** COSPAR ID (satellites only, optional) */
+    cosparId: string;
+    /** Whether this is a satellite antenna (vs receiver) */
+    isSatellite: boolean;
+    /** Calibration method */
+    method: string;
+    /** Agency that performed calibration */
+    agency: string;
+    /** Number of individual antennas calibrated */
+    numCalibrated: number;
+    /** Calibration date string */
+    date: string;
+    /** Azimuth increment (degrees). 0 = no azimuth dependence. */
+    dazi: number;
+    /** Zenith/nadir start angle (degrees) */
+    zen1: number;
+    /** Zenith/nadir end angle (degrees) */
+    zen2: number;
+    /** Zenith/nadir increment (degrees) */
+    dzen: number;
+    /** SINEX code (optional) */
+    sinexCode: string;
+    /** Valid-from date (optional) */
+    validFrom: string;
+    /** Valid-until date (optional) */
+    validUntil: string;
+    /** Per-frequency calibration data */
+    frequencies: FrequencyData[];
+}
+interface AntexFile {
+    /** Format version (e.g. 1.4) */
+    version: number;
+    /** Satellite system flag ('G','R','E','C','J','S','M') */
+    system: string;
+    /** PCV type: 'A' (absolute) or 'R' (relative) */
+    pcvType: string;
+    /** Reference antenna type (for relative values) */
+    refAntenna: string;
+    /** Header comments */
+    comments: string[];
+    /** All antenna entries in the file */
+    antennas: AntennaEntry[];
+}
+declare function parseAntex(text: string): AntexFile;
+declare function frequencyLabel(code: string): string;
+
+export { type AntennaEntry, type AntexFile, type FrequencyData, frequencyLabel, parseAntex };

package/dist/antex.js

@@ -0,0 +1,8 @@
+import {
+  frequencyLabel,
+  parseAntex
+} from "./chunk-5CMSYIYM.js";
+export {
+  frequencyLabel,
+  parseAntex
+};

package/dist/chunk-37QNKGTC.js

@@ -0,0 +1,65 @@
+import {
+  WGS84_ECCENTRICITY_SQUARED,
+  WGS84_SEMI_MAJOR_AXIS
+} from "./chunk-6FAL6P4G.js";
+
+// src/coordinates/ecef.ts
+function clampUnit(x) {
+  return x < -1 ? -1 : x > 1 ? 1 : x;
+}
+function geodeticToEcef(lat, lon, h) {
+  const N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * Math.sin(lat) ** 2);
+  const x = (N + h) * Math.cos(lat) * Math.cos(lon);
+  const y = (N + h) * Math.cos(lat) * Math.sin(lon);
+  const z = ((1 - WGS84_ECCENTRICITY_SQUARED) * N + h) * Math.sin(lat);
+  return [x, y, z];
+}
+function ecefToGeodetic(x, y, z) {
+  const lon = Math.atan2(y, x);
+  const p = Math.sqrt(x * x + y * y);
+  if (p < 1e-10) {
+    const b = WGS84_SEMI_MAJOR_AXIS * Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED);
+    const lat2 = z >= 0 ? Math.PI / 2 : -Math.PI / 2;
+    const alt2 = Math.abs(z) - b;
+    return [lat2, lon, alt2];
+  }
+  let lat = Math.atan2(z, p * (1 - WGS84_ECCENTRICITY_SQUARED));
+  let N;
+  for (let i = 0; i < 10; i++) {
+    const sinLat2 = Math.sin(lat);
+    N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat2 * sinLat2);
+    const prevLat = lat;
+    lat = Math.atan2(z + WGS84_ECCENTRICITY_SQUARED * N * sinLat2, p);
+    if (Math.abs(lat - prevLat) < 1e-15) break;
+  }
+  const sinLat = Math.sin(lat);
+  N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat * sinLat);
+  const alt = p / Math.cos(lat) - N;
+  return [lat, lon, alt];
+}
+function getEnuDifference(x, y, z, xRef, yRef, zRef) {
+  const [latRef, lonRef] = ecefToGeodetic(xRef, yRef, zRef);
+  const deltaX = x - xRef;
+  const deltaY = y - yRef;
+  const deltaZ = z - zRef;
+  const deltaE = -Math.sin(lonRef) * deltaX + Math.cos(lonRef) * deltaY;
+  const deltaN = -Math.cos(lonRef) * Math.sin(latRef) * deltaX - Math.sin(lonRef) * Math.sin(latRef) * deltaY + Math.cos(latRef) * deltaZ;
+  const deltaU = Math.cos(lonRef) * Math.cos(latRef) * deltaX + Math.sin(lonRef) * Math.cos(latRef) * deltaY + Math.sin(latRef) * deltaZ;
+  return [deltaE, deltaN, deltaU];
+}
+function getAer(x, y, z, xRef, yRef, zRef) {
+  const slant = Math.sqrt((x - xRef) ** 2 + (y - yRef) ** 2 + (z - zRef) ** 2);
+  if (!slant) return [0, 0, 0];
+  const [deltaE, deltaN, deltaU] = getEnuDifference(x, y, z, xRef, yRef, zRef);
+  const elevation = Math.asin(clampUnit(deltaU / slant));
+  const azimuth = Math.atan2(deltaE, deltaN);
+  return [elevation, azimuth, slant];
+}
+
+export {
+  clampUnit,
+  geodeticToEcef,
+  ecefToGeodetic,
+  getEnuDifference,
+  getAer
+};

package/dist/chunk-4YN353Q7.js

@@ -0,0 +1,440 @@
+import {
+  ecefToGeodetic
+} from "./chunk-37QNKGTC.js";
+
+// src/orbit/index.ts
+var GM_GPS = 3986005e8;
+var GM_GAL = 3986004418e5;
+var GM_BDS = 3986004418e5;
+var GM_GLO = 39860044e7;
+var OMEGA_E = 72921151467e-15;
+var AE_GLO = 6378136;
+var J2_GLO = 108263e-8;
+var TWO_PI = 2 * Math.PI;
+function gmForSystem(sys) {
+  if (sys === "E") return GM_GAL;
+  if (sys === "C") return GM_BDS;
+  return GM_GPS;
+}
+function keplerPosition(eph, t) {
+  const GM = gmForSystem(eph.system);
+  const a = eph.sqrtA * eph.sqrtA;
+  const n0 = Math.sqrt(GM / (a * a * a));
+  const n = n0 + eph.deltaN;
+  let tk = t - eph.toe;
+  if (tk > 302400) tk -= 604800;
+  if (tk < -302400) tk += 604800;
+  const Mk = eph.m0 + n * tk;
+  let Ek = Mk;
+  for (let i = 0; i < 10; i++) {
+    const dE = (Mk - (Ek - eph.e * Math.sin(Ek))) / (1 - eph.e * Math.cos(Ek));
+    Ek += dE;
+    if (Math.abs(dE) < 1e-12) break;
+  }
+  const sinE = Math.sin(Ek);
+  const cosE = Math.cos(Ek);
+  const vk = Math.atan2(Math.sqrt(1 - eph.e * eph.e) * sinE, cosE - eph.e);
+  const phik = vk + eph.omega;
+  const sin2phi = Math.sin(2 * phik);
+  const cos2phi = Math.cos(2 * phik);
+  const duk = eph.cus * sin2phi + eph.cuc * cos2phi;
+  const drk = eph.crs * sin2phi + eph.crc * cos2phi;
+  const dik = eph.cis * sin2phi + eph.cic * cos2phi;
+  const uk = phik + duk;
+  const rk = a * (1 - eph.e * cosE) + drk;
+  const ik = eph.i0 + dik + eph.idot * tk;
+  const xp = rk * Math.cos(uk);
+  const yp = rk * Math.sin(uk);
+  const isBdsGeo = eph.system === "C" && Math.abs(eph.i0) < 0.1 && a > 4e7;
+  if (isBdsGeo) {
+    const omegak2 = eph.omega0 + eph.omegaDot * tk - OMEGA_E * eph.toe;
+    const cosO2 = Math.cos(omegak2);
+    const sinO2 = Math.sin(omegak2);
+    const cosI2 = Math.cos(ik);
+    const sinI2 = Math.sin(ik);
+    const xg = xp * cosO2 - yp * cosI2 * sinO2;
+    const yg = xp * sinO2 + yp * cosI2 * cosO2;
+    const zg = yp * sinI2;
+    const phi = OMEGA_E * tk;
+    const cosPhi = Math.cos(phi);
+    const sinPhi = Math.sin(phi);
+    const COS5 = Math.cos(-5 * Math.PI / 180);
+    const SIN5 = Math.sin(-5 * Math.PI / 180);
+    return {
+      prn: eph.prn,
+      x: xg * cosPhi + yg * sinPhi * COS5 + zg * sinPhi * SIN5,
+      y: -xg * sinPhi + yg * cosPhi * COS5 + zg * cosPhi * SIN5,
+      z: -yg * SIN5 + zg * COS5
+    };
+  }
+  const omegak = eph.omega0 + (eph.omegaDot - OMEGA_E) * tk - OMEGA_E * eph.toe;
+  const cosO = Math.cos(omegak);
+  const sinO = Math.sin(omegak);
+  const cosI = Math.cos(ik);
+  const sinI = Math.sin(ik);
+  return {
+    prn: eph.prn,
+    x: xp * cosO - yp * cosI * sinO,
+    y: xp * sinO + yp * cosI * cosO,
+    z: yp * sinI
+  };
+}
+function gloDerivatives(state, acc) {
+  const [x, y, z, vx, vy, vz] = state;
+  const [ax, ay, az] = acc;
+  const r = Math.sqrt(x * x + y * y + z * z);
+  const r2 = r * r;
+  const r3 = r2 * r;
+  const r5 = r2 * r3;
+  const mu_r3 = GM_GLO / r3;
+  const j2_term = 1.5 * J2_GLO * AE_GLO * AE_GLO / r5;
+  const dvx = -mu_r3 * x + j2_term * x * (5 * z * z / r2 - 1) + OMEGA_E * OMEGA_E * x + 2 * OMEGA_E * vy + ax;
+  const dvy = -mu_r3 * y + j2_term * y * (5 * z * z / r2 - 1) + OMEGA_E * OMEGA_E * y - 2 * OMEGA_E * vx + ay;
+  const dvz = -mu_r3 * z + j2_term * z * (5 * z * z / r2 - 3) + az;
+  return [vx, vy, vz, dvx, dvy, dvz];
+}
+function rk4Step(state, acc, dt) {
+  const k1 = gloDerivatives(state, acc);
+  const s2 = state.map((v, i) => v + k1[i] * dt / 2);
+  const k2 = gloDerivatives(s2, acc);
+  const s3 = state.map((v, i) => v + k2[i] * dt / 2);
+  const k3 = gloDerivatives(s3, acc);
+  const s4 = state.map((v, i) => v + k3[i] * dt);
+  const k4 = gloDerivatives(s4, acc);
+  return state.map(
+    (v, i) => v + dt / 6 * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i])
+  );
+}
+function glonassPosition(eph, tUtc) {
+  const ephTime = eph.tocDate.getTime() / 1e3;
+  const dt = tUtc - ephTime;
+  let state = [
+    eph.x * 1e3,
+    eph.y * 1e3,
+    eph.z * 1e3,
+    eph.xDot * 1e3,
+    eph.yDot * 1e3,
+    eph.zDot * 1e3
+  ];
+  const acc = [
+    eph.xAcc * 1e3,
+    eph.yAcc * 1e3,
+    eph.zAcc * 1e3
+  ];
+  const step = dt > 0 ? 60 : -60;
+  const nSteps = Math.floor(Math.abs(dt) / 60);
+  const remainder = dt - nSteps * step;
+  for (let i = 0; i < nSteps; i++) {
+    state = rk4Step(state, acc, step);
+  }
+  if (Math.abs(remainder) > 1e-3) {
+    state = rk4Step(state, acc, remainder);
+  }
+  return { prn: eph.prn, x: state[0], y: state[1], z: state[2] };
+}
+function ecefToAzEl(rxX, rxY, rxZ, satX, satY, satZ) {
+  const [lat, lon] = ecefToGeodetic(rxX, rxY, rxZ);
+  const dx = satX - rxX;
+  const dy = satY - rxY;
+  const dz = satZ - rxZ;
+  const sinLat = Math.sin(lat);
+  const cosLat = Math.cos(lat);
+  const sinLon = Math.sin(lon);
+  const cosLon = Math.cos(lon);
+  const east = -sinLon * dx + cosLon * dy;
+  const north = -sinLat * cosLon * dx - sinLat * sinLon * dy + cosLat * dz;
+  const up = cosLat * cosLon * dx + cosLat * sinLon * dy + sinLat * dz;
+  const az = Math.atan2(east, north);
+  const el = Math.atan2(up, Math.sqrt(east * east + north * north));
+  return { az: (az + TWO_PI) % TWO_PI, el };
+}
+function computeDop(satAzEls) {
+  const n = satAzEls.length;
+  if (n < 4) return null;
+  const H = [];
+  for (const { az, el } of satAzEls) {
+    const cosEl = Math.cos(el);
+    H.push([cosEl * Math.sin(az), cosEl * Math.cos(az), Math.sin(el), 1]);
+  }
+  const HtH = Array.from({ length: 4 }, () => new Array(4).fill(0));
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      let sum = 0;
+      for (let k = 0; k < n; k++) {
+        sum += H[k][i] * H[k][j];
+      }
+      HtH[i][j] = sum;
+    }
+  }
+  const Q = invert4x4(HtH);
+  if (!Q) return null;
+  const gdop = Math.sqrt(Q[0][0] + Q[1][1] + Q[2][2] + Q[3][3]);
+  const pdop = Math.sqrt(Q[0][0] + Q[1][1] + Q[2][2]);
+  const hdop = Math.sqrt(Q[0][0] + Q[1][1]);
+  const vdop = Math.sqrt(Q[2][2]);
+  return { gdop, pdop, hdop, vdop };
+}
+function invert4x4(m) {
+  const a = m.flat();
+  const inv = new Array(16).fill(0);
+  inv[0] = a[5] * a[10] * a[15] - a[5] * a[11] * a[14] - a[9] * a[6] * a[15] + a[9] * a[7] * a[14] + a[13] * a[6] * a[11] - a[13] * a[7] * a[10];
+  inv[4] = -a[4] * a[10] * a[15] + a[4] * a[11] * a[14] + a[8] * a[6] * a[15] - a[8] * a[7] * a[14] - a[12] * a[6] * a[11] + a[12] * a[7] * a[10];
+  inv[8] = a[4] * a[9] * a[15] - a[4] * a[11] * a[13] - a[8] * a[5] * a[15] + a[8] * a[7] * a[13] + a[12] * a[5] * a[11] - a[12] * a[7] * a[9];
+  inv[12] = -a[4] * a[9] * a[14] + a[4] * a[10] * a[13] + a[8] * a[5] * a[14] - a[8] * a[6] * a[13] - a[12] * a[5] * a[10] + a[12] * a[6] * a[9];
+  inv[1] = -a[1] * a[10] * a[15] + a[1] * a[11] * a[14] + a[9] * a[2] * a[15] - a[9] * a[3] * a[14] - a[13] * a[2] * a[11] + a[13] * a[3] * a[10];
+  inv[5] = a[0] * a[10] * a[15] - a[0] * a[11] * a[14] - a[8] * a[2] * a[15] + a[8] * a[3] * a[14] + a[12] * a[2] * a[11] - a[12] * a[3] * a[10];
+  inv[9] = -a[0] * a[9] * a[15] + a[0] * a[11] * a[13] + a[8] * a[1] * a[15] - a[8] * a[3] * a[13] - a[12] * a[1] * a[11] + a[12] * a[3] * a[9];
+  inv[13] = a[0] * a[9] * a[14] - a[0] * a[10] * a[13] - a[8] * a[1] * a[14] + a[8] * a[2] * a[13] + a[12] * a[1] * a[10] - a[12] * a[2] * a[9];
+  inv[2] = a[1] * a[6] * a[15] - a[1] * a[7] * a[14] - a[5] * a[2] * a[15] + a[5] * a[3] * a[14] + a[13] * a[2] * a[7] - a[13] * a[3] * a[6];
+  inv[6] = -a[0] * a[6] * a[15] + a[0] * a[7] * a[14] + a[4] * a[2] * a[15] - a[4] * a[3] * a[14] - a[12] * a[2] * a[7] + a[12] * a[3] * a[6];
+  inv[10] = a[0] * a[5] * a[15] - a[0] * a[7] * a[13] - a[4] * a[1] * a[15] + a[4] * a[3] * a[13] + a[12] * a[1] * a[7] - a[12] * a[3] * a[5];
+  inv[14] = -a[0] * a[5] * a[14] + a[0] * a[6] * a[13] + a[4] * a[1] * a[14] - a[4] * a[2] * a[13] - a[12] * a[1] * a[6] + a[12] * a[2] * a[5];
+  inv[3] = -a[1] * a[6] * a[11] + a[1] * a[7] * a[10] + a[5] * a[2] * a[11] - a[5] * a[3] * a[10] - a[9] * a[2] * a[7] + a[9] * a[3] * a[6];
+  inv[7] = a[0] * a[6] * a[11] - a[0] * a[7] * a[10] - a[4] * a[2] * a[11] + a[4] * a[3] * a[10] + a[8] * a[2] * a[7] - a[8] * a[3] * a[6];
+  inv[11] = -a[0] * a[5] * a[11] + a[0] * a[7] * a[9] + a[4] * a[1] * a[11] - a[4] * a[3] * a[9] - a[8] * a[1] * a[7] + a[8] * a[3] * a[5];
+  inv[15] = a[0] * a[5] * a[10] - a[0] * a[6] * a[9] - a[4] * a[1] * a[10] + a[4] * a[2] * a[9] + a[8] * a[1] * a[6] - a[8] * a[2] * a[5];
+  let det = a[0] * inv[0] + a[1] * inv[4] + a[2] * inv[8] + a[3] * inv[12];
+  if (Math.abs(det) < 1e-20) return null;
+  det = 1 / det;
+  const result = Array.from(
+    { length: 4 },
+    () => new Array(4).fill(0)
+  );
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      result[i][j] = inv[i * 4 + j] * det;
+    }
+  }
+  return result;
+}
+function selectEphemeris(ephemerides, prn, timeMs) {
+  let best = null;
+  let bestDt = Infinity;
+  for (const eph of ephemerides) {
+    if (eph.prn !== prn) continue;
+    const ephTime = eph.tocDate.getTime();
+    const dt = Math.abs(timeMs - ephTime);
+    if (dt > 4 * 3600 * 1e3) continue;
+    if (dt < bestDt) {
+      bestDt = dt;
+      best = eph;
+    }
+  }
+  return best;
+}
+function computeSatPosition(eph, timeMs) {
+  if (eph.system === "R" || eph.system === "S") {
+    return glonassPosition(eph, timeMs / 1e3);
+  }
+  const GPS_EPOCH = Date.UTC(1980, 0, 6);
+  const gpsSeconds = (timeMs - GPS_EPOCH) / 1e3;
+  const tow = gpsSeconds % (7 * 86400);
+  return keplerPosition(eph, tow);
+}
+function navTimesFromEph(ephs) {
+  let minT = Infinity, maxT = -Infinity;
+  for (const eph of ephs) {
+    const t = eph.tocDate.getTime();
+    if (t < minT) minT = t;
+    if (t > maxT) maxT = t;
+  }
+  const span = maxT - minT;
+  const step = Math.max(span / 500, 3e4);
+  const times = [];
+  for (let t = minT; t <= maxT; t += step) times.push(t);
+  if (times.length === 0 && isFinite(minT)) times.push(minT);
+  return times;
+}
+function computeAllPositions(ephemerides, times, rxPos) {
+  const ephByPrn = /* @__PURE__ */ new Map();
+  for (const eph of ephemerides) {
+    let arr = ephByPrn.get(eph.prn);
+    if (!arr) {
+      arr = [];
+      ephByPrn.set(eph.prn, arr);
+    }
+    arr.push(eph);
+  }
+  const prns = [...ephByPrn.keys()].sort();
+  const positions = {};
+  for (const prn of prns) positions[prn] = [];
+  let sinLat = 0, cosLat = 1, sinLon = 0, cosLon = 1;
+  let hasRx = false;
+  if (rxPos) {
+    const [rxX, rxY, rxZ] = rxPos;
+    if (rxX !== 0 || rxY !== 0 || rxZ !== 0) {
+      hasRx = true;
+      const [gLat, gLon] = ecefToGeodetic(rxX, rxY, rxZ);
+      sinLat = Math.sin(gLat);
+      cosLat = Math.cos(gLat);
+      sinLon = Math.sin(gLon);
+      cosLon = Math.cos(gLon);
+    }
+  }
+  for (const t of times) {
+    for (const prn of prns) {
+      const eph = selectBest(ephByPrn.get(prn), t);
+      if (!eph) {
+        positions[prn].push(null);
+        continue;
+      }
+      const pos = computeSatPosition(eph, t);
+      const [geoLat, geoLon] = ecefToGeodetic(pos.x, pos.y, pos.z);
+      let az = 0, el = 0;
+      if (hasRx) {
+        const dx = pos.x - rxPos[0];
+        const dy = pos.y - rxPos[1];
+        const dz = pos.z - rxPos[2];
+        const east = -sinLon * dx + cosLon * dy;
+        const north = -sinLat * cosLon * dx - sinLat * sinLon * dy + cosLat * dz;
+        const up = cosLat * cosLon * dx + cosLat * sinLon * dy + sinLat * dz;
+        az = (Math.atan2(east, north) + TWO_PI) % TWO_PI;
+        el = Math.atan2(up, Math.sqrt(east * east + north * north));
+      }
+      positions[prn].push({ lat: geoLat, lon: geoLon, az, el });
+    }
+  }
+  return { prns, times, positions };
+}
+function selectBest(ephs, timeMs) {
+  let best = null;
+  let bestDt = Infinity;
+  for (const eph of ephs) {
+    const dt = Math.abs(timeMs - eph.tocDate.getTime());
+    const maxAge = eph.system === "R" || eph.system === "S" ? 18e5 : 4 * 36e5;
+    if (dt > maxAge) continue;
+    if (dt < bestDt) {
+      bestDt = dt;
+      best = eph;
+    }
+  }
+  return best;
+}
+var GPS_EPOCH_MS = Date.UTC(1980, 0, 6);
+var BDS_EPOCH_MS = Date.UTC(2006, 0, 1);
+var GAL_EPOCH_MS = GPS_EPOCH_MS;
+function ephInfoToEphemeris(info) {
+  const sys = info.prn.charAt(0);
+  if (sys === "R") {
+    if (info.x === void 0 || info.y === void 0 || info.z === void 0)
+      return null;
+    if (info.vx === void 0 || info.vy === void 0 || info.vz === void 0)
+      return null;
+    const now = new Date(info.lastReceived);
+    const utcMidnight = Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      now.getUTCDate()
+    );
+    const tbSec = (info.tb ?? 0) * 900;
+    const moscowOffset = 3 * 3600;
+    const tocMs = utcMidnight + (tbSec - moscowOffset) * 1e3;
+    return {
+      system: "R",
+      prn: info.prn,
+      tocDate: new Date(tocMs),
+      tauN: -(info.af0 ?? 0),
+      // RTCM stores -tauN
+      gammaN: info.gammaN ?? 0,
+      messageFrameTime: 0,
+      x: info.x,
+      xDot: info.vx,
+      xAcc: info.ax ?? 0,
+      y: info.y,
+      yDot: info.vy,
+      yAcc: info.ay ?? 0,
+      z: info.z,
+      zDot: info.vz,
+      zAcc: info.az ?? 0,
+      health: info.health,
+      freqNum: info.freqChannel ?? 0
+    };
+  }
+  if (info.sqrtA === void 0 || info.eccentricity === void 0 || info.inclination === void 0 || info.omega0 === void 0 || info.argPerigee === void 0 || info.meanAnomaly === void 0 || info.toe === void 0 || info.week === void 0)
+    return null;
+  let epochMs;
+  const tocSec = info.toc ?? info.toe;
+  if (sys === "C") {
+    epochMs = BDS_EPOCH_MS;
+  } else if (sys === "E") {
+    epochMs = GAL_EPOCH_MS;
+  } else {
+    epochMs = GPS_EPOCH_MS;
+  }
+  const tocDate = new Date(epochMs + info.week * 7 * 864e5 + tocSec * 1e3);
+  return {
+    system: sys,
+    prn: info.prn,
+    toc: tocSec,
+    tocDate,
+    af0: info.af0 ?? 0,
+    af1: info.af1 ?? 0,
+    af2: info.af2 ?? 0,
+    iode: info.iode ?? 0,
+    crs: info.crs ?? 0,
+    deltaN: info.deltaN ?? 0,
+    m0: info.meanAnomaly,
+    cuc: info.cuc ?? 0,
+    e: info.eccentricity,
+    cus: info.cus ?? 0,
+    sqrtA: info.sqrtA,
+    toe: info.toe,
+    cic: info.cic ?? 0,
+    omega0: info.omega0,
+    cis: info.cis ?? 0,
+    i0: info.inclination,
+    crc: info.crc ?? 0,
+    omega: info.argPerigee,
+    omegaDot: info.omegaDot ?? 0,
+    idot: info.idot ?? 0,
+    week: info.week,
+    svHealth: info.health,
+    tgd: 0
+  };
+}
+function computeLiveSkyPositions(ephemerides, rxPos, cn0Map) {
+  const now = Date.now();
+  const result = [];
+  const [rxX, rxY, rxZ] = rxPos;
+  const [rxLat, rxLon] = ecefToGeodetic(rxX, rxY, rxZ);
+  const sinRxLat = Math.sin(rxLat), cosRxLat = Math.cos(rxLat);
+  const sinRxLon = Math.sin(rxLon), cosRxLon = Math.cos(rxLon);
+  for (const info of ephemerides.values()) {
+    const eph = ephInfoToEphemeris(info);
+    if (!eph) continue;
+    try {
+      const pos = computeSatPosition(eph, now);
+      const [satLat, satLon] = ecefToGeodetic(pos.x, pos.y, pos.z);
+      const dx = pos.x - rxX, dy = pos.y - rxY, dz = pos.z - rxZ;
+      const east = -sinRxLon * dx + cosRxLon * dy;
+      const north = -sinRxLat * cosRxLon * dx - sinRxLat * sinRxLon * dy + cosRxLat * dz;
+      const up = cosRxLat * cosRxLon * dx + cosRxLat * sinRxLon * dy + sinRxLat * dz;
+      const az = (Math.atan2(east, north) + TWO_PI) % TWO_PI;
+      const el = Math.atan2(up, Math.sqrt(east * east + north * north));
+      if (el > -0.05) {
+        result.push({
+          prn: info.prn,
+          az,
+          el,
+          lat: satLat,
+          lon: satLon,
+          cn0: cn0Map?.get(info.prn)
+        });
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+
+export {
+  keplerPosition,
+  glonassPosition,
+  ecefToAzEl,
+  computeDop,
+  selectEphemeris,
+  computeSatPosition,
+  navTimesFromEph,
+  computeAllPositions,
+  computeLiveSkyPositions
+};