@neilberkman/sidereon 1.1.0 → 1.2.0

package/pkg-node/sidereon.js

@@ -1223,6 +1223,12 @@ class BroadcastRecordJs {
         BroadcastRecordJsFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof BroadcastRecordJs)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -15285,6 +15291,69 @@ class RinexClock {
 if (Symbol.dispose) RinexClock.prototype[Symbol.dispose] = RinexClock.prototype.free;
 exports.RinexClock = RinexClock;
 
+/**
+ * Result of lenient RINEX NAV parsing.
+ *
+ * `records` contains the supported records in file order and `skipped`
+ * contains malformed supported blocks reported by the core parser.
+ */
+class RinexNavParse {
+    static __wrap(ptr) {
+        const obj = Object.create(RinexNavParse.prototype);
+        obj.__wbg_ptr = ptr;
+        RinexNavParseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RinexNavParseFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rinexnavparse_free(ptr, 0);
+    }
+    /**
+     * Number of supported records returned by the parser.
+     * @returns {number}
+     */
+    get recordCount() {
+        const ret = wasm.rinexnavparse_recordCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Supported broadcast records in file order.
+     * @returns {BroadcastRecordJs[]}
+     */
+    get records() {
+        const ret = wasm.rinexnavparse_records(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Supported blocks skipped by the lenient core parser, in file order.
+     * @returns {SkippedNavBlock[]}
+     */
+    get skipped() {
+        const ret = wasm.rinexnavparse_skipped(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Number of supported blocks skipped by the parser.
+     * @returns {number}
+     */
+    get skippedCount() {
+        const ret = wasm.rinexnavparse_skippedCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RinexNavParse.prototype[Symbol.dispose] = RinexNavParse.prototype.free;
+exports.RinexNavParse = RinexNavParse;
+
 /**
  * Navigation repair result.
  */
@@ -16434,6 +16503,115 @@ class SbasKMultipliers {
 if (Symbol.dispose) SbasKMultipliers.prototype[Symbol.dispose] = SbasKMultipliers.prototype.free;
 exports.SbasKMultipliers = SbasKMultipliers;
 
+/**
+ * One timestamped SBAS message row parsed from an EMS or RTKLIB text log.
+ */
+class SbasLogBlock {
+    static __wrap(ptr) {
+        const obj = Object.create(SbasLogBlock.prototype);
+        obj.__wbg_ptr = ptr;
+        SbasLogBlockFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SbasLogBlockFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sbaslogblock_free(ptr, 0);
+    }
+    /**
+     * Raw SBAS bytes in the form selected by the core parser.
+     * @returns {Uint8Array}
+     */
+    get bytes() {
+        const ret = wasm.sbaslogblock_bytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Decode this raw message using its parsed wire form.
+     * @returns {any}
+     */
+    decode() {
+        const ret = wasm.sbaslogblock_decode(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Core-selected wire form: `"framed250"` or `"body226"`.
+     * @returns {string}
+     */
+    get form() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sbaslogblock_form(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * SBAS satellite token, such as `"S20"`.
+     * @returns {string}
+     */
+    get satellite() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sbaslogblock_satellite(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * SBAS satellite token, such as `"S20"`.
+     * @returns {string}
+     */
+    get satelliteId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sbaslogblock_satelliteId(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Seconds of GPS week of the parsed message epoch.
+     * @returns {number}
+     */
+    get towS() {
+        const ret = wasm.sbaslogblock_towS(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * GPS week of the parsed message epoch.
+     * @returns {number}
+     */
+    get week() {
+        const ret = wasm.sbaslogblock_week(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SbasLogBlock.prototype[Symbol.dispose] = SbasLogBlock.prototype.free;
+exports.SbasLogBlock = SbasLogBlock;
+
 /**
  * SBAS protection-level input or numerical failure.
  * @enum {0 | 1 | 2}
@@ -16937,6 +17115,65 @@ class SignalPolicy {
 if (Symbol.dispose) SignalPolicy.prototype[Symbol.dispose] = SignalPolicy.prototype.free;
 exports.SignalPolicy = SignalPolicy;
 
+/**
+ * One supported RINEX NAV block that the core parser could not represent.
+ *
+ * The diagnostic is retained by [`parseRinexNavLenient`] instead of turning a
+ * malformed supported block into a fatal whole-file error.
+ */
+class SkippedNavBlock {
+    static __wrap(ptr) {
+        const obj = Object.create(SkippedNavBlock.prototype);
+        obj.__wbg_ptr = ptr;
+        SkippedNavBlockFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SkippedNavBlockFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_skippednavblock_free(ptr, 0);
+    }
+    /**
+     * Core parser diagnostic explaining why the block was skipped.
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.skippednavblock_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Satellite token from the skipped block, such as `"G01"`.
+     * @returns {string}
+     */
+    get satellite() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.skippednavblock_satellite(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) SkippedNavBlock.prototype[Symbol.dispose] = SkippedNavBlock.prototype.free;
+exports.SkippedNavBlock = SkippedNavBlock;
+
 /**
  * Reason a carrier-phase arc split was flagged.
  * @enum {0 | 1 | 2 | 3}
@@ -23069,6 +23306,44 @@ function correlationAt(code_a, code_b, lag) {
 }
 exports.correlationAt = correlationAt;
 
+/**
+ * Convert a validated flat row-major 6x6 covariance from km²-based state
+ * units to m²-based state units.
+ * @param {Float64Array} covariance
+ * @returns {Float64Array}
+ */
+function covariance6KmToM(covariance) {
+    const ptr0 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.covariance6KmToM(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.covariance6KmToM = covariance6KmToM;
+
+/**
+ * Convert a validated flat row-major 6x6 covariance from m²-based state
+ * units to km²-based state units.
+ * @param {Float64Array} covariance
+ * @returns {Float64Array}
+ */
+function covariance6MToKm(covariance) {
+    const ptr0 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.covariance6MToKm(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+exports.covariance6MToKm = covariance6MToKm;
+
 /**
  * Fitted parameter covariance from a converged solve, scaling `(J^T J)^-1` by
  * the post-fit reduced chi-square `s_sq = 2 * cost / (m - n)` (the same scale
@@ -23208,6 +23483,38 @@ function cwStm(n_rad_s, dt_s) {
 }
 exports.cwStm = cwStm;
 
+/**
+ * Integer day-of-year from a validated product date.
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @returns {number}
+ */
+function dataDayOfYear(year, month, day) {
+    const ret = wasm.dataDayOfYear(year, month, day);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.dataDayOfYear = dataDayOfYear;
+
+/**
+ * Fractional day-of-year from a civil calendar date and time.
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @param {number} hour
+ * @param {number} minute
+ * @param {number} second
+ * @returns {number}
+ */
+function dayOfYear(year, month, day, hour, minute, second) {
+    const ret = wasm.dayOfYear(year, month, day, hour, minute, second);
+    return ret;
+}
+exports.dayOfYear = dayOfYear;
+
 /**
  * Decode Compact RINEX (Hatanaka) bytes into plain RINEX OBS text. Throws a
  * `TypeError` on non-UTF-8 input and an `Error` on a decode failure.
@@ -23789,6 +24096,31 @@ function ecefToGeodetic(position_km) {
 }
 exports.ecefToGeodetic = ecefToGeodetic;
 
+/**
+ * Transform a flat row-major 6x6 ECI state covariance into RTN coordinates.
+ * Position is in km and velocity is in km/s.
+ * @param {Float64Array} covariance
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+function eciToRtnCovariance6(covariance, position_km, velocity_km_s) {
+    const ptr0 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.eciToRtnCovariance6(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+exports.eciToRtnCovariance6 = eciToRtnCovariance6;
+
 /**
  * Eclipse status for satellite and Sun position batches, km. Returns a
  * `string[]` of `"sunlit"` / `"penumbra"` / `"umbra"`.
@@ -24000,6 +24332,29 @@ function encodeCrinex(rinex_text) {
 }
 exports.encodeCrinex = encodeCrinex;
 
+/**
+ * Encode an arbitrary caller-supplied list of broadcast records as RINEX NAV
+ * text. The list is consumed by the WASM boundary and the bytes are produced
+ * by the core's deterministic encoder.
+ * @param {BroadcastRecordJs[]} records
+ * @returns {string}
+ */
+function encodeRinexNav(records) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArrayJsValueToWasm0(records, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encodeRinexNav(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.encodeRinexNav = encodeRinexNav;
+
 /**
  * Encode a constructed RTCM message into a message body (without the transport
  * frame).
@@ -25636,6 +25991,29 @@ function horizontalRadiusAt(covariance_enu_m2, probability) {
 }
 exports.horizontalRadiusAt = horizontalRadiusAt;
 
+/**
+ * Interpolate two validated same-frame flat row-major 6x6 covariances with
+ * the core PSD-preserving interpolation.
+ * @param {Float64Array} covariance_a
+ * @param {Float64Array} covariance_b
+ * @param {number} u
+ * @returns {Float64Array}
+ */
+function interpolateCovariance6(covariance_a, covariance_b, u) {
+    const ptr0 = passArrayF64ToWasm0(covariance_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(covariance_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.interpolateCovariance6(ptr0, len0, ptr1, len1, u);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+exports.interpolateCovariance6 = interpolateCovariance6;
+
 /**
  * Gauss angles-only orbit determination.
  *
@@ -28051,6 +28429,27 @@ function parseRinexNav(bytes) {
 }
 exports.parseRinexNav = parseRinexNav;
 
+/**
+ * Parse RINEX NAV bytes leniently through the core parser.
+ *
+ * Header failures remain fatal. Malformed supported record blocks are
+ * returned in `skipped` with their satellite token and core diagnostic;
+ * unsupported systems and message rosters retain the core parser's skip
+ * policy. Non-UTF-8 input throws a `TypeError`.
+ * @param {Uint8Array} bytes
+ * @returns {RinexNavParse}
+ */
+function parseRinexNavLenient(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseRinexNavLenient(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RinexNavParse.__wrap(ret[0]);
+}
+exports.parseRinexNavLenient = parseRinexNavLenient;
+
 /**
  * Parse all supported GPS, Galileo, and BeiDou broadcast records from NAV
  * bytes, before the store's default health and message-policy filter.
@@ -28087,6 +28486,42 @@ function parseRinexObs(bytes) {
 }
 exports.parseRinexObs = parseRinexObs;
 
+/**
+ * Parse timestamped SBAS EMS log lines into raw message blocks.
+ * @param {string} text
+ * @returns {SbasLogBlock[]}
+ */
+function parseSbasEmsLines(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseSbasEmsLines(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+exports.parseSbasEmsLines = parseSbasEmsLines;
+
+/**
+ * Parse timestamped RTKLIB SBAS log lines into raw message blocks.
+ * @param {string} text
+ * @returns {SbasLogBlock[]}
+ */
+function parseSbasRtklibLines(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseSbasRtklibLines(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+exports.parseSbasRtklibLines = parseSbasRtklibLines;
+
 /**
  * Parse either CSV or fixed-width TXT space-weather bytes.
  * @param {Uint8Array} bytes
@@ -29008,6 +29443,47 @@ function rinexBandWavelengthM(system, band, glonass_channel) {
 }
 exports.rinexBandWavelengthM = rinexBandWavelengthM;
 
+/**
+ * RINEX observation-code frequency in hertz for a system and full code.
+ *
+ * `rinex_version` is passed to the core policy because some constellation
+ * band meanings depend on the RINEX minor version. GLONASS G1/G2 codes also
+ * require the FDMA channel number. Returns `undefined` when the core has no
+ * mapping for the supplied system/code combination.
+ * @param {GnssSystem} system
+ * @param {string} code
+ * @param {number} rinex_version
+ * @param {number | null} [glonass_channel]
+ * @returns {number | undefined}
+ */
+function rinexObservationFrequencyHz(system, code, rinex_version, glonass_channel) {
+    const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rinexObservationFrequencyHz(system, ptr0, len0, rinex_version, isLikeNone(glonass_channel) ? 0xFFFFFF : glonass_channel);
+    return ret[0] === 0 ? undefined : ret[1];
+}
+exports.rinexObservationFrequencyHz = rinexObservationFrequencyHz;
+
+/**
+ * RINEX observation-code wavelength in metres for a system and full code.
+ *
+ * This uses the same version-aware observation-code policy as
+ * [`rinexObservationFrequencyHz`]. Returns `undefined` when no core mapping
+ * exists.
+ * @param {GnssSystem} system
+ * @param {string} code
+ * @param {number} rinex_version
+ * @param {number | null} [glonass_channel]
+ * @returns {number | undefined}
+ */
+function rinexObservationWavelengthM(system, code, rinex_version, glonass_channel) {
+    const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rinexObservationWavelengthM(system, ptr0, len0, rinex_version, isLikeNone(glonass_channel) ? 0xFFFFFF : glonass_channel);
+    return ret[0] === 0 ? undefined : ret[1];
+}
+exports.rinexObservationWavelengthM = rinexObservationWavelengthM;
+
 /**
  * @param {Float64Array} position_km
  * @param {Float64Array} velocity_km_s
@@ -29181,6 +29657,31 @@ function rtnToEciCovariance(covariance_rtn, position_km, velocity_km_s) {
 }
 exports.rtnToEciCovariance = rtnToEciCovariance;
 
+/**
+ * Transform a flat row-major 6x6 RTN state covariance into ECI coordinates.
+ * Position is in km and velocity is in km/s.
+ * @param {Float64Array} covariance
+ * @param {Float64Array} position_km
+ * @param {Float64Array} velocity_km_s
+ * @returns {Float64Array}
+ */
+function rtnToEciCovariance6(covariance, position_km, velocity_km_s) {
+    const ptr0 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(position_km, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(velocity_km_s, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.rtnToEciCovariance6(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+exports.rtnToEciCovariance6 = rtnToEciCovariance6;
+
 /**
  * Convert an inertial Cartesian state to classical orbital elements.
  *
@@ -29533,6 +30034,19 @@ function seasonsSpk(spk, start_unix_us, end_unix_us, step_s, tolerance_s) {
 }
 exports.seasonsSpk = seasonsSpk;
 
+/**
+ * Seconds elapsed since the beginning of a civil day.
+ * @param {number} hour
+ * @param {number} minute
+ * @param {number} second
+ * @returns {number}
+ */
+function secondOfDay(hour, minute, second) {
+    const ret = wasm.secondOfDay(hour, minute, second);
+    return ret;
+}
+exports.secondOfDay = secondOfDay;
+
 /**
  * Select an IONEX product usable at `requestedEpochJ2000S`, degrading to a
  * diurnal-shifted prior product within `policy`.
@@ -31603,6 +32117,10 @@ function __wbg_get_imports() {
             const ret = BroadcastRecordJs.__wrap(arg0);
             return ret;
         },
+        __wbg_broadcastrecordjs_unwrap: function(arg0) {
+            const ret = BroadcastRecordJs.__unwrap(arg0);
+            return ret;
+        },
         __wbg_call_8a2dd23819f8a60a: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
@@ -31898,6 +32416,10 @@ function __wbg_get_imports() {
             const ret = SatellitePass.__wrap(arg0);
             return ret;
         },
+        __wbg_sbaslogblock_new: function(arg0) {
+            const ret = SbasLogBlock.__wrap(arg0);
+            return ret;
+        },
         __wbg_set_575dd786d51585f8: function(arg0, arg1, arg2) {
             const ret = arg0.set(arg1, arg2);
             return ret;
@@ -31915,6 +32437,10 @@ function __wbg_get_imports() {
         __wbg_set_name_3bbc583faefa4193: function(arg0, arg1, arg2) {
             arg0.name = getStringFromWasm0(arg1, arg2);
         },
+        __wbg_skippednavblock_new: function(arg0) {
+            const ret = SkippedNavBlock.__wrap(arg0);
+            return ret;
+        },
         __wbg_slipresult_new: function(arg0) {
             const ret = SlipResult.__wrap(arg0);
             return ret;
@@ -32454,6 +32980,9 @@ const ReducedOrbitStateFinalization = (typeof FinalizationRegistry === 'undefine
 const RinexClockFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rinexclock_free(ptr, 1));
+const RinexNavParseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rinexnavparse_free(ptr, 1));
 const RinexNavRepairFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rinexnavrepair_free(ptr, 1));
@@ -32490,6 +33019,9 @@ const SbasErrorModelFinalization = (typeof FinalizationRegistry === 'undefined')
 const SbasKMultipliersFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sbaskmultipliers_free(ptr, 1));
+const SbasLogBlockFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sbaslogblock_free(ptr, 1));
 const SbasProtectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sbasprotection_free(ptr, 1));
@@ -32502,6 +33034,9 @@ const SignalAnalysisModulationFinalization = (typeof FinalizationRegistry === 'u
 const SignalPolicyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signalpolicy_free(ptr, 1));
+const SkippedNavBlockFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_skippednavblock_free(ptr, 1));
 const SlipResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_slipresult_free(ptr, 1));