gnss-js 1.24.0 → 1.26.0

package/dist/binex.d.cts

@@ -0,0 +1,189 @@
+import { E as Ephemeris } from './nav-DImXUdbp.cjs';
+
+/**
+ * BINEX (BINary EXchange) framing, shared by the observation and
+ * navigation decoders.
+ *
+ * A forward-readable record is: a 1-byte sync that encodes byte order and
+ * checksum model, a record ID (ubnxi), a message length (ubnxi), the
+ * message body, then a trailing checksum whose width depends on the
+ * covered-byte count. Sync bytes (ref [1] §"Format Details"):
+ *
+ *   0xC2  little-endian, regular  CRC (forward)
+ *   0xE2  big-endian,    regular  CRC (forward)
+ *   0xC8  little-endian, enhanced CRC (forward)
+ *   0xE8  big-endian,    enhanced CRC (forward)
+ *
+ * The reverse-readable variants (0xD2/0xF2/0xD8/0xF8 leading and
+ * 0xB4/0xB0/0xE4/0xE0 terminating) are NOT decoded here (deferred).
+ *
+ * Checksum widths over the covered bytes N = recordID + lengthField +
+ * body (regular model): N ≤ 127 → 1-byte XOR; 128–4095 → CRC16
+ * (x^16+x^12+x^5+1, i.e. poly 0x1021 MSB-first, init 0); 4096–1048575 →
+ * CRC32 (poly 0x04C11DB7 MSB-first); ≥ 1048576 → 16-byte MD5. Enhanced
+ * model shifts every threshold up one step (CRC16 from 0 bytes, no XOR).
+ * The 16-byte MD5 case is not implemented (records that large do not
+ * occur in GNSS obs/eph streams); such a record is treated as bad.
+ *
+ * ubnxi (1–4 byte unsigned) and the field layouts are ported from RTKLIB
+ * demo5/2.4.3 src/rcv/binex.c (getbnxi, decode_bnx, Copyright (c)
+ * 2013-2018 T. Takasu, BSD-2-Clause) and cross-checked against the
+ * EarthScope/UNAVCO BINEX definition [1].
+ *
+ * [1] UNAVCO/EarthScope, BINEX: Binary exchange format
+ *     (http://binex.unavco.org/binex.html).
+ */
+/** BINEX 2-byte CRC (x^16+x^12+x^5+1), init 0, MSB-first. */
+declare function binexCrc16(data: Uint8Array, start: number, end: number): number;
+/**
+ * BINEX 4-byte CRC (poly 0x04C11DB7), init 0, MSB-first. Not exercised
+ * by any known fixture (obs/eph records use XOR-8 or CRC16); implemented
+ * to spec but fixture-unverified.
+ */
+declare function binexCrc32(data: Uint8Array, start: number, end: number): number;
+/** 8-bit XOR checksum of `data[start, end)`. */
+declare function binexCsum8(data: Uint8Array, start: number, end: number): number;
+/**
+ * Decode a BINEX ubnxi (1–4 byte unsigned integer, MSB-first) at
+ * `data[pos]`. The first up-to-three bytes contribute their low 7 bits
+ * with the high bit as a continuation flag; a fourth byte (reached only
+ * when the first three all continue) contributes all 8 bits. Returns the
+ * value and the number of bytes consumed (1–4). Ported from RTKLIB
+ * getbnxi.
+ */
+declare function getBnxi(data: Uint8Array, pos: number): {
+    value: number;
+    size: number;
+};
+/** One checksum-valid forward BINEX record located in a byte stream. */
+interface BinexRecord {
+    /** Record ID (e.g. 0x01, 0x7f). */
+    id: number;
+    /** Offset of the sync byte. */
+    start: number;
+    /** Offset of the message body (first byte after the length field). */
+    body: number;
+    /** Message body length in bytes. */
+    len: number;
+    /** True when the sync selects little-endian field byte order. */
+    littleEndian: boolean;
+    /** True when the sync selects the enhanced-CRC model. */
+    enhanced: boolean;
+}
+/**
+ * Iterate every checksum-valid forward BINEX record in `data`. Corrupt
+ * or truncated candidates resync at the next byte; checksum failures
+ * additionally increment `stats.badCrc`. Reverse-readable records are
+ * not recognised.
+ */
+declare function binexRecords(data: Uint8Array, view: DataView, stats: {
+    badCrc: number;
+}): Generator<BinexRecord>;
+
+/**
+ * BINEX record 0x01 — decoded GNSS ephemeris — with the per-constellation
+ * subrecords laid out in RTKLIB src/rcv/binex.c:
+ *
+ *   0x01-01 GPS LNAV      (decode_bnx_01_01)
+ *   0x01-02 GLONASS       (decode_bnx_01_02)
+ *   0x01-03 SBAS          (decode_bnx_01_03)
+ *   0x01-04 Galileo       (decode_bnx_01_04)
+ *   0x01-05 BeiDou-2/3    (decode_bnx_01_05)
+ *   0x01-06 QZSS          (decode_bnx_01_06)
+ *
+ * Ported from RTKLIB demo5/2.4.3 src/rcv/binex.c (Copyright (c) 2013-2018
+ * T. Takasu, BSD-2-Clause) and cross-checked against the EarthScope/UNAVCO
+ * BINEX definition and its reference RINEX fixtures.
+ *
+ * Output records mirror what `parseNavFile` produces for the equivalent
+ * RINEX navigation file, exactly like the SBF/NovAtel decoders:
+ *  - the Keplerian angles M0/Ω0/ω/i0 arrive as radians on the wire (R8),
+ *    while the rate terms Δn/Ω̇/İ arrive as semicircles (R4) and are
+ *    scaled by π (IS-GPS-200 SC2RAD);
+ *  - BeiDou epochs and weeks stay on the BDT scale (no BDT→GPST shift),
+ *    matching a RINEX BDS record and the NovAtel decoder;
+ *  - GLONASS state vectors are in km (PZ-90), the clock is −τ_n (the
+ *    RINEX sign), the reference epoch is UTC, and `messageFrameTime` is
+ *    the frame time `tof` as broadcast (seconds of day);
+ *  - deferred subrecords: 0x01-00 (raw-byte ephemeris) and 0x01-14 (a
+ *    newer Galileo encoding not covered by RTKLIB).
+ */
+
+/**
+ * Decode a record-0x01 ephemeris body. `body` points at the subrecord-ID
+ * byte. Returns the decoded `Ephemeris`, or null for an unsupported or
+ * malformed subrecord. Minimum body lengths mirror RTKLIB's guards.
+ */
+declare function decodeBinexEph(view: DataView, body: number, len: number, le: boolean): Ephemeris | null;
+
+/**
+ * BINEX (BINary EXchange) decoding — the path from a receiver BINEX log
+ * to RINEX-grade observables and broadcast ephemerides, mirroring the
+ * SBF and NovAtel decoders in this package.
+ *
+ * `parseBinex` runs a single framing pass over the byte stream and emits
+ * both observation epochs (record 0x7f-05, the obs record `convbin`
+ * reads) and decoded `Ephemeris` records (record 0x01, per-constellation
+ * subrecords). Frame walking, the ubnxi variable-length integer, the
+ * XOR-8/CRC16/CRC32 checksum models and the field layouts are ported
+ * from RTKLIB demo5/2.4.3 src/rcv/binex.c (Copyright (c) 2013-2018
+ * T. Takasu, BSD-2-Clause) and cross-checked against the
+ * EarthScope/UNAVCO BINEX definition and its reference RINEX fixtures.
+ *
+ * Framing (forward records only): a sync byte (0xE2 big-endian /
+ * 0xC2 little-endian, regular CRC; 0xE8/0xC8 enhanced CRC), the record
+ * ID, the message length (ubnxi), the body, then the checksum. The
+ * subrecord ID is the first body byte. Reverse-readable records
+ * (0xD2/0xF2/0xD8/0xF8 and terminating variants) are NOT decoded.
+ *
+ * Implemented: 0x7f-05 observations (multi-GNSS pseudorange, carrier
+ * phase, Doppler, C/N0, slip) and 0x01-01…06 ephemeris (GPS, GLONASS,
+ * SBAS, Galileo, BeiDou, QZSS). Deferred (counted, skipped): 0x00 site
+ * metadata, 0x02/0x03 generalized data, 0x7d/0x7e prototyping, the
+ * 0x7f-00…04 obs prototypes, 0x01-00 raw-byte ephemeris and 0x01-14.
+ */
+
+interface BinexMeasurement {
+    /** RINEX PRN, e.g. "G04", "R11", "S23", "J01". */
+    prn: string;
+    /** RINEX band+attribute, e.g. "1C", "2W", "5Q", "2I". */
+    code: string;
+    /** Pseudorange (m). */
+    pr: number | null;
+    /** Carrier phase (cycles, RINEX sign), null when the frequency is unknown. */
+    cp: number | null;
+    /** Doppler (Hz), null when the record carries none for the signal. */
+    doppler: number | null;
+    /** C/N0 (dB-Hz). */
+    cn0: number | null;
+    /** Loss-of-lock / cycle-slip flag. */
+    slip: boolean;
+}
+interface BinexEpoch {
+    /** Receiver epoch (GPS-scale ms — same convention as the RINEX parser). */
+    timeMs: number;
+    meas: BinexMeasurement[];
+}
+interface BinexParseResult {
+    /** Observation epochs (record 0x7f-05), one per record. */
+    epochs: BinexEpoch[];
+    /** Broadcast ephemerides (record 0x01), duplicates suppressed. */
+    ephemerides: Ephemeris[];
+    /** Count per record/subrecord, keyed "0x7f-05" / "0x01-01" style. */
+    messageCounts: Record<string, number>;
+    /** Observation codes seen per system letter, in first-seen order. */
+    obsCodes: Record<string, string[]>;
+    /** Records whose checksum failed (corruption indicator). */
+    badCrc: number;
+}
+/**
+ * Decode every supported BINEX record in a byte stream: 0x7f-05
+ * observation epochs and 0x01-01…06 broadcast ephemerides. Repeated
+ * broadcasts of an unchanged ephemeris are suppressed the way RTKLIB
+ * does: GPS/Galileo/QZSS/BeiDou by issue of data (iode) plus toe and toc,
+ * GLONASS/SBAS by reference epoch and health. Other records are counted
+ * and skipped; checksum failures resync at the next byte.
+ */
+declare function parseBinex(data: Uint8Array): BinexParseResult;
+
+export { type BinexEpoch, type BinexMeasurement, type BinexParseResult, type BinexRecord, binexCrc16, binexCrc32, binexCsum8, binexRecords, decodeBinexEph, getBnxi, parseBinex };

