From e526fdeaf97ff6e5b787de4eceb822908d36240b Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 10:48:39 +0200 Subject: [PATCH 01/11] Update message --- .github/workflows/haskell.yaml | 2 +- .github/workflows/java.yaml | 21 +-- .github/workflows/javascript.yaml | 2 +- .github/workflows/test_validate.yaml | 2 +- .github/workflows/validate.yaml | 10 +- HOWTO.md | 192 ++++++++++++++------------ README.md | 139 +++++++++++-------- spec/yaml/swiftnav/sbp/integrity.yaml | 129 ++++++++++++++++- 8 files changed, 321 insertions(+), 176 deletions(-) diff --git a/.github/workflows/haskell.yaml b/.github/workflows/haskell.yaml index cde4e1d086..98f1707d9e 100644 --- a/.github/workflows/haskell.yaml +++ b/.github/workflows/haskell.yaml @@ -14,7 +14,7 @@ on: jobs: build: name: Build - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 diff --git a/.github/workflows/java.yaml b/.github/workflows/java.yaml index db49657542..89bc60ae37 100644 --- a/.github/workflows/java.yaml +++ b/.github/workflows/java.yaml @@ -14,7 +14,7 @@ on: jobs: tests-java-1_8: name: Test - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 - uses: gradle/gradle-build-action@v3 @@ -22,22 +22,3 @@ jobs: gradle-version: 7.1.1 - name: Run tests run: make test-java - -# sonarqube: -# name: SonarQube -# runs-on: ubuntu-20.04 -# steps: -# - uses: actions/checkout@v4 -# with: -# fetch-depth: 0 -# - uses: gradle/gradle-build-action@v3 -# with: -# gradle-version: 7.1.1 -# - name: Run tests -# run: make test-java -# -# - name: Run sonarqube -# env: -# GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} -# SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} -# run: (cd java && gradle sonarqube) diff --git a/.github/workflows/javascript.yaml b/.github/workflows/javascript.yaml index 4a5135aa93..9e38a85c1e 100644 --- a/.github/workflows/javascript.yaml +++ b/.github/workflows/javascript.yaml @@ -17,7 +17,7 @@ on: jobs: coverage: name: Test - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 diff --git a/.github/workflows/test_validate.yaml b/.github/workflows/test_validate.yaml index c0e513c852..15631c60a6 100644 --- a/.github/workflows/test_validate.yaml +++ b/.github/workflows/test_validate.yaml @@ -8,7 +8,7 @@ on: jobs: test_validation: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - name: Checkout Sources uses: actions/checkout@v4 diff --git a/.github/workflows/validate.yaml b/.github/workflows/validate.yaml index 0fa6ec9043..36476ae7d1 100644 --- a/.github/workflows/validate.yaml +++ b/.github/workflows/validate.yaml @@ -6,17 +6,17 @@ on: - "spec/**" push: branches: - - 'v*-release' - - 'starling-v*-release' - - 'libsbp-v*-release' + - "v*-release" + - "starling-v*-release" + - "libsbp-v*-release" tags: - - 'v*' + - "v*" paths: - "spec/**" jobs: validation: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - name: Checkout Current Spec uses: actions/checkout@v4 diff --git a/HOWTO.md b/HOWTO.md index 41d0687772..6a2cd3b39b 100644 --- a/HOWTO.md +++ b/HOWTO.md @@ -1,23 +1,26 @@ -libsbp Development Procedures -============================= +# libsbp Development Procedures -- [Adding and Testing New Messages](#adding-and-testing-new-messages) - * [Generating missing tests](#generating-missing-tests) -- [Message Guidelines](#message-guidelines) -- [Releasing New Versions of the Library](#releasing-new-versions-of-the-library) - * [Using Docker](#using-docker) - * [The Process](#the-process) -- [Installing QuickType](#installing-quicktype) -- [Distributing Rust](#distributing-rust) -- [Distributing Python](#distributing-python) - * [Troubleshooting](#troubleshooting) - + [Error: `!!! No Python wheel (.whl) file found...`](#error--no-python-wheel-whl-file-found) - + [Tox error: `ERROR: FAIL could not package project`](#tox-error-error-fail-could-not-package-project) - + [Tox error: `ERROR: cowardly refusing to delete envdir`](#tox-error-error-cowardly-refusing-to-delete-envdir) -- [Distributing Java](#distributing-java) -- [Contributions](#contributions) +- [libsbp Development Procedures](#libsbp-development-procedures) + - [Adding and Testing New Messages](#adding-and-testing-new-messages) + - [Generating missing tests](#generating-missing-tests) + - [Existing Messages](#existing-messages) + - [New Messages](#new-messages) + - [Message Guidelines](#message-guidelines) + - [Releasing New Versions of the Library](#releasing-new-versions-of-the-library) + - [Using Docker](#using-docker) + - [The Process](#the-process) + - [Installing QuickType](#installing-quicktype) + - [Distributing Rust](#distributing-rust) + - [Distributing Python](#distributing-python) + - [Troubleshooting](#troubleshooting) + - [Error: `!!! No Python wheel (.whl) file found...`](#error--no-python-wheel-whl-file-found) + - [Tox error: `ERROR: FAIL could not package project`](#tox-error-error-fail-could-not-package-project) + - [Tox error: `ERROR: cowardly refusing to delete envdir`](#tox-error-error-cowardly-refusing-to-delete-envdir) + - [Distributing Java](#distributing-java) + - [Generating GPG key for Java](#generating-gpg-key-for-java) + - [Contributions](#contributions) @@ -25,7 +28,7 @@ This document summarizes some practices around contributions to this library. These instructions don't come with a warranty yet, so please feel free to update it to mirror reality. -# Adding and Testing New Messages +## Adding and Testing New Messages Adding new SBP messages is currently a very organic, social process. This is likely to change in the future. @@ -41,8 +44,8 @@ process. This is likely to change in the future. by the corresponding number of new messages. 3. If adding a new "group" of messages (adding a new YAML file to - `spec/yaml/swiftnav/sbp`), add the new message group to - `python/sbp/table.py` and `javascript/sbp/msg.js`. + `spec/yaml/swiftnav/sbp`), add the new message group to + `python/sbp/table.py` and `javascript/sbp/msg.js`. 4. Generate new clients and documentation by running `make all`. Verify that the generated code, which isn't too complicated, @@ -66,14 +69,16 @@ process. This is likely to change in the future. new message, deploy the updated Python client first, and then the C client. We haven't quite decided on the details of this process. -## Generating missing tests +### Generating missing tests + There are some tools that can assist with generating YAML based tests, like the ones already defined in the [`test`](spec/tests/yaml/swiftnav/sbp) directory. These YAML files are used to generate tests in the various languages that libsbp supports, to ensure that serializing and deserializing messages works as intended -### Existing Messages +#### Existing Messages + For messages that are already being sent (eg: by Starling, or by a Piksi), the `generator/missing.py` script can be used to connect to a socket and automatically generate tests for any received messages that do not already have @@ -81,11 +86,12 @@ tests. Usage for `missing`: -```shell +```sh python missing.py --host [HOST] --port [PORT] ``` -### New Messages +#### New Messages + The `json2test` script can be used to automatically generate tests for newly defined messages. The json2test script uses [uv](https://docs.astral.sh/uv/) to manage its dependencies, which can be installed following the instructions on that @@ -106,7 +112,7 @@ form: And then generate a test for using `json2test` with: -```shell +```sh uv -n run json2test.py --input heartbeat.json --output ../spec/tests/yaml/swiftnav/sbp/system/test_MsgHeartbeat.yaml ``` @@ -118,14 +124,14 @@ caching is turned off. Usage for `json2test` -```shell +```sh uv -n run json2test --input [PATH_TO_JSON_IN] --output [PATH_TO_YAML_OUT] ``` -* The `msg_type` can also be provided through a CLI parameter, with `--msg-id +- The `msg_type` can also be provided through a CLI parameter, with `--msg-id [MESSAGE_ID]` -# Message Guidelines +## Message Guidelines Some thoughts to consider when adding a new message: @@ -156,23 +162,27 @@ Some thoughts to consider when adding a new message: contents is fine, as long as the migrating consumers is a well-understood process. -# Releasing New Versions of the Library +## Releasing New Versions of the Library -## Using Docker +### Using Docker It's highly recommended to use the docker container to run the release process, the docker container can be pulled from DockerHub and launched via this command: - docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 +```sh +docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 +``` You can invoke individual stages like so: - docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 \ - /bin/bash -c "make python" +```sh +docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 \ + /bin/bash -c "make python" +``` Check this [link](https://hub.docker.com/r/swiftnav/libsbp-build/tags) for newer tags. -## The Process +### The Process Oh boy, so you've decided to release a new version of libsbp. It's recommended this process is performed using the above docker container. You'll likely want @@ -181,27 +191,27 @@ inside the container (so you don't have to setup git inside the docker container This process describes running `make ` in multiple places. These targets will both regenerate the language bindings and then build and run any test suites. -Skipping tests should not be done by default, but most languages have a "gen" target -available - `make gen-` - which will only regenerate the bindings without +Skipping tests should not be done by default, but most languages have a "gen" target +available - `make gen-` - which will only regenerate the bindings without running tests. This can be used to split or speed up the process should any errors occur and something needs to be repeated. 1. It's easiest to do this on the master branch. Start by tagging the release version: - ```shell + ```sh # Produces most recent tag (e.g., v2.7.5) git describe --abbrev=0 --tags # Increment that value, create a new one (e.g, v2.7.6) git tag -a -m "Version of libsbp." ``` - For library versions (i.e. ``) we try to follow + For library versions (i.e. ``) we try to follow [SemVer](https://semver.org/). For message versioning refer to this [document on versioning](./VERSIONING.md). - + 2. Make sure that the repo is reported as clean, e.g. - ```shell + ```sh git describe --tags --dirty --always ``` @@ -210,7 +220,7 @@ and something needs to be repeated. 3. Run make targets for each language and re-tag. For python: - ```shell + ```sh make python git add python/sbp/RELEASE-VERSION git commit -m 'Release ' @@ -220,22 +230,22 @@ and something needs to be repeated. For Java, jsonschema, and Protobuf (these should not require bumping the git tag, unless the generated files are out of date): - ```shell + ```sh make java jsonschema protobuf ``` For C, Haskell and JavaScript (JavaScript, make needs to be run twice to update the package information): - ```shell + ```sh make c haskell javascript rust git add c/include/libsbp/version.h haskell/sbp.cabal rust/sbp/Cargo.toml git commit --amend -a -m 'Release ' git tag -f -a INCREMENTED_TAG -m "Version INCREMENTED_TAG of libsbp." ``` - For JavaScript, needs to be run twice to update the package information - ```shell + + ```sh make javascript make javascript git add javascript/sbp/RELEASE-VERSION package.json package-lock.json @@ -244,7 +254,7 @@ and something needs to be repeated. For Kaitai - ```shell + ```sh make kaitai git add kaitai/ksy/sbp.ksy git commit --amend -a -m 'Release ' @@ -252,17 +262,17 @@ and something needs to be repeated. 4. Build the docs: - ```shell + ```sh make docs ``` - + Be sure to inspect the [docs](docs/sbp.pdf) manually, as LaTeX sometimes needs to be run multiple - times to compile properly. If something looks off with the docs, run `make docs` repeatedly until + times to compile properly. If something looks off with the docs, run `make docs` repeatedly until the issue is fixed. Then commit the docs and re-tag: - ```shell + ```sh git add docs/sbp.pdf git commit --amend -a -m 'Release ' git tag -f -a INCREMENTED_TAG -m "Version INCREMENTED_TAG of libsbp." @@ -281,7 +291,8 @@ and something needs to be repeated. documentation are consistent. 7. Push the release to GitHub: - ```shell + + ```sh git push origin master ``` @@ -302,7 +313,7 @@ and something needs to be repeated. Again, javascript needs to be built twice to get the correct package versions - ``` + ```sh git commit --allow-empty -m "prep for next release #no_auto_pr" make all make javascript @@ -311,28 +322,28 @@ and something needs to be repeated. git push origin master ``` -9. Distribute release packages. You can attempt to run all releases - with `make dist` -- this will likely not work through... it is - advisable to run each dist target separately. In particular: +10. Distribute release packages. You can attempt to run all releases + with `make dist` -- this will likely not work through... it is + advisable to run each dist target separately. In particular: - - `make dist-javascript` - - `make dist-haskell` - - `make dist-rust` (see section on Rust below) - - `make dist-python` (see section on Python below) - - `make dist-java` (see section on Java below) + - `make dist-javascript` + - `make dist-haskell` + - `make dist-rust` (see section on Rust below) + - `make dist-python` (see section on Python below) + - `make dist-java` (see section on Java below) - You may need credentials on the appropriate package repositories. Ignore the - GPG error in `stack`, the package will get uploaded correctly anyway. If - the release is a Python only change it may be appropriate to just publish to - PyPI with `make dist-python` (see section on Python below) -- we typically - update all other supported languages when we make an official firmware - release. + You may need credentials on the appropriate package repositories. Ignore the + GPG error in `stack`, the package will get uploaded correctly anyway. If + the release is a Python only change it may be appropriate to just publish to + PyPI with `make dist-python` (see section on Python below) -- we typically + update all other supported languages when we make an official firmware + release. -10. Releases are not only never perfect, they never really end. Please +11. Releases are not only never perfect, they never really end. Please pay special attention to any downstream projects or users that may have issues or regressions as a consequence of the release version. -# Installing QuickType +## Installing QuickType For web clients we generate JSON schema definitions of the SBP message. This allows web clients to build "native" objects out of SBP JSON. @@ -343,36 +354,36 @@ In order to run the `make quicktype-*` target you need to install the quicktype tool first. No particular version of this tool is required at the moment. -# Distributing Rust +## Distributing Rust To distribute Rust. Use the `cargo-release` tool: -``` +```sh cargo install cargo-release ``` Once you have logged in to crates.io with `cargo`: -```shell +```sh cargo release --allow-branch HEAD --execute ``` Then rollback any commits that are created: -``` +```sh git reset --hard v ``` -# Distributing Python +## Distributing Python The build of the libsbp wheel can be done via the `libsbp-build` container described above. You must have the correct token set in your environment to publish to PyPI. -## Troubleshooting +### Troubleshooting -### Error: `!!! No Python wheel (.whl) file found...` +#### Error: `!!! No Python wheel (.whl) file found...` This usually means the git checkout you're building from is not in a "clean" state. The build scripts will use the git command `git describe --tag --always --dirty` to generate @@ -380,47 +391,55 @@ a version. Either temporarily force update the tag with `git tag -f vM.N.X` (do push this unintentionally) and/or make sure you're submodule are up-to-date with `git submodule update --init --checkout --recursive`. -### Tox error: `ERROR: FAIL could not package project` +#### Tox error: `ERROR: FAIL could not package project` Tox needs to be run with the Python it was installed with (and apparently must run with Python 2) otherwise you'll get an error similar to: +```sh ERROR: FAIL could not package project - v = InvocationError('/home/ubuntu/dev/libsbp/python/.tox/.tox/bin/python setup.py sdist --formats=zip --dist-dir /home/ubuntu/dev/libsbp/python/.tox/dist', -11) +``` Tox also seems to have issues interacting with conda environments. The easiest way to work around this is to remove conda from your path and make sure tox is installed with a Python2 version of the interpreter. -### Tox error: `ERROR: cowardly refusing to delete envdir` +#### Tox error: `ERROR: cowardly refusing to delete envdir` Tox may fail with the following error: +```sh ERROR: cowardly refusing to delete `envdir` (it does not look like a virtualenv): /home/ubuntu/dev/libsbp/python/.tox/py38-nojit +``` -There's an open tox issue for this: https://github.com/tox-dev/tox/issues/1354 +There's an open tox issue for this: -- the only workaround that resolved this was to downgrade tox: +```sh pip install --upgrade --force-reinstall tox==3.12.1 +``` -# Distributing Java +## Distributing Java To distribute java, ensure you have the correct credentials and prerequisites + - Gradle 7+ - gradle.properties - Sonatype deployer account - Your own GPG key -## Generating GPG key for Java +### Generating GPG key for Java SonaType open source repo requires a GPG key for signatures. Generate GPG key via: -```shell +```sh gpg --gen-key gpg --export-secret-keys >keys.gpg ``` Export your public key -``` + +```sh gpg --export -a > pub.key ``` @@ -428,7 +447,7 @@ Go to [https://keyserver.ubuntu.com/#submitKey](https://keyserver.ubuntu.com/#su To locate the value for `signing.keyId` (needed below) run: -```shell +```sh ❯ gpg --list-keys --keyid-format short (base) /home/ubuntu/.gnupg/pubring.kbx ------------------------------- @@ -442,8 +461,7 @@ The `signing.keyId` value to use from above is `BB59B113`. The `/keys` folder to should map to location where your gpg key will be stored. Then, create `gradle.properties` in the `java` directory as follows: - -```shell +```sh # last 8 digit of gpg key signing.keyId=xxx # password for gpg key @@ -466,7 +484,7 @@ For more info see: -- [Installing sbp2json, json2sbp, json2json and related tools](#installing-sbp2json-json2sbp-json2json-and-related-tools) -- [Building / installing](#building--installing) - * [Using Docker](#using-docker) - + [Fetching the prebuilt image from DockerHub](#fetching-the-prebuilt-image-from-dockerhub) - + [Creating your own image](#creating-your-own-image) - + [Using the docker image](#using-the-docker-image) - * [Installing from package managers](#installing-from-package-managers) - * [Installing development Python versions](#installing-development-python-versions) - * [Adding development version as a pip dependency](#adding-development-version-as-a-pip-dependency) - * [Installing from source](#installing-from-source) -- [SBP Development Procedures](#sbp-development-procedures) -- [SBP Protocol Specification](#sbp-protocol-specification) -- [JSON Schema Definitions](#json-schema-definitions) -- [Kaitai Struct Format Descriptions](#kaitai-struct-format-descriptions) -- [LICENSE](#license) +- [Specification and Bindings for Swift Binary Protocol](#specification-and-bindings-for-swift-binary-protocol) + - [Installing sbp2json, json2sbp, json2json and related tools](#installing-sbp2json-json2sbp-json2json-and-related-tools) + - [Building / installing](#building--installing) + - [Using Docker](#using-docker) + - [Fetching the prebuilt image from DockerHub](#fetching-the-prebuilt-image-from-dockerhub) + - [Creating your own image](#creating-your-own-image) + - [Using the docker image](#using-the-docker-image) + - [Installing from package managers](#installing-from-package-managers) + - [Installing development Python versions](#installing-development-python-versions) + - [Adding development version as a pip dependency](#adding-development-version-as-a-pip-dependency) + - [Installing from source](#installing-from-source) + - [SBP Development Procedures](#sbp-development-procedures) + - [SBP Protocol Specification](#sbp-protocol-specification) + - [JSON Schema Definitions](#json-schema-definitions) + - [Kaitai Struct Format Descriptions](#kaitai-struct-format-descriptions) + - [Notes on python bindings](#notes-on-python-bindings) + - [LICENSE](#license) @@ -32,19 +34,19 @@ messages used with SBP, a compiler for generating message bindings, and client libraries in a variety of languages. This repository is organized into the following directory structure: -* [`docs`](./docs): Protocol documentation and message definitions. -* [`spec`](./spec): Machine readable protocol specification in +- [`docs`](./docs): Protocol documentation and message definitions. +- [`spec`](./spec): Machine readable protocol specification in [YAML](http://en.wikipedia.org/wiki/YAML). -* [`generator`](./generator): Simple, template-based generator for +- [`generator`](./generator): Simple, template-based generator for different languages. -* [`python`](./python): Python client and examples. -* [`c`](./c): C client library and examples. -* [`haskell`](./haskell): Haskell client and examples. -* [`java`](./java): Java client library and examples. -* [`javascript`](./javascript): JavaScript client library and examples. -* [`rust`](./rust): Rust client library and examples. -* [`sbpjson`](./sbpjson): Tools for parsing SBP-JSON. -* [`kaitai`](./kaitai): Kaitai Struct Format Description and generated code. +- [`python`](./python): Python client and examples. +- [`c`](./c): C client library and examples. +- [`haskell`](./haskell): Haskell client and examples. +- [`java`](./java): Java client library and examples. +- [`javascript`](./javascript): JavaScript client library and examples. +- [`rust`](./rust): Rust client library and examples. +- [`sbpjson`](./sbpjson): Tools for parsing SBP-JSON. +- [`kaitai`](./kaitai): Kaitai Struct Format Description and generated code. Except for the `generator`, all of the above are generated and should not be modified directly. @@ -72,7 +74,7 @@ your platform. To install from source, you can use Rust's cargo tool (first [install Rust](https://www.rust-lang.org/tools/install)), then run: -``` +```sh cargo install --git https://github.com/swift-nav/libsbp.git --bins ``` @@ -87,13 +89,13 @@ tool as well as a `sbp2prettyjson` tool. Finally, a Python version of the `sbp2json` tool exists, which is installable on any platform that supports Python via pip, e.g.: -``` +```sh pip3 install sbp ``` The tool can then be invoked as follows: -``` +```sh python3 -m sbp2json #egg=sbp&subdirectory=python" ``` Or add this to `requirements.txt`: -``` + +```sh git+https://github.com/swift-nav/libsbp@#egg=sbp&subdirectory=python ``` ### Installing from source + You can build one binding at a time or update all at once: -``` +```sh make python ``` or -``` +```sh make all ``` are both valid. To see a list of all valid targets, run `make help`. **Python version notes:** + 1. By default the Python targets `make python` and `make test-python` (as well as `make all`) run tests on all Python versions officially supported by *the libsbp Python bindings*, currently **3.6-3.9**, skipping any versions not @@ -256,7 +279,7 @@ detection. Please see [the docs](docs/sbp.pdf) for a full description of the packet structure and the message types. Developer documentation for the -language-specific sbp libraries is [here](http://swift-nav.github.io/libsbp/). +language-specific sbp libraries is available at [http://swift-nav.github.io/libsbp/](http://swift-nav.github.io/libsbp/). Please refer to [the changelog](CHANGELOG.md) for more information about the evolution of the library and its messages. @@ -281,19 +304,19 @@ respectively. The Kaitai Struct format description files can also potentially be used to generate bindings for the following targets: -* graphviz -* csharp -* rust -* java -* go -* cpp_stl -* php -* lua -* nim -* html -* ruby -* construct -* javascript +- graphviz +- csharp +- rust +- java +- go +- cpp_stl +- php +- lua +- nim +- html +- ruby +- construct +- javascript ### Notes on python bindings diff --git a/spec/yaml/swiftnav/sbp/integrity.yaml b/spec/yaml/swiftnav/sbp/integrity.yaml index 3513885bd5..6777bcb8bd 100644 --- a/spec/yaml/swiftnav/sbp/integrity.yaml +++ b/spec/yaml/swiftnav/sbp/integrity.yaml @@ -41,8 +41,128 @@ definitions: type: u8 desc: Chain and type of flag. - - MSG_SSR_FLAG_HIGH_LEVEL: + - MSG_SSR_FLAG_HIGH_LEVEL_DEP_A: id: 0x0BB9 + short_desc: Deprecated + desc: Deprecated. + public: false + replaced_by: + - MSG_SSR_FLAG_HIGH_LEVEL + fields: + - obs_time: + type: GPSTimeSec + desc: GNSS reference time of the observation used to generate the flag. + - corr_time: + type: GPSTimeSec + desc: GNSS reference time of the correction associated to the flag. + - ssr_sol_id: + type: u8 + desc: SSR Solution ID. + - tile_set_id: + type: u16 + desc: Unique identifier of the set this tile belongs to. + - tile_id: + type: u16 + desc: Unique identifier of this tile in the tile set. + - chain_id: + type: u8 + desc: Chain and type of flag. + - use_gps_sat: + type: u8 + desc: Use GPS satellites. + fields: + - 0-2: + desc: Use GPS satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_gal_sat: + type: u8 + desc: Use GAL satellites. + fields: + - 0-2: + desc: Use GAL satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_bds_sat: + type: u8 + desc: Use BDS satellites. + fields: + - 0-2: + desc: Use BDS satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_qzss_sat: + type: u8 + desc: Use QZSS satellites. + fields: + - 0-2: + desc: Use QZSS satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - reserved: + type: array + size: 5 + fill: u8 + desc: Reserved + - use_tropo_grid_points: + type: u8 + desc: Use tropo grid points. + fields: + - 0-2: + desc: Use tropo grid points. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_iono_grid_points: + type: u8 + desc: Use iono grid points. + fields: + - 0-2: + desc: Use iono grid points. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_iono_tile_sat_los: + type: u8 + desc: Use iono tile satellite LoS. + fields: + - 0-2: + desc: Use iono tile satellite LoS. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_iono_grid_point_sat_los: + type: u8 + desc: Use iono grid point satellite LoS. + fields: + - 0-2: + desc: Use iono grid point satellite LoS. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + + - MSG_SSR_FLAG_HIGH_LEVEL: + id: 0x0BBA short_desc: High level integrity flags desc: > Integrity monitoring flags for multiple aggregated elements. @@ -82,9 +202,12 @@ definitions: - obs_time: type: GPSTimeSec desc: GNSS reference time of the observation used to generate the flag. - - corr_time: + - iono_corr_time: type: GPSTimeSec - desc: GNSS reference time of the correction associated to the flag. + desc: GNSS reference time of the ionospheric correction associated to the flag. + - sat_corr_time: + type: GPSTimeSec + desc: GNSS reference time of the satellite correction associated to the flag. - ssr_sol_id: type: u8 desc: SSR Solution ID. From aa8284808baa4a4d487ea1f8255409b8790f0ea3 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 10:50:10 +0200 Subject: [PATCH 02/11] Add test --- python/tests/sbp/test_table.py | 150 ++++++++++++++++++--------------- 1 file changed, 80 insertions(+), 70 deletions(-) diff --git a/python/tests/sbp/test_table.py b/python/tests/sbp/test_table.py index 23f36a99da..b80d891031 100644 --- a/python/tests/sbp/test_table.py +++ b/python/tests/sbp/test_table.py @@ -8,95 +8,105 @@ # EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. -from sbp.msg import SBP -from sbp.table import _SBP_TABLE, dispatch +import warnings + from sbp import acquisition as acq from sbp import bootload as boot +from sbp import ext_events as ext_events from sbp import file_io as file_io from sbp import flash as flash +from sbp import imu as imu +from sbp import integrity as integrity from sbp import linux as linux from sbp import logging as log +from sbp import mag as mag from sbp import navigation as nav +from sbp import ndb as ndb from sbp import observation as obs +from sbp import orientation as orientation from sbp import piksi as piksi +from sbp import profiling as profiling +from sbp import sbas as sbas from sbp import settings as settings +from sbp import signing as signing +from sbp import solution_meta as solmeta +from sbp import ssr as ssr from sbp import system as sys +from sbp import telemetry as telemetry from sbp import tracking as trac from sbp import user as user -from sbp import imu as imu -from sbp import integrity as integrity -from sbp import ext_events as ext_events -from sbp import ndb as ndb -from sbp import mag as mag from sbp import vehicle as vehicle -from sbp import orientation as orientation -from sbp import sbas as sbas -from sbp import ssr as ssr -from sbp import solution_meta as solmeta -from sbp import signing as signing -from sbp import telemetry as telemetry -from sbp import profiling as profiling +from sbp.msg import SBP +from sbp.table import _SBP_TABLE, dispatch -import warnings def test_table_count(): - """ - Test number of available messages to deserialize. + """ + Test number of available messages to deserialize. + + """ + number_of_messages = 240 + assert len(_SBP_TABLE) == number_of_messages + - """ - number_of_messages = 239 - assert len(_SBP_TABLE) == number_of_messages +def test_table_unique_count(): + """ + Test number of messages in packages equals total number of messages. + """ + number_of_messages = ( + len(acq.msg_classes) + + len(boot.msg_classes) + + len(file_io.msg_classes) + + len(flash.msg_classes) + + len(linux.msg_classes) + + len(log.msg_classes) + + len(nav.msg_classes) + + len(obs.msg_classes) + + len(piksi.msg_classes) + + len(settings.msg_classes) + + len(sys.msg_classes) + + len(trac.msg_classes) + + len(user.msg_classes) + + len(imu.msg_classes) + + len(integrity.msg_classes) + + len(ext_events.msg_classes) + + len(ndb.msg_classes) + + len(mag.msg_classes) + + len(vehicle.msg_classes) + + len(orientation.msg_classes) + + len(sbas.msg_classes) + + len(ssr.msg_classes) + + len(solmeta.msg_classes) + + len(signing.msg_classes) + + len(telemetry.msg_classes) + + len(profiling.msg_classes) + ) + assert len(_SBP_TABLE) == number_of_messages -def test_table_unqiue_count(): - """ - Test number of messages in packages equals total number of messages. - """ - number_of_messages = (len(acq.msg_classes) - + len(boot.msg_classes) - + len(file_io.msg_classes) - + len(flash.msg_classes) - + len(linux.msg_classes) - + len(log.msg_classes) - + len(nav.msg_classes) - + len(obs.msg_classes) - + len(piksi.msg_classes) - + len(settings.msg_classes) - + len(sys.msg_classes) - + len(trac.msg_classes) - + len(user.msg_classes) - + len(imu.msg_classes) - + len(integrity.msg_classes) - + len(ext_events.msg_classes) - + len(ndb.msg_classes) - + len(mag.msg_classes) - + len(vehicle.msg_classes) - + len(orientation.msg_classes) - + len(sbas.msg_classes) - + len(ssr.msg_classes) - + len(solmeta.msg_classes) - + len(signing.msg_classes) - + len(telemetry.msg_classes) - + len(profiling.msg_classes) - ) - assert len(_SBP_TABLE) == number_of_messages def test_available_messages(): - """ - Simple example with a limited dispatch table. + """ + Simple example with a limited dispatch table. - """ - table = {acq.SBP_MSG_ACQ_RESULT_DEP_A: acq.MsgAcqResultDepA, - log.SBP_MSG_PRINT_DEP: log.MsgPrintDep} - msg = SBP(msg_type=0x15, sender=1219, length=13, - payload=b'\x92$yA\x00\x00\xbcC\x81\xc1\xf9\xc5\x1d') - # TODO (Buro): Replace this message constructor once generated SBP - # can support kwargs for constructor, instead of requiring SBP - # object. - assert dispatch(msg, table) == acq.MsgAcqResultDepA(msg) - msg = SBP(msg_type=0xB0, sender=1219, length=4, payload='v1.2', crc=0xCE01) - with warnings.catch_warnings(record=True) as w: - dispatch(msg, table) - warnings.simplefilter("always") - assert len(w) == 1 - assert issubclass(w[0].category, RuntimeWarning) - assert str(w[0].message).find("No message found for msg_type id 176 for msg*") + """ + table = { + acq.SBP_MSG_ACQ_RESULT_DEP_A: acq.MsgAcqResultDepA, + log.SBP_MSG_PRINT_DEP: log.MsgPrintDep, + } + msg = SBP( + msg_type=0x15, + sender=1219, + length=13, + payload=b"\x92$yA\x00\x00\xbcC\x81\xc1\xf9\xc5\x1d", + ) + # TODO (Buro): Replace this message constructor once generated SBP + # can support kwargs for constructor, instead of requiring SBP + # object. + assert dispatch(msg, table) == acq.MsgAcqResultDepA(msg) + msg = SBP(msg_type=0xB0, sender=1219, length=4, payload="v1.2", crc=0xCE01) + with warnings.catch_warnings(record=True) as w: + dispatch(msg, table) + warnings.simplefilter("always") + assert len(w) == 1 + assert issubclass(w[0].category, RuntimeWarning) + assert str(w[0].message).find("No message found for msg_type id 176 for msg*") From 2f73368415e33ce50c6f1f18e9623773b1653c39 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 11:06:22 +0200 Subject: [PATCH 03/11] Add new message --- c/include/libsbp/cpp/message_traits.h | 38 + c/include/libsbp/integrity.h | 1 + .../integrity/MSG_SSR_FLAG_HIGH_LEVEL.h | 9 +- .../integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h | 254 +++++ c/include/libsbp/integrity_macros.h | 189 +++- c/include/libsbp/sbp_msg.h | 13 + c/include/libsbp/sbp_msg_type.h | 5 +- c/src/include/libsbp/internal/integrity.h | 20 + c/src/integrity.c | 252 ++++- ..._check_sbp_integrity_MsgSsrFlagHighLevel.c | 48 +- ...ck_sbp_integrity_MsgSsrFlagHighLevelDepA.c | 313 ++++++ c/test/check_main.c | 2 + c/test/check_suites.h | 1 + ...check_sbp_integrity_MsgSsrFlagHighLevel.cc | 69 +- ...k_sbp_integrity_MsgSsrFlagHighLevelDepA.cc | 962 ++++++++++++++++++ docs/sbp.pdf | Bin 567691 -> 567908 bytes haskell/src/SwiftNav/SBP/Integrity.hs | 96 +- haskell/src/SwiftNav/SBP/Msg.hs | 6 + .../com/swiftnav/sbp/client/MessageTable.java | 3 + .../sbp/integrity/MsgSsrFlagHighLevel.java | 22 +- .../integrity/MsgSsrFlagHighLevelDepA.java | 158 +++ ...integrity_MsgSsrFlagHighLevelDepATest.java | 285 ++++++ ...sbp_integrity_MsgSsrFlagHighLevelTest.java | 40 +- javascript/sbp.bundle.js | 2 +- javascript/sbp/integrity.js | 86 +- jsonschema/MsgSsrFlagHighLevel.json | 6 +- kaitai/ksy/integrity.ksy | 77 +- kaitai/ksy/sbp.ksy | 6 +- kaitai/perl/KaitaiSbp/Integrity.pm | 134 ++- kaitai/perl/KaitaiSbp/Sbp.pm | 10 +- kaitai/perl/KaitaiSbp/Table.pm | 3 +- ..._check_sbp_integrity_MsgSsrFlagHighLevel.t | 16 +- ...ck_sbp_integrity_MsgSsrFlagHighLevelDepA.t | 84 ++ kaitai/python/kaitai_sbp/integrity.py | 33 +- kaitai/python/kaitai_sbp/sbp.py | 9 +- kaitai/python/kaitai_sbp/table.py | 3 +- ...check_sbp_integrity_MsgSsrFlagHighLevel.py | 16 +- ...k_sbp_integrity_MsgSsrFlagHighLevelDepA.py | 69 ++ proto/integrity.proto | 27 +- python/sbp/integrity.py | 187 +++- rust/sbp/src/messages/integrity.rs | 674 +++++++++++- rust/sbp/src/messages/mod.rs | 29 + ...k_sbp_integrity_msg_ssr_flag_high_level.rs | 88 +- ...integrity_msg_ssr_flag_high_level_dep_a.rs | 481 +++++++++ rust/sbp/tests/integration/main.rs | 1 + sbpjson/elm/SbpJson.elm | 9 +- sbpjson/javascript/SbpJson.js | 3 +- sbpjson/typescript/SbpJson.ts | 6 +- .../integrity/test_MsgSsrFlagHighLevel.yaml | 89 +- .../test_MsgSsrFlagHighLevelDepA.yaml | 46 + 50 files changed, 4769 insertions(+), 211 deletions(-) create mode 100644 c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java create mode 100644 kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t create mode 100644 kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml diff --git a/c/include/libsbp/cpp/message_traits.h b/c/include/libsbp/cpp/message_traits.h index 85a3d2d97b..7dbfc9f9ce 100644 --- a/c/include/libsbp/cpp/message_traits.h +++ b/c/include/libsbp/cpp/message_traits.h @@ -6438,6 +6438,44 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagHighLevelDepA; + static constexpr const char *name = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; + static const sbp_msg_ssr_flag_high_level_dep_a_t &get(const sbp_msg_t &msg) { + return msg.ssr_flag_high_level_dep_a; + } + static sbp_msg_ssr_flag_high_level_dep_a_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_high_level_dep_a; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_high_level_dep_a_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_high_level_dep_a = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_flag_high_level_dep_a_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_high_level_dep_a = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_high_level_dep_a_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_dep_a_t &msg) { + return sbp_msg_ssr_flag_high_level_dep_a_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + return sbp_msg_ssr_flag_high_level_dep_a_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_flag_high_level_dep_a_t &msg) { + return sbp_msg_ssr_flag_high_level_dep_a_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgSsrFlagHighLevel; diff --git a/c/include/libsbp/integrity.h b/c/include/libsbp/integrity.h index 2d2ff792e7..8ab8a8be95 100644 --- a/c/include/libsbp/integrity.h +++ b/c/include/libsbp/integrity.h @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include diff --git a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h index a11c0aeffb..b880a2e20b 100644 --- a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h +++ b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h @@ -72,9 +72,14 @@ typedef struct { sbp_gps_time_sec_t obs_time; /** - * GNSS reference time of the correction associated to the flag. + * GNSS reference time of the ionospheric correction associated to the flag. */ - sbp_gps_time_sec_t corr_time; + sbp_gps_time_sec_t iono_corr_time; + + /** + * GNSS reference time of the satellite correction associated to the flag. + */ + sbp_gps_time_sec_t sat_corr_time; /** * SSR Solution ID. diff --git a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h new file mode 100644 index 0000000000..455fd31f88 --- /dev/null +++ b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_H +#define LIBSBP_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A + * + *****************************************************************************/ +/** Deprecated + * + * Deprecated. + */ +typedef struct { + /** + * GNSS reference time of the observation used to generate the flag. + */ + sbp_gps_time_sec_t obs_time; + + /** + * GNSS reference time of the correction associated to the flag. + */ + sbp_gps_time_sec_t corr_time; + + /** + * SSR Solution ID. + */ + u8 ssr_sol_id; + + /** + * Unique identifier of the set this tile belongs to. + */ + u16 tile_set_id; + + /** + * Unique identifier of this tile in the tile set. + */ + u16 tile_id; + + /** + * Chain and type of flag. + */ + u8 chain_id; + + /** + * Use GPS satellites. + */ + u8 use_gps_sat; + + /** + * Use GAL satellites. + */ + u8 use_gal_sat; + + /** + * Use BDS satellites. + */ + u8 use_bds_sat; + + /** + * Use QZSS satellites. + */ + u8 use_qzss_sat; + + /** + * Reserved + */ + u8 reserved[SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX]; + + /** + * Use tropo grid points. + */ + u8 use_tropo_grid_points; + + /** + * Use iono grid points. + */ + u8 use_iono_grid_points; + + /** + * Use iono tile satellite LoS. + */ + u8 use_iono_tile_sat_los; + + /** + * Use iono grid point satellite LoS. + */ + u8 use_iono_grid_point_sat_los; +} sbp_msg_ssr_flag_high_level_dep_a_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_high_level_dep_a_t + * + * @param msg sbp_msg_ssr_flag_high_level_dep_a_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_high_level_dep_a_encoded_len( + const sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + (void)msg; + return SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_ENCODED_LEN; +} + +/** + * Encode an instance of sbp_msg_ssr_flag_high_level_dep_a_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_high_level_dep_a_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_dep_a_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_high_level_dep_a_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_high_level_dep_a_t message to the given instance. The caller + * must specify the length of the buffer in the \p len parameter. If non-null + * the number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_flag_high_level_dep_a_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_dep_a_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_dep_a_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_high_level_dep_a_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_high_level_dep_a_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_dep_a_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg, sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_high_level_dep_a_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_high_level_dep_a_t instance + * @param b sbp_msg_ssr_flag_high_level_dep_a_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_high_level_dep_a_cmp( + const sbp_msg_ssr_flag_high_level_dep_a_t *a, + const sbp_msg_ssr_flag_high_level_dep_a_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_H */ diff --git a/c/include/libsbp/integrity_macros.h b/c/include/libsbp/integrity_macros.h index e565900f08..83f3df97f1 100644 --- a/c/include/libsbp/integrity_macros.h +++ b/c/include/libsbp/integrity_macros.h @@ -23,6 +23,193 @@ */ #define SBP_INTEGRITY_SSR_HEADER_ENCODED_LEN 14u +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_NOT_MONITORED (3) +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_high_level_dep_a_t::reserved before the maximum SBP message + * size is exceeded + */ +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX 5u + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_GET(flags) \ + ((u8)( \ + (u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT))) | \ + (((val) & \ + (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_NOT_MONITORED \ + (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK \ + (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT \ + (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT))) | \ + (((val) & \ + (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_NOMINAL \ + (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_WARNING \ + (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_ALERT \ + (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_NOT_MONITORED \ + (3) +/** + * Encoded length of sbp_msg_ssr_flag_high_level_dep_a_t + */ +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_ENCODED_LEN 31u + #define SBP_SSR_FLAG_HIGH_LEVEL_USE_GPS_SATELLITES_MASK (0x7u) #define SBP_SSR_FLAG_HIGH_LEVEL_USE_GPS_SATELLITES_SHIFT (0u) #define SBP_SSR_FLAG_HIGH_LEVEL_USE_GPS_SATELLITES_GET(flags) \ @@ -186,7 +373,7 @@ /** * Encoded length of sbp_msg_ssr_flag_high_level_t */ -#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_ENCODED_LEN 31u +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_ENCODED_LEN 37u /** * The maximum number of items that can be stored in diff --git a/c/include/libsbp/sbp_msg.h b/c/include/libsbp/sbp_msg.h index 754aeb8e79..16b29dcf84 100644 --- a/c/include/libsbp/sbp_msg.h +++ b/c/include/libsbp/sbp_msg.h @@ -237,6 +237,7 @@ typedef union { sbp_msg_specan_t specan; sbp_msg_ssr_code_biases_t ssr_code_biases; sbp_msg_ssr_code_phase_biases_bounds_t ssr_code_phase_biases_bounds; + sbp_msg_ssr_flag_high_level_dep_a_t ssr_flag_high_level_dep_a; sbp_msg_ssr_flag_high_level_t ssr_flag_high_level; sbp_msg_ssr_flag_iono_grid_point_sat_los_t ssr_flag_iono_grid_point_sat_los; sbp_msg_ssr_flag_iono_grid_points_t ssr_flag_iono_grid_points; @@ -800,6 +801,9 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_encode( buf, len, n_written, &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_encode( + buf, len, n_written, &msg->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_encode(buf, len, n_written, &msg->ssr_flag_high_level); @@ -1469,6 +1473,9 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_decode( buf, len, n_read, &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_decode( + buf, len, n_read, &msg->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_decode(buf, len, n_read, &msg->ssr_flag_high_level); @@ -2045,6 +2052,9 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_encoded_len( &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_encoded_len( + &msg->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_encoded_len(&msg->ssr_flag_high_level); case SbpMsgSsrFlagIonoGridPointSatLos: @@ -2659,6 +2669,9 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_cmp( &a->ssr_code_phase_biases_bounds, &b->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_cmp( + &a->ssr_flag_high_level_dep_a, &b->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_cmp(&a->ssr_flag_high_level, &b->ssr_flag_high_level); diff --git a/c/include/libsbp/sbp_msg_type.h b/c/include/libsbp/sbp_msg_type.h index a098bfc013..7e6a7ffe67 100644 --- a/c/include/libsbp/sbp_msg_type.h +++ b/c/include/libsbp/sbp_msg_type.h @@ -228,7 +228,8 @@ typedef enum { SbpMsgSpecan = 0x0051, SbpMsgSsrCodeBiases = 0x05E1, SbpMsgSsrCodePhaseBiasesBounds = 0x05EC, - SbpMsgSsrFlagHighLevel = 0x0BB9, + SbpMsgSsrFlagHighLevelDepA = 0x0BB9, + SbpMsgSsrFlagHighLevel = 0x0BBA, SbpMsgSsrFlagIonoGridPointSatLos = 0x0BD1, SbpMsgSsrFlagIonoGridPoints = 0x0BC7, SbpMsgSsrFlagIonoTileSatLos = 0x0BCD, @@ -650,6 +651,8 @@ static inline const char *sbp_msg_type_to_string(sbp_msg_type_t msg_type) { return "MSG_SSR_CODE_BIASES"; case SbpMsgSsrCodePhaseBiasesBounds: return "MSG_SSR_CODE_PHASE_BIASES_BOUNDS"; + case SbpMsgSsrFlagHighLevelDepA: + return "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; case SbpMsgSsrFlagHighLevel: return "MSG_SSR_FLAG_HIGH_LEVEL"; case SbpMsgSsrFlagIonoGridPointSatLos: diff --git a/c/src/include/libsbp/internal/integrity.h b/c/src/include/libsbp/internal/integrity.h index 470067bd0d..c1f4c01cfe 100644 --- a/c/src/include/libsbp/internal/integrity.h +++ b/c/src/include/libsbp/internal/integrity.h @@ -48,6 +48,26 @@ bool sbp_integrity_ssr_header_encode_internal( bool sbp_integrity_ssr_header_decode_internal(sbp_decode_ctx_t *ctx, sbp_integrity_ssr_header_t *msg); +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_high_level_dep_a_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_dep_a_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_high_level_dep_a_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_high_level_dep_a_t *msg); + /** * Internal function to encode an SBP type to a buffer * diff --git a/c/src/integrity.c b/c/src/integrity.c index 290ee862dd..fa0bac3ce1 100644 --- a/c/src/integrity.c +++ b/c/src/integrity.c @@ -139,12 +139,250 @@ int sbp_integrity_ssr_header_cmp(const sbp_integrity_ssr_header_t *a, return ret; } +bool sbp_msg_ssr_flag_high_level_dep_a_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->obs_time)) { + return false; + } + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->corr_time)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->ssr_sol_id)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->tile_set_id)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->tile_id)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->chain_id)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_gps_sat)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_gal_sat)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_bds_sat)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_qzss_sat)) { + return false; + } + for (size_t i = 0; i < SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX; i++) { + if (!sbp_u8_encode(ctx, &msg->reserved[i])) { + return false; + } + } + if (!sbp_u8_encode(ctx, &msg->use_tropo_grid_points)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_iono_grid_points)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_iono_tile_sat_los)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_iono_grid_point_sat_los)) { + return false; + } + return true; +} + +s8 sbp_msg_ssr_flag_high_level_dep_a_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_high_level_dep_a_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_high_level_dep_a_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->obs_time)) { + return false; + } + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->corr_time)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->ssr_sol_id)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->tile_set_id)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->tile_id)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->chain_id)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_gps_sat)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_gal_sat)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_bds_sat)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_qzss_sat)) { + return false; + } + for (uint8_t i = 0; i < SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX; i++) { + if (!sbp_u8_decode(ctx, &msg->reserved[i])) { + return false; + } + } + if (!sbp_u8_decode(ctx, &msg->use_tropo_grid_points)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_iono_grid_points)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_iono_tile_sat_los)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_iono_grid_point_sat_los)) { + return false; + } + return true; +} + +s8 sbp_msg_ssr_flag_high_level_dep_a_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_high_level_dep_a_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_high_level_dep_a_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg, sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_high_level_dep_a_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_internal_forward_payload(s, SbpMsgSsrFlagHighLevelDepA, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_flag_high_level_dep_a_cmp( + const sbp_msg_ssr_flag_high_level_dep_a_t *a, + const sbp_msg_ssr_flag_high_level_dep_a_t *b) { + int ret = 0; + + ret = sbp_gps_time_sec_cmp(&a->obs_time, &b->obs_time); + if (ret != 0) { + return ret; + } + + ret = sbp_gps_time_sec_cmp(&a->corr_time, &b->corr_time); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->ssr_sol_id, &b->ssr_sol_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->tile_set_id, &b->tile_set_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->tile_id, &b->tile_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->chain_id, &b->chain_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_gps_sat, &b->use_gps_sat); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_gal_sat, &b->use_gal_sat); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_bds_sat, &b->use_bds_sat); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_qzss_sat, &b->use_qzss_sat); + if (ret != 0) { + return ret; + } + + for (uint8_t i = 0; i < SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX; i++) { + ret = sbp_u8_cmp(&a->reserved[i], &b->reserved[i]); + if (ret != 0) { + return ret; + } + } + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_tropo_grid_points, &b->use_tropo_grid_points); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_iono_grid_points, &b->use_iono_grid_points); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_iono_tile_sat_los, &b->use_iono_tile_sat_los); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_iono_grid_point_sat_los, + &b->use_iono_grid_point_sat_los); + return ret; +} + bool sbp_msg_ssr_flag_high_level_encode_internal( sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_t *msg) { if (!sbp_gps_time_sec_encode_internal(ctx, &msg->obs_time)) { return false; } - if (!sbp_gps_time_sec_encode_internal(ctx, &msg->corr_time)) { + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->iono_corr_time)) { + return false; + } + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->sat_corr_time)) { return false; } if (!sbp_u8_encode(ctx, &msg->ssr_sol_id)) { @@ -212,7 +450,10 @@ bool sbp_msg_ssr_flag_high_level_decode_internal( if (!sbp_gps_time_sec_decode_internal(ctx, &msg->obs_time)) { return false; } - if (!sbp_gps_time_sec_decode_internal(ctx, &msg->corr_time)) { + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->iono_corr_time)) { + return false; + } + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->sat_corr_time)) { return false; } if (!sbp_u8_decode(ctx, &msg->ssr_sol_id)) { @@ -298,7 +539,12 @@ int sbp_msg_ssr_flag_high_level_cmp(const sbp_msg_ssr_flag_high_level_t *a, return ret; } - ret = sbp_gps_time_sec_cmp(&a->corr_time, &b->corr_time); + ret = sbp_gps_time_sec_cmp(&a->iono_corr_time, &b->iono_corr_time); + if (ret != 0) { + return ret; + } + + ret = sbp_gps_time_sec_cmp(&a->sat_corr_time, &b->sat_corr_time); if (ret != 0) { return ret; } diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c index 68ec2a2e64..b9b9b7a16e 100644 --- a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c @@ -90,13 +90,13 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { logging_reset(); - sbp_callback_register(&sbp_state, 3001, &msg_callback, + sbp_callback_register(&sbp_state, 3002, &msg_callback, &DUMMY_MEMORY_FOR_CALLBACKS, &n); u8 encoded_frame[] = { - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, - 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, 1, 2, - 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, + 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, }; dummy_reset(); @@ -106,9 +106,9 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { test_msg.ssr_flag_high_level.chain_id = 40; - test_msg.ssr_flag_high_level.corr_time.tow = 360; + test_msg.ssr_flag_high_level.iono_corr_time.tow = 365; - test_msg.ssr_flag_high_level.corr_time.wn = 6; + test_msg.ssr_flag_high_level.iono_corr_time.wn = 6; test_msg.ssr_flag_high_level.obs_time.tow = 180; @@ -124,6 +124,10 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { test_msg.ssr_flag_high_level.reserved[4] = 0; + test_msg.ssr_flag_high_level.sat_corr_time.tow = 360; + + test_msg.ssr_flag_high_level.sat_corr_time.wn = 6; + test_msg.ssr_flag_high_level.ssr_sol_id = 10; test_msg.ssr_flag_high_level.tile_id = 30; @@ -176,17 +180,17 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { "expected 40, is %" PRId64, (int64_t)last_msg.msg.ssr_flag_high_level.chain_id); - ck_assert_msg( - last_msg.msg.ssr_flag_high_level.corr_time.tow == 360, - "incorrect value for last_msg.msg.ssr_flag_high_level.corr_time.tow, " - "expected 360, is %" PRId64, - (int64_t)last_msg.msg.ssr_flag_high_level.corr_time.tow); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.iono_corr_time.tow == 365, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.iono_corr_time.tow, " + "expected 365, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.iono_corr_time.tow); - ck_assert_msg( - last_msg.msg.ssr_flag_high_level.corr_time.wn == 6, - "incorrect value for last_msg.msg.ssr_flag_high_level.corr_time.wn, " - "expected 6, is %" PRId64, - (int64_t)last_msg.msg.ssr_flag_high_level.corr_time.wn); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.iono_corr_time.wn == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.iono_corr_time.wn, " + "expected 6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.iono_corr_time.wn); ck_assert_msg( last_msg.msg.ssr_flag_high_level.obs_time.tow == 180, @@ -226,6 +230,18 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { "expected 0, is %" PRId64, (int64_t)last_msg.msg.ssr_flag_high_level.reserved[4]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.sat_corr_time.tow == 360, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.sat_corr_time.tow, " + "expected 360, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.sat_corr_time.tow); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level.sat_corr_time.wn == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.sat_corr_time.wn, expected " + "6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.sat_corr_time.wn); + ck_assert_msg( last_msg.msg.ssr_flag_high_level.ssr_sol_id == 10, "incorrect value for last_msg.msg.ssr_flag_high_level.ssr_sol_id, " diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c new file mode 100644 index 0000000000..6c17005808 --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static size_t dummy_wr = 0; +static size_t dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + size_t real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + size_t real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3001, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, + 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, 1, 2, + 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_high_level_dep_a.chain_id = 40; + + test_msg.ssr_flag_high_level_dep_a.corr_time.tow = 360; + + test_msg.ssr_flag_high_level_dep_a.corr_time.wn = 6; + + test_msg.ssr_flag_high_level_dep_a.obs_time.tow = 180; + + test_msg.ssr_flag_high_level_dep_a.obs_time.wn = 3; + + test_msg.ssr_flag_high_level_dep_a.reserved[0] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[1] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[2] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[3] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[4] = 0; + + test_msg.ssr_flag_high_level_dep_a.ssr_sol_id = 10; + + test_msg.ssr_flag_high_level_dep_a.tile_id = 30; + + test_msg.ssr_flag_high_level_dep_a.tile_set_id = 20; + + test_msg.ssr_flag_high_level_dep_a.use_bds_sat = 3; + + test_msg.ssr_flag_high_level_dep_a.use_gal_sat = 2; + + test_msg.ssr_flag_high_level_dep_a.use_gps_sat = 1; + + test_msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los = 8; + + test_msg.ssr_flag_high_level_dep_a.use_iono_grid_points = 6; + + test_msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los = 7; + + test_msg.ssr_flag_high_level_dep_a.use_qzss_sat = 4; + + test_msg.ssr_flag_high_level_dep_a.use_tropo_grid_points = 5; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagHighLevelDepA, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &last_msg.msg, + &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.chain_id == 40, + "incorrect value for last_msg.msg.ssr_flag_high_level_dep_a.chain_id, " + "expected 40, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.chain_id); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.corr_time.tow == 360, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.corr_time.tow, expected 360, " + "is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.corr_time.tow); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.corr_time.wn == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.corr_time.wn, " + "expected 6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.corr_time.wn); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.obs_time.tow == 180, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.obs_time.tow, " + "expected 180, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.obs_time.tow); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.obs_time.wn == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.obs_time.wn, " + "expected 3, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.obs_time.wn); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[0] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[0], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[0]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[1], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[1]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[2], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[2]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[3], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[3]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[4] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[4], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[4]); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.ssr_sol_id == 10, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.ssr_sol_id, expected " + "10, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.ssr_sol_id); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.tile_id == 30, + "incorrect value for last_msg.msg.ssr_flag_high_level_dep_a.tile_id, " + "expected 30, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.tile_id); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.tile_set_id == 20, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.tile_set_id, " + "expected 20, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.tile_set_id); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_bds_sat == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_bds_sat, " + "expected 3, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_bds_sat); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_gal_sat == 2, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_gal_sat, " + "expected 2, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_gal_sat); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_gps_sat == 1, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_gps_sat, " + "expected 1, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_gps_sat); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los == 8, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los, " + "expected 8, is %" PRId64, + (int64_t) + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_points == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_points, expected " + "6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_points); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los == 7, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los, " + "expected 7, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_qzss_sat == 4, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_qzss_sat, " + "expected 4, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_qzss_sat); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_tropo_grid_points == 5, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_tropo_grid_points, " + "expected 5, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_tropo_grid_points); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA"); + tcase_add_test(tc_acq, test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA); + suite_add_tcase(s, tc_acq); + return s; +} diff --git a/c/test/check_main.c b/c/test/check_main.c index 02127b32c5..a714e2bce2 100644 --- a/c/test/check_main.c +++ b/c/test/check_main.c @@ -63,6 +63,8 @@ int main(void) { srunner_add_suite(sr, auto_check_sbp_imu_MsgImuRaw_suite()); srunner_add_suite(sr, auto_check_sbp_integrity_MsgAcknowledge_suite()); srunner_add_suite(sr, auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite()); + srunner_add_suite(sr, + auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA_suite()); srunner_add_suite( sr, auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite()); srunner_add_suite(sr, diff --git a/c/test/check_suites.h b/c/test/check_suites.h index 47b58ebc12..887bab1cfc 100644 --- a/c/test/check_suites.h +++ b/c/test/check_suites.h @@ -53,6 +53,7 @@ Suite* auto_check_sbp_imu_MsgImuComp_suite(void); Suite* auto_check_sbp_imu_MsgImuRaw_suite(void); Suite* auto_check_sbp_integrity_MsgAcknowledge_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite(void); diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc index 0c7bc59ff4..663b9ddac2 100644 --- a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc @@ -31,8 +31,8 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 public: Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0() { assign(test_msg_.chain_id, 40); - assign(test_msg_.corr_time.tow, 360); - assign(test_msg_.corr_time.wn, 6); + assign(test_msg_.iono_corr_time.tow, 365); + assign(test_msg_.iono_corr_time.wn, 6); assign(test_msg_.obs_time.tow, 180); assign(test_msg_.obs_time.wn, 3); @@ -45,6 +45,8 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 assign(test_msg_.reserved[3], 0); assign(test_msg_.reserved[4], 0); + assign(test_msg_.sat_corr_time.tow, 360); + assign(test_msg_.sat_corr_time.wn, 6); assign(test_msg_.ssr_sol_id, 10); assign(test_msg_.tile_id, 30); assign(test_msg_.tile_set_id, 20); @@ -297,11 +299,11 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 info.msg_type = static_cast(SbpMsgSsrFlagHighLevel); info.sender_id = 66; info.preamble = 0x55; - info.crc = 0x0369; + info.crc = 0xEEB1; info.encoded_frame = encoded_frame_; info.frame_len = sizeof(encoded_frame_); info.encoded_payload = encoded_payload_; - info.payload_len = 31; + info.payload_len = 37; return info; } @@ -401,13 +403,14 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 private: sbp_msg_ssr_flag_high_level_t test_msg_{}; - uint8_t encoded_frame_[31 + 8] = { - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, - 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + uint8_t encoded_frame_[37 + 8] = { + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, + 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, }; - uint8_t encoded_payload_[31] = { - 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, - 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, + uint8_t encoded_payload_[37] = { + 180, 0, 0, 0, 3, 0, 109, 1, 0, 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, + 20, 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, }; }; @@ -423,39 +426,39 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodedLen) { TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodeToBuf) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; uint8_t n_written; EXPECT_EQ(sbp_msg_ssr_flag_high_level_encode(&buf[0], sizeof(buf), &n_written, &info.test_msg), SBP_OK); - EXPECT_EQ(n_written, 31); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(n_written, 37); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); memset(&buf[0], 0, sizeof(buf)); EXPECT_EQ(sbp_message_encode(&buf[0], sizeof(buf), &n_written, SbpMsgSsrFlagHighLevel, &info.test_msg_wrapped), SBP_OK); - EXPECT_EQ(n_written, 31); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(n_written, 37); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); } TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodeToBufWithoutNwritten) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; EXPECT_EQ(sbp_msg_ssr_flag_high_level_encode(&buf[0], sizeof(buf), nullptr, &info.test_msg), SBP_OK); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); } TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodedToBufUnderflow) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; - for (uint8_t i = 0; i < 31; i++) { + for (uint8_t i = 0; i < 37; i++) { EXPECT_EQ( sbp_msg_ssr_flag_high_level_encode(&buf[0], i, nullptr, &info.test_msg), SBP_ENCODE_ERROR); @@ -470,14 +473,14 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, DecodeFromBuf) { EXPECT_EQ(sbp_msg_ssr_flag_high_level_decode(&info.encoded_payload[0], info.payload_len, &n_read, &msg), SBP_OK); - EXPECT_EQ(n_read, 31); + EXPECT_EQ(n_read, 37); EXPECT_EQ(msg, info.test_msg); sbp_msg_t wrapped_msg{}; EXPECT_EQ(sbp_message_decode(&info.encoded_payload[0], info.payload_len, &n_read, SbpMsgSsrFlagHighLevel, &wrapped_msg), SBP_OK); - EXPECT_EQ(n_read, 31); + EXPECT_EQ(n_read, 37); EXPECT_EQ(msg, info.test_msg); } @@ -669,13 +672,13 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, Comparison) { { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.corr_time.tow, greater.corr_time.tow); + make_lesser_greater(lesser.iono_corr_time.tow, greater.iono_corr_time.tow); comparison_tests(lesser, greater); } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.corr_time.wn, greater.corr_time.wn); + make_lesser_greater(lesser.iono_corr_time.wn, greater.iono_corr_time.wn); comparison_tests(lesser, greater); } { @@ -725,6 +728,18 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, Comparison) { make_lesser_greater(lesser.reserved[4], greater.reserved[4]); comparison_tests(lesser, greater); } + { + sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_t greater = info.test_msg; + make_lesser_greater(lesser.sat_corr_time.tow, greater.sat_corr_time.tow); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_t greater = info.test_msg; + make_lesser_greater(lesser.sat_corr_time.wn, greater.sat_corr_time.wn); + comparison_tests(lesser, greater); + } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; @@ -861,14 +876,14 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, CppTraitsEncodeToBuf) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; uint8_t n_written; EXPECT_EQ(sbp::MessageTraits::encode( &buf[0], sizeof(buf), &n_written, info.test_msg), SBP_OK); - EXPECT_EQ(n_written, 31); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(n_written, 37); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); } TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, @@ -880,7 +895,7 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EXPECT_EQ(sbp::MessageTraits::decode( &info.encoded_payload[0], info.payload_len, &n_read, &msg), SBP_OK); - EXPECT_EQ(n_read, 31); + EXPECT_EQ(n_read, 37); EXPECT_EQ(msg, info.test_msg); } diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc new file mode 100644 index 0000000000..46103eae00 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc @@ -0,0 +1,962 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include + +namespace { + +template +void assign(T &dest, const U &source) { + dest = static_cast(source); +} +class Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0 + : public ::testing::Test { + public: + Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0() { + assign(test_msg_.chain_id, 40); + assign(test_msg_.corr_time.tow, 360); + assign(test_msg_.corr_time.wn, 6); + assign(test_msg_.obs_time.tow, 180); + assign(test_msg_.obs_time.wn, 3); + + assign(test_msg_.reserved[0], 0); + + assign(test_msg_.reserved[1], 0); + + assign(test_msg_.reserved[2], 0); + + assign(test_msg_.reserved[3], 0); + + assign(test_msg_.reserved[4], 0); + assign(test_msg_.ssr_sol_id, 10); + assign(test_msg_.tile_id, 30); + assign(test_msg_.tile_set_id, 20); + assign(test_msg_.use_bds_sat, 3); + assign(test_msg_.use_gal_sat, 2); + assign(test_msg_.use_gps_sat, 1); + assign(test_msg_.use_iono_grid_point_sat_los, 8); + assign(test_msg_.use_iono_grid_points, 6); + assign(test_msg_.use_iono_tile_sat_los, 7); + assign(test_msg_.use_qzss_sat, 4); + assign(test_msg_.use_tropo_grid_points, 5); + } + + class SlowReader final : public sbp::IReader { + public: + SlowReader(const uint8_t *buf, uint32_t len) + : sbp::IReader(), buf_{buf}, len_{len} {} + + s32 read(uint8_t *buf, const uint32_t n) override { + if (n == 0) { + return 0; + } + if (remaining() == 0) { + return -1; + } + skip_next_read = !skip_next_read; + if (skip_next_read) { + return 0; + } + uint32_t real_n = std::min(n, 1u); + memcpy(buf, buf_ + offset_, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return len_ - offset_; } + + static s32 read_static(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->read(buf, len); + } + + private: + const uint8_t *buf_; + uint32_t len_; + uint32_t offset_{}; + bool skip_next_read{}; + }; + + class Reader final : public sbp::IReader { + public: + Reader(const uint8_t *buf, uint32_t len) + : sbp::IReader(), buf_{buf}, len_{len} {} + + s32 read(uint8_t *buf, const uint32_t n) override { + if (n == 0) { + return 0; + } + uint32_t real_n = std::min(n, remaining()); + if (real_n == 0) { + return -1; + } + memcpy(buf, buf_ + offset_, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return len_ - offset_; } + + static s32 read_static(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->read(buf, len); + } + + private: + const uint8_t *buf_; + uint32_t len_; + uint32_t offset_{}; + }; + + class SlowWriter final : public sbp::IWriter { + public: + explicit SlowWriter(uint32_t max_len = cMaxLen) + : IWriter(), max_len_{max_len} {} + static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; + + s32 write(const uint8_t *buf, uint32_t n) override { + if (n == 0) { + return 0; + } + uint32_t real_n = std::min(n, 1u); + if (real_n == 0) { + return -1; + } + memcpy(buf_ + offset_, buf, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return max_len_ - offset_; } + + const uint8_t *data() const noexcept { return buf_; } + + uint32_t len() const noexcept { return offset_; } + + static s32 write_static(const uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + static s32 write_c(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + private: + uint8_t buf_[cMaxLen]; + uint32_t max_len_; + uint32_t offset_{}; + }; + + class Writer final : public sbp::IWriter { + public: + explicit Writer(uint32_t max_len = cMaxLen) + : IWriter(), max_len_{max_len} {} + static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; + + s32 write(const uint8_t *buf, uint32_t n) override { + if (n == 0) { + return 0; + } + uint32_t real_n = std::min(n, remaining()); + if (real_n == 0) { + return -1; + } + memcpy(buf_ + offset_, buf, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return max_len_ - offset_; } + + const uint8_t *data() const noexcept { return buf_; } + + uint32_t len() const noexcept { return offset_; } + + static s32 write_static(const uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + static s32 write_c(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + private: + uint8_t buf_[cMaxLen]; + uint32_t max_len_; + uint32_t offset_{}; + }; + + struct CppHandler final + : public sbp::MessageHandler { + using sbp::MessageHandler< + sbp_msg_ssr_flag_high_level_dep_a_t>::MessageHandler; + + struct Output final { + uint16_t sender_id; + sbp_msg_ssr_flag_high_level_dep_a_t msg; + }; + + std::vector outputs{}; + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t &msg) override { + outputs.emplace_back(); + outputs.back().sender_id = sender_id; + memcpy(&outputs.back().msg, &msg, sizeof(msg)); + } + }; + + struct CHandler final { + explicit CHandler(sbp_state_t *state) : state_{state} { + sbp_callback_register(state, SbpMsgSsrFlagHighLevelDepA, + &CHandler::callback_static, this, &node_); + } + + ~CHandler() { sbp_remove_callback(state_, &node_); } + + struct Output final { + uint16_t sender_id; + sbp_msg_ssr_flag_high_level_dep_a_t msg; + }; + + std::vector outputs{}; + + private: + void callback(uint16_t sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg) { + ASSERT_EQ(msg_type, SbpMsgSsrFlagHighLevelDepA); + outputs.emplace_back(); + outputs.back().sender_id = sender_id; + memcpy(&outputs.back().msg, &msg->ssr_flag_high_level_dep_a, + sizeof(msg->ssr_flag_high_level_dep_a)); + } + + static void callback_static(uint16_t sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *ctx) { + static_cast(ctx)->callback(sender_id, msg_type, msg); + } + + sbp_msg_callbacks_node_t node_{}; + sbp_state_t *state_; + }; + + struct TestMsgInfo { + sbp_msg_ssr_flag_high_level_dep_a_t test_msg; + sbp_msg_t test_msg_wrapped; + sbp_msg_type_t msg_type; + uint16_t sender_id; + uint8_t preamble; + uint16_t crc; + const uint8_t *encoded_frame; + uint32_t frame_len; + const uint8_t *encoded_payload; + uint8_t payload_len; + + Reader get_frame_reader() const noexcept { + return Reader{encoded_frame, frame_len}; + } + + Reader get_frame_reader(uint32_t max) const noexcept { + assert(max <= frame_len); + return Reader{encoded_frame, max}; + } + + SlowReader get_slow_frame_reader() const noexcept { + return SlowReader{encoded_frame, frame_len}; + } + + Writer get_frame_writer() const noexcept { return Writer{frame_len}; } + + Writer get_frame_writer(uint32_t max) const noexcept { return Writer{max}; } + + SlowWriter get_slow_frame_writer() const noexcept { + return SlowWriter{frame_len}; + } + }; + + TestMsgInfo get_test_msg_info() const noexcept { + TestMsgInfo info; + memcpy(&info.test_msg, &test_msg_, sizeof(test_msg_)); + memcpy(&info.test_msg_wrapped.ssr_flag_high_level_dep_a, &test_msg_, + sizeof(test_msg_)); + info.msg_type = static_cast(SbpMsgSsrFlagHighLevelDepA); + info.sender_id = 66; + info.preamble = 0x55; + info.crc = 0x0369; + info.encoded_frame = encoded_frame_; + info.frame_len = sizeof(encoded_frame_); + info.encoded_payload = encoded_payload_; + info.payload_len = 31; + + return info; + } + + protected: + void comparison_tests(const sbp_msg_ssr_flag_high_level_dep_a_t &lesser, + const sbp_msg_ssr_flag_high_level_dep_a_t &greater) { + sbp_msg_t wrapped_lesser = + sbp::MessageTraits::to_sbp_msg( + lesser); + sbp_msg_t wrapped_greater = + sbp::MessageTraits::to_sbp_msg( + greater); + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_cmp(&lesser, &lesser), 0); + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_cmp(&greater, &greater), 0); + EXPECT_LE(sbp_msg_ssr_flag_high_level_dep_a_cmp(&lesser, &greater), 0); + EXPECT_GT(sbp_msg_ssr_flag_high_level_dep_a_cmp(&greater, &lesser), 0); + + EXPECT_EQ(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_lesser, + &wrapped_lesser), + 0); + EXPECT_EQ(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_greater, + &wrapped_greater), + 0); + EXPECT_LE(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_lesser, + &wrapped_greater), + 0); + EXPECT_GT(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_greater, + &wrapped_lesser), + 0); + + // lesser vs lesser + EXPECT_TRUE(lesser == lesser); + EXPECT_FALSE(lesser != lesser); + EXPECT_FALSE(lesser < lesser); + EXPECT_TRUE(lesser <= lesser); + EXPECT_FALSE(lesser > lesser); + EXPECT_TRUE(lesser >= lesser); + + // greater vs greater + EXPECT_TRUE(greater == greater); + EXPECT_FALSE(greater != greater); + EXPECT_FALSE(greater < greater); + EXPECT_TRUE(greater <= greater); + EXPECT_FALSE(greater > greater); + EXPECT_TRUE(greater >= greater); + + // lesser vs greater + EXPECT_FALSE(lesser == greater); + EXPECT_TRUE(lesser != greater); + EXPECT_TRUE(lesser < greater); + EXPECT_TRUE(lesser <= greater); + EXPECT_FALSE(lesser > greater); + EXPECT_FALSE(lesser >= greater); + + // greater vs lesser + EXPECT_FALSE(greater == lesser); + EXPECT_TRUE(greater != lesser); + EXPECT_FALSE(greater < lesser); + EXPECT_FALSE(greater <= lesser); + EXPECT_TRUE(greater > lesser); + EXPECT_TRUE(greater >= lesser); + } + + template ::value, bool> = true> + void make_lesser_greater(T &lesser, T &greater) { + if (lesser > std::numeric_limits::min()) { + lesser--; + } else { + greater++; + } + } + + template ::value, bool> = true> + void make_lesser_greater(T &lesser, T &greater) { + (void)lesser; + greater += static_cast(1.0); + } + + void make_lesser_greater(sbp_string_t &lesser, sbp_string_t &greater) { + if (greater.data[0] == 'z') { + lesser.data[0]--; + } else { + greater.data[0]++; + } + } + + template + void make_lesser_greater(char (&lesser)[N], char (&greater)[N]) { + if (lesser[0] == 'z') { + lesser[0]--; + } else { + greater[0]++; + } + } + + private: + sbp_msg_ssr_flag_high_level_dep_a_t test_msg_{}; + uint8_t encoded_frame_[31 + 8] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, + 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + }; + uint8_t encoded_payload_[31] = { + 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, + 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, + }; +}; + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, EncodedLen) { + auto info = get_test_msg_info(); + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encoded_len(&info.test_msg), + info.payload_len); + + EXPECT_EQ(sbp_message_encoded_len(SbpMsgSsrFlagHighLevelDepA, + &info.test_msg_wrapped), + info.payload_len); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, EncodeToBuf) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + uint8_t n_written; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encode( + &buf[0], sizeof(buf), &n_written, &info.test_msg), + SBP_OK); + EXPECT_EQ(n_written, 31); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + + memset(&buf[0], 0, sizeof(buf)); + EXPECT_EQ( + sbp_message_encode(&buf[0], sizeof(buf), &n_written, + SbpMsgSsrFlagHighLevelDepA, &info.test_msg_wrapped), + SBP_OK); + EXPECT_EQ(n_written, 31); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + EncodeToBufWithoutNwritten) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encode(&buf[0], sizeof(buf), + nullptr, &info.test_msg), + SBP_OK); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); +} +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + EncodedToBufUnderflow) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + + for (uint8_t i = 0; i < 31; i++) { + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encode(&buf[0], i, nullptr, + &info.test_msg), + SBP_ENCODE_ERROR); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, DecodeFromBuf) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + uint8_t n_read; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_decode( + &info.encoded_payload[0], info.payload_len, &n_read, &msg), + SBP_OK); + EXPECT_EQ(n_read, 31); + EXPECT_EQ(msg, info.test_msg); + + sbp_msg_t wrapped_msg{}; + EXPECT_EQ( + sbp_message_decode(&info.encoded_payload[0], info.payload_len, &n_read, + SbpMsgSsrFlagHighLevelDepA, &wrapped_msg), + SBP_OK); + EXPECT_EQ(n_read, 31); + EXPECT_EQ(msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + DecodeFromBufWithoutNread) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_decode( + &info.encoded_payload[0], info.payload_len, nullptr, &msg), + SBP_OK); + EXPECT_EQ(msg, info.test_msg); +} +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + DecodeFromBufUnderflow) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + + for (uint8_t i = 0; i < info.payload_len; i++) { + int expected_return = SBP_DECODE_ERROR; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_decode(&info.encoded_payload[0], + i, nullptr, &msg), + expected_return); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ReceiveThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto reader = info.get_frame_reader(); + sbp_state_set_io_context(&state, &reader); + + CHandler handler{&state}; + + while (reader.remaining() > 0) { + EXPECT_GE(sbp_process(&state, &Reader::read_static), SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ReceiveThroughSbpStateUnderflow) { + auto info = get_test_msg_info(); + + for (uint32_t i = 0; i < info.frame_len; i++) { + sbp_state_t state; + sbp_state_init(&state); + + auto reader = info.get_frame_reader(i); + sbp_state_set_io_context(&state, &reader); + + CHandler handler(&state); + + int most_recent_return = sbp_process(&state, &Reader::read_static); + while (most_recent_return == SBP_OK || reader.remaining() > 0) { + most_recent_return = sbp_process(&state, &Reader::read_static); + } + + EXPECT_NE(most_recent_return, SBP_OK); + EXPECT_EQ(reader.remaining(), 0); + + EXPECT_EQ(handler.outputs.size(), 0); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, SlowRead) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto reader = info.get_slow_frame_reader(); + sbp_state_set_io_context(&state, &reader); + + CHandler handler{&state}; + + while (reader.remaining() > 0) { + EXPECT_GE(sbp_process(&state, &SlowReader::read_static), SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, BadCRC) { + auto info = get_test_msg_info(); + uint8_t buf[SBP_MAX_FRAME_LEN]; + memcpy(&buf[0], info.encoded_frame, info.frame_len); + + // Introduce a CRC error which should cause an error return and no callback + buf[info.frame_len - 1]++; + + sbp_state_t state; + sbp_state_init(&state); + + Reader reader{buf, info.frame_len}; + sbp_state_set_io_context(&state, &reader); + + CHandler handler{&state}; + + while (reader.remaining() > 0) { + int res = sbp_process(&state, &Reader::read_static); + EXPECT_EQ(res, reader.remaining() == 0 ? SBP_CRC_ERROR : SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_send( + &state, info.sender_id, &info.test_msg, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), &info.encoded_frame[0], writer.len()), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendWrappedThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp_message_send(&state, SbpMsgSsrFlagHighLevelDepA, info.sender_id, + &info.test_msg_wrapped, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendThroughSbpStateUnderflow) { + auto info = get_test_msg_info(); + + for (uint32_t i = 0; i < info.frame_len; i++) { + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(i); + sbp_state_set_io_context(&state, &writer); + + EXPECT_NE( + sbp_message_send(&state, SbpMsgSsrFlagHighLevelDepA, info.sender_id, + &info.test_msg_wrapped, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), i); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, i), 0); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + DISABLED_SlowWrite) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_slow_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp_message_send(&state, SbpMsgSsrFlagHighLevelDepA, info.sender_id, + &info.test_msg_wrapped, &SlowWriter::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, Comparison) { + auto info = get_test_msg_info(); + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.chain_id, greater.chain_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.corr_time.tow, greater.corr_time.tow); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.corr_time.wn, greater.corr_time.wn); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.obs_time.tow, greater.obs_time.tow); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.obs_time.wn, greater.obs_time.wn); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[0], greater.reserved[0]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[1], greater.reserved[1]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[2], greater.reserved[2]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[3], greater.reserved[3]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[4], greater.reserved[4]); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.ssr_sol_id, greater.ssr_sol_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.tile_id, greater.tile_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.tile_set_id, greater.tile_set_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_bds_sat, greater.use_bds_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_gal_sat, greater.use_gal_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_gps_sat, greater.use_gps_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_iono_grid_point_sat_los, + greater.use_iono_grid_point_sat_los); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_iono_grid_points, + greater.use_iono_grid_points); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_iono_tile_sat_los, + greater.use_iono_tile_sat_los); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_qzss_sat, greater.use_qzss_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_tropo_grid_points, + greater.use_tropo_grid_points); + comparison_tests(lesser, greater); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsProperties) { + // EXPECT_EQ(sbp::MessageTraits::id, + // SbpMsgSsrFlagHighLevelDepA); + EXPECT_STREQ(sbp::MessageTraits::name, + "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsFromSbpMsgT) { + auto info = get_test_msg_info(); + + const sbp_msg_t &const_sbp_msg_t = info.test_msg_wrapped; + sbp_msg_t &non_const_sbp_msg_t = info.test_msg_wrapped; + + const sbp_msg_ssr_flag_high_level_dep_a_t &const_unwrapped = + sbp::MessageTraits::get( + const_sbp_msg_t); + sbp_msg_ssr_flag_high_level_dep_a_t &non_const_unwrapped = + sbp::MessageTraits::get( + non_const_sbp_msg_t); + + EXPECT_EQ((const void *)&const_sbp_msg_t, (const void *)&const_unwrapped); + EXPECT_EQ((void *)&non_const_sbp_msg_t, (void *)&non_const_unwrapped); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsToSbpMsgT) { + auto info = get_test_msg_info(); + + sbp_msg_t msg1 = + sbp::MessageTraits::to_sbp_msg( + info.test_msg); + EXPECT_EQ(msg1.ssr_flag_high_level_dep_a, info.test_msg); + + sbp_msg_t msg2; + sbp::MessageTraits::to_sbp_msg( + info.test_msg, &msg2); + EXPECT_EQ(msg2.ssr_flag_high_level_dep_a, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsEncodedLen) { + auto info = get_test_msg_info(); + EXPECT_EQ( + sbp::MessageTraits::encoded_len( + info.test_msg), + info.payload_len); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsSendThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp::MessageTraits::send( + &state, info.sender_id, info.test_msg, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), &info.encoded_frame[0], writer.len()), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsEncodeToBuf) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + uint8_t n_written; + + EXPECT_EQ(sbp::MessageTraits::encode( + &buf[0], sizeof(buf), &n_written, info.test_msg), + SBP_OK); + EXPECT_EQ(n_written, 31); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsDecodeFromBuf) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + uint8_t n_read; + + EXPECT_EQ(sbp::MessageTraits::decode( + &info.encoded_payload[0], info.payload_len, &n_read, &msg), + SBP_OK); + EXPECT_EQ(n_read, 31); + EXPECT_EQ(msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ReceiveThroughMessageHandler) { + auto info = get_test_msg_info(); + auto reader = info.get_frame_reader(); + + sbp::State state{}; + state.set_reader(&reader); + + CppHandler handler{&state}; + + while (reader.remaining() > 0) { + EXPECT_GE(state.process(), SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ProcessSbpMsgTThroughMessageHandler) { + auto info = get_test_msg_info(); + sbp::State state{}; + CppHandler handler(&state); + + state.process_message(info.sender_id, SbpMsgSsrFlagHighLevelDepA, + &info.test_msg_wrapped); + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendThroughCppState) { + auto info = get_test_msg_info(); + auto writer = info.get_frame_writer(); + + sbp::State state{}; + state.set_writer(&writer); + + EXPECT_EQ(state.send_message(info.sender_id, info.test_msg), SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendWrappedSbpMsgTThroughCppState) { + auto info = get_test_msg_info(); + auto writer = info.get_frame_writer(); + + sbp::State state{}; + state.set_writer(&writer); + + EXPECT_EQ(state.send_message(info.sender_id, SbpMsgSsrFlagHighLevelDepA, + info.test_msg_wrapped), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +} // namespace diff --git a/docs/sbp.pdf b/docs/sbp.pdf index a9e6a283906d26dd1b8461331677f2a7e6051160..b8f2cc1366bdfcf0908e3aea3753f8c0a81ee359 100644 GIT binary patch delta 134666 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

9CCf`&=}0X)2{rVg&2r|i`gmoZHv{0UXv6I9z! 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

bW7RBe54S%2DN+ad`mxqpiCw$k}M!fWPBuH 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

UMGW(~Q+si#F%e=ZWvNJcDoqV5 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 VIAWJOst6wnG&nK}B_%~qMheDjW*z_l diff --git a/haskell/src/SwiftNav/SBP/Integrity.hs b/haskell/src/SwiftNav/SBP/Integrity.hs index f4782d9d5a..d278c06d43 100644 --- a/haskell/src/SwiftNav/SBP/Integrity.hs +++ b/haskell/src/SwiftNav/SBP/Integrity.hs @@ -76,10 +76,89 @@ instance Binary IntegritySSRHeader where $(makeJSON "_integritySSRHeader_" ''IntegritySSRHeader) $(makeLenses ''IntegritySSRHeader) +msgSsrFlagHighLevelDepA :: Word16 +msgSsrFlagHighLevelDepA = 0x0BB9 + +-- | SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). +-- +-- Deprecated. +data MsgSsrFlagHighLevelDepA = MsgSsrFlagHighLevelDepA + { _msgSsrFlagHighLevelDepA_obs_time :: !GpsTimeSec + -- ^ GNSS reference time of the observation used to generate the flag. + , _msgSsrFlagHighLevelDepA_corr_time :: !GpsTimeSec + -- ^ GNSS reference time of the correction associated to the flag. + , _msgSsrFlagHighLevelDepA_ssr_sol_id :: !Word8 + -- ^ SSR Solution ID. + , _msgSsrFlagHighLevelDepA_tile_set_id :: !Word16 + -- ^ Unique identifier of the set this tile belongs to. + , _msgSsrFlagHighLevelDepA_tile_id :: !Word16 + -- ^ Unique identifier of this tile in the tile set. + , _msgSsrFlagHighLevelDepA_chain_id :: !Word8 + -- ^ Chain and type of flag. + , _msgSsrFlagHighLevelDepA_use_gps_sat :: !Word8 + -- ^ Use GPS satellites. + , _msgSsrFlagHighLevelDepA_use_gal_sat :: !Word8 + -- ^ Use GAL satellites. + , _msgSsrFlagHighLevelDepA_use_bds_sat :: !Word8 + -- ^ Use BDS satellites. + , _msgSsrFlagHighLevelDepA_use_qzss_sat :: !Word8 + -- ^ Use QZSS satellites. + , _msgSsrFlagHighLevelDepA_reserved :: ![Word8] + -- ^ Reserved + , _msgSsrFlagHighLevelDepA_use_tropo_grid_points :: !Word8 + -- ^ Use tropo grid points. + , _msgSsrFlagHighLevelDepA_use_iono_grid_points :: !Word8 + -- ^ Use iono grid points. + , _msgSsrFlagHighLevelDepA_use_iono_tile_sat_los :: !Word8 + -- ^ Use iono tile satellite LoS. + , _msgSsrFlagHighLevelDepA_use_iono_grid_point_sat_los :: !Word8 + -- ^ Use iono grid point satellite LoS. + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagHighLevelDepA where + get = do + _msgSsrFlagHighLevelDepA_obs_time <- get + _msgSsrFlagHighLevelDepA_corr_time <- get + _msgSsrFlagHighLevelDepA_ssr_sol_id <- getWord8 + _msgSsrFlagHighLevelDepA_tile_set_id <- getWord16le + _msgSsrFlagHighLevelDepA_tile_id <- getWord16le + _msgSsrFlagHighLevelDepA_chain_id <- getWord8 + _msgSsrFlagHighLevelDepA_use_gps_sat <- getWord8 + _msgSsrFlagHighLevelDepA_use_gal_sat <- getWord8 + _msgSsrFlagHighLevelDepA_use_bds_sat <- getWord8 + _msgSsrFlagHighLevelDepA_use_qzss_sat <- getWord8 + _msgSsrFlagHighLevelDepA_reserved <- replicateM 5 getWord8 + _msgSsrFlagHighLevelDepA_use_tropo_grid_points <- getWord8 + _msgSsrFlagHighLevelDepA_use_iono_grid_points <- getWord8 + _msgSsrFlagHighLevelDepA_use_iono_tile_sat_los <- getWord8 + _msgSsrFlagHighLevelDepA_use_iono_grid_point_sat_los <- getWord8 + pure MsgSsrFlagHighLevelDepA {..} + + put MsgSsrFlagHighLevelDepA {..} = do + put _msgSsrFlagHighLevelDepA_obs_time + put _msgSsrFlagHighLevelDepA_corr_time + putWord8 _msgSsrFlagHighLevelDepA_ssr_sol_id + putWord16le _msgSsrFlagHighLevelDepA_tile_set_id + putWord16le _msgSsrFlagHighLevelDepA_tile_id + putWord8 _msgSsrFlagHighLevelDepA_chain_id + putWord8 _msgSsrFlagHighLevelDepA_use_gps_sat + putWord8 _msgSsrFlagHighLevelDepA_use_gal_sat + putWord8 _msgSsrFlagHighLevelDepA_use_bds_sat + putWord8 _msgSsrFlagHighLevelDepA_use_qzss_sat + mapM_ putWord8 _msgSsrFlagHighLevelDepA_reserved + putWord8 _msgSsrFlagHighLevelDepA_use_tropo_grid_points + putWord8 _msgSsrFlagHighLevelDepA_use_iono_grid_points + putWord8 _msgSsrFlagHighLevelDepA_use_iono_tile_sat_los + putWord8 _msgSsrFlagHighLevelDepA_use_iono_grid_point_sat_los + +$(makeSBP 'msgSsrFlagHighLevelDepA ''MsgSsrFlagHighLevelDepA) +$(makeJSON "_msgSsrFlagHighLevelDepA_" ''MsgSsrFlagHighLevelDepA) +$(makeLenses ''MsgSsrFlagHighLevelDepA) + msgSsrFlagHighLevel :: Word16 -msgSsrFlagHighLevel = 0x0BB9 +msgSsrFlagHighLevel = 0x0BBA --- | SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). +-- | SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). -- -- Integrity monitoring flags for multiple aggregated elements. An element -- could be a satellite, SSR grid point, or SSR tile. A group of aggregated @@ -109,8 +188,11 @@ msgSsrFlagHighLevel = 0x0BB9 data MsgSsrFlagHighLevel = MsgSsrFlagHighLevel { _msgSsrFlagHighLevel_obs_time :: !GpsTimeSec -- ^ GNSS reference time of the observation used to generate the flag. - , _msgSsrFlagHighLevel_corr_time :: !GpsTimeSec - -- ^ GNSS reference time of the correction associated to the flag. + , _msgSsrFlagHighLevel_iono_corr_time :: !GpsTimeSec + -- ^ GNSS reference time of the ionospheric correction associated to the + -- flag. + , _msgSsrFlagHighLevel_sat_corr_time :: !GpsTimeSec + -- ^ GNSS reference time of the satellite correction associated to the flag. , _msgSsrFlagHighLevel_ssr_sol_id :: !Word8 -- ^ SSR Solution ID. , _msgSsrFlagHighLevel_tile_set_id :: !Word16 @@ -142,7 +224,8 @@ data MsgSsrFlagHighLevel = MsgSsrFlagHighLevel instance Binary MsgSsrFlagHighLevel where get = do _msgSsrFlagHighLevel_obs_time <- get - _msgSsrFlagHighLevel_corr_time <- get + _msgSsrFlagHighLevel_iono_corr_time <- get + _msgSsrFlagHighLevel_sat_corr_time <- get _msgSsrFlagHighLevel_ssr_sol_id <- getWord8 _msgSsrFlagHighLevel_tile_set_id <- getWord16le _msgSsrFlagHighLevel_tile_id <- getWord16le @@ -160,7 +243,8 @@ instance Binary MsgSsrFlagHighLevel where put MsgSsrFlagHighLevel {..} = do put _msgSsrFlagHighLevel_obs_time - put _msgSsrFlagHighLevel_corr_time + put _msgSsrFlagHighLevel_iono_corr_time + put _msgSsrFlagHighLevel_sat_corr_time putWord8 _msgSsrFlagHighLevel_ssr_sol_id putWord16le _msgSsrFlagHighLevel_tile_set_id putWord16le _msgSsrFlagHighLevel_tile_id diff --git a/haskell/src/SwiftNav/SBP/Msg.hs b/haskell/src/SwiftNav/SBP/Msg.hs index cbd229261f..06b92befa7 100644 --- a/haskell/src/SwiftNav/SBP/Msg.hs +++ b/haskell/src/SwiftNav/SBP/Msg.hs @@ -237,6 +237,7 @@ data SBPMsg = | SBPMsgSsrCodeBiases MsgSsrCodeBiases Msg | SBPMsgSsrCodePhaseBiasesBounds MsgSsrCodePhaseBiasesBounds Msg | SBPMsgSsrFlagHighLevel MsgSsrFlagHighLevel Msg + | SBPMsgSsrFlagHighLevelDepA MsgSsrFlagHighLevelDepA Msg | SBPMsgSsrFlagIonoGridPointSatLos MsgSsrFlagIonoGridPointSatLos Msg | SBPMsgSsrFlagIonoGridPoints MsgSsrFlagIonoGridPoints Msg | SBPMsgSsrFlagIonoTileSatLos MsgSsrFlagIonoTileSatLos Msg @@ -489,6 +490,7 @@ instance Binary SBPMsg where | _msgSBPType == msgSsrCodeBiases = SBPMsgSsrCodeBiases (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrCodePhaseBiasesBounds = SBPMsgSsrCodePhaseBiasesBounds (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagHighLevel = SBPMsgSsrFlagHighLevel (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagHighLevelDepA = SBPMsgSsrFlagHighLevelDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagIonoGridPointSatLos = SBPMsgSsrFlagIonoGridPointSatLos (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagIonoGridPoints = SBPMsgSsrFlagIonoGridPoints (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagIonoTileSatLos = SBPMsgSsrFlagIonoTileSatLos (decode (fromStrict (unBytes _msgSBPPayload))) m @@ -733,6 +735,7 @@ instance Binary SBPMsg where encoder (SBPMsgSsrCodeBiases _ m) = put m encoder (SBPMsgSsrCodePhaseBiasesBounds _ m) = put m encoder (SBPMsgSsrFlagHighLevel _ m) = put m + encoder (SBPMsgSsrFlagHighLevelDepA _ m) = put m encoder (SBPMsgSsrFlagIonoGridPointSatLos _ m) = put m encoder (SBPMsgSsrFlagIonoGridPoints _ m) = put m encoder (SBPMsgSsrFlagIonoTileSatLos _ m) = put m @@ -981,6 +984,7 @@ instance FromJSON SBPMsg where | msgType == msgSsrCodeBiases = SBPMsgSsrCodeBiases <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrCodePhaseBiasesBounds = SBPMsgSsrCodePhaseBiasesBounds <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagHighLevel = SBPMsgSsrFlagHighLevel <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagHighLevelDepA = SBPMsgSsrFlagHighLevelDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagIonoGridPointSatLos = SBPMsgSsrFlagIonoGridPointSatLos <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagIonoGridPoints = SBPMsgSsrFlagIonoGridPoints <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagIonoTileSatLos = SBPMsgSsrFlagIonoTileSatLos <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj @@ -1230,6 +1234,7 @@ instance ToJSON SBPMsg where toJSON (SBPMsgSsrCodeBiases n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrCodePhaseBiasesBounds n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagHighLevel n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagHighLevelDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagIonoGridPointSatLos n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagIonoGridPoints n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagIonoTileSatLos n m) = toJSON n <<>> toJSON m @@ -1473,6 +1478,7 @@ instance HasMsg SBPMsg where msg f (SBPMsgSsrCodeBiases n m) = SBPMsgSsrCodeBiases n <$> f m msg f (SBPMsgSsrCodePhaseBiasesBounds n m) = SBPMsgSsrCodePhaseBiasesBounds n <$> f m msg f (SBPMsgSsrFlagHighLevel n m) = SBPMsgSsrFlagHighLevel n <$> f m + msg f (SBPMsgSsrFlagHighLevelDepA n m) = SBPMsgSsrFlagHighLevelDepA n <$> f m msg f (SBPMsgSsrFlagIonoGridPointSatLos n m) = SBPMsgSsrFlagIonoGridPointSatLos n <$> f m msg f (SBPMsgSsrFlagIonoGridPoints n m) = SBPMsgSsrFlagIonoGridPoints n <$> f m msg f (SBPMsgSsrFlagIonoTileSatLos n m) = SBPMsgSsrFlagIonoTileSatLos n <$> f m diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index 9a992a1ccb..098d3d7311 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -50,6 +50,7 @@ import com.swiftnav.sbp.imu.MsgImuRaw; import com.swiftnav.sbp.integrity.MsgAcknowledge; import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevel; +import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevelDepA; import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPointSatLos; import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPoints; import com.swiftnav.sbp.integrity.MsgSsrFlagIonoTileSatLos; @@ -326,6 +327,8 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgImuAux(msg); case MsgImuComp.TYPE: return new MsgImuComp(msg); + case MsgSsrFlagHighLevelDepA.TYPE: + return new MsgSsrFlagHighLevelDepA(msg); case MsgSsrFlagHighLevel.TYPE: return new MsgSsrFlagHighLevel(msg); case MsgSsrFlagSatellites.TYPE: diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java index 1c722941d8..c736892d72 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java @@ -21,7 +21,7 @@ import org.json.JSONObject; /** - * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). * *

You can have MSG_SSR_FLAG_HIGH_LEVEL inherent its fields directly from an inherited SBP * object, or construct it inline using a dict of its fields. @@ -52,13 +52,16 @@ * group. */ public class MsgSsrFlagHighLevel extends SBPMessage { - public static final int TYPE = 0x0BB9; + public static final int TYPE = 0x0BBA; /** GNSS reference time of the observation used to generate the flag. */ public GPSTimeSec obs_time; - /** GNSS reference time of the correction associated to the flag. */ - public GPSTimeSec corr_time; + /** GNSS reference time of the ionospheric correction associated to the flag. */ + public GPSTimeSec iono_corr_time; + + /** GNSS reference time of the satellite correction associated to the flag. */ + public GPSTimeSec sat_corr_time; /** SSR Solution ID. */ public int ssr_sol_id; @@ -111,14 +114,15 @@ public MsgSsrFlagHighLevel(SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagHighLevel, expected 3001, actual " + msg.type); + "Type mismatch for MsgSsrFlagHighLevel, expected 3002, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ obs_time = new GPSTimeSec().parse(parser); - corr_time = new GPSTimeSec().parse(parser); + iono_corr_time = new GPSTimeSec().parse(parser); + sat_corr_time = new GPSTimeSec().parse(parser); ssr_sol_id = parser.getU8(); tile_set_id = parser.getU16(); tile_id = parser.getU16(); @@ -137,7 +141,8 @@ protected void parse(Parser parser) throws SBPBinaryException { @Override protected void build(Builder builder) { obs_time.build(builder); - corr_time.build(builder); + iono_corr_time.build(builder); + sat_corr_time.build(builder); builder.putU8(ssr_sol_id); builder.putU16(tile_set_id); builder.putU16(tile_id); @@ -157,7 +162,8 @@ protected void build(Builder builder) { public JSONObject toJSON() { JSONObject obj = super.toJSON(); obj.put("obs_time", obs_time.toJSON()); - obj.put("corr_time", corr_time.toJSON()); + obj.put("iono_corr_time", iono_corr_time.toJSON()); + obj.put("sat_corr_time", sat_corr_time.toJSON()); obj.put("ssr_sol_id", ssr_sol_id); obj.put("tile_set_id", tile_set_id); obj.put("tile_id", tile_id); diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java new file mode 100644 index 0000000000..cd42303ec5 --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java @@ -0,0 +1,158 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +/** + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). + * + *

You can have MSG_SSR_FLAG_HIGH_LEVEL_DEP_A inherent its fields directly from an inherited SBP + * object, or construct it inline using a dict of its fields. + * + *

Deprecated. + */ +public class MsgSsrFlagHighLevelDepA extends SBPMessage { + public static final int TYPE = 0x0BB9; + + /** GNSS reference time of the observation used to generate the flag. */ + public GPSTimeSec obs_time; + + /** GNSS reference time of the correction associated to the flag. */ + public GPSTimeSec corr_time; + + /** SSR Solution ID. */ + public int ssr_sol_id; + + /** Unique identifier of the set this tile belongs to. */ + public int tile_set_id; + + /** Unique identifier of this tile in the tile set. */ + public int tile_id; + + /** Chain and type of flag. */ + public int chain_id; + + /** Use GPS satellites. */ + public int use_gps_sat; + + /** Use GAL satellites. */ + public int use_gal_sat; + + /** Use BDS satellites. */ + public int use_bds_sat; + + /** Use QZSS satellites. */ + public int use_qzss_sat; + + /** Reserved */ + public int[] reserved; + + /** Use tropo grid points. */ + public int use_tropo_grid_points; + + /** Use iono grid points. */ + public int use_iono_grid_points; + + /** Use iono tile satellite LoS. */ + public int use_iono_tile_sat_los; + + /** Use iono grid point satellite LoS. */ + public int use_iono_grid_point_sat_los; + + public MsgSsrFlagHighLevelDepA(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagHighLevelDepA() { + super(TYPE); + } + + public MsgSsrFlagHighLevelDepA(SBPMessage msg) throws SBPBinaryException { + super(msg); + if (msg.type != TYPE) + throw new SBPBinaryException( + "Type mismatch for MsgSsrFlagHighLevelDepA, expected 3001, actual " + msg.type); + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + obs_time = new GPSTimeSec().parse(parser); + corr_time = new GPSTimeSec().parse(parser); + ssr_sol_id = parser.getU8(); + tile_set_id = parser.getU16(); + tile_id = parser.getU16(); + chain_id = parser.getU8(); + use_gps_sat = parser.getU8(); + use_gal_sat = parser.getU8(); + use_bds_sat = parser.getU8(); + use_qzss_sat = parser.getU8(); + reserved = parser.getArrayofU8(5); + use_tropo_grid_points = parser.getU8(); + use_iono_grid_points = parser.getU8(); + use_iono_tile_sat_los = parser.getU8(); + use_iono_grid_point_sat_los = parser.getU8(); + } + + @Override + protected void build(Builder builder) { + obs_time.build(builder); + corr_time.build(builder); + builder.putU8(ssr_sol_id); + builder.putU16(tile_set_id); + builder.putU16(tile_id); + builder.putU8(chain_id); + builder.putU8(use_gps_sat); + builder.putU8(use_gal_sat); + builder.putU8(use_bds_sat); + builder.putU8(use_qzss_sat); + builder.putArrayofU8(reserved, 5); + builder.putU8(use_tropo_grid_points); + builder.putU8(use_iono_grid_points); + builder.putU8(use_iono_tile_sat_los); + builder.putU8(use_iono_grid_point_sat_los); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("obs_time", obs_time.toJSON()); + obj.put("corr_time", corr_time.toJSON()); + obj.put("ssr_sol_id", ssr_sol_id); + obj.put("tile_set_id", tile_set_id); + obj.put("tile_id", tile_id); + obj.put("chain_id", chain_id); + obj.put("use_gps_sat", use_gps_sat); + obj.put("use_gal_sat", use_gal_sat); + obj.put("use_bds_sat", use_bds_sat); + obj.put("use_qzss_sat", use_qzss_sat); + obj.put("reserved", new JSONArray(reserved)); + obj.put("use_tropo_grid_points", use_tropo_grid_points); + obj.put("use_iono_grid_points", use_iono_grid_points); + obj.put("use_iono_tile_sat_los", use_iono_tile_sat_los); + obj.put("use_iono_grid_point_sat_los", use_iono_grid_point_sat_los); + return obj; + } + + @Override + public String getFriendlyName() { + return "SSR FLAG HIGH LEVEL DEP A"; + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java new file mode 100644 index 0000000000..56d5f592c5 --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java @@ -0,0 +1,285 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevelDepA; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 104, + (byte) 1, + (byte) 0, + (byte) 0, + (byte) 6, + (byte) 0, + (byte) 10, + (byte) 20, + (byte) 0, + (byte) 30, + (byte) 0, + (byte) 40, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 4, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 5, + (byte) 6, + (byte) 7, + (byte) 8, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BB9, payload); + MsgSsrFlagHighLevelDepA msg = new MsgSsrFlagHighLevelDepA(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.chain_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.chain_id + "' != '" + 40 + "'", + value.equals(BigInteger.valueOf(40L))); + } else { + value = value.longValue(); + expected = 40L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.corr_time.tow; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.corr_time.tow + "' != '" + 360 + "'", + value.equals(BigInteger.valueOf(360L))); + } else { + value = value.longValue(); + expected = 360L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.corr_time.wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.corr_time.wn + "' != '" + 6 + "'", + value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.obs_time.tow; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.obs_time.tow + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.obs_time.wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.obs_time.wn + "' != '" + 3 + "'", + value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[0] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[1] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[2] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[3] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[4] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.ssr_sol_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.ssr_sol_id + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.tile_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.tile_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf(30L))); + } else { + value = value.longValue(); + expected = 30L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.tile_set_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.tile_set_id + "' != '" + 20 + "'", + value.equals(BigInteger.valueOf(20L))); + } else { + value = value.longValue(); + expected = 20L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_bds_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_bds_sat + "' != '" + 3 + "'", + value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_gal_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_gal_sat + "' != '" + 2 + "'", + value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_gps_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_gps_sat + "' != '" + 1 + "'", + value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_iono_grid_point_sat_los; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_iono_grid_point_sat_los + "' != '" + 8 + "'", + value.equals(BigInteger.valueOf(8L))); + } else { + value = value.longValue(); + expected = 8L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_iono_grid_points; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_iono_grid_points + "' != '" + 6 + "'", + value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_iono_tile_sat_los; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_iono_tile_sat_los + "' != '" + 7 + "'", + value.equals(BigInteger.valueOf(7L))); + } else { + value = value.longValue(); + expected = 7L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_qzss_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_qzss_sat + "' != '" + 4 + "'", + value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_tropo_grid_points; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_tropo_grid_points + "' != '" + 5 + "'", + value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + + org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java index 0579248903..c035eedb7f 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java @@ -38,6 +38,12 @@ public void test1() throws Throwable { (byte) 0, (byte) 3, (byte) 0, + (byte) 109, + (byte) 1, + (byte) 0, + (byte) 0, + (byte) 6, + (byte) 0, (byte) 104, (byte) 1, (byte) 0, @@ -64,7 +70,7 @@ public void test1() throws Throwable { (byte) 7, (byte) 8, }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BB9, payload); + SBPMessage sbp = new SBPMessage(0x0042, 0x0BBA, payload); MsgSsrFlagHighLevel msg = new MsgSsrFlagHighLevel(sbp); JSONObject json = msg.toJSON(); Number value; @@ -79,20 +85,20 @@ public void test1() throws Throwable { expected = 40L; org.junit.Assert.assertEquals(value, expected); } - value = msg.corr_time.tow; + value = msg.iono_corr_time.tow; if (value instanceof BigInteger) { org.junit.Assert.assertTrue( - "'" + msg.corr_time.tow + "' != '" + 360 + "'", - value.equals(BigInteger.valueOf(360L))); + "'" + msg.iono_corr_time.tow + "' != '" + 365 + "'", + value.equals(BigInteger.valueOf(365L))); } else { value = value.longValue(); - expected = 360L; + expected = 365L; org.junit.Assert.assertEquals(value, expected); } - value = msg.corr_time.wn; + value = msg.iono_corr_time.wn; if (value instanceof BigInteger) { org.junit.Assert.assertTrue( - "'" + msg.corr_time.wn + "' != '" + 6 + "'", + "'" + msg.iono_corr_time.wn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); } else { value = value.longValue(); @@ -169,6 +175,26 @@ public void test1() throws Throwable { expected = 0L; org.junit.Assert.assertEquals(value, expected); } + value = msg.sat_corr_time.tow; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.sat_corr_time.tow + "' != '" + 360 + "'", + value.equals(BigInteger.valueOf(360L))); + } else { + value = value.longValue(); + expected = 360L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.sat_corr_time.wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.sat_corr_time.wn + "' != '" + 6 + "'", + value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } value = msg.ssr_sol_id; if (value instanceof BigInteger) { org.junit.Assert.assertTrue( diff --git a/javascript/sbp.bundle.js b/javascript/sbp.bundle.js index dba6f3ed5e..408309f92e 100644 --- a/javascript/sbp.bundle.js +++ b/javascript/sbp.bundle.js @@ -1,2 +1,2 @@ /*! For license information please see sbp.bundle.js.LICENSE.txt */ -(()=>{var e={3322:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=p(278).GnssSignalDep,n=(p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT",this.fields=t||this.parser.parse(e.payload),this});(n.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT",n.prototype.msg_type=47,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:i.prototype.parser}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),n.prototype.fieldSpec.push(["cp","writeFloatLE",4]),n.prototype.fieldSpec.push(["cf","writeFloatLE",4]),n.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT_DEP_C",a.prototype.msg_type=31,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),a.prototype.fieldSpec.push(["cp","writeFloatLE",4]),a.prototype.fieldSpec.push(["cf","writeFloatLE",4]),a.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT_DEP_B",l.prototype.msg_type=20,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["snr","writeFloatLE",4]),l.prototype.fieldSpec.push(["cp","writeFloatLE",4]),l.prototype.fieldSpec.push(["cf","writeFloatLE",4]),l.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT_DEP_A",c.prototype.msg_type=21,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").uint8("prn"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["snr","writeFloatLE",4]),c.prototype.fieldSpec.push(["cp","writeFloatLE",4]),c.prototype.fieldSpec.push(["cf","writeFloatLE",4]),c.prototype.fieldSpec.push(["prn","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="AcqSvProfile",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="AcqSvProfile",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:i.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["job_type","writeUInt8",1]),u.prototype.fieldSpec.push(["status","writeUInt8",1]),u.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),u.prototype.fieldSpec.push(["int_time","writeUInt8",1]),u.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),u.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),u.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),u.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf","writeInt32LE",4]),u.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="AcqSvProfileDep",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="AcqSvProfileDep",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:s.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["job_type","writeUInt8",1]),y.prototype.fieldSpec.push(["status","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),y.prototype.fieldSpec.push(["int_time","writeUInt8",1]),y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),y.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),y.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),y.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf","writeInt32LE",4]),y.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE",f.prototype.msg_type=46,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:u.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["acq_sv_profile","array",u.prototype.fieldSpec,function(){return this.fields.array.length},null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE_DEP",d.prototype.msg_type=30,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:y.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["acq_sv_profile","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={47:n,MsgAcqResult:n,31:a,MsgAcqResultDepC:a,20:l,MsgAcqResultDepB:l,21:c,MsgAcqResultDepA:c,AcqSvProfile:u,AcqSvProfileDep:y,46:f,MsgAcqSvProfile:f,30:d,MsgAcqSvProfileDep:d}},6053:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",i.prototype.msg_type=179,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];let s=function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",s.prototype.msg_type=180,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("flags").string("version",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt32LE",4]),s.prototype.fieldSpec.push(["version","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_JUMP_TO_APP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_JUMP_TO_APP",n.prototype.msg_type=177,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("jump"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["jump","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_NAP_DEVICE_DNA_REQ",a.prototype.msg_type=222,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little"),a.prototype.fieldSpec=[];let l=function(e,t){return r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_NAP_DEVICE_DNA_RESP",l.prototype.msg_type=221,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").array("dna",{length:8,type:"uint8"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["dna","array","writeUInt8",function(){return 1},8]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",c.prototype.msg_type=176,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").array("handshake",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["handshake","array","writeUInt8",function(){return 1},null]),e.exports={179:i,MsgBootloaderHandshakeReq:i,180:s,MsgBootloaderHandshakeResp:s,177:n,MsgBootloaderJumpToApp:n,222:a,MsgNapDeviceDnaReq:a,221:l,MsgNapDeviceDnaResp:l,176:c,MsgBootloaderHandshakeDepA:c}},7224:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_EXT_EVENT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_EXT_EVENT",i.prototype.msg_type=257,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags").uint8("pin"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]),i.prototype.fieldSpec.push(["pin","writeUInt8",1]),e.exports={257:i,MsgExtEvent:i}},8986:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_REQ",i.prototype.msg_type=168,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").uint8("chunk_size").string("filename",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),i.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),i.prototype.fieldSpec.push(["chunk_size","writeUInt8",1]),i.prototype.fieldSpec.push(["filename","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_RESP",s.prototype.msg_type=163,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("sequence").array("contents",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),s.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_DIR_REQ",n.prototype.msg_type=169,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("dirname",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),n.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),n.prototype.fieldSpec.push(["dirname","string",null]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_DIR_RESP",a.prototype.msg_type=170,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("sequence").string("contents",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),a.prototype.fieldSpec.push(["contents","string",null]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_REMOVE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_REMOVE",l.prototype.msg_type=172,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("filename",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["filename","string",null]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_WRITE_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_WRITE_REQ",c.prototype.msg_type=173,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("filename",{greedy:!0}).array("data",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),c.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),c.prototype.fieldSpec.push(["filename","string",null]),c.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},null]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_WRITE_RESP",u.prototype.msg_type=171,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sequence"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_CONFIG_REQ",y.prototype.msg_type=4097,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sequence"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_CONFIG_RESP",f.prototype.msg_type=4098,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("window_size").uint32("batch_size").uint32("fileio_version"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),f.prototype.fieldSpec.push(["window_size","writeUInt32LE",4]),f.prototype.fieldSpec.push(["batch_size","writeUInt32LE",4]),f.prototype.fieldSpec.push(["fileio_version","writeUInt32LE",4]),e.exports={168:i,MsgFileioReadReq:i,163:s,MsgFileioReadResp:s,169:n,MsgFileioReadDirReq:n,170:a,MsgFileioReadDirResp:a,172:l,MsgFileioRemove:l,173:c,MsgFileioWriteReq:c,171:u,MsgFileioWriteResp:u,4097:y,MsgFileioConfigReq:y,4098:f,MsgFileioConfigResp:f}},6667:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_PROGRAM",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_PROGRAM",i.prototype.msg_type=230,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len").array("data",{type:"uint8",length:"addr_len"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["target","writeUInt8",1]),i.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),i.prototype.fieldSpec.push(["addr_len","writeUInt8",1]),i.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},"addr_len"]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_DONE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_DONE",s.prototype.msg_type=224,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("response"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["response","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_READ_REQ",n.prototype.msg_type=231,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["target","writeUInt8",1]),n.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),n.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_READ_RESP",a.prototype.msg_type=225,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["target","writeUInt8",1]),a.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),a.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_ERASE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_ERASE",l.prototype.msg_type=226,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("target").uint32("sector_num"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["target","writeUInt8",1]),l.prototype.fieldSpec.push(["sector_num","writeUInt32LE",4]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_STM_FLASH_LOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_STM_FLASH_LOCK_SECTOR",c.prototype.msg_type=227,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sector"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_STM_FLASH_UNLOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_STM_FLASH_UNLOCK_SECTOR",u.prototype.msg_type=228,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sector"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_STM_UNIQUE_ID_REQ",y.prototype.msg_type=232,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_STM_UNIQUE_ID_RESP",f.prototype.msg_type=229,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("stm_id",{length:12,type:"uint8"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["stm_id","array","writeUInt8",function(){return 1},12]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_M25_FLASH_WRITE_STATUS",d.prototype.msg_type=243,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("status",{length:1,type:"uint8"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["status","array","writeUInt8",function(){return 1},1]),e.exports={230:i,MsgFlashProgram:i,224:s,MsgFlashDone:s,231:n,MsgFlashReadReq:n,225:a,MsgFlashReadResp:a,226:l,MsgFlashErase:l,227:c,MsgStmFlashLockSector:c,228:u,MsgStmFlashUnlockSector:u,232:y,MsgStmUniqueIdReq:y,229:f,MsgStmUniqueIdResp:f,243:d,MsgM25FlashWriteStatus:d}},278:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="GnssSignal",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="GnssSignal",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("sat").uint8("code"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sat","writeUInt8",1]),i.prototype.fieldSpec.push(["code","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="SvId",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="SvId",s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("satId").uint8("constellation"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["satId","writeUInt8",1]),s.prototype.fieldSpec.push(["constellation","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="GnssSignalDep",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="GnssSignalDep",n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("sat").uint8("code").uint8("reserved"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["sat","writeUInt16LE",2]),n.prototype.fieldSpec.push(["code","writeUInt8",1]),n.prototype.fieldSpec.push(["reserved","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="GPSTimeDep",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="GPSTimeDep",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("tow").uint16("wn"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["wn","writeUInt16LE",2]);let l=function(e,t){return r.call(this,e),this.messageType="GPSTimeSec",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="GPSTimeSec",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint32("tow").uint16("wn"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),l.prototype.fieldSpec.push(["wn","writeUInt16LE",2]);let c=function(e,t){return r.call(this,e),this.messageType="GPSTime",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="GPSTime",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("tow").int32("ns_residual").uint16("wn"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),c.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),c.prototype.fieldSpec.push(["wn","writeUInt16LE",2]);let u=function(e,t){return r.call(this,e),this.messageType="CarrierPhase",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="CarrierPhase",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").int32("i").uint8("f"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["i","writeInt32LE",4]),u.prototype.fieldSpec.push(["f","writeUInt8",1]),e.exports={GnssSignal:i,SvId:s,GnssSignalDep:n,GPSTimeDep:a,GPSTimeSec:l,GPSTime:c,CarrierPhase:u}},3276:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_IMU_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_IMU_RAW",i.prototype.msg_type=2304,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("acc_x").int16("acc_y").int16("acc_z").int16("gyr_x").int16("gyr_y").int16("gyr_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["acc_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_z","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_z","writeInt16LE",2]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_IMU_AUX",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_IMU_AUX",s.prototype.msg_type=2305,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("imu_type").int16("temp").uint8("imu_conf"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["imu_type","writeUInt8",1]),s.prototype.fieldSpec.push(["temp","writeInt16LE",2]),s.prototype.fieldSpec.push(["imu_conf","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_IMU_COMP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_IMU_COMP",n.prototype.msg_type=2309,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint64("time").uint16("flags").int32("acc_comp_x").int32("acc_comp_y").int32("acc_comp_z").int32("gyr_comp_x").int32("gyr_comp_y").int32("gyr_comp_z"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["time","writeUInt64LE",8]),n.prototype.fieldSpec.push(["flags","writeUInt16LE",2]),n.prototype.fieldSpec.push(["acc_comp_x","writeInt32LE",4]),n.prototype.fieldSpec.push(["acc_comp_y","writeInt32LE",4]),n.prototype.fieldSpec.push(["acc_comp_z","writeInt32LE",4]),n.prototype.fieldSpec.push(["gyr_comp_x","writeInt32LE",4]),n.prototype.fieldSpec.push(["gyr_comp_y","writeInt32LE",4]),n.prototype.fieldSpec.push(["gyr_comp_z","writeInt32LE",4]),e.exports={2304:i,MsgImuRaw:i,2305:s,MsgImuAux:s,2309:n,MsgImuComp:n}},8958:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal,p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec),s=p(278).SvId,n=function(e,t){return r.call(this,e),this.messageType="IntegritySSRHeader",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="IntegritySSRHeader",n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),n.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),n.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),n.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),n.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["chain_id","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_HIGH_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_HIGH_LEVEL",a.prototype.msg_type=3001,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).nest("corr_time",{type:i.prototype.parser}).uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id").uint8("use_gps_sat").uint8("use_gal_sat").uint8("use_bds_sat").uint8("use_qzss_sat").array("reserved",{length:5,type:"uint8"}).uint8("use_tropo_grid_points").uint8("use_iono_grid_points").uint8("use_iono_tile_sat_los").uint8("use_iono_grid_point_sat_los"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["corr_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),a.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gps_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gal_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_bds_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_qzss_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},5]),a.prototype.fieldSpec.push(["use_tropo_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_tile_sat_los","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_point_sat_los","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_SATELLITES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_SATELLITES",l.prototype.msg_type=3005,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint8("chain_id").uint8("const_id").uint8("n_faulty_sats").array("faulty_sats",{type:"uint8",length:"n_faulty_sats"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),l.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),l.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),l.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),l.prototype.fieldSpec.push(["const_id","writeUInt8",1]),l.prototype.fieldSpec.push(["n_faulty_sats","writeUInt8",1]),l.prototype.fieldSpec.push(["faulty_sats","array","writeUInt8",function(){return 1},"n_faulty_sats"]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",c.prototype.msg_type=3011,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),c.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),c.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",u.prototype.msg_type=3015,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),u.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",y.prototype.msg_type=3021,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),y.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",f.prototype.msg_type=3025,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint16("grid_point_id").uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),f.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),f.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),f.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_ACKNOWLEDGE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_ACKNOWLEDGE",d.prototype.msg_type=3026,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("request_id").uint32("area_id").uint8("response_code").uint16("correction_mask_on_demand").uint16("correction_mask_stream").uint8("solution_id"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["request_id","writeUInt8",1]),d.prototype.fieldSpec.push(["area_id","writeUInt32LE",4]),d.prototype.fieldSpec.push(["response_code","writeUInt8",1]),d.prototype.fieldSpec.push(["correction_mask_on_demand","writeUInt16LE",2]),d.prototype.fieldSpec.push(["correction_mask_stream","writeUInt16LE",2]),d.prototype.fieldSpec.push(["solution_id","writeUInt8",1]),e.exports={IntegritySSRHeader:n,3001:a,MsgSsrFlagHighLevel:a,3005:l,MsgSsrFlagSatellites:l,3011:c,MsgSsrFlagTropoGridPoints:c,3015:u,MsgSsrFlagIonoGridPoints:u,3021:y,MsgSsrFlagIonoTileSatLos:y,3025:f,MsgSsrFlagIonoGridPointSatLos:f,3026:d,MsgAcknowledge:d}},6747:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_CPU_STATE_DEP_A",i.prototype.msg_type=32512,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").string("tname",{length:15}).string("cmdline",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["index","writeUInt8",1]),i.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),i.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),i.prototype.fieldSpec.push(["tname","string",15]),i.prototype.fieldSpec.push(["cmdline","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_MEM_STATE_DEP_A",s.prototype.msg_type=32513,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").string("tname",{length:15}).string("cmdline",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["index","writeUInt8",1]),s.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),s.prototype.fieldSpec.push(["pmem","writeUInt8",1]),s.prototype.fieldSpec.push(["tname","string",15]),s.prototype.fieldSpec.push(["cmdline","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SYS_STATE_DEP_A",n.prototype.msg_type=32514,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),n.prototype.fieldSpec.push(["pmem","writeUInt8",1]),n.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),n.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",a.prototype.msg_type=32515,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("socket_count").uint16("socket_types").uint16("socket_states").string("cmdline",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["index","writeUInt8",1]),a.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_count","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),a.prototype.fieldSpec.push(["cmdline","string",null]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",l.prototype.msg_type=32516,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("recv_queued").uint16("send_queued").uint16("socket_types").uint16("socket_states").string("address_of_largest",{length:64}).string("cmdline",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["index","writeUInt8",1]),l.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),l.prototype.fieldSpec.push(["recv_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["send_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),l.prototype.fieldSpec.push(["address_of_largest","string",64]),l.prototype.fieldSpec.push(["cmdline","string",null]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_SOCKET_USAGE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SOCKET_USAGE",c.prototype.msg_type=32517,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("avg_queue_depth").uint32("max_queue_depth").array("socket_state_counts",{length:16,type:"uint16le"}).array("socket_type_counts",{length:16,type:"uint16le"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["avg_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["max_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["socket_state_counts","array","writeUInt16LE",function(){return 2},16]),c.prototype.fieldSpec.push(["socket_type_counts","array","writeUInt16LE",function(){return 2},16]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_COUNT",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_FD_COUNT",u.prototype.msg_type=32518,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("fd_count").string("cmdline",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt8",1]),u.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),u.prototype.fieldSpec.push(["fd_count","writeUInt16LE",2]),u.prototype.fieldSpec.push(["cmdline","string",null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_SUMMARY",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_FD_SUMMARY",y.prototype.msg_type=32519,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sys_fd_count").string("most_opened",{greedy:!0}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sys_fd_count","writeUInt32LE",4]),y.prototype.fieldSpec.push(["most_opened","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_CPU_STATE",f.prototype.msg_type=32520,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["index","writeUInt8",1]),f.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),f.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),f.prototype.fieldSpec.push(["time","writeUInt32LE",4]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["tname","string",15]),f.prototype.fieldSpec.push(["cmdline","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_MEM_STATE",d.prototype.msg_type=32521,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["index","writeUInt8",1]),d.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pmem","writeUInt8",1]),d.prototype.fieldSpec.push(["time","writeUInt32LE",4]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]),d.prototype.fieldSpec.push(["tname","string",15]),d.prototype.fieldSpec.push(["cmdline","string",null]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SYS_STATE",h.prototype.msg_type=32522,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count").uint32("time").uint8("flags"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),h.prototype.fieldSpec.push(["pmem","writeUInt8",1]),h.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),h.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]),h.prototype.fieldSpec.push(["time","writeUInt32LE",4]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={32512:i,MsgLinuxCpuStateDepA:i,32513:s,MsgLinuxMemStateDepA:s,32514:n,MsgLinuxSysStateDepA:n,32515:a,MsgLinuxProcessSocketCounts:a,32516:l,MsgLinuxProcessSocketQueues:l,32517:c,MsgLinuxSocketUsage:c,32518:u,MsgLinuxProcessFdCount:u,32519:y,MsgLinuxProcessFdSummary:y,32520:f,MsgLinuxCpuState:f,32521:d,MsgLinuxMemState:d,32522:h,MsgLinuxSysState:h}},8556:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LOG",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_LOG",i.prototype.msg_type=1025,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("level").string("text",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["level","writeUInt8",1]),i.prototype.fieldSpec.push(["text","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_FWD",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_FWD",s.prototype.msg_type=1026,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("source").uint8("protocol").array("fwd_payload",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["protocol","writeUInt8",1]),s.prototype.fieldSpec.push(["fwd_payload","array","writeUInt8",function(){return 1},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_PRINT_DEP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_PRINT_DEP",n.prototype.msg_type=16,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").string("text",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["text","string",null]),e.exports={1025:i,MsgLog:i,1026:s,MsgFwd:s,16:n,MsgPrintDep:n}},3574:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_MAG_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_MAG_RAW",i.prototype.msg_type=2306,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("mag_x").int16("mag_y").int16("mag_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["mag_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_z","writeInt16LE",2]),e.exports={2306:i,MsgMagRaw:i}},8248:(e,t,p)=>{e=p.nmd(e);var r=p(7052).i,o=(p(3627),p(4789),p(7238)),i=[0,4129,8258,12387,16516,20645,24774,28903,33032,37161,41290,45419,49548,53677,57806,61935,4657,528,12915,8786,21173,17044,29431,25302,37689,33560,45947,41818,54205,50076,62463,58334,9314,13379,1056,5121,25830,29895,17572,21637,42346,46411,34088,38153,58862,62927,50604,54669,13907,9842,5649,1584,30423,26358,22165,18100,46939,42874,38681,34616,63455,59390,55197,51132,18628,22757,26758,30887,2112,6241,10242,14371,51660,55789,59790,63919,35144,39273,43274,47403,23285,19156,31415,27286,6769,2640,14899,10770,56317,52188,64447,60318,39801,35672,47931,43802,27814,31879,19684,23749,11298,15363,3168,7233,60846,64911,52716,56781,44330,48395,36200,40265,32407,28342,24277,20212,15891,11826,7761,3696,65439,61374,57309,53244,48923,44858,40793,36728,37256,33193,45514,41451,53516,49453,61774,57711,4224,161,12482,8419,20484,16421,28742,24679,33721,37784,41979,46042,49981,54044,58239,62302,689,4752,8947,13010,16949,21012,25207,29270,46570,42443,38312,34185,62830,58703,54572,50445,13538,9411,5280,1153,29798,25671,21540,17413,42971,47098,34713,38840,59231,63358,50973,55100,9939,14066,1681,5808,26199,30326,17941,22068,55628,51565,63758,59695,39368,35305,47498,43435,22596,18533,30726,26663,6336,2273,14466,10403,52093,56156,60223,64286,35833,39896,43963,48026,19061,23124,27191,31254,2801,6864,10931,14994,64814,60687,56684,52557,48554,44427,40424,36297,31782,27655,23652,19525,15522,11395,7392,3265,61215,65342,53085,57212,44955,49082,36825,40952,28183,32310,20053,24180,11923,16050,3793,7920],s=function(e,t){for(var p in t)t.hasOwnProperty(p)&&(e[p]=t[p]);return e};function n(e){this.name="ParameterValidationError",this.message=e,this.stack=(new Error).stack}function a(e){this.name="BufferTooShortError",this.message=e,this.stack=(new Error).stack}function l(e){this.name="BufferCorruptError",this.message=e,this.stack=(new Error).stack}n.prototype=Object.create(Error.prototype),n.prototype.constructor=n,a.prototype=Object.create(Error.prototype),a.prototype.constructor=a,l.prototype=Object.create(Error.prototype),l.prototype.constructor=l;var c={acquisition:p(3322),bootload:p(6053),ext_events:p(7224),file_io:p(8986),flash:p(6667),gnss:p(278),imu:p(3276),integrity:p(8958),linux:p(6747),logging:p(8556),mag:p(3574),navigation:p(4539),ndb:p(309),observation:p(4399),orientation:p(2623),piksi:p(9757),profiling:p(2827),sbas:p(5232),settings:p(4120),signings:p(9286),solution_meta:p(848),ssr:p(9269),system:p(2644),tracking:p(752),user:p(5562),vehicle:p(7293),telemetry:p(3894)},u=Object.keys(c).reduce((function(e,t){var p=c[t],r={};return Object.keys(p).forEach((function(e){parseInt(e)==e&&(r[e]=p[e])})),s(e,r)}),{}),y=Object.keys(c).reduce((function(e,t){var p=c[t],r={};return Object.keys(p).forEach((function(e){if(parseInt(e)!=e){var t=p[e].prototype.messageType||e;r[t]=p[e]}})),s(e,r)}),{}),f=(new r).endianess("little").uint8("preamble").uint16("msg_type").uint16("sender").uint8("length").buffer("payload",{length:"length"}).uint16("crc");function d(e,t){t=t||0;for(let p of e)t=t<<8&65535^i[t>>8&255^255&p],t&=65535;return t}e.exports={preambleByte:85,crc16:d,sbpIdTable:u,sbpMessageTypesTable:y,decode:function(e){var t=f.parse(e),p=u[t.msg_type];return void 0===p?(console.log("Unknown message type: ",t.msg_type),new o(t)):new p(t)},dispatch:function(t,p,r){var o,i,s=new Buffer(0);if(void 0===r&&"function"==typeof p?o=p:(o=r,i=p),i&&!Array.isArray(i)&&-1===["function","number"].indexOf(typeof i))throw n("dispatch: messageWhitelist must be function, number, or array");var c=function(p){t.pause();try{if((s=Buffer.concat([s,p])).length<2)return;var r=function(){var t,p,r,o,n,c,u;for(u=0;us.length)throw new a;t=s.slice(u+1,u+6),r=s.readUInt16LE(u+1),_=s.readUInt16LE(u+3),o=s.readUInt8(u+5);var y=i&&Array.isArray(i)&&-1!==i.indexOf(r),f=i&&"number"==typeof i&&i&r,h=i&&"function"==typeof i&&i(r);if(i&&!(y||f||h))return s=s.slice(u+6+o+2),null;if(u+8+o>s.length)throw new a;c=d(s.slice(u+6,u+6+o),d(t)),n=s.readUInt16LE(u+6+o);var S=s.slice(u,u+6+o+2);if(n===c)return s=s.slice(u+6+o+2),[e.exports.decode(S),S];throw s=s.slice(u+1),new l}();if(null===r)return;var n=r[0],u=r[1];o(null,n,u)}catch(e){if(!(e instanceof a||e instanceof l))throw e}finally{t.resume(),s.length>0&&setTimeout((function(){c(new Buffer(0))}),0)}};t.on("data",c)}},function(r){var o={function:!0,object:!0},i=o[typeof window]&&window||this,s=o[typeof t]&&t&&!t.nodeType&&t,n=o.object&&e&&!e.nodeType&&e,a=s&&n&&"object"==typeof p.g&&p.g;!a||a.global!==a&&a.window!==a&&a.self!==a||(i=a),i.SBP=r}(e.exports)},4539:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_GPS_TIME",i.prototype.msg_type=258,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_GPS_TIME_GNSS",s.prototype.msg_type=260,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_TIME",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_UTC_TIME",n.prototype.msg_type=259,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt8",1]),n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["year","writeUInt16LE",2]),n.prototype.fieldSpec.push(["month","writeUInt8",1]),n.prototype.fieldSpec.push(["day","writeUInt8",1]),n.prototype.fieldSpec.push(["hours","writeUInt8",1]),n.prototype.fieldSpec.push(["minutes","writeUInt8",1]),n.prototype.fieldSpec.push(["seconds","writeUInt8",1]),n.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_UTC_TIME_GNSS",a.prototype.msg_type=261,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]),a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["year","writeUInt16LE",2]),a.prototype.fieldSpec.push(["month","writeUInt8",1]),a.prototype.fieldSpec.push(["day","writeUInt8",1]),a.prototype.fieldSpec.push(["hours","writeUInt8",1]),a.prototype.fieldSpec.push(["minutes","writeUInt8",1]),a.prototype.fieldSpec.push(["seconds","writeUInt8",1]),a.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_DOPS",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_DOPS",l.prototype.msg_type=520,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),l.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["flags","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF",c.prototype.msg_type=521,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),c.prototype.fieldSpec.push(["x","writeDoubleLE",8]),c.prototype.fieldSpec.push(["y","writeDoubleLE",8]),c.prototype.fieldSpec.push(["z","writeDoubleLE",8]),c.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),c.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),c.prototype.fieldSpec.push(["flags","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_COV",u.prototype.msg_type=532,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),u.prototype.fieldSpec.push(["x","writeDoubleLE",8]),u.prototype.fieldSpec.push(["y","writeDoubleLE",8]),u.prototype.fieldSpec.push(["z","writeDoubleLE",8]),u.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),u.prototype.fieldSpec.push(["flags","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH",y.prototype.msg_type=522,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),y.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),y.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),y.prototype.fieldSpec.push(["height","writeDoubleLE",8]),y.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),y.prototype.fieldSpec.push(["flags","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_COV",f.prototype.msg_type=529,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),f.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),f.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),f.prototype.fieldSpec.push(["height","writeDoubleLE",8]),f.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),f.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="EstimatedHorizontalErrorEllipse",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").floatle("semi_major").floatle("semi_minor").floatle("orientation"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["semi_major","writeFloatLE",4]),d.prototype.fieldSpec.push(["semi_minor","writeFloatLE",4]),d.prototype.fieldSpec.push(["orientation","writeFloatLE",4]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_ACC",h.prototype.msg_type=536,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").doublele("orthometric_height").floatle("h_accuracy").floatle("v_accuracy").floatle("ct_accuracy").floatle("at_accuracy").nest("h_ellipse",{type:d.prototype.parser}).uint8("confidence_and_geoid").uint8("n_sats").uint8("flags"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),h.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),h.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),h.prototype.fieldSpec.push(["height","writeDoubleLE",8]),h.prototype.fieldSpec.push(["orthometric_height","writeDoubleLE",8]),h.prototype.fieldSpec.push(["h_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["v_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["ct_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["at_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["h_ellipse",d.prototype.fieldSpec]),h.prototype.fieldSpec.push(["confidence_and_geoid","writeUInt8",1]),h.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_ECEF",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_ECEF",_.prototype.msg_type=523,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),_.prototype.fieldSpec.push(["x","writeInt32LE",4]),_.prototype.fieldSpec.push(["y","writeInt32LE",4]),_.prototype.fieldSpec.push(["z","writeInt32LE",4]),_.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),_.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_NED",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_NED",S.prototype.msg_type=524,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),S.prototype.fieldSpec.push(["n","writeInt32LE",4]),S.prototype.fieldSpec.push(["e","writeInt32LE",4]),S.prototype.fieldSpec.push(["d","writeInt32LE",4]),S.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);let g=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF",g.prototype.msg_type=525,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),g.prototype.fieldSpec.push(["x","writeInt32LE",4]),g.prototype.fieldSpec.push(["y","writeInt32LE",4]),g.prototype.fieldSpec.push(["z","writeInt32LE",4]),g.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),g.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt8",1]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_COV",w.prototype.msg_type=533,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),w.prototype.fieldSpec.push(["x","writeInt32LE",4]),w.prototype.fieldSpec.push(["y","writeInt32LE",4]),w.prototype.fieldSpec.push(["z","writeInt32LE",4]),w.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]);let E=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED",E.prototype.msg_type=526,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),E.prototype.fieldSpec.push(["n","writeInt32LE",4]),E.prototype.fieldSpec.push(["e","writeInt32LE",4]),E.prototype.fieldSpec.push(["d","writeInt32LE",4]),E.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),E.prototype.fieldSpec.push(["flags","writeUInt8",1]);let m=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_COV",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_COV",m.prototype.msg_type=530,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),m.prototype.fieldSpec.push(["n","writeInt32LE",4]),m.prototype.fieldSpec.push(["e","writeInt32LE",4]),m.prototype.fieldSpec.push(["d","writeInt32LE",4]),m.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),m.prototype.fieldSpec.push(["flags","writeUInt8",1]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_GNSS",b.prototype.msg_type=553,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),b.prototype.fieldSpec.push(["x","writeDoubleLE",8]),b.prototype.fieldSpec.push(["y","writeDoubleLE",8]),b.prototype.fieldSpec.push(["z","writeDoubleLE",8]),b.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["flags","writeUInt8",1]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_COV_GNSS",I.prototype.msg_type=564,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),I.prototype.fieldSpec.push(["x","writeDoubleLE",8]),I.prototype.fieldSpec.push(["y","writeDoubleLE",8]),I.prototype.fieldSpec.push(["z","writeDoubleLE",8]),I.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),I.prototype.fieldSpec.push(["flags","writeUInt8",1]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_GNSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_GNSS",L.prototype.msg_type=554,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),L.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),L.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),L.prototype.fieldSpec.push(["height","writeDoubleLE",8]),L.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),L.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),L.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),L.prototype.fieldSpec.push(["flags","writeUInt8",1]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_COV_GNSS",T.prototype.msg_type=561,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),T.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),T.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),T.prototype.fieldSpec.push(["height","writeDoubleLE",8]),T.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),T.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),T.prototype.fieldSpec.push(["flags","writeUInt8",1]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_GNSS",v.prototype.msg_type=557,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),v.prototype.fieldSpec.push(["x","writeInt32LE",4]),v.prototype.fieldSpec.push(["y","writeInt32LE",4]),v.prototype.fieldSpec.push(["z","writeInt32LE",4]),v.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),v.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),v.prototype.fieldSpec.push(["flags","writeUInt8",1]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_COV_GNSS",U.prototype.msg_type=565,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),U.prototype.fieldSpec.push(["x","writeInt32LE",4]),U.prototype.fieldSpec.push(["y","writeInt32LE",4]),U.prototype.fieldSpec.push(["z","writeInt32LE",4]),U.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),U.prototype.fieldSpec.push(["flags","writeUInt8",1]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_GNSS",O.prototype.msg_type=558,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),O.prototype.fieldSpec.push(["n","writeInt32LE",4]),O.prototype.fieldSpec.push(["e","writeInt32LE",4]),O.prototype.fieldSpec.push(["d","writeInt32LE",4]),O.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),O.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),O.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),O.prototype.fieldSpec.push(["flags","writeUInt8",1]);let M=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_COV_GNSS",M.prototype.msg_type=562,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),M.prototype.fieldSpec.push(["n","writeInt32LE",4]),M.prototype.fieldSpec.push(["e","writeInt32LE",4]),M.prototype.fieldSpec.push(["d","writeInt32LE",4]),M.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),M.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),M.prototype.fieldSpec.push(["flags","writeUInt8",1]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_VEL_BODY",D.prototype.msg_type=531,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),D.prototype.fieldSpec.push(["x","writeInt32LE",4]),D.prototype.fieldSpec.push(["y","writeInt32LE",4]),D.prototype.fieldSpec.push(["z","writeInt32LE",4]),D.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),D.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),D.prototype.fieldSpec.push(["flags","writeUInt8",1]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_VEL_COG",A.prototype.msg_type=540,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint32("tow").uint32("cog").uint32("sog").int32("v_up").uint32("cog_accuracy").uint32("sog_accuracy").uint32("v_up_accuracy").uint16("flags"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),A.prototype.fieldSpec.push(["cog","writeUInt32LE",4]),A.prototype.fieldSpec.push(["sog","writeUInt32LE",4]),A.prototype.fieldSpec.push(["v_up","writeInt32LE",4]),A.prototype.fieldSpec.push(["cog_accuracy","writeUInt32LE",4]),A.prototype.fieldSpec.push(["sog_accuracy","writeUInt32LE",4]),A.prototype.fieldSpec.push(["v_up_accuracy","writeUInt32LE",4]),A.prototype.fieldSpec.push(["flags","writeUInt16LE",2]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_AGE_CORRECTIONS",G.prototype.msg_type=528,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").uint32("tow").uint16("age"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),G.prototype.fieldSpec.push(["age","writeUInt16LE",2]);let C=function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="MSG_GPS_TIME_DEP_A",C.prototype.msg_type=256,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),C.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),C.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),C.prototype.fieldSpec.push(["flags","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_DOPS_DEP_A",j.prototype.msg_type=518,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),j.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]);let P=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_DEP_A",P.prototype.msg_type=512,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),P.prototype.fieldSpec.push(["x","writeDoubleLE",8]),P.prototype.fieldSpec.push(["y","writeDoubleLE",8]),P.prototype.fieldSpec.push(["z","writeDoubleLE",8]),P.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),P.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),P.prototype.fieldSpec.push(["flags","writeUInt8",1]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_DEP_A",R.prototype.msg_type=513,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),R.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),R.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),R.prototype.fieldSpec.push(["height","writeDoubleLE",8]),R.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),R.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),R.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),R.prototype.fieldSpec.push(["flags","writeUInt8",1]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_ECEF_DEP_A",N.prototype.msg_type=514,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),N.prototype.fieldSpec.push(["x","writeInt32LE",4]),N.prototype.fieldSpec.push(["y","writeInt32LE",4]),N.prototype.fieldSpec.push(["z","writeInt32LE",4]),N.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),N.prototype.fieldSpec.push(["flags","writeUInt8",1]);let x=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_NED_DEP_A",x.prototype.msg_type=515,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),x.prototype.fieldSpec.push(["n","writeInt32LE",4]),x.prototype.fieldSpec.push(["e","writeInt32LE",4]),x.prototype.fieldSpec.push(["d","writeInt32LE",4]),x.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),x.prototype.fieldSpec.push(["flags","writeUInt8",1]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_DEP_A",F.prototype.msg_type=516,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),F.prototype.fieldSpec.push(["x","writeInt32LE",4]),F.prototype.fieldSpec.push(["y","writeInt32LE",4]),F.prototype.fieldSpec.push(["z","writeInt32LE",4]),F.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),F.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),F.prototype.fieldSpec.push(["flags","writeUInt8",1]);let k=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_DEP_A",k.prototype.msg_type=517,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),k.prototype.fieldSpec.push(["n","writeInt32LE",4]),k.prototype.fieldSpec.push(["e","writeInt32LE",4]),k.prototype.fieldSpec.push(["d","writeInt32LE",4]),k.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["flags","writeUInt8",1]);let B=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_HEADING_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_HEADING_DEP_A",B.prototype.msg_type=519,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),B.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),B.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),B.prototype.fieldSpec.push(["flags","writeUInt8",1]);let q=function(e,t){return r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="MSG_PROTECTION_LEVEL_DEP_A",q.prototype.msg_type=534,q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("tow").uint16("vpl").uint16("hpl").doublele("lat").doublele("lon").doublele("height").uint8("flags"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),q.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),q.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),q.prototype.fieldSpec.push(["height","writeDoubleLE",8]),q.prototype.fieldSpec.push(["flags","writeUInt8",1]);let z=function(e,t){return r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="MSG_PROTECTION_LEVEL",z.prototype.msg_type=535,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("tow").int16("wn").uint16("hpl").uint16("vpl").uint16("atpl").uint16("ctpl").uint16("hvpl").uint16("vvpl").uint16("hopl").uint16("popl").uint16("ropl").doublele("lat").doublele("lon").doublele("height").int32("v_x").int32("v_y").int32("v_z").int32("roll").int32("pitch").int32("heading").uint32("flags"),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),z.prototype.fieldSpec.push(["wn","writeInt16LE",2]),z.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["atpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ctpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hopl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["popl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ropl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),z.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),z.prototype.fieldSpec.push(["height","writeDoubleLE",8]),z.prototype.fieldSpec.push(["v_x","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_y","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_z","writeInt32LE",4]),z.prototype.fieldSpec.push(["roll","writeInt32LE",4]),z.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),z.prototype.fieldSpec.push(["heading","writeInt32LE",4]),z.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let V=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_LEAP_SECOND",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="MSG_UTC_LEAP_SECOND",V.prototype.msg_type=570,V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").int16("reserved_0").int16("reserved_1").int8("reserved_2").int8("count_before").uint16("reserved_3").uint16("reserved_4").uint16("ref_wn").uint8("ref_dn").int8("count_after"),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["reserved_0","writeInt16LE",2]),V.prototype.fieldSpec.push(["reserved_1","writeInt16LE",2]),V.prototype.fieldSpec.push(["reserved_2","writeInt8",1]),V.prototype.fieldSpec.push(["count_before","writeInt8",1]),V.prototype.fieldSpec.push(["reserved_3","writeUInt16LE",2]),V.prototype.fieldSpec.push(["reserved_4","writeUInt16LE",2]),V.prototype.fieldSpec.push(["ref_wn","writeUInt16LE",2]),V.prototype.fieldSpec.push(["ref_dn","writeUInt8",1]),V.prototype.fieldSpec.push(["count_after","writeInt8",1]);let H=function(e,t){return r.call(this,e),this.messageType="MSG_REFERENCE_FRAME_PARAM",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_REFERENCE_FRAME_PARAM",H.prototype.msg_type=580,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").uint8("ssr_iod").string("sn",{length:32}).string("tn",{length:32}).uint8("sin").uint16("utn").uint16("re_t0").int32("delta_X0").int32("delta_Y0").int32("delta_Z0").int32("theta_01").int32("theta_02").int32("theta_03").int32("scale").int32("dot_delta_X0").int32("dot_delta_Y0").int32("dot_delta_Z0").int32("dot_theta_01").int32("dot_theta_02").int32("dot_theta_03").int16("dot_scale"),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),H.prototype.fieldSpec.push(["sn","string",32]),H.prototype.fieldSpec.push(["tn","string",32]),H.prototype.fieldSpec.push(["sin","writeUInt8",1]),H.prototype.fieldSpec.push(["utn","writeUInt16LE",2]),H.prototype.fieldSpec.push(["re_t0","writeUInt16LE",2]),H.prototype.fieldSpec.push(["delta_X0","writeInt32LE",4]),H.prototype.fieldSpec.push(["delta_Y0","writeInt32LE",4]),H.prototype.fieldSpec.push(["delta_Z0","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_01","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_02","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_03","writeInt32LE",4]),H.prototype.fieldSpec.push(["scale","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_X0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_Y0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_Z0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_01","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_02","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_03","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_scale","writeInt16LE",2]);let $=function(e,t){return r.call(this,e),this.messageType="MSG_POSE_RELATIVE",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_POSE_RELATIVE",$.prototype.msg_type=581,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").uint32("tow").uint8("sensor_id").uint32("timestamp_1").uint32("timestamp_2").array("trans",{length:3,type:"int32le"}).int32("w").int32("x").int32("y").int32("z").floatle("cov_r_x_x").floatle("cov_r_x_y").floatle("cov_r_x_z").floatle("cov_r_y_y").floatle("cov_r_y_z").floatle("cov_r_z_z").floatle("cov_c_x_x").floatle("cov_c_x_y").floatle("cov_c_x_z").floatle("cov_c_y_y").floatle("cov_c_y_z").floatle("cov_c_z_z").uint8("flags"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),$.prototype.fieldSpec.push(["sensor_id","writeUInt8",1]),$.prototype.fieldSpec.push(["timestamp_1","writeUInt32LE",4]),$.prototype.fieldSpec.push(["timestamp_2","writeUInt32LE",4]),$.prototype.fieldSpec.push(["trans","array","writeInt32LE",function(){return 4},3]),$.prototype.fieldSpec.push(["w","writeInt32LE",4]),$.prototype.fieldSpec.push(["x","writeInt32LE",4]),$.prototype.fieldSpec.push(["y","writeInt32LE",4]),$.prototype.fieldSpec.push(["z","writeInt32LE",4]),$.prototype.fieldSpec.push(["cov_r_x_x","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_x_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_x_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_y_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_y_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_z_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_x_x","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_x_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_x_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_y_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_y_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_z_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={258:i,MsgGpsTime:i,260:s,MsgGpsTimeGnss:s,259:n,MsgUtcTime:n,261:a,MsgUtcTimeGnss:a,520:l,MsgDops:l,521:c,MsgPosEcef:c,532:u,MsgPosEcefCov:u,522:y,MsgPosLlh:y,529:f,MsgPosLlhCov:f,EstimatedHorizontalErrorEllipse:d,536:h,MsgPosLlhAcc:h,523:_,MsgBaselineEcef:_,524:S,MsgBaselineNed:S,525:g,MsgVelEcef:g,533:w,MsgVelEcefCov:w,526:E,MsgVelNed:E,530:m,MsgVelNedCov:m,553:b,MsgPosEcefGnss:b,564:I,MsgPosEcefCovGnss:I,554:L,MsgPosLlhGnss:L,561:T,MsgPosLlhCovGnss:T,557:v,MsgVelEcefGnss:v,565:U,MsgVelEcefCovGnss:U,558:O,MsgVelNedGnss:O,562:M,MsgVelNedCovGnss:M,531:D,MsgVelBody:D,540:A,MsgVelCog:A,528:G,MsgAgeCorrections:G,256:C,MsgGpsTimeDepA:C,518:j,MsgDopsDepA:j,512:P,MsgPosEcefDepA:P,513:R,MsgPosLlhDepA:R,514:N,MsgBaselineEcefDepA:N,515:x,MsgBaselineNedDepA:x,516:F,MsgVelEcefDepA:F,517:k,MsgVelNedDepA:k,519:B,MsgBaselineHeadingDepA:B,534:q,MsgProtectionLevelDepA:q,535:z,MsgProtectionLevel:z,570:V,MsgUtcLeapSecond:V,580:H,MsgReferenceFrameParam:H,581:$,MsgPoseRelative:$}},309:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_NDB_EVENT",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.prototype)).messageType="MSG_NDB_EVENT",s.prototype.msg_type=1024,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("recv_time").uint8("event").uint8("object_type").uint8("result").uint8("data_source").nest("object_sid",{type:i.prototype.parser}).nest("src_sid",{type:i.prototype.parser}).uint16("original_sender"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["event","writeUInt8",1]),s.prototype.fieldSpec.push(["object_type","writeUInt8",1]),s.prototype.fieldSpec.push(["result","writeUInt8",1]),s.prototype.fieldSpec.push(["data_source","writeUInt8",1]),s.prototype.fieldSpec.push(["object_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["src_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["original_sender","writeUInt16LE",2]),e.exports={1024:s,MsgNdbEvent:s}},4399:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase),s=p(278).GnssSignal,n=p(278).GnssSignalDep,a=p(278).GPSTime,l=p(278).GPSTimeDep,c=p(278).GPSTimeSec,u=(p(278).SvId,function(e,t){return r.call(this,e),this.messageType="ObservationHeader",this.fields=t||this.parser.parse(e.payload),this});(u.prototype=Object.create(r.prototype)).messageType="ObservationHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("t",{type:a.prototype.parser}).uint8("n_obs"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="Doppler",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="Doppler",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").int16("i").uint8("f"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["i","writeInt16LE",2]),y.prototype.fieldSpec.push(["f","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="PackedObsContent",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).nest("D",{type:y.prototype.parser}).uint8("cn0").uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["P","writeUInt32LE",4]),f.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),f.prototype.fieldSpec.push(["D",y.prototype.fieldSpec]),f.prototype.fieldSpec.push(["cn0","writeUInt8",1]),f.prototype.fieldSpec.push(["lock","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let d=function(e,t){return r.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="PackedOsrContent",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}).uint16("iono_std").uint16("tropo_std").uint16("range_std"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["P","writeUInt32LE",4]),d.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),d.prototype.fieldSpec.push(["lock","writeUInt8",1]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]),d.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),d.prototype.fieldSpec.push(["iono_std","writeUInt16LE",2]),d.prototype.fieldSpec.push(["tropo_std","writeUInt16LE",2]),d.prototype.fieldSpec.push(["range_std","writeUInt16LE",2]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_OBS",h.prototype.msg_type=74,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:f.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),h.prototype.fieldSpec.push(["obs","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_BASE_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_BASE_POS_LLH",_.prototype.msg_type=68,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").doublele("lat").doublele("lon").doublele("height"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),_.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),_.prototype.fieldSpec.push(["height","writeDoubleLE",8]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_BASE_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_BASE_POS_ECEF",S.prototype.msg_type=72,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").doublele("x").doublele("y").doublele("z"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["x","writeDoubleLE",8]),S.prototype.fieldSpec.push(["y","writeDoubleLE",8]),S.prototype.fieldSpec.push(["z","writeDoubleLE",8]);let g=function(e,t){return r.call(this,e),this.messageType="EphemerisCommonContent",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="EphemerisCommonContent",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).floatle("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),g.prototype.fieldSpec.push(["ura","writeFloatLE",4]),g.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),g.prototype.fieldSpec.push(["valid","writeUInt8",1]),g.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let w=function(e,t){return r.call(this,e),this.messageType="EphemerisCommonContentDepB",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="EphemerisCommonContentDepB",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),w.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),w.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),w.prototype.fieldSpec.push(["valid","writeUInt8",1]),w.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let E=function(e,t){return r.call(this,e),this.messageType="EphemerisCommonContentDepA",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="EphemerisCommonContentDepA",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toe",{type:l.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["toe",l.prototype.fieldSpec]),E.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),E.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),E.prototype.fieldSpec.push(["valid","writeUInt8",1]),E.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let m=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_E",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_E",m.prototype.msg_type=129,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:l.prototype.parser}).uint8("iode").uint16("iodc"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),m.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),m.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["w","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),m.prototype.fieldSpec.push(["toc",l.prototype.fieldSpec]),m.prototype.fieldSpec.push(["iode","writeUInt8",1]),m.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_F",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_F",b.prototype.msg_type=134,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),b.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),b.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),b.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["w","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),b.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),b.prototype.fieldSpec.push(["iode","writeUInt8",1]),b.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS",I.prototype.msg_type=138,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),I.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),I.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),I.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["w","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["af0","writeFloatLE",4]),I.prototype.fieldSpec.push(["af1","writeFloatLE",4]),I.prototype.fieldSpec.push(["af2","writeFloatLE",4]),I.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),I.prototype.fieldSpec.push(["iode","writeUInt8",1]),I.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_QZSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_QZSS",L.prototype.msg_type=142,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),L.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),L.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),L.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["w","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["af0","writeFloatLE",4]),L.prototype.fieldSpec.push(["af1","writeFloatLE",4]),L.prototype.fieldSpec.push(["af2","writeFloatLE",4]),L.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),L.prototype.fieldSpec.push(["iode","writeUInt8",1]),L.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_BDS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_BDS",T.prototype.msg_type=137,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd1").floatle("tgd2").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),T.prototype.fieldSpec.push(["tgd1","writeFloatLE",4]),T.prototype.fieldSpec.push(["tgd2","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),T.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),T.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["w","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af1","writeFloatLE",4]),T.prototype.fieldSpec.push(["af2","writeFloatLE",4]),T.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),T.prototype.fieldSpec.push(["iode","writeUInt8",1]),T.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GAL_DEP_A",v.prototype.msg_type=149,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),v.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),v.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),v.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),v.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["w","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af2","writeFloatLE",4]),v.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),v.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),v.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GAL",U.prototype.msg_type=141,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc").uint8("source"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),U.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),U.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),U.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),U.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["w","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af2","writeFloatLE",4]),U.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),U.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),U.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),U.prototype.fieldSpec.push(["source","writeUInt8",1]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_A",O.prototype.msg_type=130,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),O.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),O.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);let M=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_A",M.prototype.msg_type=131,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),M.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),M.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),M.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_B",D.prototype.msg_type=132,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),D.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),D.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS",A.prototype.msg_type=140,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"floatle"}).array("acc",{length:3,type:"floatle"}).floatle("a_gf0").floatle("a_gf1"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),A.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["vel","array","writeFloatLE",function(){return 4},3]),A.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),A.prototype.fieldSpec.push(["a_gf0","writeFloatLE",4]),A.prototype.fieldSpec.push(["a_gf1","writeFloatLE",4]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_B",G.prototype.msg_type=133,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),G.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),G.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),G.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);let C=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_C",C.prototype.msg_type=135,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),C.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),C.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["fcn","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_D",j.prototype.msg_type=136,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn").uint8("iod"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),j.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),j.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),j.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),j.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),j.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),j.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),j.prototype.fieldSpec.push(["fcn","writeUInt8",1]),j.prototype.fieldSpec.push(["iod","writeUInt8",1]);let P=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO",P.prototype.msg_type=139,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("gamma").floatle("tau").floatle("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"floatle"}).uint8("fcn").uint8("iod"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),P.prototype.fieldSpec.push(["gamma","writeFloatLE",4]),P.prototype.fieldSpec.push(["tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["d_tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),P.prototype.fieldSpec.push(["fcn","writeUInt8",1]),P.prototype.fieldSpec.push(["iod","writeUInt8",1]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_D",R.prototype.msg_type=128,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),R.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),R.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),R.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),R.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),R.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),R.prototype.fieldSpec.push(["w","writeDoubleLE",8]),R.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),R.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),R.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),R.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),R.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),R.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),R.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),R.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),R.prototype.fieldSpec.push(["valid","writeUInt8",1]),R.prototype.fieldSpec.push(["healthy","writeUInt8",1]),R.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),R.prototype.fieldSpec.push(["iode","writeUInt8",1]),R.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),R.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_A",N.prototype.msg_type=26,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),N.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),N.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["w","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["valid","writeUInt8",1]),N.prototype.fieldSpec.push(["healthy","writeUInt8",1]),N.prototype.fieldSpec.push(["prn","writeUInt8",1]);let x=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_B",x.prototype.msg_type=70,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn").uint8("iode"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),x.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),x.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["w","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["valid","writeUInt8",1]),x.prototype.fieldSpec.push(["healthy","writeUInt8",1]),x.prototype.fieldSpec.push(["prn","writeUInt8",1]),x.prototype.fieldSpec.push(["iode","writeUInt8",1]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_C",F.prototype.msg_type=71,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),F.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),F.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),F.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),F.prototype.fieldSpec.push(["w","writeDoubleLE",8]),F.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),F.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),F.prototype.fieldSpec.push(["valid","writeUInt8",1]),F.prototype.fieldSpec.push(["healthy","writeUInt8",1]),F.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),F.prototype.fieldSpec.push(["iode","writeUInt8",1]),F.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),F.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);let k=function(e,t){return r.call(this,e),this.messageType="ObservationHeaderDep",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="ObservationHeaderDep",k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").nest("t",{type:l.prototype.parser}).uint8("n_obs"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["t",l.prototype.fieldSpec]),k.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);let B=function(e,t){return r.call(this,e),this.messageType="CarrierPhaseDepA",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="CarrierPhaseDepA",B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").int32("i").uint8("f"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["i","writeInt32LE",4]),B.prototype.fieldSpec.push(["f","writeUInt8",1]);let q=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepA",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepA",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").uint8("prn"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["P","writeUInt32LE",4]),q.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),q.prototype.fieldSpec.push(["cn0","writeUInt8",1]),q.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),q.prototype.fieldSpec.push(["prn","writeUInt8",1]);let z=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepB",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepB",z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["P","writeUInt32LE",4]),z.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),z.prototype.fieldSpec.push(["cn0","writeUInt8",1]),z.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);let V=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepC",V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["P","writeUInt32LE",4]),V.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),V.prototype.fieldSpec.push(["cn0","writeUInt8",1]),V.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),V.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);let H=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_A",H.prototype.msg_type=69,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),H.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);let $=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_B",$.prototype.msg_type=67,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:z.prototype.parser,readUntil:"eof"}),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),$.prototype.fieldSpec.push(["obs","array",z.prototype.fieldSpec,function(){return this.fields.array.length},null]);let W=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(W.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_C",W.prototype.msg_type=73,W.prototype.constructor=W,W.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:V.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",V.prototype.fieldSpec,function(){return this.fields.array.length},null]);let Q=function(e,t){return r.call(this,e),this.messageType="MSG_IONO",this.fields=t||this.parser.parse(e.payload),this};(Q.prototype=Object.create(r.prototype)).messageType="MSG_IONO",Q.prototype.msg_type=144,Q.prototype.constructor=Q,Q.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).doublele("a0").doublele("a1").doublele("a2").doublele("a3").doublele("b0").doublele("b1").doublele("b2").doublele("b3"),Q.prototype.fieldSpec=[],Q.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),Q.prototype.fieldSpec.push(["a0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a3","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b3","writeDoubleLE",8]);let K=function(e,t){return r.call(this,e),this.messageType="MSG_SV_CONFIGURATION_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(K.prototype=Object.create(r.prototype)).messageType="MSG_SV_CONFIGURATION_GPS_DEP",K.prototype.msg_type=145,K.prototype.constructor=K,K.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).uint32("l2c_mask"),K.prototype.fieldSpec=[],K.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),K.prototype.fieldSpec.push(["l2c_mask","writeUInt32LE",4]);let X=function(e,t){return r.call(this,e),this.messageType="GnssCapb",this.fields=t||this.parser.parse(e.payload),this};(X.prototype=Object.create(r.prototype)).messageType="GnssCapb",X.prototype.constructor=X,X.prototype.parser=(new o).endianess("little").uint64("gps_active").uint64("gps_l2c").uint64("gps_l5").uint32("glo_active").uint32("glo_l2of").uint32("glo_l3").uint64("sbas_active").uint64("sbas_l5").uint64("bds_active").uint64("bds_d2nav").uint64("bds_b2").uint64("bds_b2a").uint32("qzss_active").uint64("gal_active").uint64("gal_e5"),X.prototype.fieldSpec=[],X.prototype.fieldSpec.push(["gps_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l2c","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["glo_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l2of","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l3","writeUInt32LE",4]),X.prototype.fieldSpec.push(["sbas_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["sbas_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_d2nav","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2a","writeUInt64LE",8]),X.prototype.fieldSpec.push(["qzss_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["gal_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gal_e5","writeUInt64LE",8]);let Y=function(e,t){return r.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(r.prototype)).messageType="MSG_GNSS_CAPB",Y.prototype.msg_type=150,Y.prototype.constructor=Y,Y.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).nest("gc",{type:X.prototype.parser}),Y.prototype.fieldSpec=[],Y.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),Y.prototype.fieldSpec.push(["gc",X.prototype.fieldSpec]);let J=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",J.prototype.msg_type=146,J.prototype.constructor=J,J.prototype.parser=(new o).endianess("little").nest("t_op",{type:l.prototype.parser}).uint8("prn").uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),J.prototype.fieldSpec=[],J.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),J.prototype.fieldSpec.push(["prn","writeUInt8",1]),J.prototype.fieldSpec.push(["valid","writeUInt8",1]),J.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),J.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),J.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);let Z=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",Z.prototype.msg_type=147,Z.prototype.constructor=Z,Z.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:n.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["valid","writeUInt8",1]),Z.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);let ee=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY",this.fields=t||this.parser.parse(e.payload),this};(ee.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY",ee.prototype.msg_type=148,ee.prototype.constructor=ee,ee.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:s.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),ee.prototype.fieldSpec=[],ee.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["valid","writeUInt8",1]),ee.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);let te=function(e,t){return r.call(this,e),this.messageType="AlmanacCommonContent",this.fields=t||this.parser.parse(e.payload),this};(te.prototype=Object.create(r.prototype)).messageType="AlmanacCommonContent",te.prototype.constructor=te,te.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),te.prototype.fieldSpec=[],te.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),te.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),te.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),te.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),te.prototype.fieldSpec.push(["valid","writeUInt8",1]),te.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let pe=function(e,t){return r.call(this,e),this.messageType="AlmanacCommonContentDep",this.fields=t||this.parser.parse(e.payload),this};(pe.prototype=Object.create(r.prototype)).messageType="AlmanacCommonContentDep",pe.prototype.constructor=pe,pe.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),pe.prototype.fieldSpec=[],pe.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),pe.prototype.fieldSpec.push(["valid","writeUInt8",1]),pe.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let re=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(re.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GPS_DEP",re.prototype.msg_type=112,re.prototype.constructor=re,re.prototype.parser=(new o).endianess("little").nest("common",{type:pe.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),re.prototype.fieldSpec=[],re.prototype.fieldSpec.push(["common",pe.prototype.fieldSpec]),re.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),re.prototype.fieldSpec.push(["w","writeDoubleLE",8]),re.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);let oe=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS",this.fields=t||this.parser.parse(e.payload),this};(oe.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GPS",oe.prototype.msg_type=114,oe.prototype.constructor=oe,oe.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),oe.prototype.fieldSpec=[],oe.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),oe.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["w","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);let ie=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GLO_DEP",this.fields=t||this.parser.parse(e.payload),this};(ie.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GLO_DEP",ie.prototype.msg_type=113,ie.prototype.constructor=ie,ie.prototype.parser=(new o).endianess("little").nest("common",{type:pe.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),ie.prototype.fieldSpec=[],ie.prototype.fieldSpec.push(["common",pe.prototype.fieldSpec]),ie.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["i","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);let se=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GLO",this.fields=t||this.parser.parse(e.payload),this};(se.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GLO",se.prototype.msg_type=115,se.prototype.constructor=se,se.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),se.prototype.fieldSpec=[],se.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),se.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["i","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),se.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),se.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);let ne=function(e,t){return r.call(this,e),this.messageType="MSG_GLO_BIASES",this.fields=t||this.parser.parse(e.payload),this};(ne.prototype=Object.create(r.prototype)).messageType="MSG_GLO_BIASES",ne.prototype.msg_type=117,ne.prototype.constructor=ne,ne.prototype.parser=(new o).endianess("little").uint8("mask").int16("l1ca_bias").int16("l1p_bias").int16("l2ca_bias").int16("l2p_bias"),ne.prototype.fieldSpec=[],ne.prototype.fieldSpec.push(["mask","writeUInt8",1]),ne.prototype.fieldSpec.push(["l1ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l1p_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2p_bias","writeInt16LE",2]);let ae=function(e,t){return r.call(this,e),this.messageType="SvAzEl",this.fields=t||this.parser.parse(e.payload),this};(ae.prototype=Object.create(r.prototype)).messageType="SvAzEl",ae.prototype.constructor=ae,ae.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("az").int8("el"),ae.prototype.fieldSpec=[],ae.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ae.prototype.fieldSpec.push(["az","writeUInt8",1]),ae.prototype.fieldSpec.push(["el","writeInt8",1]);let le=function(e,t){return r.call(this,e),this.messageType="MSG_SV_AZ_EL",this.fields=t||this.parser.parse(e.payload),this};(le.prototype=Object.create(r.prototype)).messageType="MSG_SV_AZ_EL",le.prototype.msg_type=151,le.prototype.constructor=le,le.prototype.parser=(new o).endianess("little").array("azel",{type:ae.prototype.parser,readUntil:"eof"}),le.prototype.fieldSpec=[],le.prototype.fieldSpec.push(["azel","array",ae.prototype.fieldSpec,function(){return this.fields.array.length},null]);let ce=function(e,t){return r.call(this,e),this.messageType="MSG_OSR",this.fields=t||this.parser.parse(e.payload),this};(ce.prototype=Object.create(r.prototype)).messageType="MSG_OSR",ce.prototype.msg_type=1600,ce.prototype.constructor=ce,ce.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:d.prototype.parser,readUntil:"eof"}),ce.prototype.fieldSpec=[],ce.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),ce.prototype.fieldSpec.push(["obs","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={ObservationHeader:u,Doppler:y,PackedObsContent:f,PackedOsrContent:d,74:h,MsgObs:h,68:_,MsgBasePosLlh:_,72:S,MsgBasePosEcef:S,EphemerisCommonContent:g,EphemerisCommonContentDepB:w,EphemerisCommonContentDepA:E,129:m,MsgEphemerisGpsDepE:m,134:b,MsgEphemerisGpsDepF:b,138:I,MsgEphemerisGps:I,142:L,MsgEphemerisQzss:L,137:T,MsgEphemerisBds:T,149:v,MsgEphemerisGalDepA:v,141:U,MsgEphemerisGal:U,130:O,MsgEphemerisSbasDepA:O,131:M,MsgEphemerisGloDepA:M,132:D,MsgEphemerisSbasDepB:D,140:A,MsgEphemerisSbas:A,133:G,MsgEphemerisGloDepB:G,135:C,MsgEphemerisGloDepC:C,136:j,MsgEphemerisGloDepD:j,139:P,MsgEphemerisGlo:P,128:R,MsgEphemerisDepD:R,26:N,MsgEphemerisDepA:N,70:x,MsgEphemerisDepB:x,71:F,MsgEphemerisDepC:F,ObservationHeaderDep:k,CarrierPhaseDepA:B,PackedObsContentDepA:q,PackedObsContentDepB:z,PackedObsContentDepC:V,69:H,MsgObsDepA:H,67:$,MsgObsDepB:$,73:W,MsgObsDepC:W,144:Q,MsgIono:Q,145:K,MsgSvConfigurationGpsDep:K,GnssCapb:X,150:Y,MsgGnssCapb:Y,146:J,MsgGroupDelayDepA:J,147:Z,MsgGroupDelayDepB:Z,148:ee,MsgGroupDelay:ee,AlmanacCommonContent:te,AlmanacCommonContentDep:pe,112:re,MsgAlmanacGpsDep:re,114:oe,MsgAlmanacGps:oe,113:ie,MsgAlmanacGloDep:ie,115:se,MsgAlmanacGlo:se,117:ne,MsgGloBiases:ne,SvAzEl:ae,151:le,MsgSvAzEl:le,1600:ce,MsgOsr:ce}},2623:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_HEADING",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_HEADING",i.prototype.msg_type=527,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),i.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_ORIENT_QUAT",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_ORIENT_QUAT",s.prototype.msg_type=544,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("tow").int32("w").int32("x").int32("y").int32("z").floatle("w_accuracy").floatle("x_accuracy").floatle("y_accuracy").floatle("z_accuracy").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["w","writeInt32LE",4]),s.prototype.fieldSpec.push(["x","writeInt32LE",4]),s.prototype.fieldSpec.push(["y","writeInt32LE",4]),s.prototype.fieldSpec.push(["z","writeInt32LE",4]),s.prototype.fieldSpec.push(["w_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["x_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["y_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["z_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_ORIENT_EULER",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_ORIENT_EULER",n.prototype.msg_type=545,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").int32("roll").int32("pitch").int32("yaw").floatle("roll_accuracy").floatle("pitch_accuracy").floatle("yaw_accuracy").uint8("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["roll","writeInt32LE",4]),n.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),n.prototype.fieldSpec.push(["yaw","writeInt32LE",4]),n.prototype.fieldSpec.push(["roll_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["pitch_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["yaw_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["flags","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_ANGULAR_RATE",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_ANGULAR_RATE",a.prototype.msg_type=546,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["x","writeInt32LE",4]),a.prototype.fieldSpec.push(["y","writeInt32LE",4]),a.prototype.fieldSpec.push(["z","writeInt32LE",4]),a.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={527:i,MsgBaselineHeading:i,544:s,MsgOrientQuat:s,545:n,MsgOrientEuler:n,546:a,MsgAngularRate:a}},7978:(e,t,p)=>{var r=p(7052).i;r.prototype.uint64=function(e,t){return this.setNextParser("uint64",e,Object.assign({},t,{formatter:function(e){var t=p(7898).UINT64,r=buffer.readUInt32LE(offset);offset+=4;var o=buffer.readUInt32LE(offset);return offset+=4,new t(r,o)}}))},r.prototype.compile=function(){var e=this.getCode();this.compiled=function(t,r,o){return"undefined"!=typeof window&&void 0===window.Buffer&&(window.Buffer=Buffer),new Function("buffer","callback","constructorFn","require",e).call(this,t,r,o,(function(e){if("cuint"===e)return p(7898);throw new Error("Unknown module required: "+e)}))}},e.exports=r},9757:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=p(278).GnssSignalDep,n=p(278).GPSTime,a=p(278).GPSTimeDep,l=(p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC",this.fields=t||this.parser.parse(e.payload),this});(l.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC",l.prototype.msg_type=105,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little"),l.prototype.fieldSpec=[];let c=function(e,t){return r.call(this,e),this.messageType="MSG_SET_TIME",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SET_TIME",c.prototype.msg_type=104,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little"),c.prototype.fieldSpec=[];let u=function(e,t){return r.call(this,e),this.messageType="MSG_RESET",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_RESET",u.prototype.msg_type=182,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_RESET_DEP",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_RESET_DEP",y.prototype.msg_type=178,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CW_RESULTS",f.prototype.msg_type=192,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little"),f.prototype.fieldSpec=[];let d=function(e,t){return r.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_CW_START",d.prototype.msg_type=193,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little"),d.prototype.fieldSpec=[];let h=function(e,t){return r.call(this,e),this.messageType="MSG_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_RESET_FILTERS",h.prototype.msg_type=34,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("filter"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["filter","writeUInt8",1]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_INIT_BASE_DEP",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_INIT_BASE_DEP",_.prototype.msg_type=35,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little"),_.prototype.fieldSpec=[];let S=function(e,t){return r.call(this,e),this.messageType="MSG_THREAD_STATE",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_THREAD_STATE",S.prototype.msg_type=23,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").string("name",{length:20}).uint16("cpu").uint32("stack_free"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["name","string",20]),S.prototype.fieldSpec.push(["cpu","writeUInt16LE",2]),S.prototype.fieldSpec.push(["stack_free","writeUInt32LE",4]);let g=function(e,t){return r.call(this,e),this.messageType="UARTChannel",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="UARTChannel",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").floatle("tx_throughput").floatle("rx_throughput").uint16("crc_error_count").uint16("io_error_count").uint8("tx_buffer_level").uint8("rx_buffer_level"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["rx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["crc_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["io_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["tx_buffer_level","writeUInt8",1]),g.prototype.fieldSpec.push(["rx_buffer_level","writeUInt8",1]);let w=function(e,t){return r.call(this,e),this.messageType="Period",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="Period",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").int32("avg").int32("pmin").int32("pmax").int32("current"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["avg","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmin","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmax","writeInt32LE",4]),w.prototype.fieldSpec.push(["current","writeInt32LE",4]);let E=function(e,t){return r.call(this,e),this.messageType="Latency",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="Latency",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").int32("avg").int32("lmin").int32("lmax").int32("current"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["avg","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmin","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmax","writeInt32LE",4]),E.prototype.fieldSpec.push(["current","writeInt32LE",4]);let m=function(e,t){return r.call(this,e),this.messageType="MSG_UART_STATE",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="MSG_UART_STATE",m.prototype.msg_type=29,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}).nest("obs_period",{type:w.prototype.parser}),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["obs_period",w.prototype.fieldSpec]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_UART_STATE_DEPA",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_UART_STATE_DEPA",b.prototype.msg_type=24,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_IAR_STATE",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_IAR_STATE",I.prototype.msg_type=25,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("num_hyps"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["num_hyps","writeUInt32LE",4]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_MASK_SATELLITE",L.prototype.msg_type=43,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:i.prototype.parser}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["mask","writeUInt8",1]),L.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE_DEP",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_MASK_SATELLITE_DEP",T.prototype.msg_type=27,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:s.prototype.parser}),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["mask","writeUInt8",1]),T.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_DEVICE_MONITOR",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_DEVICE_MONITOR",v.prototype.msg_type=181,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").int16("dev_vin").int16("cpu_vint").int16("cpu_vaux").int16("cpu_temperature").int16("fe_temperature"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["dev_vin","writeInt16LE",2]),v.prototype.fieldSpec.push(["cpu_vint","writeInt16LE",2]),v.prototype.fieldSpec.push(["cpu_vaux","writeInt16LE",2]),v.prototype.fieldSpec.push(["cpu_temperature","writeInt16LE",2]),v.prototype.fieldSpec.push(["fe_temperature","writeInt16LE",2]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_REQ",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_REQ",U.prototype.msg_type=184,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("sequence").string("command",{greedy:!0}),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),U.prototype.fieldSpec.push(["command","string",null]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_RESP",O.prototype.msg_type=185,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").uint32("sequence").int32("code"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),O.prototype.fieldSpec.push(["code","writeInt32LE",4]);let M=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_OUTPUT",M.prototype.msg_type=188,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("sequence").string("line",{greedy:!0}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),M.prototype.fieldSpec.push(["line","string",null]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_REQ",D.prototype.msg_type=186,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little"),D.prototype.fieldSpec=[];let A=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_RESP",A.prototype.msg_type=187,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").array("ipv4_address",{length:4,type:"uint8"}).uint8("ipv4_mask_size").array("ipv6_address",{length:16,type:"uint8"}).uint8("ipv6_mask_size").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}).uint32("flags"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["ipv4_address","array","writeUInt8",function(){return 1},4]),A.prototype.fieldSpec.push(["ipv4_mask_size","writeUInt8",1]),A.prototype.fieldSpec.push(["ipv6_address","array","writeUInt8",function(){return 1},16]),A.prototype.fieldSpec.push(["ipv6_mask_size","writeUInt8",1]),A.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["interface_name","string",16]),A.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let G=function(e,t){return r.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="NetworkUsage",G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").uint64("duration").uint64("total_bytes").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["duration","writeUInt64LE",8]),G.prototype.fieldSpec.push(["total_bytes","writeUInt64LE",8]),G.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["interface_name","string",16]);let C=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_BANDWIDTH_USAGE",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_BANDWIDTH_USAGE",C.prototype.msg_type=189,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").array("interfaces",{type:G.prototype.parser,readUntil:"eof"}),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["interfaces","array",G.prototype.fieldSpec,function(){return this.fields.array.length},null]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_CELL_MODEM_STATUS",j.prototype.msg_type=190,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").int8("signal_strength").floatle("signal_error_rate").array("reserved",{type:"uint8",readUntil:"eof"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["signal_strength","writeInt8",1]),j.prototype.fieldSpec.push(["signal_error_rate","writeFloatLE",4]),j.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},null]);let P=function(e,t){return r.call(this,e),this.messageType="MSG_SPECAN_DEP",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_SPECAN_DEP",P.prototype.msg_type=80,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:a.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),P.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),P.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_SPECAN",R.prototype.msg_type=81,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:n.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),R.prototype.fieldSpec.push(["t",n.prototype.fieldSpec]),R.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),R.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),R.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),R.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),R.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_FRONT_END_GAIN",N.prototype.msg_type=191,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").array("rf_gain",{length:8,type:"int8"}).array("if_gain",{length:8,type:"int8"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["rf_gain","array","writeInt8",function(){return 1},8]),N.prototype.fieldSpec.push(["if_gain","array","writeInt8",function(){return 1},8]),e.exports={105:l,MsgAlmanac:l,104:c,MsgSetTime:c,182:u,MsgReset:u,178:y,MsgResetDep:y,192:f,MsgCwResults:f,193:d,MsgCwStart:d,34:h,MsgResetFilters:h,35:_,MsgInitBaseDep:_,23:S,MsgThreadState:S,UARTChannel:g,Period:w,Latency:E,29:m,MsgUartState:m,24:b,MsgUartStateDepa:b,25:I,MsgIarState:I,43:L,MsgMaskSatellite:L,27:T,MsgMaskSatelliteDep:T,181:v,MsgDeviceMonitor:v,184:U,MsgCommandReq:U,185:O,MsgCommandResp:O,188:M,MsgCommandOutput:M,186:D,MsgNetworkStateReq:D,187:A,MsgNetworkStateResp:A,NetworkUsage:G,189:C,MsgNetworkBandwidthUsage:C,190:j,MsgCellModemStatus:j,80:P,MsgSpecanDep:P,81:R,MsgSpecan:R,191:N,MsgFrontEndGain:N}},2827:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_MEASUREMENT_POINT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_MEASUREMENT_POINT",i.prototype.msg_type=52992,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("total_time").uint16("num_executions").uint32("min").uint32("max").uint64("return_addr").uint64("id").uint64("slice_time").uint16("line").string("func",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["total_time","writeUInt32LE",4]),i.prototype.fieldSpec.push(["num_executions","writeUInt16LE",2]),i.prototype.fieldSpec.push(["min","writeUInt32LE",4]),i.prototype.fieldSpec.push(["max","writeUInt32LE",4]),i.prototype.fieldSpec.push(["return_addr","writeUInt64LE",8]),i.prototype.fieldSpec.push(["id","writeUInt64LE",8]),i.prototype.fieldSpec.push(["slice_time","writeUInt64LE",8]),i.prototype.fieldSpec.push(["line","writeUInt16LE",2]),i.prototype.fieldSpec.push(["func","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_PROFILING_SYSTEM_INFO",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_PROFILING_SYSTEM_INFO",s.prototype.msg_type=52993,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("total_cpu_time").uint64("age").uint8("n_threads").uint32("heap_usage"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["total_cpu_time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["age","writeUInt64LE",8]),s.prototype.fieldSpec.push(["n_threads","writeUInt8",1]),s.prototype.fieldSpec.push(["heap_usage","writeUInt32LE",4]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_PROFILING_THREAD_INFO",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_PROFILING_THREAD_INFO",n.prototype.msg_type=52994,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint64("total_cpu_time").uint64("age").uint8("state").uint32("stack_size").uint32("stack_usage").string("name",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["total_cpu_time","writeUInt64LE",8]),n.prototype.fieldSpec.push(["age","writeUInt64LE",8]),n.prototype.fieldSpec.push(["state","writeUInt8",1]),n.prototype.fieldSpec.push(["stack_size","writeUInt32LE",4]),n.prototype.fieldSpec.push(["stack_usage","writeUInt32LE",4]),n.prototype.fieldSpec.push(["name","string",null]);let a=function(e,t){return r.call(this,e),this.messageType="ResourceBucket",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="ResourceBucket",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").string("name",{length:21}).uint8("thread").uint8("mutex").uint8("cv").uint8("io").uint32("heap_bytes_alloc").uint32("heap_bytes_free").uint32("io_write").uint32("io_read"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["name","string",21]),a.prototype.fieldSpec.push(["thread","writeUInt8",1]),a.prototype.fieldSpec.push(["mutex","writeUInt8",1]),a.prototype.fieldSpec.push(["cv","writeUInt8",1]),a.prototype.fieldSpec.push(["io","writeUInt8",1]),a.prototype.fieldSpec.push(["heap_bytes_alloc","writeUInt32LE",4]),a.prototype.fieldSpec.push(["heap_bytes_free","writeUInt32LE",4]),a.prototype.fieldSpec.push(["io_write","writeUInt32LE",4]),a.prototype.fieldSpec.push(["io_read","writeUInt32LE",4]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_PROFILING_RESOURCE_COUNTER",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_PROFILING_RESOURCE_COUNTER",l.prototype.msg_type=52995,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("seq_no").uint8("seq_len").array("buckets",{type:a.prototype.parser,readUntil:"eof"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["seq_no","writeUInt8",1]),l.prototype.fieldSpec.push(["seq_len","writeUInt8",1]),l.prototype.fieldSpec.push(["buckets","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={52992:i,MsgMeasurementPoint:i,52993:s,MsgProfilingSystemInfo:s,52994:n,MsgProfilingThreadInfo:n,ResourceBucket:a,52995:l,MsgProfilingResourceCounter:l}},5232:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_SBAS_RAW",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.prototype)).messageType="MSG_SBAS_RAW",s.prototype.msg_type=30583,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint32("tow").uint8("message_type").array("data",{length:27,type:"uint8"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["message_type","writeUInt8",1]),s.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},27]),e.exports={30583:s,MsgSbasRaw:s}},7238:(e,t,p)=>{var r=p(4148),o=(p(6468),p(7898).UINT64),i=function(e,t,p,r){var o=new Buffer(e);return o[t](p,r||0),o};function s(e){return this.messageType="raw",this.sbp=e||{},this.fields={},this}o.prototype.toJSON=function(){return this.toString()},s.prototype.fieldSpec=[],s.prototype.payloadToBuffer=function(e,t){var p=[];for(var i in e=e||this.fieldSpec,t=t||this.fields,e){var s=e[i],n=s[0],a=s[1],l=function(e){return"function"==typeof e?e.apply(this):e}.bind(this);if("string"==typeof a&&0===a.indexOf("write")){var c=l(s[2]);if("writeUInt64LE"===a){r(t[n]instanceof o,"uint64 type must be represented by cuint.UINT64");var u=t[n].clone().shiftRight(32).and(new o(4294967295,0)).toNumber(),y=t[n].clone().and(new o(4294967295,0)).toNumber();let e=new Buffer(8);e.writeUInt32LE(y),e.writeUInt32LE(u,4),p.push(e)}else{let e=new Buffer(c);e[a](t[n],0),p.push(e)}}else if("string"===a){let e=new Buffer(t[n].length);e.write(t[n],0,"utf8"),p.push(e)}else if("array"===a){var f=s[2];for(var d in t[n]){var h=t[n][d];if(Array.isArray(f))p=p.concat(this.payloadToBuffer(f,h));else{let e=new Buffer(l(s[3]));e[f](h,0),p.push(e)}}}else p=p.concat(this.payloadToBuffer(a,t[n]))}return Buffer.concat(p)},s.prototype.getLengthBuffer=function(){return i(1,"writeUInt8",this.length||this.sbp.length,0)},s.prototype.getSenderBuffer=function(){return i(2,"writeUInt16LE",this.sender||this.sbp.sender,0)},s.prototype.getPreambleBuffer=function(){return i(1,"writeUInt8",this.preamble||this.sbp.preamble,0)},s.prototype.getMsgTypeBuffer=function(){return i(2,"writeUInt16LE",this.msg_type||this.sbp.msg_type,0)},s.prototype.toBuffer=function(){var e=this.payloadToBuffer(),t=i(2,"writeUInt16LE",this.crc||this.sbp.crc,0),p=[this.getPreambleBuffer(),this.getMsgTypeBuffer(),this.getSenderBuffer(),this.getLengthBuffer()];return Buffer.concat(p.concat(e).concat(t))},s.prototype.toJSON=function(){var e={};return Object.keys(this.sbp).forEach(function(t){this.sbp[t]instanceof Buffer?e[t]=this.sbp[t].toString("base64"):e[t]=this.sbp[t]}.bind(this)),Object.keys(this.fields).forEach(function(t){e[t]=this.fields[t]}.bind(this)),e},s.prototype.toBase64=function(){return this.toBuffer().toString("base64")},e.exports=s},4120:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_SAVE",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_SAVE",i.prototype.msg_type=161,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];let s=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_WRITE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_WRITE",s.prototype.msg_type=160,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["setting","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_WRITE_RESP",n.prototype.msg_type=175,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["status","writeUInt8",1]),n.prototype.fieldSpec.push(["setting","string",null]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_REQ",a.prototype.msg_type=164,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["setting","string",null]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_RESP",l.prototype.msg_type=165,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["setting","string",null]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",c.prototype.msg_type=162,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("index"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["index","writeUInt16LE",2]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",u.prototype.msg_type=167,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("index").string("setting",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt16LE",2]),u.prototype.fieldSpec.push(["setting","string",null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",y.prototype.msg_type=166,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER",f.prototype.msg_type=174,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["setting","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER_RESP",d.prototype.msg_type=431,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["status","writeUInt8",1]),d.prototype.fieldSpec.push(["setting","string",null]),e.exports={161:i,MsgSettingsSave:i,160:s,MsgSettingsWrite:s,175:n,MsgSettingsWriteResp:n,164:a,MsgSettingsReadReq:a,165:l,MsgSettingsReadResp:l,162:c,MsgSettingsReadByIndexReq:c,167:u,MsgSettingsReadByIndexResp:u,166:y,MsgSettingsReadByIndexDone:y,174:f,MsgSettingsRegister:f,431:d,MsgSettingsRegisterResp:d}},9286:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="UtcTime",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="UtcTime",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["year","writeUInt16LE",2]),i.prototype.fieldSpec.push(["month","writeUInt8",1]),i.prototype.fieldSpec.push(["day","writeUInt8",1]),i.prototype.fieldSpec.push(["hours","writeUInt8",1]),i.prototype.fieldSpec.push(["minutes","writeUInt8",1]),i.prototype.fieldSpec.push(["seconds","writeUInt8",1]),i.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);let s=function(e,t){return r.call(this,e),this.messageType="ECDSASignature",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="ECDSASignature",s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("len").array("data",{length:72,type:"uint8"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["len","writeUInt8",1]),s.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},72]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_CERTIFICATE",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_CERTIFICATE",n.prototype.msg_type=3076,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("n_msg").array("certificate_id",{length:4,type:"uint8"}).uint8("flags").array("certificate_bytes",{type:"uint8",readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["n_msg","writeUInt8",1]),n.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),n.prototype.fieldSpec.push(["flags","writeUInt8",1]),n.prototype.fieldSpec.push(["certificate_bytes","array","writeUInt8",function(){return 1},null]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_CERTIFICATE_CHAIN",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_CERTIFICATE_CHAIN",a.prototype.msg_type=3081,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").array("root_certificate",{length:20,type:"uint8"}).array("intermediate_certificate",{length:20,type:"uint8"}).array("corrections_certificate",{length:20,type:"uint8"}).nest("expiration",{type:i.prototype.parser}).nest("signature",{type:s.prototype.parser}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["root_certificate","array","writeUInt8",function(){return 1},20]),a.prototype.fieldSpec.push(["intermediate_certificate","array","writeUInt8",function(){return 1},20]),a.prototype.fieldSpec.push(["corrections_certificate","array","writeUInt8",function(){return 1},20]),a.prototype.fieldSpec.push(["expiration",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["signature",s.prototype.fieldSpec]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_CERTIFICATE_CHAIN_DEP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_CERTIFICATE_CHAIN_DEP",l.prototype.msg_type=3077,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").array("root_certificate",{length:20,type:"uint8"}).array("intermediate_certificate",{length:20,type:"uint8"}).array("corrections_certificate",{length:20,type:"uint8"}).nest("expiration",{type:i.prototype.parser}).array("signature",{length:64,type:"uint8"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["root_certificate","array","writeUInt8",function(){return 1},20]),l.prototype.fieldSpec.push(["intermediate_certificate","array","writeUInt8",function(){return 1},20]),l.prototype.fieldSpec.push(["corrections_certificate","array","writeUInt8",function(){return 1},20]),l.prototype.fieldSpec.push(["expiration",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_AES_CMAC_SIGNATURE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_AES_CMAC_SIGNATURE",c.prototype.msg_type=3088,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).array("signature",{length:16,type:"uint8"}).uint8("flags").array("signed_messages",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),c.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),c.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),c.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},16]),c.prototype.fieldSpec.push(["flags","writeUInt8",1]),c.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_SIGNATURE",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_SIGNATURE",u.prototype.msg_type=3080,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("flags").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).nest("signature",{type:s.prototype.parser}).array("signed_messages",{type:"uint8",readUntil:"eof"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["flags","writeUInt8",1]),u.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),u.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),u.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),u.prototype.fieldSpec.push(["signature",s.prototype.fieldSpec]),u.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_SIGNATURE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_SIGNATURE_DEP_B",y.prototype.msg_type=3079,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint8("flags").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).uint8("n_signature_bytes").array("signature",{length:72,type:"uint8"}).array("signed_messages",{type:"uint8",readUntil:"eof"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["flags","writeUInt8",1]),y.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),y.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),y.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),y.prototype.fieldSpec.push(["n_signature_bytes","writeUInt8",1]),y.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},72]),y.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_SIGNATURE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_SIGNATURE_DEP_A",f.prototype.msg_type=3078,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("flags").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).array("signature",{length:64,type:"uint8"}).array("signed_messages",{type:"uint8",readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),f.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),f.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),f.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),f.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_CERTIFICATE_DEP",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_CERTIFICATE_DEP",d.prototype.msg_type=3074,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("n_msg").array("fingerprint",{length:20,type:"uint8"}).array("certificate_bytes",{type:"uint8",readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["n_msg","writeUInt8",1]),d.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),d.prototype.fieldSpec.push(["certificate_bytes","array","writeUInt8",function(){return 1},null]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE_DEP_A",h.prototype.msg_type=3073,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("signature",{length:64,type:"uint8"}).array("fingerprint",{length:20,type:"uint8"}).array("signed_messages",{type:"uint32le",readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),h.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),h.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE_DEP_B",_.prototype.msg_type=3075,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").uint8("stream_counter").uint8("on_demand_counter").array("signature",{length:64,type:"uint8"}).array("fingerprint",{length:20,type:"uint8"}).array("signed_messages",{type:"uint32le",readUntil:"eof"}),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),_.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),_.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),_.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),_.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]),e.exports={UtcTime:i,ECDSASignature:s,3076:n,MsgEcdsaCertificate:n,3081:a,MsgCertificateChain:a,3077:l,MsgCertificateChainDep:l,3088:c,MsgAesCmacSignature:c,3080:u,MsgEcdsaSignature:u,3079:y,MsgEcdsaSignatureDepB:y,3078:f,MsgEcdsaSignatureDepA:f,3074:d,MsgEd25519CertificateDep:d,3073:h,MsgEd25519SignatureDepA:h,3075:_,MsgEd25519SignatureDepB:_}},848:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="SolutionInputType",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="SolutionInputType",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("sensor_type").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_SOLN_META_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_SOLN_META_DEP_A",s.prototype.msg_type=65295,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("pdop").uint16("hdop").uint16("vdop").uint8("n_sats").uint16("age_corrections").uint8("alignment_status").uint32("last_used_gnss_pos_tow").uint32("last_used_gnss_vel_tow").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),s.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),s.prototype.fieldSpec.push(["alignment_status","writeUInt8",1]),s.prototype.fieldSpec.push(["last_used_gnss_pos_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["last_used_gnss_vel_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_SOLN_META",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_SOLN_META",n.prototype.msg_type=65294,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").uint16("pdop").uint16("hdop").uint16("vdop").uint16("age_corrections").uint32("age_gnss").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_gnss","writeUInt32LE",4]),n.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);let a=function(e,t){return r.call(this,e),this.messageType="GNSSInputType",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="GNSSInputType",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="IMUInputType",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="IMUInputType",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["flags","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="OdoInputType",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="OdoInputType",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={SolutionInputType:i,65295:s,MsgSolnMetaDepA:s,65294:n,MsgSolnMeta:n,GNSSInputType:a,IMUInputType:l,OdoInputType:c}},9269:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec),n=p(278).SvId,a=function(e,t){return r.call(this,e),this.messageType="CodeBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="CodeBiasesContent",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("code").int16("value"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["code","writeUInt8",1]),a.prototype.fieldSpec.push(["value","writeInt16LE",2]);let l=function(e,t){return r.call(this,e),this.messageType="PhaseBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="PhaseBiasesContent",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("code").uint8("integer_indicator").uint8("widelane_integer_indicator").uint8("discontinuity_counter").int32("bias"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["code","writeUInt8",1]),l.prototype.fieldSpec.push(["integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["widelane_integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["discontinuity_counter","writeUInt8",1]),l.prototype.fieldSpec.push(["bias","writeInt32LE",4]);let c=function(e,t){return r.call(this,e),this.messageType="STECHeader",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="STECHeader",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),c.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),c.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),c.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeader",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),u.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),u.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),u.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),u.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),u.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="STECSatElement",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="STECSatElement",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).uint8("stec_quality_indicator").array("stec_coeff",{length:4,type:"int16le"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["stec_quality_indicator","writeUInt8",1]),y.prototype.fieldSpec.push(["stec_coeff","array","writeInt16LE",function(){return 2},4]);let f=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrectionNoStd",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),f.prototype.fieldSpec.push(["wet","writeInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrection",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet").uint8("stddev"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),d.prototype.fieldSpec.push(["wet","writeInt8",1]),d.prototype.fieldSpec.push(["stddev","writeUInt8",1]);let h=function(e,t){return r.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="STECResidualNoStd",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),h.prototype.fieldSpec.push(["residual","writeInt16LE",2]);let _=function(e,t){return r.call(this,e),this.messageType="STECResidual",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="STECResidual",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual").uint8("stddev"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),_.prototype.fieldSpec.push(["residual","writeInt16LE",2]),_.prototype.fieldSpec.push(["stddev","writeUInt8",1]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK",S.prototype.msg_type=1501,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint32("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),S.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),S.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),S.prototype.fieldSpec.push(["iod","writeUInt32LE",4]),S.prototype.fieldSpec.push(["radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["along","writeInt32LE",4]),S.prototype.fieldSpec.push(["cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["c0","writeInt32LE",4]),S.prototype.fieldSpec.push(["c1","writeInt32LE",4]),S.prototype.fieldSpec.push(["c2","writeInt32LE",4]);let g=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_CODE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_BIASES",g.prototype.msg_type=1505,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").array("biases",{type:a.prototype.parser,readUntil:"eof"}),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),g.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),g.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),g.prototype.fieldSpec.push(["biases","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_PHASE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_SSR_PHASE_BIASES",w.prototype.msg_type=1510,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("dispersive_bias").uint8("mw_consistency").uint16("yaw").int8("yaw_rate").array("biases",{type:l.prototype.parser,readUntil:"eof"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),w.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),w.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),w.prototype.fieldSpec.push(["dispersive_bias","writeUInt8",1]),w.prototype.fieldSpec.push(["mw_consistency","writeUInt8",1]),w.prototype.fieldSpec.push(["yaw","writeUInt16LE",2]),w.prototype.fieldSpec.push(["yaw_rate","writeInt8",1]),w.prototype.fieldSpec.push(["biases","array",l.prototype.fieldSpec,function(){return this.fields.array.length},null]);let E=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP",E.prototype.msg_type=1531,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("header",{type:c.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["header",c.prototype.fieldSpec]),E.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let m=function(e,t){return r.call(this,e),this.messageType="BoundsHeader",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="BoundsHeader",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("sol_id"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),m.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),m.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),m.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),m.prototype.fieldSpec.push(["sol_id","writeUInt8",1]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION",b.prototype.msg_type=1533,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("n_sats").array("stec_sat_list",{type:y.prototype.parser,length:"n_sats"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),b.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),b.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION",I.prototype.msg_type=1532,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:d.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),I.prototype.fieldSpec.push(["index","writeUInt16LE",2]),I.prototype.fieldSpec.push(["tropo_delay_correction",d.prototype.fieldSpec]),I.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);let L=function(e,t){return r.call(this,e),this.messageType="STECSatElementIntegrity",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="STECSatElementIntegrity",L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("stec_residual",{type:_.prototype.parser}).uint8("stec_bound_mu").uint8("stec_bound_sig").uint8("stec_bound_mu_dot").uint8("stec_bound_sig_dot"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["stec_residual",_.prototype.fieldSpec]),L.prototype.fieldSpec.push(["stec_bound_mu","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_bound_sig","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_bound_mu_dot","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_bound_sig_dot","writeUInt8",1]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",T.prototype.msg_type=1534,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("tropo_qi").uint16("grid_point_id").nest("tropo_delay_correction",{type:d.prototype.parser}).uint8("tropo_v_hydro_bound_mu").uint8("tropo_v_hydro_bound_sig").uint8("tropo_v_wet_bound_mu").uint8("tropo_v_wet_bound_sig").uint8("n_sats").array("stec_sat_list",{type:L.prototype.parser,length:"n_sats"}),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),T.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),T.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tropo_qi","writeUInt8",1]),T.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tropo_delay_correction",d.prototype.fieldSpec]),T.prototype.fieldSpec.push(["tropo_v_hydro_bound_mu","writeUInt8",1]),T.prototype.fieldSpec.push(["tropo_v_hydro_bound_sig","writeUInt8",1]),T.prototype.fieldSpec.push(["tropo_v_wet_bound_mu","writeUInt8",1]),T.prototype.fieldSpec.push(["tropo_v_wet_bound_sig","writeUInt8",1]),T.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),T.prototype.fieldSpec.push(["stec_sat_list","array",L.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP_A",v.prototype.msg_type=1526,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),v.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),v.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),v.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),v.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),v.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),v.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),v.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),v.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP_B",U.prototype.msg_type=1527,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),U.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),U.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),U.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),U.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION",O.prototype.msg_type=1528,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("update_interval").uint8("sol_id").uint8("iod_atmo").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),O.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),O.prototype.fieldSpec.push(["sol_id","writeUInt8",1]),O.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),O.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),O.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),O.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),O.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),O.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),O.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),O.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),O.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),O.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);let M=function(e,t){return r.call(this,e),this.messageType="SatelliteAPC",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="SatelliteAPC",M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint8("sat_info").uint16("svn").array("pco",{length:3,type:"int16le"}).array("pcv",{length:21,type:"int8"}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),M.prototype.fieldSpec.push(["sat_info","writeUInt8",1]),M.prototype.fieldSpec.push(["svn","writeUInt16LE",2]),M.prototype.fieldSpec.push(["pco","array","writeInt16LE",function(){return 2},3]),M.prototype.fieldSpec.push(["pcv","array","writeInt8",function(){return 1},21]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC_DEP",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC_DEP",D.prototype.msg_type=1540,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").array("apc",{type:M.prototype.parser,readUntil:"eof"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["apc","array",M.prototype.fieldSpec,function(){return this.fields.array.length},null]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC",A.prototype.msg_type=1541,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("update_interval").uint8("sol_id").uint8("iod_ssr").array("apc",{type:M.prototype.parser,readUntil:"eof"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),A.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),A.prototype.fieldSpec.push(["sol_id","writeUInt8",1]),A.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),A.prototype.fieldSpec.push(["apc","array",M.prototype.fieldSpec,function(){return this.fields.array.length},null]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",G.prototype.msg_type=1500,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),G.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),G.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),G.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),G.prototype.fieldSpec.push(["iod","writeUInt8",1]),G.prototype.fieldSpec.push(["radial","writeInt32LE",4]),G.prototype.fieldSpec.push(["along","writeInt32LE",4]),G.prototype.fieldSpec.push(["cross","writeInt32LE",4]),G.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),G.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),G.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),G.prototype.fieldSpec.push(["c0","writeInt32LE",4]),G.prototype.fieldSpec.push(["c1","writeInt32LE",4]),G.prototype.fieldSpec.push(["c2","writeInt32LE",4]);let C=function(e,t){return r.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="STECHeaderDepA",C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),C.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),C.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),C.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),C.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeaderDepA",j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),j.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),j.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),j.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),j.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),j.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);let P=function(e,t){return r.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="GridDefinitionHeaderDepA",P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint8("region_size_inverse").uint16("area_width").uint16("lat_nw_corner_enc").uint16("lon_nw_corner_enc").uint8("num_msgs").uint8("seq_num"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),P.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),P.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),P.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),P.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),P.prototype.fieldSpec.push(["seq_num","writeUInt8",1]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP_A",R.prototype.msg_type=1515,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").nest("header",{type:C.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["header",C.prototype.fieldSpec]),R.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",N.prototype.msg_type=1520,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").nest("header",{type:j.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:h.prototype.parser,readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["header",j.prototype.fieldSpec]),N.prototype.fieldSpec.push(["index","writeUInt16LE",2]),N.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),N.prototype.fieldSpec.push(["stec_residuals","array",h.prototype.fieldSpec,function(){return this.fields.array.length},null]);let x=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",x.prototype.msg_type=1530,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").nest("header",{type:j.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:d.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["header",j.prototype.fieldSpec]),x.prototype.fieldSpec.push(["index","writeUInt16LE",2]),x.prototype.fieldSpec.push(["tropo_delay_correction",d.prototype.fieldSpec]),x.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRID_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",F.prototype.msg_type=1525,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").nest("header",{type:P.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["header",P.prototype.fieldSpec]),F.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]);let k=function(e,t){return r.call(this,e),this.messageType="OrbitClockBound",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="OrbitClockBound",k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("orb_radial_bound_mu").uint8("orb_along_bound_mu").uint8("orb_cross_bound_mu").uint8("orb_radial_bound_sig").uint8("orb_along_bound_sig").uint8("orb_cross_bound_sig").uint8("clock_bound_mu").uint8("clock_bound_sig"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_radial_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_along_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_cross_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_radial_bound_sig","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_along_bound_sig","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_cross_bound_sig","writeUInt8",1]),k.prototype.fieldSpec.push(["clock_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["clock_bound_sig","writeUInt8",1]);let B=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",B.prototype.msg_type=1502,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats").array("orbit_clock_bounds",{type:k.prototype.parser,length:"n_sats"}),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),B.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),B.prototype.fieldSpec.push(["const_id","writeUInt8",1]),B.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),B.prototype.fieldSpec.push(["orbit_clock_bounds","array",k.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let q=function(e,t){return r.call(this,e),this.messageType="CodePhaseBiasesSatSig",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="CodePhaseBiasesSatSig",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("signal_id").uint8("code_bias_bound_mu").uint8("code_bias_bound_sig").uint8("phase_bias_bound_mu").uint8("phase_bias_bound_sig"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),q.prototype.fieldSpec.push(["signal_id","writeUInt8",1]),q.prototype.fieldSpec.push(["code_bias_bound_mu","writeUInt8",1]),q.prototype.fieldSpec.push(["code_bias_bound_sig","writeUInt8",1]),q.prototype.fieldSpec.push(["phase_bias_bound_mu","writeUInt8",1]),q.prototype.fieldSpec.push(["phase_bias_bound_sig","writeUInt8",1]);let z=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",z.prototype.msg_type=1516,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats_signals").array("satellites_signals",{type:q.prototype.parser,length:"n_sats_signals"}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),z.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),z.prototype.fieldSpec.push(["const_id","writeUInt8",1]),z.prototype.fieldSpec.push(["n_sats_signals","writeUInt8",1]),z.prototype.fieldSpec.push(["satellites_signals","array",q.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats_signals"]);let V=function(e,t){return r.call(this,e),this.messageType="OrbitClockBoundDegradation",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="OrbitClockBoundDegradation",V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").uint8("orb_radial_bound_mu_dot").uint8("orb_along_bound_mu_dot").uint8("orb_cross_bound_mu_dot").uint8("orb_radial_bound_sig_dot").uint8("orb_along_bound_sig_dot").uint8("orb_cross_bound_sig_dot").uint8("clock_bound_mu_dot").uint8("clock_bound_sig_dot"),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["orb_radial_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_along_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_cross_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_radial_bound_sig_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_along_bound_sig_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_cross_bound_sig_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["clock_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["clock_bound_sig_dot","writeUInt8",1]);let H=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",H.prototype.msg_type=1503,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint64("sat_bitmask").nest("orbit_clock_bounds_degradation",{type:V.prototype.parser}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),H.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),H.prototype.fieldSpec.push(["const_id","writeUInt8",1]),H.prototype.fieldSpec.push(["sat_bitmask","writeUInt64LE",8]),H.prototype.fieldSpec.push(["orbit_clock_bounds_degradation",V.prototype.fieldSpec]),e.exports={CodeBiasesContent:a,PhaseBiasesContent:l,STECHeader:c,GriddedCorrectionHeader:u,STECSatElement:y,TroposphericDelayCorrectionNoStd:f,TroposphericDelayCorrection:d,STECResidualNoStd:h,STECResidual:_,1501:S,MsgSsrOrbitClock:S,1505:g,MsgSsrCodeBiases:g,1510:w,MsgSsrPhaseBiases:w,1531:E,MsgSsrStecCorrectionDep:E,BoundsHeader:m,1533:b,MsgSsrStecCorrection:b,1532:I,MsgSsrGriddedCorrection:I,STECSatElementIntegrity:L,1534:T,MsgSsrGriddedCorrectionBounds:T,1526:v,MsgSsrTileDefinitionDepA:v,1527:U,MsgSsrTileDefinitionDepB:U,1528:O,MsgSsrTileDefinition:O,SatelliteAPC:M,1540:D,MsgSsrSatelliteApcDep:D,1541:A,MsgSsrSatelliteApc:A,1500:G,MsgSsrOrbitClockDepA:G,STECHeaderDepA:C,GriddedCorrectionHeaderDepA:j,GridDefinitionHeaderDepA:P,1515:R,MsgSsrStecCorrectionDepA:R,1520:N,MsgSsrGriddedCorrectionNoStdDepA:N,1530:x,MsgSsrGriddedCorrectionDepA:x,1525:F,MsgSsrGridDefinitionDepA:F,OrbitClockBound:k,1502:B,MsgSsrOrbitClockBounds:B,CodePhaseBiasesSatSig:q,1516:z,MsgSsrCodePhaseBiasesBounds:z,OrbitClockBoundDegradation:V,1503:H,MsgSsrOrbitClockBoundsDegradation:H}},2644:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_STARTUP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_STARTUP",i.prototype.msg_type=65280,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("cause").uint8("startup_type").uint16("reserved"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["cause","writeUInt8",1]),i.prototype.fieldSpec.push(["startup_type","writeUInt8",1]),i.prototype.fieldSpec.push(["reserved","writeUInt16LE",2]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_DGNSS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_DGNSS_STATUS",s.prototype.msg_type=65282,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("flags").uint16("latency").uint8("num_signals").string("source",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["latency","writeUInt16LE",2]),s.prototype.fieldSpec.push(["num_signals","writeUInt8",1]),s.prototype.fieldSpec.push(["source","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_HEARTBEAT",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_HEARTBEAT",n.prototype.msg_type=65535,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let a=function(e,t){return r.call(this,e),this.messageType="SubSystemReport",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="SubSystemReport",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint16("component").uint8("generic").uint8("specific"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["component","writeUInt16LE",2]),a.prototype.fieldSpec.push(["generic","writeUInt8",1]),a.prototype.fieldSpec.push(["specific","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_STATUS_REPORT",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_STATUS_REPORT",l.prototype.msg_type=65534,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("sequence").uint32("uptime").array("status",{type:a.prototype.parser,readUntil:"eof"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),l.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),l.prototype.fieldSpec.push(["status","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);let c=function(e,t){return r.call(this,e),this.messageType="StatusJournalItem",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="StatusJournalItem",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("uptime").nest("report",{type:a.prototype.parser}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["report",a.prototype.fieldSpec]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_STATUS_JOURNAL",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_STATUS_JOURNAL",u.prototype.msg_type=65533,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("total_status_reports").uint8("sequence_descriptor").array("journal",{type:c.prototype.parser,readUntil:"eof"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),u.prototype.fieldSpec.push(["total_status_reports","writeUInt32LE",4]),u.prototype.fieldSpec.push(["sequence_descriptor","writeUInt8",1]),u.prototype.fieldSpec.push(["journal","array",c.prototype.fieldSpec,function(){return this.fields.array.length},null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_INS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_INS_STATUS",y.prototype.msg_type=65283,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY",f.prototype.msg_type=65284,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["id","writeUInt8",1]),f.prototype.fieldSpec.push(["telemetry","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY_LABELS",d.prototype.msg_type=65285,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry_labels",{greedy:!0}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["id","writeUInt8",1]),d.prototype.fieldSpec.push(["telemetry_labels","string",null]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_INS_UPDATES",h.prototype.msg_type=65286,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("tow").uint8("gnsspos").uint8("gnssvel").uint8("wheelticks").uint8("speed").uint8("nhc").uint8("zerovel"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),h.prototype.fieldSpec.push(["gnsspos","writeUInt8",1]),h.prototype.fieldSpec.push(["gnssvel","writeUInt8",1]),h.prototype.fieldSpec.push(["wheelticks","writeUInt8",1]),h.prototype.fieldSpec.push(["speed","writeUInt8",1]),h.prototype.fieldSpec.push(["nhc","writeUInt8",1]),h.prototype.fieldSpec.push(["zerovel","writeUInt8",1]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_GNSS_TIME_OFFSET",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_GNSS_TIME_OFFSET",_.prototype.msg_type=65287,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("weeks").int32("milliseconds").int16("microseconds").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["weeks","writeInt16LE",2]),_.prototype.fieldSpec.push(["milliseconds","writeInt32LE",4]),_.prototype.fieldSpec.push(["microseconds","writeInt16LE",2]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_PPS_TIME",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_PPS_TIME",S.prototype.msg_type=65288,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time","writeUInt64LE",8]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);let g=function(e,t){return r.call(this,e),this.messageType="MSG_SENSOR_AID_EVENT",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="MSG_SENSOR_AID_EVENT",g.prototype.msg_type=65289,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("time").uint8("sensor_type").uint16("sensor_id").uint8("sensor_state").uint8("n_available_meas").uint8("n_attempted_meas").uint8("n_accepted_meas").uint32("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time","writeUInt32LE",4]),g.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),g.prototype.fieldSpec.push(["sensor_id","writeUInt16LE",2]),g.prototype.fieldSpec.push(["sensor_state","writeUInt8",1]),g.prototype.fieldSpec.push(["n_available_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_attempted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_accepted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_META",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_META",w.prototype.msg_type=65290,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("group_id").uint8("flags").uint8("n_group_msgs").array("group_msgs",{type:"uint16le",length:"n_group_msgs"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["group_id","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]),w.prototype.fieldSpec.push(["n_group_msgs","writeUInt8",1]),w.prototype.fieldSpec.push(["group_msgs","array","writeUInt16LE",function(){return 2},"n_group_msgs"]),e.exports={65280:i,MsgStartup:i,65282:s,MsgDgnssStatus:s,65535:n,MsgHeartbeat:n,SubSystemReport:a,65534:l,MsgStatusReport:l,StatusJournalItem:c,65533:u,MsgStatusJournal:u,65283:y,MsgInsStatus:y,65284:f,MsgCsacTelemetry:f,65285:d,MsgCsacTelemetryLabels:d,65286:h,MsgInsUpdates:h,65287:_,MsgGnssTimeOffset:_,65288:S,MsgPpsTime:S,65289:g,MsgSensorAidEvent:g,65290:w,MsgGroupMeta:w}},3894:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="TelemetrySV",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.prototype)).messageType="TelemetrySV",s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("az").int8("el").uint8("availability_flags").int16("pseudorange_residual").int16("phase_residual").uint8("outlier_flags").uint8("ephemeris_flags").uint8("correction_flags").nest("sid",{type:i.prototype.parser}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["az","writeUInt8",1]),s.prototype.fieldSpec.push(["el","writeInt8",1]),s.prototype.fieldSpec.push(["availability_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["pseudorange_residual","writeInt16LE",2]),s.prototype.fieldSpec.push(["phase_residual","writeInt16LE",2]),s.prototype.fieldSpec.push(["outlier_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["ephemeris_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["correction_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_TEL_SV",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_TEL_SV",n.prototype.msg_type=288,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").uint8("n_obs").uint8("origin_flags").array("sv_tel",{type:s.prototype.parser,readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["n_obs","writeUInt8",1]),n.prototype.fieldSpec.push(["origin_flags","writeUInt8",1]),n.prototype.fieldSpec.push(["sv_tel","array",s.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={TelemetrySV:s,288:n,MsgTelSv:n}},752:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase),s=p(278).GnssSignal,n=p(278).GnssSignalDep,a=p(278).GPSTime,l=p(278).GPSTimeDep,c=(p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(c.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",c.prototype.msg_type=33,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:a.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:s.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),c.prototype.fieldSpec.push(["tot",a.prototype.fieldSpec]),c.prototype.fieldSpec.push(["P","writeUInt32LE",4]),c.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),c.prototype.fieldSpec.push(["cn0","writeUInt8",1]),c.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),c.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),c.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),c.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),c.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),c.prototype.fieldSpec.push(["acceleration","writeInt8",1]),c.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP",u.prototype.msg_type=17,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:l.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),u.prototype.fieldSpec.push(["tot",l.prototype.fieldSpec]),u.prototype.fieldSpec.push(["P","writeUInt32LE",4]),u.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["cn0","writeUInt8",1]),u.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),u.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),u.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),u.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),u.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),u.prototype.fieldSpec.push(["acceleration","writeInt8",1]),u.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="TrackingChannelState",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="TrackingChannelState",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("fcn").uint8("cn0"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["fcn","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE",f.prototype.msg_type=65,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("states",{type:y.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["states","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let d=function(e,t){return r.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MeasurementState",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("mesid",{type:s.prototype.parser}).uint8("cn0"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["mesid",s.prototype.fieldSpec]),d.prototype.fieldSpec.push(["cn0","writeUInt8",1]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_MEASUREMENT_STATE",h.prototype.msg_type=97,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("states",{type:d.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["states","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]);let _=function(e,t){return r.call(this,e),this.messageType="TrackingChannelCorrelation",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="TrackingChannelCorrelation",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("I").int16("Q"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["I","writeInt16LE",2]),_.prototype.fieldSpec.push(["Q","writeInt16LE",2]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_IQ",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_IQ",S.prototype.msg_type=45,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:_.prototype.parser}),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["channel","writeUInt8",1]),S.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["corrs","array",_.prototype.fieldSpec,function(){return this.fields.array.length},3]);let g=function(e,t){return r.call(this,e),this.messageType="TrackingChannelCorrelationDep",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="TrackingChannelCorrelationDep",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").int32("I").int32("Q"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["I","writeInt32LE",4]),g.prototype.fieldSpec.push(["Q","writeInt32LE",4]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_IQ_DEP_B",w.prototype.msg_type=44,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["channel","writeUInt8",1]),w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);let E=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_IQ_DEP_A",E.prototype.msg_type=28,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:n.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["channel","writeUInt8",1]),E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);let m=function(e,t){return r.call(this,e),this.messageType="TrackingChannelStateDepA",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="TrackingChannelStateDepA",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint8("state").uint8("prn").floatle("cn0"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["state","writeUInt8",1]),m.prototype.fieldSpec.push(["prn","writeUInt8",1]),m.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DEP_A",b.prototype.msg_type=22,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").array("states",{type:m.prototype.parser,readUntil:"eof"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["states","array",m.prototype.fieldSpec,function(){return this.fields.array.length},null]);let I=function(e,t){return r.call(this,e),this.messageType="TrackingChannelStateDepB",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="TrackingChannelStateDepB",I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint8("state").nest("sid",{type:n.prototype.parser}).floatle("cn0"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["state","writeUInt8",1]),I.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),I.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DEP_B",L.prototype.msg_type=19,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").array("states",{type:I.prototype.parser,readUntil:"eof"}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["states","array",I.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={33:c,MsgTrackingStateDetailedDepA:c,17:u,MsgTrackingStateDetailedDep:u,TrackingChannelState:y,65:f,MsgTrackingState:f,MeasurementState:d,97:h,MsgMeasurementState:h,TrackingChannelCorrelation:_,45:S,MsgTrackingIq:S,TrackingChannelCorrelationDep:g,44:w,MsgTrackingIqDepB:w,28:E,MsgTrackingIqDepA:E,TrackingChannelStateDepA:m,22:b,MsgTrackingStateDepA:b,TrackingChannelStateDepB:I,19:L,MsgTrackingStateDepB:L}},5562:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_USER_DATA",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_USER_DATA",i.prototype.msg_type=2048,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").array("contents",{type:"uint8",readUntil:"eof"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]),e.exports={2048:i,MsgUserData:i}},7293:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_ODOMETRY",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_ODOMETRY",i.prototype.msg_type=2307,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").int32("velocity").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["velocity","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_WHEELTICK",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_WHEELTICK",s.prototype.msg_type=2308,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags").uint8("source").int32("ticks"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["ticks","writeInt32LE",4]),e.exports={2307:i,MsgOdometry:i,2308:s,MsgWheeltick:s}},4148:(e,t,p)=>{"use strict";function r(e){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},r(e)}function o(e,t){for(var p=0;p1?p-1:0),o=1;o1?p-1:0),o=1;o1?p-1:0),o=1;o1?p-1:0),o=1;o{"use strict";function r(e,t){var p=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),p.push.apply(p,r)}return p}function o(e){for(var t=1;te.length)&&(p=e.length),e.substring(p-t.length,p)===t}var g="",w="",E="",m="",b={deepStrictEqual:"Expected values to be strictly deep-equal:",strictEqual:"Expected values to be strictly equal:",strictEqualObject:'Expected "actual" to be reference-equal to "expected":',deepEqual:"Expected values to be loosely deep-equal:",equal:"Expected values to be loosely equal:",notDeepStrictEqual:'Expected "actual" not to be strictly deep-equal to:',notStrictEqual:'Expected "actual" to be strictly unequal to:',notStrictEqualObject:'Expected "actual" not to be reference-equal to "expected":',notDeepEqual:'Expected "actual" not to be loosely deep-equal to:',notEqual:'Expected "actual" to be loosely unequal to:',notIdentical:"Values identical but not reference-equal:"};function I(e){var t=Object.keys(e),p=Object.create(Object.getPrototypeOf(e));return t.forEach((function(t){p[t]=e[t]})),Object.defineProperty(p,"message",{value:e.message}),p}function L(e){return h(e,{compact:!1,customInspect:!1,depth:1e3,maxArrayLength:1/0,showHidden:!1,breakLength:1/0,showProxy:!1,sorted:!0,getters:!0})}var T=function(e,t){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),Object.defineProperty(e,"prototype",{writable:!1}),t&&y(e,t)}(T,e);var p,r,s,l,c=(p=T,r=u(),function(){var e,t=f(p);if(r){var o=f(this).constructor;e=Reflect.construct(t,arguments,o)}else e=t.apply(this,arguments);return n(this,e)});function T(e){var t;if(function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,T),"object"!==d(e)||null===e)throw new _("options","Object",e);var p=e.message,r=e.operator,o=e.stackStartFn,i=e.actual,s=e.expected,l=Error.stackTraceLimit;if(Error.stackTraceLimit=0,null!=p)t=c.call(this,String(p));else if(process.stderr&&process.stderr.isTTY&&(process.stderr&&process.stderr.getColorDepth&&1!==process.stderr.getColorDepth()?(g="",w="",m="",E=""):(g="",w="",m="",E="")),"object"===d(i)&&null!==i&&"object"===d(s)&&null!==s&&"stack"in i&&i instanceof Error&&"stack"in s&&s instanceof Error&&(i=I(i),s=I(s)),"deepStrictEqual"===r||"strictEqual"===r)t=c.call(this,function(e,t,p){var r="",o="",i=0,s="",n=!1,a=L(e),l=a.split("\n"),c=L(t).split("\n"),u=0,y="";if("strictEqual"===p&&"object"===d(e)&&"object"===d(t)&&null!==e&&null!==t&&(p="strictEqualObject"),1===l.length&&1===c.length&&l[0]!==c[0]){var f=l[0].length+c[0].length;if(f<=10){if(!("object"===d(e)&&null!==e||"object"===d(t)&&null!==t||0===e&&0===t))return"".concat(b[p],"\n\n")+"".concat(l[0]," !== ").concat(c[0],"\n")}else if("strictEqualObject"!==p&&f<(process.stderr&&process.stderr.isTTY?process.stderr.columns:80)){for(;l[0][u]===c[0][u];)u++;u>2&&(y="\n ".concat(function(e,t){if(t=Math.floor(t),0==e.length||0==t)return"";var p=e.length*t;for(t=Math.floor(Math.log(t)/Math.log(2));t;)e+=e,t--;return e+e.substring(0,p-e.length)}(" ",u),"^"),u=0)}}for(var h=l[l.length-1],_=c[c.length-1];h===_&&(u++<2?s="\n ".concat(h).concat(s):r=h,l.pop(),c.pop(),0!==l.length&&0!==c.length);)h=l[l.length-1],_=c[c.length-1];var I=Math.max(l.length,c.length);if(0===I){var T=a.split("\n");if(T.length>30)for(T[26]="".concat(g,"...").concat(m);T.length>27;)T.pop();return"".concat(b.notIdentical,"\n\n").concat(T.join("\n"),"\n")}u>3&&(s="\n".concat(g,"...").concat(m).concat(s),n=!0),""!==r&&(s="\n ".concat(r).concat(s),r="");var v=0,U=b[p]+"\n".concat(w,"+ actual").concat(m," ").concat(E,"- expected").concat(m),O=" ".concat(g,"...").concat(m," Lines skipped");for(u=0;u1&&u>2&&(M>4?(o+="\n".concat(g,"...").concat(m),n=!0):M>3&&(o+="\n ".concat(c[u-2]),v++),o+="\n ".concat(c[u-1]),v++),i=u,r+="\n".concat(E,"-").concat(m," ").concat(c[u]),v++;else if(c.length1&&u>2&&(M>4?(o+="\n".concat(g,"...").concat(m),n=!0):M>3&&(o+="\n ".concat(l[u-2]),v++),o+="\n ".concat(l[u-1]),v++),i=u,o+="\n".concat(w,"+").concat(m," ").concat(l[u]),v++;else{var D=c[u],A=l[u],G=A!==D&&(!S(A,",")||A.slice(0,-1)!==D);G&&S(D,",")&&D.slice(0,-1)===A&&(G=!1,A+=","),G?(M>1&&u>2&&(M>4?(o+="\n".concat(g,"...").concat(m),n=!0):M>3&&(o+="\n ".concat(l[u-2]),v++),o+="\n ".concat(l[u-1]),v++),i=u,o+="\n".concat(w,"+").concat(m," ").concat(A),r+="\n".concat(E,"-").concat(m," ").concat(D),v+=2):(o+=r,r="",1!==M&&0!==u||(o+="\n ".concat(A),v++))}if(v>20&&u30)for(y[26]="".concat(g,"...").concat(m);y.length>27;)y.pop();t=1===y.length?c.call(this,"".concat(u," ").concat(y[0])):c.call(this,"".concat(u,"\n\n").concat(y.join("\n"),"\n"))}else{var f=L(i),h="",v=b[r];"notDeepEqual"===r||"notEqual"===r?(f="".concat(b[r],"\n\n").concat(f)).length>1024&&(f="".concat(f.slice(0,1021),"...")):(h="".concat(L(s)),f.length>512&&(f="".concat(f.slice(0,509),"...")),h.length>512&&(h="".concat(h.slice(0,509),"...")),"deepEqual"===r||"equal"===r?f="".concat(v,"\n\n").concat(f,"\n\nshould equal\n\n"):h=" ".concat(r," ").concat(h)),t=c.call(this,"".concat(f).concat(h))}return Error.stackTraceLimit=l,t.generatedMessage=!p,Object.defineProperty(a(t),"name",{value:"AssertionError [ERR_ASSERTION]",enumerable:!1,writable:!0,configurable:!0}),t.code="ERR_ASSERTION",t.actual=i,t.expected=s,t.operator=r,Error.captureStackTrace&&Error.captureStackTrace(a(t),o),t.stack,t.name="AssertionError",n(t)}return s=T,(l=[{key:"toString",value:function(){return"".concat(this.name," [").concat(this.code,"]: ").concat(this.message)}},{key:t,value:function(e,t){return h(this,o(o({},t),{},{customInspect:!1,depth:0}))}}])&&i(s.prototype,l),Object.defineProperty(s,"prototype",{writable:!1}),T}(l(Error),h.custom);e.exports=T},9597:(e,t,p)=>{"use strict";function r(e){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},r(e)}function o(e,t){return o=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(e,t){return e.__proto__=t,e},o(e,t)}function i(e){return i=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(e){return e.__proto__||Object.getPrototypeOf(e)},i(e)}var s,n,a={};function l(e,t,p){p||(p=Error);var s=function(p){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),Object.defineProperty(e,"prototype",{writable:!1}),t&&o(e,t)}(c,p);var s,n,a,l=(n=c,a=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}(),function(){var e,t=i(n);if(a){var p=i(this).constructor;e=Reflect.construct(t,arguments,p)}else e=t.apply(this,arguments);return function(e,t){if(t&&("object"===r(t)||"function"==typeof t))return t;if(void 0!==t)throw new TypeError("Derived constructors may only return object or undefined");return function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e)}(this,e)});function c(p,r,o){var i;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,c),i=l.call(this,function(e,p,r){return"string"==typeof t?t:t(e,p,r)}(p,r,o)),i.code=e,i}return s=c,Object.defineProperty(s,"prototype",{writable:!1}),s}(p);a[e]=s}function c(e,t){if(Array.isArray(e)){var p=e.length;return e=e.map((function(e){return String(e)})),p>2?"one of ".concat(t," ").concat(e.slice(0,p-1).join(", "),", or ")+e[p-1]:2===p?"one of ".concat(t," ").concat(e[0]," or ").concat(e[1]):"of ".concat(t," ").concat(e[0])}return"of ".concat(t," ").concat(String(e))}l("ERR_AMBIGUOUS_ARGUMENT",'The "%s" argument is ambiguous. %s',TypeError),l("ERR_INVALID_ARG_TYPE",(function(e,t,o){var i,n,a,l,u;if(void 0===s&&(s=p(4148)),s("string"==typeof e,"'name' must be a string"),"string"==typeof t&&(n="not ",t.substr(0,4)===n)?(i="must not be",t=t.replace(/^not /,"")):i="must be",function(e,t,p){return(void 0===p||p>e.length)&&(p=e.length),e.substring(p-9,p)===t}(e," argument"))a="The ".concat(e," ").concat(i," ").concat(c(t,"type"));else{var y=("number"!=typeof u&&(u=0),u+1>(l=e).length||-1===l.indexOf(".",u)?"argument":"property");a='The "'.concat(e,'" ').concat(y," ").concat(i," ").concat(c(t,"type"))}return a+". Received type ".concat(r(o))}),TypeError),l("ERR_INVALID_ARG_VALUE",(function(e,t){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"is invalid";void 0===n&&(n=p(4591));var o=n.inspect(t);return o.length>128&&(o="".concat(o.slice(0,128),"...")),"The argument '".concat(e,"' ").concat(r,". Received ").concat(o)}),TypeError,RangeError),l("ERR_INVALID_RETURN_VALUE",(function(e,t,p){var o;return o=p&&p.constructor&&p.constructor.name?"instance of ".concat(p.constructor.name):"type ".concat(r(p)),"Expected ".concat(e,' to be returned from the "').concat(t,'"')+" function but got ".concat(o,".")}),TypeError),l("ERR_MISSING_ARGS",(function(){for(var e=arguments.length,t=new Array(e),r=0;r0,"At least one arg needs to be specified");var o="The ",i=t.length;switch(t=t.map((function(e){return'"'.concat(e,'"')})),i){case 1:o+="".concat(t[0]," argument");break;case 2:o+="".concat(t[0]," and ").concat(t[1]," arguments");break;default:o+=t.slice(0,i-1).join(", "),o+=", and ".concat(t[i-1]," arguments")}return"".concat(o," must be specified")}),TypeError),e.exports.codes=a},2299:(e,t,p)=>{"use strict";function r(e,t){return function(e){if(Array.isArray(e))return e}(e)||function(e,t){var p=null==e?null:"undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(null!=p){var r,o,i,s,n=[],a=!0,l=!1;try{if(i=(p=p.call(e)).next,0===t){if(Object(p)!==p)return;a=!1}else for(;!(a=(r=i.call(p)).done)&&(n.push(r.value),n.length!==t);a=!0);}catch(e){l=!0,o=e}finally{try{if(!a&&null!=p.return&&(s=p.return(),Object(s)!==s))return}finally{if(l)throw o}}return n}}(e,t)||function(e,t){if(e){if("string"==typeof e)return o(e,t);var p=Object.prototype.toString.call(e).slice(8,-1);return"Object"===p&&e.constructor&&(p=e.constructor.name),"Map"===p||"Set"===p?Array.from(e):"Arguments"===p||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(p)?o(e,t):void 0}}(e,t)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var p=0,r=new Array(t);p10)return!0;for(var t=0;t57)return!0}return 10===e.length&&e>=Math.pow(2,32)}function C(e){return Object.keys(e).filter(G).concat(c(e).filter(Object.prototype.propertyIsEnumerable.bind(e)))}function j(e,t){if(e===t)return 0;for(var p=e.length,r=t.length,o=0,i=Math.min(p,r);o{e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},2078:(e,t,p)=>{"use strict";var r=p(7244),o=p(8184),i=p(5767),s=p(5680);function n(e){return e.call.bind(e)}var a="undefined"!=typeof BigInt,l="undefined"!=typeof Symbol,c=n(Object.prototype.toString),u=n(Number.prototype.valueOf),y=n(String.prototype.valueOf),f=n(Boolean.prototype.valueOf);if(a)var d=n(BigInt.prototype.valueOf);if(l)var h=n(Symbol.prototype.valueOf);function _(e,t){if("object"!=typeof e)return!1;try{return t(e),!0}catch(e){return!1}}function S(e){return"[object Map]"===c(e)}function g(e){return"[object Set]"===c(e)}function w(e){return"[object WeakMap]"===c(e)}function E(e){return"[object WeakSet]"===c(e)}function m(e){return"[object ArrayBuffer]"===c(e)}function b(e){return"undefined"!=typeof ArrayBuffer&&(m.working?m(e):e instanceof ArrayBuffer)}function I(e){return"[object DataView]"===c(e)}function L(e){return"undefined"!=typeof DataView&&(I.working?I(e):e instanceof DataView)}t.isArgumentsObject=r,t.isGeneratorFunction=o,t.isTypedArray=s,t.isPromise=function(e){return"undefined"!=typeof Promise&&e instanceof Promise||null!==e&&"object"==typeof e&&"function"==typeof e.then&&"function"==typeof e.catch},t.isArrayBufferView=function(e){return"undefined"!=typeof ArrayBuffer&&ArrayBuffer.isView?ArrayBuffer.isView(e):s(e)||L(e)},t.isUint8Array=function(e){return"Uint8Array"===i(e)},t.isUint8ClampedArray=function(e){return"Uint8ClampedArray"===i(e)},t.isUint16Array=function(e){return"Uint16Array"===i(e)},t.isUint32Array=function(e){return"Uint32Array"===i(e)},t.isInt8Array=function(e){return"Int8Array"===i(e)},t.isInt16Array=function(e){return"Int16Array"===i(e)},t.isInt32Array=function(e){return"Int32Array"===i(e)},t.isFloat32Array=function(e){return"Float32Array"===i(e)},t.isFloat64Array=function(e){return"Float64Array"===i(e)},t.isBigInt64Array=function(e){return"BigInt64Array"===i(e)},t.isBigUint64Array=function(e){return"BigUint64Array"===i(e)},S.working="undefined"!=typeof Map&&S(new Map),t.isMap=function(e){return"undefined"!=typeof Map&&(S.working?S(e):e instanceof Map)},g.working="undefined"!=typeof Set&&g(new Set),t.isSet=function(e){return"undefined"!=typeof Set&&(g.working?g(e):e instanceof Set)},w.working="undefined"!=typeof WeakMap&&w(new WeakMap),t.isWeakMap=function(e){return"undefined"!=typeof WeakMap&&(w.working?w(e):e instanceof WeakMap)},E.working="undefined"!=typeof WeakSet&&E(new WeakSet),t.isWeakSet=function(e){return E(e)},m.working="undefined"!=typeof ArrayBuffer&&m(new ArrayBuffer),t.isArrayBuffer=b,I.working="undefined"!=typeof ArrayBuffer&&"undefined"!=typeof DataView&&I(new DataView(new ArrayBuffer(1),0,1)),t.isDataView=L;var T="undefined"!=typeof SharedArrayBuffer?SharedArrayBuffer:void 0;function v(e){return"[object SharedArrayBuffer]"===c(e)}function U(e){return void 0!==T&&(void 0===v.working&&(v.working=v(new T)),v.working?v(e):e instanceof T)}function O(e){return _(e,u)}function M(e){return _(e,y)}function D(e){return _(e,f)}function A(e){return a&&_(e,d)}function G(e){return l&&_(e,h)}t.isSharedArrayBuffer=U,t.isAsyncFunction=function(e){return"[object AsyncFunction]"===c(e)},t.isMapIterator=function(e){return"[object Map Iterator]"===c(e)},t.isSetIterator=function(e){return"[object Set Iterator]"===c(e)},t.isGeneratorObject=function(e){return"[object Generator]"===c(e)},t.isWebAssemblyCompiledModule=function(e){return"[object WebAssembly.Module]"===c(e)},t.isNumberObject=O,t.isStringObject=M,t.isBooleanObject=D,t.isBigIntObject=A,t.isSymbolObject=G,t.isBoxedPrimitive=function(e){return O(e)||M(e)||D(e)||A(e)||G(e)},t.isAnyArrayBuffer=function(e){return"undefined"!=typeof Uint8Array&&(b(e)||U(e))},["isProxy","isExternal","isModuleNamespaceObject"].forEach((function(e){Object.defineProperty(t,e,{enumerable:!1,value:function(){throw new Error(e+" is not supported in userland")}})}))},4591:(e,t,p)=>{var r=Object.getOwnPropertyDescriptors||function(e){for(var t=Object.keys(e),p={},r=0;r=i)return e;switch(e){case"%s":return String(r[p++]);case"%d":return Number(r[p++]);case"%j":try{return JSON.stringify(r[p++])}catch(e){return"[Circular]"}default:return e}})),n=r[p];p=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),h(p)?r.showHidden=p:p&&t._extend(r,p),w(r.showHidden)&&(r.showHidden=!1),w(r.depth)&&(r.depth=2),w(r.colors)&&(r.colors=!1),w(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=l),u(r,e,r.depth)}function l(e,t){var p=a.styles[t];return p?"["+a.colors[p][0]+"m"+e+"["+a.colors[p][1]+"m":e}function c(e,t){return e}function u(e,p,r){if(e.customInspect&&p&&L(p.inspect)&&p.inspect!==t.inspect&&(!p.constructor||p.constructor.prototype!==p)){var o=p.inspect(r,e);return g(o)||(o=u(e,o,r)),o}var i=function(e,t){if(w(t))return e.stylize("undefined","undefined");if(g(t)){var p="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(p,"string")}return S(t)?e.stylize(""+t,"number"):h(t)?e.stylize(""+t,"boolean"):_(t)?e.stylize("null","null"):void 0}(e,p);if(i)return i;var s=Object.keys(p),n=function(e){var t={};return e.forEach((function(e,p){t[e]=!0})),t}(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(p)),I(p)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return y(p);if(0===s.length){if(L(p)){var a=p.name?": "+p.name:"";return e.stylize("[Function"+a+"]","special")}if(E(p))return e.stylize(RegExp.prototype.toString.call(p),"regexp");if(b(p))return e.stylize(Date.prototype.toString.call(p),"date");if(I(p))return y(p)}var l,c="",m=!1,T=["{","}"];return d(p)&&(m=!0,T=["[","]"]),L(p)&&(c=" [Function"+(p.name?": "+p.name:"")+"]"),E(p)&&(c=" "+RegExp.prototype.toString.call(p)),b(p)&&(c=" "+Date.prototype.toUTCString.call(p)),I(p)&&(c=" "+y(p)),0!==s.length||m&&0!=p.length?r<0?E(p)?e.stylize(RegExp.prototype.toString.call(p),"regexp"):e.stylize("[Object]","special"):(e.seen.push(p),l=m?function(e,t,p,r,o){for(var i=[],s=0,n=t.length;s60?p[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+p[1]:p[0]+t+" "+e.join(", ")+" "+p[1]}(l,c,T)):T[0]+c+T[1]}function y(e){return"["+Error.prototype.toString.call(e)+"]"}function f(e,t,p,r,o,i){var s,n,a;if((a=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?n=a.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):a.set&&(n=e.stylize("[Setter]","special")),O(r,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=_(p)?u(e,a.value,null):u(e,a.value,p-1)).indexOf("\n")>-1&&(n=i?n.split("\n").map((function(e){return" "+e})).join("\n").slice(2):"\n"+n.split("\n").map((function(e){return" "+e})).join("\n")):n=e.stylize("[Circular]","special")),w(s)){if(i&&o.match(/^\d+$/))return n;(s=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.slice(1,-1),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+n}function d(e){return Array.isArray(e)}function h(e){return"boolean"==typeof e}function _(e){return null===e}function S(e){return"number"==typeof e}function g(e){return"string"==typeof e}function w(e){return void 0===e}function E(e){return m(e)&&"[object RegExp]"===T(e)}function m(e){return"object"==typeof e&&null!==e}function b(e){return m(e)&&"[object Date]"===T(e)}function I(e){return m(e)&&("[object Error]"===T(e)||e instanceof Error)}function L(e){return"function"==typeof e}function T(e){return Object.prototype.toString.call(e)}function v(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(e=e.toUpperCase(),!i[e])if(s.test(e)){var p=process.pid;i[e]=function(){var r=t.format.apply(t,arguments);console.error("%s %d: %s",e,p,r)}}else i[e]=function(){};return i[e]},t.inspect=a,a.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},a.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.types=p(2078),t.isArray=d,t.isBoolean=h,t.isNull=_,t.isNullOrUndefined=function(e){return null==e},t.isNumber=S,t.isString=g,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=w,t.isRegExp=E,t.types.isRegExp=E,t.isObject=m,t.isDate=b,t.types.isDate=b,t.isError=I,t.types.isNativeError=I,t.isFunction=L,t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=p(3845);var U=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function O(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){var e,p;console.log("%s - %s",(p=[v((e=new Date).getHours()),v(e.getMinutes()),v(e.getSeconds())].join(":"),[e.getDate(),U[e.getMonth()],p].join(" ")),t.format.apply(t,arguments))},t.inherits=p(6698),t._extend=function(e,t){if(!t||!m(t))return e;for(var p=Object.keys(t),r=p.length;r--;)e[p[r]]=t[p[r]];return e};var M="undefined"!=typeof Symbol?Symbol("util.promisify.custom"):void 0;function D(e,t){if(!e){var p=new Error("Promise was rejected with a falsy value");p.reason=e,e=p}return t(e)}t.promisify=function(e){if("function"!=typeof e)throw new TypeError('The "original" argument must be of type Function');if(M&&e[M]){var t;if("function"!=typeof(t=e[M]))throw new TypeError('The "util.promisify.custom" argument must be of type Function');return Object.defineProperty(t,M,{value:t,enumerable:!1,writable:!1,configurable:!0}),t}function t(){for(var t,p,r=new Promise((function(e,r){t=e,p=r})),o=[],i=0;i{"use strict";t.i=void 0,p(9160);var r=p(5682),o={},i="___parser_",s={uint8:1,uint16le:2,uint16be:2,uint32le:4,uint32be:4,int8:1,int16le:2,int16be:2,int32le:4,int32be:4,int64be:8,int64le:8,uint64be:8,uint64le:8,floatle:4,floatbe:4,doublele:8,doublebe:8},n={uint8:"Uint8",uint16le:"Uint16",uint16be:"Uint16",uint32le:"Uint32",uint32be:"Uint32",int8:"Int8",int16le:"Int16",int16be:"Int16",int32le:"Int32",int32be:"Int32",int64be:"BigInt64",int64le:"BigInt64",uint64be:"BigUint64",uint64le:"BigUint64",floatle:"Float32",floatbe:"Float32",doublele:"Float64",doublebe:"Float64"},a={uint8:!1,uint16le:!0,uint16be:!1,uint32le:!0,uint32be:!1,int8:!1,int16le:!0,int16be:!1,int32le:!0,int32be:!1,int64be:!1,int64le:!0,uint64be:!1,uint64le:!0,floatle:!0,floatbe:!1,doublele:!0,doublebe:!1},l=function(){function e(){this.varName="",this.type="",this.options={},this.next=null,this.head=null,this.compiled=null,this.endian="be",this.constructorFn=null,this.alias=null}return e.start=function(){return new e},e.prototype.primitiveGenerateN=function(e,t){var p=n[e],r=a[e];t.pushCode(t.generateVariable(this.varName)+" = dataView.get"+p+"(offset, "+r+");"),t.pushCode("offset += "+s[e]+";")},e.prototype.primitiveN=function(e,t,p){return this.setNextParser(e,t,p)},e.prototype.useThisEndian=function(e){return e+this.endian.toLowerCase()},e.prototype.uint8=function(e,t){return this.primitiveN("uint8",e,t)},e.prototype.uint16=function(e,t){return this.primitiveN(this.useThisEndian("uint16"),e,t)},e.prototype.uint16le=function(e,t){return this.primitiveN("uint16le",e,t)},e.prototype.uint16be=function(e,t){return this.primitiveN("uint16be",e,t)},e.prototype.uint32=function(e,t){return this.primitiveN(this.useThisEndian("uint32"),e,t)},e.prototype.uint32le=function(e,t){return this.primitiveN("uint32le",e,t)},e.prototype.uint32be=function(e,t){return this.primitiveN("uint32be",e,t)},e.prototype.int8=function(e,t){return this.primitiveN("int8",e,t)},e.prototype.int16=function(e,t){return this.primitiveN(this.useThisEndian("int16"),e,t)},e.prototype.int16le=function(e,t){return this.primitiveN("int16le",e,t)},e.prototype.int16be=function(e,t){return this.primitiveN("int16be",e,t)},e.prototype.int32=function(e,t){return this.primitiveN(this.useThisEndian("int32"),e,t)},e.prototype.int32le=function(e,t){return this.primitiveN("int32le",e,t)},e.prototype.int32be=function(e,t){return this.primitiveN("int32be",e,t)},e.prototype.bigIntVersionCheck=function(){if(!DataView.prototype.getBigInt64)throw new Error("BigInt64 is unsupported in this runtime")},e.prototype.int64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("int64"),e,t)},e.prototype.int64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64be",e,t)},e.prototype.int64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64le",e,t)},e.prototype.uint64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("uint64"),e,t)},e.prototype.uint64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64be",e,t)},e.prototype.uint64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64le",e,t)},e.prototype.floatle=function(e,t){return this.primitiveN("floatle",e,t)},e.prototype.floatbe=function(e,t){return this.primitiveN("floatbe",e,t)},e.prototype.doublele=function(e,t){return this.primitiveN("doublele",e,t)},e.prototype.doublebe=function(e,t){return this.primitiveN("doublebe",e,t)},e.prototype.bitN=function(e,t,p){return p||(p={}),p.length=e,this.setNextParser("bit",t,p)},e.prototype.bit1=function(e,t){return this.bitN(1,e,t)},e.prototype.bit2=function(e,t){return this.bitN(2,e,t)},e.prototype.bit3=function(e,t){return this.bitN(3,e,t)},e.prototype.bit4=function(e,t){return this.bitN(4,e,t)},e.prototype.bit5=function(e,t){return this.bitN(5,e,t)},e.prototype.bit6=function(e,t){return this.bitN(6,e,t)},e.prototype.bit7=function(e,t){return this.bitN(7,e,t)},e.prototype.bit8=function(e,t){return this.bitN(8,e,t)},e.prototype.bit9=function(e,t){return this.bitN(9,e,t)},e.prototype.bit10=function(e,t){return this.bitN(10,e,t)},e.prototype.bit11=function(e,t){return this.bitN(11,e,t)},e.prototype.bit12=function(e,t){return this.bitN(12,e,t)},e.prototype.bit13=function(e,t){return this.bitN(13,e,t)},e.prototype.bit14=function(e,t){return this.bitN(14,e,t)},e.prototype.bit15=function(e,t){return this.bitN(15,e,t)},e.prototype.bit16=function(e,t){return this.bitN(16,e,t)},e.prototype.bit17=function(e,t){return this.bitN(17,e,t)},e.prototype.bit18=function(e,t){return this.bitN(18,e,t)},e.prototype.bit19=function(e,t){return this.bitN(19,e,t)},e.prototype.bit20=function(e,t){return this.bitN(20,e,t)},e.prototype.bit21=function(e,t){return this.bitN(21,e,t)},e.prototype.bit22=function(e,t){return this.bitN(22,e,t)},e.prototype.bit23=function(e,t){return this.bitN(23,e,t)},e.prototype.bit24=function(e,t){return this.bitN(24,e,t)},e.prototype.bit25=function(e,t){return this.bitN(25,e,t)},e.prototype.bit26=function(e,t){return this.bitN(26,e,t)},e.prototype.bit27=function(e,t){return this.bitN(27,e,t)},e.prototype.bit28=function(e,t){return this.bitN(28,e,t)},e.prototype.bit29=function(e,t){return this.bitN(29,e,t)},e.prototype.bit30=function(e,t){return this.bitN(30,e,t)},e.prototype.bit31=function(e,t){return this.bitN(31,e,t)},e.prototype.bit32=function(e,t){return this.bitN(32,e,t)},e.prototype.namely=function(e){return o[e]=this,this.alias=e,this},e.prototype.skip=function(e,t){return this.seek(e,t)},e.prototype.seek=function(e,t){if(t&&t.assert)throw new Error("assert option on seek is not allowed.");return this.setNextParser("seek","",{length:e})},e.prototype.string=function(e,t){if(!t.zeroTerminated&&!t.length&&!t.greedy)throw new Error("Neither length, zeroTerminated, nor greedy is defined for string.");if((t.zeroTerminated||t.length)&&t.greedy)throw new Error("greedy is mutually exclusive with length and zeroTerminated for string.");if(t.stripNull&&!t.length&&!t.greedy)throw new Error("Length or greedy must be defined if stripNull is defined.");return t.encoding=t.encoding||"utf8",this.setNextParser("string",e,t)},e.prototype.buffer=function(e,t){if(!t.length&&!t.readUntil)throw new Error("Length nor readUntil is defined in buffer parser");return this.setNextParser("buffer",e,t)},e.prototype.wrapped=function(e,t){if(!t.length&&!t.readUntil)throw new Error("Length nor readUntil is defined in buffer parser");if(!t.wrapper||!t.type)throw new Error("Both wrapper and type must be defined in wrapper parser");return this.setNextParser("wrapper",e,t)},e.prototype.array=function(e,t){if(!t.readUntil&&!t.length&&!t.lengthInBytes)throw new Error("Length option of array is not defined.");if(!t.type)throw new Error("Type option of array is not defined.");if("string"==typeof t.type&&!o[t.type]&&Object.keys(s).indexOf(t.type)<0)throw new Error('Specified primitive type "'+t.type+'" is not supported.');return this.setNextParser("array",e,t)},e.prototype.choice=function(e,t){if("object"!=typeof t&&"object"==typeof e&&(t=e,e=null),!t.tag)throw new Error("Tag option of array is not defined.");if(!t.choices)throw new Error("Choices option of array is not defined.");return Object.keys(t.choices).forEach((function(p){var r=parseInt(p,10),i=t.choices[r];if(isNaN(r))throw new Error("Key of choices must be a number.");if(!i)throw new Error("Choice Case "+p+" of "+e+" is not valid.");if("string"==typeof i&&!o[i]&&Object.keys(s).indexOf(i)<0)throw new Error('Specified primitive type "'+i+'" is not supported.')})),this.setNextParser("choice",e,t)},e.prototype.nest=function(t,p){if("object"!=typeof p&&"object"==typeof t&&(p=t,t=null),!p.type)throw new Error("Type option of nest is not defined.");if(!(p.type instanceof e||o[p.type]))throw new Error("Type option of nest must be a Parser object.");if(!(p.type instanceof e||t))throw new Error("options.type must be a object if variable name is omitted.");return this.setNextParser("nest",t,p)},e.prototype.pointer=function(t,p){if(!p.offset)throw new Error("Offset option of pointer is not defined.");if(!p.type)throw new Error("Type option of pointer is not defined.");if("string"==typeof p.type){if(Object.keys(s).indexOf(p.type)<0&&!o[p.type])throw new Error('Specified type "'+p.type+'" is not supported.')}else if(!(p.type instanceof e))throw new Error("Type option of pointer must be a string or a Parser object.");return this.setNextParser("pointer",t,p)},e.prototype.saveOffset=function(e,t){return this.setNextParser("saveOffset",e,t)},e.prototype.endianess=function(e){switch(e.toLowerCase()){case"little":this.endian="le";break;case"big":this.endian="be";break;default:throw new Error("Invalid endianess: "+e)}return this},e.prototype.create=function(e){if(!(e instanceof Function))throw new Error("Constructor must be a Function object.");return this.constructorFn=e,this},e.prototype.getContext=function(e){var t=new r.Context(e);return t.pushCode("var dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"),this.alias?(this.addAliasedCode(t),t.pushCode("return "+(i+this.alias)+"(0).result;")):this.addRawCode(t),t},e.prototype.getCode=function(){return this.getContext().code},e.prototype.addRawCode=function(e){e.pushCode("var offset = 0;"),e.pushCode("var vars = "+(this.constructorFn?"new constructorFn()":"{}")+";"),e.pushCode("vars.$parent = null;"),e.pushCode("vars.$root = vars;"),this.generate(e),this.resolveReferences(e),e.pushCode("delete vars.$parent;"),e.pushCode("delete vars.$root;"),e.pushCode("return vars;")},e.prototype.addAliasedCode=function(e){return e.pushCode("function "+(i+this.alias)+"(offset, context) {"),e.pushCode("var vars = "+(this.constructorFn?"new constructorFn()":"{}")+";"),e.pushCode("var ctx = Object.assign({$parent: null, $root: vars}, context || {});"),e.pushCode("vars = Object.assign(vars, ctx);"),this.generate(e),e.markResolved(this.alias),this.resolveReferences(e),e.pushCode("Object.keys(ctx).forEach(function (item) { delete vars[item]; });"),e.pushCode("return { offset: offset, result: vars };"),e.pushCode("}"),e},e.prototype.resolveReferences=function(e){var t=e.getUnresolvedReferences();e.markRequested(t),t.forEach((function(t){o[t].addAliasedCode(e)}))},e.prototype.compile=function(){var e="imports",t=this.getContext(e);this.compiled=new Function(e,"TextDecoder","return function (buffer, constructorFn) { "+t.code+" };")(t.imports,TextDecoder)},e.prototype.sizeOf=function(){var t=NaN;if(Object.keys(s).indexOf(this.type)>=0)t=s[this.type];else if("string"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("buffer"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("array"===this.type&&"number"==typeof this.options.length){var p=NaN;"string"==typeof this.options.type?p=s[this.options.type]:this.options.type instanceof e&&(p=this.options.type.sizeOf()),t=this.options.length*p}else"seek"===this.type?t=this.options.length:"nest"===this.type?t=this.options.type.sizeOf():this.type||(t=0);return this.next&&(t+=this.next.sizeOf()),t},e.prototype.parse=function(e){return this.compiled||this.compile(),this.compiled(e,this.constructorFn)},e.prototype.setNextParser=function(t,p,r){var o=new e;return o.type=t,o.varName=p,o.options=r||o.options,o.endian=this.endian,this.head?this.head.next=o:this.next=o,this.head=o,this},e.prototype.generate=function(e){if(this.type){switch(this.type){case"uint8":case"uint16le":case"uint16be":case"uint32le":case"uint32be":case"int8":case"int16le":case"int16be":case"int32le":case"int32be":case"int64be":case"int64le":case"uint64be":case"uint64le":case"floatle":case"floatbe":case"doublele":case"doublebe":this.primitiveGenerateN(this.type,e);break;case"bit":this.generateBit(e);break;case"string":this.generateString(e);break;case"buffer":this.generateBuffer(e);break;case"seek":this.generateSeek(e);break;case"nest":this.generateNest(e);break;case"array":this.generateArray(e);break;case"choice":this.generateChoice(e);break;case"pointer":this.generatePointer(e);break;case"saveOffset":this.generateSaveOffset(e);break;case"wrapper":this.generateWrapper(e)}this.generateAssert(e)}var t=e.generateVariable(this.varName);return this.options.formatter&&this.generateFormatter(e,t,this.options.formatter),this.generateNext(e)},e.prototype.generateAssert=function(e){if(this.options.assert){var t=e.generateVariable(this.varName);switch(typeof this.options.assert){case"function":var p=e.addImport(this.options.assert);e.pushCode("if (!"+p+".call(vars, "+t+")) {");break;case"number":e.pushCode("if ("+this.options.assert+" !== "+t+") {");break;case"string":e.pushCode('if ("'+this.options.assert+'" !== '+t+") {");break;default:throw new Error("Assert option supports only strings, numbers and assert functions.")}e.generateError('"Assert error: '+t+' is " + '+this.options.assert),e.pushCode("}")}},e.prototype.generateNext=function(e){return this.next&&(e=this.next.generate(e)),e},e.prototype.generateBit=function(e){var t=JSON.parse(JSON.stringify(this));if(t.varName=e.generateVariable(t.varName),e.bitFields.push(t),!this.next||this.next&&["bit","nest"].indexOf(this.next.type)<0){var p=0;e.bitFields.forEach((function(e){return p+=e.options.length}));var r=e.generateTmpVariable();if(p<=8)e.pushCode("var "+r+" = dataView.getUint8(offset);"),p=8;else if(p<=16)e.pushCode("var "+r+" = dataView.getUint16(offset);"),p=16;else if(p<=24){var o=e.generateTmpVariable(),i=e.generateTmpVariable();e.pushCode("var "+o+" = dataView.getUint16(offset);"),e.pushCode("var "+i+" = dataView.getUint8(offset + 2);"),e.pushCode("var "+r+" = ("+o+" << 8) | "+i+";"),p=24}else{if(!(p<=32))throw new Error("Currently, bit field sequence longer than 4-bytes is not supported.");e.pushCode("var "+r+" = dataView.getUint32(offset);"),p=32}e.pushCode("offset += "+p/8+";");var s=0,n="be"===this.endian;e.bitFields.forEach((function(t){var o=t.options.length,i=n?p-s-o:s,a=(1<> "+i+" & "+a+";"),s+=o})),e.bitFields=[]}},e.prototype.generateSeek=function(e){var t=e.generateOption(this.options.length);e.pushCode("offset += "+t+";")},e.prototype.generateString=function(e){var t=e.generateVariable(this.varName),p=e.generateTmpVariable(),r=this.options.encoding,o="hex"===r.toLowerCase(),i='b => b.toString(16).padStart(2, "0")';if(this.options.length&&this.options.zeroTerminated){var s=this.options.length;e.pushCode("var "+p+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0 && offset - "+p+" < "+s+");");var n="offset - "+p+" < "+s+" ? offset - 1 : offset";e.pushCode(o?t+" = Array.from(buffer.subarray("+p+", "+n+"), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray("+p+", "+n+"));")}else this.options.length?(s=e.generateOption(this.options.length),e.pushCode(o?t+" = Array.from(buffer.subarray(offset, offset + "+s+"), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray(offset, offset + "+s+"));"),e.pushCode("offset += "+s+";")):this.options.zeroTerminated?(e.pushCode("var "+p+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+p+", offset - 1), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray("+p+", offset - 1));")):this.options.greedy&&(e.pushCode("var "+p+" = offset;"),e.pushCode("while(buffer.length > offset++);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+p+", offset), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray("+p+", offset));"));this.options.stripNull&&e.pushCode(t+" = "+t+".replace(/\\x00+$/g, '')")},e.prototype.generateBuffer=function(e){var t=e.generateVariable(this.varName);if("function"==typeof this.options.readUntil){var p=this.options.readUntil,r=e.generateTmpVariable(),o=e.generateTmpVariable();e.pushCode("var "+r+" = offset;"),e.pushCode("var "+o+" = 0;"),e.pushCode("while (offset < buffer.length) {"),e.pushCode(o+" = dataView.getUint8(offset);");var i=e.addImport(p);e.pushCode("if ("+i+".call("+e.generateVariable()+", "+o+", buffer.subarray(offset))) break;"),e.pushCode("offset += 1;"),e.pushCode("}"),e.pushCode(t+" = buffer.subarray("+r+", offset);")}else if("eof"===this.options.readUntil)e.pushCode(t+" = buffer.subarray(offset);");else{var s=e.generateOption(this.options.length);e.pushCode(t+" = buffer.subarray(offset, offset + "+s+");"),e.pushCode("offset += "+s+";")}this.options.clone&&e.pushCode(t+" = buffer.constructor.from("+t+");")},e.prototype.generateArray=function(t){var p=t.generateOption(this.options.length),r=t.generateOption(this.options.lengthInBytes),l=this.options.type,c=t.generateTmpVariable(),u=t.generateVariable(this.varName),y=t.generateTmpVariable(),f=this.options.key,d="string"==typeof f;if(d?t.pushCode(u+" = {};"):t.pushCode(u+" = [];"),"function"==typeof this.options.readUntil?t.pushCode("do {"):"eof"===this.options.readUntil?t.pushCode("for (var "+c+" = 0; offset < buffer.length; "+c+"++) {"):void 0!==r?t.pushCode("for (var "+c+" = offset + "+r+"; offset < "+c+"; ) {"):t.pushCode("for (var "+c+" = "+p+"; "+c+" > 0; "+c+"--) {"),"string"==typeof l)if(o[l]){var h=t.generateVariable(),_=t.generateTmpVariable();t.pushCode("var "+_+" = "+(i+l)+"(offset, {"),t.pushCode("$parent: "+h+","),t.pushCode("$root: "+h+".$root,"),this.options.readUntil||void 0!==r||t.pushCode("$index: "+p+" - "+c+","),t.pushCode("});"),t.pushCode("var "+y+" = "+_+".result; offset = "+_+".offset;"),l!==this.alias&&t.addReference(l)}else{var S=n[l],g=a[l];t.pushCode("var "+y+" = dataView.get"+S+"(offset, "+g+");"),t.pushCode("offset += "+s[l]+";")}else l instanceof e&&(h=t.generateVariable(),t.pushCode("var "+y+" = {};"),t.pushScope(y),t.pushCode(y+".$parent = "+h+";"),t.pushCode(y+".$root = "+h+".$root;"),this.options.readUntil||void 0!==r||t.pushCode(y+".$index = "+p+" - "+c+";"),l.generate(t),t.pushCode("delete "+y+".$parent;"),t.pushCode("delete "+y+".$root;"),t.pushCode("delete "+y+".$index;"),t.popScope());if(d?t.pushCode(u+"["+y+"."+f+"] = "+y+";"):t.pushCode(u+".push("+y+");"),t.pushCode("}"),"function"==typeof this.options.readUntil){var w=this.options.readUntil,E=t.addImport(w);t.pushCode("while (!"+E+".call("+t.generateVariable()+", "+y+", buffer.subarray(offset)));")}},e.prototype.generateChoiceCase=function(t,p,r){if("string"==typeof r){var l=t.generateVariable(this.varName);if(o[r]){var c=t.generateTmpVariable();t.pushCode("var "+c+" = "+(i+r)+"(offset, {"),t.pushCode("$parent: "+l+".$parent,"),t.pushCode("$root: "+l+".$root,"),t.pushCode("});"),t.pushCode(l+" = "+c+".result; offset = "+c+".offset;"),r!==this.alias&&t.addReference(r)}else{var u=n[r],y=a[r];t.pushCode(l+" = dataView.get"+u+"(offset, "+y+");"),t.pushCode("offset += "+s[r])}}else r instanceof e&&(t.pushPath(p),r.generate(t),t.popPath(p))},e.prototype.generateChoice=function(e){var t=this,p=e.generateOption(this.options.tag),r=e.generateVariable(this.varName);if(this.varName){e.pushCode(r+" = {};");var o=e.generateVariable();e.pushCode(r+".$parent = "+o+";"),e.pushCode(r+".$root = "+o+".$root;")}e.pushCode("switch("+p+") {"),Object.keys(this.options.choices).forEach((function(p){var r=t.options.choices[parseInt(p,10)];e.pushCode("case "+p+":"),t.generateChoiceCase(e,t.varName,r),e.pushCode("break;")})),e.pushCode("default:"),this.options.defaultChoice?this.generateChoiceCase(e,this.varName,this.options.defaultChoice):e.generateError('"Met undefined tag value " + '+p+' + " at choice"'),e.pushCode("}"),this.varName&&(e.pushCode("delete "+r+".$parent;"),e.pushCode("delete "+r+".$root;"))},e.prototype.generateNest=function(t){var p=t.generateVariable(this.varName);if(this.options.type instanceof e){if(this.varName){var r=t.generateVariable();t.pushCode(p+" = {};"),t.pushCode(p+".$parent = "+r+";"),t.pushCode(p+".$root = "+r+".$root;")}t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName),this.varName&&(t.pushCode("delete "+p+".$parent;"),t.pushCode("delete "+p+".$root;"))}else if(o[this.options.type]){r=t.generateVariable();var s=t.generateTmpVariable();t.pushCode("var "+s+" = "+(i+this.options.type)+"(offset, {"),t.pushCode("$parent: "+r+","),t.pushCode("$root: "+r+".$root,"),t.pushCode("});"),t.pushCode(p+" = "+s+".result; offset = "+s+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}},e.prototype.generateWrapper=function(t){var p=t.generateVariable(this.varName),r=t.generateTmpVariable();if("function"==typeof this.options.readUntil){var s=this.options.readUntil,n=t.generateTmpVariable(),a=t.generateTmpVariable();t.pushCode("var "+n+" = offset;"),t.pushCode("var "+a+" = 0;"),t.pushCode("while (offset < buffer.length) {"),t.pushCode(a+" = dataView.getUint8(offset);");var l=t.addImport(s);t.pushCode("if ("+l+".call("+t.generateVariable()+", "+a+", buffer.subarray(offset))) break;"),t.pushCode("offset += 1;"),t.pushCode("}"),t.pushCode(r+" = buffer.subarray("+n+", offset);")}else if("eof"===this.options.readUntil)t.pushCode(r+" = buffer.subarray(offset);");else{var c=t.generateOption(this.options.length);t.pushCode(r+" = buffer.subarray(offset, offset + "+c+");"),t.pushCode("offset += "+c+";")}this.options.clone&&t.pushCode(r+" = buffer.constructor.from("+r+");");var u=t.generateTmpVariable(),y=t.generateTmpVariable(),f=t.generateTmpVariable(),d=t.addImport(this.options.wrapper);if(t.pushCode(r+" = "+d+".call(this, "+r+").subarray(0);"),t.pushCode("var "+u+" = buffer;"),t.pushCode("var "+y+" = offset;"),t.pushCode("var "+f+" = dataView;"),t.pushCode("buffer = "+r+";"),t.pushCode("offset = 0;"),t.pushCode("dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"),this.options.type instanceof e)this.varName&&t.pushCode(p+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var h=t.generateTmpVariable();t.pushCode("var "+h+" = "+(i+this.options.type)+"(0);"),t.pushCode(p+" = "+h+".result;"),this.options.type!==this.alias&&t.addReference(this.options.type)}t.pushCode("buffer = "+u+";"),t.pushCode("dataView = "+f+";"),t.pushCode("offset = "+y+";")},e.prototype.generateFormatter=function(e,t,p){if("function"==typeof p){var r=e.addImport(p);e.pushCode(t+" = "+r+".call("+e.generateVariable()+", "+t+");")}},e.prototype.generatePointer=function(t){var p=this.options.type,r=t.generateOption(this.options.offset),l=t.generateTmpVariable(),c=t.generateVariable(this.varName);if(t.pushCode("var "+l+" = offset;"),t.pushCode("offset = "+r+";"),this.options.type instanceof e){var u=t.generateVariable();t.pushCode(c+" = {};"),t.pushCode(c+".$parent = "+u+";"),t.pushCode(c+".$root = "+u+".$root;"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName),t.pushCode("delete "+c+".$parent;"),t.pushCode("delete "+c+".$root;")}else if(o[this.options.type]){u=t.generateVariable();var y=t.generateTmpVariable();t.pushCode("var "+y+" = "+(i+this.options.type)+"(offset, {"),t.pushCode("$parent: "+u+","),t.pushCode("$root: "+u+".$root,"),t.pushCode("});"),t.pushCode(c+" = "+y+".result; offset = "+y+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}else if(Object.keys(s).indexOf(this.options.type)>=0){var f=n[p],d=a[p];t.pushCode(c+" = dataView.get"+f+"(offset, "+d+");"),t.pushCode("offset += "+s[p]+";")}t.pushCode("offset = "+l+";")},e.prototype.generateSaveOffset=function(e){var t=e.generateVariable(this.varName);e.pushCode(t+" = offset")},e}();t.i=l},5682:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Context=void 0;var p=function(){function e(e){this.code="",this.scopes=[["vars"]],this.bitFields=[],this.tmpVariableCount=0,this.references={},this.imports=[],this.reverseImports=new Map,this.importPath=e}return e.prototype.generateVariable=function(e){var t=[],p=this.scopes[this.scopes.length-1];return t.push.apply(t,p),e&&t.push(e),t.join(".")},e.prototype.generateOption=function(e){switch(typeof e){case"number":return e.toString();case"string":return this.generateVariable(e);case"function":return this.addImport(e)+".call("+this.generateVariable()+", vars)"}},e.prototype.generateError=function(e){this.pushCode("throw new Error("+e+");")},e.prototype.generateTmpVariable=function(){return"$tmp"+this.tmpVariableCount++},e.prototype.pushCode=function(e){this.code+=e+"\n"},e.prototype.pushPath=function(e){e&&this.scopes[this.scopes.length-1].push(e)},e.prototype.popPath=function(e){e&&this.scopes[this.scopes.length-1].pop()},e.prototype.pushScope=function(e){this.scopes.push([e])},e.prototype.popScope=function(){this.scopes.pop()},e.prototype.addImport=function(e){if(!this.importPath)return"("+e+")";var t=this.reverseImports.get(e);return t||(t=this.imports.push(e)-1,this.reverseImports.set(e,t)),this.importPath+"["+t+"]"},e.prototype.addReference=function(e){this.references[e]||(this.references[e]={resolved:!1,requested:!1})},e.prototype.markResolved=function(e){this.references[e].resolved=!0},e.prototype.markRequested=function(e){var t=this;e.forEach((function(e){t.references[e].requested=!0}))},e.prototype.getUnresolvedReferences=function(){var e=this.references;return Object.keys(this.references).filter((function(t){return!e[t].resolved&&!e[t].requested}))},e}();t.Context=p},3144:(e,t,p)=>{"use strict";var r=p(6743),o=p(1002),i=p(76),s=p(7119);e.exports=s||r.call(i,o)},2205:(e,t,p)=>{"use strict";var r=p(6743),o=p(1002),i=p(3144);e.exports=function(){return i(r,o,arguments)}},1002:e=>{"use strict";e.exports=Function.prototype.apply},76:e=>{"use strict";e.exports=Function.prototype.call},3126:(e,t,p)=>{"use strict";var r=p(6743),o=p(9675),i=p(76),s=p(3144);e.exports=function(e){if(e.length<1||"function"!=typeof e[0])throw new o("a function is required");return s(r,i,e)}},7119:e=>{"use strict";e.exports="undefined"!=typeof Reflect&&Reflect&&Reflect.apply},8075:(e,t,p)=>{"use strict";var r=p(453),o=p(487),i=o(r("String.prototype.indexOf"));e.exports=function(e,t){var p=r(e,!!t);return"function"==typeof p&&i(e,".prototype.")>-1?o(p):p}},487:(e,t,p)=>{"use strict";var r=p(6897),o=p(655),i=p(3126),s=p(2205);e.exports=function(e){var t=i(arguments),p=e.length-(arguments.length-1);return r(t,1+(p>0?p:0),!0)},o?o(e.exports,"apply",{value:s}):e.exports.apply=s},6556:(e,t,p)=>{"use strict";var r=p(453),o=p(3126),i=o([r("%String.prototype.indexOf%")]);e.exports=function(e,t){var p=r(e,!!t);return"function"==typeof p&&i(e,".prototype.")>-1?o([p]):p}},5971:e=>{function t(e){if(e)return function(e){return Object.assign(e,t.prototype),e._callbacks=new Map,e}(e);this._callbacks=new Map}t.prototype.on=function(e,t){const p=this._callbacks.get(e)??[];return p.push(t),this._callbacks.set(e,p),this},t.prototype.once=function(e,t){const p=(...r)=>{this.off(e,p),t.apply(this,r)};return p.fn=t,this.on(e,p),this},t.prototype.off=function(e,t){if(void 0===e&&void 0===t)return this._callbacks.clear(),this;if(void 0===t)return this._callbacks.delete(e),this;const p=this._callbacks.get(e);if(p){for(const[e,r]of p.entries())if(r===t||r.fn===t){p.splice(e,1);break}0===p.length?this._callbacks.delete(e):this._callbacks.set(e,p)}return this},t.prototype.emit=function(e,...t){const p=this._callbacks.get(e);if(p){const e=[...p];for(const p of e)p.apply(this,t)}return this},t.prototype.listeners=function(e){return this._callbacks.get(e)??[]},t.prototype.listenerCount=function(e){if(e)return this.listeners(e).length;let t=0;for(const e of this._callbacks.values())t+=e.length;return t},t.prototype.hasListeners=function(e){return this.listenerCount(e)>0},t.prototype.addEventListener=t.prototype.on,t.prototype.removeListener=t.prototype.off,t.prototype.removeEventListener=t.prototype.off,t.prototype.removeAllListeners=t.prototype.off,e.exports=t},7898:(e,t,p)=>{t.UINT32=p(741),t.UINT64=p(174)},741:function(e,t){var p;!function(){function r(e,t){return this instanceof r?(this._low=0,this._high=0,this.remainder=null,void 0===t?i.call(this,e):"string"==typeof e?s.call(this,e,t):void o.call(this,e,t)):new r(e,t)}function o(e,t){return this._low=0|e,this._high=0|t,this}function i(e){return this._low=65535&e,this._high=e>>>16,this}function s(e,t){var p=parseInt(e,t||10);return this._low=65535&p,this._high=p>>>16,this}r(Math.pow(36,5)),r(Math.pow(16,7)),r(Math.pow(10,9)),r(Math.pow(2,30)),r(36),r(16),r(10),r(2),r.prototype.fromBits=o,r.prototype.fromNumber=i,r.prototype.fromString=s,r.prototype.toNumber=function(){return 65536*this._high+this._low},r.prototype.toString=function(e){return this.toNumber().toString(e||10)},r.prototype.add=function(e){var t=this._low+e._low,p=t>>>16;return p+=this._high+e._high,this._low=65535&t,this._high=65535&p,this},r.prototype.subtract=function(e){return this.add(e.clone().negate())},r.prototype.multiply=function(e){var t,p,r=this._high,o=this._low,i=e._high,s=e._low;return t=(p=o*s)>>>16,t+=r*s,t&=65535,t+=o*i,this._low=65535&p,this._high=65535&t,this},r.prototype.div=function(e){if(0==e._low&&0==e._high)throw Error("division by zero");if(0==e._high&&1==e._low)return this.remainder=new r(0),this;if(e.gt(this))return this.remainder=this.clone(),this._low=0,this._high=0,this;if(this.eq(e))return this.remainder=new r(0),this._low=1,this._high=0,this;for(var t=e.clone(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._low=0,this._high=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=16?this._high|=1<>>16)&65535,this},r.prototype.equals=r.prototype.eq=function(e){return this._low==e._low&&this._high==e._high},r.prototype.greaterThan=r.prototype.gt=function(e){return this._high>e._high||!(this._highe._low},r.prototype.lessThan=r.prototype.lt=function(e){return this._highe._high)&&this._low16?(this._low=this._high>>e-16,this._high=0):16==e?(this._low=this._high,this._high=0):(this._low=this._low>>e|this._high<<16-e&65535,this._high>>=e),this},r.prototype.shiftLeft=r.prototype.shiftl=function(e,t){return e>16?(this._high=this._low<>16-e,this._low=this._low<>>32-e,this._low=65535&t,this._high=t>>>16,this},r.prototype.rotateRight=r.prototype.rotr=function(e){var t=this._high<<16|this._low;return t=t>>>e|t<<32-e,this._low=65535&t,this._high=t>>>16,this},r.prototype.clone=function(){return new r(this._low,this._high)},void 0===(p=function(){return r}.apply(t,[]))||(e.exports=p)}()},174:function(e,t){var p;!function(){var r={16:i(Math.pow(16,5)),10:i(Math.pow(10,5)),2:i(Math.pow(2,5))},o={16:i(16),10:i(10),2:i(2)};function i(e,t,p,r){return this instanceof i?(this.remainder=null,"string"==typeof e?a.call(this,e,t):void 0===t?n.call(this,e):void s.apply(this,arguments)):new i(e,t,p,r)}function s(e,t,p,r){return void 0===p?(this._a00=65535&e,this._a16=e>>>16,this._a32=65535&t,this._a48=t>>>16,this):(this._a00=0|e,this._a16=0|t,this._a32=0|p,this._a48=0|r,this)}function n(e){return this._a00=65535&e,this._a16=e>>>16,this._a32=0,this._a48=0,this}function a(e,t){t=t||10,this._a00=0,this._a16=0,this._a32=0,this._a48=0;for(var p=r[t]||new i(Math.pow(t,5)),o=0,s=e.length;o=0&&(p.div(t),r[s]=p.remainder.toNumber().toString(e),p.gt(t));s--);return r[s-1]=p.toNumber().toString(e),r.join("")},i.prototype.add=function(e){var t=this._a00+e._a00,p=t>>>16,r=(p+=this._a16+e._a16)>>>16,o=(r+=this._a32+e._a32)>>>16;return o+=this._a48+e._a48,this._a00=65535&t,this._a16=65535&p,this._a32=65535&r,this._a48=65535&o,this},i.prototype.subtract=function(e){return this.add(e.clone().negate())},i.prototype.multiply=function(e){var t=this._a00,p=this._a16,r=this._a32,o=this._a48,i=e._a00,s=e._a16,n=e._a32,a=t*i,l=a>>>16,c=(l+=t*s)>>>16;l&=65535,c+=(l+=p*i)>>>16;var u=(c+=t*n)>>>16;return c&=65535,u+=(c+=p*s)>>>16,c&=65535,u+=(c+=r*i)>>>16,u+=t*e._a48,u&=65535,u+=p*n,u&=65535,u+=r*s,u&=65535,u+=o*i,this._a00=65535&a,this._a16=65535&l,this._a32=65535&c,this._a48=65535&u,this},i.prototype.div=function(e){if(0==e._a16&&0==e._a32&&0==e._a48){if(0==e._a00)throw Error("division by zero");if(1==e._a00)return this.remainder=new i(0),this}if(e.gt(this))return this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0,this;if(this.eq(e))return this.remainder=new i(0),this._a00=1,this._a16=0,this._a32=0,this._a48=0,this;for(var t=e.clone(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=48?this._a48|=1<=32?this._a32|=1<=16?this._a16|=1<>>16),this._a16=65535&e,e=(65535&~this._a32)+(e>>>16),this._a32=65535&e,this._a48=~this._a48+(e>>>16)&65535,this},i.prototype.equals=i.prototype.eq=function(e){return this._a48==e._a48&&this._a00==e._a00&&this._a32==e._a32&&this._a16==e._a16},i.prototype.greaterThan=i.prototype.gt=function(e){return this._a48>e._a48||!(this._a48e._a32||!(this._a32e._a16||!(this._a16e._a00))},i.prototype.lessThan=i.prototype.lt=function(e){return this._a48e._a48)&&(this._a32e._a32)&&(this._a16e._a16)&&this._a00=48?(this._a00=this._a48>>e-48,this._a16=0,this._a32=0,this._a48=0):e>=32?(e-=32,this._a00=65535&(this._a32>>e|this._a48<<16-e),this._a16=this._a48>>e&65535,this._a32=0,this._a48=0):e>=16?(e-=16,this._a00=65535&(this._a16>>e|this._a32<<16-e),this._a16=65535&(this._a32>>e|this._a48<<16-e),this._a32=this._a48>>e&65535,this._a48=0):(this._a00=65535&(this._a00>>e|this._a16<<16-e),this._a16=65535&(this._a16>>e|this._a32<<16-e),this._a32=65535&(this._a32>>e|this._a48<<16-e),this._a48=this._a48>>e&65535),this},i.prototype.shiftLeft=i.prototype.shiftl=function(e,t){return(e%=64)>=48?(this._a48=this._a00<=32?(e-=32,this._a48=this._a16<>16-e,this._a32=this._a00<=16?(e-=16,this._a48=this._a32<>16-e,this._a32=65535&(this._a16<>16-e),this._a16=this._a00<>16-e,this._a32=65535&(this._a32<>16-e),this._a16=65535&(this._a16<>16-e),this._a00=this._a00<=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p<>>32-e,i=r<>>32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},i.prototype.rotateRight=i.prototype.rotr=function(e){if(0==(e%=64))return this;if(e>=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p>>>e|r<<32-e,i=r>>>e|p<<32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},i.prototype.clone=function(){return new i(this._a00,this._a16,this._a32,this._a48)},void 0===(p=function(){return i}.apply(t,[]))||(e.exports=p)}()},41:(e,t,p)=>{"use strict";var r=p(655),o=p(8068),i=p(9675),s=p(5795);e.exports=function(e,t,p){if(!e||"object"!=typeof e&&"function"!=typeof e)throw new i("`obj` must be an object or a function`");if("string"!=typeof t&&"symbol"!=typeof t)throw new i("`property` must be a string or a symbol`");if(arguments.length>3&&"boolean"!=typeof arguments[3]&&null!==arguments[3])throw new i("`nonEnumerable`, if provided, must be a boolean or null");if(arguments.length>4&&"boolean"!=typeof arguments[4]&&null!==arguments[4])throw new i("`nonWritable`, if provided, must be a boolean or null");if(arguments.length>5&&"boolean"!=typeof arguments[5]&&null!==arguments[5])throw new i("`nonConfigurable`, if provided, must be a boolean or null");if(arguments.length>6&&"boolean"!=typeof arguments[6])throw new i("`loose`, if provided, must be a boolean");var n=arguments.length>3?arguments[3]:null,a=arguments.length>4?arguments[4]:null,l=arguments.length>5?arguments[5]:null,c=arguments.length>6&&arguments[6],u=!!s&&s(e,t);if(r)r(e,t,{configurable:null===l&&u?u.configurable:!l,enumerable:null===n&&u?u.enumerable:!n,value:p,writable:null===a&&u?u.writable:!a});else{if(!c&&(n||a||l))throw new o("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");e[t]=p}}},8452:(e,t,p)=>{"use strict";var r=p(1189),o="function"==typeof Symbol&&"symbol"==typeof Symbol("foo"),i=Object.prototype.toString,s=Array.prototype.concat,n=p(41),a=p(592)(),l=function(e,t,p,r){if(t in e)if(!0===r){if(e[t]===p)return}else if("function"!=typeof(o=r)||"[object Function]"!==i.call(o)||!r())return;var o;a?n(e,t,p,!0):n(e,t,p)},c=function(e,t){var p=arguments.length>2?arguments[2]:{},i=r(t);o&&(i=s.call(i,Object.getOwnPropertySymbols(t)));for(var n=0;n{"use strict";var r,o=p(3126),i=p(5795);try{r=[].__proto__===Array.prototype}catch(e){if(!e||"object"!=typeof e||!("code"in e)||"ERR_PROTO_ACCESS"!==e.code)throw e}var s=!!r&&i&&i(Object.prototype,"__proto__"),n=Object,a=n.getPrototypeOf;e.exports=s&&"function"==typeof s.get?o([s.get]):"function"==typeof a&&function(e){return a(null==e?e:n(e))}},655:e=>{"use strict";var t=Object.defineProperty||!1;if(t)try{t({},"a",{value:1})}catch(e){t=!1}e.exports=t},1237:e=>{"use strict";e.exports=EvalError},9383:e=>{"use strict";e.exports=Error},9290:e=>{"use strict";e.exports=RangeError},9538:e=>{"use strict";e.exports=ReferenceError},8068:e=>{"use strict";e.exports=SyntaxError},9675:e=>{"use strict";e.exports=TypeError},5345:e=>{"use strict";e.exports=URIError},9612:e=>{"use strict";e.exports=Object},9160:function(e,t,p){!function(e){"use strict";function t(e){for(var t=0,p=Math.min(65536,e.length+1),r=new Uint16Array(p),o=[],i=0;;){var s=t=p-1){var n=r.subarray(0,i);if(o.push(String.fromCharCode.apply(null,n)),!s)return o.join("");e=e.subarray(t),t=0,i=0}var a=e[t++];if(128&a){if(192==(224&a)){var l=63&e[t++];r[i++]=(31&a)<<6|l}else if(224==(240&a)){l=63&e[t++];var c=63&e[t++];r[i++]=(31&a)<<12|l<<6|c}else if(240==(248&a)){var u=(7&a)<<18|(l=63&e[t++])<<12|(c=63&e[t++])<<6|63&e[t++];u>65535&&(u-=65536,r[i++]=u>>>10&1023|55296,u=56320|1023&u),r[i++]=u}}else r[i++]=a}}var p="Failed to ",r=function(e,t,r){if(e)throw new Error("".concat(p).concat(t,": the '").concat(r,"' option is unsupported."))},o="function"==typeof Buffer&&Buffer.from,i=o?function(e){return Buffer.from(e)}:function(e){for(var t=0,p=e.length,r=0,o=Math.max(32,p+(p>>>1)+7),i=new Uint8Array(o>>>3<<3);t=55296&&s<=56319){if(t=55296&&s<=56319)continue}if(r+4>i.length){o+=8,o=(o*=1+t/e.length*2)>>>3<<3;var a=new Uint8Array(o);a.set(i),i=a}if(4294967168&s){if(4294965248&s)if(4294901760&s){if(4292870144&s)continue;i[r++]=s>>>18&7|240,i[r++]=s>>>12&63|128,i[r++]=s>>>6&63|128}else i[r++]=s>>>12&15|224,i[r++]=s>>>6&63|128;else i[r++]=s>>>6&31|192;i[r++]=63&s|128}else i[r++]=s}return i.slice?i.slice(0,r):i.subarray(0,r)};function s(){this.encoding="utf-8"}s.prototype.encode=function(e,t){return r(t&&t.stream,"encode","stream"),i(e)};var n=!o&&"function"==typeof Blob&&"function"==typeof URL&&"function"==typeof URL.createObjectURL,a=["utf-8","utf8","unicode-1-1-utf-8"],l=t;o?l=function(e,t){return(e instanceof Buffer?e:Buffer.from(e.buffer,e.byteOffset,e.byteLength)).toString(t)}:n&&(l=function(e){try{return function(e){var t;try{var p=new Blob([e],{type:"text/plain;charset=UTF-8"});t=URL.createObjectURL(p);var r=new XMLHttpRequest;return r.open("GET",t,!1),r.send(),r.responseText}finally{t&&URL.revokeObjectURL(t)}}(e)}catch(p){return t(e)}});var c="construct 'TextDecoder'",u="".concat(p," ").concat(c,": the ");function y(e,t){if(r(t&&t.fatal,c,"fatal"),e=e||"utf-8",!(o?Buffer.isEncoding(e):-1!==a.indexOf(e.toLowerCase())))throw new RangeError("".concat(u," encoding label provided ('").concat(e,"') is invalid."));this.encoding=e,this.fatal=!1,this.ignoreBOM=!1}y.prototype.decode=function(e,t){var p;return r(t&&t.stream,"decode","stream"),p=e instanceof Uint8Array?e:e.buffer instanceof ArrayBuffer?new Uint8Array(e.buffer):new Uint8Array(e),l(p,this.encoding)},e.TextEncoder=e.TextEncoder||s,e.TextDecoder=e.TextDecoder||y}("undefined"!=typeof window?window:void 0!==p.g?p.g:this)},2682:(e,t,p)=>{"use strict";var r=p(9600),o=Object.prototype.toString,i=Object.prototype.hasOwnProperty;e.exports=function(e,t,p){if(!r(t))throw new TypeError("iterator must be a function");var s;arguments.length>=3&&(s=p),"[object Array]"===o.call(e)?function(e,t,p){for(var r=0,o=e.length;r{"use strict";var t=Object.prototype.toString,p=Math.max,r=function(e,t){for(var p=[],r=0;r{"use strict";var r=p(9353);e.exports=Function.prototype.bind||r},453:(e,t,p)=>{"use strict";var r,o=p(9612),i=p(9383),s=p(1237),n=p(9290),a=p(9538),l=p(8068),c=p(9675),u=p(5345),y=p(1514),f=p(8968),d=p(6188),h=p(8002),_=p(5880),S=p(414),g=p(3093),w=Function,E=function(e){try{return w('"use strict"; return ('+e+").constructor;")()}catch(e){}},m=p(5795),b=p(655),I=function(){throw new c},L=m?function(){try{return I}catch(e){try{return m(arguments,"callee").get}catch(e){return I}}}():I,T=p(4039)(),v=p(3628),U=p(1064),O=p(8648),M=p(1002),D=p(76),A={},G="undefined"!=typeof Uint8Array&&v?v(Uint8Array):r,C={__proto__:null,"%AggregateError%":"undefined"==typeof AggregateError?r:AggregateError,"%Array%":Array,"%ArrayBuffer%":"undefined"==typeof ArrayBuffer?r:ArrayBuffer,"%ArrayIteratorPrototype%":T&&v?v([][Symbol.iterator]()):r,"%AsyncFromSyncIteratorPrototype%":r,"%AsyncFunction%":A,"%AsyncGenerator%":A,"%AsyncGeneratorFunction%":A,"%AsyncIteratorPrototype%":A,"%Atomics%":"undefined"==typeof Atomics?r:Atomics,"%BigInt%":"undefined"==typeof BigInt?r:BigInt,"%BigInt64Array%":"undefined"==typeof BigInt64Array?r:BigInt64Array,"%BigUint64Array%":"undefined"==typeof BigUint64Array?r:BigUint64Array,"%Boolean%":Boolean,"%DataView%":"undefined"==typeof DataView?r:DataView,"%Date%":Date,"%decodeURI%":decodeURI,"%decodeURIComponent%":decodeURIComponent,"%encodeURI%":encodeURI,"%encodeURIComponent%":encodeURIComponent,"%Error%":i,"%eval%":eval,"%EvalError%":s,"%Float32Array%":"undefined"==typeof Float32Array?r:Float32Array,"%Float64Array%":"undefined"==typeof Float64Array?r:Float64Array,"%FinalizationRegistry%":"undefined"==typeof FinalizationRegistry?r:FinalizationRegistry,"%Function%":w,"%GeneratorFunction%":A,"%Int8Array%":"undefined"==typeof Int8Array?r:Int8Array,"%Int16Array%":"undefined"==typeof Int16Array?r:Int16Array,"%Int32Array%":"undefined"==typeof Int32Array?r:Int32Array,"%isFinite%":isFinite,"%isNaN%":isNaN,"%IteratorPrototype%":T&&v?v(v([][Symbol.iterator]())):r,"%JSON%":"object"==typeof JSON?JSON:r,"%Map%":"undefined"==typeof Map?r:Map,"%MapIteratorPrototype%":"undefined"!=typeof Map&&T&&v?v((new Map)[Symbol.iterator]()):r,"%Math%":Math,"%Number%":Number,"%Object%":o,"%Object.getOwnPropertyDescriptor%":m,"%parseFloat%":parseFloat,"%parseInt%":parseInt,"%Promise%":"undefined"==typeof Promise?r:Promise,"%Proxy%":"undefined"==typeof Proxy?r:Proxy,"%RangeError%":n,"%ReferenceError%":a,"%Reflect%":"undefined"==typeof Reflect?r:Reflect,"%RegExp%":RegExp,"%Set%":"undefined"==typeof Set?r:Set,"%SetIteratorPrototype%":"undefined"!=typeof Set&&T&&v?v((new Set)[Symbol.iterator]()):r,"%SharedArrayBuffer%":"undefined"==typeof SharedArrayBuffer?r:SharedArrayBuffer,"%String%":String,"%StringIteratorPrototype%":T&&v?v(""[Symbol.iterator]()):r,"%Symbol%":T?Symbol:r,"%SyntaxError%":l,"%ThrowTypeError%":L,"%TypedArray%":G,"%TypeError%":c,"%Uint8Array%":"undefined"==typeof Uint8Array?r:Uint8Array,"%Uint8ClampedArray%":"undefined"==typeof Uint8ClampedArray?r:Uint8ClampedArray,"%Uint16Array%":"undefined"==typeof Uint16Array?r:Uint16Array,"%Uint32Array%":"undefined"==typeof Uint32Array?r:Uint32Array,"%URIError%":u,"%WeakMap%":"undefined"==typeof WeakMap?r:WeakMap,"%WeakRef%":"undefined"==typeof WeakRef?r:WeakRef,"%WeakSet%":"undefined"==typeof WeakSet?r:WeakSet,"%Function.prototype.call%":D,"%Function.prototype.apply%":M,"%Object.defineProperty%":b,"%Object.getPrototypeOf%":U,"%Math.abs%":y,"%Math.floor%":f,"%Math.max%":d,"%Math.min%":h,"%Math.pow%":_,"%Math.round%":S,"%Math.sign%":g,"%Reflect.getPrototypeOf%":O};if(v)try{null.error}catch(e){var j=v(v(e));C["%Error.prototype%"]=j}var P=function e(t){var p;if("%AsyncFunction%"===t)p=E("async function () {}");else if("%GeneratorFunction%"===t)p=E("function* () {}");else if("%AsyncGeneratorFunction%"===t)p=E("async function* () {}");else if("%AsyncGenerator%"===t){var r=e("%AsyncGeneratorFunction%");r&&(p=r.prototype)}else if("%AsyncIteratorPrototype%"===t){var o=e("%AsyncGenerator%");o&&v&&(p=v(o.prototype))}return C[t]=p,p},R={__proto__:null,"%ArrayBufferPrototype%":["ArrayBuffer","prototype"],"%ArrayPrototype%":["Array","prototype"],"%ArrayProto_entries%":["Array","prototype","entries"],"%ArrayProto_forEach%":["Array","prototype","forEach"],"%ArrayProto_keys%":["Array","prototype","keys"],"%ArrayProto_values%":["Array","prototype","values"],"%AsyncFunctionPrototype%":["AsyncFunction","prototype"],"%AsyncGenerator%":["AsyncGeneratorFunction","prototype"],"%AsyncGeneratorPrototype%":["AsyncGeneratorFunction","prototype","prototype"],"%BooleanPrototype%":["Boolean","prototype"],"%DataViewPrototype%":["DataView","prototype"],"%DatePrototype%":["Date","prototype"],"%ErrorPrototype%":["Error","prototype"],"%EvalErrorPrototype%":["EvalError","prototype"],"%Float32ArrayPrototype%":["Float32Array","prototype"],"%Float64ArrayPrototype%":["Float64Array","prototype"],"%FunctionPrototype%":["Function","prototype"],"%Generator%":["GeneratorFunction","prototype"],"%GeneratorPrototype%":["GeneratorFunction","prototype","prototype"],"%Int8ArrayPrototype%":["Int8Array","prototype"],"%Int16ArrayPrototype%":["Int16Array","prototype"],"%Int32ArrayPrototype%":["Int32Array","prototype"],"%JSONParse%":["JSON","parse"],"%JSONStringify%":["JSON","stringify"],"%MapPrototype%":["Map","prototype"],"%NumberPrototype%":["Number","prototype"],"%ObjectPrototype%":["Object","prototype"],"%ObjProto_toString%":["Object","prototype","toString"],"%ObjProto_valueOf%":["Object","prototype","valueOf"],"%PromisePrototype%":["Promise","prototype"],"%PromiseProto_then%":["Promise","prototype","then"],"%Promise_all%":["Promise","all"],"%Promise_reject%":["Promise","reject"],"%Promise_resolve%":["Promise","resolve"],"%RangeErrorPrototype%":["RangeError","prototype"],"%ReferenceErrorPrototype%":["ReferenceError","prototype"],"%RegExpPrototype%":["RegExp","prototype"],"%SetPrototype%":["Set","prototype"],"%SharedArrayBufferPrototype%":["SharedArrayBuffer","prototype"],"%StringPrototype%":["String","prototype"],"%SymbolPrototype%":["Symbol","prototype"],"%SyntaxErrorPrototype%":["SyntaxError","prototype"],"%TypedArrayPrototype%":["TypedArray","prototype"],"%TypeErrorPrototype%":["TypeError","prototype"],"%Uint8ArrayPrototype%":["Uint8Array","prototype"],"%Uint8ClampedArrayPrototype%":["Uint8ClampedArray","prototype"],"%Uint16ArrayPrototype%":["Uint16Array","prototype"],"%Uint32ArrayPrototype%":["Uint32Array","prototype"],"%URIErrorPrototype%":["URIError","prototype"],"%WeakMapPrototype%":["WeakMap","prototype"],"%WeakSetPrototype%":["WeakSet","prototype"]},N=p(6743),x=p(9957),F=N.call(D,Array.prototype.concat),k=N.call(M,Array.prototype.splice),B=N.call(D,String.prototype.replace),q=N.call(D,String.prototype.slice),z=N.call(D,RegExp.prototype.exec),V=/[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g,H=/\\(\\)?/g,$=function(e,t){var p,r=e;if(x(R,r)&&(r="%"+(p=R[r])[0]+"%"),x(C,r)){var o=C[r];if(o===A&&(o=P(r)),void 0===o&&!t)throw new c("intrinsic "+e+" exists, but is not available. Please file an issue!");return{alias:p,name:r,value:o}}throw new l("intrinsic "+e+" does not exist!")};e.exports=function(e,t){if("string"!=typeof e||0===e.length)throw new c("intrinsic name must be a non-empty string");if(arguments.length>1&&"boolean"!=typeof t)throw new c('"allowMissing" argument must be a boolean');if(null===z(/^%?[^%]*%?$/,e))throw new l("`%` may not be present anywhere but at the beginning and end of the intrinsic name");var p=function(e){var t=q(e,0,1),p=q(e,-1);if("%"===t&&"%"!==p)throw new l("invalid intrinsic syntax, expected closing `%`");if("%"===p&&"%"!==t)throw new l("invalid intrinsic syntax, expected opening `%`");var r=[];return B(e,V,(function(e,t,p,o){r[r.length]=p?B(o,H,"$1"):t||e})),r}(e),r=p.length>0?p[0]:"",o=$("%"+r+"%",t),i=o.name,s=o.value,n=!1,a=o.alias;a&&(r=a[0],k(p,F([0,1],a)));for(var u=1,y=!0;u=p.length){var _=m(s,f);s=(y=!!_)&&"get"in _&&!("originalValue"in _.get)?_.get:s[f]}else y=x(s,f),s=s[f];y&&!n&&(C[i]=s)}}return s}},1064:(e,t,p)=>{"use strict";var r=p(9612);e.exports=r.getPrototypeOf||null},8648:e=>{"use strict";e.exports="undefined"!=typeof Reflect&&Reflect.getPrototypeOf||null},3628:(e,t,p)=>{"use strict";var r=p(8648),o=p(1064),i=p(7176);e.exports=r?function(e){return r(e)}:o?function(e){if(!e||"object"!=typeof e&&"function"!=typeof e)throw new TypeError("getProto: not an object");return o(e)}:i?function(e){return i(e)}:null},6549:e=>{"use strict";e.exports=Object.getOwnPropertyDescriptor},5795:(e,t,p)=>{"use strict";var r=p(6549);if(r)try{r([],"length")}catch(e){r=null}e.exports=r},592:(e,t,p)=>{"use strict";var r=p(655),o=function(){return!!r};o.hasArrayLengthDefineBug=function(){if(!r)return null;try{return 1!==r([],"length",{value:1}).length}catch(e){return!0}},e.exports=o},4039:(e,t,p)=>{"use strict";var r="undefined"!=typeof Symbol&&Symbol,o=p(1333);e.exports=function(){return"function"==typeof r&&"function"==typeof Symbol&&"symbol"==typeof r("foo")&&"symbol"==typeof Symbol("bar")&&o()}},1333:e=>{"use strict";e.exports=function(){if("function"!=typeof Symbol||"function"!=typeof Object.getOwnPropertySymbols)return!1;if("symbol"==typeof Symbol.iterator)return!0;var e={},t=Symbol("test"),p=Object(t);if("string"==typeof t)return!1;if("[object Symbol]"!==Object.prototype.toString.call(t))return!1;if("[object Symbol]"!==Object.prototype.toString.call(p))return!1;for(var r in e[t]=42,e)return!1;if("function"==typeof Object.keys&&0!==Object.keys(e).length)return!1;if("function"==typeof Object.getOwnPropertyNames&&0!==Object.getOwnPropertyNames(e).length)return!1;var o=Object.getOwnPropertySymbols(e);if(1!==o.length||o[0]!==t)return!1;if(!Object.prototype.propertyIsEnumerable.call(e,t))return!1;if("function"==typeof Object.getOwnPropertyDescriptor){var i=Object.getOwnPropertyDescriptor(e,t);if(42!==i.value||!0!==i.enumerable)return!1}return!0}},9092:(e,t,p)=>{"use strict";var r=p(1333);e.exports=function(){return r()&&!!Symbol.toStringTag}},9957:(e,t,p)=>{"use strict";var r=Function.prototype.call,o=Object.prototype.hasOwnProperty,i=p(6743);e.exports=i.call(r,o)},6698:e=>{"function"==typeof Object.create?e.exports=function(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}))}:e.exports=function(e,t){if(t){e.super_=t;var p=function(){};p.prototype=t.prototype,e.prototype=new p,e.prototype.constructor=e}}},7244:(e,t,p)=>{"use strict";var r=p(9092)(),o=p(6556)("Object.prototype.toString"),i=function(e){return!(r&&e&&"object"==typeof e&&Symbol.toStringTag in e)&&"[object Arguments]"===o(e)},s=function(e){return!!i(e)||null!==e&&"object"==typeof e&&"length"in e&&"number"==typeof e.length&&e.length>=0&&"[object Array]"!==o(e)&&"callee"in e&&"[object Function]"===o(e.callee)},n=function(){return i(arguments)}();i.isLegacyArguments=s,e.exports=n?i:s},9600:e=>{"use strict";var t,p,r=Function.prototype.toString,o="object"==typeof Reflect&&null!==Reflect&&Reflect.apply;if("function"==typeof o&&"function"==typeof Object.defineProperty)try{t=Object.defineProperty({},"length",{get:function(){throw p}}),p={},o((function(){throw 42}),null,t)}catch(e){e!==p&&(o=null)}else o=null;var i=/^\s*class\b/,s=function(e){try{var t=r.call(e);return i.test(t)}catch(e){return!1}},n=function(e){try{return!s(e)&&(r.call(e),!0)}catch(e){return!1}},a=Object.prototype.toString,l="function"==typeof Symbol&&!!Symbol.toStringTag,c=!(0 in[,]),u=function(){return!1};if("object"==typeof document){var y=document.all;a.call(y)===a.call(document.all)&&(u=function(e){if((c||!e)&&(void 0===e||"object"==typeof e))try{var t=a.call(e);return("[object HTMLAllCollection]"===t||"[object HTML document.all class]"===t||"[object HTMLCollection]"===t||"[object Object]"===t)&&null==e("")}catch(e){}return!1})}e.exports=o?function(e){if(u(e))return!0;if(!e)return!1;if("function"!=typeof e&&"object"!=typeof e)return!1;try{o(e,null,t)}catch(e){if(e!==p)return!1}return!s(e)&&n(e)}:function(e){if(u(e))return!0;if(!e)return!1;if("function"!=typeof e&&"object"!=typeof e)return!1;if(l)return n(e);if(s(e))return!1;var t=a.call(e);return!("[object Function]"!==t&&"[object GeneratorFunction]"!==t&&!/^\[object HTML/.test(t))&&n(e)}},8184:(e,t,p)=>{"use strict";var r,o=p(6556),i=p(9721)(/^\s*(?:function)?\*/),s=p(9092)(),n=p(3628),a=o("Object.prototype.toString"),l=o("Function.prototype.toString");e.exports=function(e){if("function"!=typeof e)return!1;if(i(l(e)))return!0;if(!s)return"[object GeneratorFunction]"===a(e);if(!n)return!1;if(void 0===r){var t=function(){if(!s)return!1;try{return Function("return function*() {}")()}catch(e){}}();r=!!t&&n(t)}return n(e)===r}},3003:e=>{"use strict";e.exports=function(e){return e!=e}},4133:(e,t,p)=>{"use strict";var r=p(487),o=p(8452),i=p(3003),s=p(6642),n=p(2464),a=r(s(),Number);o(a,{getPolyfill:s,implementation:i,shim:n}),e.exports=a},6642:(e,t,p)=>{"use strict";var r=p(3003);e.exports=function(){return Number.isNaN&&Number.isNaN(NaN)&&!Number.isNaN("a")?Number.isNaN:r}},2464:(e,t,p)=>{"use strict";var r=p(8452),o=p(6642);e.exports=function(){var e=o();return r(Number,{isNaN:e},{isNaN:function(){return Number.isNaN!==e}}),e}},4035:(e,t,p)=>{"use strict";var r,o=p(6556),i=p(9092)(),s=p(9957),n=p(5795);if(i){var a=o("RegExp.prototype.exec"),l={},c=function(){throw l},u={toString:c,valueOf:c};"symbol"==typeof Symbol.toPrimitive&&(u[Symbol.toPrimitive]=c),r=function(e){if(!e||"object"!=typeof e)return!1;var t=n(e,"lastIndex");if(!t||!s(t,"value"))return!1;try{a(e,u)}catch(e){return e===l}}}else{var y=o("Object.prototype.toString");r=function(e){return!(!e||"object"!=typeof e&&"function"!=typeof e)&&"[object RegExp]"===y(e)}}e.exports=r},5680:(e,t,p)=>{"use strict";var r=p(5767);e.exports=function(e){return!!r(e)}},1514:e=>{"use strict";e.exports=Math.abs},8968:e=>{"use strict";e.exports=Math.floor},4459:e=>{"use strict";e.exports=Number.isNaN||function(e){return e!=e}},6188:e=>{"use strict";e.exports=Math.max},8002:e=>{"use strict";e.exports=Math.min},5880:e=>{"use strict";e.exports=Math.pow},414:e=>{"use strict";e.exports=Math.round},3093:(e,t,p)=>{"use strict";var r=p(4459);e.exports=function(e){return r(e)||0===e?e:e<0?-1:1}},6468:e=>{for(var t=4294967296,p=[],r=0;r<256;r++)p[r]=(r>15?"":"0")+r.toString(16);var o=e.exports=function(e,t){e instanceof Buffer?(this.buffer=e,this.offset=t||0):"[object Uint8Array]"==Object.prototype.toString.call(e)?(this.buffer=new Buffer(e),this.offset=t||0):(this.buffer=this.buffer||new Buffer(8),this.offset=0,this.setValue.apply(this,arguments))};o.MAX_INT=Math.pow(2,53),o.MIN_INT=-Math.pow(2,53),o.prototype={constructor:o,_2scomp:function(){for(var e=this.buffer,t=this.offset,p=1,r=t+7;r>=t;r--){var o=(255^e[r])+p;e[r]=255&o,p=o>>8}},setValue:function(e,p){var r=!1;if(1==arguments.length)if("number"==typeof e){if(r=e<0,p=(e=Math.abs(e))%t,(e/=t)>t)throw new RangeError(e+" is outside Int64 range");e|=0}else{if("string"!=typeof e)throw new Error(e+" must be a Number or String");p=(e=(e+"").replace(/^0x/,"")).substr(-8),e=e.length>8?e.substr(0,e.length-8):"",e=parseInt(e,16),p=parseInt(p,16)}for(var o=this.buffer,i=this.offset,s=7;s>=0;s--)o[i+s]=255&p,p=4==s?e:p>>>8;r&&this._2scomp()},toNumber:function(e){for(var t=this.buffer,p=this.offset,r=128&t[p],i=0,s=1,n=7,a=1;n>=0;n--,a*=256){var l=t[p+n];r&&(s=(l=(255^l)+s)>>8,l&=255),i+=l*a}return!e&&i>=o.MAX_INT?r?-1/0:1/0:r?-i:i},valueOf:function(){return this.toNumber(!1)},toString:function(e){return this.valueOf().toString(e||10)},toOctetString:function(e){for(var t=new Array(8),r=this.buffer,o=this.offset,i=0;i<8;i++)t[i]=p[r[o+i]];return t.join(e||"")},toBuffer:function(e){if(e&&0===this.offset)return this.buffer;var t=new Buffer(8);return this.buffer.copy(t,0,this.offset,this.offset+8),t},copy:function(e,t){this.buffer.copy(e,t||0,this.offset,this.offset+8)},compare:function(e){if((128&this.buffer[this.offset])!=(128&e.buffer[e.offset]))return e.buffer[e.offset]-this.buffer[this.offset];for(var t=0;t<8;t++)if(this.buffer[this.offset+t]!==e.buffer[e.offset+t])return this.buffer[this.offset+t]-e.buffer[e.offset+t];return 0},equals:function(e){return 0===this.compare(e)},inspect:function(){return"[Int64 value:"+this+" octets:"+this.toOctetString(" ")+"]"}}},9211:e=>{"use strict";var t=function(e){return e!=e};e.exports=function(e,p){return 0===e&&0===p?1/e==1/p:e===p||!(!t(e)||!t(p))}},7653:(e,t,p)=>{"use strict";var r=p(8452),o=p(487),i=p(9211),s=p(9394),n=p(6576),a=o(s(),Object);r(a,{getPolyfill:s,implementation:i,shim:n}),e.exports=a},9394:(e,t,p)=>{"use strict";var r=p(9211);e.exports=function(){return"function"==typeof Object.is?Object.is:r}},6576:(e,t,p)=>{"use strict";var r=p(9394),o=p(8452);e.exports=function(){var e=r();return o(Object,{is:e},{is:function(){return Object.is!==e}}),e}},8875:(e,t,p)=>{"use strict";var r;if(!Object.keys){var o=Object.prototype.hasOwnProperty,i=Object.prototype.toString,s=p(1093),n=Object.prototype.propertyIsEnumerable,a=!n.call({toString:null},"toString"),l=n.call((function(){}),"prototype"),c=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"],u=function(e){var t=e.constructor;return t&&t.prototype===e},y={$applicationCache:!0,$console:!0,$external:!0,$frame:!0,$frameElement:!0,$frames:!0,$innerHeight:!0,$innerWidth:!0,$onmozfullscreenchange:!0,$onmozfullscreenerror:!0,$outerHeight:!0,$outerWidth:!0,$pageXOffset:!0,$pageYOffset:!0,$parent:!0,$scrollLeft:!0,$scrollTop:!0,$scrollX:!0,$scrollY:!0,$self:!0,$webkitIndexedDB:!0,$webkitStorageInfo:!0,$window:!0},f=function(){if("undefined"==typeof window)return!1;for(var e in window)try{if(!y["$"+e]&&o.call(window,e)&&null!==window[e]&&"object"==typeof window[e])try{u(window[e])}catch(e){return!0}}catch(e){return!0}return!1}();r=function(e){var t=null!==e&&"object"==typeof e,p="[object Function]"===i.call(e),r=s(e),n=t&&"[object String]"===i.call(e),y=[];if(!t&&!p&&!r)throw new TypeError("Object.keys called on a non-object");var d=l&&p;if(n&&e.length>0&&!o.call(e,0))for(var h=0;h0)for(var _=0;_{"use strict";var r=Array.prototype.slice,o=p(1093),i=Object.keys,s=i?function(e){return i(e)}:p(8875),n=Object.keys;s.shim=function(){if(Object.keys){var e=function(){var e=Object.keys(arguments);return e&&e.length===arguments.length}(1,2);e||(Object.keys=function(e){return o(e)?n(r.call(e)):n(e)})}else Object.keys=s;return Object.keys||s},e.exports=s},1093:e=>{"use strict";var t=Object.prototype.toString;e.exports=function(e){var p=t.call(e),r="[object Arguments]"===p;return r||(r="[object Array]"!==p&&null!==e&&"object"==typeof e&&"number"==typeof e.length&&e.length>=0&&"[object Function]"===t.call(e.callee)),r}},8403:(e,t,p)=>{"use strict";var r=p(1189),o=p(1333)(),i=p(6556),s=p(9612),n=i("Array.prototype.push"),a=i("Object.prototype.propertyIsEnumerable"),l=o?s.getOwnPropertySymbols:null;e.exports=function(e,t){if(null==e)throw new TypeError("target must be an object");var p=s(e);if(1===arguments.length)return p;for(var i=1;i{"use strict";var r=p(8403);e.exports=function(){return Object.assign?function(){if(!Object.assign)return!1;for(var e="abcdefghijklmnopqrst",t=e.split(""),p={},r=0;r{"use strict";var r="win32"===process.platform,o=p(537);function i(e,t){for(var p=[],r=0;r=0&&!e[r];r--);return 0===p&&r===t?e:p>r?[]:e.slice(p,r+1)}var n=/^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/,a=/^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/,l={};function c(e){var t=n.exec(e),p=(t[1]||"")+(t[2]||""),r=t[3]||"",o=a.exec(r);return[p,o[1],o[2],o[3]]}function u(e){var t=n.exec(e),p=t[1]||"",r=!!p&&":"!==p[1];return{device:p,isUnc:r,isAbsolute:r||!!t[2],tail:t[3]}}function y(e){return"\\\\"+e.replace(/^[\\\/]+/,"").replace(/[\\\/]+/g,"\\")}l.resolve=function(){for(var e="",t="",p=!1,r=arguments.length-1;r>=-1;r--){var s;if(r>=0?s=arguments[r]:e?(s=process.env["="+e])&&s.substr(0,3).toLowerCase()===e.toLowerCase()+"\\"||(s=e+"\\"):s=process.cwd(),!o.isString(s))throw new TypeError("Arguments to path.resolve must be strings");if(s){var n=u(s),a=n.device,l=n.isUnc,c=n.isAbsolute,f=n.tail;if((!a||!e||a.toLowerCase()===e.toLowerCase())&&(e||(e=a),p||(t=f+"\\"+t,p=c),e&&p))break}}return l&&(e=y(e)),e+(p?"\\":"")+(t=i(t.split(/[\\\/]+/),!p).join("\\"))||"."},l.normalize=function(e){var t=u(e),p=t.device,r=t.isUnc,o=t.isAbsolute,s=t.tail,n=/[\\\/]$/.test(s);return(s=i(s.split(/[\\\/]+/),!o).join("\\"))||o||(s="."),s&&n&&(s+="\\"),r&&(p=y(p)),p+(o?"\\":"")+s},l.isAbsolute=function(e){return u(e).isAbsolute},l.join=function(){for(var e=[],t=0;t=-1&&!t;p--){var r=p>=0?arguments[p]:process.cwd();if(!o.isString(r))throw new TypeError("Arguments to path.resolve must be strings");r&&(e=r+"/"+e,t="/"===r[0])}return(t?"/":"")+(e=i(e.split("/"),!t).join("/"))||"."},d.normalize=function(e){var t=d.isAbsolute(e),p=e&&"/"===e[e.length-1];return(e=i(e.split("/"),!t).join("/"))||t||(e="."),e&&p&&(e+="/"),(t?"/":"")+e},d.isAbsolute=function(e){return"/"===e.charAt(0)},d.join=function(){for(var e="",t=0;t{"use strict";e.exports=["Float32Array","Float64Array","Int8Array","Int16Array","Int32Array","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array"]},9721:(e,t,p)=>{"use strict";var r=p(6556),o=p(4035),i=r("RegExp.prototype.exec"),s=p(9675);e.exports=function(e){if(!o(e))throw new s("`regex` must be a RegExp");return function(t){return null!==i(e,t)}}},6897:(e,t,p)=>{"use strict";var r=p(453),o=p(41),i=p(592)(),s=p(5795),n=p(9675),a=r("%Math.floor%");e.exports=function(e,t){if("function"!=typeof e)throw new n("`fn` is not a function");if("number"!=typeof t||t<0||t>4294967295||a(t)!==t)throw new n("`length` must be a positive 32-bit integer");var p=arguments.length>2&&!!arguments[2],r=!0,l=!0;if("length"in e&&s){var c=s(e,"length");c&&!c.configurable&&(r=!1),c&&!c.writable&&(l=!1)}return(r||l||!p)&&(i?o(e,"length",t,!0,!0):o(e,"length",t)),e}},4789:(e,t,p)=>{var r=p(5971);function o(){r.call(this)}o.prototype=new r,e.exports=o,o.Stream=o,o.prototype.pipe=function(e,t){var p=this;function r(t){e.writable&&!1===e.write(t)&&p.pause&&p.pause()}function o(){p.readable&&p.resume&&p.resume()}p.on("data",r),e.on("drain",o),e._isStdio||t&&!1===t.end||(p.on("end",s),p.on("close",n));var i=!1;function s(){i||(i=!0,e.end())}function n(){i||(i=!0,"function"==typeof e.destroy&&e.destroy())}function a(e){if(l(),!this.hasListeners("error"))throw e}function l(){p.off("data",r),e.off("drain",o),p.off("end",s),p.off("close",n),p.off("error",a),e.off("error",a),p.off("end",l),p.off("close",l),e.off("end",l),e.off("close",l)}return p.on("error",a),e.on("error",a),p.on("end",l),p.on("close",l),e.on("end",l),e.on("close",l),e.emit("pipe",p),e}},6622:e=>{"function"==typeof Object.create?e.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:e.exports=function(e,t){e.super_=t;var p=function(){};p.prototype=t.prototype,e.prototype=new p,e.prototype.constructor=e}},1135:e=>{e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},537:(e,t,p)=>{var r=/%[sdj%]/g;t.format=function(e){if(!_(e)){for(var t=[],p=0;p=i)return e;switch(e){case"%s":return String(o[p++]);case"%d":return Number(o[p++]);case"%j":try{return JSON.stringify(o[p++])}catch(e){return"[Circular]"}default:return e}})),a=o[p];p=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),f(p)?r.showHidden=p:p&&t._extend(r,p),S(r.showHidden)&&(r.showHidden=!1),S(r.depth)&&(r.depth=2),S(r.colors)&&(r.colors=!1),S(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=n),l(r,e,r.depth)}function n(e,t){var p=s.styles[t];return p?"["+s.colors[p][0]+"m"+e+"["+s.colors[p][1]+"m":e}function a(e,t){return e}function l(e,p,r){if(e.customInspect&&p&&b(p.inspect)&&p.inspect!==t.inspect&&(!p.constructor||p.constructor.prototype!==p)){var o=p.inspect(r,e);return _(o)||(o=l(e,o,r)),o}var i=function(e,t){if(S(t))return e.stylize("undefined","undefined");if(_(t)){var p="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(p,"string")}return h(t)?e.stylize(""+t,"number"):f(t)?e.stylize(""+t,"boolean"):d(t)?e.stylize("null","null"):void 0}(e,p);if(i)return i;var s=Object.keys(p),n=function(e){var t={};return e.forEach((function(e,p){t[e]=!0})),t}(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(p)),m(p)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return c(p);if(0===s.length){if(b(p)){var a=p.name?": "+p.name:"";return e.stylize("[Function"+a+"]","special")}if(g(p))return e.stylize(RegExp.prototype.toString.call(p),"regexp");if(E(p))return e.stylize(Date.prototype.toString.call(p),"date");if(m(p))return c(p)}var w,I="",L=!1,T=["{","}"];return y(p)&&(L=!0,T=["[","]"]),b(p)&&(I=" [Function"+(p.name?": "+p.name:"")+"]"),g(p)&&(I=" "+RegExp.prototype.toString.call(p)),E(p)&&(I=" "+Date.prototype.toUTCString.call(p)),m(p)&&(I=" "+c(p)),0!==s.length||L&&0!=p.length?r<0?g(p)?e.stylize(RegExp.prototype.toString.call(p),"regexp"):e.stylize("[Object]","special"):(e.seen.push(p),w=L?function(e,t,p,r,o){for(var i=[],s=0,n=t.length;s60?p[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+p[1]:p[0]+t+" "+e.join(", ")+" "+p[1]}(w,I,T)):T[0]+I+T[1]}function c(e){return"["+Error.prototype.toString.call(e)+"]"}function u(e,t,p,r,o,i){var s,n,a;if((a=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?n=a.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):a.set&&(n=e.stylize("[Setter]","special")),v(r,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=d(p)?l(e,a.value,null):l(e,a.value,p-1)).indexOf("\n")>-1&&(n=i?n.split("\n").map((function(e){return" "+e})).join("\n").substr(2):"\n"+n.split("\n").map((function(e){return" "+e})).join("\n")):n=e.stylize("[Circular]","special")),S(s)){if(i&&o.match(/^\d+$/))return n;(s=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+n}function y(e){return Array.isArray(e)}function f(e){return"boolean"==typeof e}function d(e){return null===e}function h(e){return"number"==typeof e}function _(e){return"string"==typeof e}function S(e){return void 0===e}function g(e){return w(e)&&"[object RegExp]"===I(e)}function w(e){return"object"==typeof e&&null!==e}function E(e){return w(e)&&"[object Date]"===I(e)}function m(e){return w(e)&&("[object Error]"===I(e)||e instanceof Error)}function b(e){return"function"==typeof e}function I(e){return Object.prototype.toString.call(e)}function L(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(S(o)&&(o=process.env.NODE_DEBUG||""),e=e.toUpperCase(),!i[e])if(new RegExp("\\b"+e+"\\b","i").test(o)){var p=process.pid;i[e]=function(){var r=t.format.apply(t,arguments);console.error("%s %d: %s",e,p,r)}}else i[e]=function(){};return i[e]},t.inspect=s,s.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},s.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=y,t.isBoolean=f,t.isNull=d,t.isNullOrUndefined=function(e){return null==e},t.isNumber=h,t.isString=_,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=S,t.isRegExp=g,t.isObject=w,t.isDate=E,t.isError=m,t.isFunction=b,t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=p(1135);var T=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function v(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){var e,p;console.log("%s - %s",(p=[L((e=new Date).getHours()),L(e.getMinutes()),L(e.getSeconds())].join(":"),[e.getDate(),T[e.getMonth()],p].join(" ")),t.format.apply(t,arguments))},t.inherits=p(6622),t._extend=function(e,t){if(!t||!w(t))return e;for(var p=Object.keys(t),r=p.length;r--;)e[p[r]]=t[p[r]];return e}},5767:(e,t,p)=>{"use strict";var r=p(2682),o=p(9209),i=p(487),s=p(6556),n=p(5795),a=s("Object.prototype.toString"),l=p(9092)(),c="undefined"==typeof globalThis?p.g:globalThis,u=o(),y=s("String.prototype.slice"),f=Object.getPrototypeOf,d=s("Array.prototype.indexOf",!0)||function(e,t){for(var p=0;p-1?t:"Object"===t&&function(e){var t=!1;return r(h,(function(p,r){if(!t)try{p(e),t=y(r,1)}catch(e){}})),t}(e)}return n?function(e){var t=!1;return r(h,(function(p,r){if(!t)try{"$"+p(e)===r&&(t=y(r,1))}catch(e){}})),t}(e):null}},9209:(e,t,p)=>{"use strict";var r=p(6578),o="undefined"==typeof globalThis?p.g:globalThis;e.exports=function(){for(var e=[],t=0;t(e.paths=[],e.children||(e.children=[]),e),p(8248)})(); \ No newline at end of file +(()=>{var e={3322:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=p(278).GnssSignalDep,n=(p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT",this.fields=t||this.parser.parse(e.payload),this});(n.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT",n.prototype.msg_type=47,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:i.prototype.parser}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),n.prototype.fieldSpec.push(["cp","writeFloatLE",4]),n.prototype.fieldSpec.push(["cf","writeFloatLE",4]),n.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT_DEP_C",a.prototype.msg_type=31,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),a.prototype.fieldSpec.push(["cp","writeFloatLE",4]),a.prototype.fieldSpec.push(["cf","writeFloatLE",4]),a.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT_DEP_B",l.prototype.msg_type=20,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["snr","writeFloatLE",4]),l.prototype.fieldSpec.push(["cp","writeFloatLE",4]),l.prototype.fieldSpec.push(["cf","writeFloatLE",4]),l.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT_DEP_A",c.prototype.msg_type=21,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").uint8("prn"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["snr","writeFloatLE",4]),c.prototype.fieldSpec.push(["cp","writeFloatLE",4]),c.prototype.fieldSpec.push(["cf","writeFloatLE",4]),c.prototype.fieldSpec.push(["prn","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="AcqSvProfile",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="AcqSvProfile",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:i.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["job_type","writeUInt8",1]),u.prototype.fieldSpec.push(["status","writeUInt8",1]),u.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),u.prototype.fieldSpec.push(["int_time","writeUInt8",1]),u.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),u.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),u.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),u.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf","writeInt32LE",4]),u.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="AcqSvProfileDep",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="AcqSvProfileDep",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:s.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["job_type","writeUInt8",1]),y.prototype.fieldSpec.push(["status","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),y.prototype.fieldSpec.push(["int_time","writeUInt8",1]),y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),y.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),y.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),y.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf","writeInt32LE",4]),y.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE",f.prototype.msg_type=46,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:u.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["acq_sv_profile","array",u.prototype.fieldSpec,function(){return this.fields.array.length},null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE_DEP",d.prototype.msg_type=30,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:y.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["acq_sv_profile","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={47:n,MsgAcqResult:n,31:a,MsgAcqResultDepC:a,20:l,MsgAcqResultDepB:l,21:c,MsgAcqResultDepA:c,AcqSvProfile:u,AcqSvProfileDep:y,46:f,MsgAcqSvProfile:f,30:d,MsgAcqSvProfileDep:d}},6053:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",i.prototype.msg_type=179,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];let s=function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",s.prototype.msg_type=180,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("flags").string("version",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt32LE",4]),s.prototype.fieldSpec.push(["version","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_JUMP_TO_APP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_JUMP_TO_APP",n.prototype.msg_type=177,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("jump"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["jump","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_NAP_DEVICE_DNA_REQ",a.prototype.msg_type=222,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little"),a.prototype.fieldSpec=[];let l=function(e,t){return r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_NAP_DEVICE_DNA_RESP",l.prototype.msg_type=221,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").array("dna",{length:8,type:"uint8"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["dna","array","writeUInt8",function(){return 1},8]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",c.prototype.msg_type=176,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").array("handshake",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["handshake","array","writeUInt8",function(){return 1},null]),e.exports={179:i,MsgBootloaderHandshakeReq:i,180:s,MsgBootloaderHandshakeResp:s,177:n,MsgBootloaderJumpToApp:n,222:a,MsgNapDeviceDnaReq:a,221:l,MsgNapDeviceDnaResp:l,176:c,MsgBootloaderHandshakeDepA:c}},7224:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_EXT_EVENT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_EXT_EVENT",i.prototype.msg_type=257,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags").uint8("pin"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]),i.prototype.fieldSpec.push(["pin","writeUInt8",1]),e.exports={257:i,MsgExtEvent:i}},8986:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_REQ",i.prototype.msg_type=168,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").uint8("chunk_size").string("filename",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),i.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),i.prototype.fieldSpec.push(["chunk_size","writeUInt8",1]),i.prototype.fieldSpec.push(["filename","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_RESP",s.prototype.msg_type=163,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("sequence").array("contents",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),s.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_DIR_REQ",n.prototype.msg_type=169,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("dirname",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),n.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),n.prototype.fieldSpec.push(["dirname","string",null]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_READ_DIR_RESP",a.prototype.msg_type=170,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("sequence").string("contents",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),a.prototype.fieldSpec.push(["contents","string",null]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_REMOVE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_REMOVE",l.prototype.msg_type=172,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("filename",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["filename","string",null]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_WRITE_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_WRITE_REQ",c.prototype.msg_type=173,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("filename",{greedy:!0}).array("data",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),c.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),c.prototype.fieldSpec.push(["filename","string",null]),c.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},null]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_WRITE_RESP",u.prototype.msg_type=171,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sequence"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_CONFIG_REQ",y.prototype.msg_type=4097,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sequence"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_CONFIG_RESP",f.prototype.msg_type=4098,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("window_size").uint32("batch_size").uint32("fileio_version"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),f.prototype.fieldSpec.push(["window_size","writeUInt32LE",4]),f.prototype.fieldSpec.push(["batch_size","writeUInt32LE",4]),f.prototype.fieldSpec.push(["fileio_version","writeUInt32LE",4]),e.exports={168:i,MsgFileioReadReq:i,163:s,MsgFileioReadResp:s,169:n,MsgFileioReadDirReq:n,170:a,MsgFileioReadDirResp:a,172:l,MsgFileioRemove:l,173:c,MsgFileioWriteReq:c,171:u,MsgFileioWriteResp:u,4097:y,MsgFileioConfigReq:y,4098:f,MsgFileioConfigResp:f}},6667:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_PROGRAM",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_PROGRAM",i.prototype.msg_type=230,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len").array("data",{type:"uint8",length:"addr_len"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["target","writeUInt8",1]),i.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),i.prototype.fieldSpec.push(["addr_len","writeUInt8",1]),i.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},"addr_len"]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_DONE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_DONE",s.prototype.msg_type=224,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("response"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["response","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_READ_REQ",n.prototype.msg_type=231,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["target","writeUInt8",1]),n.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),n.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_READ_RESP",a.prototype.msg_type=225,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["target","writeUInt8",1]),a.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),a.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_ERASE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_FLASH_ERASE",l.prototype.msg_type=226,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("target").uint32("sector_num"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["target","writeUInt8",1]),l.prototype.fieldSpec.push(["sector_num","writeUInt32LE",4]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_STM_FLASH_LOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_STM_FLASH_LOCK_SECTOR",c.prototype.msg_type=227,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sector"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_STM_FLASH_UNLOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_STM_FLASH_UNLOCK_SECTOR",u.prototype.msg_type=228,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sector"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_STM_UNIQUE_ID_REQ",y.prototype.msg_type=232,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_STM_UNIQUE_ID_RESP",f.prototype.msg_type=229,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("stm_id",{length:12,type:"uint8"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["stm_id","array","writeUInt8",function(){return 1},12]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_M25_FLASH_WRITE_STATUS",d.prototype.msg_type=243,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("status",{length:1,type:"uint8"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["status","array","writeUInt8",function(){return 1},1]),e.exports={230:i,MsgFlashProgram:i,224:s,MsgFlashDone:s,231:n,MsgFlashReadReq:n,225:a,MsgFlashReadResp:a,226:l,MsgFlashErase:l,227:c,MsgStmFlashLockSector:c,228:u,MsgStmFlashUnlockSector:u,232:y,MsgStmUniqueIdReq:y,229:f,MsgStmUniqueIdResp:f,243:d,MsgM25FlashWriteStatus:d}},278:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="GnssSignal",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="GnssSignal",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("sat").uint8("code"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sat","writeUInt8",1]),i.prototype.fieldSpec.push(["code","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="SvId",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="SvId",s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("satId").uint8("constellation"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["satId","writeUInt8",1]),s.prototype.fieldSpec.push(["constellation","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="GnssSignalDep",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="GnssSignalDep",n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("sat").uint8("code").uint8("reserved"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["sat","writeUInt16LE",2]),n.prototype.fieldSpec.push(["code","writeUInt8",1]),n.prototype.fieldSpec.push(["reserved","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="GPSTimeDep",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="GPSTimeDep",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("tow").uint16("wn"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["wn","writeUInt16LE",2]);let l=function(e,t){return r.call(this,e),this.messageType="GPSTimeSec",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="GPSTimeSec",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint32("tow").uint16("wn"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),l.prototype.fieldSpec.push(["wn","writeUInt16LE",2]);let c=function(e,t){return r.call(this,e),this.messageType="GPSTime",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="GPSTime",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("tow").int32("ns_residual").uint16("wn"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),c.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),c.prototype.fieldSpec.push(["wn","writeUInt16LE",2]);let u=function(e,t){return r.call(this,e),this.messageType="CarrierPhase",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="CarrierPhase",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").int32("i").uint8("f"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["i","writeInt32LE",4]),u.prototype.fieldSpec.push(["f","writeUInt8",1]),e.exports={GnssSignal:i,SvId:s,GnssSignalDep:n,GPSTimeDep:a,GPSTimeSec:l,GPSTime:c,CarrierPhase:u}},3276:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_IMU_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_IMU_RAW",i.prototype.msg_type=2304,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("acc_x").int16("acc_y").int16("acc_z").int16("gyr_x").int16("gyr_y").int16("gyr_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["acc_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_z","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_z","writeInt16LE",2]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_IMU_AUX",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_IMU_AUX",s.prototype.msg_type=2305,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("imu_type").int16("temp").uint8("imu_conf"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["imu_type","writeUInt8",1]),s.prototype.fieldSpec.push(["temp","writeInt16LE",2]),s.prototype.fieldSpec.push(["imu_conf","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_IMU_COMP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_IMU_COMP",n.prototype.msg_type=2309,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint64("time").uint16("flags").int32("acc_comp_x").int32("acc_comp_y").int32("acc_comp_z").int32("gyr_comp_x").int32("gyr_comp_y").int32("gyr_comp_z"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["time","writeUInt64LE",8]),n.prototype.fieldSpec.push(["flags","writeUInt16LE",2]),n.prototype.fieldSpec.push(["acc_comp_x","writeInt32LE",4]),n.prototype.fieldSpec.push(["acc_comp_y","writeInt32LE",4]),n.prototype.fieldSpec.push(["acc_comp_z","writeInt32LE",4]),n.prototype.fieldSpec.push(["gyr_comp_x","writeInt32LE",4]),n.prototype.fieldSpec.push(["gyr_comp_y","writeInt32LE",4]),n.prototype.fieldSpec.push(["gyr_comp_z","writeInt32LE",4]),e.exports={2304:i,MsgImuRaw:i,2305:s,MsgImuAux:s,2309:n,MsgImuComp:n}},8958:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal,p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec),s=p(278).SvId,n=function(e,t){return r.call(this,e),this.messageType="IntegritySSRHeader",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="IntegritySSRHeader",n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),n.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),n.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),n.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),n.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["chain_id","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_HIGH_LEVEL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_HIGH_LEVEL_DEP_A",a.prototype.msg_type=3001,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).nest("corr_time",{type:i.prototype.parser}).uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id").uint8("use_gps_sat").uint8("use_gal_sat").uint8("use_bds_sat").uint8("use_qzss_sat").array("reserved",{length:5,type:"uint8"}).uint8("use_tropo_grid_points").uint8("use_iono_grid_points").uint8("use_iono_tile_sat_los").uint8("use_iono_grid_point_sat_los"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["corr_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),a.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gps_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gal_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_bds_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_qzss_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},5]),a.prototype.fieldSpec.push(["use_tropo_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_tile_sat_los","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_point_sat_los","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_HIGH_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_HIGH_LEVEL",l.prototype.msg_type=3002,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).nest("iono_corr_time",{type:i.prototype.parser}).nest("sat_corr_time",{type:i.prototype.parser}).uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id").uint8("use_gps_sat").uint8("use_gal_sat").uint8("use_bds_sat").uint8("use_qzss_sat").array("reserved",{length:5,type:"uint8"}).uint8("use_tropo_grid_points").uint8("use_iono_grid_points").uint8("use_iono_tile_sat_los").uint8("use_iono_grid_point_sat_los"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["iono_corr_time",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["sat_corr_time",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),l.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),l.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),l.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),l.prototype.fieldSpec.push(["use_gps_sat","writeUInt8",1]),l.prototype.fieldSpec.push(["use_gal_sat","writeUInt8",1]),l.prototype.fieldSpec.push(["use_bds_sat","writeUInt8",1]),l.prototype.fieldSpec.push(["use_qzss_sat","writeUInt8",1]),l.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},5]),l.prototype.fieldSpec.push(["use_tropo_grid_points","writeUInt8",1]),l.prototype.fieldSpec.push(["use_iono_grid_points","writeUInt8",1]),l.prototype.fieldSpec.push(["use_iono_tile_sat_los","writeUInt8",1]),l.prototype.fieldSpec.push(["use_iono_grid_point_sat_los","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_SATELLITES",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_SATELLITES",c.prototype.msg_type=3005,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint8("chain_id").uint8("const_id").uint8("n_faulty_sats").array("faulty_sats",{type:"uint8",length:"n_faulty_sats"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),c.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),c.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),c.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),c.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),c.prototype.fieldSpec.push(["const_id","writeUInt8",1]),c.prototype.fieldSpec.push(["n_faulty_sats","writeUInt8",1]),c.prototype.fieldSpec.push(["faulty_sats","array","writeUInt8",function(){return 1},"n_faulty_sats"]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",u.prototype.msg_type=3011,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),u.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",y.prototype.msg_type=3015,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),y.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",f.prototype.msg_type=3021,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),f.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),f.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",d.prototype.msg_type=3025,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint16("grid_point_id").uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),d.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),d.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),d.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_ACKNOWLEDGE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_ACKNOWLEDGE",h.prototype.msg_type=3026,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("request_id").uint32("area_id").uint8("response_code").uint16("correction_mask_on_demand").uint16("correction_mask_stream").uint8("solution_id"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["request_id","writeUInt8",1]),h.prototype.fieldSpec.push(["area_id","writeUInt32LE",4]),h.prototype.fieldSpec.push(["response_code","writeUInt8",1]),h.prototype.fieldSpec.push(["correction_mask_on_demand","writeUInt16LE",2]),h.prototype.fieldSpec.push(["correction_mask_stream","writeUInt16LE",2]),h.prototype.fieldSpec.push(["solution_id","writeUInt8",1]),e.exports={IntegritySSRHeader:n,3001:a,MsgSsrFlagHighLevelDepA:a,3002:l,MsgSsrFlagHighLevel:l,3005:c,MsgSsrFlagSatellites:c,3011:u,MsgSsrFlagTropoGridPoints:u,3015:y,MsgSsrFlagIonoGridPoints:y,3021:f,MsgSsrFlagIonoTileSatLos:f,3025:d,MsgSsrFlagIonoGridPointSatLos:d,3026:h,MsgAcknowledge:h}},6747:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_CPU_STATE_DEP_A",i.prototype.msg_type=32512,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").string("tname",{length:15}).string("cmdline",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["index","writeUInt8",1]),i.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),i.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),i.prototype.fieldSpec.push(["tname","string",15]),i.prototype.fieldSpec.push(["cmdline","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_MEM_STATE_DEP_A",s.prototype.msg_type=32513,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").string("tname",{length:15}).string("cmdline",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["index","writeUInt8",1]),s.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),s.prototype.fieldSpec.push(["pmem","writeUInt8",1]),s.prototype.fieldSpec.push(["tname","string",15]),s.prototype.fieldSpec.push(["cmdline","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SYS_STATE_DEP_A",n.prototype.msg_type=32514,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),n.prototype.fieldSpec.push(["pmem","writeUInt8",1]),n.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),n.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",a.prototype.msg_type=32515,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("socket_count").uint16("socket_types").uint16("socket_states").string("cmdline",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["index","writeUInt8",1]),a.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_count","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),a.prototype.fieldSpec.push(["cmdline","string",null]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",l.prototype.msg_type=32516,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("recv_queued").uint16("send_queued").uint16("socket_types").uint16("socket_states").string("address_of_largest",{length:64}).string("cmdline",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["index","writeUInt8",1]),l.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),l.prototype.fieldSpec.push(["recv_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["send_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),l.prototype.fieldSpec.push(["address_of_largest","string",64]),l.prototype.fieldSpec.push(["cmdline","string",null]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_SOCKET_USAGE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SOCKET_USAGE",c.prototype.msg_type=32517,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("avg_queue_depth").uint32("max_queue_depth").array("socket_state_counts",{length:16,type:"uint16le"}).array("socket_type_counts",{length:16,type:"uint16le"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["avg_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["max_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["socket_state_counts","array","writeUInt16LE",function(){return 2},16]),c.prototype.fieldSpec.push(["socket_type_counts","array","writeUInt16LE",function(){return 2},16]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_COUNT",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_FD_COUNT",u.prototype.msg_type=32518,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("fd_count").string("cmdline",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt8",1]),u.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),u.prototype.fieldSpec.push(["fd_count","writeUInt16LE",2]),u.prototype.fieldSpec.push(["cmdline","string",null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_SUMMARY",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_FD_SUMMARY",y.prototype.msg_type=32519,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sys_fd_count").string("most_opened",{greedy:!0}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sys_fd_count","writeUInt32LE",4]),y.prototype.fieldSpec.push(["most_opened","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_CPU_STATE",f.prototype.msg_type=32520,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["index","writeUInt8",1]),f.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),f.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),f.prototype.fieldSpec.push(["time","writeUInt32LE",4]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["tname","string",15]),f.prototype.fieldSpec.push(["cmdline","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_MEM_STATE",d.prototype.msg_type=32521,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["index","writeUInt8",1]),d.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pmem","writeUInt8",1]),d.prototype.fieldSpec.push(["time","writeUInt32LE",4]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]),d.prototype.fieldSpec.push(["tname","string",15]),d.prototype.fieldSpec.push(["cmdline","string",null]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SYS_STATE",h.prototype.msg_type=32522,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count").uint32("time").uint8("flags"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),h.prototype.fieldSpec.push(["pmem","writeUInt8",1]),h.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),h.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]),h.prototype.fieldSpec.push(["time","writeUInt32LE",4]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={32512:i,MsgLinuxCpuStateDepA:i,32513:s,MsgLinuxMemStateDepA:s,32514:n,MsgLinuxSysStateDepA:n,32515:a,MsgLinuxProcessSocketCounts:a,32516:l,MsgLinuxProcessSocketQueues:l,32517:c,MsgLinuxSocketUsage:c,32518:u,MsgLinuxProcessFdCount:u,32519:y,MsgLinuxProcessFdSummary:y,32520:f,MsgLinuxCpuState:f,32521:d,MsgLinuxMemState:d,32522:h,MsgLinuxSysState:h}},8556:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LOG",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_LOG",i.prototype.msg_type=1025,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("level").string("text",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["level","writeUInt8",1]),i.prototype.fieldSpec.push(["text","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_FWD",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_FWD",s.prototype.msg_type=1026,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("source").uint8("protocol").array("fwd_payload",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["protocol","writeUInt8",1]),s.prototype.fieldSpec.push(["fwd_payload","array","writeUInt8",function(){return 1},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_PRINT_DEP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_PRINT_DEP",n.prototype.msg_type=16,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").string("text",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["text","string",null]),e.exports={1025:i,MsgLog:i,1026:s,MsgFwd:s,16:n,MsgPrintDep:n}},3574:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_MAG_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_MAG_RAW",i.prototype.msg_type=2306,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("mag_x").int16("mag_y").int16("mag_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["mag_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_z","writeInt16LE",2]),e.exports={2306:i,MsgMagRaw:i}},8248:(e,t,p)=>{e=p.nmd(e);var r=p(7052).i,o=(p(3627),p(4789),p(7238)),i=[0,4129,8258,12387,16516,20645,24774,28903,33032,37161,41290,45419,49548,53677,57806,61935,4657,528,12915,8786,21173,17044,29431,25302,37689,33560,45947,41818,54205,50076,62463,58334,9314,13379,1056,5121,25830,29895,17572,21637,42346,46411,34088,38153,58862,62927,50604,54669,13907,9842,5649,1584,30423,26358,22165,18100,46939,42874,38681,34616,63455,59390,55197,51132,18628,22757,26758,30887,2112,6241,10242,14371,51660,55789,59790,63919,35144,39273,43274,47403,23285,19156,31415,27286,6769,2640,14899,10770,56317,52188,64447,60318,39801,35672,47931,43802,27814,31879,19684,23749,11298,15363,3168,7233,60846,64911,52716,56781,44330,48395,36200,40265,32407,28342,24277,20212,15891,11826,7761,3696,65439,61374,57309,53244,48923,44858,40793,36728,37256,33193,45514,41451,53516,49453,61774,57711,4224,161,12482,8419,20484,16421,28742,24679,33721,37784,41979,46042,49981,54044,58239,62302,689,4752,8947,13010,16949,21012,25207,29270,46570,42443,38312,34185,62830,58703,54572,50445,13538,9411,5280,1153,29798,25671,21540,17413,42971,47098,34713,38840,59231,63358,50973,55100,9939,14066,1681,5808,26199,30326,17941,22068,55628,51565,63758,59695,39368,35305,47498,43435,22596,18533,30726,26663,6336,2273,14466,10403,52093,56156,60223,64286,35833,39896,43963,48026,19061,23124,27191,31254,2801,6864,10931,14994,64814,60687,56684,52557,48554,44427,40424,36297,31782,27655,23652,19525,15522,11395,7392,3265,61215,65342,53085,57212,44955,49082,36825,40952,28183,32310,20053,24180,11923,16050,3793,7920],s=function(e,t){for(var p in t)t.hasOwnProperty(p)&&(e[p]=t[p]);return e};function n(e){this.name="ParameterValidationError",this.message=e,this.stack=(new Error).stack}function a(e){this.name="BufferTooShortError",this.message=e,this.stack=(new Error).stack}function l(e){this.name="BufferCorruptError",this.message=e,this.stack=(new Error).stack}n.prototype=Object.create(Error.prototype),n.prototype.constructor=n,a.prototype=Object.create(Error.prototype),a.prototype.constructor=a,l.prototype=Object.create(Error.prototype),l.prototype.constructor=l;var c={acquisition:p(3322),bootload:p(6053),ext_events:p(7224),file_io:p(8986),flash:p(6667),gnss:p(278),imu:p(3276),integrity:p(8958),linux:p(6747),logging:p(8556),mag:p(3574),navigation:p(4539),ndb:p(309),observation:p(4399),orientation:p(2623),piksi:p(9757),profiling:p(2827),sbas:p(5232),settings:p(4120),signings:p(9286),solution_meta:p(848),ssr:p(9269),system:p(2644),tracking:p(752),user:p(5562),vehicle:p(7293),telemetry:p(3894)},u=Object.keys(c).reduce((function(e,t){var p=c[t],r={};return Object.keys(p).forEach((function(e){parseInt(e)==e&&(r[e]=p[e])})),s(e,r)}),{}),y=Object.keys(c).reduce((function(e,t){var p=c[t],r={};return Object.keys(p).forEach((function(e){if(parseInt(e)!=e){var t=p[e].prototype.messageType||e;r[t]=p[e]}})),s(e,r)}),{}),f=(new r).endianess("little").uint8("preamble").uint16("msg_type").uint16("sender").uint8("length").buffer("payload",{length:"length"}).uint16("crc");function d(e,t){t=t||0;for(let p of e)t=t<<8&65535^i[t>>8&255^255&p],t&=65535;return t}e.exports={preambleByte:85,crc16:d,sbpIdTable:u,sbpMessageTypesTable:y,decode:function(e){var t=f.parse(e),p=u[t.msg_type];return void 0===p?(console.log("Unknown message type: ",t.msg_type),new o(t)):new p(t)},dispatch:function(t,p,r){var o,i,s=new Buffer(0);if(void 0===r&&"function"==typeof p?o=p:(o=r,i=p),i&&!Array.isArray(i)&&-1===["function","number"].indexOf(typeof i))throw n("dispatch: messageWhitelist must be function, number, or array");var c=function(p){t.pause();try{if((s=Buffer.concat([s,p])).length<2)return;var r=function(){var t,p,r,o,n,c,u;for(u=0;us.length)throw new a;t=s.slice(u+1,u+6),r=s.readUInt16LE(u+1),_=s.readUInt16LE(u+3),o=s.readUInt8(u+5);var y=i&&Array.isArray(i)&&-1!==i.indexOf(r),f=i&&"number"==typeof i&&i&r,h=i&&"function"==typeof i&&i(r);if(i&&!(y||f||h))return s=s.slice(u+6+o+2),null;if(u+8+o>s.length)throw new a;c=d(s.slice(u+6,u+6+o),d(t)),n=s.readUInt16LE(u+6+o);var S=s.slice(u,u+6+o+2);if(n===c)return s=s.slice(u+6+o+2),[e.exports.decode(S),S];throw s=s.slice(u+1),new l}();if(null===r)return;var n=r[0],u=r[1];o(null,n,u)}catch(e){if(!(e instanceof a||e instanceof l))throw e}finally{t.resume(),s.length>0&&setTimeout((function(){c(new Buffer(0))}),0)}};t.on("data",c)}},function(r){var o={function:!0,object:!0},i=o[typeof window]&&window||this,s=o[typeof t]&&t&&!t.nodeType&&t,n=o.object&&e&&!e.nodeType&&e,a=s&&n&&"object"==typeof p.g&&p.g;!a||a.global!==a&&a.window!==a&&a.self!==a||(i=a),i.SBP=r}(e.exports)},4539:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_GPS_TIME",i.prototype.msg_type=258,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_GPS_TIME_GNSS",s.prototype.msg_type=260,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_TIME",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_UTC_TIME",n.prototype.msg_type=259,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt8",1]),n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["year","writeUInt16LE",2]),n.prototype.fieldSpec.push(["month","writeUInt8",1]),n.prototype.fieldSpec.push(["day","writeUInt8",1]),n.prototype.fieldSpec.push(["hours","writeUInt8",1]),n.prototype.fieldSpec.push(["minutes","writeUInt8",1]),n.prototype.fieldSpec.push(["seconds","writeUInt8",1]),n.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_UTC_TIME_GNSS",a.prototype.msg_type=261,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]),a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["year","writeUInt16LE",2]),a.prototype.fieldSpec.push(["month","writeUInt8",1]),a.prototype.fieldSpec.push(["day","writeUInt8",1]),a.prototype.fieldSpec.push(["hours","writeUInt8",1]),a.prototype.fieldSpec.push(["minutes","writeUInt8",1]),a.prototype.fieldSpec.push(["seconds","writeUInt8",1]),a.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_DOPS",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_DOPS",l.prototype.msg_type=520,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),l.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["flags","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF",c.prototype.msg_type=521,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),c.prototype.fieldSpec.push(["x","writeDoubleLE",8]),c.prototype.fieldSpec.push(["y","writeDoubleLE",8]),c.prototype.fieldSpec.push(["z","writeDoubleLE",8]),c.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),c.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),c.prototype.fieldSpec.push(["flags","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_COV",u.prototype.msg_type=532,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),u.prototype.fieldSpec.push(["x","writeDoubleLE",8]),u.prototype.fieldSpec.push(["y","writeDoubleLE",8]),u.prototype.fieldSpec.push(["z","writeDoubleLE",8]),u.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),u.prototype.fieldSpec.push(["flags","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH",y.prototype.msg_type=522,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),y.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),y.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),y.prototype.fieldSpec.push(["height","writeDoubleLE",8]),y.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),y.prototype.fieldSpec.push(["flags","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_COV",f.prototype.msg_type=529,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),f.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),f.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),f.prototype.fieldSpec.push(["height","writeDoubleLE",8]),f.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),f.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),f.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="EstimatedHorizontalErrorEllipse",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").floatle("semi_major").floatle("semi_minor").floatle("orientation"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["semi_major","writeFloatLE",4]),d.prototype.fieldSpec.push(["semi_minor","writeFloatLE",4]),d.prototype.fieldSpec.push(["orientation","writeFloatLE",4]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_ACC",h.prototype.msg_type=536,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").doublele("orthometric_height").floatle("h_accuracy").floatle("v_accuracy").floatle("ct_accuracy").floatle("at_accuracy").nest("h_ellipse",{type:d.prototype.parser}).uint8("confidence_and_geoid").uint8("n_sats").uint8("flags"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),h.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),h.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),h.prototype.fieldSpec.push(["height","writeDoubleLE",8]),h.prototype.fieldSpec.push(["orthometric_height","writeDoubleLE",8]),h.prototype.fieldSpec.push(["h_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["v_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["ct_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["at_accuracy","writeFloatLE",4]),h.prototype.fieldSpec.push(["h_ellipse",d.prototype.fieldSpec]),h.prototype.fieldSpec.push(["confidence_and_geoid","writeUInt8",1]),h.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_ECEF",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_ECEF",_.prototype.msg_type=523,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),_.prototype.fieldSpec.push(["x","writeInt32LE",4]),_.prototype.fieldSpec.push(["y","writeInt32LE",4]),_.prototype.fieldSpec.push(["z","writeInt32LE",4]),_.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),_.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_NED",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_NED",S.prototype.msg_type=524,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),S.prototype.fieldSpec.push(["n","writeInt32LE",4]),S.prototype.fieldSpec.push(["e","writeInt32LE",4]),S.prototype.fieldSpec.push(["d","writeInt32LE",4]),S.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);let g=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF",g.prototype.msg_type=525,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),g.prototype.fieldSpec.push(["x","writeInt32LE",4]),g.prototype.fieldSpec.push(["y","writeInt32LE",4]),g.prototype.fieldSpec.push(["z","writeInt32LE",4]),g.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),g.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt8",1]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_COV",w.prototype.msg_type=533,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),w.prototype.fieldSpec.push(["x","writeInt32LE",4]),w.prototype.fieldSpec.push(["y","writeInt32LE",4]),w.prototype.fieldSpec.push(["z","writeInt32LE",4]),w.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]);let E=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED",E.prototype.msg_type=526,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),E.prototype.fieldSpec.push(["n","writeInt32LE",4]),E.prototype.fieldSpec.push(["e","writeInt32LE",4]),E.prototype.fieldSpec.push(["d","writeInt32LE",4]),E.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),E.prototype.fieldSpec.push(["flags","writeUInt8",1]);let m=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_COV",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_COV",m.prototype.msg_type=530,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),m.prototype.fieldSpec.push(["n","writeInt32LE",4]),m.prototype.fieldSpec.push(["e","writeInt32LE",4]),m.prototype.fieldSpec.push(["d","writeInt32LE",4]),m.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),m.prototype.fieldSpec.push(["flags","writeUInt8",1]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_GNSS",b.prototype.msg_type=553,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),b.prototype.fieldSpec.push(["x","writeDoubleLE",8]),b.prototype.fieldSpec.push(["y","writeDoubleLE",8]),b.prototype.fieldSpec.push(["z","writeDoubleLE",8]),b.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["flags","writeUInt8",1]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_COV_GNSS",I.prototype.msg_type=564,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),I.prototype.fieldSpec.push(["x","writeDoubleLE",8]),I.prototype.fieldSpec.push(["y","writeDoubleLE",8]),I.prototype.fieldSpec.push(["z","writeDoubleLE",8]),I.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),I.prototype.fieldSpec.push(["flags","writeUInt8",1]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_GNSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_GNSS",L.prototype.msg_type=554,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),L.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),L.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),L.prototype.fieldSpec.push(["height","writeDoubleLE",8]),L.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),L.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),L.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),L.prototype.fieldSpec.push(["flags","writeUInt8",1]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_COV_GNSS",T.prototype.msg_type=561,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),T.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),T.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),T.prototype.fieldSpec.push(["height","writeDoubleLE",8]),T.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),T.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),T.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),T.prototype.fieldSpec.push(["flags","writeUInt8",1]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_GNSS",v.prototype.msg_type=557,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),v.prototype.fieldSpec.push(["x","writeInt32LE",4]),v.prototype.fieldSpec.push(["y","writeInt32LE",4]),v.prototype.fieldSpec.push(["z","writeInt32LE",4]),v.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),v.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),v.prototype.fieldSpec.push(["flags","writeUInt8",1]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_COV_GNSS",U.prototype.msg_type=565,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),U.prototype.fieldSpec.push(["x","writeInt32LE",4]),U.prototype.fieldSpec.push(["y","writeInt32LE",4]),U.prototype.fieldSpec.push(["z","writeInt32LE",4]),U.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),U.prototype.fieldSpec.push(["flags","writeUInt8",1]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_GNSS",O.prototype.msg_type=558,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),O.prototype.fieldSpec.push(["n","writeInt32LE",4]),O.prototype.fieldSpec.push(["e","writeInt32LE",4]),O.prototype.fieldSpec.push(["d","writeInt32LE",4]),O.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),O.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),O.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),O.prototype.fieldSpec.push(["flags","writeUInt8",1]);let M=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_COV_GNSS",M.prototype.msg_type=562,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),M.prototype.fieldSpec.push(["n","writeInt32LE",4]),M.prototype.fieldSpec.push(["e","writeInt32LE",4]),M.prototype.fieldSpec.push(["d","writeInt32LE",4]),M.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),M.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),M.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),M.prototype.fieldSpec.push(["flags","writeUInt8",1]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_VEL_BODY",D.prototype.msg_type=531,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),D.prototype.fieldSpec.push(["x","writeInt32LE",4]),D.prototype.fieldSpec.push(["y","writeInt32LE",4]),D.prototype.fieldSpec.push(["z","writeInt32LE",4]),D.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),D.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),D.prototype.fieldSpec.push(["flags","writeUInt8",1]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_VEL_COG",A.prototype.msg_type=540,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint32("tow").uint32("cog").uint32("sog").int32("v_up").uint32("cog_accuracy").uint32("sog_accuracy").uint32("v_up_accuracy").uint16("flags"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),A.prototype.fieldSpec.push(["cog","writeUInt32LE",4]),A.prototype.fieldSpec.push(["sog","writeUInt32LE",4]),A.prototype.fieldSpec.push(["v_up","writeInt32LE",4]),A.prototype.fieldSpec.push(["cog_accuracy","writeUInt32LE",4]),A.prototype.fieldSpec.push(["sog_accuracy","writeUInt32LE",4]),A.prototype.fieldSpec.push(["v_up_accuracy","writeUInt32LE",4]),A.prototype.fieldSpec.push(["flags","writeUInt16LE",2]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_AGE_CORRECTIONS",G.prototype.msg_type=528,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").uint32("tow").uint16("age"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),G.prototype.fieldSpec.push(["age","writeUInt16LE",2]);let C=function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="MSG_GPS_TIME_DEP_A",C.prototype.msg_type=256,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),C.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),C.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),C.prototype.fieldSpec.push(["flags","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_DOPS_DEP_A",j.prototype.msg_type=518,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),j.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),j.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]);let P=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_DEP_A",P.prototype.msg_type=512,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),P.prototype.fieldSpec.push(["x","writeDoubleLE",8]),P.prototype.fieldSpec.push(["y","writeDoubleLE",8]),P.prototype.fieldSpec.push(["z","writeDoubleLE",8]),P.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),P.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),P.prototype.fieldSpec.push(["flags","writeUInt8",1]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_DEP_A",R.prototype.msg_type=513,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),R.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),R.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),R.prototype.fieldSpec.push(["height","writeDoubleLE",8]),R.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),R.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),R.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),R.prototype.fieldSpec.push(["flags","writeUInt8",1]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_ECEF_DEP_A",N.prototype.msg_type=514,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),N.prototype.fieldSpec.push(["x","writeInt32LE",4]),N.prototype.fieldSpec.push(["y","writeInt32LE",4]),N.prototype.fieldSpec.push(["z","writeInt32LE",4]),N.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),N.prototype.fieldSpec.push(["flags","writeUInt8",1]);let x=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_NED_DEP_A",x.prototype.msg_type=515,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),x.prototype.fieldSpec.push(["n","writeInt32LE",4]),x.prototype.fieldSpec.push(["e","writeInt32LE",4]),x.prototype.fieldSpec.push(["d","writeInt32LE",4]),x.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),x.prototype.fieldSpec.push(["flags","writeUInt8",1]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_DEP_A",F.prototype.msg_type=516,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),F.prototype.fieldSpec.push(["x","writeInt32LE",4]),F.prototype.fieldSpec.push(["y","writeInt32LE",4]),F.prototype.fieldSpec.push(["z","writeInt32LE",4]),F.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),F.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),F.prototype.fieldSpec.push(["flags","writeUInt8",1]);let k=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_DEP_A",k.prototype.msg_type=517,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),k.prototype.fieldSpec.push(["n","writeInt32LE",4]),k.prototype.fieldSpec.push(["e","writeInt32LE",4]),k.prototype.fieldSpec.push(["d","writeInt32LE",4]),k.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["flags","writeUInt8",1]);let B=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_HEADING_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_HEADING_DEP_A",B.prototype.msg_type=519,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),B.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),B.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),B.prototype.fieldSpec.push(["flags","writeUInt8",1]);let q=function(e,t){return r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="MSG_PROTECTION_LEVEL_DEP_A",q.prototype.msg_type=534,q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("tow").uint16("vpl").uint16("hpl").doublele("lat").doublele("lon").doublele("height").uint8("flags"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),q.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),q.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),q.prototype.fieldSpec.push(["height","writeDoubleLE",8]),q.prototype.fieldSpec.push(["flags","writeUInt8",1]);let z=function(e,t){return r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="MSG_PROTECTION_LEVEL",z.prototype.msg_type=535,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("tow").int16("wn").uint16("hpl").uint16("vpl").uint16("atpl").uint16("ctpl").uint16("hvpl").uint16("vvpl").uint16("hopl").uint16("popl").uint16("ropl").doublele("lat").doublele("lon").doublele("height").int32("v_x").int32("v_y").int32("v_z").int32("roll").int32("pitch").int32("heading").uint32("flags"),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),z.prototype.fieldSpec.push(["wn","writeInt16LE",2]),z.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["atpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ctpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hopl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["popl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ropl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),z.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),z.prototype.fieldSpec.push(["height","writeDoubleLE",8]),z.prototype.fieldSpec.push(["v_x","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_y","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_z","writeInt32LE",4]),z.prototype.fieldSpec.push(["roll","writeInt32LE",4]),z.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),z.prototype.fieldSpec.push(["heading","writeInt32LE",4]),z.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let V=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_LEAP_SECOND",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="MSG_UTC_LEAP_SECOND",V.prototype.msg_type=570,V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").int16("reserved_0").int16("reserved_1").int8("reserved_2").int8("count_before").uint16("reserved_3").uint16("reserved_4").uint16("ref_wn").uint8("ref_dn").int8("count_after"),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["reserved_0","writeInt16LE",2]),V.prototype.fieldSpec.push(["reserved_1","writeInt16LE",2]),V.prototype.fieldSpec.push(["reserved_2","writeInt8",1]),V.prototype.fieldSpec.push(["count_before","writeInt8",1]),V.prototype.fieldSpec.push(["reserved_3","writeUInt16LE",2]),V.prototype.fieldSpec.push(["reserved_4","writeUInt16LE",2]),V.prototype.fieldSpec.push(["ref_wn","writeUInt16LE",2]),V.prototype.fieldSpec.push(["ref_dn","writeUInt8",1]),V.prototype.fieldSpec.push(["count_after","writeInt8",1]);let H=function(e,t){return r.call(this,e),this.messageType="MSG_REFERENCE_FRAME_PARAM",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_REFERENCE_FRAME_PARAM",H.prototype.msg_type=580,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").uint8("ssr_iod").string("sn",{length:32}).string("tn",{length:32}).uint8("sin").uint16("utn").uint16("re_t0").int32("delta_X0").int32("delta_Y0").int32("delta_Z0").int32("theta_01").int32("theta_02").int32("theta_03").int32("scale").int32("dot_delta_X0").int32("dot_delta_Y0").int32("dot_delta_Z0").int32("dot_theta_01").int32("dot_theta_02").int32("dot_theta_03").int16("dot_scale"),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),H.prototype.fieldSpec.push(["sn","string",32]),H.prototype.fieldSpec.push(["tn","string",32]),H.prototype.fieldSpec.push(["sin","writeUInt8",1]),H.prototype.fieldSpec.push(["utn","writeUInt16LE",2]),H.prototype.fieldSpec.push(["re_t0","writeUInt16LE",2]),H.prototype.fieldSpec.push(["delta_X0","writeInt32LE",4]),H.prototype.fieldSpec.push(["delta_Y0","writeInt32LE",4]),H.prototype.fieldSpec.push(["delta_Z0","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_01","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_02","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_03","writeInt32LE",4]),H.prototype.fieldSpec.push(["scale","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_X0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_Y0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_Z0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_01","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_02","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_03","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_scale","writeInt16LE",2]);let $=function(e,t){return r.call(this,e),this.messageType="MSG_POSE_RELATIVE",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_POSE_RELATIVE",$.prototype.msg_type=581,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").uint32("tow").uint8("sensor_id").uint32("timestamp_1").uint32("timestamp_2").array("trans",{length:3,type:"int32le"}).int32("w").int32("x").int32("y").int32("z").floatle("cov_r_x_x").floatle("cov_r_x_y").floatle("cov_r_x_z").floatle("cov_r_y_y").floatle("cov_r_y_z").floatle("cov_r_z_z").floatle("cov_c_x_x").floatle("cov_c_x_y").floatle("cov_c_x_z").floatle("cov_c_y_y").floatle("cov_c_y_z").floatle("cov_c_z_z").uint8("flags"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),$.prototype.fieldSpec.push(["sensor_id","writeUInt8",1]),$.prototype.fieldSpec.push(["timestamp_1","writeUInt32LE",4]),$.prototype.fieldSpec.push(["timestamp_2","writeUInt32LE",4]),$.prototype.fieldSpec.push(["trans","array","writeInt32LE",function(){return 4},3]),$.prototype.fieldSpec.push(["w","writeInt32LE",4]),$.prototype.fieldSpec.push(["x","writeInt32LE",4]),$.prototype.fieldSpec.push(["y","writeInt32LE",4]),$.prototype.fieldSpec.push(["z","writeInt32LE",4]),$.prototype.fieldSpec.push(["cov_r_x_x","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_x_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_x_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_y_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_y_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_r_z_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_x_x","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_x_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_x_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_y_y","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_y_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["cov_c_z_z","writeFloatLE",4]),$.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={258:i,MsgGpsTime:i,260:s,MsgGpsTimeGnss:s,259:n,MsgUtcTime:n,261:a,MsgUtcTimeGnss:a,520:l,MsgDops:l,521:c,MsgPosEcef:c,532:u,MsgPosEcefCov:u,522:y,MsgPosLlh:y,529:f,MsgPosLlhCov:f,EstimatedHorizontalErrorEllipse:d,536:h,MsgPosLlhAcc:h,523:_,MsgBaselineEcef:_,524:S,MsgBaselineNed:S,525:g,MsgVelEcef:g,533:w,MsgVelEcefCov:w,526:E,MsgVelNed:E,530:m,MsgVelNedCov:m,553:b,MsgPosEcefGnss:b,564:I,MsgPosEcefCovGnss:I,554:L,MsgPosLlhGnss:L,561:T,MsgPosLlhCovGnss:T,557:v,MsgVelEcefGnss:v,565:U,MsgVelEcefCovGnss:U,558:O,MsgVelNedGnss:O,562:M,MsgVelNedCovGnss:M,531:D,MsgVelBody:D,540:A,MsgVelCog:A,528:G,MsgAgeCorrections:G,256:C,MsgGpsTimeDepA:C,518:j,MsgDopsDepA:j,512:P,MsgPosEcefDepA:P,513:R,MsgPosLlhDepA:R,514:N,MsgBaselineEcefDepA:N,515:x,MsgBaselineNedDepA:x,516:F,MsgVelEcefDepA:F,517:k,MsgVelNedDepA:k,519:B,MsgBaselineHeadingDepA:B,534:q,MsgProtectionLevelDepA:q,535:z,MsgProtectionLevel:z,570:V,MsgUtcLeapSecond:V,580:H,MsgReferenceFrameParam:H,581:$,MsgPoseRelative:$}},309:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_NDB_EVENT",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.prototype)).messageType="MSG_NDB_EVENT",s.prototype.msg_type=1024,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("recv_time").uint8("event").uint8("object_type").uint8("result").uint8("data_source").nest("object_sid",{type:i.prototype.parser}).nest("src_sid",{type:i.prototype.parser}).uint16("original_sender"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["event","writeUInt8",1]),s.prototype.fieldSpec.push(["object_type","writeUInt8",1]),s.prototype.fieldSpec.push(["result","writeUInt8",1]),s.prototype.fieldSpec.push(["data_source","writeUInt8",1]),s.prototype.fieldSpec.push(["object_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["src_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["original_sender","writeUInt16LE",2]),e.exports={1024:s,MsgNdbEvent:s}},4399:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase),s=p(278).GnssSignal,n=p(278).GnssSignalDep,a=p(278).GPSTime,l=p(278).GPSTimeDep,c=p(278).GPSTimeSec,u=(p(278).SvId,function(e,t){return r.call(this,e),this.messageType="ObservationHeader",this.fields=t||this.parser.parse(e.payload),this});(u.prototype=Object.create(r.prototype)).messageType="ObservationHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("t",{type:a.prototype.parser}).uint8("n_obs"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="Doppler",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="Doppler",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").int16("i").uint8("f"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["i","writeInt16LE",2]),y.prototype.fieldSpec.push(["f","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="PackedObsContent",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).nest("D",{type:y.prototype.parser}).uint8("cn0").uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["P","writeUInt32LE",4]),f.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),f.prototype.fieldSpec.push(["D",y.prototype.fieldSpec]),f.prototype.fieldSpec.push(["cn0","writeUInt8",1]),f.prototype.fieldSpec.push(["lock","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let d=function(e,t){return r.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="PackedOsrContent",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}).uint16("iono_std").uint16("tropo_std").uint16("range_std"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["P","writeUInt32LE",4]),d.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),d.prototype.fieldSpec.push(["lock","writeUInt8",1]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]),d.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),d.prototype.fieldSpec.push(["iono_std","writeUInt16LE",2]),d.prototype.fieldSpec.push(["tropo_std","writeUInt16LE",2]),d.prototype.fieldSpec.push(["range_std","writeUInt16LE",2]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_OBS",h.prototype.msg_type=74,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:f.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),h.prototype.fieldSpec.push(["obs","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_BASE_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_BASE_POS_LLH",_.prototype.msg_type=68,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").doublele("lat").doublele("lon").doublele("height"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),_.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),_.prototype.fieldSpec.push(["height","writeDoubleLE",8]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_BASE_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_BASE_POS_ECEF",S.prototype.msg_type=72,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").doublele("x").doublele("y").doublele("z"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["x","writeDoubleLE",8]),S.prototype.fieldSpec.push(["y","writeDoubleLE",8]),S.prototype.fieldSpec.push(["z","writeDoubleLE",8]);let g=function(e,t){return r.call(this,e),this.messageType="EphemerisCommonContent",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="EphemerisCommonContent",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).floatle("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),g.prototype.fieldSpec.push(["ura","writeFloatLE",4]),g.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),g.prototype.fieldSpec.push(["valid","writeUInt8",1]),g.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let w=function(e,t){return r.call(this,e),this.messageType="EphemerisCommonContentDepB",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="EphemerisCommonContentDepB",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),w.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),w.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),w.prototype.fieldSpec.push(["valid","writeUInt8",1]),w.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let E=function(e,t){return r.call(this,e),this.messageType="EphemerisCommonContentDepA",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="EphemerisCommonContentDepA",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toe",{type:l.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["toe",l.prototype.fieldSpec]),E.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),E.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),E.prototype.fieldSpec.push(["valid","writeUInt8",1]),E.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let m=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_E",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_E",m.prototype.msg_type=129,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:l.prototype.parser}).uint8("iode").uint16("iodc"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),m.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),m.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["w","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),m.prototype.fieldSpec.push(["toc",l.prototype.fieldSpec]),m.prototype.fieldSpec.push(["iode","writeUInt8",1]),m.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_F",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_F",b.prototype.msg_type=134,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),b.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),b.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),b.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["w","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),b.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),b.prototype.fieldSpec.push(["iode","writeUInt8",1]),b.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS",I.prototype.msg_type=138,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),I.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),I.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),I.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["w","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["af0","writeFloatLE",4]),I.prototype.fieldSpec.push(["af1","writeFloatLE",4]),I.prototype.fieldSpec.push(["af2","writeFloatLE",4]),I.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),I.prototype.fieldSpec.push(["iode","writeUInt8",1]),I.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_QZSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_QZSS",L.prototype.msg_type=142,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),L.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),L.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),L.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["w","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["af0","writeFloatLE",4]),L.prototype.fieldSpec.push(["af1","writeFloatLE",4]),L.prototype.fieldSpec.push(["af2","writeFloatLE",4]),L.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),L.prototype.fieldSpec.push(["iode","writeUInt8",1]),L.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_BDS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_BDS",T.prototype.msg_type=137,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd1").floatle("tgd2").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),T.prototype.fieldSpec.push(["tgd1","writeFloatLE",4]),T.prototype.fieldSpec.push(["tgd2","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),T.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),T.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["w","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af1","writeFloatLE",4]),T.prototype.fieldSpec.push(["af2","writeFloatLE",4]),T.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),T.prototype.fieldSpec.push(["iode","writeUInt8",1]),T.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GAL_DEP_A",v.prototype.msg_type=149,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),v.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),v.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),v.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),v.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["w","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af2","writeFloatLE",4]),v.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),v.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),v.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GAL",U.prototype.msg_type=141,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc").uint8("source"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),U.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),U.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),U.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),U.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["w","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af2","writeFloatLE",4]),U.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),U.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),U.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),U.prototype.fieldSpec.push(["source","writeUInt8",1]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_A",O.prototype.msg_type=130,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),O.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),O.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);let M=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_A",M.prototype.msg_type=131,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),M.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),M.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),M.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_B",D.prototype.msg_type=132,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),D.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),D.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS",A.prototype.msg_type=140,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"floatle"}).array("acc",{length:3,type:"floatle"}).floatle("a_gf0").floatle("a_gf1"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),A.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["vel","array","writeFloatLE",function(){return 4},3]),A.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),A.prototype.fieldSpec.push(["a_gf0","writeFloatLE",4]),A.prototype.fieldSpec.push(["a_gf1","writeFloatLE",4]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_B",G.prototype.msg_type=133,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),G.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),G.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),G.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);let C=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_C",C.prototype.msg_type=135,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),C.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),C.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["fcn","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_D",j.prototype.msg_type=136,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn").uint8("iod"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),j.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),j.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),j.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),j.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),j.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),j.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),j.prototype.fieldSpec.push(["fcn","writeUInt8",1]),j.prototype.fieldSpec.push(["iod","writeUInt8",1]);let P=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO",P.prototype.msg_type=139,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("gamma").floatle("tau").floatle("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"floatle"}).uint8("fcn").uint8("iod"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),P.prototype.fieldSpec.push(["gamma","writeFloatLE",4]),P.prototype.fieldSpec.push(["tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["d_tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),P.prototype.fieldSpec.push(["fcn","writeUInt8",1]),P.prototype.fieldSpec.push(["iod","writeUInt8",1]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_D",R.prototype.msg_type=128,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),R.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),R.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),R.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),R.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),R.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),R.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),R.prototype.fieldSpec.push(["w","writeDoubleLE",8]),R.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),R.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),R.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),R.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),R.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),R.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),R.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),R.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),R.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),R.prototype.fieldSpec.push(["valid","writeUInt8",1]),R.prototype.fieldSpec.push(["healthy","writeUInt8",1]),R.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),R.prototype.fieldSpec.push(["iode","writeUInt8",1]),R.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),R.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_A",N.prototype.msg_type=26,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),N.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),N.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["w","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["valid","writeUInt8",1]),N.prototype.fieldSpec.push(["healthy","writeUInt8",1]),N.prototype.fieldSpec.push(["prn","writeUInt8",1]);let x=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_B",x.prototype.msg_type=70,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn").uint8("iode"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),x.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),x.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["w","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["valid","writeUInt8",1]),x.prototype.fieldSpec.push(["healthy","writeUInt8",1]),x.prototype.fieldSpec.push(["prn","writeUInt8",1]),x.prototype.fieldSpec.push(["iode","writeUInt8",1]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_C",F.prototype.msg_type=71,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),F.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),F.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),F.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),F.prototype.fieldSpec.push(["w","writeDoubleLE",8]),F.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),F.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),F.prototype.fieldSpec.push(["valid","writeUInt8",1]),F.prototype.fieldSpec.push(["healthy","writeUInt8",1]),F.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),F.prototype.fieldSpec.push(["iode","writeUInt8",1]),F.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),F.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);let k=function(e,t){return r.call(this,e),this.messageType="ObservationHeaderDep",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="ObservationHeaderDep",k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").nest("t",{type:l.prototype.parser}).uint8("n_obs"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["t",l.prototype.fieldSpec]),k.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);let B=function(e,t){return r.call(this,e),this.messageType="CarrierPhaseDepA",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="CarrierPhaseDepA",B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").int32("i").uint8("f"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["i","writeInt32LE",4]),B.prototype.fieldSpec.push(["f","writeUInt8",1]);let q=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepA",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepA",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").uint8("prn"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["P","writeUInt32LE",4]),q.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),q.prototype.fieldSpec.push(["cn0","writeUInt8",1]),q.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),q.prototype.fieldSpec.push(["prn","writeUInt8",1]);let z=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepB",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepB",z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["P","writeUInt32LE",4]),z.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),z.prototype.fieldSpec.push(["cn0","writeUInt8",1]),z.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);let V=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepC",V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["P","writeUInt32LE",4]),V.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),V.prototype.fieldSpec.push(["cn0","writeUInt8",1]),V.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),V.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);let H=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_A",H.prototype.msg_type=69,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),H.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);let $=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_B",$.prototype.msg_type=67,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:z.prototype.parser,readUntil:"eof"}),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),$.prototype.fieldSpec.push(["obs","array",z.prototype.fieldSpec,function(){return this.fields.array.length},null]);let W=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(W.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_C",W.prototype.msg_type=73,W.prototype.constructor=W,W.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:V.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",V.prototype.fieldSpec,function(){return this.fields.array.length},null]);let Q=function(e,t){return r.call(this,e),this.messageType="MSG_IONO",this.fields=t||this.parser.parse(e.payload),this};(Q.prototype=Object.create(r.prototype)).messageType="MSG_IONO",Q.prototype.msg_type=144,Q.prototype.constructor=Q,Q.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).doublele("a0").doublele("a1").doublele("a2").doublele("a3").doublele("b0").doublele("b1").doublele("b2").doublele("b3"),Q.prototype.fieldSpec=[],Q.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),Q.prototype.fieldSpec.push(["a0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a3","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b3","writeDoubleLE",8]);let K=function(e,t){return r.call(this,e),this.messageType="MSG_SV_CONFIGURATION_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(K.prototype=Object.create(r.prototype)).messageType="MSG_SV_CONFIGURATION_GPS_DEP",K.prototype.msg_type=145,K.prototype.constructor=K,K.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).uint32("l2c_mask"),K.prototype.fieldSpec=[],K.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),K.prototype.fieldSpec.push(["l2c_mask","writeUInt32LE",4]);let X=function(e,t){return r.call(this,e),this.messageType="GnssCapb",this.fields=t||this.parser.parse(e.payload),this};(X.prototype=Object.create(r.prototype)).messageType="GnssCapb",X.prototype.constructor=X,X.prototype.parser=(new o).endianess("little").uint64("gps_active").uint64("gps_l2c").uint64("gps_l5").uint32("glo_active").uint32("glo_l2of").uint32("glo_l3").uint64("sbas_active").uint64("sbas_l5").uint64("bds_active").uint64("bds_d2nav").uint64("bds_b2").uint64("bds_b2a").uint32("qzss_active").uint64("gal_active").uint64("gal_e5"),X.prototype.fieldSpec=[],X.prototype.fieldSpec.push(["gps_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l2c","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["glo_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l2of","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l3","writeUInt32LE",4]),X.prototype.fieldSpec.push(["sbas_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["sbas_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_d2nav","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2a","writeUInt64LE",8]),X.prototype.fieldSpec.push(["qzss_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["gal_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gal_e5","writeUInt64LE",8]);let Y=function(e,t){return r.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(r.prototype)).messageType="MSG_GNSS_CAPB",Y.prototype.msg_type=150,Y.prototype.constructor=Y,Y.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).nest("gc",{type:X.prototype.parser}),Y.prototype.fieldSpec=[],Y.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),Y.prototype.fieldSpec.push(["gc",X.prototype.fieldSpec]);let J=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",J.prototype.msg_type=146,J.prototype.constructor=J,J.prototype.parser=(new o).endianess("little").nest("t_op",{type:l.prototype.parser}).uint8("prn").uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),J.prototype.fieldSpec=[],J.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),J.prototype.fieldSpec.push(["prn","writeUInt8",1]),J.prototype.fieldSpec.push(["valid","writeUInt8",1]),J.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),J.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),J.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);let Z=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",Z.prototype.msg_type=147,Z.prototype.constructor=Z,Z.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:n.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["valid","writeUInt8",1]),Z.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);let ee=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY",this.fields=t||this.parser.parse(e.payload),this};(ee.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY",ee.prototype.msg_type=148,ee.prototype.constructor=ee,ee.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:s.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),ee.prototype.fieldSpec=[],ee.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["valid","writeUInt8",1]),ee.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);let te=function(e,t){return r.call(this,e),this.messageType="AlmanacCommonContent",this.fields=t||this.parser.parse(e.payload),this};(te.prototype=Object.create(r.prototype)).messageType="AlmanacCommonContent",te.prototype.constructor=te,te.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),te.prototype.fieldSpec=[],te.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),te.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),te.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),te.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),te.prototype.fieldSpec.push(["valid","writeUInt8",1]),te.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let pe=function(e,t){return r.call(this,e),this.messageType="AlmanacCommonContentDep",this.fields=t||this.parser.parse(e.payload),this};(pe.prototype=Object.create(r.prototype)).messageType="AlmanacCommonContentDep",pe.prototype.constructor=pe,pe.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),pe.prototype.fieldSpec=[],pe.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),pe.prototype.fieldSpec.push(["valid","writeUInt8",1]),pe.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);let re=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(re.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GPS_DEP",re.prototype.msg_type=112,re.prototype.constructor=re,re.prototype.parser=(new o).endianess("little").nest("common",{type:pe.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),re.prototype.fieldSpec=[],re.prototype.fieldSpec.push(["common",pe.prototype.fieldSpec]),re.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),re.prototype.fieldSpec.push(["w","writeDoubleLE",8]),re.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);let oe=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS",this.fields=t||this.parser.parse(e.payload),this};(oe.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GPS",oe.prototype.msg_type=114,oe.prototype.constructor=oe,oe.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),oe.prototype.fieldSpec=[],oe.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),oe.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["w","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);let ie=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GLO_DEP",this.fields=t||this.parser.parse(e.payload),this};(ie.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GLO_DEP",ie.prototype.msg_type=113,ie.prototype.constructor=ie,ie.prototype.parser=(new o).endianess("little").nest("common",{type:pe.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),ie.prototype.fieldSpec=[],ie.prototype.fieldSpec.push(["common",pe.prototype.fieldSpec]),ie.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["i","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);let se=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GLO",this.fields=t||this.parser.parse(e.payload),this};(se.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GLO",se.prototype.msg_type=115,se.prototype.constructor=se,se.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),se.prototype.fieldSpec=[],se.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),se.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["i","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),se.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),se.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);let ne=function(e,t){return r.call(this,e),this.messageType="MSG_GLO_BIASES",this.fields=t||this.parser.parse(e.payload),this};(ne.prototype=Object.create(r.prototype)).messageType="MSG_GLO_BIASES",ne.prototype.msg_type=117,ne.prototype.constructor=ne,ne.prototype.parser=(new o).endianess("little").uint8("mask").int16("l1ca_bias").int16("l1p_bias").int16("l2ca_bias").int16("l2p_bias"),ne.prototype.fieldSpec=[],ne.prototype.fieldSpec.push(["mask","writeUInt8",1]),ne.prototype.fieldSpec.push(["l1ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l1p_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2p_bias","writeInt16LE",2]);let ae=function(e,t){return r.call(this,e),this.messageType="SvAzEl",this.fields=t||this.parser.parse(e.payload),this};(ae.prototype=Object.create(r.prototype)).messageType="SvAzEl",ae.prototype.constructor=ae,ae.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("az").int8("el"),ae.prototype.fieldSpec=[],ae.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ae.prototype.fieldSpec.push(["az","writeUInt8",1]),ae.prototype.fieldSpec.push(["el","writeInt8",1]);let le=function(e,t){return r.call(this,e),this.messageType="MSG_SV_AZ_EL",this.fields=t||this.parser.parse(e.payload),this};(le.prototype=Object.create(r.prototype)).messageType="MSG_SV_AZ_EL",le.prototype.msg_type=151,le.prototype.constructor=le,le.prototype.parser=(new o).endianess("little").array("azel",{type:ae.prototype.parser,readUntil:"eof"}),le.prototype.fieldSpec=[],le.prototype.fieldSpec.push(["azel","array",ae.prototype.fieldSpec,function(){return this.fields.array.length},null]);let ce=function(e,t){return r.call(this,e),this.messageType="MSG_OSR",this.fields=t||this.parser.parse(e.payload),this};(ce.prototype=Object.create(r.prototype)).messageType="MSG_OSR",ce.prototype.msg_type=1600,ce.prototype.constructor=ce,ce.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:d.prototype.parser,readUntil:"eof"}),ce.prototype.fieldSpec=[],ce.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),ce.prototype.fieldSpec.push(["obs","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={ObservationHeader:u,Doppler:y,PackedObsContent:f,PackedOsrContent:d,74:h,MsgObs:h,68:_,MsgBasePosLlh:_,72:S,MsgBasePosEcef:S,EphemerisCommonContent:g,EphemerisCommonContentDepB:w,EphemerisCommonContentDepA:E,129:m,MsgEphemerisGpsDepE:m,134:b,MsgEphemerisGpsDepF:b,138:I,MsgEphemerisGps:I,142:L,MsgEphemerisQzss:L,137:T,MsgEphemerisBds:T,149:v,MsgEphemerisGalDepA:v,141:U,MsgEphemerisGal:U,130:O,MsgEphemerisSbasDepA:O,131:M,MsgEphemerisGloDepA:M,132:D,MsgEphemerisSbasDepB:D,140:A,MsgEphemerisSbas:A,133:G,MsgEphemerisGloDepB:G,135:C,MsgEphemerisGloDepC:C,136:j,MsgEphemerisGloDepD:j,139:P,MsgEphemerisGlo:P,128:R,MsgEphemerisDepD:R,26:N,MsgEphemerisDepA:N,70:x,MsgEphemerisDepB:x,71:F,MsgEphemerisDepC:F,ObservationHeaderDep:k,CarrierPhaseDepA:B,PackedObsContentDepA:q,PackedObsContentDepB:z,PackedObsContentDepC:V,69:H,MsgObsDepA:H,67:$,MsgObsDepB:$,73:W,MsgObsDepC:W,144:Q,MsgIono:Q,145:K,MsgSvConfigurationGpsDep:K,GnssCapb:X,150:Y,MsgGnssCapb:Y,146:J,MsgGroupDelayDepA:J,147:Z,MsgGroupDelayDepB:Z,148:ee,MsgGroupDelay:ee,AlmanacCommonContent:te,AlmanacCommonContentDep:pe,112:re,MsgAlmanacGpsDep:re,114:oe,MsgAlmanacGps:oe,113:ie,MsgAlmanacGloDep:ie,115:se,MsgAlmanacGlo:se,117:ne,MsgGloBiases:ne,SvAzEl:ae,151:le,MsgSvAzEl:le,1600:ce,MsgOsr:ce}},2623:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_HEADING",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_HEADING",i.prototype.msg_type=527,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),i.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_ORIENT_QUAT",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_ORIENT_QUAT",s.prototype.msg_type=544,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("tow").int32("w").int32("x").int32("y").int32("z").floatle("w_accuracy").floatle("x_accuracy").floatle("y_accuracy").floatle("z_accuracy").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["w","writeInt32LE",4]),s.prototype.fieldSpec.push(["x","writeInt32LE",4]),s.prototype.fieldSpec.push(["y","writeInt32LE",4]),s.prototype.fieldSpec.push(["z","writeInt32LE",4]),s.prototype.fieldSpec.push(["w_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["x_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["y_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["z_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_ORIENT_EULER",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_ORIENT_EULER",n.prototype.msg_type=545,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").int32("roll").int32("pitch").int32("yaw").floatle("roll_accuracy").floatle("pitch_accuracy").floatle("yaw_accuracy").uint8("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["roll","writeInt32LE",4]),n.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),n.prototype.fieldSpec.push(["yaw","writeInt32LE",4]),n.prototype.fieldSpec.push(["roll_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["pitch_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["yaw_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["flags","writeUInt8",1]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_ANGULAR_RATE",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_ANGULAR_RATE",a.prototype.msg_type=546,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["x","writeInt32LE",4]),a.prototype.fieldSpec.push(["y","writeInt32LE",4]),a.prototype.fieldSpec.push(["z","writeInt32LE",4]),a.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={527:i,MsgBaselineHeading:i,544:s,MsgOrientQuat:s,545:n,MsgOrientEuler:n,546:a,MsgAngularRate:a}},7978:(e,t,p)=>{var r=p(7052).i;r.prototype.uint64=function(e,t){return this.setNextParser("uint64",e,Object.assign({},t,{formatter:function(e){var t=p(7898).UINT64,r=buffer.readUInt32LE(offset);offset+=4;var o=buffer.readUInt32LE(offset);return offset+=4,new t(r,o)}}))},r.prototype.compile=function(){var e=this.getCode();this.compiled=function(t,r,o){return"undefined"!=typeof window&&void 0===window.Buffer&&(window.Buffer=Buffer),new Function("buffer","callback","constructorFn","require",e).call(this,t,r,o,(function(e){if("cuint"===e)return p(7898);throw new Error("Unknown module required: "+e)}))}},e.exports=r},9757:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=p(278).GnssSignalDep,n=p(278).GPSTime,a=p(278).GPSTimeDep,l=(p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC",this.fields=t||this.parser.parse(e.payload),this});(l.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC",l.prototype.msg_type=105,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little"),l.prototype.fieldSpec=[];let c=function(e,t){return r.call(this,e),this.messageType="MSG_SET_TIME",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SET_TIME",c.prototype.msg_type=104,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little"),c.prototype.fieldSpec=[];let u=function(e,t){return r.call(this,e),this.messageType="MSG_RESET",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_RESET",u.prototype.msg_type=182,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_RESET_DEP",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_RESET_DEP",y.prototype.msg_type=178,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CW_RESULTS",f.prototype.msg_type=192,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little"),f.prototype.fieldSpec=[];let d=function(e,t){return r.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_CW_START",d.prototype.msg_type=193,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little"),d.prototype.fieldSpec=[];let h=function(e,t){return r.call(this,e),this.messageType="MSG_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_RESET_FILTERS",h.prototype.msg_type=34,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("filter"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["filter","writeUInt8",1]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_INIT_BASE_DEP",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_INIT_BASE_DEP",_.prototype.msg_type=35,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little"),_.prototype.fieldSpec=[];let S=function(e,t){return r.call(this,e),this.messageType="MSG_THREAD_STATE",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_THREAD_STATE",S.prototype.msg_type=23,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").string("name",{length:20}).uint16("cpu").uint32("stack_free"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["name","string",20]),S.prototype.fieldSpec.push(["cpu","writeUInt16LE",2]),S.prototype.fieldSpec.push(["stack_free","writeUInt32LE",4]);let g=function(e,t){return r.call(this,e),this.messageType="UARTChannel",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="UARTChannel",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").floatle("tx_throughput").floatle("rx_throughput").uint16("crc_error_count").uint16("io_error_count").uint8("tx_buffer_level").uint8("rx_buffer_level"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["rx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["crc_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["io_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["tx_buffer_level","writeUInt8",1]),g.prototype.fieldSpec.push(["rx_buffer_level","writeUInt8",1]);let w=function(e,t){return r.call(this,e),this.messageType="Period",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="Period",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").int32("avg").int32("pmin").int32("pmax").int32("current"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["avg","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmin","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmax","writeInt32LE",4]),w.prototype.fieldSpec.push(["current","writeInt32LE",4]);let E=function(e,t){return r.call(this,e),this.messageType="Latency",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="Latency",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").int32("avg").int32("lmin").int32("lmax").int32("current"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["avg","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmin","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmax","writeInt32LE",4]),E.prototype.fieldSpec.push(["current","writeInt32LE",4]);let m=function(e,t){return r.call(this,e),this.messageType="MSG_UART_STATE",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="MSG_UART_STATE",m.prototype.msg_type=29,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}).nest("obs_period",{type:w.prototype.parser}),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["obs_period",w.prototype.fieldSpec]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_UART_STATE_DEPA",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_UART_STATE_DEPA",b.prototype.msg_type=24,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_IAR_STATE",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_IAR_STATE",I.prototype.msg_type=25,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("num_hyps"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["num_hyps","writeUInt32LE",4]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_MASK_SATELLITE",L.prototype.msg_type=43,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:i.prototype.parser}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["mask","writeUInt8",1]),L.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE_DEP",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_MASK_SATELLITE_DEP",T.prototype.msg_type=27,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:s.prototype.parser}),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["mask","writeUInt8",1]),T.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_DEVICE_MONITOR",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_DEVICE_MONITOR",v.prototype.msg_type=181,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").int16("dev_vin").int16("cpu_vint").int16("cpu_vaux").int16("cpu_temperature").int16("fe_temperature"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["dev_vin","writeInt16LE",2]),v.prototype.fieldSpec.push(["cpu_vint","writeInt16LE",2]),v.prototype.fieldSpec.push(["cpu_vaux","writeInt16LE",2]),v.prototype.fieldSpec.push(["cpu_temperature","writeInt16LE",2]),v.prototype.fieldSpec.push(["fe_temperature","writeInt16LE",2]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_REQ",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_REQ",U.prototype.msg_type=184,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("sequence").string("command",{greedy:!0}),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),U.prototype.fieldSpec.push(["command","string",null]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_RESP",O.prototype.msg_type=185,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").uint32("sequence").int32("code"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),O.prototype.fieldSpec.push(["code","writeInt32LE",4]);let M=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_OUTPUT",M.prototype.msg_type=188,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("sequence").string("line",{greedy:!0}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),M.prototype.fieldSpec.push(["line","string",null]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_REQ",D.prototype.msg_type=186,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little"),D.prototype.fieldSpec=[];let A=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_RESP",A.prototype.msg_type=187,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").array("ipv4_address",{length:4,type:"uint8"}).uint8("ipv4_mask_size").array("ipv6_address",{length:16,type:"uint8"}).uint8("ipv6_mask_size").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}).uint32("flags"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["ipv4_address","array","writeUInt8",function(){return 1},4]),A.prototype.fieldSpec.push(["ipv4_mask_size","writeUInt8",1]),A.prototype.fieldSpec.push(["ipv6_address","array","writeUInt8",function(){return 1},16]),A.prototype.fieldSpec.push(["ipv6_mask_size","writeUInt8",1]),A.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["interface_name","string",16]),A.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let G=function(e,t){return r.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="NetworkUsage",G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").uint64("duration").uint64("total_bytes").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["duration","writeUInt64LE",8]),G.prototype.fieldSpec.push(["total_bytes","writeUInt64LE",8]),G.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["interface_name","string",16]);let C=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_BANDWIDTH_USAGE",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_BANDWIDTH_USAGE",C.prototype.msg_type=189,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").array("interfaces",{type:G.prototype.parser,readUntil:"eof"}),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["interfaces","array",G.prototype.fieldSpec,function(){return this.fields.array.length},null]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_CELL_MODEM_STATUS",j.prototype.msg_type=190,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").int8("signal_strength").floatle("signal_error_rate").array("reserved",{type:"uint8",readUntil:"eof"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["signal_strength","writeInt8",1]),j.prototype.fieldSpec.push(["signal_error_rate","writeFloatLE",4]),j.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},null]);let P=function(e,t){return r.call(this,e),this.messageType="MSG_SPECAN_DEP",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_SPECAN_DEP",P.prototype.msg_type=80,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:a.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),P.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),P.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_SPECAN",R.prototype.msg_type=81,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:n.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),R.prototype.fieldSpec.push(["t",n.prototype.fieldSpec]),R.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),R.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),R.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),R.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),R.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_FRONT_END_GAIN",N.prototype.msg_type=191,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").array("rf_gain",{length:8,type:"int8"}).array("if_gain",{length:8,type:"int8"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["rf_gain","array","writeInt8",function(){return 1},8]),N.prototype.fieldSpec.push(["if_gain","array","writeInt8",function(){return 1},8]),e.exports={105:l,MsgAlmanac:l,104:c,MsgSetTime:c,182:u,MsgReset:u,178:y,MsgResetDep:y,192:f,MsgCwResults:f,193:d,MsgCwStart:d,34:h,MsgResetFilters:h,35:_,MsgInitBaseDep:_,23:S,MsgThreadState:S,UARTChannel:g,Period:w,Latency:E,29:m,MsgUartState:m,24:b,MsgUartStateDepa:b,25:I,MsgIarState:I,43:L,MsgMaskSatellite:L,27:T,MsgMaskSatelliteDep:T,181:v,MsgDeviceMonitor:v,184:U,MsgCommandReq:U,185:O,MsgCommandResp:O,188:M,MsgCommandOutput:M,186:D,MsgNetworkStateReq:D,187:A,MsgNetworkStateResp:A,NetworkUsage:G,189:C,MsgNetworkBandwidthUsage:C,190:j,MsgCellModemStatus:j,80:P,MsgSpecanDep:P,81:R,MsgSpecan:R,191:N,MsgFrontEndGain:N}},2827:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_MEASUREMENT_POINT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_MEASUREMENT_POINT",i.prototype.msg_type=52992,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("total_time").uint16("num_executions").uint32("min").uint32("max").uint64("return_addr").uint64("id").uint64("slice_time").uint16("line").string("func",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["total_time","writeUInt32LE",4]),i.prototype.fieldSpec.push(["num_executions","writeUInt16LE",2]),i.prototype.fieldSpec.push(["min","writeUInt32LE",4]),i.prototype.fieldSpec.push(["max","writeUInt32LE",4]),i.prototype.fieldSpec.push(["return_addr","writeUInt64LE",8]),i.prototype.fieldSpec.push(["id","writeUInt64LE",8]),i.prototype.fieldSpec.push(["slice_time","writeUInt64LE",8]),i.prototype.fieldSpec.push(["line","writeUInt16LE",2]),i.prototype.fieldSpec.push(["func","string",null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_PROFILING_SYSTEM_INFO",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_PROFILING_SYSTEM_INFO",s.prototype.msg_type=52993,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("total_cpu_time").uint64("age").uint8("n_threads").uint32("heap_usage"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["total_cpu_time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["age","writeUInt64LE",8]),s.prototype.fieldSpec.push(["n_threads","writeUInt8",1]),s.prototype.fieldSpec.push(["heap_usage","writeUInt32LE",4]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_PROFILING_THREAD_INFO",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_PROFILING_THREAD_INFO",n.prototype.msg_type=52994,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint64("total_cpu_time").uint64("age").uint8("state").uint32("stack_size").uint32("stack_usage").string("name",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["total_cpu_time","writeUInt64LE",8]),n.prototype.fieldSpec.push(["age","writeUInt64LE",8]),n.prototype.fieldSpec.push(["state","writeUInt8",1]),n.prototype.fieldSpec.push(["stack_size","writeUInt32LE",4]),n.prototype.fieldSpec.push(["stack_usage","writeUInt32LE",4]),n.prototype.fieldSpec.push(["name","string",null]);let a=function(e,t){return r.call(this,e),this.messageType="ResourceBucket",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="ResourceBucket",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").string("name",{length:21}).uint8("thread").uint8("mutex").uint8("cv").uint8("io").uint32("heap_bytes_alloc").uint32("heap_bytes_free").uint32("io_write").uint32("io_read"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["name","string",21]),a.prototype.fieldSpec.push(["thread","writeUInt8",1]),a.prototype.fieldSpec.push(["mutex","writeUInt8",1]),a.prototype.fieldSpec.push(["cv","writeUInt8",1]),a.prototype.fieldSpec.push(["io","writeUInt8",1]),a.prototype.fieldSpec.push(["heap_bytes_alloc","writeUInt32LE",4]),a.prototype.fieldSpec.push(["heap_bytes_free","writeUInt32LE",4]),a.prototype.fieldSpec.push(["io_write","writeUInt32LE",4]),a.prototype.fieldSpec.push(["io_read","writeUInt32LE",4]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_PROFILING_RESOURCE_COUNTER",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_PROFILING_RESOURCE_COUNTER",l.prototype.msg_type=52995,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("seq_no").uint8("seq_len").array("buckets",{type:a.prototype.parser,readUntil:"eof"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["seq_no","writeUInt8",1]),l.prototype.fieldSpec.push(["seq_len","writeUInt8",1]),l.prototype.fieldSpec.push(["buckets","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={52992:i,MsgMeasurementPoint:i,52993:s,MsgProfilingSystemInfo:s,52994:n,MsgProfilingThreadInfo:n,ResourceBucket:a,52995:l,MsgProfilingResourceCounter:l}},5232:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_SBAS_RAW",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.prototype)).messageType="MSG_SBAS_RAW",s.prototype.msg_type=30583,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint32("tow").uint8("message_type").array("data",{length:27,type:"uint8"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["message_type","writeUInt8",1]),s.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},27]),e.exports={30583:s,MsgSbasRaw:s}},7238:(e,t,p)=>{var r=p(4148),o=(p(6468),p(7898).UINT64),i=function(e,t,p,r){var o=new Buffer(e);return o[t](p,r||0),o};function s(e){return this.messageType="raw",this.sbp=e||{},this.fields={},this}o.prototype.toJSON=function(){return this.toString()},s.prototype.fieldSpec=[],s.prototype.payloadToBuffer=function(e,t){var p=[];for(var i in e=e||this.fieldSpec,t=t||this.fields,e){var s=e[i],n=s[0],a=s[1],l=function(e){return"function"==typeof e?e.apply(this):e}.bind(this);if("string"==typeof a&&0===a.indexOf("write")){var c=l(s[2]);if("writeUInt64LE"===a){r(t[n]instanceof o,"uint64 type must be represented by cuint.UINT64");var u=t[n].clone().shiftRight(32).and(new o(4294967295,0)).toNumber(),y=t[n].clone().and(new o(4294967295,0)).toNumber();let e=new Buffer(8);e.writeUInt32LE(y),e.writeUInt32LE(u,4),p.push(e)}else{let e=new Buffer(c);e[a](t[n],0),p.push(e)}}else if("string"===a){let e=new Buffer(t[n].length);e.write(t[n],0,"utf8"),p.push(e)}else if("array"===a){var f=s[2];for(var d in t[n]){var h=t[n][d];if(Array.isArray(f))p=p.concat(this.payloadToBuffer(f,h));else{let e=new Buffer(l(s[3]));e[f](h,0),p.push(e)}}}else p=p.concat(this.payloadToBuffer(a,t[n]))}return Buffer.concat(p)},s.prototype.getLengthBuffer=function(){return i(1,"writeUInt8",this.length||this.sbp.length,0)},s.prototype.getSenderBuffer=function(){return i(2,"writeUInt16LE",this.sender||this.sbp.sender,0)},s.prototype.getPreambleBuffer=function(){return i(1,"writeUInt8",this.preamble||this.sbp.preamble,0)},s.prototype.getMsgTypeBuffer=function(){return i(2,"writeUInt16LE",this.msg_type||this.sbp.msg_type,0)},s.prototype.toBuffer=function(){var e=this.payloadToBuffer(),t=i(2,"writeUInt16LE",this.crc||this.sbp.crc,0),p=[this.getPreambleBuffer(),this.getMsgTypeBuffer(),this.getSenderBuffer(),this.getLengthBuffer()];return Buffer.concat(p.concat(e).concat(t))},s.prototype.toJSON=function(){var e={};return Object.keys(this.sbp).forEach(function(t){this.sbp[t]instanceof Buffer?e[t]=this.sbp[t].toString("base64"):e[t]=this.sbp[t]}.bind(this)),Object.keys(this.fields).forEach(function(t){e[t]=this.fields[t]}.bind(this)),e},s.prototype.toBase64=function(){return this.toBuffer().toString("base64")},e.exports=s},4120:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_SAVE",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_SAVE",i.prototype.msg_type=161,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];let s=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_WRITE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_WRITE",s.prototype.msg_type=160,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["setting","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_WRITE_RESP",n.prototype.msg_type=175,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["status","writeUInt8",1]),n.prototype.fieldSpec.push(["setting","string",null]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_REQ",a.prototype.msg_type=164,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["setting","string",null]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_RESP",l.prototype.msg_type=165,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["setting","string",null]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",c.prototype.msg_type=162,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("index"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["index","writeUInt16LE",2]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",u.prototype.msg_type=167,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("index").string("setting",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt16LE",2]),u.prototype.fieldSpec.push(["setting","string",null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",y.prototype.msg_type=166,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER",f.prototype.msg_type=174,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["setting","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER_RESP",d.prototype.msg_type=431,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["status","writeUInt8",1]),d.prototype.fieldSpec.push(["setting","string",null]),e.exports={161:i,MsgSettingsSave:i,160:s,MsgSettingsWrite:s,175:n,MsgSettingsWriteResp:n,164:a,MsgSettingsReadReq:a,165:l,MsgSettingsReadResp:l,162:c,MsgSettingsReadByIndexReq:c,167:u,MsgSettingsReadByIndexResp:u,166:y,MsgSettingsReadByIndexDone:y,174:f,MsgSettingsRegister:f,431:d,MsgSettingsRegisterResp:d}},9286:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="UtcTime",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="UtcTime",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["year","writeUInt16LE",2]),i.prototype.fieldSpec.push(["month","writeUInt8",1]),i.prototype.fieldSpec.push(["day","writeUInt8",1]),i.prototype.fieldSpec.push(["hours","writeUInt8",1]),i.prototype.fieldSpec.push(["minutes","writeUInt8",1]),i.prototype.fieldSpec.push(["seconds","writeUInt8",1]),i.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);let s=function(e,t){return r.call(this,e),this.messageType="ECDSASignature",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="ECDSASignature",s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("len").array("data",{length:72,type:"uint8"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["len","writeUInt8",1]),s.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},72]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_CERTIFICATE",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_CERTIFICATE",n.prototype.msg_type=3076,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("n_msg").array("certificate_id",{length:4,type:"uint8"}).uint8("flags").array("certificate_bytes",{type:"uint8",readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["n_msg","writeUInt8",1]),n.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),n.prototype.fieldSpec.push(["flags","writeUInt8",1]),n.prototype.fieldSpec.push(["certificate_bytes","array","writeUInt8",function(){return 1},null]);let a=function(e,t){return r.call(this,e),this.messageType="MSG_CERTIFICATE_CHAIN",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_CERTIFICATE_CHAIN",a.prototype.msg_type=3081,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").array("root_certificate",{length:20,type:"uint8"}).array("intermediate_certificate",{length:20,type:"uint8"}).array("corrections_certificate",{length:20,type:"uint8"}).nest("expiration",{type:i.prototype.parser}).nest("signature",{type:s.prototype.parser}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["root_certificate","array","writeUInt8",function(){return 1},20]),a.prototype.fieldSpec.push(["intermediate_certificate","array","writeUInt8",function(){return 1},20]),a.prototype.fieldSpec.push(["corrections_certificate","array","writeUInt8",function(){return 1},20]),a.prototype.fieldSpec.push(["expiration",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["signature",s.prototype.fieldSpec]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_CERTIFICATE_CHAIN_DEP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_CERTIFICATE_CHAIN_DEP",l.prototype.msg_type=3077,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").array("root_certificate",{length:20,type:"uint8"}).array("intermediate_certificate",{length:20,type:"uint8"}).array("corrections_certificate",{length:20,type:"uint8"}).nest("expiration",{type:i.prototype.parser}).array("signature",{length:64,type:"uint8"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["root_certificate","array","writeUInt8",function(){return 1},20]),l.prototype.fieldSpec.push(["intermediate_certificate","array","writeUInt8",function(){return 1},20]),l.prototype.fieldSpec.push(["corrections_certificate","array","writeUInt8",function(){return 1},20]),l.prototype.fieldSpec.push(["expiration",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_AES_CMAC_SIGNATURE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_AES_CMAC_SIGNATURE",c.prototype.msg_type=3088,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).array("signature",{length:16,type:"uint8"}).uint8("flags").array("signed_messages",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),c.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),c.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),c.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},16]),c.prototype.fieldSpec.push(["flags","writeUInt8",1]),c.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_SIGNATURE",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_SIGNATURE",u.prototype.msg_type=3080,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("flags").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).nest("signature",{type:s.prototype.parser}).array("signed_messages",{type:"uint8",readUntil:"eof"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["flags","writeUInt8",1]),u.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),u.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),u.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),u.prototype.fieldSpec.push(["signature",s.prototype.fieldSpec]),u.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_SIGNATURE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_SIGNATURE_DEP_B",y.prototype.msg_type=3079,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint8("flags").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).uint8("n_signature_bytes").array("signature",{length:72,type:"uint8"}).array("signed_messages",{type:"uint8",readUntil:"eof"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["flags","writeUInt8",1]),y.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),y.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),y.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),y.prototype.fieldSpec.push(["n_signature_bytes","writeUInt8",1]),y.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},72]),y.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_ECDSA_SIGNATURE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_ECDSA_SIGNATURE_DEP_A",f.prototype.msg_type=3078,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("flags").uint8("stream_counter").uint8("on_demand_counter").array("certificate_id",{length:4,type:"uint8"}).array("signature",{length:64,type:"uint8"}).array("signed_messages",{type:"uint8",readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),f.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),f.prototype.fieldSpec.push(["certificate_id","array","writeUInt8",function(){return 1},4]),f.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),f.prototype.fieldSpec.push(["signed_messages","array","writeUInt8",function(){return 1},null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_CERTIFICATE_DEP",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_CERTIFICATE_DEP",d.prototype.msg_type=3074,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("n_msg").array("fingerprint",{length:20,type:"uint8"}).array("certificate_bytes",{type:"uint8",readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["n_msg","writeUInt8",1]),d.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),d.prototype.fieldSpec.push(["certificate_bytes","array","writeUInt8",function(){return 1},null]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE_DEP_A",h.prototype.msg_type=3073,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("signature",{length:64,type:"uint8"}).array("fingerprint",{length:20,type:"uint8"}).array("signed_messages",{type:"uint32le",readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),h.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),h.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE_DEP_B",_.prototype.msg_type=3075,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").uint8("stream_counter").uint8("on_demand_counter").array("signature",{length:64,type:"uint8"}).array("fingerprint",{length:20,type:"uint8"}).array("signed_messages",{type:"uint32le",readUntil:"eof"}),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),_.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),_.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),_.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),_.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]),e.exports={UtcTime:i,ECDSASignature:s,3076:n,MsgEcdsaCertificate:n,3081:a,MsgCertificateChain:a,3077:l,MsgCertificateChainDep:l,3088:c,MsgAesCmacSignature:c,3080:u,MsgEcdsaSignature:u,3079:y,MsgEcdsaSignatureDepB:y,3078:f,MsgEcdsaSignatureDepA:f,3074:d,MsgEd25519CertificateDep:d,3073:h,MsgEd25519SignatureDepA:h,3075:_,MsgEd25519SignatureDepB:_}},848:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="SolutionInputType",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="SolutionInputType",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("sensor_type").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_SOLN_META_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_SOLN_META_DEP_A",s.prototype.msg_type=65295,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("pdop").uint16("hdop").uint16("vdop").uint8("n_sats").uint16("age_corrections").uint8("alignment_status").uint32("last_used_gnss_pos_tow").uint32("last_used_gnss_vel_tow").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),s.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),s.prototype.fieldSpec.push(["alignment_status","writeUInt8",1]),s.prototype.fieldSpec.push(["last_used_gnss_pos_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["last_used_gnss_vel_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_SOLN_META",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_SOLN_META",n.prototype.msg_type=65294,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").uint16("pdop").uint16("hdop").uint16("vdop").uint16("age_corrections").uint32("age_gnss").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_gnss","writeUInt32LE",4]),n.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);let a=function(e,t){return r.call(this,e),this.messageType="GNSSInputType",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="GNSSInputType",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="IMUInputType",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="IMUInputType",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["flags","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="OdoInputType",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="OdoInputType",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={SolutionInputType:i,65295:s,MsgSolnMetaDepA:s,65294:n,MsgSolnMeta:n,GNSSInputType:a,IMUInputType:l,OdoInputType:c}},9269:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec),n=p(278).SvId,a=function(e,t){return r.call(this,e),this.messageType="CodeBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="CodeBiasesContent",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("code").int16("value"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["code","writeUInt8",1]),a.prototype.fieldSpec.push(["value","writeInt16LE",2]);let l=function(e,t){return r.call(this,e),this.messageType="PhaseBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="PhaseBiasesContent",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("code").uint8("integer_indicator").uint8("widelane_integer_indicator").uint8("discontinuity_counter").int32("bias"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["code","writeUInt8",1]),l.prototype.fieldSpec.push(["integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["widelane_integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["discontinuity_counter","writeUInt8",1]),l.prototype.fieldSpec.push(["bias","writeInt32LE",4]);let c=function(e,t){return r.call(this,e),this.messageType="STECHeader",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="STECHeader",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),c.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),c.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),c.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeader",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),u.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),u.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),u.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),u.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),u.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="STECSatElement",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="STECSatElement",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).uint8("stec_quality_indicator").array("stec_coeff",{length:4,type:"int16le"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["stec_quality_indicator","writeUInt8",1]),y.prototype.fieldSpec.push(["stec_coeff","array","writeInt16LE",function(){return 2},4]);let f=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrectionNoStd",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),f.prototype.fieldSpec.push(["wet","writeInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrection",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet").uint8("stddev"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),d.prototype.fieldSpec.push(["wet","writeInt8",1]),d.prototype.fieldSpec.push(["stddev","writeUInt8",1]);let h=function(e,t){return r.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="STECResidualNoStd",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),h.prototype.fieldSpec.push(["residual","writeInt16LE",2]);let _=function(e,t){return r.call(this,e),this.messageType="STECResidual",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="STECResidual",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual").uint8("stddev"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),_.prototype.fieldSpec.push(["residual","writeInt16LE",2]),_.prototype.fieldSpec.push(["stddev","writeUInt8",1]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK",S.prototype.msg_type=1501,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint32("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),S.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),S.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),S.prototype.fieldSpec.push(["iod","writeUInt32LE",4]),S.prototype.fieldSpec.push(["radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["along","writeInt32LE",4]),S.prototype.fieldSpec.push(["cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["c0","writeInt32LE",4]),S.prototype.fieldSpec.push(["c1","writeInt32LE",4]),S.prototype.fieldSpec.push(["c2","writeInt32LE",4]);let g=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_CODE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_BIASES",g.prototype.msg_type=1505,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").array("biases",{type:a.prototype.parser,readUntil:"eof"}),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),g.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),g.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),g.prototype.fieldSpec.push(["biases","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_PHASE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_SSR_PHASE_BIASES",w.prototype.msg_type=1510,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("dispersive_bias").uint8("mw_consistency").uint16("yaw").int8("yaw_rate").array("biases",{type:l.prototype.parser,readUntil:"eof"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),w.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),w.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),w.prototype.fieldSpec.push(["dispersive_bias","writeUInt8",1]),w.prototype.fieldSpec.push(["mw_consistency","writeUInt8",1]),w.prototype.fieldSpec.push(["yaw","writeUInt16LE",2]),w.prototype.fieldSpec.push(["yaw_rate","writeInt8",1]),w.prototype.fieldSpec.push(["biases","array",l.prototype.fieldSpec,function(){return this.fields.array.length},null]);let E=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP",E.prototype.msg_type=1531,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("header",{type:c.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["header",c.prototype.fieldSpec]),E.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let m=function(e,t){return r.call(this,e),this.messageType="BoundsHeader",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="BoundsHeader",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("sol_id"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),m.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),m.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),m.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),m.prototype.fieldSpec.push(["sol_id","writeUInt8",1]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION",b.prototype.msg_type=1533,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("n_sats").array("stec_sat_list",{type:y.prototype.parser,length:"n_sats"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),b.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),b.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let I=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION",I.prototype.msg_type=1532,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:d.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),I.prototype.fieldSpec.push(["index","writeUInt16LE",2]),I.prototype.fieldSpec.push(["tropo_delay_correction",d.prototype.fieldSpec]),I.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);let L=function(e,t){return r.call(this,e),this.messageType="STECSatElementIntegrity",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="STECSatElementIntegrity",L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("stec_residual",{type:_.prototype.parser}).uint8("stec_bound_mu").uint8("stec_bound_sig").uint8("stec_bound_mu_dot").uint8("stec_bound_sig_dot"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["stec_residual",_.prototype.fieldSpec]),L.prototype.fieldSpec.push(["stec_bound_mu","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_bound_sig","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_bound_mu_dot","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_bound_sig_dot","writeUInt8",1]);let T=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",T.prototype.msg_type=1534,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("tropo_qi").uint16("grid_point_id").nest("tropo_delay_correction",{type:d.prototype.parser}).uint8("tropo_v_hydro_bound_mu").uint8("tropo_v_hydro_bound_sig").uint8("tropo_v_wet_bound_mu").uint8("tropo_v_wet_bound_sig").uint8("n_sats").array("stec_sat_list",{type:L.prototype.parser,length:"n_sats"}),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),T.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),T.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tropo_qi","writeUInt8",1]),T.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tropo_delay_correction",d.prototype.fieldSpec]),T.prototype.fieldSpec.push(["tropo_v_hydro_bound_mu","writeUInt8",1]),T.prototype.fieldSpec.push(["tropo_v_hydro_bound_sig","writeUInt8",1]),T.prototype.fieldSpec.push(["tropo_v_wet_bound_mu","writeUInt8",1]),T.prototype.fieldSpec.push(["tropo_v_wet_bound_sig","writeUInt8",1]),T.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),T.prototype.fieldSpec.push(["stec_sat_list","array",L.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let v=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP_A",v.prototype.msg_type=1526,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),v.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),v.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),v.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),v.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),v.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),v.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),v.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),v.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);let U=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP_B",U.prototype.msg_type=1527,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),U.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),U.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),U.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),U.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION",O.prototype.msg_type=1528,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("update_interval").uint8("sol_id").uint8("iod_atmo").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),O.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),O.prototype.fieldSpec.push(["sol_id","writeUInt8",1]),O.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),O.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),O.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),O.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),O.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),O.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),O.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),O.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),O.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),O.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);let M=function(e,t){return r.call(this,e),this.messageType="SatelliteAPC",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="SatelliteAPC",M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint8("sat_info").uint16("svn").array("pco",{length:3,type:"int16le"}).array("pcv",{length:21,type:"int8"}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),M.prototype.fieldSpec.push(["sat_info","writeUInt8",1]),M.prototype.fieldSpec.push(["svn","writeUInt16LE",2]),M.prototype.fieldSpec.push(["pco","array","writeInt16LE",function(){return 2},3]),M.prototype.fieldSpec.push(["pcv","array","writeInt8",function(){return 1},21]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC_DEP",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC_DEP",D.prototype.msg_type=1540,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").array("apc",{type:M.prototype.parser,readUntil:"eof"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["apc","array",M.prototype.fieldSpec,function(){return this.fields.array.length},null]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC",A.prototype.msg_type=1541,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("update_interval").uint8("sol_id").uint8("iod_ssr").array("apc",{type:M.prototype.parser,readUntil:"eof"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),A.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),A.prototype.fieldSpec.push(["sol_id","writeUInt8",1]),A.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),A.prototype.fieldSpec.push(["apc","array",M.prototype.fieldSpec,function(){return this.fields.array.length},null]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",G.prototype.msg_type=1500,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),G.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),G.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),G.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),G.prototype.fieldSpec.push(["iod","writeUInt8",1]),G.prototype.fieldSpec.push(["radial","writeInt32LE",4]),G.prototype.fieldSpec.push(["along","writeInt32LE",4]),G.prototype.fieldSpec.push(["cross","writeInt32LE",4]),G.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),G.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),G.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),G.prototype.fieldSpec.push(["c0","writeInt32LE",4]),G.prototype.fieldSpec.push(["c1","writeInt32LE",4]),G.prototype.fieldSpec.push(["c2","writeInt32LE",4]);let C=function(e,t){return r.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="STECHeaderDepA",C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),C.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),C.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),C.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),C.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeaderDepA",j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),j.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),j.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),j.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),j.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),j.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);let P=function(e,t){return r.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="GridDefinitionHeaderDepA",P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint8("region_size_inverse").uint16("area_width").uint16("lat_nw_corner_enc").uint16("lon_nw_corner_enc").uint8("num_msgs").uint8("seq_num"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),P.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),P.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),P.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),P.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),P.prototype.fieldSpec.push(["seq_num","writeUInt8",1]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP_A",R.prototype.msg_type=1515,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").nest("header",{type:C.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["header",C.prototype.fieldSpec]),R.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let N=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",N.prototype.msg_type=1520,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").nest("header",{type:j.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:h.prototype.parser,readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["header",j.prototype.fieldSpec]),N.prototype.fieldSpec.push(["index","writeUInt16LE",2]),N.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),N.prototype.fieldSpec.push(["stec_residuals","array",h.prototype.fieldSpec,function(){return this.fields.array.length},null]);let x=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",x.prototype.msg_type=1530,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").nest("header",{type:j.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:d.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["header",j.prototype.fieldSpec]),x.prototype.fieldSpec.push(["index","writeUInt16LE",2]),x.prototype.fieldSpec.push(["tropo_delay_correction",d.prototype.fieldSpec]),x.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRID_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",F.prototype.msg_type=1525,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").nest("header",{type:P.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["header",P.prototype.fieldSpec]),F.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]);let k=function(e,t){return r.call(this,e),this.messageType="OrbitClockBound",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="OrbitClockBound",k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("orb_radial_bound_mu").uint8("orb_along_bound_mu").uint8("orb_cross_bound_mu").uint8("orb_radial_bound_sig").uint8("orb_along_bound_sig").uint8("orb_cross_bound_sig").uint8("clock_bound_mu").uint8("clock_bound_sig"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_radial_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_along_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_cross_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_radial_bound_sig","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_along_bound_sig","writeUInt8",1]),k.prototype.fieldSpec.push(["orb_cross_bound_sig","writeUInt8",1]),k.prototype.fieldSpec.push(["clock_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["clock_bound_sig","writeUInt8",1]);let B=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",B.prototype.msg_type=1502,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats").array("orbit_clock_bounds",{type:k.prototype.parser,length:"n_sats"}),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),B.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),B.prototype.fieldSpec.push(["const_id","writeUInt8",1]),B.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),B.prototype.fieldSpec.push(["orbit_clock_bounds","array",k.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let q=function(e,t){return r.call(this,e),this.messageType="CodePhaseBiasesSatSig",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="CodePhaseBiasesSatSig",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("signal_id").uint8("code_bias_bound_mu").uint8("code_bias_bound_sig").uint8("phase_bias_bound_mu").uint8("phase_bias_bound_sig"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),q.prototype.fieldSpec.push(["signal_id","writeUInt8",1]),q.prototype.fieldSpec.push(["code_bias_bound_mu","writeUInt8",1]),q.prototype.fieldSpec.push(["code_bias_bound_sig","writeUInt8",1]),q.prototype.fieldSpec.push(["phase_bias_bound_mu","writeUInt8",1]),q.prototype.fieldSpec.push(["phase_bias_bound_sig","writeUInt8",1]);let z=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",z.prototype.msg_type=1516,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats_signals").array("satellites_signals",{type:q.prototype.parser,length:"n_sats_signals"}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),z.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),z.prototype.fieldSpec.push(["const_id","writeUInt8",1]),z.prototype.fieldSpec.push(["n_sats_signals","writeUInt8",1]),z.prototype.fieldSpec.push(["satellites_signals","array",q.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats_signals"]);let V=function(e,t){return r.call(this,e),this.messageType="OrbitClockBoundDegradation",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="OrbitClockBoundDegradation",V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").uint8("orb_radial_bound_mu_dot").uint8("orb_along_bound_mu_dot").uint8("orb_cross_bound_mu_dot").uint8("orb_radial_bound_sig_dot").uint8("orb_along_bound_sig_dot").uint8("orb_cross_bound_sig_dot").uint8("clock_bound_mu_dot").uint8("clock_bound_sig_dot"),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["orb_radial_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_along_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_cross_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_radial_bound_sig_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_along_bound_sig_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["orb_cross_bound_sig_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["clock_bound_mu_dot","writeUInt8",1]),V.prototype.fieldSpec.push(["clock_bound_sig_dot","writeUInt8",1]);let H=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",H.prototype.msg_type=1503,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint64("sat_bitmask").nest("orbit_clock_bounds_degradation",{type:V.prototype.parser}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),H.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),H.prototype.fieldSpec.push(["const_id","writeUInt8",1]),H.prototype.fieldSpec.push(["sat_bitmask","writeUInt64LE",8]),H.prototype.fieldSpec.push(["orbit_clock_bounds_degradation",V.prototype.fieldSpec]),e.exports={CodeBiasesContent:a,PhaseBiasesContent:l,STECHeader:c,GriddedCorrectionHeader:u,STECSatElement:y,TroposphericDelayCorrectionNoStd:f,TroposphericDelayCorrection:d,STECResidualNoStd:h,STECResidual:_,1501:S,MsgSsrOrbitClock:S,1505:g,MsgSsrCodeBiases:g,1510:w,MsgSsrPhaseBiases:w,1531:E,MsgSsrStecCorrectionDep:E,BoundsHeader:m,1533:b,MsgSsrStecCorrection:b,1532:I,MsgSsrGriddedCorrection:I,STECSatElementIntegrity:L,1534:T,MsgSsrGriddedCorrectionBounds:T,1526:v,MsgSsrTileDefinitionDepA:v,1527:U,MsgSsrTileDefinitionDepB:U,1528:O,MsgSsrTileDefinition:O,SatelliteAPC:M,1540:D,MsgSsrSatelliteApcDep:D,1541:A,MsgSsrSatelliteApc:A,1500:G,MsgSsrOrbitClockDepA:G,STECHeaderDepA:C,GriddedCorrectionHeaderDepA:j,GridDefinitionHeaderDepA:P,1515:R,MsgSsrStecCorrectionDepA:R,1520:N,MsgSsrGriddedCorrectionNoStdDepA:N,1530:x,MsgSsrGriddedCorrectionDepA:x,1525:F,MsgSsrGridDefinitionDepA:F,OrbitClockBound:k,1502:B,MsgSsrOrbitClockBounds:B,CodePhaseBiasesSatSig:q,1516:z,MsgSsrCodePhaseBiasesBounds:z,OrbitClockBoundDegradation:V,1503:H,MsgSsrOrbitClockBoundsDegradation:H}},2644:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_STARTUP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_STARTUP",i.prototype.msg_type=65280,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("cause").uint8("startup_type").uint16("reserved"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["cause","writeUInt8",1]),i.prototype.fieldSpec.push(["startup_type","writeUInt8",1]),i.prototype.fieldSpec.push(["reserved","writeUInt16LE",2]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_DGNSS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_DGNSS_STATUS",s.prototype.msg_type=65282,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("flags").uint16("latency").uint8("num_signals").string("source",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["latency","writeUInt16LE",2]),s.prototype.fieldSpec.push(["num_signals","writeUInt8",1]),s.prototype.fieldSpec.push(["source","string",null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_HEARTBEAT",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_HEARTBEAT",n.prototype.msg_type=65535,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let a=function(e,t){return r.call(this,e),this.messageType="SubSystemReport",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="SubSystemReport",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint16("component").uint8("generic").uint8("specific"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["component","writeUInt16LE",2]),a.prototype.fieldSpec.push(["generic","writeUInt8",1]),a.prototype.fieldSpec.push(["specific","writeUInt8",1]);let l=function(e,t){return r.call(this,e),this.messageType="MSG_STATUS_REPORT",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_STATUS_REPORT",l.prototype.msg_type=65534,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("sequence").uint32("uptime").array("status",{type:a.prototype.parser,readUntil:"eof"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),l.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),l.prototype.fieldSpec.push(["status","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);let c=function(e,t){return r.call(this,e),this.messageType="StatusJournalItem",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="StatusJournalItem",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("uptime").nest("report",{type:a.prototype.parser}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["report",a.prototype.fieldSpec]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_STATUS_JOURNAL",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_STATUS_JOURNAL",u.prototype.msg_type=65533,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("total_status_reports").uint8("sequence_descriptor").array("journal",{type:c.prototype.parser,readUntil:"eof"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),u.prototype.fieldSpec.push(["total_status_reports","writeUInt32LE",4]),u.prototype.fieldSpec.push(["sequence_descriptor","writeUInt8",1]),u.prototype.fieldSpec.push(["journal","array",c.prototype.fieldSpec,function(){return this.fields.array.length},null]);let y=function(e,t){return r.call(this,e),this.messageType="MSG_INS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_INS_STATUS",y.prototype.msg_type=65283,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY",f.prototype.msg_type=65284,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["id","writeUInt8",1]),f.prototype.fieldSpec.push(["telemetry","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY_LABELS",d.prototype.msg_type=65285,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry_labels",{greedy:!0}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["id","writeUInt8",1]),d.prototype.fieldSpec.push(["telemetry_labels","string",null]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_INS_UPDATES",h.prototype.msg_type=65286,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("tow").uint8("gnsspos").uint8("gnssvel").uint8("wheelticks").uint8("speed").uint8("nhc").uint8("zerovel"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),h.prototype.fieldSpec.push(["gnsspos","writeUInt8",1]),h.prototype.fieldSpec.push(["gnssvel","writeUInt8",1]),h.prototype.fieldSpec.push(["wheelticks","writeUInt8",1]),h.prototype.fieldSpec.push(["speed","writeUInt8",1]),h.prototype.fieldSpec.push(["nhc","writeUInt8",1]),h.prototype.fieldSpec.push(["zerovel","writeUInt8",1]);let _=function(e,t){return r.call(this,e),this.messageType="MSG_GNSS_TIME_OFFSET",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="MSG_GNSS_TIME_OFFSET",_.prototype.msg_type=65287,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("weeks").int32("milliseconds").int16("microseconds").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["weeks","writeInt16LE",2]),_.prototype.fieldSpec.push(["milliseconds","writeInt32LE",4]),_.prototype.fieldSpec.push(["microseconds","writeInt16LE",2]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_PPS_TIME",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_PPS_TIME",S.prototype.msg_type=65288,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time","writeUInt64LE",8]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);let g=function(e,t){return r.call(this,e),this.messageType="MSG_SENSOR_AID_EVENT",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="MSG_SENSOR_AID_EVENT",g.prototype.msg_type=65289,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("time").uint8("sensor_type").uint16("sensor_id").uint8("sensor_state").uint8("n_available_meas").uint8("n_attempted_meas").uint8("n_accepted_meas").uint32("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time","writeUInt32LE",4]),g.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),g.prototype.fieldSpec.push(["sensor_id","writeUInt16LE",2]),g.prototype.fieldSpec.push(["sensor_state","writeUInt8",1]),g.prototype.fieldSpec.push(["n_available_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_attempted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_accepted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_META",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_META",w.prototype.msg_type=65290,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("group_id").uint8("flags").uint8("n_group_msgs").array("group_msgs",{type:"uint16le",length:"n_group_msgs"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["group_id","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]),w.prototype.fieldSpec.push(["n_group_msgs","writeUInt8",1]),w.prototype.fieldSpec.push(["group_msgs","array","writeUInt16LE",function(){return 2},"n_group_msgs"]),e.exports={65280:i,MsgStartup:i,65282:s,MsgDgnssStatus:s,65535:n,MsgHeartbeat:n,SubSystemReport:a,65534:l,MsgStatusReport:l,StatusJournalItem:c,65533:u,MsgStatusJournal:u,65283:y,MsgInsStatus:y,65284:f,MsgCsacTelemetry:f,65285:d,MsgCsacTelemetryLabels:d,65286:h,MsgInsUpdates:h,65287:_,MsgGnssTimeOffset:_,65288:S,MsgPpsTime:S,65289:g,MsgSensorAidEvent:g,65290:w,MsgGroupMeta:w}},3894:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase,p(278).GnssSignal),s=(p(278).GnssSignalDep,p(278).GPSTime,p(278).GPSTimeDep,p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="TelemetrySV",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.prototype)).messageType="TelemetrySV",s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("az").int8("el").uint8("availability_flags").int16("pseudorange_residual").int16("phase_residual").uint8("outlier_flags").uint8("ephemeris_flags").uint8("correction_flags").nest("sid",{type:i.prototype.parser}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["az","writeUInt8",1]),s.prototype.fieldSpec.push(["el","writeInt8",1]),s.prototype.fieldSpec.push(["availability_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["pseudorange_residual","writeInt16LE",2]),s.prototype.fieldSpec.push(["phase_residual","writeInt16LE",2]),s.prototype.fieldSpec.push(["outlier_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["ephemeris_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["correction_flags","writeUInt8",1]),s.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_TEL_SV",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_TEL_SV",n.prototype.msg_type=288,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").uint8("n_obs").uint8("origin_flags").array("sv_tel",{type:s.prototype.parser,readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["n_obs","writeUInt8",1]),n.prototype.fieldSpec.push(["origin_flags","writeUInt8",1]),n.prototype.fieldSpec.push(["sv_tel","array",s.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={TelemetrySV:s,288:n,MsgTelSv:n}},752:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,p(278).CarrierPhase),s=p(278).GnssSignal,n=p(278).GnssSignalDep,a=p(278).GPSTime,l=p(278).GPSTimeDep,c=(p(278).GPSTimeSec,p(278).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(c.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",c.prototype.msg_type=33,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:a.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:s.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),c.prototype.fieldSpec.push(["tot",a.prototype.fieldSpec]),c.prototype.fieldSpec.push(["P","writeUInt32LE",4]),c.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),c.prototype.fieldSpec.push(["cn0","writeUInt8",1]),c.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),c.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),c.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),c.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),c.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),c.prototype.fieldSpec.push(["acceleration","writeInt8",1]),c.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);let u=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP",u.prototype.msg_type=17,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:l.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),u.prototype.fieldSpec.push(["tot",l.prototype.fieldSpec]),u.prototype.fieldSpec.push(["P","writeUInt32LE",4]),u.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["cn0","writeUInt8",1]),u.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),u.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),u.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),u.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),u.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),u.prototype.fieldSpec.push(["acceleration","writeInt8",1]),u.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);let y=function(e,t){return r.call(this,e),this.messageType="TrackingChannelState",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="TrackingChannelState",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("fcn").uint8("cn0"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["fcn","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE",f.prototype.msg_type=65,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("states",{type:y.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["states","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let d=function(e,t){return r.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MeasurementState",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("mesid",{type:s.prototype.parser}).uint8("cn0"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["mesid",s.prototype.fieldSpec]),d.prototype.fieldSpec.push(["cn0","writeUInt8",1]);let h=function(e,t){return r.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_MEASUREMENT_STATE",h.prototype.msg_type=97,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("states",{type:d.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["states","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]);let _=function(e,t){return r.call(this,e),this.messageType="TrackingChannelCorrelation",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.prototype)).messageType="TrackingChannelCorrelation",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("I").int16("Q"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["I","writeInt16LE",2]),_.prototype.fieldSpec.push(["Q","writeInt16LE",2]);let S=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_IQ",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_IQ",S.prototype.msg_type=45,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:_.prototype.parser}),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["channel","writeUInt8",1]),S.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["corrs","array",_.prototype.fieldSpec,function(){return this.fields.array.length},3]);let g=function(e,t){return r.call(this,e),this.messageType="TrackingChannelCorrelationDep",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.prototype)).messageType="TrackingChannelCorrelationDep",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").int32("I").int32("Q"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["I","writeInt32LE",4]),g.prototype.fieldSpec.push(["Q","writeInt32LE",4]);let w=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_IQ_DEP_B",w.prototype.msg_type=44,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["channel","writeUInt8",1]),w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);let E=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_IQ_DEP_A",E.prototype.msg_type=28,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:n.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["channel","writeUInt8",1]),E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);let m=function(e,t){return r.call(this,e),this.messageType="TrackingChannelStateDepA",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="TrackingChannelStateDepA",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint8("state").uint8("prn").floatle("cn0"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["state","writeUInt8",1]),m.prototype.fieldSpec.push(["prn","writeUInt8",1]),m.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);let b=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DEP_A",b.prototype.msg_type=22,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").array("states",{type:m.prototype.parser,readUntil:"eof"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["states","array",m.prototype.fieldSpec,function(){return this.fields.array.length},null]);let I=function(e,t){return r.call(this,e),this.messageType="TrackingChannelStateDepB",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="TrackingChannelStateDepB",I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint8("state").nest("sid",{type:n.prototype.parser}).floatle("cn0"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["state","writeUInt8",1]),I.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),I.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);let L=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DEP_B",L.prototype.msg_type=19,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").array("states",{type:I.prototype.parser,readUntil:"eof"}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["states","array",I.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={33:c,MsgTrackingStateDetailedDepA:c,17:u,MsgTrackingStateDetailedDep:u,TrackingChannelState:y,65:f,MsgTrackingState:f,MeasurementState:d,97:h,MsgMeasurementState:h,TrackingChannelCorrelation:_,45:S,MsgTrackingIq:S,TrackingChannelCorrelationDep:g,44:w,MsgTrackingIqDepB:w,28:E,MsgTrackingIqDepA:E,TrackingChannelStateDepA:m,22:b,MsgTrackingStateDepA:b,TrackingChannelStateDepB:I,19:L,MsgTrackingStateDepB:L}},5562:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_USER_DATA",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_USER_DATA",i.prototype.msg_type=2048,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").array("contents",{type:"uint8",readUntil:"eof"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]),e.exports={2048:i,MsgUserData:i}},7293:(e,t,p)=>{let r=p(7238),o=p(7978),i=(p(6468),p(7898).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_ODOMETRY",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_ODOMETRY",i.prototype.msg_type=2307,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").int32("velocity").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["velocity","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_WHEELTICK",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_WHEELTICK",s.prototype.msg_type=2308,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags").uint8("source").int32("ticks"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["ticks","writeInt32LE",4]),e.exports={2307:i,MsgOdometry:i,2308:s,MsgWheeltick:s}},4148:(e,t,p)=>{"use strict";function r(e){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},r(e)}function o(e,t){for(var p=0;p1?p-1:0),o=1;o1?p-1:0),o=1;o1?p-1:0),o=1;o1?p-1:0),o=1;o{"use strict";function r(e,t){var p=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),p.push.apply(p,r)}return p}function o(e){for(var t=1;te.length)&&(p=e.length),e.substring(p-t.length,p)===t}var g="",w="",E="",m="",b={deepStrictEqual:"Expected values to be strictly deep-equal:",strictEqual:"Expected values to be strictly equal:",strictEqualObject:'Expected "actual" to be reference-equal to "expected":',deepEqual:"Expected values to be loosely deep-equal:",equal:"Expected values to be loosely equal:",notDeepStrictEqual:'Expected "actual" not to be strictly deep-equal to:',notStrictEqual:'Expected "actual" to be strictly unequal to:',notStrictEqualObject:'Expected "actual" not to be reference-equal to "expected":',notDeepEqual:'Expected "actual" not to be loosely deep-equal to:',notEqual:'Expected "actual" to be loosely unequal to:',notIdentical:"Values identical but not reference-equal:"};function I(e){var t=Object.keys(e),p=Object.create(Object.getPrototypeOf(e));return t.forEach((function(t){p[t]=e[t]})),Object.defineProperty(p,"message",{value:e.message}),p}function L(e){return h(e,{compact:!1,customInspect:!1,depth:1e3,maxArrayLength:1/0,showHidden:!1,breakLength:1/0,showProxy:!1,sorted:!0,getters:!0})}var T=function(e,t){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),Object.defineProperty(e,"prototype",{writable:!1}),t&&y(e,t)}(T,e);var p,r,s,l,c=(p=T,r=u(),function(){var e,t=f(p);if(r){var o=f(this).constructor;e=Reflect.construct(t,arguments,o)}else e=t.apply(this,arguments);return n(this,e)});function T(e){var t;if(function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,T),"object"!==d(e)||null===e)throw new _("options","Object",e);var p=e.message,r=e.operator,o=e.stackStartFn,i=e.actual,s=e.expected,l=Error.stackTraceLimit;if(Error.stackTraceLimit=0,null!=p)t=c.call(this,String(p));else if(process.stderr&&process.stderr.isTTY&&(process.stderr&&process.stderr.getColorDepth&&1!==process.stderr.getColorDepth()?(g="",w="",m="",E=""):(g="",w="",m="",E="")),"object"===d(i)&&null!==i&&"object"===d(s)&&null!==s&&"stack"in i&&i instanceof Error&&"stack"in s&&s instanceof Error&&(i=I(i),s=I(s)),"deepStrictEqual"===r||"strictEqual"===r)t=c.call(this,function(e,t,p){var r="",o="",i=0,s="",n=!1,a=L(e),l=a.split("\n"),c=L(t).split("\n"),u=0,y="";if("strictEqual"===p&&"object"===d(e)&&"object"===d(t)&&null!==e&&null!==t&&(p="strictEqualObject"),1===l.length&&1===c.length&&l[0]!==c[0]){var f=l[0].length+c[0].length;if(f<=10){if(!("object"===d(e)&&null!==e||"object"===d(t)&&null!==t||0===e&&0===t))return"".concat(b[p],"\n\n")+"".concat(l[0]," !== ").concat(c[0],"\n")}else if("strictEqualObject"!==p&&f<(process.stderr&&process.stderr.isTTY?process.stderr.columns:80)){for(;l[0][u]===c[0][u];)u++;u>2&&(y="\n ".concat(function(e,t){if(t=Math.floor(t),0==e.length||0==t)return"";var p=e.length*t;for(t=Math.floor(Math.log(t)/Math.log(2));t;)e+=e,t--;return e+e.substring(0,p-e.length)}(" ",u),"^"),u=0)}}for(var h=l[l.length-1],_=c[c.length-1];h===_&&(u++<2?s="\n ".concat(h).concat(s):r=h,l.pop(),c.pop(),0!==l.length&&0!==c.length);)h=l[l.length-1],_=c[c.length-1];var I=Math.max(l.length,c.length);if(0===I){var T=a.split("\n");if(T.length>30)for(T[26]="".concat(g,"...").concat(m);T.length>27;)T.pop();return"".concat(b.notIdentical,"\n\n").concat(T.join("\n"),"\n")}u>3&&(s="\n".concat(g,"...").concat(m).concat(s),n=!0),""!==r&&(s="\n ".concat(r).concat(s),r="");var v=0,U=b[p]+"\n".concat(w,"+ actual").concat(m," ").concat(E,"- expected").concat(m),O=" ".concat(g,"...").concat(m," Lines skipped");for(u=0;u1&&u>2&&(M>4?(o+="\n".concat(g,"...").concat(m),n=!0):M>3&&(o+="\n ".concat(c[u-2]),v++),o+="\n ".concat(c[u-1]),v++),i=u,r+="\n".concat(E,"-").concat(m," ").concat(c[u]),v++;else if(c.length1&&u>2&&(M>4?(o+="\n".concat(g,"...").concat(m),n=!0):M>3&&(o+="\n ".concat(l[u-2]),v++),o+="\n ".concat(l[u-1]),v++),i=u,o+="\n".concat(w,"+").concat(m," ").concat(l[u]),v++;else{var D=c[u],A=l[u],G=A!==D&&(!S(A,",")||A.slice(0,-1)!==D);G&&S(D,",")&&D.slice(0,-1)===A&&(G=!1,A+=","),G?(M>1&&u>2&&(M>4?(o+="\n".concat(g,"...").concat(m),n=!0):M>3&&(o+="\n ".concat(l[u-2]),v++),o+="\n ".concat(l[u-1]),v++),i=u,o+="\n".concat(w,"+").concat(m," ").concat(A),r+="\n".concat(E,"-").concat(m," ").concat(D),v+=2):(o+=r,r="",1!==M&&0!==u||(o+="\n ".concat(A),v++))}if(v>20&&u30)for(y[26]="".concat(g,"...").concat(m);y.length>27;)y.pop();t=1===y.length?c.call(this,"".concat(u," ").concat(y[0])):c.call(this,"".concat(u,"\n\n").concat(y.join("\n"),"\n"))}else{var f=L(i),h="",v=b[r];"notDeepEqual"===r||"notEqual"===r?(f="".concat(b[r],"\n\n").concat(f)).length>1024&&(f="".concat(f.slice(0,1021),"...")):(h="".concat(L(s)),f.length>512&&(f="".concat(f.slice(0,509),"...")),h.length>512&&(h="".concat(h.slice(0,509),"...")),"deepEqual"===r||"equal"===r?f="".concat(v,"\n\n").concat(f,"\n\nshould equal\n\n"):h=" ".concat(r," ").concat(h)),t=c.call(this,"".concat(f).concat(h))}return Error.stackTraceLimit=l,t.generatedMessage=!p,Object.defineProperty(a(t),"name",{value:"AssertionError [ERR_ASSERTION]",enumerable:!1,writable:!0,configurable:!0}),t.code="ERR_ASSERTION",t.actual=i,t.expected=s,t.operator=r,Error.captureStackTrace&&Error.captureStackTrace(a(t),o),t.stack,t.name="AssertionError",n(t)}return s=T,(l=[{key:"toString",value:function(){return"".concat(this.name," [").concat(this.code,"]: ").concat(this.message)}},{key:t,value:function(e,t){return h(this,o(o({},t),{},{customInspect:!1,depth:0}))}}])&&i(s.prototype,l),Object.defineProperty(s,"prototype",{writable:!1}),T}(l(Error),h.custom);e.exports=T},9597:(e,t,p)=>{"use strict";function r(e){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},r(e)}function o(e,t){return o=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(e,t){return e.__proto__=t,e},o(e,t)}function i(e){return i=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(e){return e.__proto__||Object.getPrototypeOf(e)},i(e)}var s,n,a={};function l(e,t,p){p||(p=Error);var s=function(p){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),Object.defineProperty(e,"prototype",{writable:!1}),t&&o(e,t)}(c,p);var s,n,a,l=(n=c,a=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}(),function(){var e,t=i(n);if(a){var p=i(this).constructor;e=Reflect.construct(t,arguments,p)}else e=t.apply(this,arguments);return function(e,t){if(t&&("object"===r(t)||"function"==typeof t))return t;if(void 0!==t)throw new TypeError("Derived constructors may only return object or undefined");return function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e)}(this,e)});function c(p,r,o){var i;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,c),i=l.call(this,function(e,p,r){return"string"==typeof t?t:t(e,p,r)}(p,r,o)),i.code=e,i}return s=c,Object.defineProperty(s,"prototype",{writable:!1}),s}(p);a[e]=s}function c(e,t){if(Array.isArray(e)){var p=e.length;return e=e.map((function(e){return String(e)})),p>2?"one of ".concat(t," ").concat(e.slice(0,p-1).join(", "),", or ")+e[p-1]:2===p?"one of ".concat(t," ").concat(e[0]," or ").concat(e[1]):"of ".concat(t," ").concat(e[0])}return"of ".concat(t," ").concat(String(e))}l("ERR_AMBIGUOUS_ARGUMENT",'The "%s" argument is ambiguous. %s',TypeError),l("ERR_INVALID_ARG_TYPE",(function(e,t,o){var i,n,a,l,u;if(void 0===s&&(s=p(4148)),s("string"==typeof e,"'name' must be a string"),"string"==typeof t&&(n="not ",t.substr(0,4)===n)?(i="must not be",t=t.replace(/^not /,"")):i="must be",function(e,t,p){return(void 0===p||p>e.length)&&(p=e.length),e.substring(p-9,p)===t}(e," argument"))a="The ".concat(e," ").concat(i," ").concat(c(t,"type"));else{var y=("number"!=typeof u&&(u=0),u+1>(l=e).length||-1===l.indexOf(".",u)?"argument":"property");a='The "'.concat(e,'" ').concat(y," ").concat(i," ").concat(c(t,"type"))}return a+". Received type ".concat(r(o))}),TypeError),l("ERR_INVALID_ARG_VALUE",(function(e,t){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"is invalid";void 0===n&&(n=p(4591));var o=n.inspect(t);return o.length>128&&(o="".concat(o.slice(0,128),"...")),"The argument '".concat(e,"' ").concat(r,". Received ").concat(o)}),TypeError,RangeError),l("ERR_INVALID_RETURN_VALUE",(function(e,t,p){var o;return o=p&&p.constructor&&p.constructor.name?"instance of ".concat(p.constructor.name):"type ".concat(r(p)),"Expected ".concat(e,' to be returned from the "').concat(t,'"')+" function but got ".concat(o,".")}),TypeError),l("ERR_MISSING_ARGS",(function(){for(var e=arguments.length,t=new Array(e),r=0;r0,"At least one arg needs to be specified");var o="The ",i=t.length;switch(t=t.map((function(e){return'"'.concat(e,'"')})),i){case 1:o+="".concat(t[0]," argument");break;case 2:o+="".concat(t[0]," and ").concat(t[1]," arguments");break;default:o+=t.slice(0,i-1).join(", "),o+=", and ".concat(t[i-1]," arguments")}return"".concat(o," must be specified")}),TypeError),e.exports.codes=a},2299:(e,t,p)=>{"use strict";function r(e,t){return function(e){if(Array.isArray(e))return e}(e)||function(e,t){var p=null==e?null:"undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(null!=p){var r,o,i,s,n=[],a=!0,l=!1;try{if(i=(p=p.call(e)).next,0===t){if(Object(p)!==p)return;a=!1}else for(;!(a=(r=i.call(p)).done)&&(n.push(r.value),n.length!==t);a=!0);}catch(e){l=!0,o=e}finally{try{if(!a&&null!=p.return&&(s=p.return(),Object(s)!==s))return}finally{if(l)throw o}}return n}}(e,t)||function(e,t){if(e){if("string"==typeof e)return o(e,t);var p=Object.prototype.toString.call(e).slice(8,-1);return"Object"===p&&e.constructor&&(p=e.constructor.name),"Map"===p||"Set"===p?Array.from(e):"Arguments"===p||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(p)?o(e,t):void 0}}(e,t)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var p=0,r=new Array(t);p10)return!0;for(var t=0;t57)return!0}return 10===e.length&&e>=Math.pow(2,32)}function C(e){return Object.keys(e).filter(G).concat(c(e).filter(Object.prototype.propertyIsEnumerable.bind(e)))}function j(e,t){if(e===t)return 0;for(var p=e.length,r=t.length,o=0,i=Math.min(p,r);o{e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},2078:(e,t,p)=>{"use strict";var r=p(7244),o=p(8184),i=p(5767),s=p(5680);function n(e){return e.call.bind(e)}var a="undefined"!=typeof BigInt,l="undefined"!=typeof Symbol,c=n(Object.prototype.toString),u=n(Number.prototype.valueOf),y=n(String.prototype.valueOf),f=n(Boolean.prototype.valueOf);if(a)var d=n(BigInt.prototype.valueOf);if(l)var h=n(Symbol.prototype.valueOf);function _(e,t){if("object"!=typeof e)return!1;try{return t(e),!0}catch(e){return!1}}function S(e){return"[object Map]"===c(e)}function g(e){return"[object Set]"===c(e)}function w(e){return"[object WeakMap]"===c(e)}function E(e){return"[object WeakSet]"===c(e)}function m(e){return"[object ArrayBuffer]"===c(e)}function b(e){return"undefined"!=typeof ArrayBuffer&&(m.working?m(e):e instanceof ArrayBuffer)}function I(e){return"[object DataView]"===c(e)}function L(e){return"undefined"!=typeof DataView&&(I.working?I(e):e instanceof DataView)}t.isArgumentsObject=r,t.isGeneratorFunction=o,t.isTypedArray=s,t.isPromise=function(e){return"undefined"!=typeof Promise&&e instanceof Promise||null!==e&&"object"==typeof e&&"function"==typeof e.then&&"function"==typeof e.catch},t.isArrayBufferView=function(e){return"undefined"!=typeof ArrayBuffer&&ArrayBuffer.isView?ArrayBuffer.isView(e):s(e)||L(e)},t.isUint8Array=function(e){return"Uint8Array"===i(e)},t.isUint8ClampedArray=function(e){return"Uint8ClampedArray"===i(e)},t.isUint16Array=function(e){return"Uint16Array"===i(e)},t.isUint32Array=function(e){return"Uint32Array"===i(e)},t.isInt8Array=function(e){return"Int8Array"===i(e)},t.isInt16Array=function(e){return"Int16Array"===i(e)},t.isInt32Array=function(e){return"Int32Array"===i(e)},t.isFloat32Array=function(e){return"Float32Array"===i(e)},t.isFloat64Array=function(e){return"Float64Array"===i(e)},t.isBigInt64Array=function(e){return"BigInt64Array"===i(e)},t.isBigUint64Array=function(e){return"BigUint64Array"===i(e)},S.working="undefined"!=typeof Map&&S(new Map),t.isMap=function(e){return"undefined"!=typeof Map&&(S.working?S(e):e instanceof Map)},g.working="undefined"!=typeof Set&&g(new Set),t.isSet=function(e){return"undefined"!=typeof Set&&(g.working?g(e):e instanceof Set)},w.working="undefined"!=typeof WeakMap&&w(new WeakMap),t.isWeakMap=function(e){return"undefined"!=typeof WeakMap&&(w.working?w(e):e instanceof WeakMap)},E.working="undefined"!=typeof WeakSet&&E(new WeakSet),t.isWeakSet=function(e){return E(e)},m.working="undefined"!=typeof ArrayBuffer&&m(new ArrayBuffer),t.isArrayBuffer=b,I.working="undefined"!=typeof ArrayBuffer&&"undefined"!=typeof DataView&&I(new DataView(new ArrayBuffer(1),0,1)),t.isDataView=L;var T="undefined"!=typeof SharedArrayBuffer?SharedArrayBuffer:void 0;function v(e){return"[object SharedArrayBuffer]"===c(e)}function U(e){return void 0!==T&&(void 0===v.working&&(v.working=v(new T)),v.working?v(e):e instanceof T)}function O(e){return _(e,u)}function M(e){return _(e,y)}function D(e){return _(e,f)}function A(e){return a&&_(e,d)}function G(e){return l&&_(e,h)}t.isSharedArrayBuffer=U,t.isAsyncFunction=function(e){return"[object AsyncFunction]"===c(e)},t.isMapIterator=function(e){return"[object Map Iterator]"===c(e)},t.isSetIterator=function(e){return"[object Set Iterator]"===c(e)},t.isGeneratorObject=function(e){return"[object Generator]"===c(e)},t.isWebAssemblyCompiledModule=function(e){return"[object WebAssembly.Module]"===c(e)},t.isNumberObject=O,t.isStringObject=M,t.isBooleanObject=D,t.isBigIntObject=A,t.isSymbolObject=G,t.isBoxedPrimitive=function(e){return O(e)||M(e)||D(e)||A(e)||G(e)},t.isAnyArrayBuffer=function(e){return"undefined"!=typeof Uint8Array&&(b(e)||U(e))},["isProxy","isExternal","isModuleNamespaceObject"].forEach((function(e){Object.defineProperty(t,e,{enumerable:!1,value:function(){throw new Error(e+" is not supported in userland")}})}))},4591:(e,t,p)=>{var r=Object.getOwnPropertyDescriptors||function(e){for(var t=Object.keys(e),p={},r=0;r=i)return e;switch(e){case"%s":return String(r[p++]);case"%d":return Number(r[p++]);case"%j":try{return JSON.stringify(r[p++])}catch(e){return"[Circular]"}default:return e}})),n=r[p];p=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),h(p)?r.showHidden=p:p&&t._extend(r,p),w(r.showHidden)&&(r.showHidden=!1),w(r.depth)&&(r.depth=2),w(r.colors)&&(r.colors=!1),w(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=l),u(r,e,r.depth)}function l(e,t){var p=a.styles[t];return p?"["+a.colors[p][0]+"m"+e+"["+a.colors[p][1]+"m":e}function c(e,t){return e}function u(e,p,r){if(e.customInspect&&p&&L(p.inspect)&&p.inspect!==t.inspect&&(!p.constructor||p.constructor.prototype!==p)){var o=p.inspect(r,e);return g(o)||(o=u(e,o,r)),o}var i=function(e,t){if(w(t))return e.stylize("undefined","undefined");if(g(t)){var p="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(p,"string")}return S(t)?e.stylize(""+t,"number"):h(t)?e.stylize(""+t,"boolean"):_(t)?e.stylize("null","null"):void 0}(e,p);if(i)return i;var s=Object.keys(p),n=function(e){var t={};return e.forEach((function(e,p){t[e]=!0})),t}(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(p)),I(p)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return y(p);if(0===s.length){if(L(p)){var a=p.name?": "+p.name:"";return e.stylize("[Function"+a+"]","special")}if(E(p))return e.stylize(RegExp.prototype.toString.call(p),"regexp");if(b(p))return e.stylize(Date.prototype.toString.call(p),"date");if(I(p))return y(p)}var l,c="",m=!1,T=["{","}"];return d(p)&&(m=!0,T=["[","]"]),L(p)&&(c=" [Function"+(p.name?": "+p.name:"")+"]"),E(p)&&(c=" "+RegExp.prototype.toString.call(p)),b(p)&&(c=" "+Date.prototype.toUTCString.call(p)),I(p)&&(c=" "+y(p)),0!==s.length||m&&0!=p.length?r<0?E(p)?e.stylize(RegExp.prototype.toString.call(p),"regexp"):e.stylize("[Object]","special"):(e.seen.push(p),l=m?function(e,t,p,r,o){for(var i=[],s=0,n=t.length;s60?p[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+p[1]:p[0]+t+" "+e.join(", ")+" "+p[1]}(l,c,T)):T[0]+c+T[1]}function y(e){return"["+Error.prototype.toString.call(e)+"]"}function f(e,t,p,r,o,i){var s,n,a;if((a=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?n=a.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):a.set&&(n=e.stylize("[Setter]","special")),O(r,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=_(p)?u(e,a.value,null):u(e,a.value,p-1)).indexOf("\n")>-1&&(n=i?n.split("\n").map((function(e){return" "+e})).join("\n").slice(2):"\n"+n.split("\n").map((function(e){return" "+e})).join("\n")):n=e.stylize("[Circular]","special")),w(s)){if(i&&o.match(/^\d+$/))return n;(s=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.slice(1,-1),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+n}function d(e){return Array.isArray(e)}function h(e){return"boolean"==typeof e}function _(e){return null===e}function S(e){return"number"==typeof e}function g(e){return"string"==typeof e}function w(e){return void 0===e}function E(e){return m(e)&&"[object RegExp]"===T(e)}function m(e){return"object"==typeof e&&null!==e}function b(e){return m(e)&&"[object Date]"===T(e)}function I(e){return m(e)&&("[object Error]"===T(e)||e instanceof Error)}function L(e){return"function"==typeof e}function T(e){return Object.prototype.toString.call(e)}function v(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(e=e.toUpperCase(),!i[e])if(s.test(e)){var p=process.pid;i[e]=function(){var r=t.format.apply(t,arguments);console.error("%s %d: %s",e,p,r)}}else i[e]=function(){};return i[e]},t.inspect=a,a.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},a.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.types=p(2078),t.isArray=d,t.isBoolean=h,t.isNull=_,t.isNullOrUndefined=function(e){return null==e},t.isNumber=S,t.isString=g,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=w,t.isRegExp=E,t.types.isRegExp=E,t.isObject=m,t.isDate=b,t.types.isDate=b,t.isError=I,t.types.isNativeError=I,t.isFunction=L,t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=p(3845);var U=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function O(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){var e,p;console.log("%s - %s",(p=[v((e=new Date).getHours()),v(e.getMinutes()),v(e.getSeconds())].join(":"),[e.getDate(),U[e.getMonth()],p].join(" ")),t.format.apply(t,arguments))},t.inherits=p(6698),t._extend=function(e,t){if(!t||!m(t))return e;for(var p=Object.keys(t),r=p.length;r--;)e[p[r]]=t[p[r]];return e};var M="undefined"!=typeof Symbol?Symbol("util.promisify.custom"):void 0;function D(e,t){if(!e){var p=new Error("Promise was rejected with a falsy value");p.reason=e,e=p}return t(e)}t.promisify=function(e){if("function"!=typeof e)throw new TypeError('The "original" argument must be of type Function');if(M&&e[M]){var t;if("function"!=typeof(t=e[M]))throw new TypeError('The "util.promisify.custom" argument must be of type Function');return Object.defineProperty(t,M,{value:t,enumerable:!1,writable:!1,configurable:!0}),t}function t(){for(var t,p,r=new Promise((function(e,r){t=e,p=r})),o=[],i=0;i{"use strict";t.i=void 0,p(9160);var r=p(5682),o={},i="___parser_",s={uint8:1,uint16le:2,uint16be:2,uint32le:4,uint32be:4,int8:1,int16le:2,int16be:2,int32le:4,int32be:4,int64be:8,int64le:8,uint64be:8,uint64le:8,floatle:4,floatbe:4,doublele:8,doublebe:8},n={uint8:"Uint8",uint16le:"Uint16",uint16be:"Uint16",uint32le:"Uint32",uint32be:"Uint32",int8:"Int8",int16le:"Int16",int16be:"Int16",int32le:"Int32",int32be:"Int32",int64be:"BigInt64",int64le:"BigInt64",uint64be:"BigUint64",uint64le:"BigUint64",floatle:"Float32",floatbe:"Float32",doublele:"Float64",doublebe:"Float64"},a={uint8:!1,uint16le:!0,uint16be:!1,uint32le:!0,uint32be:!1,int8:!1,int16le:!0,int16be:!1,int32le:!0,int32be:!1,int64be:!1,int64le:!0,uint64be:!1,uint64le:!0,floatle:!0,floatbe:!1,doublele:!0,doublebe:!1},l=function(){function e(){this.varName="",this.type="",this.options={},this.next=null,this.head=null,this.compiled=null,this.endian="be",this.constructorFn=null,this.alias=null}return e.start=function(){return new e},e.prototype.primitiveGenerateN=function(e,t){var p=n[e],r=a[e];t.pushCode(t.generateVariable(this.varName)+" = dataView.get"+p+"(offset, "+r+");"),t.pushCode("offset += "+s[e]+";")},e.prototype.primitiveN=function(e,t,p){return this.setNextParser(e,t,p)},e.prototype.useThisEndian=function(e){return e+this.endian.toLowerCase()},e.prototype.uint8=function(e,t){return this.primitiveN("uint8",e,t)},e.prototype.uint16=function(e,t){return this.primitiveN(this.useThisEndian("uint16"),e,t)},e.prototype.uint16le=function(e,t){return this.primitiveN("uint16le",e,t)},e.prototype.uint16be=function(e,t){return this.primitiveN("uint16be",e,t)},e.prototype.uint32=function(e,t){return this.primitiveN(this.useThisEndian("uint32"),e,t)},e.prototype.uint32le=function(e,t){return this.primitiveN("uint32le",e,t)},e.prototype.uint32be=function(e,t){return this.primitiveN("uint32be",e,t)},e.prototype.int8=function(e,t){return this.primitiveN("int8",e,t)},e.prototype.int16=function(e,t){return this.primitiveN(this.useThisEndian("int16"),e,t)},e.prototype.int16le=function(e,t){return this.primitiveN("int16le",e,t)},e.prototype.int16be=function(e,t){return this.primitiveN("int16be",e,t)},e.prototype.int32=function(e,t){return this.primitiveN(this.useThisEndian("int32"),e,t)},e.prototype.int32le=function(e,t){return this.primitiveN("int32le",e,t)},e.prototype.int32be=function(e,t){return this.primitiveN("int32be",e,t)},e.prototype.bigIntVersionCheck=function(){if(!DataView.prototype.getBigInt64)throw new Error("BigInt64 is unsupported in this runtime")},e.prototype.int64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("int64"),e,t)},e.prototype.int64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64be",e,t)},e.prototype.int64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64le",e,t)},e.prototype.uint64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("uint64"),e,t)},e.prototype.uint64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64be",e,t)},e.prototype.uint64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64le",e,t)},e.prototype.floatle=function(e,t){return this.primitiveN("floatle",e,t)},e.prototype.floatbe=function(e,t){return this.primitiveN("floatbe",e,t)},e.prototype.doublele=function(e,t){return this.primitiveN("doublele",e,t)},e.prototype.doublebe=function(e,t){return this.primitiveN("doublebe",e,t)},e.prototype.bitN=function(e,t,p){return p||(p={}),p.length=e,this.setNextParser("bit",t,p)},e.prototype.bit1=function(e,t){return this.bitN(1,e,t)},e.prototype.bit2=function(e,t){return this.bitN(2,e,t)},e.prototype.bit3=function(e,t){return this.bitN(3,e,t)},e.prototype.bit4=function(e,t){return this.bitN(4,e,t)},e.prototype.bit5=function(e,t){return this.bitN(5,e,t)},e.prototype.bit6=function(e,t){return this.bitN(6,e,t)},e.prototype.bit7=function(e,t){return this.bitN(7,e,t)},e.prototype.bit8=function(e,t){return this.bitN(8,e,t)},e.prototype.bit9=function(e,t){return this.bitN(9,e,t)},e.prototype.bit10=function(e,t){return this.bitN(10,e,t)},e.prototype.bit11=function(e,t){return this.bitN(11,e,t)},e.prototype.bit12=function(e,t){return this.bitN(12,e,t)},e.prototype.bit13=function(e,t){return this.bitN(13,e,t)},e.prototype.bit14=function(e,t){return this.bitN(14,e,t)},e.prototype.bit15=function(e,t){return this.bitN(15,e,t)},e.prototype.bit16=function(e,t){return this.bitN(16,e,t)},e.prototype.bit17=function(e,t){return this.bitN(17,e,t)},e.prototype.bit18=function(e,t){return this.bitN(18,e,t)},e.prototype.bit19=function(e,t){return this.bitN(19,e,t)},e.prototype.bit20=function(e,t){return this.bitN(20,e,t)},e.prototype.bit21=function(e,t){return this.bitN(21,e,t)},e.prototype.bit22=function(e,t){return this.bitN(22,e,t)},e.prototype.bit23=function(e,t){return this.bitN(23,e,t)},e.prototype.bit24=function(e,t){return this.bitN(24,e,t)},e.prototype.bit25=function(e,t){return this.bitN(25,e,t)},e.prototype.bit26=function(e,t){return this.bitN(26,e,t)},e.prototype.bit27=function(e,t){return this.bitN(27,e,t)},e.prototype.bit28=function(e,t){return this.bitN(28,e,t)},e.prototype.bit29=function(e,t){return this.bitN(29,e,t)},e.prototype.bit30=function(e,t){return this.bitN(30,e,t)},e.prototype.bit31=function(e,t){return this.bitN(31,e,t)},e.prototype.bit32=function(e,t){return this.bitN(32,e,t)},e.prototype.namely=function(e){return o[e]=this,this.alias=e,this},e.prototype.skip=function(e,t){return this.seek(e,t)},e.prototype.seek=function(e,t){if(t&&t.assert)throw new Error("assert option on seek is not allowed.");return this.setNextParser("seek","",{length:e})},e.prototype.string=function(e,t){if(!t.zeroTerminated&&!t.length&&!t.greedy)throw new Error("Neither length, zeroTerminated, nor greedy is defined for string.");if((t.zeroTerminated||t.length)&&t.greedy)throw new Error("greedy is mutually exclusive with length and zeroTerminated for string.");if(t.stripNull&&!t.length&&!t.greedy)throw new Error("Length or greedy must be defined if stripNull is defined.");return t.encoding=t.encoding||"utf8",this.setNextParser("string",e,t)},e.prototype.buffer=function(e,t){if(!t.length&&!t.readUntil)throw new Error("Length nor readUntil is defined in buffer parser");return this.setNextParser("buffer",e,t)},e.prototype.wrapped=function(e,t){if(!t.length&&!t.readUntil)throw new Error("Length nor readUntil is defined in buffer parser");if(!t.wrapper||!t.type)throw new Error("Both wrapper and type must be defined in wrapper parser");return this.setNextParser("wrapper",e,t)},e.prototype.array=function(e,t){if(!t.readUntil&&!t.length&&!t.lengthInBytes)throw new Error("Length option of array is not defined.");if(!t.type)throw new Error("Type option of array is not defined.");if("string"==typeof t.type&&!o[t.type]&&Object.keys(s).indexOf(t.type)<0)throw new Error('Specified primitive type "'+t.type+'" is not supported.');return this.setNextParser("array",e,t)},e.prototype.choice=function(e,t){if("object"!=typeof t&&"object"==typeof e&&(t=e,e=null),!t.tag)throw new Error("Tag option of array is not defined.");if(!t.choices)throw new Error("Choices option of array is not defined.");return Object.keys(t.choices).forEach((function(p){var r=parseInt(p,10),i=t.choices[r];if(isNaN(r))throw new Error("Key of choices must be a number.");if(!i)throw new Error("Choice Case "+p+" of "+e+" is not valid.");if("string"==typeof i&&!o[i]&&Object.keys(s).indexOf(i)<0)throw new Error('Specified primitive type "'+i+'" is not supported.')})),this.setNextParser("choice",e,t)},e.prototype.nest=function(t,p){if("object"!=typeof p&&"object"==typeof t&&(p=t,t=null),!p.type)throw new Error("Type option of nest is not defined.");if(!(p.type instanceof e||o[p.type]))throw new Error("Type option of nest must be a Parser object.");if(!(p.type instanceof e||t))throw new Error("options.type must be a object if variable name is omitted.");return this.setNextParser("nest",t,p)},e.prototype.pointer=function(t,p){if(!p.offset)throw new Error("Offset option of pointer is not defined.");if(!p.type)throw new Error("Type option of pointer is not defined.");if("string"==typeof p.type){if(Object.keys(s).indexOf(p.type)<0&&!o[p.type])throw new Error('Specified type "'+p.type+'" is not supported.')}else if(!(p.type instanceof e))throw new Error("Type option of pointer must be a string or a Parser object.");return this.setNextParser("pointer",t,p)},e.prototype.saveOffset=function(e,t){return this.setNextParser("saveOffset",e,t)},e.prototype.endianess=function(e){switch(e.toLowerCase()){case"little":this.endian="le";break;case"big":this.endian="be";break;default:throw new Error("Invalid endianess: "+e)}return this},e.prototype.create=function(e){if(!(e instanceof Function))throw new Error("Constructor must be a Function object.");return this.constructorFn=e,this},e.prototype.getContext=function(e){var t=new r.Context(e);return t.pushCode("var dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"),this.alias?(this.addAliasedCode(t),t.pushCode("return "+(i+this.alias)+"(0).result;")):this.addRawCode(t),t},e.prototype.getCode=function(){return this.getContext().code},e.prototype.addRawCode=function(e){e.pushCode("var offset = 0;"),e.pushCode("var vars = "+(this.constructorFn?"new constructorFn()":"{}")+";"),e.pushCode("vars.$parent = null;"),e.pushCode("vars.$root = vars;"),this.generate(e),this.resolveReferences(e),e.pushCode("delete vars.$parent;"),e.pushCode("delete vars.$root;"),e.pushCode("return vars;")},e.prototype.addAliasedCode=function(e){return e.pushCode("function "+(i+this.alias)+"(offset, context) {"),e.pushCode("var vars = "+(this.constructorFn?"new constructorFn()":"{}")+";"),e.pushCode("var ctx = Object.assign({$parent: null, $root: vars}, context || {});"),e.pushCode("vars = Object.assign(vars, ctx);"),this.generate(e),e.markResolved(this.alias),this.resolveReferences(e),e.pushCode("Object.keys(ctx).forEach(function (item) { delete vars[item]; });"),e.pushCode("return { offset: offset, result: vars };"),e.pushCode("}"),e},e.prototype.resolveReferences=function(e){var t=e.getUnresolvedReferences();e.markRequested(t),t.forEach((function(t){o[t].addAliasedCode(e)}))},e.prototype.compile=function(){var e="imports",t=this.getContext(e);this.compiled=new Function(e,"TextDecoder","return function (buffer, constructorFn) { "+t.code+" };")(t.imports,TextDecoder)},e.prototype.sizeOf=function(){var t=NaN;if(Object.keys(s).indexOf(this.type)>=0)t=s[this.type];else if("string"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("buffer"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("array"===this.type&&"number"==typeof this.options.length){var p=NaN;"string"==typeof this.options.type?p=s[this.options.type]:this.options.type instanceof e&&(p=this.options.type.sizeOf()),t=this.options.length*p}else"seek"===this.type?t=this.options.length:"nest"===this.type?t=this.options.type.sizeOf():this.type||(t=0);return this.next&&(t+=this.next.sizeOf()),t},e.prototype.parse=function(e){return this.compiled||this.compile(),this.compiled(e,this.constructorFn)},e.prototype.setNextParser=function(t,p,r){var o=new e;return o.type=t,o.varName=p,o.options=r||o.options,o.endian=this.endian,this.head?this.head.next=o:this.next=o,this.head=o,this},e.prototype.generate=function(e){if(this.type){switch(this.type){case"uint8":case"uint16le":case"uint16be":case"uint32le":case"uint32be":case"int8":case"int16le":case"int16be":case"int32le":case"int32be":case"int64be":case"int64le":case"uint64be":case"uint64le":case"floatle":case"floatbe":case"doublele":case"doublebe":this.primitiveGenerateN(this.type,e);break;case"bit":this.generateBit(e);break;case"string":this.generateString(e);break;case"buffer":this.generateBuffer(e);break;case"seek":this.generateSeek(e);break;case"nest":this.generateNest(e);break;case"array":this.generateArray(e);break;case"choice":this.generateChoice(e);break;case"pointer":this.generatePointer(e);break;case"saveOffset":this.generateSaveOffset(e);break;case"wrapper":this.generateWrapper(e)}this.generateAssert(e)}var t=e.generateVariable(this.varName);return this.options.formatter&&this.generateFormatter(e,t,this.options.formatter),this.generateNext(e)},e.prototype.generateAssert=function(e){if(this.options.assert){var t=e.generateVariable(this.varName);switch(typeof this.options.assert){case"function":var p=e.addImport(this.options.assert);e.pushCode("if (!"+p+".call(vars, "+t+")) {");break;case"number":e.pushCode("if ("+this.options.assert+" !== "+t+") {");break;case"string":e.pushCode('if ("'+this.options.assert+'" !== '+t+") {");break;default:throw new Error("Assert option supports only strings, numbers and assert functions.")}e.generateError('"Assert error: '+t+' is " + '+this.options.assert),e.pushCode("}")}},e.prototype.generateNext=function(e){return this.next&&(e=this.next.generate(e)),e},e.prototype.generateBit=function(e){var t=JSON.parse(JSON.stringify(this));if(t.varName=e.generateVariable(t.varName),e.bitFields.push(t),!this.next||this.next&&["bit","nest"].indexOf(this.next.type)<0){var p=0;e.bitFields.forEach((function(e){return p+=e.options.length}));var r=e.generateTmpVariable();if(p<=8)e.pushCode("var "+r+" = dataView.getUint8(offset);"),p=8;else if(p<=16)e.pushCode("var "+r+" = dataView.getUint16(offset);"),p=16;else if(p<=24){var o=e.generateTmpVariable(),i=e.generateTmpVariable();e.pushCode("var "+o+" = dataView.getUint16(offset);"),e.pushCode("var "+i+" = dataView.getUint8(offset + 2);"),e.pushCode("var "+r+" = ("+o+" << 8) | "+i+";"),p=24}else{if(!(p<=32))throw new Error("Currently, bit field sequence longer than 4-bytes is not supported.");e.pushCode("var "+r+" = dataView.getUint32(offset);"),p=32}e.pushCode("offset += "+p/8+";");var s=0,n="be"===this.endian;e.bitFields.forEach((function(t){var o=t.options.length,i=n?p-s-o:s,a=(1<> "+i+" & "+a+";"),s+=o})),e.bitFields=[]}},e.prototype.generateSeek=function(e){var t=e.generateOption(this.options.length);e.pushCode("offset += "+t+";")},e.prototype.generateString=function(e){var t=e.generateVariable(this.varName),p=e.generateTmpVariable(),r=this.options.encoding,o="hex"===r.toLowerCase(),i='b => b.toString(16).padStart(2, "0")';if(this.options.length&&this.options.zeroTerminated){var s=this.options.length;e.pushCode("var "+p+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0 && offset - "+p+" < "+s+");");var n="offset - "+p+" < "+s+" ? offset - 1 : offset";e.pushCode(o?t+" = Array.from(buffer.subarray("+p+", "+n+"), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray("+p+", "+n+"));")}else this.options.length?(s=e.generateOption(this.options.length),e.pushCode(o?t+" = Array.from(buffer.subarray(offset, offset + "+s+"), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray(offset, offset + "+s+"));"),e.pushCode("offset += "+s+";")):this.options.zeroTerminated?(e.pushCode("var "+p+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+p+", offset - 1), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray("+p+", offset - 1));")):this.options.greedy&&(e.pushCode("var "+p+" = offset;"),e.pushCode("while(buffer.length > offset++);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+p+", offset), "+i+").join('');":t+" = new TextDecoder('"+r+"').decode(buffer.subarray("+p+", offset));"));this.options.stripNull&&e.pushCode(t+" = "+t+".replace(/\\x00+$/g, '')")},e.prototype.generateBuffer=function(e){var t=e.generateVariable(this.varName);if("function"==typeof this.options.readUntil){var p=this.options.readUntil,r=e.generateTmpVariable(),o=e.generateTmpVariable();e.pushCode("var "+r+" = offset;"),e.pushCode("var "+o+" = 0;"),e.pushCode("while (offset < buffer.length) {"),e.pushCode(o+" = dataView.getUint8(offset);");var i=e.addImport(p);e.pushCode("if ("+i+".call("+e.generateVariable()+", "+o+", buffer.subarray(offset))) break;"),e.pushCode("offset += 1;"),e.pushCode("}"),e.pushCode(t+" = buffer.subarray("+r+", offset);")}else if("eof"===this.options.readUntil)e.pushCode(t+" = buffer.subarray(offset);");else{var s=e.generateOption(this.options.length);e.pushCode(t+" = buffer.subarray(offset, offset + "+s+");"),e.pushCode("offset += "+s+";")}this.options.clone&&e.pushCode(t+" = buffer.constructor.from("+t+");")},e.prototype.generateArray=function(t){var p=t.generateOption(this.options.length),r=t.generateOption(this.options.lengthInBytes),l=this.options.type,c=t.generateTmpVariable(),u=t.generateVariable(this.varName),y=t.generateTmpVariable(),f=this.options.key,d="string"==typeof f;if(d?t.pushCode(u+" = {};"):t.pushCode(u+" = [];"),"function"==typeof this.options.readUntil?t.pushCode("do {"):"eof"===this.options.readUntil?t.pushCode("for (var "+c+" = 0; offset < buffer.length; "+c+"++) {"):void 0!==r?t.pushCode("for (var "+c+" = offset + "+r+"; offset < "+c+"; ) {"):t.pushCode("for (var "+c+" = "+p+"; "+c+" > 0; "+c+"--) {"),"string"==typeof l)if(o[l]){var h=t.generateVariable(),_=t.generateTmpVariable();t.pushCode("var "+_+" = "+(i+l)+"(offset, {"),t.pushCode("$parent: "+h+","),t.pushCode("$root: "+h+".$root,"),this.options.readUntil||void 0!==r||t.pushCode("$index: "+p+" - "+c+","),t.pushCode("});"),t.pushCode("var "+y+" = "+_+".result; offset = "+_+".offset;"),l!==this.alias&&t.addReference(l)}else{var S=n[l],g=a[l];t.pushCode("var "+y+" = dataView.get"+S+"(offset, "+g+");"),t.pushCode("offset += "+s[l]+";")}else l instanceof e&&(h=t.generateVariable(),t.pushCode("var "+y+" = {};"),t.pushScope(y),t.pushCode(y+".$parent = "+h+";"),t.pushCode(y+".$root = "+h+".$root;"),this.options.readUntil||void 0!==r||t.pushCode(y+".$index = "+p+" - "+c+";"),l.generate(t),t.pushCode("delete "+y+".$parent;"),t.pushCode("delete "+y+".$root;"),t.pushCode("delete "+y+".$index;"),t.popScope());if(d?t.pushCode(u+"["+y+"."+f+"] = "+y+";"):t.pushCode(u+".push("+y+");"),t.pushCode("}"),"function"==typeof this.options.readUntil){var w=this.options.readUntil,E=t.addImport(w);t.pushCode("while (!"+E+".call("+t.generateVariable()+", "+y+", buffer.subarray(offset)));")}},e.prototype.generateChoiceCase=function(t,p,r){if("string"==typeof r){var l=t.generateVariable(this.varName);if(o[r]){var c=t.generateTmpVariable();t.pushCode("var "+c+" = "+(i+r)+"(offset, {"),t.pushCode("$parent: "+l+".$parent,"),t.pushCode("$root: "+l+".$root,"),t.pushCode("});"),t.pushCode(l+" = "+c+".result; offset = "+c+".offset;"),r!==this.alias&&t.addReference(r)}else{var u=n[r],y=a[r];t.pushCode(l+" = dataView.get"+u+"(offset, "+y+");"),t.pushCode("offset += "+s[r])}}else r instanceof e&&(t.pushPath(p),r.generate(t),t.popPath(p))},e.prototype.generateChoice=function(e){var t=this,p=e.generateOption(this.options.tag),r=e.generateVariable(this.varName);if(this.varName){e.pushCode(r+" = {};");var o=e.generateVariable();e.pushCode(r+".$parent = "+o+";"),e.pushCode(r+".$root = "+o+".$root;")}e.pushCode("switch("+p+") {"),Object.keys(this.options.choices).forEach((function(p){var r=t.options.choices[parseInt(p,10)];e.pushCode("case "+p+":"),t.generateChoiceCase(e,t.varName,r),e.pushCode("break;")})),e.pushCode("default:"),this.options.defaultChoice?this.generateChoiceCase(e,this.varName,this.options.defaultChoice):e.generateError('"Met undefined tag value " + '+p+' + " at choice"'),e.pushCode("}"),this.varName&&(e.pushCode("delete "+r+".$parent;"),e.pushCode("delete "+r+".$root;"))},e.prototype.generateNest=function(t){var p=t.generateVariable(this.varName);if(this.options.type instanceof e){if(this.varName){var r=t.generateVariable();t.pushCode(p+" = {};"),t.pushCode(p+".$parent = "+r+";"),t.pushCode(p+".$root = "+r+".$root;")}t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName),this.varName&&(t.pushCode("delete "+p+".$parent;"),t.pushCode("delete "+p+".$root;"))}else if(o[this.options.type]){r=t.generateVariable();var s=t.generateTmpVariable();t.pushCode("var "+s+" = "+(i+this.options.type)+"(offset, {"),t.pushCode("$parent: "+r+","),t.pushCode("$root: "+r+".$root,"),t.pushCode("});"),t.pushCode(p+" = "+s+".result; offset = "+s+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}},e.prototype.generateWrapper=function(t){var p=t.generateVariable(this.varName),r=t.generateTmpVariable();if("function"==typeof this.options.readUntil){var s=this.options.readUntil,n=t.generateTmpVariable(),a=t.generateTmpVariable();t.pushCode("var "+n+" = offset;"),t.pushCode("var "+a+" = 0;"),t.pushCode("while (offset < buffer.length) {"),t.pushCode(a+" = dataView.getUint8(offset);");var l=t.addImport(s);t.pushCode("if ("+l+".call("+t.generateVariable()+", "+a+", buffer.subarray(offset))) break;"),t.pushCode("offset += 1;"),t.pushCode("}"),t.pushCode(r+" = buffer.subarray("+n+", offset);")}else if("eof"===this.options.readUntil)t.pushCode(r+" = buffer.subarray(offset);");else{var c=t.generateOption(this.options.length);t.pushCode(r+" = buffer.subarray(offset, offset + "+c+");"),t.pushCode("offset += "+c+";")}this.options.clone&&t.pushCode(r+" = buffer.constructor.from("+r+");");var u=t.generateTmpVariable(),y=t.generateTmpVariable(),f=t.generateTmpVariable(),d=t.addImport(this.options.wrapper);if(t.pushCode(r+" = "+d+".call(this, "+r+").subarray(0);"),t.pushCode("var "+u+" = buffer;"),t.pushCode("var "+y+" = offset;"),t.pushCode("var "+f+" = dataView;"),t.pushCode("buffer = "+r+";"),t.pushCode("offset = 0;"),t.pushCode("dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"),this.options.type instanceof e)this.varName&&t.pushCode(p+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var h=t.generateTmpVariable();t.pushCode("var "+h+" = "+(i+this.options.type)+"(0);"),t.pushCode(p+" = "+h+".result;"),this.options.type!==this.alias&&t.addReference(this.options.type)}t.pushCode("buffer = "+u+";"),t.pushCode("dataView = "+f+";"),t.pushCode("offset = "+y+";")},e.prototype.generateFormatter=function(e,t,p){if("function"==typeof p){var r=e.addImport(p);e.pushCode(t+" = "+r+".call("+e.generateVariable()+", "+t+");")}},e.prototype.generatePointer=function(t){var p=this.options.type,r=t.generateOption(this.options.offset),l=t.generateTmpVariable(),c=t.generateVariable(this.varName);if(t.pushCode("var "+l+" = offset;"),t.pushCode("offset = "+r+";"),this.options.type instanceof e){var u=t.generateVariable();t.pushCode(c+" = {};"),t.pushCode(c+".$parent = "+u+";"),t.pushCode(c+".$root = "+u+".$root;"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName),t.pushCode("delete "+c+".$parent;"),t.pushCode("delete "+c+".$root;")}else if(o[this.options.type]){u=t.generateVariable();var y=t.generateTmpVariable();t.pushCode("var "+y+" = "+(i+this.options.type)+"(offset, {"),t.pushCode("$parent: "+u+","),t.pushCode("$root: "+u+".$root,"),t.pushCode("});"),t.pushCode(c+" = "+y+".result; offset = "+y+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}else if(Object.keys(s).indexOf(this.options.type)>=0){var f=n[p],d=a[p];t.pushCode(c+" = dataView.get"+f+"(offset, "+d+");"),t.pushCode("offset += "+s[p]+";")}t.pushCode("offset = "+l+";")},e.prototype.generateSaveOffset=function(e){var t=e.generateVariable(this.varName);e.pushCode(t+" = offset")},e}();t.i=l},5682:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Context=void 0;var p=function(){function e(e){this.code="",this.scopes=[["vars"]],this.bitFields=[],this.tmpVariableCount=0,this.references={},this.imports=[],this.reverseImports=new Map,this.importPath=e}return e.prototype.generateVariable=function(e){var t=[],p=this.scopes[this.scopes.length-1];return t.push.apply(t,p),e&&t.push(e),t.join(".")},e.prototype.generateOption=function(e){switch(typeof e){case"number":return e.toString();case"string":return this.generateVariable(e);case"function":return this.addImport(e)+".call("+this.generateVariable()+", vars)"}},e.prototype.generateError=function(e){this.pushCode("throw new Error("+e+");")},e.prototype.generateTmpVariable=function(){return"$tmp"+this.tmpVariableCount++},e.prototype.pushCode=function(e){this.code+=e+"\n"},e.prototype.pushPath=function(e){e&&this.scopes[this.scopes.length-1].push(e)},e.prototype.popPath=function(e){e&&this.scopes[this.scopes.length-1].pop()},e.prototype.pushScope=function(e){this.scopes.push([e])},e.prototype.popScope=function(){this.scopes.pop()},e.prototype.addImport=function(e){if(!this.importPath)return"("+e+")";var t=this.reverseImports.get(e);return t||(t=this.imports.push(e)-1,this.reverseImports.set(e,t)),this.importPath+"["+t+"]"},e.prototype.addReference=function(e){this.references[e]||(this.references[e]={resolved:!1,requested:!1})},e.prototype.markResolved=function(e){this.references[e].resolved=!0},e.prototype.markRequested=function(e){var t=this;e.forEach((function(e){t.references[e].requested=!0}))},e.prototype.getUnresolvedReferences=function(){var e=this.references;return Object.keys(this.references).filter((function(t){return!e[t].resolved&&!e[t].requested}))},e}();t.Context=p},3144:(e,t,p)=>{"use strict";var r=p(6743),o=p(1002),i=p(76),s=p(7119);e.exports=s||r.call(i,o)},2205:(e,t,p)=>{"use strict";var r=p(6743),o=p(1002),i=p(3144);e.exports=function(){return i(r,o,arguments)}},1002:e=>{"use strict";e.exports=Function.prototype.apply},76:e=>{"use strict";e.exports=Function.prototype.call},3126:(e,t,p)=>{"use strict";var r=p(6743),o=p(9675),i=p(76),s=p(3144);e.exports=function(e){if(e.length<1||"function"!=typeof e[0])throw new o("a function is required");return s(r,i,e)}},7119:e=>{"use strict";e.exports="undefined"!=typeof Reflect&&Reflect&&Reflect.apply},8075:(e,t,p)=>{"use strict";var r=p(453),o=p(487),i=o(r("String.prototype.indexOf"));e.exports=function(e,t){var p=r(e,!!t);return"function"==typeof p&&i(e,".prototype.")>-1?o(p):p}},487:(e,t,p)=>{"use strict";var r=p(6897),o=p(655),i=p(3126),s=p(2205);e.exports=function(e){var t=i(arguments),p=e.length-(arguments.length-1);return r(t,1+(p>0?p:0),!0)},o?o(e.exports,"apply",{value:s}):e.exports.apply=s},6556:(e,t,p)=>{"use strict";var r=p(453),o=p(3126),i=o([r("%String.prototype.indexOf%")]);e.exports=function(e,t){var p=r(e,!!t);return"function"==typeof p&&i(e,".prototype.")>-1?o([p]):p}},5971:e=>{function t(e){if(e)return function(e){return Object.assign(e,t.prototype),e._callbacks=new Map,e}(e);this._callbacks=new Map}t.prototype.on=function(e,t){const p=this._callbacks.get(e)??[];return p.push(t),this._callbacks.set(e,p),this},t.prototype.once=function(e,t){const p=(...r)=>{this.off(e,p),t.apply(this,r)};return p.fn=t,this.on(e,p),this},t.prototype.off=function(e,t){if(void 0===e&&void 0===t)return this._callbacks.clear(),this;if(void 0===t)return this._callbacks.delete(e),this;const p=this._callbacks.get(e);if(p){for(const[e,r]of p.entries())if(r===t||r.fn===t){p.splice(e,1);break}0===p.length?this._callbacks.delete(e):this._callbacks.set(e,p)}return this},t.prototype.emit=function(e,...t){const p=this._callbacks.get(e);if(p){const e=[...p];for(const p of e)p.apply(this,t)}return this},t.prototype.listeners=function(e){return this._callbacks.get(e)??[]},t.prototype.listenerCount=function(e){if(e)return this.listeners(e).length;let t=0;for(const e of this._callbacks.values())t+=e.length;return t},t.prototype.hasListeners=function(e){return this.listenerCount(e)>0},t.prototype.addEventListener=t.prototype.on,t.prototype.removeListener=t.prototype.off,t.prototype.removeEventListener=t.prototype.off,t.prototype.removeAllListeners=t.prototype.off,e.exports=t},7898:(e,t,p)=>{t.UINT32=p(741),t.UINT64=p(174)},741:function(e,t){var p;!function(){function r(e,t){return this instanceof r?(this._low=0,this._high=0,this.remainder=null,void 0===t?i.call(this,e):"string"==typeof e?s.call(this,e,t):void o.call(this,e,t)):new r(e,t)}function o(e,t){return this._low=0|e,this._high=0|t,this}function i(e){return this._low=65535&e,this._high=e>>>16,this}function s(e,t){var p=parseInt(e,t||10);return this._low=65535&p,this._high=p>>>16,this}r(Math.pow(36,5)),r(Math.pow(16,7)),r(Math.pow(10,9)),r(Math.pow(2,30)),r(36),r(16),r(10),r(2),r.prototype.fromBits=o,r.prototype.fromNumber=i,r.prototype.fromString=s,r.prototype.toNumber=function(){return 65536*this._high+this._low},r.prototype.toString=function(e){return this.toNumber().toString(e||10)},r.prototype.add=function(e){var t=this._low+e._low,p=t>>>16;return p+=this._high+e._high,this._low=65535&t,this._high=65535&p,this},r.prototype.subtract=function(e){return this.add(e.clone().negate())},r.prototype.multiply=function(e){var t,p,r=this._high,o=this._low,i=e._high,s=e._low;return t=(p=o*s)>>>16,t+=r*s,t&=65535,t+=o*i,this._low=65535&p,this._high=65535&t,this},r.prototype.div=function(e){if(0==e._low&&0==e._high)throw Error("division by zero");if(0==e._high&&1==e._low)return this.remainder=new r(0),this;if(e.gt(this))return this.remainder=this.clone(),this._low=0,this._high=0,this;if(this.eq(e))return this.remainder=new r(0),this._low=1,this._high=0,this;for(var t=e.clone(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._low=0,this._high=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=16?this._high|=1<>>16)&65535,this},r.prototype.equals=r.prototype.eq=function(e){return this._low==e._low&&this._high==e._high},r.prototype.greaterThan=r.prototype.gt=function(e){return this._high>e._high||!(this._highe._low},r.prototype.lessThan=r.prototype.lt=function(e){return this._highe._high)&&this._low16?(this._low=this._high>>e-16,this._high=0):16==e?(this._low=this._high,this._high=0):(this._low=this._low>>e|this._high<<16-e&65535,this._high>>=e),this},r.prototype.shiftLeft=r.prototype.shiftl=function(e,t){return e>16?(this._high=this._low<>16-e,this._low=this._low<>>32-e,this._low=65535&t,this._high=t>>>16,this},r.prototype.rotateRight=r.prototype.rotr=function(e){var t=this._high<<16|this._low;return t=t>>>e|t<<32-e,this._low=65535&t,this._high=t>>>16,this},r.prototype.clone=function(){return new r(this._low,this._high)},void 0===(p=function(){return r}.apply(t,[]))||(e.exports=p)}()},174:function(e,t){var p;!function(){var r={16:i(Math.pow(16,5)),10:i(Math.pow(10,5)),2:i(Math.pow(2,5))},o={16:i(16),10:i(10),2:i(2)};function i(e,t,p,r){return this instanceof i?(this.remainder=null,"string"==typeof e?a.call(this,e,t):void 0===t?n.call(this,e):void s.apply(this,arguments)):new i(e,t,p,r)}function s(e,t,p,r){return void 0===p?(this._a00=65535&e,this._a16=e>>>16,this._a32=65535&t,this._a48=t>>>16,this):(this._a00=0|e,this._a16=0|t,this._a32=0|p,this._a48=0|r,this)}function n(e){return this._a00=65535&e,this._a16=e>>>16,this._a32=0,this._a48=0,this}function a(e,t){t=t||10,this._a00=0,this._a16=0,this._a32=0,this._a48=0;for(var p=r[t]||new i(Math.pow(t,5)),o=0,s=e.length;o=0&&(p.div(t),r[s]=p.remainder.toNumber().toString(e),p.gt(t));s--);return r[s-1]=p.toNumber().toString(e),r.join("")},i.prototype.add=function(e){var t=this._a00+e._a00,p=t>>>16,r=(p+=this._a16+e._a16)>>>16,o=(r+=this._a32+e._a32)>>>16;return o+=this._a48+e._a48,this._a00=65535&t,this._a16=65535&p,this._a32=65535&r,this._a48=65535&o,this},i.prototype.subtract=function(e){return this.add(e.clone().negate())},i.prototype.multiply=function(e){var t=this._a00,p=this._a16,r=this._a32,o=this._a48,i=e._a00,s=e._a16,n=e._a32,a=t*i,l=a>>>16,c=(l+=t*s)>>>16;l&=65535,c+=(l+=p*i)>>>16;var u=(c+=t*n)>>>16;return c&=65535,u+=(c+=p*s)>>>16,c&=65535,u+=(c+=r*i)>>>16,u+=t*e._a48,u&=65535,u+=p*n,u&=65535,u+=r*s,u&=65535,u+=o*i,this._a00=65535&a,this._a16=65535&l,this._a32=65535&c,this._a48=65535&u,this},i.prototype.div=function(e){if(0==e._a16&&0==e._a32&&0==e._a48){if(0==e._a00)throw Error("division by zero");if(1==e._a00)return this.remainder=new i(0),this}if(e.gt(this))return this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0,this;if(this.eq(e))return this.remainder=new i(0),this._a00=1,this._a16=0,this._a32=0,this._a48=0,this;for(var t=e.clone(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=48?this._a48|=1<=32?this._a32|=1<=16?this._a16|=1<>>16),this._a16=65535&e,e=(65535&~this._a32)+(e>>>16),this._a32=65535&e,this._a48=~this._a48+(e>>>16)&65535,this},i.prototype.equals=i.prototype.eq=function(e){return this._a48==e._a48&&this._a00==e._a00&&this._a32==e._a32&&this._a16==e._a16},i.prototype.greaterThan=i.prototype.gt=function(e){return this._a48>e._a48||!(this._a48e._a32||!(this._a32e._a16||!(this._a16e._a00))},i.prototype.lessThan=i.prototype.lt=function(e){return this._a48e._a48)&&(this._a32e._a32)&&(this._a16e._a16)&&this._a00=48?(this._a00=this._a48>>e-48,this._a16=0,this._a32=0,this._a48=0):e>=32?(e-=32,this._a00=65535&(this._a32>>e|this._a48<<16-e),this._a16=this._a48>>e&65535,this._a32=0,this._a48=0):e>=16?(e-=16,this._a00=65535&(this._a16>>e|this._a32<<16-e),this._a16=65535&(this._a32>>e|this._a48<<16-e),this._a32=this._a48>>e&65535,this._a48=0):(this._a00=65535&(this._a00>>e|this._a16<<16-e),this._a16=65535&(this._a16>>e|this._a32<<16-e),this._a32=65535&(this._a32>>e|this._a48<<16-e),this._a48=this._a48>>e&65535),this},i.prototype.shiftLeft=i.prototype.shiftl=function(e,t){return(e%=64)>=48?(this._a48=this._a00<=32?(e-=32,this._a48=this._a16<>16-e,this._a32=this._a00<=16?(e-=16,this._a48=this._a32<>16-e,this._a32=65535&(this._a16<>16-e),this._a16=this._a00<>16-e,this._a32=65535&(this._a32<>16-e),this._a16=65535&(this._a16<>16-e),this._a00=this._a00<=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p<>>32-e,i=r<>>32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},i.prototype.rotateRight=i.prototype.rotr=function(e){if(0==(e%=64))return this;if(e>=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p>>>e|r<<32-e,i=r>>>e|p<<32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},i.prototype.clone=function(){return new i(this._a00,this._a16,this._a32,this._a48)},void 0===(p=function(){return i}.apply(t,[]))||(e.exports=p)}()},41:(e,t,p)=>{"use strict";var r=p(655),o=p(8068),i=p(9675),s=p(5795);e.exports=function(e,t,p){if(!e||"object"!=typeof e&&"function"!=typeof e)throw new i("`obj` must be an object or a function`");if("string"!=typeof t&&"symbol"!=typeof t)throw new i("`property` must be a string or a symbol`");if(arguments.length>3&&"boolean"!=typeof arguments[3]&&null!==arguments[3])throw new i("`nonEnumerable`, if provided, must be a boolean or null");if(arguments.length>4&&"boolean"!=typeof arguments[4]&&null!==arguments[4])throw new i("`nonWritable`, if provided, must be a boolean or null");if(arguments.length>5&&"boolean"!=typeof arguments[5]&&null!==arguments[5])throw new i("`nonConfigurable`, if provided, must be a boolean or null");if(arguments.length>6&&"boolean"!=typeof arguments[6])throw new i("`loose`, if provided, must be a boolean");var n=arguments.length>3?arguments[3]:null,a=arguments.length>4?arguments[4]:null,l=arguments.length>5?arguments[5]:null,c=arguments.length>6&&arguments[6],u=!!s&&s(e,t);if(r)r(e,t,{configurable:null===l&&u?u.configurable:!l,enumerable:null===n&&u?u.enumerable:!n,value:p,writable:null===a&&u?u.writable:!a});else{if(!c&&(n||a||l))throw new o("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");e[t]=p}}},8452:(e,t,p)=>{"use strict";var r=p(1189),o="function"==typeof Symbol&&"symbol"==typeof Symbol("foo"),i=Object.prototype.toString,s=Array.prototype.concat,n=p(41),a=p(592)(),l=function(e,t,p,r){if(t in e)if(!0===r){if(e[t]===p)return}else if("function"!=typeof(o=r)||"[object Function]"!==i.call(o)||!r())return;var o;a?n(e,t,p,!0):n(e,t,p)},c=function(e,t){var p=arguments.length>2?arguments[2]:{},i=r(t);o&&(i=s.call(i,Object.getOwnPropertySymbols(t)));for(var n=0;n{"use strict";var r,o=p(3126),i=p(5795);try{r=[].__proto__===Array.prototype}catch(e){if(!e||"object"!=typeof e||!("code"in e)||"ERR_PROTO_ACCESS"!==e.code)throw e}var s=!!r&&i&&i(Object.prototype,"__proto__"),n=Object,a=n.getPrototypeOf;e.exports=s&&"function"==typeof s.get?o([s.get]):"function"==typeof a&&function(e){return a(null==e?e:n(e))}},655:e=>{"use strict";var t=Object.defineProperty||!1;if(t)try{t({},"a",{value:1})}catch(e){t=!1}e.exports=t},1237:e=>{"use strict";e.exports=EvalError},9383:e=>{"use strict";e.exports=Error},9290:e=>{"use strict";e.exports=RangeError},9538:e=>{"use strict";e.exports=ReferenceError},8068:e=>{"use strict";e.exports=SyntaxError},9675:e=>{"use strict";e.exports=TypeError},5345:e=>{"use strict";e.exports=URIError},9612:e=>{"use strict";e.exports=Object},9160:function(e,t,p){!function(e){"use strict";function t(e){for(var t=0,p=Math.min(65536,e.length+1),r=new Uint16Array(p),o=[],i=0;;){var s=t=p-1){var n=r.subarray(0,i);if(o.push(String.fromCharCode.apply(null,n)),!s)return o.join("");e=e.subarray(t),t=0,i=0}var a=e[t++];if(128&a){if(192==(224&a)){var l=63&e[t++];r[i++]=(31&a)<<6|l}else if(224==(240&a)){l=63&e[t++];var c=63&e[t++];r[i++]=(31&a)<<12|l<<6|c}else if(240==(248&a)){var u=(7&a)<<18|(l=63&e[t++])<<12|(c=63&e[t++])<<6|63&e[t++];u>65535&&(u-=65536,r[i++]=u>>>10&1023|55296,u=56320|1023&u),r[i++]=u}}else r[i++]=a}}var p="Failed to ",r=function(e,t,r){if(e)throw new Error("".concat(p).concat(t,": the '").concat(r,"' option is unsupported."))},o="function"==typeof Buffer&&Buffer.from,i=o?function(e){return Buffer.from(e)}:function(e){for(var t=0,p=e.length,r=0,o=Math.max(32,p+(p>>>1)+7),i=new Uint8Array(o>>>3<<3);t=55296&&s<=56319){if(t=55296&&s<=56319)continue}if(r+4>i.length){o+=8,o=(o*=1+t/e.length*2)>>>3<<3;var a=new Uint8Array(o);a.set(i),i=a}if(4294967168&s){if(4294965248&s)if(4294901760&s){if(4292870144&s)continue;i[r++]=s>>>18&7|240,i[r++]=s>>>12&63|128,i[r++]=s>>>6&63|128}else i[r++]=s>>>12&15|224,i[r++]=s>>>6&63|128;else i[r++]=s>>>6&31|192;i[r++]=63&s|128}else i[r++]=s}return i.slice?i.slice(0,r):i.subarray(0,r)};function s(){this.encoding="utf-8"}s.prototype.encode=function(e,t){return r(t&&t.stream,"encode","stream"),i(e)};var n=!o&&"function"==typeof Blob&&"function"==typeof URL&&"function"==typeof URL.createObjectURL,a=["utf-8","utf8","unicode-1-1-utf-8"],l=t;o?l=function(e,t){return(e instanceof Buffer?e:Buffer.from(e.buffer,e.byteOffset,e.byteLength)).toString(t)}:n&&(l=function(e){try{return function(e){var t;try{var p=new Blob([e],{type:"text/plain;charset=UTF-8"});t=URL.createObjectURL(p);var r=new XMLHttpRequest;return r.open("GET",t,!1),r.send(),r.responseText}finally{t&&URL.revokeObjectURL(t)}}(e)}catch(p){return t(e)}});var c="construct 'TextDecoder'",u="".concat(p," ").concat(c,": the ");function y(e,t){if(r(t&&t.fatal,c,"fatal"),e=e||"utf-8",!(o?Buffer.isEncoding(e):-1!==a.indexOf(e.toLowerCase())))throw new RangeError("".concat(u," encoding label provided ('").concat(e,"') is invalid."));this.encoding=e,this.fatal=!1,this.ignoreBOM=!1}y.prototype.decode=function(e,t){var p;return r(t&&t.stream,"decode","stream"),p=e instanceof Uint8Array?e:e.buffer instanceof ArrayBuffer?new Uint8Array(e.buffer):new Uint8Array(e),l(p,this.encoding)},e.TextEncoder=e.TextEncoder||s,e.TextDecoder=e.TextDecoder||y}("undefined"!=typeof window?window:void 0!==p.g?p.g:this)},2682:(e,t,p)=>{"use strict";var r=p(9600),o=Object.prototype.toString,i=Object.prototype.hasOwnProperty;e.exports=function(e,t,p){if(!r(t))throw new TypeError("iterator must be a function");var s;arguments.length>=3&&(s=p),"[object Array]"===o.call(e)?function(e,t,p){for(var r=0,o=e.length;r{"use strict";var t=Object.prototype.toString,p=Math.max,r=function(e,t){for(var p=[],r=0;r{"use strict";var r=p(9353);e.exports=Function.prototype.bind||r},453:(e,t,p)=>{"use strict";var r,o=p(9612),i=p(9383),s=p(1237),n=p(9290),a=p(9538),l=p(8068),c=p(9675),u=p(5345),y=p(1514),f=p(8968),d=p(6188),h=p(8002),_=p(5880),S=p(414),g=p(3093),w=Function,E=function(e){try{return w('"use strict"; return ('+e+").constructor;")()}catch(e){}},m=p(5795),b=p(655),I=function(){throw new c},L=m?function(){try{return I}catch(e){try{return m(arguments,"callee").get}catch(e){return I}}}():I,T=p(4039)(),v=p(3628),U=p(1064),O=p(8648),M=p(1002),D=p(76),A={},G="undefined"!=typeof Uint8Array&&v?v(Uint8Array):r,C={__proto__:null,"%AggregateError%":"undefined"==typeof AggregateError?r:AggregateError,"%Array%":Array,"%ArrayBuffer%":"undefined"==typeof ArrayBuffer?r:ArrayBuffer,"%ArrayIteratorPrototype%":T&&v?v([][Symbol.iterator]()):r,"%AsyncFromSyncIteratorPrototype%":r,"%AsyncFunction%":A,"%AsyncGenerator%":A,"%AsyncGeneratorFunction%":A,"%AsyncIteratorPrototype%":A,"%Atomics%":"undefined"==typeof Atomics?r:Atomics,"%BigInt%":"undefined"==typeof BigInt?r:BigInt,"%BigInt64Array%":"undefined"==typeof BigInt64Array?r:BigInt64Array,"%BigUint64Array%":"undefined"==typeof BigUint64Array?r:BigUint64Array,"%Boolean%":Boolean,"%DataView%":"undefined"==typeof DataView?r:DataView,"%Date%":Date,"%decodeURI%":decodeURI,"%decodeURIComponent%":decodeURIComponent,"%encodeURI%":encodeURI,"%encodeURIComponent%":encodeURIComponent,"%Error%":i,"%eval%":eval,"%EvalError%":s,"%Float32Array%":"undefined"==typeof Float32Array?r:Float32Array,"%Float64Array%":"undefined"==typeof Float64Array?r:Float64Array,"%FinalizationRegistry%":"undefined"==typeof FinalizationRegistry?r:FinalizationRegistry,"%Function%":w,"%GeneratorFunction%":A,"%Int8Array%":"undefined"==typeof Int8Array?r:Int8Array,"%Int16Array%":"undefined"==typeof Int16Array?r:Int16Array,"%Int32Array%":"undefined"==typeof Int32Array?r:Int32Array,"%isFinite%":isFinite,"%isNaN%":isNaN,"%IteratorPrototype%":T&&v?v(v([][Symbol.iterator]())):r,"%JSON%":"object"==typeof JSON?JSON:r,"%Map%":"undefined"==typeof Map?r:Map,"%MapIteratorPrototype%":"undefined"!=typeof Map&&T&&v?v((new Map)[Symbol.iterator]()):r,"%Math%":Math,"%Number%":Number,"%Object%":o,"%Object.getOwnPropertyDescriptor%":m,"%parseFloat%":parseFloat,"%parseInt%":parseInt,"%Promise%":"undefined"==typeof Promise?r:Promise,"%Proxy%":"undefined"==typeof Proxy?r:Proxy,"%RangeError%":n,"%ReferenceError%":a,"%Reflect%":"undefined"==typeof Reflect?r:Reflect,"%RegExp%":RegExp,"%Set%":"undefined"==typeof Set?r:Set,"%SetIteratorPrototype%":"undefined"!=typeof Set&&T&&v?v((new Set)[Symbol.iterator]()):r,"%SharedArrayBuffer%":"undefined"==typeof SharedArrayBuffer?r:SharedArrayBuffer,"%String%":String,"%StringIteratorPrototype%":T&&v?v(""[Symbol.iterator]()):r,"%Symbol%":T?Symbol:r,"%SyntaxError%":l,"%ThrowTypeError%":L,"%TypedArray%":G,"%TypeError%":c,"%Uint8Array%":"undefined"==typeof Uint8Array?r:Uint8Array,"%Uint8ClampedArray%":"undefined"==typeof Uint8ClampedArray?r:Uint8ClampedArray,"%Uint16Array%":"undefined"==typeof Uint16Array?r:Uint16Array,"%Uint32Array%":"undefined"==typeof Uint32Array?r:Uint32Array,"%URIError%":u,"%WeakMap%":"undefined"==typeof WeakMap?r:WeakMap,"%WeakRef%":"undefined"==typeof WeakRef?r:WeakRef,"%WeakSet%":"undefined"==typeof WeakSet?r:WeakSet,"%Function.prototype.call%":D,"%Function.prototype.apply%":M,"%Object.defineProperty%":b,"%Object.getPrototypeOf%":U,"%Math.abs%":y,"%Math.floor%":f,"%Math.max%":d,"%Math.min%":h,"%Math.pow%":_,"%Math.round%":S,"%Math.sign%":g,"%Reflect.getPrototypeOf%":O};if(v)try{null.error}catch(e){var j=v(v(e));C["%Error.prototype%"]=j}var P=function e(t){var p;if("%AsyncFunction%"===t)p=E("async function () {}");else if("%GeneratorFunction%"===t)p=E("function* () {}");else if("%AsyncGeneratorFunction%"===t)p=E("async function* () {}");else if("%AsyncGenerator%"===t){var r=e("%AsyncGeneratorFunction%");r&&(p=r.prototype)}else if("%AsyncIteratorPrototype%"===t){var o=e("%AsyncGenerator%");o&&v&&(p=v(o.prototype))}return C[t]=p,p},R={__proto__:null,"%ArrayBufferPrototype%":["ArrayBuffer","prototype"],"%ArrayPrototype%":["Array","prototype"],"%ArrayProto_entries%":["Array","prototype","entries"],"%ArrayProto_forEach%":["Array","prototype","forEach"],"%ArrayProto_keys%":["Array","prototype","keys"],"%ArrayProto_values%":["Array","prototype","values"],"%AsyncFunctionPrototype%":["AsyncFunction","prototype"],"%AsyncGenerator%":["AsyncGeneratorFunction","prototype"],"%AsyncGeneratorPrototype%":["AsyncGeneratorFunction","prototype","prototype"],"%BooleanPrototype%":["Boolean","prototype"],"%DataViewPrototype%":["DataView","prototype"],"%DatePrototype%":["Date","prototype"],"%ErrorPrototype%":["Error","prototype"],"%EvalErrorPrototype%":["EvalError","prototype"],"%Float32ArrayPrototype%":["Float32Array","prototype"],"%Float64ArrayPrototype%":["Float64Array","prototype"],"%FunctionPrototype%":["Function","prototype"],"%Generator%":["GeneratorFunction","prototype"],"%GeneratorPrototype%":["GeneratorFunction","prototype","prototype"],"%Int8ArrayPrototype%":["Int8Array","prototype"],"%Int16ArrayPrototype%":["Int16Array","prototype"],"%Int32ArrayPrototype%":["Int32Array","prototype"],"%JSONParse%":["JSON","parse"],"%JSONStringify%":["JSON","stringify"],"%MapPrototype%":["Map","prototype"],"%NumberPrototype%":["Number","prototype"],"%ObjectPrototype%":["Object","prototype"],"%ObjProto_toString%":["Object","prototype","toString"],"%ObjProto_valueOf%":["Object","prototype","valueOf"],"%PromisePrototype%":["Promise","prototype"],"%PromiseProto_then%":["Promise","prototype","then"],"%Promise_all%":["Promise","all"],"%Promise_reject%":["Promise","reject"],"%Promise_resolve%":["Promise","resolve"],"%RangeErrorPrototype%":["RangeError","prototype"],"%ReferenceErrorPrototype%":["ReferenceError","prototype"],"%RegExpPrototype%":["RegExp","prototype"],"%SetPrototype%":["Set","prototype"],"%SharedArrayBufferPrototype%":["SharedArrayBuffer","prototype"],"%StringPrototype%":["String","prototype"],"%SymbolPrototype%":["Symbol","prototype"],"%SyntaxErrorPrototype%":["SyntaxError","prototype"],"%TypedArrayPrototype%":["TypedArray","prototype"],"%TypeErrorPrototype%":["TypeError","prototype"],"%Uint8ArrayPrototype%":["Uint8Array","prototype"],"%Uint8ClampedArrayPrototype%":["Uint8ClampedArray","prototype"],"%Uint16ArrayPrototype%":["Uint16Array","prototype"],"%Uint32ArrayPrototype%":["Uint32Array","prototype"],"%URIErrorPrototype%":["URIError","prototype"],"%WeakMapPrototype%":["WeakMap","prototype"],"%WeakSetPrototype%":["WeakSet","prototype"]},N=p(6743),x=p(9957),F=N.call(D,Array.prototype.concat),k=N.call(M,Array.prototype.splice),B=N.call(D,String.prototype.replace),q=N.call(D,String.prototype.slice),z=N.call(D,RegExp.prototype.exec),V=/[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g,H=/\\(\\)?/g,$=function(e,t){var p,r=e;if(x(R,r)&&(r="%"+(p=R[r])[0]+"%"),x(C,r)){var o=C[r];if(o===A&&(o=P(r)),void 0===o&&!t)throw new c("intrinsic "+e+" exists, but is not available. Please file an issue!");return{alias:p,name:r,value:o}}throw new l("intrinsic "+e+" does not exist!")};e.exports=function(e,t){if("string"!=typeof e||0===e.length)throw new c("intrinsic name must be a non-empty string");if(arguments.length>1&&"boolean"!=typeof t)throw new c('"allowMissing" argument must be a boolean');if(null===z(/^%?[^%]*%?$/,e))throw new l("`%` may not be present anywhere but at the beginning and end of the intrinsic name");var p=function(e){var t=q(e,0,1),p=q(e,-1);if("%"===t&&"%"!==p)throw new l("invalid intrinsic syntax, expected closing `%`");if("%"===p&&"%"!==t)throw new l("invalid intrinsic syntax, expected opening `%`");var r=[];return B(e,V,(function(e,t,p,o){r[r.length]=p?B(o,H,"$1"):t||e})),r}(e),r=p.length>0?p[0]:"",o=$("%"+r+"%",t),i=o.name,s=o.value,n=!1,a=o.alias;a&&(r=a[0],k(p,F([0,1],a)));for(var u=1,y=!0;u=p.length){var _=m(s,f);s=(y=!!_)&&"get"in _&&!("originalValue"in _.get)?_.get:s[f]}else y=x(s,f),s=s[f];y&&!n&&(C[i]=s)}}return s}},1064:(e,t,p)=>{"use strict";var r=p(9612);e.exports=r.getPrototypeOf||null},8648:e=>{"use strict";e.exports="undefined"!=typeof Reflect&&Reflect.getPrototypeOf||null},3628:(e,t,p)=>{"use strict";var r=p(8648),o=p(1064),i=p(7176);e.exports=r?function(e){return r(e)}:o?function(e){if(!e||"object"!=typeof e&&"function"!=typeof e)throw new TypeError("getProto: not an object");return o(e)}:i?function(e){return i(e)}:null},6549:e=>{"use strict";e.exports=Object.getOwnPropertyDescriptor},5795:(e,t,p)=>{"use strict";var r=p(6549);if(r)try{r([],"length")}catch(e){r=null}e.exports=r},592:(e,t,p)=>{"use strict";var r=p(655),o=function(){return!!r};o.hasArrayLengthDefineBug=function(){if(!r)return null;try{return 1!==r([],"length",{value:1}).length}catch(e){return!0}},e.exports=o},4039:(e,t,p)=>{"use strict";var r="undefined"!=typeof Symbol&&Symbol,o=p(1333);e.exports=function(){return"function"==typeof r&&"function"==typeof Symbol&&"symbol"==typeof r("foo")&&"symbol"==typeof Symbol("bar")&&o()}},1333:e=>{"use strict";e.exports=function(){if("function"!=typeof Symbol||"function"!=typeof Object.getOwnPropertySymbols)return!1;if("symbol"==typeof Symbol.iterator)return!0;var e={},t=Symbol("test"),p=Object(t);if("string"==typeof t)return!1;if("[object Symbol]"!==Object.prototype.toString.call(t))return!1;if("[object Symbol]"!==Object.prototype.toString.call(p))return!1;for(var r in e[t]=42,e)return!1;if("function"==typeof Object.keys&&0!==Object.keys(e).length)return!1;if("function"==typeof Object.getOwnPropertyNames&&0!==Object.getOwnPropertyNames(e).length)return!1;var o=Object.getOwnPropertySymbols(e);if(1!==o.length||o[0]!==t)return!1;if(!Object.prototype.propertyIsEnumerable.call(e,t))return!1;if("function"==typeof Object.getOwnPropertyDescriptor){var i=Object.getOwnPropertyDescriptor(e,t);if(42!==i.value||!0!==i.enumerable)return!1}return!0}},9092:(e,t,p)=>{"use strict";var r=p(1333);e.exports=function(){return r()&&!!Symbol.toStringTag}},9957:(e,t,p)=>{"use strict";var r=Function.prototype.call,o=Object.prototype.hasOwnProperty,i=p(6743);e.exports=i.call(r,o)},6698:e=>{"function"==typeof Object.create?e.exports=function(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}))}:e.exports=function(e,t){if(t){e.super_=t;var p=function(){};p.prototype=t.prototype,e.prototype=new p,e.prototype.constructor=e}}},7244:(e,t,p)=>{"use strict";var r=p(9092)(),o=p(6556)("Object.prototype.toString"),i=function(e){return!(r&&e&&"object"==typeof e&&Symbol.toStringTag in e)&&"[object Arguments]"===o(e)},s=function(e){return!!i(e)||null!==e&&"object"==typeof e&&"length"in e&&"number"==typeof e.length&&e.length>=0&&"[object Array]"!==o(e)&&"callee"in e&&"[object Function]"===o(e.callee)},n=function(){return i(arguments)}();i.isLegacyArguments=s,e.exports=n?i:s},9600:e=>{"use strict";var t,p,r=Function.prototype.toString,o="object"==typeof Reflect&&null!==Reflect&&Reflect.apply;if("function"==typeof o&&"function"==typeof Object.defineProperty)try{t=Object.defineProperty({},"length",{get:function(){throw p}}),p={},o((function(){throw 42}),null,t)}catch(e){e!==p&&(o=null)}else o=null;var i=/^\s*class\b/,s=function(e){try{var t=r.call(e);return i.test(t)}catch(e){return!1}},n=function(e){try{return!s(e)&&(r.call(e),!0)}catch(e){return!1}},a=Object.prototype.toString,l="function"==typeof Symbol&&!!Symbol.toStringTag,c=!(0 in[,]),u=function(){return!1};if("object"==typeof document){var y=document.all;a.call(y)===a.call(document.all)&&(u=function(e){if((c||!e)&&(void 0===e||"object"==typeof e))try{var t=a.call(e);return("[object HTMLAllCollection]"===t||"[object HTML document.all class]"===t||"[object HTMLCollection]"===t||"[object Object]"===t)&&null==e("")}catch(e){}return!1})}e.exports=o?function(e){if(u(e))return!0;if(!e)return!1;if("function"!=typeof e&&"object"!=typeof e)return!1;try{o(e,null,t)}catch(e){if(e!==p)return!1}return!s(e)&&n(e)}:function(e){if(u(e))return!0;if(!e)return!1;if("function"!=typeof e&&"object"!=typeof e)return!1;if(l)return n(e);if(s(e))return!1;var t=a.call(e);return!("[object Function]"!==t&&"[object GeneratorFunction]"!==t&&!/^\[object HTML/.test(t))&&n(e)}},8184:(e,t,p)=>{"use strict";var r,o=p(6556),i=p(9721)(/^\s*(?:function)?\*/),s=p(9092)(),n=p(3628),a=o("Object.prototype.toString"),l=o("Function.prototype.toString");e.exports=function(e){if("function"!=typeof e)return!1;if(i(l(e)))return!0;if(!s)return"[object GeneratorFunction]"===a(e);if(!n)return!1;if(void 0===r){var t=function(){if(!s)return!1;try{return Function("return function*() {}")()}catch(e){}}();r=!!t&&n(t)}return n(e)===r}},3003:e=>{"use strict";e.exports=function(e){return e!=e}},4133:(e,t,p)=>{"use strict";var r=p(487),o=p(8452),i=p(3003),s=p(6642),n=p(2464),a=r(s(),Number);o(a,{getPolyfill:s,implementation:i,shim:n}),e.exports=a},6642:(e,t,p)=>{"use strict";var r=p(3003);e.exports=function(){return Number.isNaN&&Number.isNaN(NaN)&&!Number.isNaN("a")?Number.isNaN:r}},2464:(e,t,p)=>{"use strict";var r=p(8452),o=p(6642);e.exports=function(){var e=o();return r(Number,{isNaN:e},{isNaN:function(){return Number.isNaN!==e}}),e}},4035:(e,t,p)=>{"use strict";var r,o=p(6556),i=p(9092)(),s=p(9957),n=p(5795);if(i){var a=o("RegExp.prototype.exec"),l={},c=function(){throw l},u={toString:c,valueOf:c};"symbol"==typeof Symbol.toPrimitive&&(u[Symbol.toPrimitive]=c),r=function(e){if(!e||"object"!=typeof e)return!1;var t=n(e,"lastIndex");if(!t||!s(t,"value"))return!1;try{a(e,u)}catch(e){return e===l}}}else{var y=o("Object.prototype.toString");r=function(e){return!(!e||"object"!=typeof e&&"function"!=typeof e)&&"[object RegExp]"===y(e)}}e.exports=r},5680:(e,t,p)=>{"use strict";var r=p(5767);e.exports=function(e){return!!r(e)}},1514:e=>{"use strict";e.exports=Math.abs},8968:e=>{"use strict";e.exports=Math.floor},4459:e=>{"use strict";e.exports=Number.isNaN||function(e){return e!=e}},6188:e=>{"use strict";e.exports=Math.max},8002:e=>{"use strict";e.exports=Math.min},5880:e=>{"use strict";e.exports=Math.pow},414:e=>{"use strict";e.exports=Math.round},3093:(e,t,p)=>{"use strict";var r=p(4459);e.exports=function(e){return r(e)||0===e?e:e<0?-1:1}},6468:e=>{for(var t=4294967296,p=[],r=0;r<256;r++)p[r]=(r>15?"":"0")+r.toString(16);var o=e.exports=function(e,t){e instanceof Buffer?(this.buffer=e,this.offset=t||0):"[object Uint8Array]"==Object.prototype.toString.call(e)?(this.buffer=new Buffer(e),this.offset=t||0):(this.buffer=this.buffer||new Buffer(8),this.offset=0,this.setValue.apply(this,arguments))};o.MAX_INT=Math.pow(2,53),o.MIN_INT=-Math.pow(2,53),o.prototype={constructor:o,_2scomp:function(){for(var e=this.buffer,t=this.offset,p=1,r=t+7;r>=t;r--){var o=(255^e[r])+p;e[r]=255&o,p=o>>8}},setValue:function(e,p){var r=!1;if(1==arguments.length)if("number"==typeof e){if(r=e<0,p=(e=Math.abs(e))%t,(e/=t)>t)throw new RangeError(e+" is outside Int64 range");e|=0}else{if("string"!=typeof e)throw new Error(e+" must be a Number or String");p=(e=(e+"").replace(/^0x/,"")).substr(-8),e=e.length>8?e.substr(0,e.length-8):"",e=parseInt(e,16),p=parseInt(p,16)}for(var o=this.buffer,i=this.offset,s=7;s>=0;s--)o[i+s]=255&p,p=4==s?e:p>>>8;r&&this._2scomp()},toNumber:function(e){for(var t=this.buffer,p=this.offset,r=128&t[p],i=0,s=1,n=7,a=1;n>=0;n--,a*=256){var l=t[p+n];r&&(s=(l=(255^l)+s)>>8,l&=255),i+=l*a}return!e&&i>=o.MAX_INT?r?-1/0:1/0:r?-i:i},valueOf:function(){return this.toNumber(!1)},toString:function(e){return this.valueOf().toString(e||10)},toOctetString:function(e){for(var t=new Array(8),r=this.buffer,o=this.offset,i=0;i<8;i++)t[i]=p[r[o+i]];return t.join(e||"")},toBuffer:function(e){if(e&&0===this.offset)return this.buffer;var t=new Buffer(8);return this.buffer.copy(t,0,this.offset,this.offset+8),t},copy:function(e,t){this.buffer.copy(e,t||0,this.offset,this.offset+8)},compare:function(e){if((128&this.buffer[this.offset])!=(128&e.buffer[e.offset]))return e.buffer[e.offset]-this.buffer[this.offset];for(var t=0;t<8;t++)if(this.buffer[this.offset+t]!==e.buffer[e.offset+t])return this.buffer[this.offset+t]-e.buffer[e.offset+t];return 0},equals:function(e){return 0===this.compare(e)},inspect:function(){return"[Int64 value:"+this+" octets:"+this.toOctetString(" ")+"]"}}},9211:e=>{"use strict";var t=function(e){return e!=e};e.exports=function(e,p){return 0===e&&0===p?1/e==1/p:e===p||!(!t(e)||!t(p))}},7653:(e,t,p)=>{"use strict";var r=p(8452),o=p(487),i=p(9211),s=p(9394),n=p(6576),a=o(s(),Object);r(a,{getPolyfill:s,implementation:i,shim:n}),e.exports=a},9394:(e,t,p)=>{"use strict";var r=p(9211);e.exports=function(){return"function"==typeof Object.is?Object.is:r}},6576:(e,t,p)=>{"use strict";var r=p(9394),o=p(8452);e.exports=function(){var e=r();return o(Object,{is:e},{is:function(){return Object.is!==e}}),e}},8875:(e,t,p)=>{"use strict";var r;if(!Object.keys){var o=Object.prototype.hasOwnProperty,i=Object.prototype.toString,s=p(1093),n=Object.prototype.propertyIsEnumerable,a=!n.call({toString:null},"toString"),l=n.call((function(){}),"prototype"),c=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"],u=function(e){var t=e.constructor;return t&&t.prototype===e},y={$applicationCache:!0,$console:!0,$external:!0,$frame:!0,$frameElement:!0,$frames:!0,$innerHeight:!0,$innerWidth:!0,$onmozfullscreenchange:!0,$onmozfullscreenerror:!0,$outerHeight:!0,$outerWidth:!0,$pageXOffset:!0,$pageYOffset:!0,$parent:!0,$scrollLeft:!0,$scrollTop:!0,$scrollX:!0,$scrollY:!0,$self:!0,$webkitIndexedDB:!0,$webkitStorageInfo:!0,$window:!0},f=function(){if("undefined"==typeof window)return!1;for(var e in window)try{if(!y["$"+e]&&o.call(window,e)&&null!==window[e]&&"object"==typeof window[e])try{u(window[e])}catch(e){return!0}}catch(e){return!0}return!1}();r=function(e){var t=null!==e&&"object"==typeof e,p="[object Function]"===i.call(e),r=s(e),n=t&&"[object String]"===i.call(e),y=[];if(!t&&!p&&!r)throw new TypeError("Object.keys called on a non-object");var d=l&&p;if(n&&e.length>0&&!o.call(e,0))for(var h=0;h0)for(var _=0;_{"use strict";var r=Array.prototype.slice,o=p(1093),i=Object.keys,s=i?function(e){return i(e)}:p(8875),n=Object.keys;s.shim=function(){if(Object.keys){var e=function(){var e=Object.keys(arguments);return e&&e.length===arguments.length}(1,2);e||(Object.keys=function(e){return o(e)?n(r.call(e)):n(e)})}else Object.keys=s;return Object.keys||s},e.exports=s},1093:e=>{"use strict";var t=Object.prototype.toString;e.exports=function(e){var p=t.call(e),r="[object Arguments]"===p;return r||(r="[object Array]"!==p&&null!==e&&"object"==typeof e&&"number"==typeof e.length&&e.length>=0&&"[object Function]"===t.call(e.callee)),r}},8403:(e,t,p)=>{"use strict";var r=p(1189),o=p(1333)(),i=p(6556),s=p(9612),n=i("Array.prototype.push"),a=i("Object.prototype.propertyIsEnumerable"),l=o?s.getOwnPropertySymbols:null;e.exports=function(e,t){if(null==e)throw new TypeError("target must be an object");var p=s(e);if(1===arguments.length)return p;for(var i=1;i{"use strict";var r=p(8403);e.exports=function(){return Object.assign?function(){if(!Object.assign)return!1;for(var e="abcdefghijklmnopqrst",t=e.split(""),p={},r=0;r{"use strict";var r="win32"===process.platform,o=p(537);function i(e,t){for(var p=[],r=0;r=0&&!e[r];r--);return 0===p&&r===t?e:p>r?[]:e.slice(p,r+1)}var n=/^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/,a=/^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/,l={};function c(e){var t=n.exec(e),p=(t[1]||"")+(t[2]||""),r=t[3]||"",o=a.exec(r);return[p,o[1],o[2],o[3]]}function u(e){var t=n.exec(e),p=t[1]||"",r=!!p&&":"!==p[1];return{device:p,isUnc:r,isAbsolute:r||!!t[2],tail:t[3]}}function y(e){return"\\\\"+e.replace(/^[\\\/]+/,"").replace(/[\\\/]+/g,"\\")}l.resolve=function(){for(var e="",t="",p=!1,r=arguments.length-1;r>=-1;r--){var s;if(r>=0?s=arguments[r]:e?(s=process.env["="+e])&&s.substr(0,3).toLowerCase()===e.toLowerCase()+"\\"||(s=e+"\\"):s=process.cwd(),!o.isString(s))throw new TypeError("Arguments to path.resolve must be strings");if(s){var n=u(s),a=n.device,l=n.isUnc,c=n.isAbsolute,f=n.tail;if((!a||!e||a.toLowerCase()===e.toLowerCase())&&(e||(e=a),p||(t=f+"\\"+t,p=c),e&&p))break}}return l&&(e=y(e)),e+(p?"\\":"")+(t=i(t.split(/[\\\/]+/),!p).join("\\"))||"."},l.normalize=function(e){var t=u(e),p=t.device,r=t.isUnc,o=t.isAbsolute,s=t.tail,n=/[\\\/]$/.test(s);return(s=i(s.split(/[\\\/]+/),!o).join("\\"))||o||(s="."),s&&n&&(s+="\\"),r&&(p=y(p)),p+(o?"\\":"")+s},l.isAbsolute=function(e){return u(e).isAbsolute},l.join=function(){for(var e=[],t=0;t=-1&&!t;p--){var r=p>=0?arguments[p]:process.cwd();if(!o.isString(r))throw new TypeError("Arguments to path.resolve must be strings");r&&(e=r+"/"+e,t="/"===r[0])}return(t?"/":"")+(e=i(e.split("/"),!t).join("/"))||"."},d.normalize=function(e){var t=d.isAbsolute(e),p=e&&"/"===e[e.length-1];return(e=i(e.split("/"),!t).join("/"))||t||(e="."),e&&p&&(e+="/"),(t?"/":"")+e},d.isAbsolute=function(e){return"/"===e.charAt(0)},d.join=function(){for(var e="",t=0;t{"use strict";e.exports=["Float32Array","Float64Array","Int8Array","Int16Array","Int32Array","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array"]},9721:(e,t,p)=>{"use strict";var r=p(6556),o=p(4035),i=r("RegExp.prototype.exec"),s=p(9675);e.exports=function(e){if(!o(e))throw new s("`regex` must be a RegExp");return function(t){return null!==i(e,t)}}},6897:(e,t,p)=>{"use strict";var r=p(453),o=p(41),i=p(592)(),s=p(5795),n=p(9675),a=r("%Math.floor%");e.exports=function(e,t){if("function"!=typeof e)throw new n("`fn` is not a function");if("number"!=typeof t||t<0||t>4294967295||a(t)!==t)throw new n("`length` must be a positive 32-bit integer");var p=arguments.length>2&&!!arguments[2],r=!0,l=!0;if("length"in e&&s){var c=s(e,"length");c&&!c.configurable&&(r=!1),c&&!c.writable&&(l=!1)}return(r||l||!p)&&(i?o(e,"length",t,!0,!0):o(e,"length",t)),e}},4789:(e,t,p)=>{var r=p(5971);function o(){r.call(this)}o.prototype=new r,e.exports=o,o.Stream=o,o.prototype.pipe=function(e,t){var p=this;function r(t){e.writable&&!1===e.write(t)&&p.pause&&p.pause()}function o(){p.readable&&p.resume&&p.resume()}p.on("data",r),e.on("drain",o),e._isStdio||t&&!1===t.end||(p.on("end",s),p.on("close",n));var i=!1;function s(){i||(i=!0,e.end())}function n(){i||(i=!0,"function"==typeof e.destroy&&e.destroy())}function a(e){if(l(),!this.hasListeners("error"))throw e}function l(){p.off("data",r),e.off("drain",o),p.off("end",s),p.off("close",n),p.off("error",a),e.off("error",a),p.off("end",l),p.off("close",l),e.off("end",l),e.off("close",l)}return p.on("error",a),e.on("error",a),p.on("end",l),p.on("close",l),e.on("end",l),e.on("close",l),e.emit("pipe",p),e}},6622:e=>{"function"==typeof Object.create?e.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:e.exports=function(e,t){e.super_=t;var p=function(){};p.prototype=t.prototype,e.prototype=new p,e.prototype.constructor=e}},1135:e=>{e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},537:(e,t,p)=>{var r=/%[sdj%]/g;t.format=function(e){if(!_(e)){for(var t=[],p=0;p=i)return e;switch(e){case"%s":return String(o[p++]);case"%d":return Number(o[p++]);case"%j":try{return JSON.stringify(o[p++])}catch(e){return"[Circular]"}default:return e}})),a=o[p];p=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),f(p)?r.showHidden=p:p&&t._extend(r,p),S(r.showHidden)&&(r.showHidden=!1),S(r.depth)&&(r.depth=2),S(r.colors)&&(r.colors=!1),S(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=n),l(r,e,r.depth)}function n(e,t){var p=s.styles[t];return p?"["+s.colors[p][0]+"m"+e+"["+s.colors[p][1]+"m":e}function a(e,t){return e}function l(e,p,r){if(e.customInspect&&p&&b(p.inspect)&&p.inspect!==t.inspect&&(!p.constructor||p.constructor.prototype!==p)){var o=p.inspect(r,e);return _(o)||(o=l(e,o,r)),o}var i=function(e,t){if(S(t))return e.stylize("undefined","undefined");if(_(t)){var p="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(p,"string")}return h(t)?e.stylize(""+t,"number"):f(t)?e.stylize(""+t,"boolean"):d(t)?e.stylize("null","null"):void 0}(e,p);if(i)return i;var s=Object.keys(p),n=function(e){var t={};return e.forEach((function(e,p){t[e]=!0})),t}(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(p)),m(p)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return c(p);if(0===s.length){if(b(p)){var a=p.name?": "+p.name:"";return e.stylize("[Function"+a+"]","special")}if(g(p))return e.stylize(RegExp.prototype.toString.call(p),"regexp");if(E(p))return e.stylize(Date.prototype.toString.call(p),"date");if(m(p))return c(p)}var w,I="",L=!1,T=["{","}"];return y(p)&&(L=!0,T=["[","]"]),b(p)&&(I=" [Function"+(p.name?": "+p.name:"")+"]"),g(p)&&(I=" "+RegExp.prototype.toString.call(p)),E(p)&&(I=" "+Date.prototype.toUTCString.call(p)),m(p)&&(I=" "+c(p)),0!==s.length||L&&0!=p.length?r<0?g(p)?e.stylize(RegExp.prototype.toString.call(p),"regexp"):e.stylize("[Object]","special"):(e.seen.push(p),w=L?function(e,t,p,r,o){for(var i=[],s=0,n=t.length;s60?p[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+p[1]:p[0]+t+" "+e.join(", ")+" "+p[1]}(w,I,T)):T[0]+I+T[1]}function c(e){return"["+Error.prototype.toString.call(e)+"]"}function u(e,t,p,r,o,i){var s,n,a;if((a=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?n=a.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):a.set&&(n=e.stylize("[Setter]","special")),v(r,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=d(p)?l(e,a.value,null):l(e,a.value,p-1)).indexOf("\n")>-1&&(n=i?n.split("\n").map((function(e){return" "+e})).join("\n").substr(2):"\n"+n.split("\n").map((function(e){return" "+e})).join("\n")):n=e.stylize("[Circular]","special")),S(s)){if(i&&o.match(/^\d+$/))return n;(s=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+n}function y(e){return Array.isArray(e)}function f(e){return"boolean"==typeof e}function d(e){return null===e}function h(e){return"number"==typeof e}function _(e){return"string"==typeof e}function S(e){return void 0===e}function g(e){return w(e)&&"[object RegExp]"===I(e)}function w(e){return"object"==typeof e&&null!==e}function E(e){return w(e)&&"[object Date]"===I(e)}function m(e){return w(e)&&("[object Error]"===I(e)||e instanceof Error)}function b(e){return"function"==typeof e}function I(e){return Object.prototype.toString.call(e)}function L(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(S(o)&&(o=process.env.NODE_DEBUG||""),e=e.toUpperCase(),!i[e])if(new RegExp("\\b"+e+"\\b","i").test(o)){var p=process.pid;i[e]=function(){var r=t.format.apply(t,arguments);console.error("%s %d: %s",e,p,r)}}else i[e]=function(){};return i[e]},t.inspect=s,s.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},s.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=y,t.isBoolean=f,t.isNull=d,t.isNullOrUndefined=function(e){return null==e},t.isNumber=h,t.isString=_,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=S,t.isRegExp=g,t.isObject=w,t.isDate=E,t.isError=m,t.isFunction=b,t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=p(1135);var T=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function v(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){var e,p;console.log("%s - %s",(p=[L((e=new Date).getHours()),L(e.getMinutes()),L(e.getSeconds())].join(":"),[e.getDate(),T[e.getMonth()],p].join(" ")),t.format.apply(t,arguments))},t.inherits=p(6622),t._extend=function(e,t){if(!t||!w(t))return e;for(var p=Object.keys(t),r=p.length;r--;)e[p[r]]=t[p[r]];return e}},5767:(e,t,p)=>{"use strict";var r=p(2682),o=p(9209),i=p(487),s=p(6556),n=p(5795),a=s("Object.prototype.toString"),l=p(9092)(),c="undefined"==typeof globalThis?p.g:globalThis,u=o(),y=s("String.prototype.slice"),f=Object.getPrototypeOf,d=s("Array.prototype.indexOf",!0)||function(e,t){for(var p=0;p-1?t:"Object"===t&&function(e){var t=!1;return r(h,(function(p,r){if(!t)try{p(e),t=y(r,1)}catch(e){}})),t}(e)}return n?function(e){var t=!1;return r(h,(function(p,r){if(!t)try{"$"+p(e)===r&&(t=y(r,1))}catch(e){}})),t}(e):null}},9209:(e,t,p)=>{"use strict";var r=p(6578),o="undefined"==typeof globalThis?p.g:globalThis;e.exports=function(){for(var e=[],t=0;t(e.paths=[],e.children||(e.children=[]),e),p(8248)})(); \ No newline at end of file diff --git a/javascript/sbp/integrity.js b/javascript/sbp/integrity.js index 883971014a..3f2bb99333 100644 --- a/javascript/sbp/integrity.js +++ b/javascript/sbp/integrity.js @@ -74,7 +74,76 @@ IntegritySSRHeader.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); IntegritySSRHeader.prototype.fieldSpec.push(['chain_id', 'writeUInt8', 1]); /** - * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). + * + * Deprecated. + * + * Fields in the SBP payload (`sbp.payload`): + * @field obs_time GPSTimeSec GNSS reference time of the observation used to generate the flag. + * @field corr_time GPSTimeSec GNSS reference time of the correction associated to the flag. + * @field ssr_sol_id number (unsigned 8-bit int, 1 byte) SSR Solution ID. + * @field tile_set_id number (unsigned 16-bit int, 2 bytes) Unique identifier of the set this tile belongs to. + * @field tile_id number (unsigned 16-bit int, 2 bytes) Unique identifier of this tile in the tile set. + * @field chain_id number (unsigned 8-bit int, 1 byte) Chain and type of flag. + * @field use_gps_sat number (unsigned 8-bit int, 1 byte) Use GPS satellites. + * @field use_gal_sat number (unsigned 8-bit int, 1 byte) Use GAL satellites. + * @field use_bds_sat number (unsigned 8-bit int, 1 byte) Use BDS satellites. + * @field use_qzss_sat number (unsigned 8-bit int, 1 byte) Use QZSS satellites. + * @field reserved array Reserved + * @field use_tropo_grid_points number (unsigned 8-bit int, 1 byte) Use tropo grid points. + * @field use_iono_grid_points number (unsigned 8-bit int, 1 byte) Use iono grid points. + * @field use_iono_tile_sat_los number (unsigned 8-bit int, 1 byte) Use iono tile satellite LoS. + * @field use_iono_grid_point_sat_los number (unsigned 8-bit int, 1 byte) Use iono grid point satellite LoS. + * + * @param sbp An SBP object with a payload to be decoded. + */ +let MsgSsrFlagHighLevelDepA = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagHighLevelDepA.prototype = Object.create(SBP.prototype); +MsgSsrFlagHighLevelDepA.prototype.messageType = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; +MsgSsrFlagHighLevelDepA.prototype.msg_type = 0x0BB9; +MsgSsrFlagHighLevelDepA.prototype.constructor = MsgSsrFlagHighLevelDepA; +MsgSsrFlagHighLevelDepA.prototype.parser = new Parser() + .endianess('little') + .nest('obs_time', { type: GPSTimeSec.prototype.parser }) + .nest('corr_time', { type: GPSTimeSec.prototype.parser }) + .uint8('ssr_sol_id') + .uint16('tile_set_id') + .uint16('tile_id') + .uint8('chain_id') + .uint8('use_gps_sat') + .uint8('use_gal_sat') + .uint8('use_bds_sat') + .uint8('use_qzss_sat') + .array('reserved', { length: 5, type: 'uint8' }) + .uint8('use_tropo_grid_points') + .uint8('use_iono_grid_points') + .uint8('use_iono_tile_sat_los') + .uint8('use_iono_grid_point_sat_los'); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec = []; +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['obs_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['corr_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['ssr_sol_id', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['tile_set_id', 'writeUInt16LE', 2]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['chain_id', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_gps_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_gal_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_bds_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_qzss_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['reserved', 'array', 'writeUInt8', function () { return 1; }, 5]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_tropo_grid_points', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_iono_grid_points', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_iono_tile_sat_los', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_iono_grid_point_sat_los', 'writeUInt8', 1]); + +/** + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). * * Integrity monitoring flags for multiple aggregated elements. An element could be * a satellite, SSR grid point, or SSR tile. A group of aggregated elements being @@ -93,7 +162,8 @@ IntegritySSRHeader.prototype.fieldSpec.push(['chain_id', 'writeUInt8', 1]); * * Fields in the SBP payload (`sbp.payload`): * @field obs_time GPSTimeSec GNSS reference time of the observation used to generate the flag. - * @field corr_time GPSTimeSec GNSS reference time of the correction associated to the flag. + * @field iono_corr_time GPSTimeSec GNSS reference time of the ionospheric correction associated to the flag. + * @field sat_corr_time GPSTimeSec GNSS reference time of the satellite correction associated to the flag. * @field ssr_sol_id number (unsigned 8-bit int, 1 byte) SSR Solution ID. * @field tile_set_id number (unsigned 16-bit int, 2 bytes) Unique identifier of the set this tile belongs to. * @field tile_id number (unsigned 16-bit int, 2 bytes) Unique identifier of this tile in the tile set. @@ -119,12 +189,13 @@ let MsgSsrFlagHighLevel = function (sbp, fields) { }; MsgSsrFlagHighLevel.prototype = Object.create(SBP.prototype); MsgSsrFlagHighLevel.prototype.messageType = "MSG_SSR_FLAG_HIGH_LEVEL"; -MsgSsrFlagHighLevel.prototype.msg_type = 0x0BB9; +MsgSsrFlagHighLevel.prototype.msg_type = 0x0BBA; MsgSsrFlagHighLevel.prototype.constructor = MsgSsrFlagHighLevel; MsgSsrFlagHighLevel.prototype.parser = new Parser() .endianess('little') .nest('obs_time', { type: GPSTimeSec.prototype.parser }) - .nest('corr_time', { type: GPSTimeSec.prototype.parser }) + .nest('iono_corr_time', { type: GPSTimeSec.prototype.parser }) + .nest('sat_corr_time', { type: GPSTimeSec.prototype.parser }) .uint8('ssr_sol_id') .uint16('tile_set_id') .uint16('tile_id') @@ -140,7 +211,8 @@ MsgSsrFlagHighLevel.prototype.parser = new Parser() .uint8('use_iono_grid_point_sat_los'); MsgSsrFlagHighLevel.prototype.fieldSpec = []; MsgSsrFlagHighLevel.prototype.fieldSpec.push(['obs_time', GPSTimeSec.prototype.fieldSpec]); -MsgSsrFlagHighLevel.prototype.fieldSpec.push(['corr_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevel.prototype.fieldSpec.push(['iono_corr_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevel.prototype.fieldSpec.push(['sat_corr_time', GPSTimeSec.prototype.fieldSpec]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['ssr_sol_id', 'writeUInt8', 1]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['tile_set_id', 'writeUInt16LE', 2]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); @@ -379,7 +451,9 @@ MsgAcknowledge.prototype.fieldSpec.push(['solution_id', 'writeUInt8', 1]); module.exports = { IntegritySSRHeader: IntegritySSRHeader, - 0x0BB9: MsgSsrFlagHighLevel, + 0x0BB9: MsgSsrFlagHighLevelDepA, + MsgSsrFlagHighLevelDepA: MsgSsrFlagHighLevelDepA, + 0x0BBA: MsgSsrFlagHighLevel, MsgSsrFlagHighLevel: MsgSsrFlagHighLevel, 0x0BBD: MsgSsrFlagSatellites, MsgSsrFlagSatellites: MsgSsrFlagSatellites, diff --git a/jsonschema/MsgSsrFlagHighLevel.json b/jsonschema/MsgSsrFlagHighLevel.json index 70005ae4a3..1c89d6cb76 100644 --- a/jsonschema/MsgSsrFlagHighLevel.json +++ b/jsonschema/MsgSsrFlagHighLevel.json @@ -17,7 +17,8 @@ "type": "object", "properties": { "obs_time": {"$ref": "GpsTimeSec.json"}, - "corr_time": {"$ref": "GpsTimeSec.json"}, + "iono_corr_time": {"$ref": "GpsTimeSec.json"}, + "sat_corr_time": {"$ref": "GpsTimeSec.json"}, "ssr_sol_id": {"type": "integer"}, "tile_set_id": {"type": "integer"}, "tile_id": {"type": "integer"}, @@ -33,7 +34,8 @@ }, "required": [ "obs_time", - "corr_time", + "iono_corr_time", + "sat_corr_time", "ssr_sol_id", "tile_set_id", "tile_id", diff --git a/kaitai/ksy/integrity.ksy b/kaitai/ksy/integrity.ksy index bb34cfda71..e82d1d621f 100644 --- a/kaitai/ksy/integrity.ksy +++ b/kaitai/ksy/integrity.ksy @@ -51,6 +51,73 @@ types: Chain and type of flag. type: u1 + msg_ssr_flag_high_level_dep_a: + doc: | + Deprecated. + seq: + - id: obs_time + doc: | + GNSS reference time of the observation used to generate the flag. + type: gnss::gps_time_sec + - id: corr_time + doc: | + GNSS reference time of the correction associated to the flag. + type: gnss::gps_time_sec + - id: ssr_sol_id + doc: | + SSR Solution ID. + type: u1 + - id: tile_set_id + doc: | + Unique identifier of the set this tile belongs to. + type: u2 + - id: tile_id + doc: | + Unique identifier of this tile in the tile set. + type: u2 + - id: chain_id + doc: | + Chain and type of flag. + type: u1 + - id: use_gps_sat + doc: | + Use GPS satellites. + type: u1 + - id: use_gal_sat + doc: | + Use GAL satellites. + type: u1 + - id: use_bds_sat + doc: | + Use BDS satellites. + type: u1 + - id: use_qzss_sat + doc: | + Use QZSS satellites. + type: u1 + - id: reserved + doc: | + Reserved + type: u1 + repeat: expr + repeat-expr: 5 + - id: use_tropo_grid_points + doc: | + Use tropo grid points. + type: u1 + - id: use_iono_grid_points + doc: | + Use iono grid points. + type: u1 + - id: use_iono_tile_sat_los + doc: | + Use iono tile satellite LoS. + type: u1 + - id: use_iono_grid_point_sat_los + doc: | + Use iono grid point satellite LoS. + type: u1 + msg_ssr_flag_high_level: doc: | Integrity monitoring flags for multiple aggregated elements. An element @@ -83,9 +150,15 @@ types: doc: | GNSS reference time of the observation used to generate the flag. type: gnss::gps_time_sec - - id: corr_time + - id: iono_corr_time doc: | - GNSS reference time of the correction associated to the flag. + GNSS reference time of the ionospheric correction associated to the + flag. + type: gnss::gps_time_sec + - id: sat_corr_time + doc: | + GNSS reference time of the satellite correction associated to the + flag. type: gnss::gps_time_sec - id: ssr_sol_id doc: | diff --git a/kaitai/ksy/sbp.ksy b/kaitai/ksy/sbp.ksy index 870563ca55..846496fb39 100644 --- a/kaitai/ksy/sbp.ksy +++ b/kaitai/ksy/sbp.ksy @@ -97,7 +97,8 @@ enums: 2305: msg_imu_aux 2309: msg_imu_comp - 3001: msg_ssr_flag_high_level + 3001: msg_ssr_flag_high_level_dep_a + 3002: msg_ssr_flag_high_level 3005: msg_ssr_flag_satellites 3011: msg_ssr_flag_tropo_grid_points 3015: msg_ssr_flag_iono_grid_points @@ -381,7 +382,8 @@ types: 2305: imu::msg_imu_aux 2309: imu::msg_imu_comp - 3001: integrity::msg_ssr_flag_high_level + 3001: integrity::msg_ssr_flag_high_level_dep_a + 3002: integrity::msg_ssr_flag_high_level 3005: integrity::msg_ssr_flag_satellites 3011: integrity::msg_ssr_flag_tropo_grid_points 3015: integrity::msg_ssr_flag_iono_grid_points diff --git a/kaitai/perl/KaitaiSbp/Integrity.pm b/kaitai/perl/KaitaiSbp/Integrity.pm index a522c9bcea..f88e6f1bbc 100644 --- a/kaitai/perl/KaitaiSbp/Integrity.pm +++ b/kaitai/perl/KaitaiSbp/Integrity.pm @@ -481,7 +481,7 @@ sub faulty_points { } ######################################################################## -package Integrity::MsgSsrFlagHighLevel; +package Integrity::MsgSsrFlagHighLevelDepA; our @ISA = 'IO::KaitaiStruct::Struct'; @@ -606,4 +606,136 @@ sub use_iono_grid_point_sat_los { return $self->{use_iono_grid_point_sat_los}; } +######################################################################## +package Integrity::MsgSsrFlagHighLevel; + +our @ISA = 'IO::KaitaiStruct::Struct'; + +sub from_file { + my ($class, $filename) = @_; + my $fd; + + open($fd, '<', $filename) or return undef; + binmode($fd); + return new($class, IO::KaitaiStruct::Stream->new($fd)); +} + +sub new { + my ($class, $_io, $_parent, $_root) = @_; + my $self = IO::KaitaiStruct::Struct->new($_io); + + bless $self, $class; + $self->{_parent} = $_parent; + $self->{_root} = $_root || $self;; + + $self->_read(); + + return $self; +} + +sub _read { + my ($self) = @_; + + $self->{obs_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); + $self->{iono_corr_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); + $self->{sat_corr_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); + $self->{ssr_sol_id} = $self->{_io}->read_u1(); + $self->{tile_set_id} = $self->{_io}->read_u2le(); + $self->{tile_id} = $self->{_io}->read_u2le(); + $self->{chain_id} = $self->{_io}->read_u1(); + $self->{use_gps_sat} = $self->{_io}->read_u1(); + $self->{use_gal_sat} = $self->{_io}->read_u1(); + $self->{use_bds_sat} = $self->{_io}->read_u1(); + $self->{use_qzss_sat} = $self->{_io}->read_u1(); + $self->{reserved} = []; + my $n_reserved = 5; + for (my $i = 0; $i < $n_reserved; $i++) { + push @{$self->{reserved}}, $self->{_io}->read_u1(); + } + $self->{use_tropo_grid_points} = $self->{_io}->read_u1(); + $self->{use_iono_grid_points} = $self->{_io}->read_u1(); + $self->{use_iono_tile_sat_los} = $self->{_io}->read_u1(); + $self->{use_iono_grid_point_sat_los} = $self->{_io}->read_u1(); +} + +sub obs_time { + my ($self) = @_; + return $self->{obs_time}; +} + +sub iono_corr_time { + my ($self) = @_; + return $self->{iono_corr_time}; +} + +sub sat_corr_time { + my ($self) = @_; + return $self->{sat_corr_time}; +} + +sub ssr_sol_id { + my ($self) = @_; + return $self->{ssr_sol_id}; +} + +sub tile_set_id { + my ($self) = @_; + return $self->{tile_set_id}; +} + +sub tile_id { + my ($self) = @_; + return $self->{tile_id}; +} + +sub chain_id { + my ($self) = @_; + return $self->{chain_id}; +} + +sub use_gps_sat { + my ($self) = @_; + return $self->{use_gps_sat}; +} + +sub use_gal_sat { + my ($self) = @_; + return $self->{use_gal_sat}; +} + +sub use_bds_sat { + my ($self) = @_; + return $self->{use_bds_sat}; +} + +sub use_qzss_sat { + my ($self) = @_; + return $self->{use_qzss_sat}; +} + +sub reserved { + my ($self) = @_; + return $self->{reserved}; +} + +sub use_tropo_grid_points { + my ($self) = @_; + return $self->{use_tropo_grid_points}; +} + +sub use_iono_grid_points { + my ($self) = @_; + return $self->{use_iono_grid_points}; +} + +sub use_iono_tile_sat_los { + my ($self) = @_; + return $self->{use_iono_tile_sat_los}; +} + +sub use_iono_grid_point_sat_los { + my ($self) = @_; + return $self->{use_iono_grid_point_sat_los}; +} + 1; diff --git a/kaitai/perl/KaitaiSbp/Sbp.pm b/kaitai/perl/KaitaiSbp/Sbp.pm index 0f3f1be210..980f6db294 100644 --- a/kaitai/perl/KaitaiSbp/Sbp.pm +++ b/kaitai/perl/KaitaiSbp/Sbp.pm @@ -234,7 +234,8 @@ our $MSG_IDS_MSG_MAG_RAW = 2306; our $MSG_IDS_MSG_ODOMETRY = 2307; our $MSG_IDS_MSG_WHEELTICK = 2308; our $MSG_IDS_MSG_IMU_COMP = 2309; -our $MSG_IDS_MSG_SSR_FLAG_HIGH_LEVEL = 3001; +our $MSG_IDS_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A = 3001; +our $MSG_IDS_MSG_SSR_FLAG_HIGH_LEVEL = 3002; our $MSG_IDS_MSG_SSR_FLAG_SATELLITES = 3005; our $MSG_IDS_MSG_SSR_FLAG_TROPO_GRID_POINTS = 3011; our $MSG_IDS_MSG_SSR_FLAG_IONO_GRID_POINTS = 3015; @@ -1510,7 +1511,7 @@ sub _read { elsif ($_on == 3001) { $self->{_raw_payload} = $self->{_io}->read_bytes($self->length()); my $io__raw_payload = IO::KaitaiStruct::Stream->new($self->{_raw_payload}); - $self->{payload} = Integrity::MsgSsrFlagHighLevel->new($io__raw_payload, $self, $self->{_root}); + $self->{payload} = Integrity::MsgSsrFlagHighLevelDepA->new($io__raw_payload, $self, $self->{_root}); } elsif ($_on == 30) { $self->{_raw_payload} = $self->{_io}->read_bytes($self->length()); @@ -1542,6 +1543,11 @@ sub _read { my $io__raw_payload = IO::KaitaiStruct::Stream->new($self->{_raw_payload}); $self->{payload} = Bootload::MsgNapDeviceDnaReq->new($io__raw_payload, $self, $self->{_root}); } + elsif ($_on == 3002) { + $self->{_raw_payload} = $self->{_io}->read_bytes($self->length()); + my $io__raw_payload = IO::KaitaiStruct::Stream->new($self->{_raw_payload}); + $self->{payload} = Integrity::MsgSsrFlagHighLevel->new($io__raw_payload, $self, $self->{_root}); + } else { $self->{payload} = $self->{_io}->read_bytes($self->length()); } diff --git a/kaitai/perl/KaitaiSbp/Table.pm b/kaitai/perl/KaitaiSbp/Table.pm index 2f69d8e287..5f12a5de43 100644 --- a/kaitai/perl/KaitaiSbp/Table.pm +++ b/kaitai/perl/KaitaiSbp/Table.pm @@ -91,7 +91,8 @@ our %TABLE = ( 2305 => sub{Imu::MsgImuAux->new(@_)}, 2309 => sub{Imu::MsgImuComp->new(@_)}, - 3001 => sub{Integrity::MsgSsrFlagHighLevel->new(@_)}, + 3001 => sub{Integrity::MsgSsrFlagHighLevelDepA->new(@_)}, + 3002 => sub{Integrity::MsgSsrFlagHighLevel->new(@_)}, 3005 => sub{Integrity::MsgSsrFlagSatellites->new(@_)}, 3011 => sub{Integrity::MsgSsrFlagTropoGridPoints->new(@_)}, 3015 => sub{Integrity::MsgSsrFlagIonoGridPoints->new(@_)}, diff --git a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t index 2e66aa82db..1b2311ed94 100644 --- a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t +++ b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t @@ -29,32 +29,34 @@ use Test::More; use JSON::PP; use MIME::Base64; sub test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1() { - my $buf = decode_base64("VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD"); + my $buf = decode_base64("VboLQgAltAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCLHu"); my $stream = IO::KaitaiStruct::Stream->new($buf); my $msg = ParseUtils::get_flattened_msg(Sbp::SbpMessage->new($stream)); is($msg->{'preamble'}, 0x55, "preamble"); - is($msg->{'msg_type'}, 0x0BB9, "msg_type"); + is($msg->{'msg_type'}, 0x0BBA, "msg_type"); is($msg->{'sender'}, 0x0042, "sender"); - is($msg->{'length'}, 31, "length"); + is($msg->{'length'}, 37, "length"); - is($msg->{'payload'}, "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "payload"); + is($msg->{'payload'}, "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "payload"); - is($msg->{'crc'}, 0x0369, "crc"); + is($msg->{'crc'}, 0xEEB1, "crc"); my $json = JSON::PP->new->convert_blessed->canonical; is($msg->chain_id(), 40, "chain_id"); - is($json->encode($msg->corr_time()), $json->encode($json->decode(q{{"tow":360,"wn":6}})), "corr_time"); + is($json->encode($msg->iono_corr_time()), $json->encode($json->decode(q{{"tow":365,"wn":6}})), "iono_corr_time"); is($json->encode($msg->obs_time()), $json->encode($json->decode(q{{"tow":180,"wn":3}})), "obs_time"); is($json->encode($msg->reserved()), $json->encode($json->decode(q{[0,0,0,0,0]})), "reserved"); + is($json->encode($msg->sat_corr_time()), $json->encode($json->decode(q{{"tow":360,"wn":6}})), "sat_corr_time"); + is($msg->ssr_sol_id(), 10, "ssr_sol_id"); is($msg->tile_id(), 30, "tile_id"); @@ -77,7 +79,7 @@ sub test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1() { is($msg->use_tropo_grid_points(), 5, "use_tropo_grid_points"); - is($json->encode($msg), $json->encode($json->decode(q{{"chain_id":40,"corr_time":{"tow":360,"wn":6},"crc":873,"length":31,"msg_type":3001,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); + is($json->encode($msg), $json->encode($json->decode(q{{"chain_id":40,"crc":61105,"iono_corr_time":{"tow":365,"wn":6},"length":37,"msg_type":3002,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sat_corr_time":{"tow":360,"wn":6},"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); } test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(); diff --git a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t new file mode 100644 index 0000000000..c0eeddbbbf --- /dev/null +++ b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t @@ -0,0 +1,84 @@ +#!/usr/bin/perl -w +# +# Copyright (C) 2015-2023 Swift Navigation Inc. +# Contact: https://support.swiftnav.com +# +# This source is subject to the license found in the file 'LICENSE' which must +# be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. +# +# Test cases automatically generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml +# with generate.py. Do not modify by hand! + +use strict; + +BEGIN { + # add grandparent directory to include path + use Cwd qw(realpath); + use File::Basename; + unshift @INC, realpath(dirname($0))."/../../"; +} + +use KaitaiSbp::Sbp; +use KaitaiSbp::ParseUtils; +use IO::KaitaiStruct; +use Test::More; +use JSON::PP; +use MIME::Base64; +sub test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a_1() { + my $buf = decode_base64("VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD"); + my $stream = IO::KaitaiStruct::Stream->new($buf); + my $msg = ParseUtils::get_flattened_msg(Sbp::SbpMessage->new($stream)); + + is($msg->{'preamble'}, 0x55, "preamble"); + + is($msg->{'msg_type'}, 0x0BB9, "msg_type"); + + is($msg->{'sender'}, 0x0042, "sender"); + + is($msg->{'length'}, 31, "length"); + + is($msg->{'payload'}, "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "payload"); + + is($msg->{'crc'}, 0x0369, "crc"); + + my $json = JSON::PP->new->convert_blessed->canonical; + + is($msg->chain_id(), 40, "chain_id"); + + is($json->encode($msg->corr_time()), $json->encode($json->decode(q{{"tow":360,"wn":6}})), "corr_time"); + + is($json->encode($msg->obs_time()), $json->encode($json->decode(q{{"tow":180,"wn":3}})), "obs_time"); + + is($json->encode($msg->reserved()), $json->encode($json->decode(q{[0,0,0,0,0]})), "reserved"); + + is($msg->ssr_sol_id(), 10, "ssr_sol_id"); + + is($msg->tile_id(), 30, "tile_id"); + + is($msg->tile_set_id(), 20, "tile_set_id"); + + is($msg->use_bds_sat(), 3, "use_bds_sat"); + + is($msg->use_gal_sat(), 2, "use_gal_sat"); + + is($msg->use_gps_sat(), 1, "use_gps_sat"); + + is($msg->use_iono_grid_point_sat_los(), 8, "use_iono_grid_point_sat_los"); + + is($msg->use_iono_grid_points(), 6, "use_iono_grid_points"); + + is($msg->use_iono_tile_sat_los(), 7, "use_iono_tile_sat_los"); + + is($msg->use_qzss_sat(), 4, "use_qzss_sat"); + + is($msg->use_tropo_grid_points(), 5, "use_tropo_grid_points"); + + is($json->encode($msg), $json->encode($json->decode(q{{"chain_id":40,"corr_time":{"tow":360,"wn":6},"crc":873,"length":31,"msg_type":3001,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); +} +test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a_1(); + +done_testing(); diff --git a/kaitai/python/kaitai_sbp/integrity.py b/kaitai/python/kaitai_sbp/integrity.py index 7fcf216f63..55d57614d3 100644 --- a/kaitai/python/kaitai_sbp/integrity.py +++ b/kaitai/python/kaitai_sbp/integrity.py @@ -147,6 +147,36 @@ def _read(self): + class MsgSsrFlagHighLevelDepA(KaitaiStruct): + """Deprecated. + """ + def __init__(self, _io, _parent=None, _root=None): + self._io = _io + self._parent = _parent + self._root = _root if _root else self + self._read() + + def _read(self): + self.obs_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.corr_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.ssr_sol_id = self._io.read_u1() + self.tile_set_id = self._io.read_u2le() + self.tile_id = self._io.read_u2le() + self.chain_id = self._io.read_u1() + self.use_gps_sat = self._io.read_u1() + self.use_gal_sat = self._io.read_u1() + self.use_bds_sat = self._io.read_u1() + self.use_qzss_sat = self._io.read_u1() + self.reserved = [] + for i in range(5): + self.reserved.append(self._io.read_u1()) + + self.use_tropo_grid_points = self._io.read_u1() + self.use_iono_grid_points = self._io.read_u1() + self.use_iono_tile_sat_los = self._io.read_u1() + self.use_iono_grid_point_sat_los = self._io.read_u1() + + class MsgSsrFlagHighLevel(KaitaiStruct): """Integrity monitoring flags for multiple aggregated elements. An element could be a satellite, SSR grid point, or SSR tile. A group of aggregated @@ -182,7 +212,8 @@ def __init__(self, _io, _parent=None, _root=None): def _read(self): self.obs_time = Gnss.GpsTimeSec(self._io, self, self._root) - self.corr_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.iono_corr_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.sat_corr_time = Gnss.GpsTimeSec(self._io, self, self._root) self.ssr_sol_id = self._io.read_u1() self.tile_set_id = self._io.read_u2le() self.tile_id = self._io.read_u2le() diff --git a/kaitai/python/kaitai_sbp/sbp.py b/kaitai/python/kaitai_sbp/sbp.py index 75d6ae8b82..5b7f5627f8 100644 --- a/kaitai/python/kaitai_sbp/sbp.py +++ b/kaitai/python/kaitai_sbp/sbp.py @@ -227,7 +227,8 @@ class MsgIds(Enum): msg_odometry = 2307 msg_wheeltick = 2308 msg_imu_comp = 2309 - msg_ssr_flag_high_level = 3001 + msg_ssr_flag_high_level_dep_a = 3001 + msg_ssr_flag_high_level = 3002 msg_ssr_flag_satellites = 3005 msg_ssr_flag_tropo_grid_points = 3011 msg_ssr_flag_iono_grid_points = 3015 @@ -1237,7 +1238,7 @@ def _read(self): elif _on == 3001: self._raw_payload = self._io.read_bytes(self.length) _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) - self.payload = Integrity.MsgSsrFlagHighLevel(_io__raw_payload, self, self._root) + self.payload = Integrity.MsgSsrFlagHighLevelDepA(_io__raw_payload, self, self._root) elif _on == 30: self._raw_payload = self._io.read_bytes(self.length) _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) @@ -1262,6 +1263,10 @@ def _read(self): self._raw_payload = self._io.read_bytes(self.length) _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) self.payload = Bootload.MsgNapDeviceDnaReq(_io__raw_payload, self, self._root) + elif _on == 3002: + self._raw_payload = self._io.read_bytes(self.length) + _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) + self.payload = Integrity.MsgSsrFlagHighLevel(_io__raw_payload, self, self._root) else: self.payload = self._io.read_bytes(self.length) self.crc = self._io.read_u2le() diff --git a/kaitai/python/kaitai_sbp/table.py b/kaitai/python/kaitai_sbp/table.py index 1685d44394..17ab1718a0 100644 --- a/kaitai/python/kaitai_sbp/table.py +++ b/kaitai/python/kaitai_sbp/table.py @@ -85,7 +85,8 @@ 2305: Imu.MsgImuAux, 2309: Imu.MsgImuComp, - 3001: Integrity.MsgSsrFlagHighLevel, + 3001: Integrity.MsgSsrFlagHighLevelDepA, + 3002: Integrity.MsgSsrFlagHighLevel, 3005: Integrity.MsgSsrFlagSatellites, 3011: Integrity.MsgSsrFlagTropoGridPoints, 3015: Integrity.MsgSsrFlagIonoGridPoints, diff --git a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py index 8a9739e187..efe7a31bd5 100644 --- a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py +++ b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py @@ -19,31 +19,33 @@ import base64 def test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(): - buf = base64.standard_b64decode("VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD") + buf = base64.standard_b64decode("VboLQgAltAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCLHu") stream = KaitaiStream(io.BytesIO(buf)) msg = get_flattened_msg(sbp.Sbp.SbpMessage(stream)) assert msg.preamble == 0x55 - assert msg.msg_type == 0x0BB9 + assert msg.msg_type == 0x0BBA assert msg.sender == 0x0042 - assert msg.length == 31 + assert msg.length == 37 - assert msg.payload == "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==" + assert msg.payload == "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==" - assert msg.crc == 0x0369 + assert msg.crc == 0xEEB1 assert dictify(msg.chain_id) == 40 - assert dictify(msg.corr_time) == {'tow': 360, 'wn': 6} + assert dictify(msg.iono_corr_time) == {'tow': 365, 'wn': 6} assert dictify(msg.obs_time) == {'tow': 180, 'wn': 3} assert dictify(msg.reserved) == [0, 0, 0, 0, 0] + assert dictify(msg.sat_corr_time) == {'tow': 360, 'wn': 6} + assert dictify(msg.ssr_sol_id) == 10 assert dictify(msg.tile_id) == 30 @@ -66,4 +68,4 @@ def test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(): assert dictify(msg.use_tropo_grid_points) == 5 - assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'corr_time': {'tow': 360, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3001, 'sender': 66, 'length': 31, 'payload': 'tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 873} + assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'sat_corr_time': {'tow': 360, 'wn': 6}, 'iono_corr_time': {'tow': 365, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3002, 'sender': 66, 'length': 37, 'payload': 'tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 61105} diff --git a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py new file mode 100644 index 0000000000..0c1a6bf544 --- /dev/null +++ b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py @@ -0,0 +1,69 @@ +# Copyright (C) 2015-2023 Swift Navigation Inc. +# Contact: https://support.swiftnav.com +# +# This source is subject to the license found in the file 'LICENSE' which must +# be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. +# +# Test cases automatically generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml +# with generate.py. Do not modify by hand! + +import kaitai_sbp.sbp as sbp +from kaitai_sbp.parse_utils import get_flattened_msg +from kaitai_sbp.tests.utils import dictify +from kaitaistruct import KaitaiStream +import io +import base64 + +def test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a_1(): + buf = base64.standard_b64decode("VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD") + + stream = KaitaiStream(io.BytesIO(buf)) + msg = get_flattened_msg(sbp.Sbp.SbpMessage(stream)) + + assert msg.preamble == 0x55 + + assert msg.msg_type == 0x0BB9 + + assert msg.sender == 0x0042 + + assert msg.length == 31 + + assert msg.payload == "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==" + + assert msg.crc == 0x0369 + + assert dictify(msg.chain_id) == 40 + + assert dictify(msg.corr_time) == {'tow': 360, 'wn': 6} + + assert dictify(msg.obs_time) == {'tow': 180, 'wn': 3} + + assert dictify(msg.reserved) == [0, 0, 0, 0, 0] + + assert dictify(msg.ssr_sol_id) == 10 + + assert dictify(msg.tile_id) == 30 + + assert dictify(msg.tile_set_id) == 20 + + assert dictify(msg.use_bds_sat) == 3 + + assert dictify(msg.use_gal_sat) == 2 + + assert dictify(msg.use_gps_sat) == 1 + + assert dictify(msg.use_iono_grid_point_sat_los) == 8 + + assert dictify(msg.use_iono_grid_points) == 6 + + assert dictify(msg.use_iono_tile_sat_los) == 7 + + assert dictify(msg.use_qzss_sat) == 4 + + assert dictify(msg.use_tropo_grid_points) == 5 + + assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'corr_time': {'tow': 360, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3001, 'sender': 66, 'length': 31, 'payload': 'tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 873} diff --git a/proto/integrity.proto b/proto/integrity.proto index 507a8b82f3..28ce64b5e1 100644 --- a/proto/integrity.proto +++ b/proto/integrity.proto @@ -65,19 +65,20 @@ message IntegritySSRHeader { */ message MsgSsrFlagHighLevel { gnss.GpsTimeSec obs_time = 1; - gnss.GpsTimeSec corr_time = 2; - uint32 ssr_sol_id = 3; - uint32 tile_set_id = 4; - uint32 tile_id = 5; - uint32 chain_id = 6; - uint32 use_gps_sat = 7; - uint32 use_gal_sat = 8; - uint32 use_bds_sat = 9; - uint32 use_qzss_sat = 10; - uint32 use_tropo_grid_points = 12; - uint32 use_iono_grid_points = 13; - uint32 use_iono_tile_sat_los = 14; - uint32 use_iono_grid_point_sat_los = 15; + gnss.GpsTimeSec iono_corr_time = 2; + gnss.GpsTimeSec sat_corr_time = 3; + uint32 ssr_sol_id = 4; + uint32 tile_set_id = 5; + uint32 tile_id = 6; + uint32 chain_id = 7; + uint32 use_gps_sat = 8; + uint32 use_gal_sat = 9; + uint32 use_bds_sat = 10; + uint32 use_qzss_sat = 11; + uint32 use_tropo_grid_points = 13; + uint32 use_iono_grid_points = 14; + uint32 use_iono_tile_sat_los = 15; + uint32 use_iono_grid_point_sat_los = 16; } /** List of satellites which are faulty, per constellation diff --git a/python/sbp/integrity.py b/python/sbp/integrity.py index 47983388d8..3f344f7211 100644 --- a/python/sbp/integrity.py +++ b/python/sbp/integrity.py @@ -86,9 +86,174 @@ def from_binary(self, d): for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) -SBP_MSG_SSR_FLAG_HIGH_LEVEL = 0x0BB9 +SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A = 0x0BB9 +class MsgSsrFlagHighLevelDepA(SBP): + """SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). + + You can have MSG_SSR_FLAG_HIGH_LEVEL_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + obs_time : GPSTimeSec + GNSS reference time of the observation used to generate the flag. + corr_time : GPSTimeSec + GNSS reference time of the correction associated to the flag. + ssr_sol_id : int + SSR Solution ID. + tile_set_id : int + Unique identifier of the set this tile belongs to. + tile_id : int + Unique identifier of this tile in the tile set. + chain_id : int + Chain and type of flag. + use_gps_sat : int + Use GPS satellites. + use_gal_sat : int + Use GAL satellites. + use_bds_sat : int + Use BDS satellites. + use_qzss_sat : int + Use QZSS satellites. + reserved : array + Reserved + use_tropo_grid_points : int + Use tropo grid points. + use_iono_grid_points : int + Use iono grid points. + use_iono_tile_sat_los : int + Use iono tile satellite LoS. + use_iono_grid_point_sat_los : int + Use iono grid point satellite LoS. + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'obs_time' / GPSTimeSec._parser, + 'corr_time' / GPSTimeSec._parser, + 'ssr_sol_id' / construct.Int8ul, + 'tile_set_id' / construct.Int16ul, + 'tile_id' / construct.Int16ul, + 'chain_id' / construct.Int8ul, + 'use_gps_sat' / construct.Int8ul, + 'use_gal_sat' / construct.Int8ul, + 'use_bds_sat' / construct.Int8ul, + 'use_qzss_sat' / construct.Int8ul, + 'reserved' / construct.Array(5, construct.Int8ul), + 'use_tropo_grid_points' / construct.Int8ul, + 'use_iono_grid_points' / construct.Int8ul, + 'use_iono_tile_sat_los' / construct.Int8ul, + 'use_iono_grid_point_sat_los' / construct.Int8ul,) + __slots__ = [ + 'obs_time', + 'corr_time', + 'ssr_sol_id', + 'tile_set_id', + 'tile_id', + 'chain_id', + 'use_gps_sat', + 'use_gal_sat', + 'use_bds_sat', + 'use_qzss_sat', + 'reserved', + 'use_tropo_grid_points', + 'use_iono_grid_points', + 'use_iono_tile_sat_los', + 'use_iono_grid_point_sat_los', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagHighLevelDepA, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagHighLevelDepA, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A + self.sender = kwargs.pop('sender', SENDER_ID) + self.obs_time = kwargs.pop('obs_time') + self.corr_time = kwargs.pop('corr_time') + self.ssr_sol_id = kwargs.pop('ssr_sol_id') + self.tile_set_id = kwargs.pop('tile_set_id') + self.tile_id = kwargs.pop('tile_id') + self.chain_id = kwargs.pop('chain_id') + self.use_gps_sat = kwargs.pop('use_gps_sat') + self.use_gal_sat = kwargs.pop('use_gal_sat') + self.use_bds_sat = kwargs.pop('use_bds_sat') + self.use_qzss_sat = kwargs.pop('use_qzss_sat') + self.reserved = kwargs.pop('reserved') + self.use_tropo_grid_points = kwargs.pop('use_tropo_grid_points') + self.use_iono_grid_points = kwargs.pop('use_iono_grid_points') + self.use_iono_tile_sat_los = kwargs.pop('use_iono_tile_sat_los') + self.use_iono_grid_point_sat_los = kwargs.pop('use_iono_grid_point_sat_los') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagHighLevelDepA.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagHighLevelDepA(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagHighLevelDepA._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagHighLevelDepA._parser.build(c) + return self.pack() + + def friendly_name(self): + """Produces friendly human-readable name for this message + + """ + return "SSR FLAG HIGH LEVEL DEP A" + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagHighLevelDepA._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagHighLevelDepA, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_FLAG_HIGH_LEVEL = 0x0BBA class MsgSsrFlagHighLevel(SBP): - """SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + """SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). You can have MSG_SSR_FLAG_HIGH_LEVEL inherit its fields directly from an inherited SBP object, or construct it inline using a dict @@ -127,8 +292,10 @@ class MsgSsrFlagHighLevel(SBP): SBP parent object to inherit from. obs_time : GPSTimeSec GNSS reference time of the observation used to generate the flag. - corr_time : GPSTimeSec - GNSS reference time of the correction associated to the flag. + iono_corr_time : GPSTimeSec + GNSS reference time of the ionospheric correction associated to the flag. + sat_corr_time : GPSTimeSec + GNSS reference time of the satellite correction associated to the flag. ssr_sol_id : int SSR Solution ID. tile_set_id : int @@ -161,7 +328,8 @@ class MsgSsrFlagHighLevel(SBP): """ _parser = construct.Struct( 'obs_time' / GPSTimeSec._parser, - 'corr_time' / GPSTimeSec._parser, + 'iono_corr_time' / GPSTimeSec._parser, + 'sat_corr_time' / GPSTimeSec._parser, 'ssr_sol_id' / construct.Int8ul, 'tile_set_id' / construct.Int16ul, 'tile_id' / construct.Int16ul, @@ -177,7 +345,8 @@ class MsgSsrFlagHighLevel(SBP): 'use_iono_grid_point_sat_los' / construct.Int8ul,) __slots__ = [ 'obs_time', - 'corr_time', + 'iono_corr_time', + 'sat_corr_time', 'ssr_sol_id', 'tile_set_id', 'tile_id', @@ -204,7 +373,8 @@ def __init__(self, sbp=None, **kwargs): self.msg_type = SBP_MSG_SSR_FLAG_HIGH_LEVEL self.sender = kwargs.pop('sender', SENDER_ID) self.obs_time = kwargs.pop('obs_time') - self.corr_time = kwargs.pop('corr_time') + self.iono_corr_time = kwargs.pop('iono_corr_time') + self.sat_corr_time = kwargs.pop('sat_corr_time') self.ssr_sol_id = kwargs.pop('ssr_sol_id') self.tile_set_id = kwargs.pop('tile_set_id') self.tile_id = kwargs.pop('tile_id') @@ -949,7 +1119,8 @@ def to_json_dict(self): msg_classes = { - 0x0BB9: MsgSsrFlagHighLevel, + 0x0BB9: MsgSsrFlagHighLevelDepA, + 0x0BBA: MsgSsrFlagHighLevel, 0x0BBD: MsgSsrFlagSatellites, 0x0BC3: MsgSsrFlagTropoGridPoints, 0x0BC7: MsgSsrFlagIonoGridPoints, diff --git a/rust/sbp/src/messages/integrity.rs b/rust/sbp/src/messages/integrity.rs index ef9322b784..2f0ad929f5 100644 --- a/rust/sbp/src/messages/integrity.rs +++ b/rust/sbp/src/messages/integrity.rs @@ -16,6 +16,7 @@ pub use integrity_ssr_header::IntegritySSRHeader; pub use msg_acknowledge::MsgAcknowledge; pub use msg_ssr_flag_high_level::MsgSsrFlagHighLevel; +pub use msg_ssr_flag_high_level_dep_a::MsgSsrFlagHighLevelDepA; pub use msg_ssr_flag_iono_grid_point_sat_los::MsgSsrFlagIonoGridPointSatLos; pub use msg_ssr_flag_iono_grid_points::MsgSsrFlagIonoGridPoints; pub use msg_ssr_flag_iono_tile_sat_los::MsgSsrFlagIonoTileSatLos; @@ -888,9 +889,13 @@ pub mod msg_ssr_flag_high_level { /// GNSS reference time of the observation used to generate the flag. #[cfg_attr(feature = "serde", serde(rename = "obs_time"))] pub obs_time: GpsTimeSec, - /// GNSS reference time of the correction associated to the flag. - #[cfg_attr(feature = "serde", serde(rename = "corr_time"))] - pub corr_time: GpsTimeSec, + /// GNSS reference time of the ionospheric correction associated to the + /// flag. + #[cfg_attr(feature = "serde", serde(rename = "iono_corr_time"))] + pub iono_corr_time: GpsTimeSec, + /// GNSS reference time of the satellite correction associated to the flag. + #[cfg_attr(feature = "serde", serde(rename = "sat_corr_time"))] + pub sat_corr_time: GpsTimeSec, /// SSR Solution ID. #[cfg_attr(feature = "serde", serde(rename = "ssr_sol_id"))] pub ssr_sol_id: u8, @@ -1083,7 +1088,7 @@ pub mod msg_ssr_flag_high_level { } impl ConcreteMessage for MsgSsrFlagHighLevel { - const MESSAGE_TYPE: u16 = 3001; + const MESSAGE_TYPE: u16 = 3002; const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_HIGH_LEVEL"; } @@ -1129,6 +1134,7 @@ pub mod msg_ssr_flag_high_level { impl WireFormat for MsgSsrFlagHighLevel { const MIN_LEN: usize = ::MIN_LEN + + ::MIN_LEN + ::MIN_LEN + ::MIN_LEN + ::MIN_LEN @@ -1145,7 +1151,8 @@ pub mod msg_ssr_flag_high_level { + ::MIN_LEN; fn len(&self) -> usize { WireFormat::len(&self.obs_time) - + WireFormat::len(&self.corr_time) + + WireFormat::len(&self.iono_corr_time) + + WireFormat::len(&self.sat_corr_time) + WireFormat::len(&self.ssr_sol_id) + WireFormat::len(&self.tile_set_id) + WireFormat::len(&self.tile_id) @@ -1162,7 +1169,8 @@ pub mod msg_ssr_flag_high_level { } fn write(&self, buf: &mut B) { WireFormat::write(&self.obs_time, buf); - WireFormat::write(&self.corr_time, buf); + WireFormat::write(&self.iono_corr_time, buf); + WireFormat::write(&self.sat_corr_time, buf); WireFormat::write(&self.ssr_sol_id, buf); WireFormat::write(&self.tile_set_id, buf); WireFormat::write(&self.tile_id, buf); @@ -1179,6 +1187,660 @@ pub mod msg_ssr_flag_high_level { } fn parse_unchecked(buf: &mut B) -> Self { MsgSsrFlagHighLevel { + sender_id: None, + obs_time: WireFormat::parse_unchecked(buf), + iono_corr_time: WireFormat::parse_unchecked(buf), + sat_corr_time: WireFormat::parse_unchecked(buf), + ssr_sol_id: WireFormat::parse_unchecked(buf), + tile_set_id: WireFormat::parse_unchecked(buf), + tile_id: WireFormat::parse_unchecked(buf), + chain_id: WireFormat::parse_unchecked(buf), + use_gps_sat: WireFormat::parse_unchecked(buf), + use_gal_sat: WireFormat::parse_unchecked(buf), + use_bds_sat: WireFormat::parse_unchecked(buf), + use_qzss_sat: WireFormat::parse_unchecked(buf), + reserved: WireFormat::parse_unchecked(buf), + use_tropo_grid_points: WireFormat::parse_unchecked(buf), + use_iono_grid_points: WireFormat::parse_unchecked(buf), + use_iono_tile_sat_los: WireFormat::parse_unchecked(buf), + use_iono_grid_point_sat_los: WireFormat::parse_unchecked(buf), + } + } + } + + /// Use GPS satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseGpsSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseGpsSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseGpsSatellites::Nominal => f.write_str("Nominal"), + UseGpsSatellites::Warning => f.write_str("Warning"), + UseGpsSatellites::Alert => f.write_str("Alert"), + UseGpsSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseGpsSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseGpsSatellites::Nominal), + 1 => Ok(UseGpsSatellites::Warning), + 2 => Ok(UseGpsSatellites::Alert), + 3 => Ok(UseGpsSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use GAL satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseGalSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseGalSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseGalSatellites::Nominal => f.write_str("Nominal"), + UseGalSatellites::Warning => f.write_str("Warning"), + UseGalSatellites::Alert => f.write_str("Alert"), + UseGalSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseGalSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseGalSatellites::Nominal), + 1 => Ok(UseGalSatellites::Warning), + 2 => Ok(UseGalSatellites::Alert), + 3 => Ok(UseGalSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use BDS satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseBdsSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseBdsSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseBdsSatellites::Nominal => f.write_str("Nominal"), + UseBdsSatellites::Warning => f.write_str("Warning"), + UseBdsSatellites::Alert => f.write_str("Alert"), + UseBdsSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseBdsSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseBdsSatellites::Nominal), + 1 => Ok(UseBdsSatellites::Warning), + 2 => Ok(UseBdsSatellites::Alert), + 3 => Ok(UseBdsSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use QZSS satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseQzssSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseQzssSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseQzssSatellites::Nominal => f.write_str("Nominal"), + UseQzssSatellites::Warning => f.write_str("Warning"), + UseQzssSatellites::Alert => f.write_str("Alert"), + UseQzssSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseQzssSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseQzssSatellites::Nominal), + 1 => Ok(UseQzssSatellites::Warning), + 2 => Ok(UseQzssSatellites::Alert), + 3 => Ok(UseQzssSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use tropo grid points. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseTropoGridPoints { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseTropoGridPoints { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseTropoGridPoints::Nominal => f.write_str("Nominal"), + UseTropoGridPoints::Warning => f.write_str("Warning"), + UseTropoGridPoints::Alert => f.write_str("Alert"), + UseTropoGridPoints::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseTropoGridPoints { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseTropoGridPoints::Nominal), + 1 => Ok(UseTropoGridPoints::Warning), + 2 => Ok(UseTropoGridPoints::Alert), + 3 => Ok(UseTropoGridPoints::NotMonitored), + i => Err(i), + } + } + } + + /// Use iono grid points. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseIonoGridPoints { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseIonoGridPoints { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseIonoGridPoints::Nominal => f.write_str("Nominal"), + UseIonoGridPoints::Warning => f.write_str("Warning"), + UseIonoGridPoints::Alert => f.write_str("Alert"), + UseIonoGridPoints::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseIonoGridPoints { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseIonoGridPoints::Nominal), + 1 => Ok(UseIonoGridPoints::Warning), + 2 => Ok(UseIonoGridPoints::Alert), + 3 => Ok(UseIonoGridPoints::NotMonitored), + i => Err(i), + } + } + } + + /// Use iono tile satellite LoS. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseIonoTileSatelliteLoS { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseIonoTileSatelliteLoS { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseIonoTileSatelliteLoS::Nominal => f.write_str("Nominal"), + UseIonoTileSatelliteLoS::Warning => f.write_str("Warning"), + UseIonoTileSatelliteLoS::Alert => f.write_str("Alert"), + UseIonoTileSatelliteLoS::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseIonoTileSatelliteLoS { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseIonoTileSatelliteLoS::Nominal), + 1 => Ok(UseIonoTileSatelliteLoS::Warning), + 2 => Ok(UseIonoTileSatelliteLoS::Alert), + 3 => Ok(UseIonoTileSatelliteLoS::NotMonitored), + i => Err(i), + } + } + } + + /// Use iono grid point satellite LoS. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseIonoGridPointSatelliteLoS { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseIonoGridPointSatelliteLoS { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseIonoGridPointSatelliteLoS::Nominal => f.write_str("Nominal"), + UseIonoGridPointSatelliteLoS::Warning => f.write_str("Warning"), + UseIonoGridPointSatelliteLoS::Alert => f.write_str("Alert"), + UseIonoGridPointSatelliteLoS::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseIonoGridPointSatelliteLoS { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseIonoGridPointSatelliteLoS::Nominal), + 1 => Ok(UseIonoGridPointSatelliteLoS::Warning), + 2 => Ok(UseIonoGridPointSatelliteLoS::Alert), + 3 => Ok(UseIonoGridPointSatelliteLoS::NotMonitored), + i => Err(i), + } + } + } +} + +pub mod msg_ssr_flag_high_level_dep_a { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + + /// Deprecated + /// + /// Deprecated. + /// + #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Debug, PartialEq, Clone)] + pub struct MsgSsrFlagHighLevelDepA { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing, alias = "sender"))] + pub sender_id: Option, + /// GNSS reference time of the observation used to generate the flag. + #[cfg_attr(feature = "serde", serde(rename = "obs_time"))] + pub obs_time: GpsTimeSec, + /// GNSS reference time of the correction associated to the flag. + #[cfg_attr(feature = "serde", serde(rename = "corr_time"))] + pub corr_time: GpsTimeSec, + /// SSR Solution ID. + #[cfg_attr(feature = "serde", serde(rename = "ssr_sol_id"))] + pub ssr_sol_id: u8, + /// Unique identifier of the set this tile belongs to. + #[cfg_attr(feature = "serde", serde(rename = "tile_set_id"))] + pub tile_set_id: u16, + /// Unique identifier of this tile in the tile set. + #[cfg_attr(feature = "serde", serde(rename = "tile_id"))] + pub tile_id: u16, + /// Chain and type of flag. + #[cfg_attr(feature = "serde", serde(rename = "chain_id"))] + pub chain_id: u8, + /// Use GPS satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_gps_sat"))] + pub use_gps_sat: u8, + /// Use GAL satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_gal_sat"))] + pub use_gal_sat: u8, + /// Use BDS satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_bds_sat"))] + pub use_bds_sat: u8, + /// Use QZSS satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_qzss_sat"))] + pub use_qzss_sat: u8, + /// Reserved + #[cfg_attr(feature = "serde", serde(rename = "reserved"))] + pub reserved: [u8; 5], + /// Use tropo grid points. + #[cfg_attr(feature = "serde", serde(rename = "use_tropo_grid_points"))] + pub use_tropo_grid_points: u8, + /// Use iono grid points. + #[cfg_attr(feature = "serde", serde(rename = "use_iono_grid_points"))] + pub use_iono_grid_points: u8, + /// Use iono tile satellite LoS. + #[cfg_attr(feature = "serde", serde(rename = "use_iono_tile_sat_los"))] + pub use_iono_tile_sat_los: u8, + /// Use iono grid point satellite LoS. + #[cfg_attr(feature = "serde", serde(rename = "use_iono_grid_point_sat_los"))] + pub use_iono_grid_point_sat_los: u8, + } + + impl MsgSsrFlagHighLevelDepA { + /// Gets the [UseGpsSatellites][self::UseGpsSatellites] stored in the `use_gps_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseGpsSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseGpsSatellites` were added. + pub fn use_gps_satellites(&self) -> Result { + get_bit_range!(self.use_gps_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseGpsSatellites][UseGpsSatellites] of the `use_gps_sat` bitfield. + pub fn set_use_gps_satellites(&mut self, use_gps_satellites: UseGpsSatellites) { + set_bit_range!(&mut self.use_gps_sat, use_gps_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseGalSatellites][self::UseGalSatellites] stored in the `use_gal_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseGalSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseGalSatellites` were added. + pub fn use_gal_satellites(&self) -> Result { + get_bit_range!(self.use_gal_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseGalSatellites][UseGalSatellites] of the `use_gal_sat` bitfield. + pub fn set_use_gal_satellites(&mut self, use_gal_satellites: UseGalSatellites) { + set_bit_range!(&mut self.use_gal_sat, use_gal_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseBdsSatellites][self::UseBdsSatellites] stored in the `use_bds_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseBdsSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseBdsSatellites` were added. + pub fn use_bds_satellites(&self) -> Result { + get_bit_range!(self.use_bds_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseBdsSatellites][UseBdsSatellites] of the `use_bds_sat` bitfield. + pub fn set_use_bds_satellites(&mut self, use_bds_satellites: UseBdsSatellites) { + set_bit_range!(&mut self.use_bds_sat, use_bds_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseQzssSatellites][self::UseQzssSatellites] stored in the `use_qzss_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseQzssSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseQzssSatellites` were added. + pub fn use_qzss_satellites(&self) -> Result { + get_bit_range!(self.use_qzss_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseQzssSatellites][UseQzssSatellites] of the `use_qzss_sat` bitfield. + pub fn set_use_qzss_satellites(&mut self, use_qzss_satellites: UseQzssSatellites) { + set_bit_range!(&mut self.use_qzss_sat, use_qzss_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseTropoGridPoints][self::UseTropoGridPoints] stored in the `use_tropo_grid_points` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseTropoGridPoints` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseTropoGridPoints` were added. + pub fn use_tropo_grid_points(&self) -> Result { + get_bit_range!(self.use_tropo_grid_points, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseTropoGridPoints][UseTropoGridPoints] of the `use_tropo_grid_points` bitfield. + pub fn set_use_tropo_grid_points(&mut self, use_tropo_grid_points: UseTropoGridPoints) { + set_bit_range!( + &mut self.use_tropo_grid_points, + use_tropo_grid_points, + u8, + u8, + 2, + 0 + ); + } + + /// Gets the [UseIonoGridPoints][self::UseIonoGridPoints] stored in the `use_iono_grid_points` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseIonoGridPoints` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseIonoGridPoints` were added. + pub fn use_iono_grid_points(&self) -> Result { + get_bit_range!(self.use_iono_grid_points, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseIonoGridPoints][UseIonoGridPoints] of the `use_iono_grid_points` bitfield. + pub fn set_use_iono_grid_points(&mut self, use_iono_grid_points: UseIonoGridPoints) { + set_bit_range!( + &mut self.use_iono_grid_points, + use_iono_grid_points, + u8, + u8, + 2, + 0 + ); + } + + /// Gets the [UseIonoTileSatelliteLoS][self::UseIonoTileSatelliteLoS] stored in the `use_iono_tile_sat_los` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseIonoTileSatelliteLoS` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseIonoTileSatelliteLoS` were added. + pub fn use_iono_tile_satellite_lo_s(&self) -> Result { + get_bit_range!(self.use_iono_tile_sat_los, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseIonoTileSatelliteLoS][UseIonoTileSatelliteLoS] of the `use_iono_tile_sat_los` bitfield. + pub fn set_use_iono_tile_satellite_lo_s( + &mut self, + use_iono_tile_satellite_lo_s: UseIonoTileSatelliteLoS, + ) { + set_bit_range!( + &mut self.use_iono_tile_sat_los, + use_iono_tile_satellite_lo_s, + u8, + u8, + 2, + 0 + ); + } + + /// Gets the [UseIonoGridPointSatelliteLoS][self::UseIonoGridPointSatelliteLoS] stored in the `use_iono_grid_point_sat_los` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseIonoGridPointSatelliteLoS` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseIonoGridPointSatelliteLoS` were added. + pub fn use_iono_grid_point_satellite_lo_s( + &self, + ) -> Result { + get_bit_range!(self.use_iono_grid_point_sat_los, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseIonoGridPointSatelliteLoS][UseIonoGridPointSatelliteLoS] of the `use_iono_grid_point_sat_los` bitfield. + pub fn set_use_iono_grid_point_satellite_lo_s( + &mut self, + use_iono_grid_point_satellite_lo_s: UseIonoGridPointSatelliteLoS, + ) { + set_bit_range!( + &mut self.use_iono_grid_point_sat_los, + use_iono_grid_point_satellite_lo_s, + u8, + u8, + 2, + 0 + ); + } + } + + impl ConcreteMessage for MsgSsrFlagHighLevelDepA { + const MESSAGE_TYPE: u16 = 3001; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; + } + + impl SbpMessage for MsgSsrFlagHighLevelDepA { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> Option { + Some(::MESSAGE_TYPE) + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + fn is_valid(&self) -> bool { + true + } + fn into_valid_msg(self) -> Result { + Ok(self) + } + } + + impl FriendlyName for MsgSsrFlagHighLevelDepA { + fn friendly_name() -> &'static str { + "SSR FLAG HIGH LEVEL DEP A" + } + } + + impl TryFrom for MsgSsrFlagHighLevelDepA { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagHighLevelDepA(m) => Ok(m), + _ => Err(TryFromSbpError(msg)), + } + } + } + + impl WireFormat for MsgSsrFlagHighLevelDepA { + const MIN_LEN: usize = ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + <[u8; 5] as WireFormat>::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.obs_time) + + WireFormat::len(&self.corr_time) + + WireFormat::len(&self.ssr_sol_id) + + WireFormat::len(&self.tile_set_id) + + WireFormat::len(&self.tile_id) + + WireFormat::len(&self.chain_id) + + WireFormat::len(&self.use_gps_sat) + + WireFormat::len(&self.use_gal_sat) + + WireFormat::len(&self.use_bds_sat) + + WireFormat::len(&self.use_qzss_sat) + + WireFormat::len(&self.reserved) + + WireFormat::len(&self.use_tropo_grid_points) + + WireFormat::len(&self.use_iono_grid_points) + + WireFormat::len(&self.use_iono_tile_sat_los) + + WireFormat::len(&self.use_iono_grid_point_sat_los) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.obs_time, buf); + WireFormat::write(&self.corr_time, buf); + WireFormat::write(&self.ssr_sol_id, buf); + WireFormat::write(&self.tile_set_id, buf); + WireFormat::write(&self.tile_id, buf); + WireFormat::write(&self.chain_id, buf); + WireFormat::write(&self.use_gps_sat, buf); + WireFormat::write(&self.use_gal_sat, buf); + WireFormat::write(&self.use_bds_sat, buf); + WireFormat::write(&self.use_qzss_sat, buf); + WireFormat::write(&self.reserved, buf); + WireFormat::write(&self.use_tropo_grid_points, buf); + WireFormat::write(&self.use_iono_grid_points, buf); + WireFormat::write(&self.use_iono_tile_sat_los, buf); + WireFormat::write(&self.use_iono_grid_point_sat_los, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagHighLevelDepA { sender_id: None, obs_time: WireFormat::parse_unchecked(buf), corr_time: WireFormat::parse_unchecked(buf), diff --git a/rust/sbp/src/messages/mod.rs b/rust/sbp/src/messages/mod.rs index e4c86f0d22..754cca7f6d 100644 --- a/rust/sbp/src/messages/mod.rs +++ b/rust/sbp/src/messages/mod.rs @@ -81,6 +81,7 @@ use self::imu::msg_imu_comp::MsgImuComp; use self::imu::msg_imu_raw::MsgImuRaw; use self::integrity::msg_acknowledge::MsgAcknowledge; use self::integrity::msg_ssr_flag_high_level::MsgSsrFlagHighLevel; +use self::integrity::msg_ssr_flag_high_level_dep_a::MsgSsrFlagHighLevelDepA; use self::integrity::msg_ssr_flag_iono_grid_point_sat_los::MsgSsrFlagIonoGridPointSatLos; use self::integrity::msg_ssr_flag_iono_grid_points::MsgSsrFlagIonoGridPoints; use self::integrity::msg_ssr_flag_iono_tile_sat_los::MsgSsrFlagIonoTileSatLos; @@ -769,6 +770,8 @@ pub enum Sbp { MsgWheeltick(MsgWheeltick), /// Compensated IMU data MsgImuComp(MsgImuComp), + /// Deprecated + MsgSsrFlagHighLevelDepA(MsgSsrFlagHighLevelDepA), /// High level integrity flags MsgSsrFlagHighLevel(MsgSsrFlagHighLevel), /// List of satellites which are faulty, per constellation @@ -1477,6 +1480,10 @@ impl<'de> serde::Deserialize<'de> for Sbp { Some(MsgImuComp::MESSAGE_TYPE) => { serde_json::from_value::(value).map(Sbp::MsgImuComp) } + Some(MsgSsrFlagHighLevelDepA::MESSAGE_TYPE) => { + serde_json::from_value::(value) + .map(Sbp::MsgSsrFlagHighLevelDepA) + } Some(MsgSsrFlagHighLevel::MESSAGE_TYPE) => { serde_json::from_value::(value).map(Sbp::MsgSsrFlagHighLevel) } @@ -2194,6 +2201,9 @@ impl Sbp { MsgOdometry::MESSAGE_TYPE => MsgOdometry::parse(&mut payload).map(Sbp::MsgOdometry), MsgWheeltick::MESSAGE_TYPE => MsgWheeltick::parse(&mut payload).map(Sbp::MsgWheeltick), MsgImuComp::MESSAGE_TYPE => MsgImuComp::parse(&mut payload).map(Sbp::MsgImuComp), + MsgSsrFlagHighLevelDepA::MESSAGE_TYPE => { + MsgSsrFlagHighLevelDepA::parse(&mut payload).map(Sbp::MsgSsrFlagHighLevelDepA) + } MsgSsrFlagHighLevel::MESSAGE_TYPE => { MsgSsrFlagHighLevel::parse(&mut payload).map(Sbp::MsgSsrFlagHighLevel) } @@ -2551,6 +2561,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.message_name(), Sbp::MsgWheeltick(msg) => msg.message_name(), Sbp::MsgImuComp(msg) => msg.message_name(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.message_name(), Sbp::MsgSsrFlagHighLevel(msg) => msg.message_name(), Sbp::MsgSsrFlagSatellites(msg) => msg.message_name(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.message_name(), @@ -2797,6 +2808,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.message_type(), Sbp::MsgWheeltick(msg) => msg.message_type(), Sbp::MsgImuComp(msg) => msg.message_type(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.message_type(), Sbp::MsgSsrFlagHighLevel(msg) => msg.message_type(), Sbp::MsgSsrFlagSatellites(msg) => msg.message_type(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.message_type(), @@ -3043,6 +3055,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.sender_id(), Sbp::MsgWheeltick(msg) => msg.sender_id(), Sbp::MsgImuComp(msg) => msg.sender_id(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.sender_id(), Sbp::MsgSsrFlagHighLevel(msg) => msg.sender_id(), Sbp::MsgSsrFlagSatellites(msg) => msg.sender_id(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.sender_id(), @@ -3289,6 +3302,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.set_sender_id(new_id), Sbp::MsgWheeltick(msg) => msg.set_sender_id(new_id), Sbp::MsgImuComp(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrFlagHighLevel(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrFlagSatellites(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.set_sender_id(new_id), @@ -3535,6 +3549,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.encoded_len(), Sbp::MsgWheeltick(msg) => msg.encoded_len(), Sbp::MsgImuComp(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.encoded_len(), Sbp::MsgSsrFlagHighLevel(msg) => msg.encoded_len(), Sbp::MsgSsrFlagSatellites(msg) => msg.encoded_len(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.encoded_len(), @@ -3784,6 +3799,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.gps_time(), Sbp::MsgWheeltick(msg) => msg.gps_time(), Sbp::MsgImuComp(msg) => msg.gps_time(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.gps_time(), Sbp::MsgSsrFlagHighLevel(msg) => msg.gps_time(), Sbp::MsgSsrFlagSatellites(msg) => msg.gps_time(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.gps_time(), @@ -4030,6 +4046,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.friendly_name(), Sbp::MsgWheeltick(msg) => msg.friendly_name(), Sbp::MsgImuComp(msg) => msg.friendly_name(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.friendly_name(), Sbp::MsgSsrFlagHighLevel(msg) => msg.friendly_name(), Sbp::MsgSsrFlagSatellites(msg) => msg.friendly_name(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.friendly_name(), @@ -4276,6 +4293,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.is_valid(), Sbp::MsgWheeltick(msg) => msg.is_valid(), Sbp::MsgImuComp(msg) => msg.is_valid(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.is_valid(), Sbp::MsgSsrFlagHighLevel(msg) => msg.is_valid(), Sbp::MsgSsrFlagSatellites(msg) => msg.is_valid(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.is_valid(), @@ -4583,6 +4601,9 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => Ok(Sbp::MsgOdometry(msg.into_valid_msg()?)), Sbp::MsgWheeltick(msg) => Ok(Sbp::MsgWheeltick(msg.into_valid_msg()?)), Sbp::MsgImuComp(msg) => Ok(Sbp::MsgImuComp(msg.into_valid_msg()?)), + Sbp::MsgSsrFlagHighLevelDepA(msg) => { + Ok(Sbp::MsgSsrFlagHighLevelDepA(msg.into_valid_msg()?)) + } Sbp::MsgSsrFlagHighLevel(msg) => Ok(Sbp::MsgSsrFlagHighLevel(msg.into_valid_msg()?)), Sbp::MsgSsrFlagSatellites(msg) => Ok(Sbp::MsgSsrFlagSatellites(msg.into_valid_msg()?)), Sbp::MsgSsrFlagTropoGridPoints(msg) => { @@ -4878,6 +4899,7 @@ impl WireFormat for Sbp { Sbp::MsgOdometry(msg) => WireFormat::write(msg, buf), Sbp::MsgWheeltick(msg) => WireFormat::write(msg, buf), Sbp::MsgImuComp(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagHighLevelDepA(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrFlagHighLevel(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrFlagSatellites(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrFlagTropoGridPoints(msg) => WireFormat::write(msg, buf), @@ -5124,6 +5146,7 @@ impl WireFormat for Sbp { Sbp::MsgOdometry(msg) => WireFormat::len(msg), Sbp::MsgWheeltick(msg) => WireFormat::len(msg), Sbp::MsgImuComp(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagHighLevelDepA(msg) => WireFormat::len(msg), Sbp::MsgSsrFlagHighLevel(msg) => WireFormat::len(msg), Sbp::MsgSsrFlagSatellites(msg) => WireFormat::len(msg), Sbp::MsgSsrFlagTropoGridPoints(msg) => WireFormat::len(msg), @@ -6314,6 +6337,12 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgSsrFlagHighLevelDepA) -> Self { + Sbp::MsgSsrFlagHighLevelDepA(msg) + } +} + impl From for Sbp { fn from(msg: MsgSsrFlagHighLevel) -> Self { Sbp::MsgSsrFlagHighLevel(msg) diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs index cbccb955c2..9b34d06432 100644 --- a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs @@ -22,8 +22,8 @@ use crate::*; fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { { let mut payload = Cursor::new(vec![ - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, - 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, + 20, 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, ]); // Test the round trip payload parsing @@ -37,8 +37,8 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { sbp::messages::Sbp::MsgSsrFlagHighLevel(msg) => { let msg_type = msg.message_type().unwrap(); assert_eq!( - msg_type, 3001, - "Incorrect message type, expected 3001, is {msg_type}" + msg_type, 3002, + "Incorrect message type, expected 3002, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( @@ -51,14 +51,14 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { msg.chain_id ); assert_eq!( - msg.corr_time.tow, 360, - "incorrect value for corr_time.tow, expected 360, is {}", - msg.corr_time.tow + msg.iono_corr_time.tow, 365, + "incorrect value for iono_corr_time.tow, expected 365, is {}", + msg.iono_corr_time.tow ); assert_eq!( - msg.corr_time.wn, 6, - "incorrect value for corr_time.wn, expected 6, is {}", - msg.corr_time.wn + msg.iono_corr_time.wn, 6, + "incorrect value for iono_corr_time.wn, expected 6, is {}", + msg.iono_corr_time.wn ); assert_eq!( msg.obs_time.tow, 180, @@ -95,6 +95,16 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect value for reserved[4], expected 0, is {}", msg.reserved[4] ); + assert_eq!( + msg.sat_corr_time.tow, 360, + "incorrect value for sat_corr_time.tow, expected 360, is {}", + msg.sat_corr_time.tow + ); + assert_eq!( + msg.sat_corr_time.wn, 6, + "incorrect value for sat_corr_time.wn, expected 6, is {}", + msg.sat_corr_time.wn + ); assert_eq!( msg.ssr_sol_id, 10, "incorrect value for ssr_sol_id, expected 10, is {}", @@ -169,7 +179,7 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { #[cfg(feature = "json")] fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { { - let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}"#.as_bytes(); + let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "iono_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3002, "sender": 66, "length": 37, "payload": "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 61105}"#.as_bytes(); let sbp_msg = { // JSON to SBP message from payload @@ -193,8 +203,8 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { sbp::messages::Sbp::MsgSsrFlagHighLevel(msg) => { let msg_type = msg.message_type().unwrap(); assert_eq!( - msg_type, 3001, - "Incorrect message type, expected 3001, is {msg_type}" + msg_type, 3002, + "Incorrect message type, expected 3002, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( @@ -207,14 +217,14 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { msg.chain_id ); assert_eq!( - msg.corr_time.tow, 360, - "incorrect value for corr_time.tow, expected 360, is {}", - msg.corr_time.tow + msg.iono_corr_time.tow, 365, + "incorrect value for iono_corr_time.tow, expected 365, is {}", + msg.iono_corr_time.tow ); assert_eq!( - msg.corr_time.wn, 6, - "incorrect value for corr_time.wn, expected 6, is {}", - msg.corr_time.wn + msg.iono_corr_time.wn, 6, + "incorrect value for iono_corr_time.wn, expected 6, is {}", + msg.iono_corr_time.wn ); assert_eq!( msg.obs_time.tow, 180, @@ -251,6 +261,16 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect value for reserved[4], expected 0, is {}", msg.reserved[4] ); + assert_eq!( + msg.sat_corr_time.tow, 360, + "incorrect value for sat_corr_time.tow, expected 360, is {}", + msg.sat_corr_time.tow + ); + assert_eq!( + msg.sat_corr_time.wn, 6, + "incorrect value for sat_corr_time.wn, expected 6, is {}", + msg.sat_corr_time.wn + ); assert_eq!( msg.ssr_sol_id, 10, "incorrect value for ssr_sol_id, expected 10, is {}", @@ -325,8 +345,8 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { { let mut payload = Cursor::new(vec![ - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, - 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, + 20, 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, ]); // Construct sbp message @@ -357,8 +377,8 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { sbp::messages::Sbp::MsgSsrFlagHighLevel(msg) => { let msg_type = msg.message_type().unwrap(); assert_eq!( - msg_type, 3001, - "Incorrect message type, expected 3001, is {msg_type}" + msg_type, 3002, + "Incorrect message type, expected 3002, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( @@ -371,14 +391,14 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { msg.chain_id ); assert_eq!( - msg.corr_time.tow, 360, - "incorrect value for corr_time.tow, expected 360, is {}", - msg.corr_time.tow + msg.iono_corr_time.tow, 365, + "incorrect value for iono_corr_time.tow, expected 365, is {}", + msg.iono_corr_time.tow ); assert_eq!( - msg.corr_time.wn, 6, - "incorrect value for corr_time.wn, expected 6, is {}", - msg.corr_time.wn + msg.iono_corr_time.wn, 6, + "incorrect value for iono_corr_time.wn, expected 6, is {}", + msg.iono_corr_time.wn ); assert_eq!( msg.obs_time.tow, 180, @@ -415,6 +435,16 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect value for reserved[4], expected 0, is {}", msg.reserved[4] ); + assert_eq!( + msg.sat_corr_time.tow, 360, + "incorrect value for sat_corr_time.tow, expected 360, is {}", + msg.sat_corr_time.tow + ); + assert_eq!( + msg.sat_corr_time.wn, 6, + "incorrect value for sat_corr_time.wn, expected 6, is {}", + msg.sat_corr_time.wn + ); assert_eq!( msg.ssr_sol_id, 10, "incorrect value for ssr_sol_id, expected 10, is {}", diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs new file mode 100644 index 0000000000..4d47bb0577 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs @@ -0,0 +1,481 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by generate.py. Do not modify by hand! + +use crate::*; + +/// Tests [`sbp::iter_messages`], from payload into SBP messages +/// +/// Asserts: +/// - SBP fields equates to that of the field +/// - Payload is identical +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { + { + let mut payload = Cursor::new(vec![ + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagHighLevelDepA(msg) => { + let msg_type = msg.message_type().unwrap(); + assert_eq!( + msg_type, 3001, + "Incorrect message type, expected 3001, is {msg_type}" + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {sender_id}" + ); + assert_eq!( + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id + ); + assert_eq!( + msg.corr_time.tow, 360, + "incorrect value for corr_time.tow, expected 360, is {}", + msg.corr_time.tow + ); + assert_eq!( + msg.corr_time.wn, 6, + "incorrect value for corr_time.wn, expected 6, is {}", + msg.corr_time.wn + ); + assert_eq!( + msg.obs_time.tow, 180, + "incorrect value for obs_time.tow, expected 180, is {}", + msg.obs_time.tow + ); + assert_eq!( + msg.obs_time.wn, 3, + "incorrect value for obs_time.wn, expected 3, is {}", + msg.obs_time.wn + ); + assert_eq!( + msg.reserved[0], 0, + "incorrect value for reserved[0], expected 0, is {}", + msg.reserved[0] + ); + assert_eq!( + msg.reserved[1], 0, + "incorrect value for reserved[1], expected 0, is {}", + msg.reserved[1] + ); + assert_eq!( + msg.reserved[2], 0, + "incorrect value for reserved[2], expected 0, is {}", + msg.reserved[2] + ); + assert_eq!( + msg.reserved[3], 0, + "incorrect value for reserved[3], expected 0, is {}", + msg.reserved[3] + ); + assert_eq!( + msg.reserved[4], 0, + "incorrect value for reserved[4], expected 0, is {}", + msg.reserved[4] + ); + assert_eq!( + msg.ssr_sol_id, 10, + "incorrect value for ssr_sol_id, expected 10, is {}", + msg.ssr_sol_id + ); + assert_eq!( + msg.tile_id, 30, + "incorrect value for tile_id, expected 30, is {}", + msg.tile_id + ); + assert_eq!( + msg.tile_set_id, 20, + "incorrect value for tile_set_id, expected 20, is {}", + msg.tile_set_id + ); + assert_eq!( + msg.use_bds_sat, 3, + "incorrect value for use_bds_sat, expected 3, is {}", + msg.use_bds_sat + ); + assert_eq!( + msg.use_gal_sat, 2, + "incorrect value for use_gal_sat, expected 2, is {}", + msg.use_gal_sat + ); + assert_eq!( + msg.use_gps_sat, 1, + "incorrect value for use_gps_sat, expected 1, is {}", + msg.use_gps_sat + ); + assert_eq!( + msg.use_iono_grid_point_sat_los, 8, + "incorrect value for use_iono_grid_point_sat_los, expected 8, is {}", + msg.use_iono_grid_point_sat_los + ); + assert_eq!( + msg.use_iono_grid_points, 6, + "incorrect value for use_iono_grid_points, expected 6, is {}", + msg.use_iono_grid_points + ); + assert_eq!( + msg.use_iono_tile_sat_los, 7, + "incorrect value for use_iono_tile_sat_los, expected 7, is {}", + msg.use_iono_tile_sat_los + ); + assert_eq!( + msg.use_qzss_sat, 4, + "incorrect value for use_qzss_sat, expected 4, is {}", + msg.use_qzss_sat + ); + assert_eq!( + msg.use_tropo_grid_points, 5, + "incorrect value for use_tropo_grid_points, expected 5, is {}", + msg.use_tropo_grid_points + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagHighLevelDepA"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} + +/// Tests [`sbp::json::iter_messages`] for JSON payload -> SBP message +/// and [`sbp::json::iter_messages_from_fields`] for JSON fields -> SBP message. +/// +/// Asserts: +/// - SBP message constructed via payload is identical to from fields +/// - SBP fields equates to that of the field +/// - Payload is identical +#[test] +#[cfg(feature = "json")] +fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { + { + let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}"#.as_bytes(); + + let sbp_msg = { + // JSON to SBP message from payload + let mut iter = json2sbp_iter_msg(json_input); + let from_payload = iter + .next() + .expect("no message found") + .expect("failed to parse message"); + + // JSON to SBP message from fields + let mut iter = iter_messages_from_fields(json_input); + let from_fields = iter + .next() + .expect("no message found") + .expect("failed to parse message"); + + assert_eq!(from_fields, from_payload); + from_fields + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagHighLevelDepA(msg) => { + let msg_type = msg.message_type().unwrap(); + assert_eq!( + msg_type, 3001, + "Incorrect message type, expected 3001, is {msg_type}" + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {sender_id}" + ); + assert_eq!( + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id + ); + assert_eq!( + msg.corr_time.tow, 360, + "incorrect value for corr_time.tow, expected 360, is {}", + msg.corr_time.tow + ); + assert_eq!( + msg.corr_time.wn, 6, + "incorrect value for corr_time.wn, expected 6, is {}", + msg.corr_time.wn + ); + assert_eq!( + msg.obs_time.tow, 180, + "incorrect value for obs_time.tow, expected 180, is {}", + msg.obs_time.tow + ); + assert_eq!( + msg.obs_time.wn, 3, + "incorrect value for obs_time.wn, expected 3, is {}", + msg.obs_time.wn + ); + assert_eq!( + msg.reserved[0], 0, + "incorrect value for reserved[0], expected 0, is {}", + msg.reserved[0] + ); + assert_eq!( + msg.reserved[1], 0, + "incorrect value for reserved[1], expected 0, is {}", + msg.reserved[1] + ); + assert_eq!( + msg.reserved[2], 0, + "incorrect value for reserved[2], expected 0, is {}", + msg.reserved[2] + ); + assert_eq!( + msg.reserved[3], 0, + "incorrect value for reserved[3], expected 0, is {}", + msg.reserved[3] + ); + assert_eq!( + msg.reserved[4], 0, + "incorrect value for reserved[4], expected 0, is {}", + msg.reserved[4] + ); + assert_eq!( + msg.ssr_sol_id, 10, + "incorrect value for ssr_sol_id, expected 10, is {}", + msg.ssr_sol_id + ); + assert_eq!( + msg.tile_id, 30, + "incorrect value for tile_id, expected 30, is {}", + msg.tile_id + ); + assert_eq!( + msg.tile_set_id, 20, + "incorrect value for tile_set_id, expected 20, is {}", + msg.tile_set_id + ); + assert_eq!( + msg.use_bds_sat, 3, + "incorrect value for use_bds_sat, expected 3, is {}", + msg.use_bds_sat + ); + assert_eq!( + msg.use_gal_sat, 2, + "incorrect value for use_gal_sat, expected 2, is {}", + msg.use_gal_sat + ); + assert_eq!( + msg.use_gps_sat, 1, + "incorrect value for use_gps_sat, expected 1, is {}", + msg.use_gps_sat + ); + assert_eq!( + msg.use_iono_grid_point_sat_los, 8, + "incorrect value for use_iono_grid_point_sat_los, expected 8, is {}", + msg.use_iono_grid_point_sat_los + ); + assert_eq!( + msg.use_iono_grid_points, 6, + "incorrect value for use_iono_grid_points, expected 6, is {}", + msg.use_iono_grid_points + ); + assert_eq!( + msg.use_iono_tile_sat_los, 7, + "incorrect value for use_iono_tile_sat_los, expected 7, is {}", + msg.use_iono_tile_sat_los + ); + assert_eq!( + msg.use_qzss_sat, 4, + "incorrect value for use_qzss_sat, expected 4, is {}", + msg.use_qzss_sat + ); + assert_eq!( + msg.use_tropo_grid_points, 5, + "incorrect value for use_tropo_grid_points, expected 5, is {}", + msg.use_tropo_grid_points + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagHighLevelDepA"), + }; + } +} + +/// Tests [`sbp::json::JsonEncoder`] for roundtrip SBP message -> JSON +/// +/// Assumes: +/// - [`self::test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a`] passes +/// +/// Asserts: +/// - SBP fields equates to that of the field +/// - Payload is identical +#[test] +#[cfg(feature = "json")] +fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { + { + let mut payload = Cursor::new(vec![ + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + ]); + + // Construct sbp message + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + + let mut json_buffer = vec![]; + // Populate json buffer, CompactFormatter + sbp::json::JsonEncoder::new(&mut json_buffer, sbp::json::CompactFormatter {}) + .send(&sbp_msg) + .unwrap(); + + // Reconstruct Sbp message from json fields, roundtrip + let sbp_msg = sbp::messages::Sbp::MsgSsrFlagHighLevelDepA( + serde_json::from_str( + std::str::from_utf8(json_buffer.as_slice()) + .unwrap() + .to_string() + .as_str(), + ) + .unwrap(), + ); + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagHighLevelDepA(msg) => { + let msg_type = msg.message_type().unwrap(); + assert_eq!( + msg_type, 3001, + "Incorrect message type, expected 3001, is {msg_type}" + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {sender_id}" + ); + assert_eq!( + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id + ); + assert_eq!( + msg.corr_time.tow, 360, + "incorrect value for corr_time.tow, expected 360, is {}", + msg.corr_time.tow + ); + assert_eq!( + msg.corr_time.wn, 6, + "incorrect value for corr_time.wn, expected 6, is {}", + msg.corr_time.wn + ); + assert_eq!( + msg.obs_time.tow, 180, + "incorrect value for obs_time.tow, expected 180, is {}", + msg.obs_time.tow + ); + assert_eq!( + msg.obs_time.wn, 3, + "incorrect value for obs_time.wn, expected 3, is {}", + msg.obs_time.wn + ); + assert_eq!( + msg.reserved[0], 0, + "incorrect value for reserved[0], expected 0, is {}", + msg.reserved[0] + ); + assert_eq!( + msg.reserved[1], 0, + "incorrect value for reserved[1], expected 0, is {}", + msg.reserved[1] + ); + assert_eq!( + msg.reserved[2], 0, + "incorrect value for reserved[2], expected 0, is {}", + msg.reserved[2] + ); + assert_eq!( + msg.reserved[3], 0, + "incorrect value for reserved[3], expected 0, is {}", + msg.reserved[3] + ); + assert_eq!( + msg.reserved[4], 0, + "incorrect value for reserved[4], expected 0, is {}", + msg.reserved[4] + ); + assert_eq!( + msg.ssr_sol_id, 10, + "incorrect value for ssr_sol_id, expected 10, is {}", + msg.ssr_sol_id + ); + assert_eq!( + msg.tile_id, 30, + "incorrect value for tile_id, expected 30, is {}", + msg.tile_id + ); + assert_eq!( + msg.tile_set_id, 20, + "incorrect value for tile_set_id, expected 20, is {}", + msg.tile_set_id + ); + assert_eq!( + msg.use_bds_sat, 3, + "incorrect value for use_bds_sat, expected 3, is {}", + msg.use_bds_sat + ); + assert_eq!( + msg.use_gal_sat, 2, + "incorrect value for use_gal_sat, expected 2, is {}", + msg.use_gal_sat + ); + assert_eq!( + msg.use_gps_sat, 1, + "incorrect value for use_gps_sat, expected 1, is {}", + msg.use_gps_sat + ); + assert_eq!( + msg.use_iono_grid_point_sat_los, 8, + "incorrect value for use_iono_grid_point_sat_los, expected 8, is {}", + msg.use_iono_grid_point_sat_los + ); + assert_eq!( + msg.use_iono_grid_points, 6, + "incorrect value for use_iono_grid_points, expected 6, is {}", + msg.use_iono_grid_points + ); + assert_eq!( + msg.use_iono_tile_sat_los, 7, + "incorrect value for use_iono_tile_sat_los, expected 7, is {}", + msg.use_iono_tile_sat_los + ); + assert_eq!( + msg.use_qzss_sat, 4, + "incorrect value for use_qzss_sat, expected 4, is {}", + msg.use_qzss_sat + ); + assert_eq!( + msg.use_tropo_grid_points, 5, + "incorrect value for use_tropo_grid_points, expected 5, is {}", + msg.use_tropo_grid_points + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagHighLevelDepA"), + }; + + // Check payload is still identical + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/main.rs b/rust/sbp/tests/integration/main.rs index db3f62f8a8..9d03f17798 100644 --- a/rust/sbp/tests/integration/main.rs +++ b/rust/sbp/tests/integration/main.rs @@ -48,6 +48,7 @@ mod auto_check_sbp_imu_msg_imu_comp; mod auto_check_sbp_imu_msg_imu_raw; mod auto_check_sbp_integrity_msg_acknowledge; mod auto_check_sbp_integrity_msg_ssr_flag_high_level; +mod auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a; mod auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los; mod auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points; mod auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los; diff --git a/sbpjson/elm/SbpJson.elm b/sbpjson/elm/SbpJson.elm index 17b4fc6346..9ebcdccd1c 100644 --- a/sbpjson/elm/SbpJson.elm +++ b/sbpjson/elm/SbpJson.elm @@ -2855,8 +2855,9 @@ group. -} type alias MsgSsrFlagHighLevel = { chainID : Int - , corrTime : GpsTimeSEC + , ionoCorrTime : GpsTimeSEC , obsTime : GpsTimeSEC + , satCorrTime : GpsTimeSEC , ssrSolID : Int , tileID : Int , tileSetID : Int @@ -7279,8 +7280,9 @@ msgSsrFlagHighLevel : Jdec.Decoder MsgSsrFlagHighLevel msgSsrFlagHighLevel = Jpipe.decode MsgSsrFlagHighLevel |> Jpipe.required "chain_id" Jdec.int - |> Jpipe.required "corr_time" gpsTimeSEC + |> Jpipe.required "iono_corr_time" gpsTimeSEC |> Jpipe.required "obs_time" gpsTimeSEC + |> Jpipe.required "sat_corr_time" gpsTimeSEC |> Jpipe.required "ssr_sol_id" Jdec.int |> Jpipe.required "tile_id" Jdec.int |> Jpipe.required "tile_set_id" Jdec.int @@ -7297,8 +7299,9 @@ encodeMsgSsrFlagHighLevel : MsgSsrFlagHighLevel -> Jenc.Value encodeMsgSsrFlagHighLevel x = Jenc.object [ ("chain_id", Jenc.int x.chainID) - , ("corr_time", encodeGpsTimeSEC x.corrTime) + , ("iono_corr_time", encodeGpsTimeSEC x.ionoCorrTime) , ("obs_time", encodeGpsTimeSEC x.obsTime) + , ("sat_corr_time", encodeGpsTimeSEC x.satCorrTime) , ("ssr_sol_id", Jenc.int x.ssrSolID) , ("tile_id", Jenc.int x.tileID) , ("tile_set_id", Jenc.int x.tileSetID) diff --git a/sbpjson/javascript/SbpJson.js b/sbpjson/javascript/SbpJson.js index 13702ffaca..f690e07216 100644 --- a/sbpjson/javascript/SbpJson.js +++ b/sbpjson/javascript/SbpJson.js @@ -3255,8 +3255,9 @@ const typeMap = { ], "any"), "MsgSsrFlagHighLevel": o([ { json: "chain_id", js: "chain_id", typ: 0 }, - { json: "corr_time", js: "corr_time", typ: r("GpsTimeSEC") }, + { json: "iono_corr_time", js: "iono_corr_time", typ: r("GpsTimeSEC") }, { json: "obs_time", js: "obs_time", typ: r("GpsTimeSEC") }, + { json: "sat_corr_time", js: "sat_corr_time", typ: r("GpsTimeSEC") }, { json: "ssr_sol_id", js: "ssr_sol_id", typ: 0 }, { json: "tile_id", js: "tile_id", typ: 0 }, { json: "tile_set_id", js: "tile_set_id", typ: 0 }, diff --git a/sbpjson/typescript/SbpJson.ts b/sbpjson/typescript/SbpJson.ts index 21d23c70d5..4c4f4dd809 100644 --- a/sbpjson/typescript/SbpJson.ts +++ b/sbpjson/typescript/SbpJson.ts @@ -2446,8 +2446,9 @@ export interface CodePhaseBiasesSatSig { */ export interface MsgSsrFlagHighLevel { chain_id: number; - corr_time: GpsTimeSEC; + iono_corr_time: GpsTimeSEC; obs_time: GpsTimeSEC; + sat_corr_time: GpsTimeSEC; ssr_sol_id: number; tile_id: number; tile_set_id: number; @@ -6365,8 +6366,9 @@ const typeMap: any = { ], "any"), "MsgSsrFlagHighLevel": o([ { json: "chain_id", js: "chain_id", typ: 0 }, - { json: "corr_time", js: "corr_time", typ: r("GpsTimeSEC") }, + { json: "iono_corr_time", js: "iono_corr_time", typ: r("GpsTimeSEC") }, { json: "obs_time", js: "obs_time", typ: r("GpsTimeSEC") }, + { json: "sat_corr_time", js: "sat_corr_time", typ: r("GpsTimeSEC") }, { json: "ssr_sol_id", js: "ssr_sol_id", typ: 0 }, { json: "tile_id", js: "tile_id", typ: 0 }, { json: "tile_set_id", js: "tile_set_id", typ: 0 }, diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml index 699affdfcf..16710efd96 100644 --- a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml @@ -1,46 +1,49 @@ description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagHighLevel -generated_on: 2022-04-21 # manually generated +generated_on: 2025-07-09 # manually generated package: sbp.integrity tests: - -- msg: - fields: - obs_time: - tow: 180 - wn: 3 - corr_time: - tow: 360 - wn: 6 - ssr_sol_id: 10 - tile_set_id: 20 - tile_id: 30 - chain_id: 40 - use_gps_sat: 1 - use_gal_sat: 2 - use_bds_sat: 3 - use_qzss_sat: 4 - reserved: - - 0 - - 0 - - 0 - - 0 - - 0 - use_tropo_grid_points: 5 - use_iono_grid_points: 6 - use_iono_tile_sat_los: 7 - use_iono_grid_point_sat_los: 8 - module: sbp.integrity - name: MsgSsrFlagHighLevel - msg_type: '3001' - raw_json: '{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, - "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], - "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, - "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}' - raw_packet: VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD - sbp: - preamble: '0x55' - msg_type: '0x0BB9' - sender: '0x0042' - length: 31 - payload: tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA== - crc: '0x0369' + - msg: + fields: + obs_time: + tow: 180 + wn: 3 + sat_corr_time: + tow: 360 + wn: 6 + iono_corr_time: + tow: 365 + wn: 6 + ssr_sol_id: 10 + tile_set_id: 20 + tile_id: 30 + chain_id: 40 + use_gps_sat: 1 + use_gal_sat: 2 + use_bds_sat: 3 + use_qzss_sat: 4 + reserved: + - 0 + - 0 + - 0 + - 0 + - 0 + use_tropo_grid_points: 5 + use_iono_grid_points: 6 + use_iono_tile_sat_los: 7 + use_iono_grid_point_sat_los: 8 + module: sbp.integrity + name: MsgSsrFlagHighLevel + msg_type: "3002" + raw_json: + '{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "iono_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, + "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], + "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, + "preamble": 85, "msg_type": 3002, "sender": 66, "length": 37, "payload": "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 61105}' + raw_packet: VboLQgAltAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCLHu + sbp: + preamble: "0x55" + msg_type: "0x0BBA" + sender: "0x0042" + length: 37 + payload: tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA== + crc: "0xEEB1" diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml new file mode 100644 index 0000000000..91e5105370 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml @@ -0,0 +1,46 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagHighLevelDepA +generated_on: 2025-07-09 # manually generated +package: sbp.integrity +tests: + - msg: + fields: + obs_time: + tow: 180 + wn: 3 + corr_time: + tow: 360 + wn: 6 + ssr_sol_id: 10 + tile_set_id: 20 + tile_id: 30 + chain_id: 40 + use_gps_sat: 1 + use_gal_sat: 2 + use_bds_sat: 3 + use_qzss_sat: 4 + reserved: + - 0 + - 0 + - 0 + - 0 + - 0 + use_tropo_grid_points: 5 + use_iono_grid_points: 6 + use_iono_tile_sat_los: 7 + use_iono_grid_point_sat_los: 8 + module: sbp.integrity + name: MsgSsrFlagHighLevelDepA + msg_type: "3001" + raw_json: + '{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, + "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], + "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, + "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}' + raw_packet: VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD + sbp: + preamble: "0x55" + msg_type: "0x0BB9" + sender: "0x0042" + length: 31 + payload: tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA== + crc: "0x0369" From 3f56da9c4ba4f0d9a0a254df5629d26df26f59f5 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 11:26:51 +0200 Subject: [PATCH 04/11] update java workflow --- .github/workflows/java.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/java.yaml b/.github/workflows/java.yaml index 89bc60ae37..d394555ad3 100644 --- a/.github/workflows/java.yaml +++ b/.github/workflows/java.yaml @@ -15,6 +15,7 @@ jobs: tests-java-1_8: name: Test runs-on: ubuntu-24.04 + container: ubuntu:20.04 steps: - uses: actions/checkout@v4 - uses: gradle/gradle-build-action@v3 From b5743479f19f618581e185559847f31a4f7f3d51 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 13:17:39 +0200 Subject: [PATCH 05/11] Test --- .github/workflows/java.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/java.yaml b/.github/workflows/java.yaml index d394555ad3..607ef526da 100644 --- a/.github/workflows/java.yaml +++ b/.github/workflows/java.yaml @@ -18,6 +18,10 @@ jobs: container: ubuntu:20.04 steps: - uses: actions/checkout@v4 + - uses: actions/setup-java@v4.7.1 + with: + java-version: "11" + distribution: "temurin" - uses: gradle/gradle-build-action@v3 with: gradle-version: 7.1.1 From 79b819511bf76d53f1b6ec40954e0a19aba756ea Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 13:19:54 +0200 Subject: [PATCH 06/11] Add unzip --- .github/workflows/java.yaml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/java.yaml b/.github/workflows/java.yaml index 607ef526da..07c2a0a4ab 100644 --- a/.github/workflows/java.yaml +++ b/.github/workflows/java.yaml @@ -22,6 +22,11 @@ jobs: with: java-version: "11" distribution: "temurin" + - name: Update apt and install unzip + run: | + apt-get update + apt-get install -y unzip + shell: bash - uses: gradle/gradle-build-action@v3 with: gradle-version: 7.1.1 From ac25e21624a7bf1a5bd3442c8c876452f1651549 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 13:20:56 +0200 Subject: [PATCH 07/11] Add make --- .github/workflows/java.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/java.yaml b/.github/workflows/java.yaml index 07c2a0a4ab..024c8b6c47 100644 --- a/.github/workflows/java.yaml +++ b/.github/workflows/java.yaml @@ -25,7 +25,7 @@ jobs: - name: Update apt and install unzip run: | apt-get update - apt-get install -y unzip + apt-get install -y unzip make shell: bash - uses: gradle/gradle-build-action@v3 with: From 6a3a37f26dd32f62df386c38e12fcc1857b64f78 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 13:30:14 +0200 Subject: [PATCH 08/11] Fix bench? --- python/Dockerfile.benchmark | 21 ++++--- test_data/benchmark_main.py | 106 ++++++++++++++++++++++++------------ 2 files changed, 81 insertions(+), 46 deletions(-) diff --git a/python/Dockerfile.benchmark b/python/Dockerfile.benchmark index dcd3d8dd68..1527661d49 100644 --- a/python/Dockerfile.benchmark +++ b/python/Dockerfile.benchmark @@ -1,12 +1,13 @@ -FROM python:3.7-slim-buster +FROM python:3.7-slim-bookworm ENV DEBIAN_FRONTEND=noninteractive -RUN apt-get update \ - && apt-get install -y git llvm-7-dev build-essential unzip curl libjson-perl libdigest-crc-perl +RUN apt-get update \ + && apt-get install -y build-essential curl git libdigest-crc-perl libjson-perl unzip \ + && rm -rf /var/lib/apt/lists/* # install perl runtime for kaitai struct +WORKDIR /tmp RUN \ - cd /tmp \ && curl -LO https://github.com/kaitai-io/kaitai_struct_perl_runtime/archive/refs/tags/0.10.zip \ && unzip 0.10.zip \ && cd kaitai_struct_perl_runtime-0.10 \ @@ -15,12 +16,10 @@ RUN \ && rm -rf /tmp/* WORKDIR /work -ADD . /work +COPY . /work -RUN pip3 install -r /work/setup_requirements.txt -RUN pip3 install -r /work/requirements.txt -RUN pip3 install kaitaistruct +RUN pip3 install -r /work/setup_requirements.txt \ + && pip3 install -r /work/requirements.txt \ + && pip3 install kaitaistruct \ + && pip3 install wheel setuptools '.[sbp2json]' -RUN pip3 install wheel setuptools - -RUN pip3 install '.[sbp2json]' diff --git a/test_data/benchmark_main.py b/test_data/benchmark_main.py index 507fc25120..56b3948030 100755 --- a/test_data/benchmark_main.py +++ b/test_data/benchmark_main.py @@ -1,20 +1,20 @@ #!/usr/bin/env python3 -import os -import sys import gzip import json +import os import subprocess +import sys # If the ratio is off from expected by more than this percentage SLUSH_PERCENTAGE = 0.25 # How much faster Rust should be than other implementations RATIOS_SBP2JSON = { - "haskell" : 3.01, - "python" : 23.38, - "kaitai_python" : 5.00, - "kaitai_perl" : 18, + "haskell": 3.2, + "python": 23.38, + "kaitai_python": 5.00, + "kaitai_perl": 20, } RATIOS_JSON2SBP = { @@ -29,20 +29,25 @@ def maybe_via_docker(pwd, image, cmd, env=None): - if not os.environ.get('VIA_DOCKER'): + if not os.environ.get("VIA_DOCKER"): if env is not None: - for var,val in env.items(): + for var, val in env.items(): os.environ[var] = val return cmd docker_args = [ - 'docker', 'run', '-i', - '--cpus=2', '--memory=1g', - '--rm', '-v', f'{pwd}:/work', + "docker", + "run", + "-i", + "--cpus=2", + "--memory=1g", + "--rm", + "-v", + f"{pwd}:/work", ] if env is not None: - for var,val in env.items(): - docker_args += ['--env', f'{var}={val}'] + for var, val in env.items(): + docker_args += ["--env", f"{var}={val}"] docker_args += [image] + cmd return docker_args @@ -65,23 +70,34 @@ def validate_thresholds(binary, thresholds, means, target): ratio = means[lang] / target if not compare_ratio(threshold, ratio): sys.stderr.write( - f"\nERROR: {binary} speed threshold failed for {lang}, expected: {threshold}, actual: {ratio}\n\n") + f"\nERROR: {binary} speed threshold failed for {lang}, expected: {threshold}, actual: {ratio}\n\n" + ) sys.stderr.flush() FAILED[0] = True def main(): - if not os.environ.get("BENCHMARK_SKIP_SBP2JSON"): subprocess.run( - ['hyperfine', '--warmup', '5', '--min-runs', '20', - '--show-output', '--export-json', 'benchmark_sbp2json.json', - '-L', 'lang', 'rust,python,haskell,kaitai_python,kaitai_perl', - './test_data/benchmark/sbp2json_{lang}.py'], - check=True) + [ + "hyperfine", + "--warmup", + "5", + "--min-runs", + "20", + "--show-output", + "--export-json", + "benchmark_sbp2json.json", + "-L", + "lang", + "rust,python,haskell,kaitai_python,kaitai_perl", + "./test_data/benchmark/sbp2json_{lang}.py", + ], + check=True, + ) print() - bench_sbp2json = json.load(open('benchmark_sbp2json.json')) + bench_sbp2json = json.load(open("benchmark_sbp2json.json")) sbp2json_rust_mean = get_bench_mean(bench_sbp2json, "rust") means_sbp2json = { "haskell": get_bench_mean(bench_sbp2json, "haskell"), @@ -100,14 +116,23 @@ def main(): if not os.environ.get("BENCHMARK_SKIP_JSON2SBP"): subprocess.run( - ['hyperfine', '--warmup', '3', '--show-output', - '--export-json', 'benchmark_json2sbp.json', - '-L', 'lang', 'rust,haskell', - './test_data/benchmark/json2sbp_{lang}.py'], - check=True) + [ + "hyperfine", + "--warmup", + "3", + "--show-output", + "--export-json", + "benchmark_json2sbp.json", + "-L", + "lang", + "rust,haskell", + "./test_data/benchmark/json2sbp_{lang}.py", + ], + check=True, + ) print() - bench_json2sbp = json.load(open('benchmark_json2sbp.json')) + bench_json2sbp = json.load(open("benchmark_json2sbp.json")) means_json2sbp = { "haskell": get_bench_mean(bench_json2sbp, "haskell"), @@ -124,14 +149,23 @@ def main(): benchmark_input_json2json.write(json_data) subprocess.run( - ['hyperfine', '--warmup', '3', '--show-output', - '--export-json', 'benchmark_json2json.json', - '-L', 'lang', 'rust,haskell', - './test_data/benchmark/json2json_{lang}.py'], - check=True) + [ + "hyperfine", + "--warmup", + "3", + "--show-output", + "--export-json", + "benchmark_json2json.json", + "-L", + "lang", + "rust,haskell", + "./test_data/benchmark/json2json_{lang}.py", + ], + check=True, + ) print() - bench_json2json = json.load(open('benchmark_json2json.json')) + bench_json2json = json.load(open("benchmark_json2json.json")) means_json2json = { "haskell": get_bench_mean(bench_json2json, "haskell"), @@ -139,11 +173,13 @@ def main(): json2json_rust_mean = get_bench_mean(bench_json2json, "rust") - validate_thresholds("json2json", RATIOS_JSON2JSON, means_json2json, json2json_rust_mean) + validate_thresholds( + "json2json", RATIOS_JSON2JSON, means_json2json, json2json_rust_mean + ) if FAILED[0]: sys.exit(1) -if __name__ == '__main__': +if __name__ == "__main__": main() From f9663db5e69b915c3d50a55424291196ca164d60 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 13:35:31 +0200 Subject: [PATCH 09/11] Fix benhc --- haskell/Dockerfile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/haskell/Dockerfile b/haskell/Dockerfile index aa63d5e939..8d11741968 100644 --- a/haskell/Dockerfile +++ b/haskell/Dockerfile @@ -1,8 +1,9 @@ -FROM debian:buster-slim +FROM debian:bookwork-slim RUN \ apt-get update && \ apt-get install curl make ca-certificates xz-utils -y --no-install-recommends && \ + rm -rf /var/lib/apt/lists/* && \ curl -sSL https://get.haskellstack.org/ | sh WORKDIR /work From 4a3f534a83e809ffb87d409c52b0dd7791419a4f Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 13:42:57 +0200 Subject: [PATCH 10/11] Bring in all image changes --- haskell/Dockerfile | 2 +- rust/Dockerfile | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/haskell/Dockerfile b/haskell/Dockerfile index 8d11741968..d9a4a281b6 100644 --- a/haskell/Dockerfile +++ b/haskell/Dockerfile @@ -1,4 +1,4 @@ -FROM debian:bookwork-slim +FROM debian:bookworm-slim RUN \ apt-get update && \ diff --git a/rust/Dockerfile b/rust/Dockerfile index eaa556d0c0..3205e99602 100644 --- a/rust/Dockerfile +++ b/rust/Dockerfile @@ -1,4 +1,4 @@ -FROM rust:1.67.1-slim-buster +FROM rust:1.88.0-slim ARG DEBIAN_FRONTEND=noninterative @@ -9,11 +9,11 @@ ARG SCCACHE_URL=https://github.com/mozilla/sccache/releases/download/${SCCACHE_F ENV SCCACHE_CACHE_SIZE=100G ENV SCCACHE_DIR=/opt/sccache -RUN mkdir -p $SCCACHE_DIR +RUN mkdir -p "$SCCACHE_DIR" RUN \ - apt-get update \ - && apt-get install -y libssl-dev pkg-config curl build-essential make musl-tools \ + apt-get update \ + && apt-get install -y build-essential curl libssl-dev make musl-tools pkg-config \ && curl -sSL -o /tmp/sccache.tgz "${SCCACHE_URL}" \ && mkdir /tmp/sccache \ && tar --strip-components=1 -C /tmp/sccache -xzf /tmp/sccache.tgz \ From cc205f87c562b770252ea2f88e0f085f797677f8 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 13:46:42 +0200 Subject: [PATCH 11/11] ?? --- haskell/Dockerfile | 1 - python/Dockerfile.benchmark | 19 ++++++++++--------- rust/Dockerfile | 6 +++--- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/haskell/Dockerfile b/haskell/Dockerfile index d9a4a281b6..af406a52cd 100644 --- a/haskell/Dockerfile +++ b/haskell/Dockerfile @@ -3,7 +3,6 @@ FROM debian:bookworm-slim RUN \ apt-get update && \ apt-get install curl make ca-certificates xz-utils -y --no-install-recommends && \ - rm -rf /var/lib/apt/lists/* && \ curl -sSL https://get.haskellstack.org/ | sh WORKDIR /work diff --git a/python/Dockerfile.benchmark b/python/Dockerfile.benchmark index 1527661d49..ced23a8b8d 100644 --- a/python/Dockerfile.benchmark +++ b/python/Dockerfile.benchmark @@ -1,13 +1,12 @@ FROM python:3.7-slim-bookworm ENV DEBIAN_FRONTEND=noninteractive -RUN apt-get update \ - && apt-get install -y build-essential curl git libdigest-crc-perl libjson-perl unzip \ - && rm -rf /var/lib/apt/lists/* +RUN apt-get update \ + && apt-get install -y git build-essential unzip curl libjson-perl libdigest-crc-perl # install perl runtime for kaitai struct -WORKDIR /tmp RUN \ + cd /tmp \ && curl -LO https://github.com/kaitai-io/kaitai_struct_perl_runtime/archive/refs/tags/0.10.zip \ && unzip 0.10.zip \ && cd kaitai_struct_perl_runtime-0.10 \ @@ -16,10 +15,12 @@ RUN \ && rm -rf /tmp/* WORKDIR /work -COPY . /work +ADD . /work -RUN pip3 install -r /work/setup_requirements.txt \ - && pip3 install -r /work/requirements.txt \ - && pip3 install kaitaistruct \ - && pip3 install wheel setuptools '.[sbp2json]' +RUN pip3 install -r /work/setup_requirements.txt +RUN pip3 install -r /work/requirements.txt +RUN pip3 install kaitaistruct +RUN pip3 install wheel setuptools + +RUN pip3 install '.[sbp2json]' diff --git a/rust/Dockerfile b/rust/Dockerfile index 3205e99602..d7dc4856f0 100644 --- a/rust/Dockerfile +++ b/rust/Dockerfile @@ -9,11 +9,11 @@ ARG SCCACHE_URL=https://github.com/mozilla/sccache/releases/download/${SCCACHE_F ENV SCCACHE_CACHE_SIZE=100G ENV SCCACHE_DIR=/opt/sccache -RUN mkdir -p "$SCCACHE_DIR" +RUN mkdir -p $SCCACHE_DIR RUN \ - apt-get update \ - && apt-get install -y build-essential curl libssl-dev make musl-tools pkg-config \ + apt-get update \ + && apt-get install -y libssl-dev pkg-config curl build-essential make musl-tools \ && curl -sSL -o /tmp/sccache.tgz "${SCCACHE_URL}" \ && mkdir /tmp/sccache \ && tar --strip-components=1 -C /tmp/sccache -xzf /tmp/sccache.tgz \