package/dist/binex.d.ts

@@ -0,0 +1,189 @@
+import { E as Ephemeris } from './nav-DImXUdbp.js';
+
+/**
+ * BINEX (BINary EXchange) framing, shared by the observation and
+ * navigation decoders.
+ *
+ * A forward-readable record is: a 1-byte sync that encodes byte order and
+ * checksum model, a record ID (ubnxi), a message length (ubnxi), the
+ * message body, then a trailing checksum whose width depends on the
+ * covered-byte count. Sync bytes (ref [1] §"Format Details"):
+ *
+ *   0xC2  little-endian, regular  CRC (forward)
+ *   0xE2  big-endian,    regular  CRC (forward)
+ *   0xC8  little-endian, enhanced CRC (forward)
+ *   0xE8  big-endian,    enhanced CRC (forward)
+ *
+ * The reverse-readable variants (0xD2/0xF2/0xD8/0xF8 leading and
+ * 0xB4/0xB0/0xE4/0xE0 terminating) are NOT decoded here (deferred).
+ *
+ * Checksum widths over the covered bytes N = recordID + lengthField +
+ * body (regular model): N ≤ 127 → 1-byte XOR; 128–4095 → CRC16
+ * (x^16+x^12+x^5+1, i.e. poly 0x1021 MSB-first, init 0); 4096–1048575 →
+ * CRC32 (poly 0x04C11DB7 MSB-first); ≥ 1048576 → 16-byte MD5. Enhanced
+ * model shifts every threshold up one step (CRC16 from 0 bytes, no XOR).
+ * The 16-byte MD5 case is not implemented (records that large do not
+ * occur in GNSS obs/eph streams); such a record is treated as bad.
+ *
+ * ubnxi (1–4 byte unsigned) and the field layouts are ported from RTKLIB
+ * demo5/2.4.3 src/rcv/binex.c (getbnxi, decode_bnx, Copyright (c)
+ * 2013-2018 T. Takasu, BSD-2-Clause) and cross-checked against the
+ * EarthScope/UNAVCO BINEX definition [1].
+ *
+ * [1] UNAVCO/EarthScope, BINEX: Binary exchange format
+ *     (http://binex.unavco.org/binex.html).
+ */
+/** BINEX 2-byte CRC (x^16+x^12+x^5+1), init 0, MSB-first. */
+declare function binexCrc16(data: Uint8Array, start: number, end: number): number;
+/**
+ * BINEX 4-byte CRC (poly 0x04C11DB7), init 0, MSB-first. Not exercised
+ * by any known fixture (obs/eph records use XOR-8 or CRC16); implemented
+ * to spec but fixture-unverified.
+ */
+declare function binexCrc32(data: Uint8Array, start: number, end: number): number;
+/** 8-bit XOR checksum of `data[start, end)`. */
+declare function binexCsum8(data: Uint8Array, start: number, end: number): number;
+/**
+ * Decode a BINEX ubnxi (1–4 byte unsigned integer, MSB-first) at
+ * `data[pos]`. The first up-to-three bytes contribute their low 7 bits
+ * with the high bit as a continuation flag; a fourth byte (reached only
+ * when the first three all continue) contributes all 8 bits. Returns the
+ * value and the number of bytes consumed (1–4). Ported from RTKLIB
+ * getbnxi.
+ */
+declare function getBnxi(data: Uint8Array, pos: number): {
+    value: number;
+    size: number;
+};
+/** One checksum-valid forward BINEX record located in a byte stream. */
+interface BinexRecord {
+    /** Record ID (e.g. 0x01, 0x7f). */
+    id: number;
+    /** Offset of the sync byte. */
+    start: number;
+    /** Offset of the message body (first byte after the length field). */
+    body: number;
+    /** Message body length in bytes. */
+    len: number;
+    /** True when the sync selects little-endian field byte order. */
+    littleEndian: boolean;
+    /** True when the sync selects the enhanced-CRC model. */
+    enhanced: boolean;
+}
+/**
+ * Iterate every checksum-valid forward BINEX record in `data`. Corrupt
+ * or truncated candidates resync at the next byte; checksum failures
+ * additionally increment `stats.badCrc`. Reverse-readable records are
+ * not recognised.
+ */
+declare function binexRecords(data: Uint8Array, view: DataView, stats: {
+    badCrc: number;
+}): Generator<BinexRecord>;
+
+/**
+ * BINEX record 0x01 — decoded GNSS ephemeris — with the per-constellation
+ * subrecords laid out in RTKLIB src/rcv/binex.c:
+ *
+ *   0x01-01 GPS LNAV      (decode_bnx_01_01)
+ *   0x01-02 GLONASS       (decode_bnx_01_02)
+ *   0x01-03 SBAS          (decode_bnx_01_03)
+ *   0x01-04 Galileo       (decode_bnx_01_04)
+ *   0x01-05 BeiDou-2/3    (decode_bnx_01_05)
+ *   0x01-06 QZSS          (decode_bnx_01_06)
+ *
+ * Ported from RTKLIB demo5/2.4.3 src/rcv/binex.c (Copyright (c) 2013-2018
+ * T. Takasu, BSD-2-Clause) and cross-checked against the EarthScope/UNAVCO
+ * BINEX definition and its reference RINEX fixtures.
+ *
+ * Output records mirror what `parseNavFile` produces for the equivalent
+ * RINEX navigation file, exactly like the SBF/NovAtel decoders:
+ *  - the Keplerian angles M0/Ω0/ω/i0 arrive as radians on the wire (R8),
+ *    while the rate terms Δn/Ω̇/İ arrive as semicircles (R4) and are
+ *    scaled by π (IS-GPS-200 SC2RAD);
+ *  - BeiDou epochs and weeks stay on the BDT scale (no BDT→GPST shift),
+ *    matching a RINEX BDS record and the NovAtel decoder;
+ *  - GLONASS state vectors are in km (PZ-90), the clock is −τ_n (the
+ *    RINEX sign), the reference epoch is UTC, and `messageFrameTime` is
+ *    the frame time `tof` as broadcast (seconds of day);
+ *  - deferred subrecords: 0x01-00 (raw-byte ephemeris) and 0x01-14 (a
+ *    newer Galileo encoding not covered by RTKLIB).
+ */
+
+/**
+ * Decode a record-0x01 ephemeris body. `body` points at the subrecord-ID
+ * byte. Returns the decoded `Ephemeris`, or null for an unsupported or
+ * malformed subrecord. Minimum body lengths mirror RTKLIB's guards.
+ */
+declare function decodeBinexEph(view: DataView, body: number, len: number, le: boolean): Ephemeris | null;
+
+/**
+ * BINEX (BINary EXchange) decoding — the path from a receiver BINEX log
+ * to RINEX-grade observables and broadcast ephemerides, mirroring the
+ * SBF and NovAtel decoders in this package.
+ *
+ * `parseBinex` runs a single framing pass over the byte stream and emits
+ * both observation epochs (record 0x7f-05, the obs record `convbin`
+ * reads) and decoded `Ephemeris` records (record 0x01, per-constellation
+ * subrecords). Frame walking, the ubnxi variable-length integer, the
+ * XOR-8/CRC16/CRC32 checksum models and the field layouts are ported
+ * from RTKLIB demo5/2.4.3 src/rcv/binex.c (Copyright (c) 2013-2018
+ * T. Takasu, BSD-2-Clause) and cross-checked against the
+ * EarthScope/UNAVCO BINEX definition and its reference RINEX fixtures.
+ *
+ * Framing (forward records only): a sync byte (0xE2 big-endian /
+ * 0xC2 little-endian, regular CRC; 0xE8/0xC8 enhanced CRC), the record
+ * ID, the message length (ubnxi), the body, then the checksum. The
+ * subrecord ID is the first body byte. Reverse-readable records
+ * (0xD2/0xF2/0xD8/0xF8 and terminating variants) are NOT decoded.
+ *
+ * Implemented: 0x7f-05 observations (multi-GNSS pseudorange, carrier
+ * phase, Doppler, C/N0, slip) and 0x01-01…06 ephemeris (GPS, GLONASS,
+ * SBAS, Galileo, BeiDou, QZSS). Deferred (counted, skipped): 0x00 site
+ * metadata, 0x02/0x03 generalized data, 0x7d/0x7e prototyping, the
+ * 0x7f-00…04 obs prototypes, 0x01-00 raw-byte ephemeris and 0x01-14.
+ */
+
+interface BinexMeasurement {
+    /** RINEX PRN, e.g. "G04", "R11", "S23", "J01". */
+    prn: string;
+    /** RINEX band+attribute, e.g. "1C", "2W", "5Q", "2I". */
+    code: string;
+    /** Pseudorange (m). */
+    pr: number | null;
+    /** Carrier phase (cycles, RINEX sign), null when the frequency is unknown. */
+    cp: number | null;
+    /** Doppler (Hz), null when the record carries none for the signal. */
+    doppler: number | null;
+    /** C/N0 (dB-Hz). */
+    cn0: number | null;
+    /** Loss-of-lock / cycle-slip flag. */
+    slip: boolean;
+}
+interface BinexEpoch {
+    /** Receiver epoch (GPS-scale ms — same convention as the RINEX parser). */
+    timeMs: number;
+    meas: BinexMeasurement[];
+}
+interface BinexParseResult {
+    /** Observation epochs (record 0x7f-05), one per record. */
+    epochs: BinexEpoch[];
+    /** Broadcast ephemerides (record 0x01), duplicates suppressed. */
+    ephemerides: Ephemeris[];
+    /** Count per record/subrecord, keyed "0x7f-05" / "0x01-01" style. */
+    messageCounts: Record<string, number>;
+    /** Observation codes seen per system letter, in first-seen order. */
+    obsCodes: Record<string, string[]>;
+    /** Records whose checksum failed (corruption indicator). */
+    badCrc: number;
+}
+/**
+ * Decode every supported BINEX record in a byte stream: 0x7f-05
+ * observation epochs and 0x01-01…06 broadcast ephemerides. Repeated
+ * broadcasts of an unchanged ephemeris are suppressed the way RTKLIB
+ * does: GPS/Galileo/QZSS/BeiDou by issue of data (iode) plus toe and toc,
+ * GLONASS/SBAS by reference epoch and health. Other records are counted
+ * and skipped; checksum failures resync at the next byte.
+ */
+declare function parseBinex(data: Uint8Array): BinexParseResult;
+
+export { type BinexEpoch, type BinexMeasurement, type BinexParseResult, type BinexRecord, binexCrc16, binexCrc32, binexCsum8, binexRecords, decodeBinexEph, getBnxi, parseBinex };

package/dist/binex.js

@@ -0,0 +1,19 @@
+import {
+  binexCrc16,
+  binexCrc32,
+  binexCsum8,
+  binexRecords,
+  decodeBinexEph,
+  getBnxi,
+  parseBinex
+} from "./chunk-OK4GGNOO.js";
+import "./chunk-IQ5OIMQD.js";
+export {
+  binexCrc16,
+  binexCrc32,
+  binexCsum8,
+  binexRecords,
+  decodeBinexEph,
+  getBnxi,
+  parseBinex
+};

package/dist/{chunk-T2ZMNRCY.js → chunk-4XGKCVE3.js}

@@ -43,6 +43,51 @@ function klobucharDelay(coeffs, latRad, lonRad, azRad, elRad, gpsTowSec) {
   return F * (5e-9 + amp * (1 - x2 / 2 + x2 * x2 / 24));
 }
 
+// src/positioning/gim.ts
+var R_E = 6371e3;
+var H_ION = 45e4;
+var F_L1 = 157542e4;
+var IONO_L1_M_PER_TECU = 403e15 / (F_L1 * F_L1);
+function tecAtMap(grid, mapIdx, latDeg, lonDeg) {
+  const m = grid.maps[mapIdx];
+  const { lats, lons } = grid;
+  const w = lons.length;
+  const fi = (latDeg - lats[0]) / (lats[lats.length - 1] - lats[0]) * (lats.length - 1);
+  const fj = (lonDeg - lons[0]) / (lons[w - 1] - lons[0]) * (w - 1);
+  const i0 = Math.max(0, Math.min(lats.length - 2, Math.floor(fi)));
+  const j0 = Math.max(0, Math.min(w - 2, Math.floor(fj)));
+  const di = Math.max(0, Math.min(1, fi - i0));
+  const dj = Math.max(0, Math.min(1, fj - j0));
+  return m[i0 * w + j0] * (1 - di) * (1 - dj) + m[i0 * w + j0 + 1] * (1 - di) * dj + m[(i0 + 1) * w + j0] * di * (1 - dj) + m[(i0 + 1) * w + j0 + 1] * di * dj;
+}
+function gimVerticalTec(grid, timeMs, latDeg, lonDeg) {
+  const e = grid.epochs;
+  if (e.length === 0 || timeMs < e[0] || timeMs > e[e.length - 1]) return null;
+  let i = 0;
+  while (i < e.length - 2 && e[i + 1] <= timeMs) i++;
+  const span = e[i + 1] - e[i];
+  const f = span > 0 ? (timeMs - e[i]) / span : 0;
+  const a = tecAtMap(grid, i, latDeg, lonDeg);
+  const b = tecAtMap(grid, i + 1, latDeg, lonDeg);
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return null;
+  return a * (1 - f) + b * f;
+}
+function gimSlantIonoDelayL1(grid, latRad, lonRad, azRad, elRad, timeMs) {
+  if (elRad <= 0) return null;
+  const sinZp = R_E / (R_E + H_ION) * Math.cos(elRad);
+  const mapping = 1 / Math.sqrt(1 - sinZp * sinZp);
+  const psi = Math.PI / 2 - elRad - Math.asin(sinZp);
+  const latI = Math.asin(
+    Math.sin(latRad) * Math.cos(psi) + Math.cos(latRad) * Math.sin(psi) * Math.cos(azRad)
+  );
+  const lonI = lonRad + Math.asin(Math.sin(psi) * Math.sin(azRad) / Math.cos(latI));
+  const latDeg = latI * 180 / Math.PI;
+  const lonDeg = ((lonI * 180 / Math.PI + 540) % 360 + 360) % 360 - 180;
+  const vtec = gimVerticalTec(grid, timeMs, latDeg, lonDeg);
+  if (vtec === null) return null;
+  return IONO_L1_M_PER_TECU * vtec * mapping;
+}
+
 // src/positioning/lambda.ts
 var LOOPMAX = 1e4;
 var ROUND = (x) => Math.floor(x + 0.5);
@@ -1084,10 +1129,17 @@ var PRIMARY_FREQ_HZ = {
   C: 1561098e3,
   R: 1602e6
 };
-var F_L1 = 157542e4;
-function tropoDelay2(elevationRad) {
-  const sinEl = Math.sin(elevationRad);
-  return 2.47 / (sinEl + 0.0121);
+var F_L12 = 157542e4;
+function tropoDelay2(elevationRad, latRad, heightM) {
+  if (elevationRad <= 0) return 0;
+  const h = heightM < 0 ? 0 : heightM > 1e4 ? 1e4 : heightM;
+  const humi = 0.7;
+  const pres = 1013.25 * Math.pow(1 - 22557e-9 * h, 5.2568);
+  const temp = 15 - 65e-4 * h + 273.16;
+  const e = 6.108 * humi * Math.exp((17.15 * temp - 4684) / (temp - 38.45));
+  const zhd = 22768e-7 * pres / (1 - 266e-5 * Math.cos(2 * latRad) - 28e-5 * (h / 1e3));
+  const zwd = 2277e-6 * (1255 / temp + 0.05) * e;
+  return (zhd + zwd) / Math.sin(elevationRad);
 }
 function sagnac2(pos, travelTimeS) {
   const theta = OMEGA_E * travelTimeS;
@@ -1120,7 +1172,8 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
     maxIterations = 15,
     convergenceM = 1e-4,
     tgd = true,
-    iono
+    iono,
+    gim
   } = opts;
   const gpsTow = (timeMs - GPS_EPOCH_MS_SPP) / 1e3 % 604800;
   const all = [...pseudoranges.keys()].filter((p) => ephemerides.has(p));
@@ -1147,7 +1200,7 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
       let rows = 0;
       for (const k of Object.keys(residuals2)) delete residuals2[k];
       const positionSaneIter = x2 * x2 + y2 * y2 + z2 * z2 > 1e12;
-      const [rxLat, rxLon] = positionSaneIter ? ecefToGeodetic(x2, y2, z2) : [0, 0];
+      const [rxLat, rxLon, rxHgt] = positionSaneIter ? ecefToGeodetic(x2, y2, z2) : [0, 0, 0];
       for (const prn of prns) {
         const psr = pseudoranges.get(prn);
         const eph = ephemerides.get(prn);
@@ -1177,11 +1230,18 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
           const sinEl = Math.max(Math.sin(elev), 0.1);
           weight = sinEl * sinEl;
         }
-        const tropo = troposphere && positionSane ? tropoDelay2(elev) : 0;
+        const tropo = troposphere && positionSane ? tropoDelay2(elev, rxLat, rxHgt) : 0;
         let ionoM = 0;
-        if (iono && positionSane) {
-          const f = PRIMARY_FREQ_HZ[sys] ?? F_L1;
-          ionoM = C_LIGHT * klobucharDelay(iono, rxLat, rxLon, azim, elev, gpsTow) * (F_L1 / f * (F_L1 / f));
+        if ((gim || iono) && positionSane) {
+          let l1M = null;
+          if (gim) l1M = gimSlantIonoDelayL1(gim, rxLat, rxLon, azim, elev, timeMs);
+          if (l1M === null && iono) {
+            l1M = C_LIGHT * klobucharDelay(iono, rxLat, rxLon, azim, elev, gpsTow);
+          }
+          if (l1M !== null) {
+            const f = PRIMARY_FREQ_HZ[sys] ?? F_L12;
+            ionoM = l1M * (F_L12 / f * (F_L12 / f));
+          }
         }
         const predicted = rho + clk - C_LIGHT * dts + tropo + ionoM;
         const v = psr - predicted;
@@ -1263,6 +1323,9 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
 
 export {
   klobucharDelay,
+  IONO_L1_M_PER_TECU,
+  gimVerticalTec,
+  gimSlantIonoDelayL1,
   lambdaSearch,
   lambdaReduction,
   toRtkEpoch,

package/dist/{chunk-VTX3VCL4.js → chunk-5AUK42AL.js}

@@ -1,9 +1,11 @@
+import {
+  crc24q
+} from "./chunk-726LQBGM.js";
 import {
   GPS_PI,
-  crc24q,
   getBitS,
   getBitU
-} from "./chunk-WZDFZ76K.js";
+} from "./chunk-IQ5OIMQD.js";
 import {
   getUtcDate
 } from "./chunk-HVXYFUCB.js";