From a1e633544b6a107a19eb07c33ec503eb6e7d1006 Mon Sep 17 00:00:00 2001 From: Navid Mahabadi Date: Wed, 16 Nov 2022 14:27:41 +0100 Subject: [PATCH 1/9] add initial files --- python/tests/sbp/test_table.py | 2 +- .../sbp/navigation/test_MsgPoseRelative.yaml | 47 +++++++ spec/yaml/swiftnav/sbp/navigation.yaml | 119 ++++++++++++++++++ 3 files changed, 167 insertions(+), 1 deletion(-) create mode 100644 spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml diff --git a/python/tests/sbp/test_table.py b/python/tests/sbp/test_table.py index 174642df3d..52402a3e3b 100644 --- a/python/tests/sbp/test_table.py +++ b/python/tests/sbp/test_table.py @@ -42,7 +42,7 @@ def test_table_count(): Test number of available messages to deserialize. """ - number_of_messages = 222 + number_of_messages = 223 assert len(_SBP_TABLE) == number_of_messages def test_table_unqiue_count(): diff --git a/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml new file mode 100644 index 0000000000..8cb13e5b4d --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml @@ -0,0 +1,47 @@ +description: Unit tests for swiftnav.sbp.navigation MsgPoseRelative +generated_on: '2022-11-16 08:58:47.874300' +package: sbp.navigation +tests: +- msg: + fields: + cov_c_x_x: 2.0 + cov_c_x_y: 0.0 + cov_c_x_z: 0.0 + cov_c_y_y: 2.0 + cov_c_y_z: 0.0 + cov_c_z_z: 2.0 + cov_r_x_x: 1.0 + cov_r_x_y: 0.0 + cov_r_x_z: 0.0 + cov_r_y_y: 1.0 + cov_r_y_z: 0.0 + cov_r_z_z: 1.0 + flags: 5 + timestamp_1: 1110 + timestamp_2: 2220 + trans: + - 1100 + - 550 + - 100 + w: -859307164 + x: -6444804 + y: -1866844813 + z: 622997694 + module: sbp.navigation + name: MsgPoseRelative + msg_type: '0x245' + raw_json: '{"preamble": 85, "msg_type": 581, "sender": 66, "length": 85, "payload": + "VgQAAKwIAABMBAAAJgIAAGQAAABkA8jM/Kid/3M1upC+MCIlAACAPwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAQAAAAAAAAAAAAAAAQAAAAAAAAABABQ==", + "crc": 22597, "timestamp_1": 1110, "timestamp_2": 2220, "trans": [1100, 550, 100], + "w": -859307164, "x": -6444804, "y": -1866844813, "z": 622997694, "cov_r_x_x": + 1.0, "cov_r_x_y": 0.0, "cov_r_x_z": 0.0, "cov_r_y_y": 1.0, "cov_r_y_z": 0.0, "cov_r_z_z": + 1.0, "cov_c_x_x": 2.0, "cov_c_x_y": 0.0, "cov_c_x_z": 0.0, "cov_c_y_y": 2.0, "cov_c_y_z": + 0.0, "cov_c_z_z": 2.0, "flags": 5}' + raw_packet: VUUCQgBVVgQAAKwIAABMBAAAJgIAAGQAAABkA8jM/Kid/3M1upC+MCIlAACAPwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAQAAAAAAAAAAAAAAAQAAAAAAAAABABUVY + sbp: + crc: '0x5845' + length: 85 + msg_type: '0x245' + payload: VgQAAKwIAABMBAAAJgIAAGQAAABkA8jM/Kid/3M1upC+MCIlAACAPwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAQAAAAAAAAAAAAAAAQAAAAAAAAABABQ== + preamble: '0x55' + sender: '0x42' diff --git a/spec/yaml/swiftnav/sbp/navigation.yaml b/spec/yaml/swiftnav/sbp/navigation.yaml index 0601265bfe..56d9df3cf4 100644 --- a/spec/yaml/swiftnav/sbp/navigation.yaml +++ b/spec/yaml/swiftnav/sbp/navigation.yaml @@ -2555,3 +2555,122 @@ definitions: type: s16 units: 0.0000002 ppm/yr desc: Rate of change of scale correction. + + - MSG_POSE_RELATIVE: + id: 0x0245 + short_desc: Relative Pose + desc: > + This solution message reports the relative pose of a sensor between + two time instances. The relative pose comprises of a rotation and + a translation which relates the sensor (e.g. camera) frame at a given + time (first keyframe) to the sensor frame at another time (second key frame). + The relative translations is a 3x1 vector described in the first keyframe. + Relative rotation is described by a quaternion from second keyframe to the first keyframe. + fields: + - tow: + type: u32 + units: ms + desc: GPS Time of Week + - sensor_id: + type: u8 + desc: ID of the sensor producing this message + - timestamp_1: + type: u32 + units: ms + desc: Timestamp of first keyframe + - timestamp_2: + type: u32 + units: ms + desc: Timestamp of second keyframe + - trans: + type: array + size: 3 + fill: s32 + desc: Relative translation [x,y,z] described in first keyframe + units: mm + - w: + type: s32 + units: 2^-31 + desc: Real component of quaternion to describe relative rotation (second to first keyframe) + - x: + type: s32 + units: 2^-31 + desc: 1st imaginary component of quaternion to describe relative rotation (second to first keyframe) + - y: + type: s32 + units: 2^-31 + desc: 2nd imaginary component of quaternion to describe relative rotation (second to first keyframe) + - z: + type: s32 + units: 2^-31 + desc: 3rd imaginary component of quaternion to describe relative rotation (second to first keyframe) + - cov_r_x_x: + type: float + units: m^2 + desc: Estimated variance of x (relative translation) + - cov_r_x_y: + type: float + units: m^2 + desc: Covariance of x and y (relative translation) + - cov_r_x_z: + type: float + units: m^2 + desc: Covariance of x and z (relative translation) + - cov_r_y_y: + type: float + units: m^2 + desc: Estimated variance of y (relative translation) + - cov_r_y_z: + type: float + units: m^2 + desc: Covariance of y and z (relative translation) + - cov_r_z_z: + type: float + units: m^2 + desc: Estimated variance of z (relative translation) + - cov_c_x_x: + type: float + units: rad^2 + desc: Estimated variance of x (relative rotation) + - cov_c_x_y: + type: float + units: rad^2 + desc: Covariance of x and y (relative rotation) + - cov_c_x_z: + type: float + units: rad^2 + desc: Covariance of x and z (relative rotation) + - cov_c_y_y: + type: float + units: rad^2 + desc: Estimated variance of y (relative rotation) + - cov_c_y_z: + type: float + units: rad^2 + desc: Covariance of y and z (relative rotation) + - cov_c_z_z: + type: float + units: rad^2 + desc: Estimated variance of z (relative rotation) + - flags: + type: u8 + desc: Status flags of relative translation and rotation + fields: + - 6-7: + desc: Reserved + - 4-5: + desc: Time source + values: + - 0: None (invalid) + - 1: GNSS Solution (ms in week) + - 2: Local CPU Time (ms) + - 2-3: + desc: Relative translation status + values: + - 0: Invalid + - 1: Valid + - 0-1: + desc: Relative rotation status + values: + - 0: Invalid + - 1: Valid \ No newline at end of file From 444fece5a13c476a33ae25fd1c88990827d6e75b Mon Sep 17 00:00:00 2001 From: Navid Mahabadi Date: Wed, 16 Nov 2022 15:29:45 +0100 Subject: [PATCH 2/9] update test yaml --- .../sbp/navigation/test_MsgPoseRelative.yaml | 26 ++++++++++--------- 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml index 8cb13e5b4d..54975af9b6 100644 --- a/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml +++ b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml @@ -1,5 +1,5 @@ description: Unit tests for swiftnav.sbp.navigation MsgPoseRelative -generated_on: '2022-11-16 08:58:47.874300' +generated_on: '2022-11-16 15:23:45.116976' package: sbp.navigation tests: - msg: @@ -17,8 +17,10 @@ tests: cov_r_y_z: 0.0 cov_r_z_z: 1.0 flags: 5 + sensor_id: 0 timestamp_1: 1110 timestamp_2: 2220 + tow: 1110 trans: - 1100 - 550 @@ -30,18 +32,18 @@ tests: module: sbp.navigation name: MsgPoseRelative msg_type: '0x245' - raw_json: '{"preamble": 85, "msg_type": 581, "sender": 66, "length": 85, "payload": - "VgQAAKwIAABMBAAAJgIAAGQAAABkA8jM/Kid/3M1upC+MCIlAACAPwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAQAAAAAAAAAAAAAAAQAAAAAAAAABABQ==", - "crc": 22597, "timestamp_1": 1110, "timestamp_2": 2220, "trans": [1100, 550, 100], - "w": -859307164, "x": -6444804, "y": -1866844813, "z": 622997694, "cov_r_x_x": - 1.0, "cov_r_x_y": 0.0, "cov_r_x_z": 0.0, "cov_r_y_y": 1.0, "cov_r_y_z": 0.0, "cov_r_z_z": - 1.0, "cov_c_x_x": 2.0, "cov_c_x_y": 0.0, "cov_c_x_z": 0.0, "cov_c_y_y": 2.0, "cov_c_y_z": - 0.0, "cov_c_z_z": 2.0, "flags": 5}' - raw_packet: VUUCQgBVVgQAAKwIAABMBAAAJgIAAGQAAABkA8jM/Kid/3M1upC+MCIlAACAPwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAQAAAAAAAAAAAAAAAQAAAAAAAAABABUVY + raw_json: '{"preamble": 85, "msg_type": 581, "sender": 66, "length": 90, "payload": + "VgQAAABWBAAArAgAAEwEAAAmAgAAZAAAAGQDyMz8qJ3/czW6kL4wIiUAAIA/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAABAAAAAAAAAAAAAAABAAAAAAAAAAEAF", + "crc": 48043, "tow": 1110, "sensor_id": 0, "timestamp_1": 1110, "timestamp_2": + 2220, "trans": [1100, 550, 100], "w": -859307164, "x": -6444804, "y": -1866844813, + "z": 622997694, "cov_r_x_x": 1.0, "cov_r_x_y": 0.0, "cov_r_x_z": 0.0, "cov_r_y_y": + 1.0, "cov_r_y_z": 0.0, "cov_r_z_z": 1.0, "cov_c_x_x": 2.0, "cov_c_x_y": 0.0, "cov_c_x_z": + 0.0, "cov_c_y_y": 2.0, "cov_c_y_z": 0.0, "cov_c_z_z": 2.0, "flags": 5}' + raw_packet: VUUCQgBaVgQAAABWBAAArAgAAEwEAAAmAgAAZAAAAGQDyMz8qJ3/czW6kL4wIiUAAIA/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAABAAAAAAAAAAAAAAABAAAAAAAAAAEAFq7s= sbp: - crc: '0x5845' - length: 85 + crc: '0xBBAB' + length: 90 msg_type: '0x245' - payload: VgQAAKwIAABMBAAAJgIAAGQAAABkA8jM/Kid/3M1upC+MCIlAACAPwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAQAAAAAAAAAAAAAAAQAAAAAAAAABABQ== + payload: VgQAAABWBAAArAgAAEwEAAAmAgAAZAAAAGQDyMz8qJ3/czW6kL4wIiUAAIA/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAABAAAAAAAAAAAAAAABAAAAAAAAAAEAF preamble: '0x55' sender: '0x42' From d944cbad394d519d4afcc76f90292745b7dc9358 Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Wed, 16 Nov 2022 12:59:18 -0800 Subject: [PATCH 3/9] Add generated files --- c/include/libsbp/cpp/message_traits.h | 35 ++ c/include/libsbp/legacy/cpp/message_traits.h | 6 + c/include/libsbp/legacy/navigation.h | 41 ++ c/include/libsbp/navigation_macros.h | 63 ++ c/include/libsbp/sbp_msg_type.h | 1 + c/include/libsbp/v4/navigation.h | 1 + .../libsbp/v4/navigation/MSG_POSE_RELATIVE.h | 293 ++++++++++ c/include/libsbp/v4/sbp_msg.h | 11 + c/src/include/libsbp/internal/v4/navigation.h | 20 + c/src/v4/navigation.c | 308 ++++++++++ ...uto_check_sbp_navigation_MsgPoseRelative.c | 324 +++++++++++ c/test/check_main.c | 1 + c/test/check_main_legacy.c | 2 + c/test/check_suites.h | 1 + c/test/check_suites_legacy.h | 1 + ...to_check_sbp_navigation_MsgPoseRelative.cc | 201 +++++++ ...uto_check_sbp_navigation_MsgPoseRelative.c | 317 +++++++++++ ...to_check_sbp_navigation_MsgPoseRelative.cc | 209 +++++++ docs/sbp.pdf | Bin 576989 -> 581543 bytes haskell/src/SwiftNav/SBP/Msg.hs | 6 + haskell/src/SwiftNav/SBP/Navigation.hs | 117 ++++ javascript/sbp.bundle.js | 6 +- javascript/sbp/navigation.js | 101 ++++ python/sbp/navigation.py | 205 +++++++ rust/sbp/src/messages/mod.rs | 25 + rust/sbp/src/messages/navigation.rs | 383 +++++++++++++ ..._check_sbp_navigation_msg_pose_relative.rs | 536 ++++++++++++++++++ rust/sbp/tests/integration/main.rs | 1 + 28 files changed, 3212 insertions(+), 3 deletions(-) create mode 100644 c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h create mode 100644 c/test/auto_check_sbp_navigation_MsgPoseRelative.c create mode 100644 c/test/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc create mode 100644 c/test/legacy/auto_check_sbp_navigation_MsgPoseRelative.c create mode 100644 c/test/legacy/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc create mode 100644 rust/sbp/tests/integration/auto_check_sbp_navigation_msg_pose_relative.rs diff --git a/c/include/libsbp/cpp/message_traits.h b/c/include/libsbp/cpp/message_traits.h index 3793a06b68..341fb4dddb 100644 --- a/c/include/libsbp/cpp/message_traits.h +++ b/c/include/libsbp/cpp/message_traits.h @@ -4828,6 +4828,41 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgPoseRelative; + static const sbp_msg_pose_relative_t &get(const sbp_msg_t &msg) { + return msg.pose_relative; + } + static sbp_msg_pose_relative_t &get(sbp_msg_t &msg) { + return msg.pose_relative; + } + static void to_sbp_msg(const sbp_msg_pose_relative_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->pose_relative = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_pose_relative_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.pose_relative = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_pose_relative_t &msg, sbp_write_fn_t write) { + return sbp_msg_pose_relative_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_pose_relative_t &msg) { + return sbp_msg_pose_relative_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_pose_relative_t *msg) { + return sbp_msg_pose_relative_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_pose_relative_t &msg) { + return sbp_msg_pose_relative_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgPpsTime; diff --git a/c/include/libsbp/legacy/cpp/message_traits.h b/c/include/libsbp/legacy/cpp/message_traits.h index 6c6159b041..4ac51679b4 100644 --- a/c/include/libsbp/legacy/cpp/message_traits.h +++ b/c/include/libsbp/legacy/cpp/message_traits.h @@ -926,6 +926,12 @@ struct MessageTraits { }; +template<> +struct MessageTraits { + static constexpr u16 id = 581; +}; + + template<> struct MessageTraits { static constexpr u16 id = 1024; diff --git a/c/include/libsbp/legacy/navigation.h b/c/include/libsbp/legacy/navigation.h index e212630e4d..f3ec35fa31 100644 --- a/c/include/libsbp/legacy/navigation.h +++ b/c/include/libsbp/legacy/navigation.h @@ -969,6 +969,47 @@ typedef struct SBP_ATTR_PACKED { s16 dot_scale; /**< Rate of change of scale correction. [0.0000002 ppm/yr] */ } msg_reference_frame_param_t; +/** Relative Pose + * + * This solution message reports the relative pose of a sensor between two + * time instances. The relative pose comprises of a rotation and a translation + * which relates the sensor (e.g. camera) frame at a given time (first + * keyframe) to the sensor frame at another time (second key frame). The + * relative translations is a 3x1 vector described in the first keyframe. + * Relative rotation is described by a quaternion from second keyframe to the + * first keyframe. + */ + +typedef struct SBP_ATTR_PACKED { + u32 tow; /**< GPS Time of Week [ms] */ + u8 sensor_id; /**< ID of the sensor producing this message */ + u32 timestamp_1; /**< Timestamp of first keyframe [ms] */ + u32 timestamp_2; /**< Timestamp of second keyframe [ms] */ + s32 trans[3]; /**< Relative translation [x,y,z] described in first + keyframe [mm] */ + s32 w; /**< Real component of quaternion to describe relative + rotation (second to first keyframe) [2^-31] */ + s32 x; /**< 1st imaginary component of quaternion to describe + relative rotation (second to first keyframe) [2^-31] */ + s32 y; /**< 2nd imaginary component of quaternion to describe + relative rotation (second to first keyframe) [2^-31] */ + s32 z; /**< 3rd imaginary component of quaternion to describe + relative rotation (second to first keyframe) [2^-31] */ + float cov_r_x_x; /**< Estimated variance of x (relative translation) [m^2] */ + float cov_r_x_y; /**< Covariance of x and y (relative translation) [m^2] */ + float cov_r_x_z; /**< Covariance of x and z (relative translation) [m^2] */ + float cov_r_y_y; /**< Estimated variance of y (relative translation) [m^2] */ + float cov_r_y_z; /**< Covariance of y and z (relative translation) [m^2] */ + float cov_r_z_z; /**< Estimated variance of z (relative translation) [m^2] */ + float cov_c_x_x; /**< Estimated variance of x (relative rotation) [rad^2] */ + float cov_c_x_y; /**< Covariance of x and y (relative rotation) [rad^2] */ + float cov_c_x_z; /**< Covariance of x and z (relative rotation) [rad^2] */ + float cov_c_y_y; /**< Estimated variance of y (relative rotation) [rad^2] */ + float cov_c_y_z; /**< Covariance of y and z (relative rotation) [rad^2] */ + float cov_c_z_z; /**< Estimated variance of z (relative rotation) [rad^2] */ + u8 flags; /**< Status flags of relative translation and rotation */ +} msg_pose_relative_t; + /** \} */ SBP_PACK_END diff --git a/c/include/libsbp/navigation_macros.h b/c/include/libsbp/navigation_macros.h index e2ad5dcf0e..35b5e131cf 100644 --- a/c/include/libsbp/navigation_macros.h +++ b/c/include/libsbp/navigation_macros.h @@ -1766,4 +1766,67 @@ */ #define SBP_MSG_REFERENCE_FRAME_PARAM_ENCODED_LEN 124u +#define SBP_MSG_POSE_RELATIVE 0x0245 +/** + * The maximum number of items that can be stored in + * sbp_msg_pose_relative_t::trans (V4 API) or msg_pose_relative_t::trans (legacy + * API) before the maximum SBP message size is exceeded + */ +#define SBP_MSG_POSE_RELATIVE_TRANS_MAX 3u + +#define SBP_POSE_RELATIVE_TIME_SOURCE_MASK (0x3u) +#define SBP_POSE_RELATIVE_TIME_SOURCE_SHIFT (4u) +#define SBP_POSE_RELATIVE_TIME_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POSE_RELATIVE_TIME_SOURCE_SHIFT) & \ + SBP_POSE_RELATIVE_TIME_SOURCE_MASK)) +#define SBP_POSE_RELATIVE_TIME_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POSE_RELATIVE_TIME_SOURCE_MASK \ + << SBP_POSE_RELATIVE_TIME_SOURCE_SHIFT))) | \ + (((val) & (SBP_POSE_RELATIVE_TIME_SOURCE_MASK)) \ + << (SBP_POSE_RELATIVE_TIME_SOURCE_SHIFT))); \ + } while (0) + +#define SBP_POSE_RELATIVE_TIME_SOURCE_NONE (0) +#define SBP_POSE_RELATIVE_TIME_SOURCE_GNSS_SOLUTION (1) +#define SBP_POSE_RELATIVE_TIME_SOURCE_LOCAL_CPU_TIME (2) +#define SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_MASK (0x3u) +#define SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_SHIFT (2u) +#define SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_SHIFT) & \ + SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_MASK)) +#define SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & \ + (~(SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_MASK \ + << SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_SHIFT))) | \ + (((val) & (SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_MASK)) \ + << (SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_SHIFT))); \ + } while (0) + +#define SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_INVALID (0) +#define SBP_POSE_RELATIVE_RELATIVE_TRANSLATION_STATUS_VALID (1) +#define SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_MASK (0x3u) +#define SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_SHIFT (0u) +#define SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_SHIFT) & \ + SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_MASK)) +#define SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_MASK \ + << SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_SHIFT))) | \ + (((val) & (SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_MASK)) \ + << (SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_SHIFT))); \ + } while (0) + +#define SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_INVALID (0) +#define SBP_POSE_RELATIVE_RELATIVE_ROTATION_STATUS_VALID (1) +/** + * Encoded length of sbp_msg_pose_relative_t (V4 API) and + * msg_pose_relative_t (legacy API) + */ +#define SBP_MSG_POSE_RELATIVE_ENCODED_LEN 90u + #endif /* LIBSBP_NAVIGATION_MACROS_H */ diff --git a/c/include/libsbp/sbp_msg_type.h b/c/include/libsbp/sbp_msg_type.h index e428fe9f7e..4f4174a2d3 100644 --- a/c/include/libsbp/sbp_msg_type.h +++ b/c/include/libsbp/sbp_msg_type.h @@ -188,6 +188,7 @@ typedef enum { SbpMsgPosLlhDepA = SBP_MSG_POS_LLH_DEP_A, SbpMsgPosLlhGnss = SBP_MSG_POS_LLH_GNSS, SbpMsgPosLlh = SBP_MSG_POS_LLH, + SbpMsgPoseRelative = SBP_MSG_POSE_RELATIVE, SbpMsgPpsTime = SBP_MSG_PPS_TIME, SbpMsgPrintDep = SBP_MSG_PRINT_DEP, SbpMsgProtectionLevelDepA = SBP_MSG_PROTECTION_LEVEL_DEP_A, diff --git a/c/include/libsbp/v4/navigation.h b/c/include/libsbp/v4/navigation.h index fc89dacc0c..9f944d0462 100644 --- a/c/include/libsbp/v4/navigation.h +++ b/c/include/libsbp/v4/navigation.h @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include diff --git a/c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h b/c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h new file mode 100644 index 0000000000..d69e014b51 --- /dev/null +++ b/c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h @@ -0,0 +1,293 @@ +/* + * 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 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/navigation.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_NAVIGATION_MSG_POSE_RELATIVE_H +#define LIBSBP_V4_NAVIGATION_MSG_POSE_RELATIVE_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_POSE_RELATIVE + * + *****************************************************************************/ +/** Relative Pose + * + * This solution message reports the relative pose of a sensor between two time + * instances. The relative pose comprises of a rotation and a translation which + * relates the sensor (e.g. camera) frame at a given time (first keyframe) to + * the sensor frame at another time (second key frame). The relative + * translations is a 3x1 vector described in the first keyframe. Relative + * rotation is described by a quaternion from second keyframe to the first + * keyframe. + */ +typedef struct { + /** + * GPS Time of Week [ms] + */ + u32 tow; + + /** + * ID of the sensor producing this message + */ + u8 sensor_id; + + /** + * Timestamp of first keyframe [ms] + */ + u32 timestamp_1; + + /** + * Timestamp of second keyframe [ms] + */ + u32 timestamp_2; + + /** + * Relative translation [x,y,z] described in first keyframe [mm] + */ + s32 trans[SBP_MSG_POSE_RELATIVE_TRANS_MAX]; + + /** + * Real component of quaternion to describe relative rotation (second to first + * keyframe) [2^-31] + */ + s32 w; + + /** + * 1st imaginary component of quaternion to describe relative rotation (second + * to first keyframe) [2^-31] + */ + s32 x; + + /** + * 2nd imaginary component of quaternion to describe relative rotation (second + * to first keyframe) [2^-31] + */ + s32 y; + + /** + * 3rd imaginary component of quaternion to describe relative rotation (second + * to first keyframe) [2^-31] + */ + s32 z; + + /** + * Estimated variance of x (relative translation) [m^2] + */ + float cov_r_x_x; + + /** + * Covariance of x and y (relative translation) [m^2] + */ + float cov_r_x_y; + + /** + * Covariance of x and z (relative translation) [m^2] + */ + float cov_r_x_z; + + /** + * Estimated variance of y (relative translation) [m^2] + */ + float cov_r_y_y; + + /** + * Covariance of y and z (relative translation) [m^2] + */ + float cov_r_y_z; + + /** + * Estimated variance of z (relative translation) [m^2] + */ + float cov_r_z_z; + + /** + * Estimated variance of x (relative rotation) [rad^2] + */ + float cov_c_x_x; + + /** + * Covariance of x and y (relative rotation) [rad^2] + */ + float cov_c_x_y; + + /** + * Covariance of x and z (relative rotation) [rad^2] + */ + float cov_c_x_z; + + /** + * Estimated variance of y (relative rotation) [rad^2] + */ + float cov_c_y_y; + + /** + * Covariance of y and z (relative rotation) [rad^2] + */ + float cov_c_y_z; + + /** + * Estimated variance of z (relative rotation) [rad^2] + */ + float cov_c_z_z; + + /** + * Status flags of relative translation and rotation + */ + u8 flags; +} sbp_msg_pose_relative_t; + +/** + * Get encoded size of an instance of sbp_msg_pose_relative_t + * + * @param msg sbp_msg_pose_relative_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_pose_relative_encoded_len( + const sbp_msg_pose_relative_t *msg) { + (void)msg; + return SBP_MSG_POSE_RELATIVE_ENCODED_LEN; +} + +/** + * Encode an instance of sbp_msg_pose_relative_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_pose_relative_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_pose_relative_encode(uint8_t *buf, uint8_t len, + uint8_t *n_written, + const sbp_msg_pose_relative_t *msg); + +/** + * Decode an instance of sbp_msg_pose_relative_t from wire representation + * + * This function decodes the wire representation of a sbp_msg_pose_relative_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_pose_relative_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_pose_relative_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, + sbp_msg_pose_relative_t *msg); +/** + * Send an instance of sbp_msg_pose_relative_t with the given write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_pose_relative_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_pose_relative_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_pose_relative_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_pose_relative_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_pose_relative_t instance + * @param b sbp_msg_pose_relative_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_pose_relative_cmp(const sbp_msg_pose_relative_t *a, + const sbp_msg_pose_relative_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_pose_relative_t &lhs, + const sbp_msg_pose_relative_t &rhs) { + return sbp_msg_pose_relative_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_pose_relative_t &lhs, + const sbp_msg_pose_relative_t &rhs) { + return sbp_msg_pose_relative_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_pose_relative_t &lhs, + const sbp_msg_pose_relative_t &rhs) { + return sbp_msg_pose_relative_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_pose_relative_t &lhs, + const sbp_msg_pose_relative_t &rhs) { + return sbp_msg_pose_relative_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_pose_relative_t &lhs, + const sbp_msg_pose_relative_t &rhs) { + return sbp_msg_pose_relative_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_pose_relative_t &lhs, + const sbp_msg_pose_relative_t &rhs) { + return sbp_msg_pose_relative_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_NAVIGATION_MSG_POSE_RELATIVE_H */ diff --git a/c/include/libsbp/v4/sbp_msg.h b/c/include/libsbp/v4/sbp_msg.h index e6584408ff..078c4f9303 100644 --- a/c/include/libsbp/v4/sbp_msg.h +++ b/c/include/libsbp/v4/sbp_msg.h @@ -194,6 +194,7 @@ typedef union { sbp_msg_pos_llh_dep_a_t pos_llh_dep_a; sbp_msg_pos_llh_gnss_t pos_llh_gnss; sbp_msg_pos_llh_t pos_llh; + sbp_msg_pose_relative_t pose_relative; sbp_msg_pps_time_t pps_time; sbp_msg_print_dep_t print_dep; sbp_msg_protection_level_dep_a_t protection_level_dep_a; @@ -669,6 +670,9 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, &msg->pos_llh_gnss); case SbpMsgPosLlh: return sbp_msg_pos_llh_encode(buf, len, n_written, &msg->pos_llh); + case SbpMsgPoseRelative: + return sbp_msg_pose_relative_encode(buf, len, n_written, + &msg->pose_relative); case SbpMsgPpsTime: return sbp_msg_pps_time_encode(buf, len, n_written, &msg->pps_time); case SbpMsgPrintDep: @@ -1290,6 +1294,9 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, return sbp_msg_pos_llh_gnss_decode(buf, len, n_read, &msg->pos_llh_gnss); case SbpMsgPosLlh: return sbp_msg_pos_llh_decode(buf, len, n_read, &msg->pos_llh); + case SbpMsgPoseRelative: + return sbp_msg_pose_relative_decode(buf, len, n_read, + &msg->pose_relative); case SbpMsgPpsTime: return sbp_msg_pps_time_decode(buf, len, n_read, &msg->pps_time); case SbpMsgPrintDep: @@ -1833,6 +1840,8 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, return sbp_msg_pos_llh_gnss_encoded_len(&msg->pos_llh_gnss); case SbpMsgPosLlh: return sbp_msg_pos_llh_encoded_len(&msg->pos_llh); + case SbpMsgPoseRelative: + return sbp_msg_pose_relative_encoded_len(&msg->pose_relative); case SbpMsgPpsTime: return sbp_msg_pps_time_encoded_len(&msg->pps_time); case SbpMsgPrintDep: @@ -2392,6 +2401,8 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, return sbp_msg_pos_llh_gnss_cmp(&a->pos_llh_gnss, &b->pos_llh_gnss); case SbpMsgPosLlh: return sbp_msg_pos_llh_cmp(&a->pos_llh, &b->pos_llh); + case SbpMsgPoseRelative: + return sbp_msg_pose_relative_cmp(&a->pose_relative, &b->pose_relative); case SbpMsgPpsTime: return sbp_msg_pps_time_cmp(&a->pps_time, &b->pps_time); case SbpMsgPrintDep: diff --git a/c/src/include/libsbp/internal/v4/navigation.h b/c/src/include/libsbp/internal/v4/navigation.h index 00f63a0271..d59c8d8a3d 100644 --- a/c/src/include/libsbp/internal/v4/navigation.h +++ b/c/src/include/libsbp/internal/v4/navigation.h @@ -846,6 +846,26 @@ bool sbp_msg_reference_frame_param_encode_internal( bool sbp_msg_reference_frame_param_decode_internal( sbp_decode_ctx_t *ctx, sbp_msg_reference_frame_param_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_pose_relative_encode_internal(sbp_encode_ctx_t *ctx, + const sbp_msg_pose_relative_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_pose_relative_decode_internal(sbp_decode_ctx_t *ctx, + sbp_msg_pose_relative_t *msg); + #ifdef __cplusplus } #endif diff --git a/c/src/v4/navigation.c b/c/src/v4/navigation.c index a2fdda5ecc..6987e6ec09 100644 --- a/c/src/v4/navigation.c +++ b/c/src/v4/navigation.c @@ -6428,3 +6428,311 @@ int sbp_msg_reference_frame_param_cmp( } return ret; } + +bool sbp_msg_pose_relative_encode_internal(sbp_encode_ctx_t *ctx, + const sbp_msg_pose_relative_t *msg) { + if (!sbp_u32_encode(ctx, &msg->tow)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->sensor_id)) { + return false; + } + if (!sbp_u32_encode(ctx, &msg->timestamp_1)) { + return false; + } + if (!sbp_u32_encode(ctx, &msg->timestamp_2)) { + return false; + } + for (size_t i = 0; i < SBP_MSG_POSE_RELATIVE_TRANS_MAX; i++) { + if (!sbp_s32_encode(ctx, &msg->trans[i])) { + return false; + } + } + if (!sbp_s32_encode(ctx, &msg->w)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->x)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->y)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->z)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_r_x_x)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_r_x_y)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_r_x_z)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_r_y_y)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_r_y_z)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_r_z_z)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_c_x_x)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_c_x_y)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_c_x_z)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_c_y_y)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_c_y_z)) { + return false; + } + if (!sbp_float_encode(ctx, &msg->cov_c_z_z)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->flags)) { + return false; + } + return true; +} + +s8 sbp_msg_pose_relative_encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_pose_relative_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_pose_relative_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_pose_relative_decode_internal(sbp_decode_ctx_t *ctx, + sbp_msg_pose_relative_t *msg) { + if (!sbp_u32_decode(ctx, &msg->tow)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->sensor_id)) { + return false; + } + if (!sbp_u32_decode(ctx, &msg->timestamp_1)) { + return false; + } + if (!sbp_u32_decode(ctx, &msg->timestamp_2)) { + return false; + } + for (uint8_t i = 0; i < SBP_MSG_POSE_RELATIVE_TRANS_MAX; i++) { + if (!sbp_s32_decode(ctx, &msg->trans[i])) { + return false; + } + } + if (!sbp_s32_decode(ctx, &msg->w)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->x)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->y)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->z)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_r_x_x)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_r_x_y)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_r_x_z)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_r_y_y)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_r_y_z)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_r_z_z)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_c_x_x)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_c_x_y)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_c_x_z)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_c_y_y)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_c_y_z)) { + return false; + } + if (!sbp_float_decode(ctx, &msg->cov_c_z_z)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->flags)) { + return false; + } + return true; +} + +s8 sbp_msg_pose_relative_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, sbp_msg_pose_relative_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_pose_relative_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_pose_relative_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_pose_relative_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = + sbp_msg_pose_relative_encode(payload, sizeof(payload), &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_POSE_RELATIVE, sender_id, payload_len, + payload, write); +} + +int sbp_msg_pose_relative_cmp(const sbp_msg_pose_relative_t *a, + const sbp_msg_pose_relative_t *b) { + int ret = 0; + + ret = sbp_u32_cmp(&a->tow, &b->tow); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->sensor_id, &b->sensor_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u32_cmp(&a->timestamp_1, &b->timestamp_1); + if (ret != 0) { + return ret; + } + + ret = sbp_u32_cmp(&a->timestamp_2, &b->timestamp_2); + if (ret != 0) { + return ret; + } + + for (uint8_t i = 0; ret == 0 && i < SBP_MSG_POSE_RELATIVE_TRANS_MAX; i++) { + ret = sbp_s32_cmp(&a->trans[i], &b->trans[i]); + } + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->w, &b->w); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->x, &b->x); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->y, &b->y); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->z, &b->z); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_r_x_x, &b->cov_r_x_x); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_r_x_y, &b->cov_r_x_y); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_r_x_z, &b->cov_r_x_z); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_r_y_y, &b->cov_r_y_y); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_r_y_z, &b->cov_r_y_z); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_r_z_z, &b->cov_r_z_z); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_c_x_x, &b->cov_c_x_x); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_c_x_y, &b->cov_c_x_y); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_c_x_z, &b->cov_c_x_z); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_c_y_y, &b->cov_c_y_y); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_c_y_z, &b->cov_c_y_z); + if (ret != 0) { + return ret; + } + + ret = sbp_float_cmp(&a->cov_c_z_z, &b->cov_c_z_z); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->flags, &b->flags); + if (ret != 0) { + return ret; + } + return ret; +} diff --git a/c/test/auto_check_sbp_navigation_MsgPoseRelative.c b/c/test/auto_check_sbp_navigation_MsgPoseRelative.c new file mode 100644 index 0000000000..cf8e3bbdd7 --- /dev/null +++ b/c/test/auto_check_sbp_navigation_MsgPoseRelative.c @@ -0,0 +1,324 @@ +/* + * 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 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/navigation/test_MsgPoseRelative.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 u32 dummy_wr = 0; +static u32 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; + u32 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; + u32 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_navigation_MsgPoseRelative) { + 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, 0x245, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 69, 2, 66, 0, 90, 86, 4, 0, 0, 0, 86, 4, 0, + 0, 172, 8, 0, 0, 76, 4, 0, 0, 38, 2, 0, 0, 100, + 0, 0, 0, 100, 3, 200, 204, 252, 168, 157, 255, 115, 53, 186, + 144, 190, 48, 34, 37, 0, 0, 128, 63, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, + 63, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 64, 5, 171, 187, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.pose_relative.cov_c_x_x = 2.0; + + test_msg.pose_relative.cov_c_x_y = 0.0; + + test_msg.pose_relative.cov_c_x_z = 0.0; + + test_msg.pose_relative.cov_c_y_y = 2.0; + + test_msg.pose_relative.cov_c_y_z = 0.0; + + test_msg.pose_relative.cov_c_z_z = 2.0; + + test_msg.pose_relative.cov_r_x_x = 1.0; + + test_msg.pose_relative.cov_r_x_y = 0.0; + + test_msg.pose_relative.cov_r_x_z = 0.0; + + test_msg.pose_relative.cov_r_y_y = 1.0; + + test_msg.pose_relative.cov_r_y_z = 0.0; + + test_msg.pose_relative.cov_r_z_z = 1.0; + + test_msg.pose_relative.flags = 5; + + test_msg.pose_relative.sensor_id = 0; + + test_msg.pose_relative.timestamp_1 = 1110; + + test_msg.pose_relative.timestamp_2 = 2220; + + test_msg.pose_relative.tow = 1110; + + test_msg.pose_relative.trans[0] = 1100; + + test_msg.pose_relative.trans[1] = 550; + + test_msg.pose_relative.trans[2] = 100; + + test_msg.pose_relative.w = -859307164; + + test_msg.pose_relative.x = -6444804; + + test_msg.pose_relative.y = -1866844813; + + test_msg.pose_relative.z = 622997694; + + sbp_message_send(&sbp_state, SbpMsgPoseRelative, 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(SbpMsgPoseRelative, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_c_x_x * 100 - 2.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_c_x_x, expected " + "2.0, is %s", + last_msg.msg.pose_relative.cov_c_x_x); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_c_x_y * 100 - 0.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_c_x_y, expected " + "0.0, is %s", + last_msg.msg.pose_relative.cov_c_x_y); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_c_x_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_c_x_z, expected " + "0.0, is %s", + last_msg.msg.pose_relative.cov_c_x_z); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_c_y_y * 100 - 2.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_c_y_y, expected " + "2.0, is %s", + last_msg.msg.pose_relative.cov_c_y_y); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_c_y_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_c_y_z, expected " + "0.0, is %s", + last_msg.msg.pose_relative.cov_c_y_z); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_c_z_z * 100 - 2.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_c_z_z, expected " + "2.0, is %s", + last_msg.msg.pose_relative.cov_c_z_z); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_r_x_x * 100 - 1.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_r_x_x, expected " + "1.0, is %s", + last_msg.msg.pose_relative.cov_r_x_x); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_r_x_y * 100 - 0.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_r_x_y, expected " + "0.0, is %s", + last_msg.msg.pose_relative.cov_r_x_y); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_r_x_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_r_x_z, expected " + "0.0, is %s", + last_msg.msg.pose_relative.cov_r_x_z); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_r_y_y * 100 - 1.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_r_y_y, expected " + "1.0, is %s", + last_msg.msg.pose_relative.cov_r_y_y); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_r_y_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_r_y_z, expected " + "0.0, is %s", + last_msg.msg.pose_relative.cov_r_y_z); + + ck_assert_msg( + (last_msg.msg.pose_relative.cov_r_z_z * 100 - 1.0 * 100) < 0.05, + "incorrect value for last_msg.msg.pose_relative.cov_r_z_z, expected " + "1.0, is %s", + last_msg.msg.pose_relative.cov_r_z_z); + + ck_assert_msg(last_msg.msg.pose_relative.flags == 5, + "incorrect value for last_msg.msg.pose_relative.flags, " + "expected 5, is %d", + last_msg.msg.pose_relative.flags); + + ck_assert_msg(last_msg.msg.pose_relative.sensor_id == 0, + "incorrect value for last_msg.msg.pose_relative.sensor_id, " + "expected 0, is %d", + last_msg.msg.pose_relative.sensor_id); + + ck_assert_msg(last_msg.msg.pose_relative.timestamp_1 == 1110, + "incorrect value for last_msg.msg.pose_relative.timestamp_1, " + "expected 1110, is %d", + last_msg.msg.pose_relative.timestamp_1); + + ck_assert_msg(last_msg.msg.pose_relative.timestamp_2 == 2220, + "incorrect value for last_msg.msg.pose_relative.timestamp_2, " + "expected 2220, is %d", + last_msg.msg.pose_relative.timestamp_2); + + ck_assert_msg(last_msg.msg.pose_relative.tow == 1110, + "incorrect value for last_msg.msg.pose_relative.tow, " + "expected 1110, is %d", + last_msg.msg.pose_relative.tow); + + ck_assert_msg(last_msg.msg.pose_relative.trans[0] == 1100, + "incorrect value for last_msg.msg.pose_relative.trans[0], " + "expected 1100, is %d", + last_msg.msg.pose_relative.trans[0]); + ck_assert_msg(last_msg.msg.pose_relative.trans[1] == 550, + "incorrect value for last_msg.msg.pose_relative.trans[1], " + "expected 550, is %d", + last_msg.msg.pose_relative.trans[1]); + ck_assert_msg(last_msg.msg.pose_relative.trans[2] == 100, + "incorrect value for last_msg.msg.pose_relative.trans[2], " + "expected 100, is %d", + last_msg.msg.pose_relative.trans[2]); + + ck_assert_msg(last_msg.msg.pose_relative.w == -859307164, + "incorrect value for last_msg.msg.pose_relative.w, expected " + "-859307164, is %d", + last_msg.msg.pose_relative.w); + + ck_assert_msg(last_msg.msg.pose_relative.x == -6444804, + "incorrect value for last_msg.msg.pose_relative.x, expected " + "-6444804, is %d", + last_msg.msg.pose_relative.x); + + ck_assert_msg(last_msg.msg.pose_relative.y == -1866844813, + "incorrect value for last_msg.msg.pose_relative.y, expected " + "-1866844813, is %d", + last_msg.msg.pose_relative.y); + + ck_assert_msg(last_msg.msg.pose_relative.z == 622997694, + "incorrect value for last_msg.msg.pose_relative.z, expected " + "622997694, is %d", + last_msg.msg.pose_relative.z); + } +} +END_TEST + +Suite *auto_check_sbp_navigation_MsgPoseRelative_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_navigation_MsgPoseRelative"); + TCase *tc_acq = + tcase_create("Automated_Suite_auto_check_sbp_navigation_MsgPoseRelative"); + tcase_add_test(tc_acq, test_auto_check_sbp_navigation_MsgPoseRelative); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/check_main.c b/c/test/check_main.c index 32d2571061..2cd6b2110d 100644 --- a/c/test/check_main.c +++ b/c/test/check_main.c @@ -67,6 +67,7 @@ int main(void) { srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosLLHDepA_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosLlhCovGnss_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosLlhGnss_suite()); + srunner_add_suite(sr, auto_check_sbp_navigation_MsgPoseRelative_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgProtectionLevel_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgReferenceFrameParam_suite()); diff --git a/c/test/check_main_legacy.c b/c/test/check_main_legacy.c index 2123d2e2cb..34a36f4fb1 100644 --- a/c/test/check_main_legacy.c +++ b/c/test/check_main_legacy.c @@ -85,6 +85,8 @@ int main(void) { srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgPosLlhCovGnss_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgPosLlhGnss_suite()); + srunner_add_suite(sr, + legacy_auto_check_sbp_navigation_MsgPoseRelative_suite()); srunner_add_suite( sr, legacy_auto_check_sbp_navigation_MsgProtectionLevel_suite()); srunner_add_suite( diff --git a/c/test/check_suites.h b/c/test/check_suites.h index a48b9b1a12..0cc0e45d46 100644 --- a/c/test/check_suites.h +++ b/c/test/check_suites.h @@ -55,6 +55,7 @@ Suite* auto_check_sbp_navigation_MsgPosLLHCov_suite(void); Suite* auto_check_sbp_navigation_MsgPosLLHDepA_suite(void); Suite* auto_check_sbp_navigation_MsgPosLlhCovGnss_suite(void); Suite* auto_check_sbp_navigation_MsgPosLlhGnss_suite(void); +Suite* auto_check_sbp_navigation_MsgPoseRelative_suite(void); Suite* auto_check_sbp_navigation_MsgProtectionLevel_suite(void); Suite* auto_check_sbp_navigation_MsgReferenceFrameParam_suite(void); Suite* auto_check_sbp_navigation_MsgUTCLeapSecond_suite(void); diff --git a/c/test/check_suites_legacy.h b/c/test/check_suites_legacy.h index ac63576e04..f421223a57 100644 --- a/c/test/check_suites_legacy.h +++ b/c/test/check_suites_legacy.h @@ -56,6 +56,7 @@ Suite* legacy_auto_check_sbp_navigation_MsgPosLLHCov_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosLLHDepA_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosLlhCovGnss_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosLlhGnss_suite(void); +Suite* legacy_auto_check_sbp_navigation_MsgPoseRelative_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgProtectionLevel_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgReferenceFrameParam_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgUTCLeapSecond_suite(void); diff --git a/c/test/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc b/c/test/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc new file mode 100644 index 0000000000..b2933e5870 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc @@ -0,0 +1,201 @@ +/* + * 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 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/navigation/test_MsgPoseRelative.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_navigation_MsgPoseRelative0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_navigation_MsgPoseRelative0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_pose_relative_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_pose_relative_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_navigation_MsgPoseRelative0, Test) { + uint8_t encoded_frame[] = { + 85, 69, 2, 66, 0, 90, 86, 4, 0, 0, 0, 86, 4, 0, + 0, 172, 8, 0, 0, 76, 4, 0, 0, 38, 2, 0, 0, 100, + 0, 0, 0, 100, 3, 200, 204, 252, 168, 157, 255, 115, 53, 186, + 144, 190, 48, 34, 37, 0, 0, 128, 63, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, + 63, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 64, 5, 171, 187, + }; + + sbp_msg_pose_relative_t test_msg{}; + test_msg.cov_c_x_x = 2.0; + test_msg.cov_c_x_y = 0.0; + test_msg.cov_c_x_z = 0.0; + test_msg.cov_c_y_y = 2.0; + test_msg.cov_c_y_z = 0.0; + test_msg.cov_c_z_z = 2.0; + test_msg.cov_r_x_x = 1.0; + test_msg.cov_r_x_y = 0.0; + test_msg.cov_r_x_z = 0.0; + test_msg.cov_r_y_y = 1.0; + test_msg.cov_r_y_z = 0.0; + test_msg.cov_r_z_z = 1.0; + test_msg.flags = 5; + test_msg.sensor_id = 0; + test_msg.timestamp_1 = 1110; + test_msg.timestamp_2 = 2220; + test_msg.tow = 1110; + + test_msg.trans[0] = 1100; + + test_msg.trans[1] = 550; + + test_msg.trans[2] = 100; + test_msg.w = -859307164; + test_msg.x = -6444804; + test_msg.y = -1866844813; + test_msg.z = 622997694; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_LT((last_msg_.cov_c_x_x * 100 - 2.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_c_x_x, expected 2.0, is " + << last_msg_.cov_c_x_x; + EXPECT_LT((last_msg_.cov_c_x_y * 100 - 0.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_c_x_y, expected 0.0, is " + << last_msg_.cov_c_x_y; + EXPECT_LT((last_msg_.cov_c_x_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_c_x_z, expected 0.0, is " + << last_msg_.cov_c_x_z; + EXPECT_LT((last_msg_.cov_c_y_y * 100 - 2.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_c_y_y, expected 2.0, is " + << last_msg_.cov_c_y_y; + EXPECT_LT((last_msg_.cov_c_y_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_c_y_z, expected 0.0, is " + << last_msg_.cov_c_y_z; + EXPECT_LT((last_msg_.cov_c_z_z * 100 - 2.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_c_z_z, expected 2.0, is " + << last_msg_.cov_c_z_z; + EXPECT_LT((last_msg_.cov_r_x_x * 100 - 1.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_r_x_x, expected 1.0, is " + << last_msg_.cov_r_x_x; + EXPECT_LT((last_msg_.cov_r_x_y * 100 - 0.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_r_x_y, expected 0.0, is " + << last_msg_.cov_r_x_y; + EXPECT_LT((last_msg_.cov_r_x_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_r_x_z, expected 0.0, is " + << last_msg_.cov_r_x_z; + EXPECT_LT((last_msg_.cov_r_y_y * 100 - 1.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_r_y_y, expected 1.0, is " + << last_msg_.cov_r_y_y; + EXPECT_LT((last_msg_.cov_r_y_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_r_y_z, expected 0.0, is " + << last_msg_.cov_r_y_z; + EXPECT_LT((last_msg_.cov_r_z_z * 100 - 1.0 * 100), 0.05) + << "incorrect value for last_msg_.cov_r_z_z, expected 1.0, is " + << last_msg_.cov_r_z_z; + EXPECT_EQ(last_msg_.flags, 5) + << "incorrect value for last_msg_.flags, expected 5, is " + << last_msg_.flags; + EXPECT_EQ(last_msg_.sensor_id, 0) + << "incorrect value for last_msg_.sensor_id, expected 0, is " + << last_msg_.sensor_id; + EXPECT_EQ(last_msg_.timestamp_1, 1110) + << "incorrect value for last_msg_.timestamp_1, expected 1110, is " + << last_msg_.timestamp_1; + EXPECT_EQ(last_msg_.timestamp_2, 2220) + << "incorrect value for last_msg_.timestamp_2, expected 2220, is " + << last_msg_.timestamp_2; + EXPECT_EQ(last_msg_.tow, 1110) + << "incorrect value for last_msg_.tow, expected 1110, is " + << last_msg_.tow; + EXPECT_EQ(last_msg_.trans[0], 1100) + << "incorrect value for last_msg_.trans[0], expected 1100, is " + << last_msg_.trans[0]; + EXPECT_EQ(last_msg_.trans[1], 550) + << "incorrect value for last_msg_.trans[1], expected 550, is " + << last_msg_.trans[1]; + EXPECT_EQ(last_msg_.trans[2], 100) + << "incorrect value for last_msg_.trans[2], expected 100, is " + << last_msg_.trans[2]; + EXPECT_EQ(last_msg_.w, -859307164) + << "incorrect value for last_msg_.w, expected -859307164, is " + << last_msg_.w; + EXPECT_EQ(last_msg_.x, -6444804) + << "incorrect value for last_msg_.x, expected -6444804, is " + << last_msg_.x; + EXPECT_EQ(last_msg_.y, -1866844813) + << "incorrect value for last_msg_.y, expected -1866844813, is " + << last_msg_.y; + EXPECT_EQ(last_msg_.z, 622997694) + << "incorrect value for last_msg_.z, expected 622997694, is " + << last_msg_.z; +} diff --git a/c/test/legacy/auto_check_sbp_navigation_MsgPoseRelative.c b/c/test/legacy/auto_check_sbp_navigation_MsgPoseRelative.c new file mode 100644 index 0000000000..42c5fcff54 --- /dev/null +++ b/c/test/legacy/auto_check_sbp_navigation_MsgPoseRelative.c @@ -0,0 +1,317 @@ +/* + * 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 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/navigation/test_MsgPoseRelative.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; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 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; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_navigation_MsgPoseRelative) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // 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_payload_callback_register(&sbp_state, 0x245, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 0x245, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 69, 2, 66, 0, 90, 86, 4, 0, 0, 0, 86, 4, 0, + 0, 172, 8, 0, 0, 76, 4, 0, 0, 38, 2, 0, 0, 100, + 0, 0, 0, 100, 3, 200, 204, 252, 168, 157, 255, 115, 53, 186, + 144, 190, 48, 34, 37, 0, 0, 128, 63, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, + 63, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 64, 5, 171, 187, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_pose_relative_t *test_msg = (msg_pose_relative_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + test_msg->cov_c_x_x = 2.0; + test_msg->cov_c_x_y = 0.0; + test_msg->cov_c_x_z = 0.0; + test_msg->cov_c_y_y = 2.0; + test_msg->cov_c_y_z = 0.0; + test_msg->cov_c_z_z = 2.0; + test_msg->cov_r_x_x = 1.0; + test_msg->cov_r_x_y = 0.0; + test_msg->cov_r_x_z = 0.0; + test_msg->cov_r_y_y = 1.0; + test_msg->cov_r_y_z = 0.0; + test_msg->cov_r_z_z = 1.0; + test_msg->flags = 5; + test_msg->sensor_id = 0; + test_msg->timestamp_1 = 1110; + test_msg->timestamp_2 = 2220; + test_msg->tow = 1110; + if (sizeof(test_msg->trans) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->trans[0]); + } + test_msg->trans[0] = 1100; + if (sizeof(test_msg->trans) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->trans[0]); + } + test_msg->trans[1] = 550; + if (sizeof(test_msg->trans) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->trans[0]); + } + test_msg->trans[2] = 100; + test_msg->w = -859307164; + test_msg->x = -6444804; + test_msg->y = -1866844813; + test_msg->z = 622997694; + sbp_payload_send(&sbp_state, 0x245, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + 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(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 0x245, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_pose_relative_t *check_msg = + (msg_pose_relative_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg((check_msg->cov_c_x_x * 100 - 2.0 * 100) < 0.05, + "incorrect value for cov_c_x_x, expected 2.0, is %f", + check_msg->cov_c_x_x); + ck_assert_msg((check_msg->cov_c_x_y * 100 - 0.0 * 100) < 0.05, + "incorrect value for cov_c_x_y, expected 0.0, is %f", + check_msg->cov_c_x_y); + ck_assert_msg((check_msg->cov_c_x_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for cov_c_x_z, expected 0.0, is %f", + check_msg->cov_c_x_z); + ck_assert_msg((check_msg->cov_c_y_y * 100 - 2.0 * 100) < 0.05, + "incorrect value for cov_c_y_y, expected 2.0, is %f", + check_msg->cov_c_y_y); + ck_assert_msg((check_msg->cov_c_y_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for cov_c_y_z, expected 0.0, is %f", + check_msg->cov_c_y_z); + ck_assert_msg((check_msg->cov_c_z_z * 100 - 2.0 * 100) < 0.05, + "incorrect value for cov_c_z_z, expected 2.0, is %f", + check_msg->cov_c_z_z); + ck_assert_msg((check_msg->cov_r_x_x * 100 - 1.0 * 100) < 0.05, + "incorrect value for cov_r_x_x, expected 1.0, is %f", + check_msg->cov_r_x_x); + ck_assert_msg((check_msg->cov_r_x_y * 100 - 0.0 * 100) < 0.05, + "incorrect value for cov_r_x_y, expected 0.0, is %f", + check_msg->cov_r_x_y); + ck_assert_msg((check_msg->cov_r_x_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for cov_r_x_z, expected 0.0, is %f", + check_msg->cov_r_x_z); + ck_assert_msg((check_msg->cov_r_y_y * 100 - 1.0 * 100) < 0.05, + "incorrect value for cov_r_y_y, expected 1.0, is %f", + check_msg->cov_r_y_y); + ck_assert_msg((check_msg->cov_r_y_z * 100 - 0.0 * 100) < 0.05, + "incorrect value for cov_r_y_z, expected 0.0, is %f", + check_msg->cov_r_y_z); + ck_assert_msg((check_msg->cov_r_z_z * 100 - 1.0 * 100) < 0.05, + "incorrect value for cov_r_z_z, expected 1.0, is %f", + check_msg->cov_r_z_z); + ck_assert_msg(check_msg->flags == 5, + "incorrect value for flags, expected 5, is %d", + check_msg->flags); + ck_assert_msg(check_msg->sensor_id == 0, + "incorrect value for sensor_id, expected 0, is %d", + check_msg->sensor_id); + ck_assert_msg(check_msg->timestamp_1 == 1110, + "incorrect value for timestamp_1, expected 1110, is %d", + check_msg->timestamp_1); + ck_assert_msg(check_msg->timestamp_2 == 2220, + "incorrect value for timestamp_2, expected 2220, is %d", + check_msg->timestamp_2); + ck_assert_msg(check_msg->tow == 1110, + "incorrect value for tow, expected 1110, is %d", + check_msg->tow); + ck_assert_msg(check_msg->trans[0] == 1100, + "incorrect value for trans[0], expected 1100, is %d", + check_msg->trans[0]); + ck_assert_msg(check_msg->trans[1] == 550, + "incorrect value for trans[1], expected 550, is %d", + check_msg->trans[1]); + ck_assert_msg(check_msg->trans[2] == 100, + "incorrect value for trans[2], expected 100, is %d", + check_msg->trans[2]); + ck_assert_msg(check_msg->w == -859307164, + "incorrect value for w, expected -859307164, is %d", + check_msg->w); + ck_assert_msg(check_msg->x == -6444804, + "incorrect value for x, expected -6444804, is %d", + check_msg->x); + ck_assert_msg(check_msg->y == -1866844813, + "incorrect value for y, expected -1866844813, is %d", + check_msg->y); + ck_assert_msg(check_msg->z == 622997694, + "incorrect value for z, expected 622997694, is %d", + check_msg->z); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_navigation_MsgPoseRelative_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_navigation_MsgPoseRelative"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_navigation_MsgPoseRelative"); + tcase_add_test(tc_acq, test_legacy_auto_check_sbp_navigation_MsgPoseRelative); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc new file mode 100644 index 0000000000..33e237ad64 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgPoseRelative.cc @@ -0,0 +1,209 @@ +/* + * 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 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/navigation/test_MsgPoseRelative.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_navigation_MsgPoseRelative0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_navigation_MsgPoseRelative0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_pose_relative_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_pose_relative_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_navigation_MsgPoseRelative0, Test) { + uint8_t encoded_frame[] = { + 85, 69, 2, 66, 0, 90, 86, 4, 0, 0, 0, 86, 4, 0, + 0, 172, 8, 0, 0, 76, 4, 0, 0, 38, 2, 0, 0, 100, + 0, 0, 0, 100, 3, 200, 204, 252, 168, 157, 255, 115, 53, 186, + 144, 190, 48, 34, 37, 0, 0, 128, 63, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, + 63, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 64, 5, 171, 187, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_pose_relative_t *test_msg = (msg_pose_relative_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + test_msg->cov_c_x_x = 2.0; + test_msg->cov_c_x_y = 0.0; + test_msg->cov_c_x_z = 0.0; + test_msg->cov_c_y_y = 2.0; + test_msg->cov_c_y_z = 0.0; + test_msg->cov_c_z_z = 2.0; + test_msg->cov_r_x_x = 1.0; + test_msg->cov_r_x_y = 0.0; + test_msg->cov_r_x_z = 0.0; + test_msg->cov_r_y_y = 1.0; + test_msg->cov_r_y_z = 0.0; + test_msg->cov_r_z_z = 1.0; + test_msg->flags = 5; + test_msg->sensor_id = 0; + test_msg->timestamp_1 = 1110; + test_msg->timestamp_2 = 2220; + test_msg->tow = 1110; + if (sizeof(test_msg->trans) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->trans[0])); + } + test_msg->trans[0] = 1100; + if (sizeof(test_msg->trans) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->trans[0])); + } + test_msg->trans[1] = 550; + if (sizeof(test_msg->trans) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->trans[0])); + } + test_msg->trans[2] = 100; + test_msg->w = -859307164; + test_msg->x = -6444804; + test_msg->y = -1866844813; + test_msg->z = 622997694; + + EXPECT_EQ(send_message(0x245, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_LT((last_msg_->cov_c_x_x * 100 - 2.0 * 100), 0.05) + << "incorrect value for cov_c_x_x, expected 2.0, is " + << last_msg_->cov_c_x_x; + EXPECT_LT((last_msg_->cov_c_x_y * 100 - 0.0 * 100), 0.05) + << "incorrect value for cov_c_x_y, expected 0.0, is " + << last_msg_->cov_c_x_y; + EXPECT_LT((last_msg_->cov_c_x_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for cov_c_x_z, expected 0.0, is " + << last_msg_->cov_c_x_z; + EXPECT_LT((last_msg_->cov_c_y_y * 100 - 2.0 * 100), 0.05) + << "incorrect value for cov_c_y_y, expected 2.0, is " + << last_msg_->cov_c_y_y; + EXPECT_LT((last_msg_->cov_c_y_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for cov_c_y_z, expected 0.0, is " + << last_msg_->cov_c_y_z; + EXPECT_LT((last_msg_->cov_c_z_z * 100 - 2.0 * 100), 0.05) + << "incorrect value for cov_c_z_z, expected 2.0, is " + << last_msg_->cov_c_z_z; + EXPECT_LT((last_msg_->cov_r_x_x * 100 - 1.0 * 100), 0.05) + << "incorrect value for cov_r_x_x, expected 1.0, is " + << last_msg_->cov_r_x_x; + EXPECT_LT((last_msg_->cov_r_x_y * 100 - 0.0 * 100), 0.05) + << "incorrect value for cov_r_x_y, expected 0.0, is " + << last_msg_->cov_r_x_y; + EXPECT_LT((last_msg_->cov_r_x_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for cov_r_x_z, expected 0.0, is " + << last_msg_->cov_r_x_z; + EXPECT_LT((last_msg_->cov_r_y_y * 100 - 1.0 * 100), 0.05) + << "incorrect value for cov_r_y_y, expected 1.0, is " + << last_msg_->cov_r_y_y; + EXPECT_LT((last_msg_->cov_r_y_z * 100 - 0.0 * 100), 0.05) + << "incorrect value for cov_r_y_z, expected 0.0, is " + << last_msg_->cov_r_y_z; + EXPECT_LT((last_msg_->cov_r_z_z * 100 - 1.0 * 100), 0.05) + << "incorrect value for cov_r_z_z, expected 1.0, is " + << last_msg_->cov_r_z_z; + EXPECT_EQ(last_msg_->flags, 5) + << "incorrect value for flags, expected 5, is " << last_msg_->flags; + EXPECT_EQ(last_msg_->sensor_id, 0) + << "incorrect value for sensor_id, expected 0, is " + << last_msg_->sensor_id; + EXPECT_EQ(last_msg_->timestamp_1, 1110) + << "incorrect value for timestamp_1, expected 1110, is " + << last_msg_->timestamp_1; + EXPECT_EQ(last_msg_->timestamp_2, 2220) + << "incorrect value for timestamp_2, expected 2220, is " + << last_msg_->timestamp_2; + EXPECT_EQ(last_msg_->tow, 1110) + << "incorrect value for tow, expected 1110, is " << last_msg_->tow; + EXPECT_EQ(last_msg_->trans[0], 1100) + << "incorrect value for trans[0], expected 1100, is " + << last_msg_->trans[0]; + EXPECT_EQ(last_msg_->trans[1], 550) + << "incorrect value for trans[1], expected 550, is " + << last_msg_->trans[1]; + EXPECT_EQ(last_msg_->trans[2], 100) + << "incorrect value for trans[2], expected 100, is " + << last_msg_->trans[2]; + EXPECT_EQ(last_msg_->w, -859307164) + << "incorrect value for w, expected -859307164, is " << last_msg_->w; + EXPECT_EQ(last_msg_->x, -6444804) + << "incorrect value for x, expected -6444804, is " << last_msg_->x; + EXPECT_EQ(last_msg_->y, -1866844813) + << "incorrect value for y, expected -1866844813, is " << last_msg_->y; + EXPECT_EQ(last_msg_->z, 622997694) + << "incorrect value for z, expected 622997694, is " << last_msg_->z; +} diff --git a/docs/sbp.pdf b/docs/sbp.pdf index 8d5760510a20dc982807795738ec96e4ba12e00a..8dacbabe96a4bce9c479eb6e1cf78d4a4b571236 100644 GIT binary patch delta 148322 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%0DTL-wKOvj9npsod#Vqk~ME1!(- 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 delta 143635 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

NQKpT>!>?Dq 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%0A|;5dB{xDn?(#K; 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 pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgPosLlhDepA = SBPMsgPosLlhDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgPosLlhGnss = SBPMsgPosLlhGnss <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgPoseRelative = SBPMsgPoseRelative <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgPpsTime = SBPMsgPpsTime <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgPrintDep = SBPMsgPrintDep <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgProtectionLevel = SBPMsgProtectionLevel <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj @@ -1118,6 +1122,7 @@ instance ToJSON SBPMsg where toJSON (SBPMsgPosLlhCovGnss n m) = toJSON n <<>> toJSON m toJSON (SBPMsgPosLlhDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgPosLlhGnss n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgPoseRelative n m) = toJSON n <<>> toJSON m toJSON (SBPMsgPpsTime n m) = toJSON n <<>> toJSON m toJSON (SBPMsgPrintDep n m) = toJSON n <<>> toJSON m toJSON (SBPMsgProtectionLevel n m) = toJSON n <<>> toJSON m @@ -1344,6 +1349,7 @@ instance HasMsg SBPMsg where msg f (SBPMsgPosLlhCovGnss n m) = SBPMsgPosLlhCovGnss n <$> f m msg f (SBPMsgPosLlhDepA n m) = SBPMsgPosLlhDepA n <$> f m msg f (SBPMsgPosLlhGnss n m) = SBPMsgPosLlhGnss n <$> f m + msg f (SBPMsgPoseRelative n m) = SBPMsgPoseRelative n <$> f m msg f (SBPMsgPpsTime n m) = SBPMsgPpsTime n <$> f m msg f (SBPMsgPrintDep n m) = SBPMsgPrintDep n <$> f m msg f (SBPMsgProtectionLevel n m) = SBPMsgProtectionLevel n <$> f m diff --git a/haskell/src/SwiftNav/SBP/Navigation.hs b/haskell/src/SwiftNav/SBP/Navigation.hs index a471879701..2ae05b1ab1 100644 --- a/haskell/src/SwiftNav/SBP/Navigation.hs +++ b/haskell/src/SwiftNav/SBP/Navigation.hs @@ -2456,3 +2456,120 @@ instance Binary MsgReferenceFrameParam where $(makeSBP 'msgReferenceFrameParam ''MsgReferenceFrameParam) $(makeJSON "_msgReferenceFrameParam_" ''MsgReferenceFrameParam) $(makeLenses ''MsgReferenceFrameParam) + +msgPoseRelative :: Word16 +msgPoseRelative = 0x0245 + +-- | SBP class for message MSG_POSE_RELATIVE (0x0245). +-- +-- This solution message reports the relative pose of a sensor between two +-- time instances. The relative pose comprises of a rotation and a translation +-- which relates the sensor (e.g. camera) frame at a given time (first +-- keyframe) to the sensor frame at another time (second key frame). The +-- relative translations is a 3x1 vector described in the first keyframe. +-- Relative rotation is described by a quaternion from second keyframe to the +-- first keyframe. +data MsgPoseRelative = MsgPoseRelative + { _msgPoseRelative_tow :: !Word32 + -- ^ GPS Time of Week + , _msgPoseRelative_sensor_id :: !Word8 + -- ^ ID of the sensor producing this message + , _msgPoseRelative_timestamp_1 :: !Word32 + -- ^ Timestamp of first keyframe + , _msgPoseRelative_timestamp_2 :: !Word32 + -- ^ Timestamp of second keyframe + , _msgPoseRelative_trans :: ![Int32] + -- ^ Relative translation [x,y,z] described in first keyframe + , _msgPoseRelative_w :: !Int32 + -- ^ Real component of quaternion to describe relative rotation (second to + -- first keyframe) + , _msgPoseRelative_x :: !Int32 + -- ^ 1st imaginary component of quaternion to describe relative rotation + -- (second to first keyframe) + , _msgPoseRelative_y :: !Int32 + -- ^ 2nd imaginary component of quaternion to describe relative rotation + -- (second to first keyframe) + , _msgPoseRelative_z :: !Int32 + -- ^ 3rd imaginary component of quaternion to describe relative rotation + -- (second to first keyframe) + , _msgPoseRelative_cov_r_x_x :: !Float + -- ^ Estimated variance of x (relative translation) + , _msgPoseRelative_cov_r_x_y :: !Float + -- ^ Covariance of x and y (relative translation) + , _msgPoseRelative_cov_r_x_z :: !Float + -- ^ Covariance of x and z (relative translation) + , _msgPoseRelative_cov_r_y_y :: !Float + -- ^ Estimated variance of y (relative translation) + , _msgPoseRelative_cov_r_y_z :: !Float + -- ^ Covariance of y and z (relative translation) + , _msgPoseRelative_cov_r_z_z :: !Float + -- ^ Estimated variance of z (relative translation) + , _msgPoseRelative_cov_c_x_x :: !Float + -- ^ Estimated variance of x (relative rotation) + , _msgPoseRelative_cov_c_x_y :: !Float + -- ^ Covariance of x and y (relative rotation) + , _msgPoseRelative_cov_c_x_z :: !Float + -- ^ Covariance of x and z (relative rotation) + , _msgPoseRelative_cov_c_y_y :: !Float + -- ^ Estimated variance of y (relative rotation) + , _msgPoseRelative_cov_c_y_z :: !Float + -- ^ Covariance of y and z (relative rotation) + , _msgPoseRelative_cov_c_z_z :: !Float + -- ^ Estimated variance of z (relative rotation) + , _msgPoseRelative_flags :: !Word8 + -- ^ Status flags of relative translation and rotation + } deriving ( Show, Read, Eq ) + +instance Binary MsgPoseRelative where + get = do + _msgPoseRelative_tow <- getWord32le + _msgPoseRelative_sensor_id <- getWord8 + _msgPoseRelative_timestamp_1 <- getWord32le + _msgPoseRelative_timestamp_2 <- getWord32le + _msgPoseRelative_trans <- replicateM 3 (fromIntegral <$> getWord32le) + _msgPoseRelative_w <- (fromIntegral <$> getWord32le) + _msgPoseRelative_x <- (fromIntegral <$> getWord32le) + _msgPoseRelative_y <- (fromIntegral <$> getWord32le) + _msgPoseRelative_z <- (fromIntegral <$> getWord32le) + _msgPoseRelative_cov_r_x_x <- getFloat32le + _msgPoseRelative_cov_r_x_y <- getFloat32le + _msgPoseRelative_cov_r_x_z <- getFloat32le + _msgPoseRelative_cov_r_y_y <- getFloat32le + _msgPoseRelative_cov_r_y_z <- getFloat32le + _msgPoseRelative_cov_r_z_z <- getFloat32le + _msgPoseRelative_cov_c_x_x <- getFloat32le + _msgPoseRelative_cov_c_x_y <- getFloat32le + _msgPoseRelative_cov_c_x_z <- getFloat32le + _msgPoseRelative_cov_c_y_y <- getFloat32le + _msgPoseRelative_cov_c_y_z <- getFloat32le + _msgPoseRelative_cov_c_z_z <- getFloat32le + _msgPoseRelative_flags <- getWord8 + pure MsgPoseRelative {..} + + put MsgPoseRelative {..} = do + putWord32le _msgPoseRelative_tow + putWord8 _msgPoseRelative_sensor_id + putWord32le _msgPoseRelative_timestamp_1 + putWord32le _msgPoseRelative_timestamp_2 + mapM_ (putWord32le . fromIntegral) _msgPoseRelative_trans + (putWord32le . fromIntegral) _msgPoseRelative_w + (putWord32le . fromIntegral) _msgPoseRelative_x + (putWord32le . fromIntegral) _msgPoseRelative_y + (putWord32le . fromIntegral) _msgPoseRelative_z + putFloat32le _msgPoseRelative_cov_r_x_x + putFloat32le _msgPoseRelative_cov_r_x_y + putFloat32le _msgPoseRelative_cov_r_x_z + putFloat32le _msgPoseRelative_cov_r_y_y + putFloat32le _msgPoseRelative_cov_r_y_z + putFloat32le _msgPoseRelative_cov_r_z_z + putFloat32le _msgPoseRelative_cov_c_x_x + putFloat32le _msgPoseRelative_cov_c_x_y + putFloat32le _msgPoseRelative_cov_c_x_z + putFloat32le _msgPoseRelative_cov_c_y_y + putFloat32le _msgPoseRelative_cov_c_y_z + putFloat32le _msgPoseRelative_cov_c_z_z + putWord8 _msgPoseRelative_flags + +$(makeSBP 'msgPoseRelative ''MsgPoseRelative) +$(makeJSON "_msgPoseRelative_" ''MsgPoseRelative) +$(makeLenses ''MsgPoseRelative) diff --git a/javascript/sbp.bundle.js b/javascript/sbp.bundle.js index d5de96b699..9195a17623 100644 --- a/javascript/sbp.bundle.js +++ b/javascript/sbp.bundle.js @@ -1,15 +1,15 @@ -!function(e){var t={};function p(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,p),o.l=!0,o.exports}p.m=e,p.c=t,p.d=function(e,t,r){p.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:r})},p.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},p.t=function(e,t){if(1&t&&(e=p(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var r=Object.create(null);if(p.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)p.d(r,o,function(t){return e[t]}.bind(null,o));return r},p.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return p.d(t,"a",t),t},p.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},p.p="",p(p.s=24)}([function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=function(e,t){return r.call(this,e),this.messageType="GPSTime",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="GPSTime",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("tow").int32("ns_residual").uint16("wn"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),u.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),u.prototype.fieldSpec.push(["wn","writeUInt16LE",2]);let c=function(e,t){return r.call(this,e),this.messageType="CarrierPhase",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="CarrierPhase",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").int32("i").uint8("f"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["i","writeInt32LE",4]),c.prototype.fieldSpec.push(["f","writeUInt8",1]),e.exports={GnssSignal:i,SvId:s,GnssSignalDep:n,GPSTimeDep:a,GPSTimeSec:l,GPSTime:u,CarrierPhase:c}},function(e,t,p){t.UINT32=p(44),t.UINT64=p(45)},function(e,t,p){(function(t){var r=p(43),o=(p(3),p(1).UINT64),i=function(e,p,r,o){var i=new t(e);return i[p](r,o||0),i};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,p){var i=[];for(var s in e=e||this.fieldSpec,p=p||this.fields,e){var n=e[s],a=n[0],l=n[1],u=function(e){return"function"==typeof e?e.apply(this):e}.bind(this);if("string"==typeof l&&0===l.indexOf("write")){var c=u(n[2]);if("writeUInt64LE"===l){r(p[a]instanceof o,"uint64 type must be represented by cuint.UINT64");var y=p[a].clone().shiftRight(32).and(new o(4294967295,0)).toNumber(),h=p[a].clone().and(new o(4294967295,0)).toNumber();let e=new t(8);e.writeUInt32LE(h),e.writeUInt32LE(y,4),i.push(e)}else{let e=new t(c);e[l](p[a],0),i.push(e)}}else if("string"===l){let e=new t(p[a].length);e.write(p[a],0,"utf8"),i.push(e)}else if("array"===l){var f=n[2];for(var d in p[a]){var _=p[a][d];if(Array.isArray(f))i=i.concat(this.payloadToBuffer(f,_));else{let e=new t(u(n[3]));e[f](_,0),i.push(e)}}}else i=i.concat(this.payloadToBuffer(l,p[a]))}return t.concat(i)},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(),p=i(2,"writeUInt16LE",this.crc||this.sbp.crc,0),r=[this.getPreambleBuffer(),this.getMsgTypeBuffer(),this.getSenderBuffer(),this.getLengthBuffer()];return t.concat(r.concat(e).concat(p))},s.prototype.toJSON=function(){var e={};return Object.keys(this.sbp).forEach(function(p){this.sbp[p]instanceof t?e[p]=this.sbp[p].toString("base64"):e[p]=this.sbp[p]}.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}).call(this,p(8).Buffer)},function(e,t,p){(function(t){for(var p=4294967296,r=[],o=0;o<256;o++)r[o]=(o>15?"":"0")+o.toString(16);var i=e.exports=function(e,p){e instanceof t?(this.buffer=e,this.offset=p||0):"[object Uint8Array]"==Object.prototype.toString.call(e)?(this.buffer=new t(e),this.offset=p||0):(this.buffer=this.buffer||new t(8),this.offset=0,this.setValue.apply(this,arguments))};i.MAX_INT=Math.pow(2,53),i.MIN_INT=-Math.pow(2,53),i.prototype={constructor:i,_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,t){var r=!1;if(1==arguments.length)if("number"==typeof e){if(r=e<0,t=(e=Math.abs(e))%p,(e/=p)>p)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");t=(e=(e+"").replace(/^0x/,"")).substr(-8),e=e.length>8?e.substr(0,e.length-8):"",e=parseInt(e,16),t=parseInt(t,16)}for(var o=this.buffer,i=this.offset,s=7;s>=0;s--)o[i+s]=255&t,t=4==s?e:t>>>8;r&&this._2scomp()},toNumber:function(e){for(var t=this.buffer,p=this.offset,r=128&t[p],o=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),o+=l*a}return!e&&o>=i.MAX_INT?r?-1/0:1/0:r?-o:o},valueOf:function(){return this.toNumber(!1)},toString:function(e){return this.valueOf().toString(e||10)},toOctetString:function(e){for(var t=new Array(8),p=this.buffer,o=this.offset,i=0;i<8;i++)t[i]=r[p[o+i]];return t.join(e||"")},toBuffer:function(e){if(e&&0===this.offset)return this.buffer;var p=new t(8);return this.buffer.copy(p,0,this.offset,this.offset+8),p},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(" ")+"]"}}}).call(this,p(8).Buffer)},function(e,t,p){(function(t){var r=p(17).Parser;r.prototype.uint64=function(e,t){return this.setNextParser("uint64",e,Object.assign({},t,{formatter:function(e){var t=p(1).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(r,o,i){return"undefined"!=typeof window&&void 0===window.Buffer&&(window.Buffer=t),new Function("buffer","callback","constructorFn","require",e).call(this,r,o,i,(function(e){if("cuint"===e)return p(1);throw new Error("Unknown module required: "+e)}))}},e.exports=r}).call(this,p(8).Buffer)},function(e,t){var p;p=function(){return this}();try{p=p||new Function("return this")()}catch(e){"object"==typeof window&&(p=window)}e.exports=p},function(e,t){"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}},function(e,t,p){"use strict";var r=p(11),o=Object.keys||function(e){var t=[];for(var p in e)t.push(p);return t};e.exports=c;var i=p(10);i.inherits=p(6);var s=p(19),n=p(15);i.inherits(c,s);for(var a=o(n.prototype),l=0;l15?"":"0")+o.toString(16);var i=e.exports=function(e,p){e instanceof t?(this.buffer=e,this.offset=p||0):"[object Uint8Array]"==Object.prototype.toString.call(e)?(this.buffer=new t(e),this.offset=p||0):(this.buffer=this.buffer||new t(8),this.offset=0,this.setValue.apply(this,arguments))};i.MAX_INT=Math.pow(2,53),i.MIN_INT=-Math.pow(2,53),i.prototype={constructor:i,_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,t){var r=!1;if(1==arguments.length)if("number"==typeof e){if(r=e<0,t=(e=Math.abs(e))%p,(e/=p)>p)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");t=(e=(e+"").replace(/^0x/,"")).substr(-8),e=e.length>8?e.substr(0,e.length-8):"",e=parseInt(e,16),t=parseInt(t,16)}for(var o=this.buffer,i=this.offset,s=7;s>=0;s--)o[i+s]=255&t,t=4==s?e:t>>>8;r&&this._2scomp()},toNumber:function(e){for(var t=this.buffer,p=this.offset,r=128&t[p],o=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),o+=l*a}return!e&&o>=i.MAX_INT?r?-1/0:1/0:r?-o:o},valueOf:function(){return this.toNumber(!1)},toString:function(e){return this.valueOf().toString(e||10)},toOctetString:function(e){for(var t=new Array(8),p=this.buffer,o=this.offset,i=0;i<8;i++)t[i]=r[p[o+i]];return t.join(e||"")},toBuffer:function(e){if(e&&0===this.offset)return this.buffer;var p=new t(8);return this.buffer.copy(p,0,this.offset,this.offset+8),p},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(" ")+"]"}}}).call(this,p(8).Buffer)},function(e,t,p){(function(t){var r=p(17).Parser;r.prototype.uint64=function(e,t){return this.setNextParser("uint64",e,Object.assign({},t,{formatter:function(e){var t=p(1).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(r,o,i){return"undefined"!=typeof window&&void 0===window.Buffer&&(window.Buffer=t),new Function("buffer","callback","constructorFn","require",e).call(this,r,o,i,(function(e){if("cuint"===e)return p(1);throw new Error("Unknown module required: "+e)}))}},e.exports=r}).call(this,p(8).Buffer)},function(e,t){var p;p=function(){return this}();try{p=p||new Function("return this")()}catch(e){"object"==typeof window&&(p=window)}e.exports=p},function(e,t){"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}},function(e,t,p){"use strict";var r=p(11),o=Object.keys||function(e){var t=[];for(var p in e)t.push(p);return t};e.exports=u;var i=p(10);i.inherits=p(6);var s=p(19),n=p(15);i.inherits(u,s);for(var a=o(n.prototype),l=0;l * @license MIT */ -var r=p(25),o=p(26),i=p(16);function s(){return a.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function n(e,t){if(s()=s())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+s().toString(16)+" bytes");return 0|e}function f(e,t){if(a.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var p=e.length;if(0===p)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return p;case"utf8":case"utf-8":case void 0:return F(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*p;case"hex":return p>>>1;case"base64":return B(e).length;default:if(r)return F(e).length;t=(""+t).toLowerCase(),r=!0}}function d(e,t,p){var r=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===p||p>this.length)&&(p=this.length),p<=0)return"";if((p>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return D(this,t,p);case"utf8":case"utf-8":return v(this,t,p);case"ascii":return U(this,t,p);case"latin1":case"binary":return M(this,t,p);case"base64":return T(this,t,p);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return O(this,t,p);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}function _(e,t,p){var r=e[t];e[t]=e[p],e[p]=r}function S(e,t,p,r,o){if(0===e.length)return-1;if("string"==typeof p?(r=p,p=0):p>2147483647?p=2147483647:p<-2147483648&&(p=-2147483648),p=+p,isNaN(p)&&(p=o?0:e.length-1),p<0&&(p=e.length+p),p>=e.length){if(o)return-1;p=e.length-1}else if(p<0){if(!o)return-1;p=0}if("string"==typeof t&&(t=a.from(t,r)),a.isBuffer(t))return 0===t.length?-1:g(e,t,p,r,o);if("number"==typeof t)return t&=255,a.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,p):Uint8Array.prototype.lastIndexOf.call(e,t,p):g(e,[t],p,r,o);throw new TypeError("val must be string, number or Buffer")}function g(e,t,p,r,o){var i,s=1,n=e.length,a=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;s=2,n/=2,a/=2,p/=2}function l(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(o){var u=-1;for(i=p;in&&(p=n-a),i=p;i>=0;i--){for(var c=!0,y=0;yo&&(r=o):r=o;var i=t.length;if(i%2!=0)throw new TypeError("Invalid hex string");r>i/2&&(r=i/2);for(var s=0;s>8,o=p%256,i.push(o),i.push(r);return i}(t,e.length-p),e,p,r)}function T(e,t,p){return 0===t&&p===e.length?r.fromByteArray(e):r.fromByteArray(e.slice(t,p))}function v(e,t,p){p=Math.min(e.length,p);for(var r=[],o=t;o239?4:l>223?3:l>191?2:1;if(o+c<=p)switch(c){case 1:l<128&&(u=l);break;case 2:128==(192&(i=e[o+1]))&&(a=(31&l)<<6|63&i)>127&&(u=a);break;case 3:i=e[o+1],s=e[o+2],128==(192&i)&&128==(192&s)&&(a=(15&l)<<12|(63&i)<<6|63&s)>2047&&(a<55296||a>57343)&&(u=a);break;case 4:i=e[o+1],s=e[o+2],n=e[o+3],128==(192&i)&&128==(192&s)&&128==(192&n)&&(a=(15&l)<<18|(63&i)<<12|(63&s)<<6|63&n)>65535&&a<1114112&&(u=a)}null===u?(u=65533,c=1):u>65535&&(u-=65536,r.push(u>>>10&1023|55296),u=56320|1023&u),r.push(u),o+=c}return function(e){var t=e.length;if(t<=4096)return String.fromCharCode.apply(String,e);var p="",r=0;for(;r0&&(e=this.toString("hex",0,p).match(/.{2}/g).join(" "),this.length>p&&(e+=" ... ")),""},a.prototype.compare=function(e,t,p,r,o){if(!a.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===p&&(p=e?e.length:0),void 0===r&&(r=0),void 0===o&&(o=this.length),t<0||p>e.length||r<0||o>this.length)throw new RangeError("out of range index");if(r>=o&&t>=p)return 0;if(r>=o)return-1;if(t>=p)return 1;if(this===e)return 0;for(var i=(o>>>=0)-(r>>>=0),s=(p>>>=0)-(t>>>=0),n=Math.min(i,s),l=this.slice(r,o),u=e.slice(t,p),c=0;co)&&(p=o),e.length>0&&(p<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var i=!1;;)switch(r){case"hex":return w(this,e,t,p);case"utf8":case"utf-8":return E(this,e,t,p);case"ascii":return m(this,e,t,p);case"latin1":case"binary":return b(this,e,t,p);case"base64":return I(this,e,t,p);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return L(this,e,t,p);default:if(i)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),i=!0}},a.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function U(e,t,p){var r="";p=Math.min(e.length,p);for(var o=t;or)&&(p=r);for(var o="",i=t;ip)throw new RangeError("Trying to access beyond buffer length")}function A(e,t,p,r,o,i){if(!a.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function C(e,t,p,r){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-p,2);o>>8*(r?o:1-o)}function R(e,t,p,r){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-p,4);o>>8*(r?o:3-o)&255}function P(e,t,p,r,o,i){if(p+r>e.length)throw new RangeError("Index out of range");if(p<0)throw new RangeError("Index out of range")}function N(e,t,p,r,i){return i||P(e,0,p,4),o.write(e,t,p,r,23,4),p+4}function j(e,t,p,r,i){return i||P(e,0,p,8),o.write(e,t,p,r,52,8),p+8}a.prototype.slice=function(e,t){var p,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),(t=void 0===t?r:~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),t0&&(o*=256);)r+=this[e+--t]*o;return r},a.prototype.readUInt8=function(e,t){return t||G(e,1,this.length),this[e]},a.prototype.readUInt16LE=function(e,t){return t||G(e,2,this.length),this[e]|this[e+1]<<8},a.prototype.readUInt16BE=function(e,t){return t||G(e,2,this.length),this[e]<<8|this[e+1]},a.prototype.readUInt32LE=function(e,t){return t||G(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},a.prototype.readUInt32BE=function(e,t){return t||G(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},a.prototype.readIntLE=function(e,t,p){e|=0,t|=0,p||G(e,t,this.length);for(var r=this[e],o=1,i=0;++i=(o*=128)&&(r-=Math.pow(2,8*t)),r},a.prototype.readIntBE=function(e,t,p){e|=0,t|=0,p||G(e,t,this.length);for(var r=t,o=1,i=this[e+--r];r>0&&(o*=256);)i+=this[e+--r]*o;return i>=(o*=128)&&(i-=Math.pow(2,8*t)),i},a.prototype.readInt8=function(e,t){return t||G(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},a.prototype.readInt16LE=function(e,t){t||G(e,2,this.length);var p=this[e]|this[e+1]<<8;return 32768&p?4294901760|p:p},a.prototype.readInt16BE=function(e,t){t||G(e,2,this.length);var p=this[e+1]|this[e]<<8;return 32768&p?4294901760|p:p},a.prototype.readInt32LE=function(e,t){return t||G(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},a.prototype.readInt32BE=function(e,t){return t||G(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},a.prototype.readFloatLE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!0,23,4)},a.prototype.readFloatBE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!1,23,4)},a.prototype.readDoubleLE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!0,52,8)},a.prototype.readDoubleBE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!1,52,8)},a.prototype.writeUIntLE=function(e,t,p,r){(e=+e,t|=0,p|=0,r)||A(this,e,t,p,Math.pow(2,8*p)-1,0);var o=1,i=0;for(this[t]=255&e;++i=0&&(i*=256);)this[t+o]=e/i&255;return t+p},a.prototype.writeUInt8=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,1,255,0),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},a.prototype.writeUInt16LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeUInt16BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeUInt32LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):R(this,e,t,!0),t+4},a.prototype.writeUInt32BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeIntLE=function(e,t,p,r){if(e=+e,t|=0,!r){var o=Math.pow(2,8*p-1);A(this,e,t,p,o-1,-o)}var i=0,s=1,n=0;for(this[t]=255&e;++i>0)-n&255;return t+p},a.prototype.writeIntBE=function(e,t,p,r){if(e=+e,t|=0,!r){var o=Math.pow(2,8*p-1);A(this,e,t,p,o-1,-o)}var i=p-1,s=1,n=0;for(this[t+i]=255&e;--i>=0&&(s*=256);)e<0&&0===n&&0!==this[t+i+1]&&(n=1),this[t+i]=(e/s>>0)-n&255;return t+p},a.prototype.writeInt8=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,1,127,-128),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},a.prototype.writeInt16LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeInt16BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeInt32LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,2147483647,-2147483648),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):R(this,e,t,!0),t+4},a.prototype.writeInt32BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeFloatLE=function(e,t,p){return N(this,e,t,!0,p)},a.prototype.writeFloatBE=function(e,t,p){return N(this,e,t,!1,p)},a.prototype.writeDoubleLE=function(e,t,p){return j(this,e,t,!0,p)},a.prototype.writeDoubleBE=function(e,t,p){return j(this,e,t,!1,p)},a.prototype.copy=function(e,t,p,r){if(p||(p=0),r||0===r||(r=this.length),t>=e.length&&(t=e.length),t||(t=0),r>0&&r=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t=0;--o)e[o+t]=this[o+p];else if(i<1e3||!a.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,p=void 0===p?this.length:p>>>0,e||(e=0),"number"==typeof e)for(i=t;i55295&&p<57344){if(!o){if(p>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(s+1===r){(t-=3)>-1&&i.push(239,191,189);continue}o=p;continue}if(p<56320){(t-=3)>-1&&i.push(239,191,189),o=p;continue}p=65536+(o-55296<<10|p-56320)}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,p<128){if((t-=1)<0)break;i.push(p)}else if(p<2048){if((t-=2)<0)break;i.push(p>>6|192,63&p|128)}else if(p<65536){if((t-=3)<0)break;i.push(p>>12|224,p>>6&63|128,63&p|128)}else{if(!(p<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(p>>18|240,p>>12&63|128,p>>6&63|128,63&p|128)}}return i}function B(e){return r.toByteArray(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(x,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function q(e,t,p,r){for(var o=0;o=t.length||o>=e.length);++o)t[o+p]=e[o];return o}}).call(this,p(5))},function(e,t){var p,r,o=e.exports={};function i(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}function n(e){if(p===setTimeout)return setTimeout(e,0);if((p===i||!p)&&setTimeout)return p=setTimeout,setTimeout(e,0);try{return p(e,0)}catch(t){try{return p.call(null,e,0)}catch(t){return p.call(this,e,0)}}}!function(){try{p="function"==typeof setTimeout?setTimeout:i}catch(e){p=i}try{r="function"==typeof clearTimeout?clearTimeout:s}catch(e){r=s}}();var a,l=[],u=!1,c=-1;function y(){u&&a&&(u=!1,a.length?l=a.concat(l):c=-1,l.length&&h())}function h(){if(!u){var e=n(y);u=!0;for(var t=l.length;t;){for(a=l,l=[];++c1)for(var p=1;p0&&this._events[e].length>s&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},p.prototype.on=p.prototype.addListener,p.prototype.once=function(e,t){if(!r(t))throw TypeError("listener must be a function");var p=!1;function o(){this.removeListener(e,o),p||(p=!0,t.apply(this,arguments))}return o.listener=t,this.on(e,o),this},p.prototype.removeListener=function(e,t){var p,i,s,n;if(!r(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(s=(p=this._events[e]).length,i=-1,p===t||r(p.listener)&&p.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(o(p)){for(n=s;n-- >0;)if(p[n]===t||p[n].listener&&p[n].listener===t){i=n;break}if(i<0)return this;1===p.length?(p.length=0,delete this._events[e]):p.splice(i,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},p.prototype.removeAllListeners=function(e){var t,p;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(r(p=this._events[e]))this.removeListener(e,p);else if(p)for(;p.length;)this.removeListener(e,p[p.length-1]);return delete this._events[e],this},p.prototype.listeners=function(e){return this._events&&this._events[e]?r(this._events[e])?[this._events[e]]:this._events[e].slice():[]},p.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(r(t))return 1;if(t)return t.length}return 0},p.listenerCount=function(e,t){return e.listenerCount(t)}},function(e,t,p){(t=e.exports=p(19)).Stream=t,t.Readable=t,t.Writable=p(15),t.Duplex=p(7),t.Transform=p(23),t.PassThrough=p(38)},function(e,t,p){"use strict";(function(t,r,o){var i=p(11);function s(e){var t=this;this.next=null,this.entry=null,this.finish=function(){!function(e,t,p){var r=e.entry;e.entry=null;for(;r;){var o=r.callback;t.pendingcb--,o(p),r=r.next}t.corkedRequestsFree?t.corkedRequestsFree.next=e:t.corkedRequestsFree=e}(t,e)}}e.exports=g;var n,a=!t.browser&&["v0.10","v0.9."].indexOf(t.version.slice(0,5))>-1?r:i.nextTick;g.WritableState=S;var l=p(10);l.inherits=p(6);var u={deprecate:p(37)},c=p(20),y=p(12).Buffer,h=o.Uint8Array||function(){};var f,d=p(21);function _(){}function S(e,t){n=n||p(7),e=e||{};var r=t instanceof n;this.objectMode=!!e.objectMode,r&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var o=e.highWaterMark,l=e.writableHighWaterMark,u=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:r&&(l||0===l)?l:u,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var c=!1===e.decodeStrings;this.decodeStrings=!c,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){!function(e,t){var p=e._writableState,r=p.sync,o=p.writecb;if(function(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}(p),t)!function(e,t,p,r,o){--t.pendingcb,p?(i.nextTick(o,r),i.nextTick(L,e,t),e._writableState.errorEmitted=!0,e.emit("error",r)):(o(r),e._writableState.errorEmitted=!0,e.emit("error",r),L(e,t))}(e,p,r,t,o);else{var s=b(p);s||p.corked||p.bufferProcessing||!p.bufferedRequest||m(e,p),r?a(E,e,p,s,o):E(e,p,s,o)}}(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new s(this)}function g(e){if(n=n||p(7),!(f.call(g,this)||this instanceof n))return new g(e);this._writableState=new S(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev),"function"==typeof e.destroy&&(this._destroy=e.destroy),"function"==typeof e.final&&(this._final=e.final)),c.call(this)}function w(e,t,p,r,o,i,s){t.writelen=r,t.writecb=s,t.writing=!0,t.sync=!0,p?e._writev(o,t.onwrite):e._write(o,i,t.onwrite),t.sync=!1}function E(e,t,p,r){p||function(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}(e,t),t.pendingcb--,r(),L(e,t)}function m(e,t){t.bufferProcessing=!0;var p=t.bufferedRequest;if(e._writev&&p&&p.next){var r=t.bufferedRequestCount,o=new Array(r),i=t.corkedRequestsFree;i.entry=p;for(var n=0,a=!0;p;)o[n]=p,p.isBuf||(a=!1),p=p.next,n+=1;o.allBuffers=a,w(e,t,!0,t.length,o,"",i.finish),t.pendingcb++,t.lastBufferedRequest=null,i.next?(t.corkedRequestsFree=i.next,i.next=null):t.corkedRequestsFree=new s(t),t.bufferedRequestCount=0}else{for(;p;){var l=p.chunk,u=p.encoding,c=p.callback;if(w(e,t,!1,t.objectMode?1:l.length,l,u,c),p=p.next,t.bufferedRequestCount--,t.writing)break}null===p&&(t.lastBufferedRequest=null)}t.bufferedRequest=p,t.bufferProcessing=!1}function b(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function I(e,t){e._final((function(p){t.pendingcb--,p&&e.emit("error",p),t.prefinished=!0,e.emit("prefinish"),L(e,t)}))}function L(e,t){var p=b(t);return p&&(!function(e,t){t.prefinished||t.finalCalled||("function"==typeof e._final?(t.pendingcb++,t.finalCalled=!0,i.nextTick(I,e,t)):(t.prefinished=!0,e.emit("prefinish")))}(e,t),0===t.pendingcb&&(t.finished=!0,e.emit("finish"))),p}l.inherits(g,c),S.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(S.prototype,"buffer",{get:u.deprecate((function(){return this.getBuffer()}),"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(e){}}(),"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(f=Function.prototype[Symbol.hasInstance],Object.defineProperty(g,Symbol.hasInstance,{value:function(e){return!!f.call(this,e)||this===g&&(e&&e._writableState instanceof S)}})):f=function(e){return e instanceof this},g.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},g.prototype.write=function(e,t,p){var r,o=this._writableState,s=!1,n=!o.objectMode&&(r=e,y.isBuffer(r)||r instanceof h);return n&&!y.isBuffer(e)&&(e=function(e){return y.from(e)}(e)),"function"==typeof t&&(p=t,t=null),n?t="buffer":t||(t=o.defaultEncoding),"function"!=typeof p&&(p=_),o.ended?function(e,t){var p=new Error("write after end");e.emit("error",p),i.nextTick(t,p)}(this,p):(n||function(e,t,p,r){var o=!0,s=!1;return null===p?s=new TypeError("May not write null values to stream"):"string"==typeof p||void 0===p||t.objectMode||(s=new TypeError("Invalid non-string/buffer chunk")),s&&(e.emit("error",s),i.nextTick(r,s),o=!1),o}(this,o,e,p))&&(o.pendingcb++,s=function(e,t,p,r,o,i){if(!p){var s=function(e,t,p){e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=y.from(t,p));return t}(t,r,o);r!==s&&(p=!0,o="buffer",r=s)}var n=t.objectMode?1:r.length;t.length+=n;var a=t.length-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Object.defineProperty(g.prototype,"writableHighWaterMark",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),g.prototype._write=function(e,t,p){p(new Error("_write() is not implemented"))},g.prototype._writev=null,g.prototype.end=function(e,t,p){var r=this._writableState;"function"==typeof e?(p=e,e=null,t=null):"function"==typeof t&&(p=t,t=null),null!=e&&this.write(e,t),r.corked&&(r.corked=1,this.uncork()),r.ending||r.finished||function(e,t,p){t.ending=!0,L(e,t),p&&(t.finished?i.nextTick(p):e.once("finish",p));t.ended=!0,e.writable=!1}(this,r,p)},Object.defineProperty(g.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),g.prototype.destroy=d.destroy,g.prototype._undestroy=d.undestroy,g.prototype._destroy=function(e,t){this.end(),t(e)}}).call(this,p(9),p(35).setImmediate,p(5))},function(e,t){var p={}.toString;e.exports=Array.isArray||function(e){return"[object Array]"==p.call(e)}},function(e,t,p){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Parser=void 0;var r=p(28),o={},i={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},s={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"},n={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},a=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=s[e],r=n[e];t.pushCode(t.generateVariable(this.varName)+" = dataView.get"+p+"(offset, "+r+");"),t.pushCode("offset += "+i[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.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(i).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),s=t.choices[r];if(isNaN(r))throw new Error("Key of choices must be a number.");if(!s)throw new Error("Choice Case "+p+" of "+e+" is not valid.");if("string"==typeof s&&!o[s]&&Object.keys(i).indexOf(s)<0)throw new Error('Specified primitive type "'+s+'" 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(i).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 ___parser_"+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;"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),this.resolveReferences(e),e.pushCode("return vars;")},e.prototype.addAliasedCode=function(e){return e.pushCode("function ___parser_"+this.alias+"(offset) {"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),e.markResolved(this.alias),this.resolveReferences(e),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=this.getContext("imports");this.compiled=new Function("imports","TextDecoder","return function (buffer, constructorFn) { "+e.code+" };")(e.imports,"undefined"==typeof TextDecoder?p(18).TextDecoder:TextDecoder)},e.prototype.sizeOf=function(){var t=NaN;if(Object.keys(i).indexOf(this.type)>=0)t=i[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=i[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)}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 if(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+";")}else 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(this, "+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),a=this.options.type,l=t.generateTmpVariable(),u=t.generateVariable(this.varName),c=t.generateTmpVariable(),y=this.options.key,h="string"==typeof y;if(h?t.pushCode(u+" = {};"):t.pushCode(u+" = [];"),"function"==typeof this.options.readUntil?t.pushCode("do {"):"eof"===this.options.readUntil?t.pushCode("for (var "+l+" = 0; offset < buffer.length; "+l+"++) {"):void 0!==r?t.pushCode("for (var "+l+" = offset + "+r+"; offset < "+l+"; ) {"):t.pushCode("for (var "+l+" = "+p+"; "+l+" > 0; "+l+"--) {"),"string"==typeof a)if(o[a]){var f=t.generateTmpVariable();t.pushCode("var "+f+" = ___parser_"+a+"(offset);"),t.pushCode("var "+c+" = "+f+".result; offset = "+f+".offset;"),a!==this.alias&&t.addReference(a)}else{var d=s[a],_=n[a];t.pushCode("var "+c+" = dataView.get"+d+"(offset, "+_+");"),t.pushCode("offset += "+i[a]+";")}else a instanceof e&&(t.pushCode("var "+c+" = {};"),t.pushScope(c),a.generate(t),t.popScope());if(h?t.pushCode(u+"["+c+"."+y+"] = "+c+";"):t.pushCode(u+".push("+c+");"),t.pushCode("}"),"function"==typeof this.options.readUntil){var S=this.options.readUntil,g=t.addImport(S);t.pushCode("while (!"+g+".call(this, "+c+", buffer.subarray(offset)));")}},e.prototype.generateChoiceCase=function(t,p,r){if("string"==typeof r){var a=t.generateVariable(this.varName);if(o[r]){var l=t.generateTmpVariable();t.pushCode("var "+l+" = ___parser_"+r+"(offset);"),t.pushCode(a+" = "+l+".result; offset = "+l+".offset;"),r!==this.alias&&t.addReference(r)}else{var u=s[r],c=n[r];t.pushCode(a+" = dataView.get"+u+"(offset, "+c+");"),t.pushCode("offset += "+i[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);this.varName&&e.pushCode(e.generateVariable(this.varName)+" = {};"),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("}")},e.prototype.generateNest=function(t){var p=t.generateVariable(this.varName);if(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 r=t.generateTmpVariable();t.pushCode("var "+r+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(p+" = "+r+".result; offset = "+r+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}},e.prototype.generateFormatter=function(e,t,p){if("function"==typeof p){var r=e.addImport(p);e.pushCode(t+" = "+r+".call(this, "+t+");")}},e.prototype.generatePointer=function(t){var p=this.options.type,r=t.generateOption(this.options.offset),a=t.generateTmpVariable(),l=t.generateVariable(this.varName);if(t.pushCode("var "+a+" = offset;"),t.pushCode("offset = "+r+";"),this.options.type instanceof e)t.pushCode(l+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var u=t.generateTmpVariable();t.pushCode("var "+u+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(l+" = "+u+".result; offset = "+u+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}else if(Object.keys(i).indexOf(this.options.type)>=0){var c=s[p],y=n[p];t.pushCode(l+" = dataView.get"+c+"(offset, "+y+");"),t.pushCode("offset += "+i[p]+";")}t.pushCode("offset = "+a+";")},e.prototype.generateSaveOffset=function(e){var t=e.generateVariable(this.varName);e.pushCode(t+" = offset")},e}();t.Parser=a},function(e,t,p){(function(e,r){var o=/%[sdj%]/g;t.format=function(e){if(!S(e)){for(var t=[],p=0;p=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}})),a=r[p];p=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),f(p)?r.showHidden=p:p&&t._extend(r,p),g(r.showHidden)&&(r.showHidden=!1),g(r.depth)&&(r.depth=2),g(r.colors)&&(r.colors=!1),g(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=a),u(r,e,r.depth)}function a(e,t){var p=n.styles[t];return p?"["+n.colors[p][0]+"m"+e+"["+n.colors[p][1]+"m":e}function l(e,t){return e}function u(e,p,r){if(e.customInspect&&p&&I(p.inspect)&&p.inspect!==t.inspect&&(!p.constructor||p.constructor.prototype!==p)){var o=p.inspect(r,e);return S(o)||(o=u(e,o,r)),o}var i=function(e,t){if(g(t))return e.stylize("undefined","undefined");if(S(t)){var p="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(p,"string")}if(_(t))return e.stylize(""+t,"number");if(f(t))return e.stylize(""+t,"boolean");if(d(t))return e.stylize("null","null")}(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)),b(p)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return c(p);if(0===s.length){if(I(p)){var a=p.name?": "+p.name:"";return e.stylize("[Function"+a+"]","special")}if(w(p))return e.stylize(RegExp.prototype.toString.call(p),"regexp");if(m(p))return e.stylize(Date.prototype.toString.call(p),"date");if(b(p))return c(p)}var l,E="",L=!1,T=["{","}"];(h(p)&&(L=!0,T=["[","]"]),I(p))&&(E=" [Function"+(p.name?": "+p.name:"")+"]");return w(p)&&(E=" "+RegExp.prototype.toString.call(p)),m(p)&&(E=" "+Date.prototype.toUTCString.call(p)),b(p)&&(E=" "+c(p)),0!==s.length||L&&0!=p.length?r<0?w(p)?e.stylize(RegExp.prototype.toString.call(p),"regexp"):e.stylize("[Object]","special"):(e.seen.push(p),l=L?function(e,t,p,r,o){for(var i=[],s=0,n=t.length;s=0&&0,e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0)>60)return p[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+p[1];return p[0]+t+" "+e.join(", ")+" "+p[1]}(l,E,T)):T[0]+E+T[1]}function c(e){return"["+Error.prototype.toString.call(e)+"]"}function y(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")),M(r,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=d(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").substr(2):"\n"+n.split("\n").map((function(e){return" "+e})).join("\n")):n=e.stylize("[Circular]","special")),g(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 h(e){return Array.isArray(e)}function f(e){return"boolean"==typeof e}function d(e){return null===e}function _(e){return"number"==typeof e}function S(e){return"string"==typeof e}function g(e){return void 0===e}function w(e){return E(e)&&"[object RegExp]"===L(e)}function E(e){return"object"==typeof e&&null!==e}function m(e){return E(e)&&"[object Date]"===L(e)}function b(e){return E(e)&&("[object Error]"===L(e)||e instanceof Error)}function I(e){return"function"==typeof e}function L(e){return Object.prototype.toString.call(e)}function T(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(g(i)&&(i=r.env.NODE_DEBUG||""),e=e.toUpperCase(),!s[e])if(new RegExp("\\b"+e+"\\b","i").test(i)){var p=r.pid;s[e]=function(){var r=t.format.apply(t,arguments);console.error("%s %d: %s",e,p,r)}}else s[e]=function(){};return s[e]},t.inspect=n,n.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]},n.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=h,t.isBoolean=f,t.isNull=d,t.isNullOrUndefined=function(e){return null==e},t.isNumber=_,t.isString=S,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=g,t.isRegExp=w,t.isObject=E,t.isDate=m,t.isError=b,t.isFunction=I,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(29);var v=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function U(){var e=new Date,t=[T(e.getHours()),T(e.getMinutes()),T(e.getSeconds())].join(":");return[e.getDate(),v[e.getMonth()],t].join(" ")}function M(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){console.log("%s - %s",U(),t.format.apply(t,arguments))},t.inherits=p(6),t._extend=function(e,t){if(!t||!E(t))return e;for(var p=Object.keys(t),r=p.length;r--;)e[p[r]]=t[p[r]];return e}}).call(this,p(5),p(9))},function(e,t,p){"use strict";(function(t,r){var o=p(11);e.exports=w;var i,s=p(16);w.ReadableState=g;p(13).EventEmitter;var n=function(e,t){return e.listeners(t).length},a=p(20),l=p(12).Buffer,u=t.Uint8Array||function(){};var c=p(10);c.inherits=p(6);var y=p(32),h=void 0;h=y&&y.debuglog?y.debuglog("stream"):function(){};var f,d=p(33),_=p(21);c.inherits(w,a);var S=["error","close","destroy","pause","resume"];function g(e,t){e=e||{};var r=t instanceof(i=i||p(7));this.objectMode=!!e.objectMode,r&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var o=e.highWaterMark,s=e.readableHighWaterMark,n=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:r&&(s||0===s)?s:n,this.highWaterMark=Math.floor(this.highWaterMark),this.buffer=new d,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.destroyed=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(f||(f=p(22).StringDecoder),this.decoder=new f(e.encoding),this.encoding=e.encoding)}function w(e){if(i=i||p(7),!(this instanceof w))return new w(e);this._readableState=new g(e,this),this.readable=!0,e&&("function"==typeof e.read&&(this._read=e.read),"function"==typeof e.destroy&&(this._destroy=e.destroy)),a.call(this)}function E(e,t,p,r,o){var i,s=e._readableState;null===t?(s.reading=!1,function(e,t){if(t.ended)return;if(t.decoder){var p=t.decoder.end();p&&p.length&&(t.buffer.push(p),t.length+=t.objectMode?1:p.length)}t.ended=!0,I(e)}(e,s)):(o||(i=function(e,t){var p;r=t,l.isBuffer(r)||r instanceof u||"string"==typeof t||void 0===t||e.objectMode||(p=new TypeError("Invalid non-string/buffer chunk"));var r;return p}(s,t)),i?e.emit("error",i):s.objectMode||t&&t.length>0?("string"==typeof t||s.objectMode||Object.getPrototypeOf(t)===l.prototype||(t=function(e){return l.from(e)}(t)),r?s.endEmitted?e.emit("error",new Error("stream.unshift() after end event")):m(e,s,t,!0):s.ended?e.emit("error",new Error("stream.push() after EOF")):(s.reading=!1,s.decoder&&!p?(t=s.decoder.write(t),s.objectMode||0!==t.length?m(e,s,t,!1):T(e,s)):m(e,s,t,!1))):r||(s.reading=!1));return function(e){return!e.ended&&(e.needReadable||e.lengtht.highWaterMark&&(t.highWaterMark=function(e){return e>=8388608?e=8388608:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function I(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(h("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?o.nextTick(L,e):L(e))}function L(e){h("emit readable"),e.emit("readable"),D(e)}function T(e,t){t.readingMore||(t.readingMore=!0,o.nextTick(v,e,t))}function v(e,t){for(var p=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(p=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):p=function(e,t,p){var r;ei.length?i.length:e;if(s===i.length?o+=i:o+=i.slice(0,e),0===(e-=s)){s===i.length?(++r,p.next?t.head=p.next:t.head=t.tail=null):(t.head=p,p.data=i.slice(s));break}++r}return t.length-=r,o}(e,t):function(e,t){var p=l.allocUnsafe(e),r=t.head,o=1;r.data.copy(p),e-=r.data.length;for(;r=r.next;){var i=r.data,s=e>i.length?i.length:e;if(i.copy(p,p.length-e,0,s),0===(e-=s)){s===i.length?(++o,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=i.slice(s));break}++o}return t.length-=o,p}(e,t);return r}(e,t.buffer,t.decoder),p);var p}function G(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,o.nextTick(A,t,e))}function A(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function C(e,t){for(var p=0,r=e.length;p=t.highWaterMark||t.ended))return h("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?G(this):I(this),null;if(0===(e=b(e,t))&&t.ended)return 0===t.length&&G(this),null;var r,o=t.needReadable;return h("need readable",o),(0===t.length||t.length-e0?O(e,t):null)?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),p!==e&&t.ended&&G(this)),null!==r&&this.emit("data",r),r},w.prototype._read=function(e){this.emit("error",new Error("_read() is not implemented"))},w.prototype.pipe=function(e,t){var p=this,i=this._readableState;switch(i.pipesCount){case 0:i.pipes=e;break;case 1:i.pipes=[i.pipes,e];break;default:i.pipes.push(e)}i.pipesCount+=1,h("pipe count=%d opts=%j",i.pipesCount,t);var a=(!t||!1!==t.end)&&e!==r.stdout&&e!==r.stderr?u:w;function l(t,r){h("onunpipe"),t===p&&r&&!1===r.hasUnpiped&&(r.hasUnpiped=!0,h("cleanup"),e.removeListener("close",S),e.removeListener("finish",g),e.removeListener("drain",c),e.removeListener("error",_),e.removeListener("unpipe",l),p.removeListener("end",u),p.removeListener("end",w),p.removeListener("data",d),y=!0,!i.awaitDrain||e._writableState&&!e._writableState.needDrain||c())}function u(){h("onend"),e.end()}i.endEmitted?o.nextTick(a):p.once("end",a),e.on("unpipe",l);var c=function(e){return function(){var t=e._readableState;h("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&n(e,"data")&&(t.flowing=!0,D(e))}}(p);e.on("drain",c);var y=!1;var f=!1;function d(t){h("ondata"),f=!1,!1!==e.write(t)||f||((1===i.pipesCount&&i.pipes===e||i.pipesCount>1&&-1!==C(i.pipes,e))&&!y&&(h("false write response, pause",p._readableState.awaitDrain),p._readableState.awaitDrain++,f=!0),p.pause())}function _(t){h("onerror",t),w(),e.removeListener("error",_),0===n(e,"error")&&e.emit("error",t)}function S(){e.removeListener("finish",g),w()}function g(){h("onfinish"),e.removeListener("close",S),w()}function w(){h("unpipe"),p.unpipe(e)}return p.on("data",d),function(e,t,p){if("function"==typeof e.prependListener)return e.prependListener(t,p);e._events&&e._events[t]?s(e._events[t])?e._events[t].unshift(p):e._events[t]=[p,e._events[t]]:e.on(t,p)}(e,"error",_),e.once("close",S),e.once("finish",g),e.emit("pipe",p),i.flowing||(h("pipe resume"),p.resume()),e},w.prototype.unpipe=function(e){var t=this._readableState,p={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes||(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this,p)),this;if(!e){var r=t.pipes,o=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function n(e){var t=this.lastTotal-this.lastNeed,p=function(e,t,p){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(e.lastNeed>1&&t.length>1){if(128!=(192&t[1]))return e.lastNeed=1,"�";if(e.lastNeed>2&&t.length>2&&128!=(192&t[2]))return e.lastNeed=2,"�"}}(this,e);return void 0!==p?p:this.lastNeed<=e.length?(e.copy(this.lastChar,t,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(e.copy(this.lastChar,t,0,e.length),void(this.lastNeed-=e.length))}function a(e,t){if((e.length-t)%2==0){var p=e.toString("utf16le",t);if(p){var r=p.charCodeAt(p.length-1);if(r>=55296&&r<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1],p.slice(0,-1)}return p}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=e[e.length-1],e.toString("utf16le",t,e.length-1)}function l(e){var t=e&&e.length?this.write(e):"";if(this.lastNeed){var p=this.lastTotal-this.lastNeed;return t+this.lastChar.toString("utf16le",0,p)}return t}function u(e,t){var p=(e.length-t)%3;return 0===p?e.toString("base64",t):(this.lastNeed=3-p,this.lastTotal=3,1===p?this.lastChar[0]=e[e.length-1]:(this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1]),e.toString("base64",t,e.length-p))}function c(e){var t=e&&e.length?this.write(e):"";return this.lastNeed?t+this.lastChar.toString("base64",0,3-this.lastNeed):t}function y(e){return e.toString(this.encoding)}function h(e){return e&&e.length?this.write(e):""}t.StringDecoder=i,i.prototype.write=function(e){if(0===e.length)return"";var t,p;if(this.lastNeed){if(void 0===(t=this.fillLast(e)))return"";p=this.lastNeed,this.lastNeed=0}else p=0;return p=0)return o>0&&(e.lastNeed=o-1),o;if(--r=0)return o>0&&(e.lastNeed=o-2),o;if(--r=0)return o>0&&(2===o?o=0:e.lastNeed=o-3),o;return 0}(this,e,t);if(!this.lastNeed)return e.toString("utf8",t);this.lastTotal=p;var r=e.length-(p-this.lastNeed);return e.copy(this.lastChar,0,r),e.toString("utf8",t,r)},i.prototype.fillLast=function(e){if(this.lastNeed<=e.length)return e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,e.length),this.lastNeed-=e.length}},function(e,t,p){"use strict";e.exports=s;var r=p(7),o=p(10);function i(e,t){var p=this._transformState;p.transforming=!1;var r=p.writecb;if(!r)return this.emit("error",new Error("write callback called multiple times"));p.writechunk=null,p.writecb=null,null!=t&&this.push(t),r(e);var o=this._readableState;o.reading=!1,(o.needReadable||o.length>8&255^255&p],t&=65535;return t}r.exports={preambleByte:85,crc16:S,sbpIdTable:h,sbpMessageTypesTable:f,decode:function(e){var t=d.parse(e),p=h[t.msg_type];return void 0===p?(console.log("Unknown message type: ",t.msg_type),new s(t)):new p(t)},dispatch:function(t,p,o){var i,s,n=new e(0);if(void 0===o&&"function"==typeof p?i=p:(i=o,s=p),s&&!Array.isArray(s)&&-1===["function","number"].indexOf(typeof s))throw l("dispatch: messageWhitelist must be function, number, or array");var a=function(p){t.pause();try{if((n=e.concat([n,p])).length<2)return;var o=function(){var e,t,p,o,i,a,l;for(l=0;ln.length)throw new u;e=n.slice(l+1,l+6),p=n.readUInt16LE(l+1),_=n.readUInt16LE(l+3),o=n.readUInt8(l+5);var y=s&&Array.isArray(s)&&-1!==s.indexOf(p),h=s&&"number"==typeof s&&s&p,f=s&&"function"==typeof s&&s(p);if(s&&!(y||h||f))return n=n.slice(l+6+o+2),null;if(l+8+o>n.length)throw new u;a=S(n.slice(l+6,l+6+o),S(e)),i=n.readUInt16LE(l+6+o);var d=n.slice(l,l+6+o+2);if(i===a)return n=n.slice(l+6+o+2),[r.exports.decode(d),d];throw n=n.slice(l+1),new c}();if(null===o)return;var l=o[0],y=o[1];i(null,l,y)}catch(e){if(!(e instanceof u||e instanceof c))throw e}finally{t.resume(),n.length>0&&setTimeout((function(){a(new e(0))}),0)}};t.on("data",a)}},function(e){var p={function:!0,object:!0},i=p[typeof window]&&window||this,s=p[typeof t]&&t&&!t.nodeType&&t,n=p[typeof r]&&r&&!r.nodeType&&r,a=s&&n&&"object"==typeof o&&o;!a||a.global!==a&&a.window!==a&&a.self!==a||(i=a),i.SBP=e}(r.exports)}).call(this,p(8).Buffer,p(27)(e),p(5))},function(e,t,p){"use strict";t.byteLength=function(e){var t=l(e),p=t[0],r=t[1];return 3*(p+r)/4-r},t.toByteArray=function(e){for(var t,p=l(e),r=p[0],s=p[1],n=new i(function(e,t,p){return 3*(t+p)/4-p}(0,r,s)),a=0,u=s>0?r-4:r,c=0;c>16&255,n[a++]=t>>8&255,n[a++]=255&t;2===s&&(t=o[e.charCodeAt(c)]<<2|o[e.charCodeAt(c+1)]>>4,n[a++]=255&t);1===s&&(t=o[e.charCodeAt(c)]<<10|o[e.charCodeAt(c+1)]<<4|o[e.charCodeAt(c+2)]>>2,n[a++]=t>>8&255,n[a++]=255&t);return n},t.fromByteArray=function(e){for(var t,p=e.length,o=p%3,i=[],s=0,n=p-o;sn?n:s+16383));1===o?(t=e[p-1],i.push(r[t>>2]+r[t<<4&63]+"==")):2===o&&(t=(e[p-2]<<8)+e[p-1],i.push(r[t>>10]+r[t>>4&63]+r[t<<2&63]+"="));return i.join("")};for(var r=[],o=[],i="undefined"!=typeof Uint8Array?Uint8Array:Array,s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",n=0,a=s.length;n0)throw new Error("Invalid string. Length must be a multiple of 4");var p=e.indexOf("=");return-1===p&&(p=t),[p,p===t?0:4-p%4]}function u(e,t,p){for(var o,i,s=[],n=t;n>18&63]+r[i>>12&63]+r[i>>6&63]+r[63&i]);return s.join("")}o["-".charCodeAt(0)]=62,o["_".charCodeAt(0)]=63},function(e,t){t.read=function(e,t,p,r,o){var i,s,n=8*o-r-1,a=(1<>1,u=-7,c=p?o-1:0,y=p?-1:1,h=e[t+c];for(c+=y,i=h&(1<<-u)-1,h>>=-u,u+=n;u>0;i=256*i+e[t+c],c+=y,u-=8);for(s=i&(1<<-u)-1,i>>=-u,u+=r;u>0;s=256*s+e[t+c],c+=y,u-=8);if(0===i)i=1-l;else{if(i===a)return s?NaN:1/0*(h?-1:1);s+=Math.pow(2,r),i-=l}return(h?-1:1)*s*Math.pow(2,i-r)},t.write=function(e,t,p,r,o,i){var s,n,a,l=8*i-o-1,u=(1<>1,y=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:i-1,f=r?1:-1,d=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(n=isNaN(t)?1:0,s=u):(s=Math.floor(Math.log(t)/Math.LN2),t*(a=Math.pow(2,-s))<1&&(s--,a*=2),(t+=s+c>=1?y/a:y*Math.pow(2,1-c))*a>=2&&(s++,a/=2),s+c>=u?(n=0,s=u):s+c>=1?(n=(t*a-1)*Math.pow(2,o),s+=c):(n=t*Math.pow(2,c-1)*Math.pow(2,o),s=0));o>=8;e[p+h]=255&n,h+=f,n/=256,o-=8);for(s=s<0;e[p+h]=255&s,h+=f,s/=256,l-=8);e[p+h-f]|=128*d}},function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},function(e,t,p){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Context=void 0;var r=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=r},function(e,t){e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},function(e,t,p){(function(e){function p(e,t){for(var p=0,r=e.length-1;r>=0;r--){var o=e[r];"."===o?e.splice(r,1):".."===o?(e.splice(r,1),p++):p&&(e.splice(r,1),p--)}if(t)for(;p--;p)e.unshift("..");return e}var r=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/,o=function(e){return r.exec(e).slice(1)};function i(e,t){if(e.filter)return e.filter(t);for(var p=[],r=0;r=-1&&!r;o--){var s=o>=0?arguments[o]:e.cwd();if("string"!=typeof s)throw new TypeError("Arguments to path.resolve must be strings");s&&(t=s+"/"+t,r="/"===s.charAt(0))}return(r?"/":"")+(t=p(i(t.split("/"),(function(e){return!!e})),!r).join("/"))||"."},t.normalize=function(e){var r=t.isAbsolute(e),o="/"===s(e,-1);return(e=p(i(e.split("/"),(function(e){return!!e})),!r).join("/"))||r||(e="."),e&&o&&(e+="/"),(r?"/":"")+e},t.isAbsolute=function(e){return"/"===e.charAt(0)},t.join=function(){var e=Array.prototype.slice.call(arguments,0);return t.normalize(i(e,(function(e,t){if("string"!=typeof e)throw new TypeError("Arguments to path.join must be strings");return e})).join("/"))},t.relative=function(e,p){function r(e){for(var t=0;t=0&&""===e[p];p--);return t>p?[]:e.slice(t,p-t+1)}e=t.resolve(e).substr(1),p=t.resolve(p).substr(1);for(var o=r(e.split("/")),i=r(p.split("/")),s=Math.min(o.length,i.length),n=s,a=0;a0?this.tail.next=t:this.head=t,this.tail=t,++this.length},e.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},e.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},e.prototype.clear=function(){this.head=this.tail=null,this.length=0},e.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,p=""+t.data;t=t.next;)p+=e+t.data;return p},e.prototype.concat=function(e){if(0===this.length)return r.alloc(0);if(1===this.length)return this.head.data;for(var t=r.allocUnsafe(e>>>0),p=this.head,o=0;p;)i(p.data,t,o),o+=p.data.length,p=p.next;return t},e}(),o&&o.inspect&&o.inspect.custom&&(e.exports.prototype[o.inspect.custom]=function(){var e=o.inspect({length:this.length});return this.constructor.name+" "+e})},function(e,t){},function(e,t,p){(function(e){var r=void 0!==e&&e||"undefined"!=typeof self&&self||window,o=Function.prototype.apply;function i(e,t){this._id=e,this._clearFn=t}t.setTimeout=function(){return new i(o.call(setTimeout,r,arguments),clearTimeout)},t.setInterval=function(){return new i(o.call(setInterval,r,arguments),clearInterval)},t.clearTimeout=t.clearInterval=function(e){e&&e.close()},i.prototype.unref=i.prototype.ref=function(){},i.prototype.close=function(){this._clearFn.call(r,this._id)},t.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},t.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},t._unrefActive=t.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout((function(){e._onTimeout&&e._onTimeout()}),t))},p(36),t.setImmediate="undefined"!=typeof self&&self.setImmediate||void 0!==e&&e.setImmediate||this&&this.setImmediate,t.clearImmediate="undefined"!=typeof self&&self.clearImmediate||void 0!==e&&e.clearImmediate||this&&this.clearImmediate}).call(this,p(5))},function(e,t,p){(function(e,t){!function(e,p){"use strict";if(!e.setImmediate){var r,o,i,s,n,a=1,l={},u=!1,c=e.document,y=Object.getPrototypeOf&&Object.getPrototypeOf(e);y=y&&y.setTimeout?y:e,"[object process]"==={}.toString.call(e.process)?r=function(e){t.nextTick((function(){f(e)}))}:!function(){if(e.postMessage&&!e.importScripts){var t=!0,p=e.onmessage;return e.onmessage=function(){t=!1},e.postMessage("","*"),e.onmessage=p,t}}()?e.MessageChannel?((i=new MessageChannel).port1.onmessage=function(e){f(e.data)},r=function(e){i.port2.postMessage(e)}):c&&"onreadystatechange"in c.createElement("script")?(o=c.documentElement,r=function(e){var t=c.createElement("script");t.onreadystatechange=function(){f(e),t.onreadystatechange=null,o.removeChild(t),t=null},o.appendChild(t)}):r=function(e){setTimeout(f,0,e)}:(s="setImmediate$"+Math.random()+"$",n=function(t){t.source===e&&"string"==typeof t.data&&0===t.data.indexOf(s)&&f(+t.data.slice(s.length))},e.addEventListener?e.addEventListener("message",n,!1):e.attachEvent("onmessage",n),r=function(t){e.postMessage(s+t,"*")}),y.setImmediate=function(e){"function"!=typeof e&&(e=new Function(""+e));for(var t=new Array(arguments.length-1),p=0;p=s())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+s().toString(16)+" bytes");return 0|e}function f(e,t){if(a.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var p=e.length;if(0===p)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return p;case"utf8":case"utf-8":case void 0:return k(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*p;case"hex":return p>>>1;case"base64":return B(e).length;default:if(r)return k(e).length;t=(""+t).toLowerCase(),r=!0}}function d(e,t,p){var r=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===p||p>this.length)&&(p=this.length),p<=0)return"";if((p>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return D(this,t,p);case"utf8":case"utf-8":return v(this,t,p);case"ascii":return U(this,t,p);case"latin1":case"binary":return M(this,t,p);case"base64":return T(this,t,p);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return O(this,t,p);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}function _(e,t,p){var r=e[t];e[t]=e[p],e[p]=r}function S(e,t,p,r,o){if(0===e.length)return-1;if("string"==typeof p?(r=p,p=0):p>2147483647?p=2147483647:p<-2147483648&&(p=-2147483648),p=+p,isNaN(p)&&(p=o?0:e.length-1),p<0&&(p=e.length+p),p>=e.length){if(o)return-1;p=e.length-1}else if(p<0){if(!o)return-1;p=0}if("string"==typeof t&&(t=a.from(t,r)),a.isBuffer(t))return 0===t.length?-1:g(e,t,p,r,o);if("number"==typeof t)return t&=255,a.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,p):Uint8Array.prototype.lastIndexOf.call(e,t,p):g(e,[t],p,r,o);throw new TypeError("val must be string, number or Buffer")}function g(e,t,p,r,o){var i,s=1,n=e.length,a=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;s=2,n/=2,a/=2,p/=2}function l(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(o){var c=-1;for(i=p;in&&(p=n-a),i=p;i>=0;i--){for(var u=!0,y=0;yo&&(r=o):r=o;var i=t.length;if(i%2!=0)throw new TypeError("Invalid hex string");r>i/2&&(r=i/2);for(var s=0;s>8,o=p%256,i.push(o),i.push(r);return i}(t,e.length-p),e,p,r)}function T(e,t,p){return 0===t&&p===e.length?r.fromByteArray(e):r.fromByteArray(e.slice(t,p))}function v(e,t,p){p=Math.min(e.length,p);for(var r=[],o=t;o239?4:l>223?3:l>191?2:1;if(o+u<=p)switch(u){case 1:l<128&&(c=l);break;case 2:128==(192&(i=e[o+1]))&&(a=(31&l)<<6|63&i)>127&&(c=a);break;case 3:i=e[o+1],s=e[o+2],128==(192&i)&&128==(192&s)&&(a=(15&l)<<12|(63&i)<<6|63&s)>2047&&(a<55296||a>57343)&&(c=a);break;case 4:i=e[o+1],s=e[o+2],n=e[o+3],128==(192&i)&&128==(192&s)&&128==(192&n)&&(a=(15&l)<<18|(63&i)<<12|(63&s)<<6|63&n)>65535&&a<1114112&&(c=a)}null===c?(c=65533,u=1):c>65535&&(c-=65536,r.push(c>>>10&1023|55296),c=56320|1023&c),r.push(c),o+=u}return function(e){var t=e.length;if(t<=4096)return String.fromCharCode.apply(String,e);var p="",r=0;for(;r0&&(e=this.toString("hex",0,p).match(/.{2}/g).join(" "),this.length>p&&(e+=" ... ")),""},a.prototype.compare=function(e,t,p,r,o){if(!a.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===p&&(p=e?e.length:0),void 0===r&&(r=0),void 0===o&&(o=this.length),t<0||p>e.length||r<0||o>this.length)throw new RangeError("out of range index");if(r>=o&&t>=p)return 0;if(r>=o)return-1;if(t>=p)return 1;if(this===e)return 0;for(var i=(o>>>=0)-(r>>>=0),s=(p>>>=0)-(t>>>=0),n=Math.min(i,s),l=this.slice(r,o),c=e.slice(t,p),u=0;uo)&&(p=o),e.length>0&&(p<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var i=!1;;)switch(r){case"hex":return w(this,e,t,p);case"utf8":case"utf-8":return E(this,e,t,p);case"ascii":return m(this,e,t,p);case"latin1":case"binary":return b(this,e,t,p);case"base64":return I(this,e,t,p);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return L(this,e,t,p);default:if(i)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),i=!0}},a.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function U(e,t,p){var r="";p=Math.min(e.length,p);for(var o=t;or)&&(p=r);for(var o="",i=t;ip)throw new RangeError("Trying to access beyond buffer length")}function A(e,t,p,r,o,i){if(!a.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function C(e,t,p,r){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-p,2);o>>8*(r?o:1-o)}function R(e,t,p,r){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-p,4);o>>8*(r?o:3-o)&255}function P(e,t,p,r,o,i){if(p+r>e.length)throw new RangeError("Index out of range");if(p<0)throw new RangeError("Index out of range")}function N(e,t,p,r,i){return i||P(e,0,p,4),o.write(e,t,p,r,23,4),p+4}function j(e,t,p,r,i){return i||P(e,0,p,8),o.write(e,t,p,r,52,8),p+8}a.prototype.slice=function(e,t){var p,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),(t=void 0===t?r:~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),t0&&(o*=256);)r+=this[e+--t]*o;return r},a.prototype.readUInt8=function(e,t){return t||G(e,1,this.length),this[e]},a.prototype.readUInt16LE=function(e,t){return t||G(e,2,this.length),this[e]|this[e+1]<<8},a.prototype.readUInt16BE=function(e,t){return t||G(e,2,this.length),this[e]<<8|this[e+1]},a.prototype.readUInt32LE=function(e,t){return t||G(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},a.prototype.readUInt32BE=function(e,t){return t||G(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},a.prototype.readIntLE=function(e,t,p){e|=0,t|=0,p||G(e,t,this.length);for(var r=this[e],o=1,i=0;++i=(o*=128)&&(r-=Math.pow(2,8*t)),r},a.prototype.readIntBE=function(e,t,p){e|=0,t|=0,p||G(e,t,this.length);for(var r=t,o=1,i=this[e+--r];r>0&&(o*=256);)i+=this[e+--r]*o;return i>=(o*=128)&&(i-=Math.pow(2,8*t)),i},a.prototype.readInt8=function(e,t){return t||G(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},a.prototype.readInt16LE=function(e,t){t||G(e,2,this.length);var p=this[e]|this[e+1]<<8;return 32768&p?4294901760|p:p},a.prototype.readInt16BE=function(e,t){t||G(e,2,this.length);var p=this[e+1]|this[e]<<8;return 32768&p?4294901760|p:p},a.prototype.readInt32LE=function(e,t){return t||G(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},a.prototype.readInt32BE=function(e,t){return t||G(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},a.prototype.readFloatLE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!0,23,4)},a.prototype.readFloatBE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!1,23,4)},a.prototype.readDoubleLE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!0,52,8)},a.prototype.readDoubleBE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!1,52,8)},a.prototype.writeUIntLE=function(e,t,p,r){(e=+e,t|=0,p|=0,r)||A(this,e,t,p,Math.pow(2,8*p)-1,0);var o=1,i=0;for(this[t]=255&e;++i=0&&(i*=256);)this[t+o]=e/i&255;return t+p},a.prototype.writeUInt8=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,1,255,0),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},a.prototype.writeUInt16LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeUInt16BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeUInt32LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):R(this,e,t,!0),t+4},a.prototype.writeUInt32BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeIntLE=function(e,t,p,r){if(e=+e,t|=0,!r){var o=Math.pow(2,8*p-1);A(this,e,t,p,o-1,-o)}var i=0,s=1,n=0;for(this[t]=255&e;++i>0)-n&255;return t+p},a.prototype.writeIntBE=function(e,t,p,r){if(e=+e,t|=0,!r){var o=Math.pow(2,8*p-1);A(this,e,t,p,o-1,-o)}var i=p-1,s=1,n=0;for(this[t+i]=255&e;--i>=0&&(s*=256);)e<0&&0===n&&0!==this[t+i+1]&&(n=1),this[t+i]=(e/s>>0)-n&255;return t+p},a.prototype.writeInt8=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,1,127,-128),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},a.prototype.writeInt16LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeInt16BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeInt32LE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,2147483647,-2147483648),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):R(this,e,t,!0),t+4},a.prototype.writeInt32BE=function(e,t,p){return e=+e,t|=0,p||A(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeFloatLE=function(e,t,p){return N(this,e,t,!0,p)},a.prototype.writeFloatBE=function(e,t,p){return N(this,e,t,!1,p)},a.prototype.writeDoubleLE=function(e,t,p){return j(this,e,t,!0,p)},a.prototype.writeDoubleBE=function(e,t,p){return j(this,e,t,!1,p)},a.prototype.copy=function(e,t,p,r){if(p||(p=0),r||0===r||(r=this.length),t>=e.length&&(t=e.length),t||(t=0),r>0&&r=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t=0;--o)e[o+t]=this[o+p];else if(i<1e3||!a.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,p=void 0===p?this.length:p>>>0,e||(e=0),"number"==typeof e)for(i=t;i55295&&p<57344){if(!o){if(p>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(s+1===r){(t-=3)>-1&&i.push(239,191,189);continue}o=p;continue}if(p<56320){(t-=3)>-1&&i.push(239,191,189),o=p;continue}p=65536+(o-55296<<10|p-56320)}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,p<128){if((t-=1)<0)break;i.push(p)}else if(p<2048){if((t-=2)<0)break;i.push(p>>6|192,63&p|128)}else if(p<65536){if((t-=3)<0)break;i.push(p>>12|224,p>>6&63|128,63&p|128)}else{if(!(p<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(p>>18|240,p>>12&63|128,p>>6&63|128,63&p|128)}}return i}function B(e){return r.toByteArray(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(x,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function q(e,t,p,r){for(var o=0;o=t.length||o>=e.length);++o)t[o+p]=e[o];return o}}).call(this,p(5))},function(e,t){var p,r,o=e.exports={};function i(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}function n(e){if(p===setTimeout)return setTimeout(e,0);if((p===i||!p)&&setTimeout)return p=setTimeout,setTimeout(e,0);try{return p(e,0)}catch(t){try{return p.call(null,e,0)}catch(t){return p.call(this,e,0)}}}!function(){try{p="function"==typeof setTimeout?setTimeout:i}catch(e){p=i}try{r="function"==typeof clearTimeout?clearTimeout:s}catch(e){r=s}}();var a,l=[],c=!1,u=-1;function y(){c&&a&&(c=!1,a.length?l=a.concat(l):u=-1,l.length&&h())}function h(){if(!c){var e=n(y);c=!0;for(var t=l.length;t;){for(a=l,l=[];++u1)for(var p=1;p0&&this._events[e].length>s&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},p.prototype.on=p.prototype.addListener,p.prototype.once=function(e,t){if(!r(t))throw TypeError("listener must be a function");var p=!1;function o(){this.removeListener(e,o),p||(p=!0,t.apply(this,arguments))}return o.listener=t,this.on(e,o),this},p.prototype.removeListener=function(e,t){var p,i,s,n;if(!r(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(s=(p=this._events[e]).length,i=-1,p===t||r(p.listener)&&p.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(o(p)){for(n=s;n-- >0;)if(p[n]===t||p[n].listener&&p[n].listener===t){i=n;break}if(i<0)return this;1===p.length?(p.length=0,delete this._events[e]):p.splice(i,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},p.prototype.removeAllListeners=function(e){var t,p;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(r(p=this._events[e]))this.removeListener(e,p);else if(p)for(;p.length;)this.removeListener(e,p[p.length-1]);return delete this._events[e],this},p.prototype.listeners=function(e){return this._events&&this._events[e]?r(this._events[e])?[this._events[e]]:this._events[e].slice():[]},p.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(r(t))return 1;if(t)return t.length}return 0},p.listenerCount=function(e,t){return e.listenerCount(t)}},function(e,t,p){(t=e.exports=p(19)).Stream=t,t.Readable=t,t.Writable=p(15),t.Duplex=p(7),t.Transform=p(23),t.PassThrough=p(38)},function(e,t,p){"use strict";(function(t,r,o){var i=p(11);function s(e){var t=this;this.next=null,this.entry=null,this.finish=function(){!function(e,t,p){var r=e.entry;e.entry=null;for(;r;){var o=r.callback;t.pendingcb--,o(p),r=r.next}t.corkedRequestsFree?t.corkedRequestsFree.next=e:t.corkedRequestsFree=e}(t,e)}}e.exports=g;var n,a=!t.browser&&["v0.10","v0.9."].indexOf(t.version.slice(0,5))>-1?r:i.nextTick;g.WritableState=S;var l=p(10);l.inherits=p(6);var c={deprecate:p(37)},u=p(20),y=p(12).Buffer,h=o.Uint8Array||function(){};var f,d=p(21);function _(){}function S(e,t){n=n||p(7),e=e||{};var r=t instanceof n;this.objectMode=!!e.objectMode,r&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var o=e.highWaterMark,l=e.writableHighWaterMark,c=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:r&&(l||0===l)?l:c,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var u=!1===e.decodeStrings;this.decodeStrings=!u,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){!function(e,t){var p=e._writableState,r=p.sync,o=p.writecb;if(function(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}(p),t)!function(e,t,p,r,o){--t.pendingcb,p?(i.nextTick(o,r),i.nextTick(L,e,t),e._writableState.errorEmitted=!0,e.emit("error",r)):(o(r),e._writableState.errorEmitted=!0,e.emit("error",r),L(e,t))}(e,p,r,t,o);else{var s=b(p);s||p.corked||p.bufferProcessing||!p.bufferedRequest||m(e,p),r?a(E,e,p,s,o):E(e,p,s,o)}}(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new s(this)}function g(e){if(n=n||p(7),!(f.call(g,this)||this instanceof n))return new g(e);this._writableState=new S(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev),"function"==typeof e.destroy&&(this._destroy=e.destroy),"function"==typeof e.final&&(this._final=e.final)),u.call(this)}function w(e,t,p,r,o,i,s){t.writelen=r,t.writecb=s,t.writing=!0,t.sync=!0,p?e._writev(o,t.onwrite):e._write(o,i,t.onwrite),t.sync=!1}function E(e,t,p,r){p||function(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}(e,t),t.pendingcb--,r(),L(e,t)}function m(e,t){t.bufferProcessing=!0;var p=t.bufferedRequest;if(e._writev&&p&&p.next){var r=t.bufferedRequestCount,o=new Array(r),i=t.corkedRequestsFree;i.entry=p;for(var n=0,a=!0;p;)o[n]=p,p.isBuf||(a=!1),p=p.next,n+=1;o.allBuffers=a,w(e,t,!0,t.length,o,"",i.finish),t.pendingcb++,t.lastBufferedRequest=null,i.next?(t.corkedRequestsFree=i.next,i.next=null):t.corkedRequestsFree=new s(t),t.bufferedRequestCount=0}else{for(;p;){var l=p.chunk,c=p.encoding,u=p.callback;if(w(e,t,!1,t.objectMode?1:l.length,l,c,u),p=p.next,t.bufferedRequestCount--,t.writing)break}null===p&&(t.lastBufferedRequest=null)}t.bufferedRequest=p,t.bufferProcessing=!1}function b(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function I(e,t){e._final((function(p){t.pendingcb--,p&&e.emit("error",p),t.prefinished=!0,e.emit("prefinish"),L(e,t)}))}function L(e,t){var p=b(t);return p&&(!function(e,t){t.prefinished||t.finalCalled||("function"==typeof e._final?(t.pendingcb++,t.finalCalled=!0,i.nextTick(I,e,t)):(t.prefinished=!0,e.emit("prefinish")))}(e,t),0===t.pendingcb&&(t.finished=!0,e.emit("finish"))),p}l.inherits(g,u),S.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(S.prototype,"buffer",{get:c.deprecate((function(){return this.getBuffer()}),"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(e){}}(),"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(f=Function.prototype[Symbol.hasInstance],Object.defineProperty(g,Symbol.hasInstance,{value:function(e){return!!f.call(this,e)||this===g&&(e&&e._writableState instanceof S)}})):f=function(e){return e instanceof this},g.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},g.prototype.write=function(e,t,p){var r,o=this._writableState,s=!1,n=!o.objectMode&&(r=e,y.isBuffer(r)||r instanceof h);return n&&!y.isBuffer(e)&&(e=function(e){return y.from(e)}(e)),"function"==typeof t&&(p=t,t=null),n?t="buffer":t||(t=o.defaultEncoding),"function"!=typeof p&&(p=_),o.ended?function(e,t){var p=new Error("write after end");e.emit("error",p),i.nextTick(t,p)}(this,p):(n||function(e,t,p,r){var o=!0,s=!1;return null===p?s=new TypeError("May not write null values to stream"):"string"==typeof p||void 0===p||t.objectMode||(s=new TypeError("Invalid non-string/buffer chunk")),s&&(e.emit("error",s),i.nextTick(r,s),o=!1),o}(this,o,e,p))&&(o.pendingcb++,s=function(e,t,p,r,o,i){if(!p){var s=function(e,t,p){e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=y.from(t,p));return t}(t,r,o);r!==s&&(p=!0,o="buffer",r=s)}var n=t.objectMode?1:r.length;t.length+=n;var a=t.length-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Object.defineProperty(g.prototype,"writableHighWaterMark",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),g.prototype._write=function(e,t,p){p(new Error("_write() is not implemented"))},g.prototype._writev=null,g.prototype.end=function(e,t,p){var r=this._writableState;"function"==typeof e?(p=e,e=null,t=null):"function"==typeof t&&(p=t,t=null),null!=e&&this.write(e,t),r.corked&&(r.corked=1,this.uncork()),r.ending||r.finished||function(e,t,p){t.ending=!0,L(e,t),p&&(t.finished?i.nextTick(p):e.once("finish",p));t.ended=!0,e.writable=!1}(this,r,p)},Object.defineProperty(g.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),g.prototype.destroy=d.destroy,g.prototype._undestroy=d.undestroy,g.prototype._destroy=function(e,t){this.end(),t(e)}}).call(this,p(9),p(35).setImmediate,p(5))},function(e,t){var p={}.toString;e.exports=Array.isArray||function(e){return"[object Array]"==p.call(e)}},function(e,t,p){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Parser=void 0;var r=p(28),o={},i={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},s={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"},n={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},a=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=s[e],r=n[e];t.pushCode(t.generateVariable(this.varName)+" = dataView.get"+p+"(offset, "+r+");"),t.pushCode("offset += "+i[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.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(i).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),s=t.choices[r];if(isNaN(r))throw new Error("Key of choices must be a number.");if(!s)throw new Error("Choice Case "+p+" of "+e+" is not valid.");if("string"==typeof s&&!o[s]&&Object.keys(i).indexOf(s)<0)throw new Error('Specified primitive type "'+s+'" 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(i).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 ___parser_"+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;"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),this.resolveReferences(e),e.pushCode("return vars;")},e.prototype.addAliasedCode=function(e){return e.pushCode("function ___parser_"+this.alias+"(offset) {"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),e.markResolved(this.alias),this.resolveReferences(e),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=this.getContext("imports");this.compiled=new Function("imports","TextDecoder","return function (buffer, constructorFn) { "+e.code+" };")(e.imports,"undefined"==typeof TextDecoder?p(18).TextDecoder:TextDecoder)},e.prototype.sizeOf=function(){var t=NaN;if(Object.keys(i).indexOf(this.type)>=0)t=i[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=i[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)}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 if(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+";")}else 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(this, "+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),a=this.options.type,l=t.generateTmpVariable(),c=t.generateVariable(this.varName),u=t.generateTmpVariable(),y=this.options.key,h="string"==typeof y;if(h?t.pushCode(c+" = {};"):t.pushCode(c+" = [];"),"function"==typeof this.options.readUntil?t.pushCode("do {"):"eof"===this.options.readUntil?t.pushCode("for (var "+l+" = 0; offset < buffer.length; "+l+"++) {"):void 0!==r?t.pushCode("for (var "+l+" = offset + "+r+"; offset < "+l+"; ) {"):t.pushCode("for (var "+l+" = "+p+"; "+l+" > 0; "+l+"--) {"),"string"==typeof a)if(o[a]){var f=t.generateTmpVariable();t.pushCode("var "+f+" = ___parser_"+a+"(offset);"),t.pushCode("var "+u+" = "+f+".result; offset = "+f+".offset;"),a!==this.alias&&t.addReference(a)}else{var d=s[a],_=n[a];t.pushCode("var "+u+" = dataView.get"+d+"(offset, "+_+");"),t.pushCode("offset += "+i[a]+";")}else a instanceof e&&(t.pushCode("var "+u+" = {};"),t.pushScope(u),a.generate(t),t.popScope());if(h?t.pushCode(c+"["+u+"."+y+"] = "+u+";"):t.pushCode(c+".push("+u+");"),t.pushCode("}"),"function"==typeof this.options.readUntil){var S=this.options.readUntil,g=t.addImport(S);t.pushCode("while (!"+g+".call(this, "+u+", buffer.subarray(offset)));")}},e.prototype.generateChoiceCase=function(t,p,r){if("string"==typeof r){var a=t.generateVariable(this.varName);if(o[r]){var l=t.generateTmpVariable();t.pushCode("var "+l+" = ___parser_"+r+"(offset);"),t.pushCode(a+" = "+l+".result; offset = "+l+".offset;"),r!==this.alias&&t.addReference(r)}else{var c=s[r],u=n[r];t.pushCode(a+" = dataView.get"+c+"(offset, "+u+");"),t.pushCode("offset += "+i[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);this.varName&&e.pushCode(e.generateVariable(this.varName)+" = {};"),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("}")},e.prototype.generateNest=function(t){var p=t.generateVariable(this.varName);if(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 r=t.generateTmpVariable();t.pushCode("var "+r+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(p+" = "+r+".result; offset = "+r+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}},e.prototype.generateFormatter=function(e,t,p){if("function"==typeof p){var r=e.addImport(p);e.pushCode(t+" = "+r+".call(this, "+t+");")}},e.prototype.generatePointer=function(t){var p=this.options.type,r=t.generateOption(this.options.offset),a=t.generateTmpVariable(),l=t.generateVariable(this.varName);if(t.pushCode("var "+a+" = offset;"),t.pushCode("offset = "+r+";"),this.options.type instanceof e)t.pushCode(l+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var c=t.generateTmpVariable();t.pushCode("var "+c+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(l+" = "+c+".result; offset = "+c+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}else if(Object.keys(i).indexOf(this.options.type)>=0){var u=s[p],y=n[p];t.pushCode(l+" = dataView.get"+u+"(offset, "+y+");"),t.pushCode("offset += "+i[p]+";")}t.pushCode("offset = "+a+";")},e.prototype.generateSaveOffset=function(e){var t=e.generateVariable(this.varName);e.pushCode(t+" = offset")},e}();t.Parser=a},function(e,t,p){(function(e,r){var o=/%[sdj%]/g;t.format=function(e){if(!S(e)){for(var t=[],p=0;p=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}})),a=r[p];p=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),f(p)?r.showHidden=p:p&&t._extend(r,p),g(r.showHidden)&&(r.showHidden=!1),g(r.depth)&&(r.depth=2),g(r.colors)&&(r.colors=!1),g(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=a),c(r,e,r.depth)}function a(e,t){var p=n.styles[t];return p?"["+n.colors[p][0]+"m"+e+"["+n.colors[p][1]+"m":e}function l(e,t){return e}function c(e,p,r){if(e.customInspect&&p&&I(p.inspect)&&p.inspect!==t.inspect&&(!p.constructor||p.constructor.prototype!==p)){var o=p.inspect(r,e);return S(o)||(o=c(e,o,r)),o}var i=function(e,t){if(g(t))return e.stylize("undefined","undefined");if(S(t)){var p="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(p,"string")}if(_(t))return e.stylize(""+t,"number");if(f(t))return e.stylize(""+t,"boolean");if(d(t))return e.stylize("null","null")}(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)),b(p)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return u(p);if(0===s.length){if(I(p)){var a=p.name?": "+p.name:"";return e.stylize("[Function"+a+"]","special")}if(w(p))return e.stylize(RegExp.prototype.toString.call(p),"regexp");if(m(p))return e.stylize(Date.prototype.toString.call(p),"date");if(b(p))return u(p)}var l,E="",L=!1,T=["{","}"];(h(p)&&(L=!0,T=["[","]"]),I(p))&&(E=" [Function"+(p.name?": "+p.name:"")+"]");return w(p)&&(E=" "+RegExp.prototype.toString.call(p)),m(p)&&(E=" "+Date.prototype.toUTCString.call(p)),b(p)&&(E=" "+u(p)),0!==s.length||L&&0!=p.length?r<0?w(p)?e.stylize(RegExp.prototype.toString.call(p),"regexp"):e.stylize("[Object]","special"):(e.seen.push(p),l=L?function(e,t,p,r,o){for(var i=[],s=0,n=t.length;s=0&&0,e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0)>60)return p[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+p[1];return p[0]+t+" "+e.join(", ")+" "+p[1]}(l,E,T)):T[0]+E+T[1]}function u(e){return"["+Error.prototype.toString.call(e)+"]"}function y(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")),M(r,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=d(p)?c(e,a.value,null):c(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")),g(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 h(e){return Array.isArray(e)}function f(e){return"boolean"==typeof e}function d(e){return null===e}function _(e){return"number"==typeof e}function S(e){return"string"==typeof e}function g(e){return void 0===e}function w(e){return E(e)&&"[object RegExp]"===L(e)}function E(e){return"object"==typeof e&&null!==e}function m(e){return E(e)&&"[object Date]"===L(e)}function b(e){return E(e)&&("[object Error]"===L(e)||e instanceof Error)}function I(e){return"function"==typeof e}function L(e){return Object.prototype.toString.call(e)}function T(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(g(i)&&(i=r.env.NODE_DEBUG||""),e=e.toUpperCase(),!s[e])if(new RegExp("\\b"+e+"\\b","i").test(i)){var p=r.pid;s[e]=function(){var r=t.format.apply(t,arguments);console.error("%s %d: %s",e,p,r)}}else s[e]=function(){};return s[e]},t.inspect=n,n.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]},n.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=h,t.isBoolean=f,t.isNull=d,t.isNullOrUndefined=function(e){return null==e},t.isNumber=_,t.isString=S,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=g,t.isRegExp=w,t.isObject=E,t.isDate=m,t.isError=b,t.isFunction=I,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(29);var v=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function U(){var e=new Date,t=[T(e.getHours()),T(e.getMinutes()),T(e.getSeconds())].join(":");return[e.getDate(),v[e.getMonth()],t].join(" ")}function M(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){console.log("%s - %s",U(),t.format.apply(t,arguments))},t.inherits=p(6),t._extend=function(e,t){if(!t||!E(t))return e;for(var p=Object.keys(t),r=p.length;r--;)e[p[r]]=t[p[r]];return e}}).call(this,p(5),p(9))},function(e,t,p){"use strict";(function(t,r){var o=p(11);e.exports=w;var i,s=p(16);w.ReadableState=g;p(13).EventEmitter;var n=function(e,t){return e.listeners(t).length},a=p(20),l=p(12).Buffer,c=t.Uint8Array||function(){};var u=p(10);u.inherits=p(6);var y=p(32),h=void 0;h=y&&y.debuglog?y.debuglog("stream"):function(){};var f,d=p(33),_=p(21);u.inherits(w,a);var S=["error","close","destroy","pause","resume"];function g(e,t){e=e||{};var r=t instanceof(i=i||p(7));this.objectMode=!!e.objectMode,r&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var o=e.highWaterMark,s=e.readableHighWaterMark,n=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:r&&(s||0===s)?s:n,this.highWaterMark=Math.floor(this.highWaterMark),this.buffer=new d,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.destroyed=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(f||(f=p(22).StringDecoder),this.decoder=new f(e.encoding),this.encoding=e.encoding)}function w(e){if(i=i||p(7),!(this instanceof w))return new w(e);this._readableState=new g(e,this),this.readable=!0,e&&("function"==typeof e.read&&(this._read=e.read),"function"==typeof e.destroy&&(this._destroy=e.destroy)),a.call(this)}function E(e,t,p,r,o){var i,s=e._readableState;null===t?(s.reading=!1,function(e,t){if(t.ended)return;if(t.decoder){var p=t.decoder.end();p&&p.length&&(t.buffer.push(p),t.length+=t.objectMode?1:p.length)}t.ended=!0,I(e)}(e,s)):(o||(i=function(e,t){var p;r=t,l.isBuffer(r)||r instanceof c||"string"==typeof t||void 0===t||e.objectMode||(p=new TypeError("Invalid non-string/buffer chunk"));var r;return p}(s,t)),i?e.emit("error",i):s.objectMode||t&&t.length>0?("string"==typeof t||s.objectMode||Object.getPrototypeOf(t)===l.prototype||(t=function(e){return l.from(e)}(t)),r?s.endEmitted?e.emit("error",new Error("stream.unshift() after end event")):m(e,s,t,!0):s.ended?e.emit("error",new Error("stream.push() after EOF")):(s.reading=!1,s.decoder&&!p?(t=s.decoder.write(t),s.objectMode||0!==t.length?m(e,s,t,!1):T(e,s)):m(e,s,t,!1))):r||(s.reading=!1));return function(e){return!e.ended&&(e.needReadable||e.lengtht.highWaterMark&&(t.highWaterMark=function(e){return e>=8388608?e=8388608:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function I(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(h("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?o.nextTick(L,e):L(e))}function L(e){h("emit readable"),e.emit("readable"),D(e)}function T(e,t){t.readingMore||(t.readingMore=!0,o.nextTick(v,e,t))}function v(e,t){for(var p=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(p=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):p=function(e,t,p){var r;ei.length?i.length:e;if(s===i.length?o+=i:o+=i.slice(0,e),0===(e-=s)){s===i.length?(++r,p.next?t.head=p.next:t.head=t.tail=null):(t.head=p,p.data=i.slice(s));break}++r}return t.length-=r,o}(e,t):function(e,t){var p=l.allocUnsafe(e),r=t.head,o=1;r.data.copy(p),e-=r.data.length;for(;r=r.next;){var i=r.data,s=e>i.length?i.length:e;if(i.copy(p,p.length-e,0,s),0===(e-=s)){s===i.length?(++o,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=i.slice(s));break}++o}return t.length-=o,p}(e,t);return r}(e,t.buffer,t.decoder),p);var p}function G(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,o.nextTick(A,t,e))}function A(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function C(e,t){for(var p=0,r=e.length;p=t.highWaterMark||t.ended))return h("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?G(this):I(this),null;if(0===(e=b(e,t))&&t.ended)return 0===t.length&&G(this),null;var r,o=t.needReadable;return h("need readable",o),(0===t.length||t.length-e0?O(e,t):null)?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),p!==e&&t.ended&&G(this)),null!==r&&this.emit("data",r),r},w.prototype._read=function(e){this.emit("error",new Error("_read() is not implemented"))},w.prototype.pipe=function(e,t){var p=this,i=this._readableState;switch(i.pipesCount){case 0:i.pipes=e;break;case 1:i.pipes=[i.pipes,e];break;default:i.pipes.push(e)}i.pipesCount+=1,h("pipe count=%d opts=%j",i.pipesCount,t);var a=(!t||!1!==t.end)&&e!==r.stdout&&e!==r.stderr?c:w;function l(t,r){h("onunpipe"),t===p&&r&&!1===r.hasUnpiped&&(r.hasUnpiped=!0,h("cleanup"),e.removeListener("close",S),e.removeListener("finish",g),e.removeListener("drain",u),e.removeListener("error",_),e.removeListener("unpipe",l),p.removeListener("end",c),p.removeListener("end",w),p.removeListener("data",d),y=!0,!i.awaitDrain||e._writableState&&!e._writableState.needDrain||u())}function c(){h("onend"),e.end()}i.endEmitted?o.nextTick(a):p.once("end",a),e.on("unpipe",l);var u=function(e){return function(){var t=e._readableState;h("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&n(e,"data")&&(t.flowing=!0,D(e))}}(p);e.on("drain",u);var y=!1;var f=!1;function d(t){h("ondata"),f=!1,!1!==e.write(t)||f||((1===i.pipesCount&&i.pipes===e||i.pipesCount>1&&-1!==C(i.pipes,e))&&!y&&(h("false write response, pause",p._readableState.awaitDrain),p._readableState.awaitDrain++,f=!0),p.pause())}function _(t){h("onerror",t),w(),e.removeListener("error",_),0===n(e,"error")&&e.emit("error",t)}function S(){e.removeListener("finish",g),w()}function g(){h("onfinish"),e.removeListener("close",S),w()}function w(){h("unpipe"),p.unpipe(e)}return p.on("data",d),function(e,t,p){if("function"==typeof e.prependListener)return e.prependListener(t,p);e._events&&e._events[t]?s(e._events[t])?e._events[t].unshift(p):e._events[t]=[p,e._events[t]]:e.on(t,p)}(e,"error",_),e.once("close",S),e.once("finish",g),e.emit("pipe",p),i.flowing||(h("pipe resume"),p.resume()),e},w.prototype.unpipe=function(e){var t=this._readableState,p={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes||(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this,p)),this;if(!e){var r=t.pipes,o=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function n(e){var t=this.lastTotal-this.lastNeed,p=function(e,t,p){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(e.lastNeed>1&&t.length>1){if(128!=(192&t[1]))return e.lastNeed=1,"�";if(e.lastNeed>2&&t.length>2&&128!=(192&t[2]))return e.lastNeed=2,"�"}}(this,e);return void 0!==p?p:this.lastNeed<=e.length?(e.copy(this.lastChar,t,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(e.copy(this.lastChar,t,0,e.length),void(this.lastNeed-=e.length))}function a(e,t){if((e.length-t)%2==0){var p=e.toString("utf16le",t);if(p){var r=p.charCodeAt(p.length-1);if(r>=55296&&r<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1],p.slice(0,-1)}return p}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=e[e.length-1],e.toString("utf16le",t,e.length-1)}function l(e){var t=e&&e.length?this.write(e):"";if(this.lastNeed){var p=this.lastTotal-this.lastNeed;return t+this.lastChar.toString("utf16le",0,p)}return t}function c(e,t){var p=(e.length-t)%3;return 0===p?e.toString("base64",t):(this.lastNeed=3-p,this.lastTotal=3,1===p?this.lastChar[0]=e[e.length-1]:(this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1]),e.toString("base64",t,e.length-p))}function u(e){var t=e&&e.length?this.write(e):"";return this.lastNeed?t+this.lastChar.toString("base64",0,3-this.lastNeed):t}function y(e){return e.toString(this.encoding)}function h(e){return e&&e.length?this.write(e):""}t.StringDecoder=i,i.prototype.write=function(e){if(0===e.length)return"";var t,p;if(this.lastNeed){if(void 0===(t=this.fillLast(e)))return"";p=this.lastNeed,this.lastNeed=0}else p=0;return p=0)return o>0&&(e.lastNeed=o-1),o;if(--r=0)return o>0&&(e.lastNeed=o-2),o;if(--r=0)return o>0&&(2===o?o=0:e.lastNeed=o-3),o;return 0}(this,e,t);if(!this.lastNeed)return e.toString("utf8",t);this.lastTotal=p;var r=e.length-(p-this.lastNeed);return e.copy(this.lastChar,0,r),e.toString("utf8",t,r)},i.prototype.fillLast=function(e){if(this.lastNeed<=e.length)return e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,e.length),this.lastNeed-=e.length}},function(e,t,p){"use strict";e.exports=s;var r=p(7),o=p(10);function i(e,t){var p=this._transformState;p.transforming=!1;var r=p.writecb;if(!r)return this.emit("error",new Error("write callback called multiple times"));p.writechunk=null,p.writecb=null,null!=t&&this.push(t),r(e);var o=this._readableState;o.reading=!1,(o.needReadable||o.length>8&255^255&p],t&=65535;return t}r.exports={preambleByte:85,crc16:S,sbpIdTable:h,sbpMessageTypesTable:f,decode:function(e){var t=d.parse(e),p=h[t.msg_type];return void 0===p?(console.log("Unknown message type: ",t.msg_type),new s(t)):new p(t)},dispatch:function(t,p,o){var i,s,n=new e(0);if(void 0===o&&"function"==typeof p?i=p:(i=o,s=p),s&&!Array.isArray(s)&&-1===["function","number"].indexOf(typeof s))throw l("dispatch: messageWhitelist must be function, number, or array");var a=function(p){t.pause();try{if((n=e.concat([n,p])).length<2)return;var o=function(){var e,t,p,o,i,a,l;for(l=0;ln.length)throw new c;e=n.slice(l+1,l+6),p=n.readUInt16LE(l+1),_=n.readUInt16LE(l+3),o=n.readUInt8(l+5);var y=s&&Array.isArray(s)&&-1!==s.indexOf(p),h=s&&"number"==typeof s&&s&p,f=s&&"function"==typeof s&&s(p);if(s&&!(y||h||f))return n=n.slice(l+6+o+2),null;if(l+8+o>n.length)throw new c;a=S(n.slice(l+6,l+6+o),S(e)),i=n.readUInt16LE(l+6+o);var d=n.slice(l,l+6+o+2);if(i===a)return n=n.slice(l+6+o+2),[r.exports.decode(d),d];throw n=n.slice(l+1),new u}();if(null===o)return;var l=o[0],y=o[1];i(null,l,y)}catch(e){if(!(e instanceof c||e instanceof u))throw e}finally{t.resume(),n.length>0&&setTimeout((function(){a(new e(0))}),0)}};t.on("data",a)}},function(e){var p={function:!0,object:!0},i=p[typeof window]&&window||this,s=p[typeof t]&&t&&!t.nodeType&&t,n=p[typeof r]&&r&&!r.nodeType&&r,a=s&&n&&"object"==typeof o&&o;!a||a.global!==a&&a.window!==a&&a.self!==a||(i=a),i.SBP=e}(r.exports)}).call(this,p(8).Buffer,p(27)(e),p(5))},function(e,t,p){"use strict";t.byteLength=function(e){var t=l(e),p=t[0],r=t[1];return 3*(p+r)/4-r},t.toByteArray=function(e){for(var t,p=l(e),r=p[0],s=p[1],n=new i(function(e,t,p){return 3*(t+p)/4-p}(0,r,s)),a=0,c=s>0?r-4:r,u=0;u>16&255,n[a++]=t>>8&255,n[a++]=255&t;2===s&&(t=o[e.charCodeAt(u)]<<2|o[e.charCodeAt(u+1)]>>4,n[a++]=255&t);1===s&&(t=o[e.charCodeAt(u)]<<10|o[e.charCodeAt(u+1)]<<4|o[e.charCodeAt(u+2)]>>2,n[a++]=t>>8&255,n[a++]=255&t);return n},t.fromByteArray=function(e){for(var t,p=e.length,o=p%3,i=[],s=0,n=p-o;sn?n:s+16383));1===o?(t=e[p-1],i.push(r[t>>2]+r[t<<4&63]+"==")):2===o&&(t=(e[p-2]<<8)+e[p-1],i.push(r[t>>10]+r[t>>4&63]+r[t<<2&63]+"="));return i.join("")};for(var r=[],o=[],i="undefined"!=typeof Uint8Array?Uint8Array:Array,s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",n=0,a=s.length;n0)throw new Error("Invalid string. Length must be a multiple of 4");var p=e.indexOf("=");return-1===p&&(p=t),[p,p===t?0:4-p%4]}function c(e,t,p){for(var o,i,s=[],n=t;n>18&63]+r[i>>12&63]+r[i>>6&63]+r[63&i]);return s.join("")}o["-".charCodeAt(0)]=62,o["_".charCodeAt(0)]=63},function(e,t){t.read=function(e,t,p,r,o){var i,s,n=8*o-r-1,a=(1<>1,c=-7,u=p?o-1:0,y=p?-1:1,h=e[t+u];for(u+=y,i=h&(1<<-c)-1,h>>=-c,c+=n;c>0;i=256*i+e[t+u],u+=y,c-=8);for(s=i&(1<<-c)-1,i>>=-c,c+=r;c>0;s=256*s+e[t+u],u+=y,c-=8);if(0===i)i=1-l;else{if(i===a)return s?NaN:1/0*(h?-1:1);s+=Math.pow(2,r),i-=l}return(h?-1:1)*s*Math.pow(2,i-r)},t.write=function(e,t,p,r,o,i){var s,n,a,l=8*i-o-1,c=(1<>1,y=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:i-1,f=r?1:-1,d=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(n=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(a=Math.pow(2,-s))<1&&(s--,a*=2),(t+=s+u>=1?y/a:y*Math.pow(2,1-u))*a>=2&&(s++,a/=2),s+u>=c?(n=0,s=c):s+u>=1?(n=(t*a-1)*Math.pow(2,o),s+=u):(n=t*Math.pow(2,u-1)*Math.pow(2,o),s=0));o>=8;e[p+h]=255&n,h+=f,n/=256,o-=8);for(s=s<0;e[p+h]=255&s,h+=f,s/=256,l-=8);e[p+h-f]|=128*d}},function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},function(e,t,p){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Context=void 0;var r=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=r},function(e,t){e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},function(e,t,p){(function(e){function p(e,t){for(var p=0,r=e.length-1;r>=0;r--){var o=e[r];"."===o?e.splice(r,1):".."===o?(e.splice(r,1),p++):p&&(e.splice(r,1),p--)}if(t)for(;p--;p)e.unshift("..");return e}var r=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/,o=function(e){return r.exec(e).slice(1)};function i(e,t){if(e.filter)return e.filter(t);for(var p=[],r=0;r=-1&&!r;o--){var s=o>=0?arguments[o]:e.cwd();if("string"!=typeof s)throw new TypeError("Arguments to path.resolve must be strings");s&&(t=s+"/"+t,r="/"===s.charAt(0))}return(r?"/":"")+(t=p(i(t.split("/"),(function(e){return!!e})),!r).join("/"))||"."},t.normalize=function(e){var r=t.isAbsolute(e),o="/"===s(e,-1);return(e=p(i(e.split("/"),(function(e){return!!e})),!r).join("/"))||r||(e="."),e&&o&&(e+="/"),(r?"/":"")+e},t.isAbsolute=function(e){return"/"===e.charAt(0)},t.join=function(){var e=Array.prototype.slice.call(arguments,0);return t.normalize(i(e,(function(e,t){if("string"!=typeof e)throw new TypeError("Arguments to path.join must be strings");return e})).join("/"))},t.relative=function(e,p){function r(e){for(var t=0;t=0&&""===e[p];p--);return t>p?[]:e.slice(t,p-t+1)}e=t.resolve(e).substr(1),p=t.resolve(p).substr(1);for(var o=r(e.split("/")),i=r(p.split("/")),s=Math.min(o.length,i.length),n=s,a=0;a0?this.tail.next=t:this.head=t,this.tail=t,++this.length},e.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},e.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},e.prototype.clear=function(){this.head=this.tail=null,this.length=0},e.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,p=""+t.data;t=t.next;)p+=e+t.data;return p},e.prototype.concat=function(e){if(0===this.length)return r.alloc(0);if(1===this.length)return this.head.data;for(var t=r.allocUnsafe(e>>>0),p=this.head,o=0;p;)i(p.data,t,o),o+=p.data.length,p=p.next;return t},e}(),o&&o.inspect&&o.inspect.custom&&(e.exports.prototype[o.inspect.custom]=function(){var e=o.inspect({length:this.length});return this.constructor.name+" "+e})},function(e,t){},function(e,t,p){(function(e){var r=void 0!==e&&e||"undefined"!=typeof self&&self||window,o=Function.prototype.apply;function i(e,t){this._id=e,this._clearFn=t}t.setTimeout=function(){return new i(o.call(setTimeout,r,arguments),clearTimeout)},t.setInterval=function(){return new i(o.call(setInterval,r,arguments),clearInterval)},t.clearTimeout=t.clearInterval=function(e){e&&e.close()},i.prototype.unref=i.prototype.ref=function(){},i.prototype.close=function(){this._clearFn.call(r,this._id)},t.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},t.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},t._unrefActive=t.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout((function(){e._onTimeout&&e._onTimeout()}),t))},p(36),t.setImmediate="undefined"!=typeof self&&self.setImmediate||void 0!==e&&e.setImmediate||this&&this.setImmediate,t.clearImmediate="undefined"!=typeof self&&self.clearImmediate||void 0!==e&&e.clearImmediate||this&&this.clearImmediate}).call(this,p(5))},function(e,t,p){(function(e,t){!function(e,p){"use strict";if(!e.setImmediate){var r,o,i,s,n,a=1,l={},c=!1,u=e.document,y=Object.getPrototypeOf&&Object.getPrototypeOf(e);y=y&&y.setTimeout?y:e,"[object process]"==={}.toString.call(e.process)?r=function(e){t.nextTick((function(){f(e)}))}:!function(){if(e.postMessage&&!e.importScripts){var t=!0,p=e.onmessage;return e.onmessage=function(){t=!1},e.postMessage("","*"),e.onmessage=p,t}}()?e.MessageChannel?((i=new MessageChannel).port1.onmessage=function(e){f(e.data)},r=function(e){i.port2.postMessage(e)}):u&&"onreadystatechange"in u.createElement("script")?(o=u.documentElement,r=function(e){var t=u.createElement("script");t.onreadystatechange=function(){f(e),t.onreadystatechange=null,o.removeChild(t),t=null},o.appendChild(t)}):r=function(e){setTimeout(f,0,e)}:(s="setImmediate$"+Math.random()+"$",n=function(t){t.source===e&&"string"==typeof t.data&&0===t.data.indexOf(s)&&f(+t.data.slice(s.length))},e.addEventListener?e.addEventListener("message",n,!1):e.attachEvent("onmessage",n),r=function(t){e.postMessage(s+t,"*")}),y.setImmediate=function(e){"function"!=typeof e&&(e=new Function(""+e));for(var t=new Array(arguments.length-1),p=0;p * @license MIT */ -function r(e,t){if(e===t)return 0;for(var p=e.length,r=t.length,o=0,i=Math.min(p,r);o=0;l--)if(u[l]!==c[l])return!1;for(l=u.length-1;l>=0;l--)if(a=u[l],!g(e[a],t[a],p,r))return!1;return!0}(e,t,p,s))}return p?e===t:e==t}function w(e){return"[object Arguments]"==Object.prototype.toString.call(e)}function E(e,t){if(!e||!t)return!1;if("[object RegExp]"==Object.prototype.toString.call(t))return t.test(e);try{if(e instanceof t)return!0}catch(e){}return!Error.isPrototypeOf(t)&&!0===t.call({},e)}function m(e,t,p,r){var o;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof p&&(r=p,p=null),o=function(e){var t;try{e()}catch(e){t=e}return t}(t),r=(p&&p.name?" ("+p.name+").":".")+(r?" "+r:"."),e&&!o&&_(o,p,"Missing expected exception"+r);var s="string"==typeof r,n=!e&&o&&!p;if((!e&&i.isError(o)&&s&&E(o,p)||n)&&_(o,p,"Got unwanted exception"+r),e&&o&&p&&!E(o,p)||!e&&o)throw o}c.AssertionError=function(e){this.name="AssertionError",this.actual=e.actual,this.expected=e.expected,this.operator=e.operator,e.message?(this.message=e.message,this.generatedMessage=!1):(this.message=function(e){return f(d(e.actual),128)+" "+e.operator+" "+f(d(e.expected),128)}(this),this.generatedMessage=!0);var t=e.stackStartFunction||_;if(Error.captureStackTrace)Error.captureStackTrace(this,t);else{var p=new Error;if(p.stack){var r=p.stack,o=h(t),i=r.indexOf("\n"+o);if(i>=0){var s=r.indexOf("\n",i+1);r=r.substring(s+1)}this.stack=r}}},i.inherits(c.AssertionError,Error),c.fail=_,c.ok=S,c.equal=function(e,t,p){e!=t&&_(e,t,p,"==",c.equal)},c.notEqual=function(e,t,p){e==t&&_(e,t,p,"!=",c.notEqual)},c.deepEqual=function(e,t,p){g(e,t,!1)||_(e,t,p,"deepEqual",c.deepEqual)},c.deepStrictEqual=function(e,t,p){g(e,t,!0)||_(e,t,p,"deepStrictEqual",c.deepStrictEqual)},c.notDeepEqual=function(e,t,p){g(e,t,!1)&&_(e,t,p,"notDeepEqual",c.notDeepEqual)},c.notDeepStrictEqual=function e(t,p,r){g(t,p,!0)&&_(t,p,r,"notDeepStrictEqual",e)},c.strictEqual=function(e,t,p){e!==t&&_(e,t,p,"===",c.strictEqual)},c.notStrictEqual=function(e,t,p){e===t&&_(e,t,p,"!==",c.notStrictEqual)},c.throws=function(e,t,p){m(!0,e,t,p)},c.doesNotThrow=function(e,t,p){m(!1,e,t,p)},c.ifError=function(e){if(e)throw e};var b=Object.keys||function(e){var t=[];for(var p in e)s.call(e,p)&&t.push(p);return t}}).call(this,p(5))},function(e,t,p){var r;!function(p){o(Math.pow(36,5)),o(Math.pow(16,7)),o(Math.pow(10,9)),o(Math.pow(2,30)),o(36),o(16),o(10),o(2);function o(e,t){return this instanceof o?(this._low=0,this._high=0,this.remainder=null,void 0===t?s.call(this,e):"string"==typeof e?n.call(this,e,t):void i.call(this,e,t)):new o(e,t)}function i(e,t){return this._low=0|e,this._high=0|t,this}function s(e){return this._low=65535&e,this._high=e>>>16,this}function n(e,t){var p=parseInt(e,t||10);return this._low=65535&p,this._high=p>>>16,this}o.prototype.fromBits=i,o.prototype.fromNumber=s,o.prototype.fromString=n,o.prototype.toNumber=function(){return 65536*this._high+this._low},o.prototype.toString=function(e){return this.toNumber().toString(e||10)},o.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},o.prototype.subtract=function(e){return this.add(e.clone().negate())},o.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},o.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 o(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 o(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},o.prototype.equals=o.prototype.eq=function(e){return this._low==e._low&&this._high==e._high},o.prototype.greaterThan=o.prototype.gt=function(e){return this._high>e._high||!(this._highe._low},o.prototype.lessThan=o.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},o.prototype.shiftLeft=o.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},o.prototype.rotateRight=o.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},o.prototype.clone=function(){return new o(this._low,this._high)},void 0===(r=function(){return o}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){var r;!function(p){var o={16:s(Math.pow(16,5)),10:s(Math.pow(10,5)),2:s(Math.pow(2,5))},i={16:s(16),10:s(10),2:s(2)};function s(e,t,p,r){return this instanceof s?(this.remainder=null,"string"==typeof e?l.call(this,e,t):void 0===t?a.call(this,e):void n.apply(this,arguments)):new s(e,t,p,r)}function n(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 a(e){return this._a00=65535&e,this._a16=e>>>16,this._a32=0,this._a48=0,this}function l(e,t){t=t||10,this._a00=0,this._a16=0,this._a32=0,this._a48=0;for(var p=o[t]||new s(Math.pow(t,5)),r=0,i=e.length;r=0&&(p.div(t),r[o]=p.remainder.toNumber().toString(e),p.gt(t));o--);return r[o-1]=p.toNumber().toString(e),r.join("")},s.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},s.prototype.subtract=function(e){return this.add(e.clone().negate())},s.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,u=(l+=t*s)>>>16;l&=65535,u+=(l+=p*i)>>>16;var c=(u+=t*n)>>>16;return u&=65535,c+=(u+=p*s)>>>16,u&=65535,c+=(u+=r*i)>>>16,c+=t*e._a48,c&=65535,c+=p*n,c&=65535,c+=r*s,c&=65535,c+=o*i,this._a00=65535&a,this._a16=65535&l,this._a32=65535&u,this._a48=65535&c,this},s.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 s(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 s(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},s.prototype.equals=s.prototype.eq=function(e){return this._a48==e._a48&&this._a00==e._a00&&this._a32==e._a32&&this._a16==e._a16},s.prototype.greaterThan=s.prototype.gt=function(e){return this._a48>e._a48||!(this._a48e._a32||!(this._a32e._a16||!(this._a16e._a00))},s.prototype.lessThan=s.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},s.prototype.shiftLeft=s.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},s.prototype.rotateRight=s.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},s.prototype.clone=function(){return new s(this._a00,this._a16,this._a32,this._a48)},void 0===(r=function(){return s}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=(p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).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 u=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_RESULT_DEP_A",u.prototype.msg_type=21,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").uint8("prn"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["snr","writeFloatLE",4]),u.prototype.fieldSpec.push(["cp","writeFloatLE",4]),u.prototype.fieldSpec.push(["cf","writeFloatLE",4]),u.prototype.fieldSpec.push(["prn","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="AcqSvProfile",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="AcqSvProfile",c.prototype.constructor=c,c.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"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["job_type","writeUInt8",1]),c.prototype.fieldSpec.push(["status","writeUInt8",1]),c.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),c.prototype.fieldSpec.push(["int_time","writeUInt8",1]),c.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),c.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),c.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),c.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),c.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),c.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),c.prototype.fieldSpec.push(["cf","writeInt32LE",4]),c.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE",h.prototype.msg_type=46,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:c.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["acq_sv_profile","array",c.prototype.fieldSpec,function(){return this.fields.array.length},null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE_DEP",f.prototype.msg_type=30,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:y.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.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:u,MsgAcqResultDepA:u,AcqSvProfile:c,AcqSvProfileDep:y,46:h,MsgAcqSvProfile:h,30:f,MsgAcqSvProfileDep:f}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",u.prototype.msg_type=176,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").array("handshake",{type:"uint8",readUntil:"eof"}),u.prototype.fieldSpec=[],u.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:u,MsgBootloaderHandshakeDepA:u}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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").array("contents",{type:"uint8",readUntil:"eof"}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),a.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},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 u=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_WRITE_REQ",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_WRITE_REQ",u.prototype.msg_type=173,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("filename",{greedy:!0}).array("data",{type:"uint8",readUntil:"eof"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),u.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),u.prototype.fieldSpec.push(["filename","string",null]),u.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},null]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_WRITE_RESP",c.prototype.msg_type=171,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sequence"),c.prototype.fieldSpec=[],c.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_CONFIG_RESP",h.prototype.msg_type=4098,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("window_size").uint32("batch_size").uint32("fileio_version"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),h.prototype.fieldSpec.push(["window_size","writeUInt32LE",4]),h.prototype.fieldSpec.push(["batch_size","writeUInt32LE",4]),h.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:u,MsgFileioWriteReq:u,171:c,MsgFileioWriteResp:c,4097:y,MsgFileioConfigReq:y,4098:h,MsgFileioConfigResp:h}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=function(e,t){return r.call(this,e),this.messageType="MSG_STM_FLASH_LOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_STM_FLASH_LOCK_SECTOR",u.prototype.msg_type=227,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sector"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_STM_FLASH_UNLOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_STM_FLASH_UNLOCK_SECTOR",c.prototype.msg_type=228,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sector"),c.prototype.fieldSpec=[],c.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_STM_UNIQUE_ID_RESP",h.prototype.msg_type=229,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("stm_id",{length:12,type:"uint8"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["stm_id","array","writeUInt8",function(){return 1},12]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_M25_FLASH_WRITE_STATUS",f.prototype.msg_type=243,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("status",{length:1,type:"uint8"}),f.prototype.fieldSpec=[],f.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:u,MsgStmFlashLockSector:u,228:c,MsgStmFlashUnlockSector:c,232:y,MsgStmUniqueIdReq:y,229:h,MsgStmUniqueIdResp:h,243:f,MsgM25FlashWriteStatus:f}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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]),e.exports={2304:i,MsgImuRaw:i,2305:s,MsgImuAux:s}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal,p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),s=p(0).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").array("reserved",{length:6,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(["reserved","array","writeUInt8",function(){return 1},6]),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 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 c=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};(c.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",c.prototype.msg_type=3015,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 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 h=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};(h.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",h.prototype.msg_type=3025,h.prototype.constructor=h,h.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"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),h.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),h.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),h.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]),e.exports={IntegritySSRHeader:n,3001:a,MsgSsrFlagHighLevel:a,3005:l,MsgSsrFlagSatellites:l,3011:u,MsgSsrFlagTropoGridPoints:u,3015:c,MsgSsrFlagIonoGridPoints:c,3021:y,MsgSsrFlagIonoTileSatLos:y,3025:h,MsgSsrFlagIonoGridPointSatLos:h}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_SOCKET_USAGE",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SOCKET_USAGE",u.prototype.msg_type=32517,u.prototype.constructor=u,u.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"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["avg_queue_depth","writeUInt32LE",4]),u.prototype.fieldSpec.push(["max_queue_depth","writeUInt32LE",4]),u.prototype.fieldSpec.push(["socket_state_counts","array","writeUInt16LE",function(){return 2},16]),u.prototype.fieldSpec.push(["socket_type_counts","array","writeUInt16LE",function(){return 2},16]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_COUNT",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_PROCESS_FD_COUNT",c.prototype.msg_type=32518,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("fd_count").string("cmdline",{greedy:!0}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["index","writeUInt8",1]),c.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),c.prototype.fieldSpec.push(["fd_count","writeUInt16LE",2]),c.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_CPU_STATE",h.prototype.msg_type=32520,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["index","writeUInt8",1]),h.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),h.prototype.fieldSpec.push(["time","writeUInt32LE",4]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["tname","string",15]),h.prototype.fieldSpec.push(["cmdline","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_MEM_STATE",f.prototype.msg_type=32521,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").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(["pmem","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_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SYS_STATE",d.prototype.msg_type=32522,d.prototype.constructor=d,d.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"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),d.prototype.fieldSpec.push(["pmem","writeUInt8",1]),d.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),d.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]),d.prototype.fieldSpec.push(["time","writeUInt32LE",4]),d.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:u,MsgLinuxSocketUsage:u,32518:c,MsgLinuxProcessFdCount:c,32519:y,MsgLinuxProcessFdSummary:y,32520:h,MsgLinuxCpuState:h,32521:f,MsgLinuxMemState:f,32522:d,MsgLinuxSysState:d}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF",u.prototype.msg_type=521,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").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(["accuracy","writeUInt16LE",2]),u.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),u.prototype.fieldSpec.push(["flags","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_COV",c.prototype.msg_type=532,c.prototype.constructor=c,c.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"),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(["cov_x_x","writeFloatLE",4]),c.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),c.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),c.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),c.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),c.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),c.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),c.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_COV",h.prototype.msg_type=529,h.prototype.constructor=h,h.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"),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(["cov_n_n","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="EstimatedHorizontalErrorEllipse",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").floatle("semi_major").floatle("semi_minor").floatle("orientation"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["semi_major","writeFloatLE",4]),f.prototype.fieldSpec.push(["semi_minor","writeFloatLE",4]),f.prototype.fieldSpec.push(["orientation","writeFloatLE",4]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_ACC",d.prototype.msg_type=536,d.prototype.constructor=d,d.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:f.prototype.parser}).uint8("confidence_and_geoid").uint8("n_sats").uint8("flags"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),d.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),d.prototype.fieldSpec.push(["height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["orthometric_height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["h_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["v_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["ct_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["at_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["h_ellipse",f.prototype.fieldSpec]),d.prototype.fieldSpec.push(["confidence_and_geoid","writeUInt8",1]),d.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),d.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 M=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_GNSS",M.prototype.msg_type=558,M.prototype.constructor=M,M.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"),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(["h_accuracy","writeUInt16LE",2]),M.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),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_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_COV_GNSS",D.prototype.msg_type=562,D.prototype.constructor=D,D.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"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),D.prototype.fieldSpec.push(["n","writeInt32LE",4]),D.prototype.fieldSpec.push(["e","writeInt32LE",4]),D.prototype.fieldSpec.push(["d","writeInt32LE",4]),D.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),D.prototype.fieldSpec.push(["flags","writeUInt8",1]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_VEL_BODY",O.prototype.msg_type=531,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),O.prototype.fieldSpec.push(["x","writeInt32LE",4]),O.prototype.fieldSpec.push(["y","writeInt32LE",4]),O.prototype.fieldSpec.push(["z","writeInt32LE",4]),O.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),O.prototype.fieldSpec.push(["flags","writeUInt8",1]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_VEL_COG",G.prototype.msg_type=540,G.prototype.constructor=G,G.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"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),G.prototype.fieldSpec.push(["cog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up","writeInt32LE",4]),G.prototype.fieldSpec.push(["cog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["flags","writeUInt16LE",2]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_AGE_CORRECTIONS",A.prototype.msg_type=528,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint32("tow").uint16("age"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),A.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 R=function(e,t){return r.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_DOPS_DEP_A",R.prototype.msg_type=518,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),R.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),R.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 N=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_DEP_A",N.prototype.msg_type=513,N.prototype.constructor=N,N.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"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),N.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),N.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),N.prototype.fieldSpec.push(["height","writeDoubleLE",8]),N.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),N.prototype.fieldSpec.push(["flags","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_ECEF_DEP_A",j.prototype.msg_type=514,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),j.prototype.fieldSpec.push(["x","writeInt32LE",4]),j.prototype.fieldSpec.push(["y","writeInt32LE",4]),j.prototype.fieldSpec.push(["z","writeInt32LE",4]),j.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),j.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),j.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 k=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="MSG_VEL_ECEF_DEP_A",k.prototype.msg_type=516,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),k.prototype.fieldSpec.push(["x","writeInt32LE",4]),k.prototype.fieldSpec.push(["y","writeInt32LE",4]),k.prototype.fieldSpec.push(["z","writeInt32LE",4]),k.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["flags","writeUInt8",1]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_DEP_A",F.prototype.msg_type=517,F.prototype.constructor=F,F.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"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),F.prototype.fieldSpec.push(["n","writeInt32LE",4]),F.prototype.fieldSpec.push(["e","writeInt32LE",4]),F.prototype.fieldSpec.push(["d","writeInt32LE",4]),F.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),F.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),F.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),F.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 H=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_LEAP_SECOND",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_UTC_LEAP_SECOND",H.prototype.msg_type=570,H.prototype.constructor=H,H.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"),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["reserved_0","writeInt16LE",2]),H.prototype.fieldSpec.push(["reserved_1","writeInt16LE",2]),H.prototype.fieldSpec.push(["reserved_2","writeInt8",1]),H.prototype.fieldSpec.push(["count_before","writeInt8",1]),H.prototype.fieldSpec.push(["reserved_3","writeUInt16LE",2]),H.prototype.fieldSpec.push(["reserved_4","writeUInt16LE",2]),H.prototype.fieldSpec.push(["ref_wn","writeUInt16LE",2]),H.prototype.fieldSpec.push(["ref_dn","writeUInt8",1]),H.prototype.fieldSpec.push(["count_after","writeInt8",1]);let V=function(e,t){return r.call(this,e),this.messageType="MSG_REFERENCE_FRAME_PARAM",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="MSG_REFERENCE_FRAME_PARAM",V.prototype.msg_type=580,V.prototype.constructor=V,V.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"),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),V.prototype.fieldSpec.push(["sn","string",32]),V.prototype.fieldSpec.push(["tn","string",32]),V.prototype.fieldSpec.push(["sin","writeUInt8",1]),V.prototype.fieldSpec.push(["utn","writeUInt16LE",2]),V.prototype.fieldSpec.push(["re_t0","writeUInt16LE",2]),V.prototype.fieldSpec.push(["delta_X0","writeInt32LE",4]),V.prototype.fieldSpec.push(["delta_Y0","writeInt32LE",4]),V.prototype.fieldSpec.push(["delta_Z0","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_01","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_02","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_03","writeInt32LE",4]),V.prototype.fieldSpec.push(["scale","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_X0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_Y0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_Z0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_01","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_02","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_03","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_scale","writeInt16LE",2]),e.exports={258:i,MsgGpsTime:i,260:s,MsgGpsTimeGnss:s,259:n,MsgUtcTime:n,261:a,MsgUtcTimeGnss:a,520:l,MsgDops:l,521:u,MsgPosEcef:u,532:c,MsgPosEcefCov:c,522:y,MsgPosLlh:y,529:h,MsgPosLlhCov:h,EstimatedHorizontalErrorEllipse:f,536:d,MsgPosLlhAcc:d,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:M,MsgVelNedGnss:M,562:D,MsgVelNedCovGnss:D,531:O,MsgVelBody:O,540:G,MsgVelCog:G,528:A,MsgAgeCorrections:A,256:C,MsgGpsTimeDepA:C,518:R,MsgDopsDepA:R,512:P,MsgPosEcefDepA:P,513:N,MsgPosLlhDepA:N,514:j,MsgBaselineEcefDepA:j,515:x,MsgBaselineNedDepA:x,516:k,MsgVelEcefDepA:k,517:F,MsgVelNedDepA:F,519:B,MsgBaselineHeadingDepA:B,534:q,MsgProtectionLevelDepA:q,535:z,MsgProtectionLevel:z,570:H,MsgUtcLeapSecond:H,580:V,MsgReferenceFrameParam:V}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,u=p(0).GPSTimeSec,c=(p(0).SvId,function(e,t){return r.call(this,e),this.messageType="ObservationHeader",this.fields=t||this.parser.parse(e.payload),this});(c.prototype=Object.create(r.prototype)).messageType="ObservationHeader",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").nest("t",{type:a.prototype.parser}).uint8("n_obs"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),c.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 h=function(e,t){return r.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="PackedObsContent",h.prototype.constructor=h,h.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}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["P","writeUInt32LE",4]),h.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),h.prototype.fieldSpec.push(["D",y.prototype.fieldSpec]),h.prototype.fieldSpec.push(["cn0","writeUInt8",1]),h.prototype.fieldSpec.push(["lock","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let f=function(e,t){return r.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="PackedOsrContent",f.prototype.constructor=f,f.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"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["P","writeUInt32LE",4]),f.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),f.prototype.fieldSpec.push(["lock","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["iono_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["tropo_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["range_std","writeUInt16LE",2]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_OBS",d.prototype.msg_type=74,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("header",{type:c.prototype.parser}).array("obs",{type:h.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["header",c.prototype.fieldSpec]),d.prototype.fieldSpec.push(["obs","array",h.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:u.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",u.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:u.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",u.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:u.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",u.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:u.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",u.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:u.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",u.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:u.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",u.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:u.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",u.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:u.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",u.prototype.fieldSpec]),U.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),U.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),U.prototype.fieldSpec.push(["source","writeUInt8",1]);let M=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_A",M.prototype.msg_type=130,M.prototype.constructor=M,M.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"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),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]),M.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),M.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_A",D.prototype.msg_type=131,D.prototype.constructor=D,D.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"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),D.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),D.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),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]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_B",O.prototype.msg_type=132,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["common",w.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 G=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS",G.prototype.msg_type=140,G.prototype.constructor=G,G.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"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),G.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["vel","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["a_gf0","writeFloatLE",4]),G.prototype.fieldSpec.push(["a_gf1","writeFloatLE",4]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_B",A.prototype.msg_type=133,A.prototype.constructor=A,A.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"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),A.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),A.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),A.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),A.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 R=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_D",R.prototype.msg_type=136,R.prototype.constructor=R,R.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"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),R.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),R.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["fcn","writeUInt8",1]),R.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 N=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_D",N.prototype.msg_type=128,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").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),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(["sid",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["iode","writeUInt8",1]),N.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),N.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_A",j.prototype.msg_type=26,j.prototype.constructor=j,j.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"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),j.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),j.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["w","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["valid","writeUInt8",1]),j.prototype.fieldSpec.push(["healthy","writeUInt8",1]),j.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 k=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_C",k.prototype.msg_type=71,k.prototype.constructor=k,k.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"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),k.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),k.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),k.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),k.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),k.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),k.prototype.fieldSpec.push(["w","writeDoubleLE",8]),k.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),k.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),k.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),k.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),k.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),k.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),k.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),k.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),k.prototype.fieldSpec.push(["valid","writeUInt8",1]),k.prototype.fieldSpec.push(["healthy","writeUInt8",1]),k.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),k.prototype.fieldSpec.push(["iode","writeUInt8",1]),k.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),k.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);let F=function(e,t){return r.call(this,e),this.messageType="ObservationHeaderDep",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="ObservationHeaderDep",F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").nest("t",{type:l.prototype.parser}).uint8("n_obs"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["t",l.prototype.fieldSpec]),F.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 H=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepC",H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["P","writeUInt32LE",4]),H.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),H.prototype.fieldSpec.push(["cn0","writeUInt8",1]),H.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),H.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);let V=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_A",V.prototype.msg_type=69,V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").nest("header",{type:F.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),V.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);let Y=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_B",Y.prototype.msg_type=67,Y.prototype.constructor=Y,Y.prototype.parser=(new o).endianess("little").nest("header",{type:F.prototype.parser}).array("obs",{type:z.prototype.parser,readUntil:"eof"}),Y.prototype.fieldSpec=[],Y.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),Y.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:F.prototype.parser}).array("obs",{type:H.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",H.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:u.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",u.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:u.prototype.parser}).uint32("l2c_mask"),K.prototype.fieldSpec=[],K.prototype.fieldSpec.push(["t_nmct",u.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 J=function(e,t){return r.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(r.prototype)).messageType="MSG_GNSS_CAPB",J.prototype.msg_type=150,J.prototype.constructor=J,J.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:u.prototype.parser}).nest("gc",{type:X.prototype.parser}),J.prototype.fieldSpec=[],J.prototype.fieldSpec.push(["t_nmct",u.prototype.fieldSpec]),J.prototype.fieldSpec.push(["gc",X.prototype.fieldSpec]);let Z=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",Z.prototype.msg_type=146,Z.prototype.constructor=Z,Z.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"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["prn","writeUInt8",1]),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 $=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",$.prototype.msg_type=147,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").nest("t_op",{type:u.prototype.parser}).nest("sid",{type:n.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["t_op",u.prototype.fieldSpec]),$.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),$.prototype.fieldSpec.push(["valid","writeUInt8",1]),$.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),$.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:u.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",u.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:u.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",u.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:u.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",u.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 ue=function(e,t){return r.call(this,e),this.messageType="MSG_OSR",this.fields=t||this.parser.parse(e.payload),this};(ue.prototype=Object.create(r.prototype)).messageType="MSG_OSR",ue.prototype.msg_type=1600,ue.prototype.constructor=ue,ue.prototype.parser=(new o).endianess("little").nest("header",{type:c.prototype.parser}).array("obs",{type:f.prototype.parser,readUntil:"eof"}),ue.prototype.fieldSpec=[],ue.prototype.fieldSpec.push(["header",c.prototype.fieldSpec]),ue.prototype.fieldSpec.push(["obs","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={ObservationHeader:c,Doppler:y,PackedObsContent:h,PackedOsrContent:f,74:d,MsgObs:d,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:M,MsgEphemerisSbasDepA:M,131:D,MsgEphemerisGloDepA:D,132:O,MsgEphemerisSbasDepB:O,140:G,MsgEphemerisSbas:G,133:A,MsgEphemerisGloDepB:A,135:C,MsgEphemerisGloDepC:C,136:R,MsgEphemerisGloDepD:R,139:P,MsgEphemerisGlo:P,128:N,MsgEphemerisDepD:N,26:j,MsgEphemerisDepA:j,70:x,MsgEphemerisDepB:x,71:k,MsgEphemerisDepC:k,ObservationHeaderDep:F,CarrierPhaseDepA:B,PackedObsContentDepA:q,PackedObsContentDepB:z,PackedObsContentDepC:H,69:V,MsgObsDepA:V,67:Y,MsgObsDepB:Y,73:W,MsgObsDepC:W,144:Q,MsgIono:Q,145:K,MsgSvConfigurationGpsDep:K,GnssCapb:X,150:J,MsgGnssCapb:J,146:Z,MsgGroupDelayDepA:Z,147:$,MsgGroupDelayDepB:$,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:ue,MsgOsr:ue}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=p(0).GPSTime,a=p(0).GPSTimeDep,l=(p(0).GPSTimeSec,p(0).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 u=function(e,t){return r.call(this,e),this.messageType="MSG_SET_TIME",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_SET_TIME",u.prototype.msg_type=104,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little"),u.prototype.fieldSpec=[];let c=function(e,t){return r.call(this,e),this.messageType="MSG_RESET",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_RESET",c.prototype.msg_type=182,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("flags"),c.prototype.fieldSpec=[],c.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_CW_RESULTS",h.prototype.msg_type=192,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little"),h.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CW_START",f.prototype.msg_type=193,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_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_RESET_FILTERS",d.prototype.msg_type=34,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("filter"),d.prototype.fieldSpec=[],d.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 M=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_RESP",M.prototype.msg_type=185,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("sequence").int32("code"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),M.prototype.fieldSpec.push(["code","writeInt32LE",4]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_OUTPUT",D.prototype.msg_type=188,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("sequence").string("line",{greedy:!0}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),D.prototype.fieldSpec.push(["line","string",null]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_REQ",O.prototype.msg_type=186,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little"),O.prototype.fieldSpec=[];let G=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_RESP",G.prototype.msg_type=187,G.prototype.constructor=G,G.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"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["ipv4_address","array","writeUInt8",function(){return 1},4]),G.prototype.fieldSpec.push(["ipv4_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["ipv6_address","array","writeUInt8",function(){return 1},16]),G.prototype.fieldSpec.push(["ipv6_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["interface_name","string",16]),G.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let A=function(e,t){return r.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="NetworkUsage",A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint64("duration").uint64("total_bytes").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["duration","writeUInt64LE",8]),A.prototype.fieldSpec.push(["total_bytes","writeUInt64LE",8]),A.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),A.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:A.prototype.parser,readUntil:"eof"}),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["interfaces","array",A.prototype.fieldSpec,function(){return this.fields.array.length},null]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_CELL_MODEM_STATUS",R.prototype.msg_type=190,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").int8("signal_strength").floatle("signal_error_rate").array("reserved",{type:"uint8",readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["signal_strength","writeInt8",1]),R.prototype.fieldSpec.push(["signal_error_rate","writeFloatLE",4]),R.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 N=function(e,t){return r.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SPECAN",N.prototype.msg_type=81,N.prototype.constructor=N,N.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"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),N.prototype.fieldSpec.push(["t",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_FRONT_END_GAIN",j.prototype.msg_type=191,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").array("rf_gain",{length:8,type:"int8"}).array("if_gain",{length:8,type:"int8"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["rf_gain","array","writeInt8",function(){return 1},8]),j.prototype.fieldSpec.push(["if_gain","array","writeInt8",function(){return 1},8]),e.exports={105:l,MsgAlmanac:l,104:u,MsgSetTime:u,182:c,MsgReset:c,178:y,MsgResetDep:y,192:h,MsgCwResults:h,193:f,MsgCwStart:f,34:d,MsgResetFilters:d,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:M,MsgCommandResp:M,188:D,MsgCommandOutput:D,186:O,MsgNetworkStateReq:O,187:G,MsgNetworkStateResp:G,NetworkUsage:A,189:C,MsgNetworkBandwidthUsage:C,190:R,MsgCellModemStatus:R,80:P,MsgSpecanDep:P,81:N,MsgSpecan:N,191:j,MsgFrontEndGain:j}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=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};(u.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",u.prototype.msg_type=162,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("index"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt16LE",2]);let c=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};(c.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",c.prototype.msg_type=167,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("index").string("setting",{greedy:!0}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["index","writeUInt16LE",2]),c.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER",h.prototype.msg_type=174,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["setting","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER_RESP",f.prototype.msg_type=431,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["status","writeUInt8",1]),f.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:u,MsgSettingsReadByIndexReq:u,167:c,MsgSettingsReadByIndexResp:c,166:y,MsgSettingsReadByIndexDone:y,174:h,MsgSettingsRegister:h,431:f,MsgSettingsRegisterResp:f}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal,p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE_DEP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE_DEP",i.prototype.msg_type=3073,i.prototype.constructor=i,i.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"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),i.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),i.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_CERTIFICATE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_CERTIFICATE",s.prototype.msg_type=3074,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("n_msg").array("fingerprint",{length:20,type:"uint8"}).array("certificate_bytes",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["n_msg","writeUInt8",1]),s.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),s.prototype.fieldSpec.push(["certificate_bytes","array","writeUInt8",function(){return 1},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE",n.prototype.msg_type=3075,n.prototype.constructor=n,n.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"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),n.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),n.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),n.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),n.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]),e.exports={3073:i,MsgEd25519SignatureDep:i,3074:s,MsgEd25519Certificate:s,3075:n,MsgEd25519Signature:n}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=function(e,t){return r.call(this,e),this.messageType="OdoInputType",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="OdoInputType",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={SolutionInputType:i,65295:s,MsgSolnMetaDepA:s,65294:n,MsgSolnMeta:n,GNSSInputType:a,IMUInputType:l,OdoInputType:u}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),n=p(0).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 u=function(e,t){return r.call(this,e),this.messageType="STECHeader",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="STECHeader",u.prototype.constructor=u,u.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"),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","writeUInt8",1]),u.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),u.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),u.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);let c=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeader",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeader",c.prototype.constructor=c,c.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"),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","writeUInt16LE",2]),c.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),c.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),c.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),c.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 h=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrectionNoStd",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),h.prototype.fieldSpec.push(["wet","writeInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrection",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet").uint8("stddev"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),f.prototype.fieldSpec.push(["wet","writeInt8",1]),f.prototype.fieldSpec.push(["stddev","writeUInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="STECResidualNoStd",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),d.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:u.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["header",u.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:c.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["header",c.prototype.fieldSpec]),I.prototype.fieldSpec.push(["index","writeUInt16LE",2]),I.prototype.fieldSpec.push(["tropo_delay_correction",f.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:f.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",f.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",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP",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",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION",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 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",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC",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 O=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};(O.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",O.prototype.msg_type=1500,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),O.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),O.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),O.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),O.prototype.fieldSpec.push(["iod","writeUInt8",1]),O.prototype.fieldSpec.push(["radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["along","writeInt32LE",4]),O.prototype.fieldSpec.push(["cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["c0","writeInt32LE",4]),O.prototype.fieldSpec.push(["c1","writeInt32LE",4]),O.prototype.fieldSpec.push(["c2","writeInt32LE",4]);let G=function(e,t){return r.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="STECHeaderDepA",G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),G.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),G.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),G.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),G.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);let A=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeaderDepA",A.prototype.constructor=A,A.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"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),A.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),A.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),A.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),A.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),A.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);let C=function(e,t){return r.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="GridDefinitionHeaderDepA",C.prototype.constructor=C,C.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"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),C.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),C.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:G.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["header",G.prototype.fieldSpec]),R.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let P=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};(P.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",P.prototype.msg_type=1520,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:h.prototype.parser}).array("stec_residuals",{type:d.prototype.parser,readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["header",A.prototype.fieldSpec]),P.prototype.fieldSpec.push(["index","writeUInt16LE",2]),P.prototype.fieldSpec.push(["tropo_delay_correction",h.prototype.fieldSpec]),P.prototype.fieldSpec.push(["stec_residuals","array",d.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_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",N.prototype.msg_type=1530,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["header",A.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",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);let j=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};(j.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",j.prototype.msg_type=1525,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("header",{type:C.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["header",C.prototype.fieldSpec]),j.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]);let x=function(e,t){return r.call(this,e),this.messageType="OrbitClockBound",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="OrbitClockBound",x.prototype.constructor=x,x.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"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_sig","writeUInt8",1]);let k=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",k.prototype.msg_type=1502,k.prototype.constructor=k,k.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:x.prototype.parser,length:"n_sats"}),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),k.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),k.prototype.fieldSpec.push(["const_id","writeUInt8",1]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["orbit_clock_bounds","array",x.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let F=function(e,t){return r.call(this,e),this.messageType="CodePhaseBiasesSatSig",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="CodePhaseBiasesSatSig",F.prototype.constructor=F,F.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"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),F.prototype.fieldSpec.push(["signal_id","writeUInt8",1]),F.prototype.fieldSpec.push(["code_bias_bound_mu","writeUInt8",1]),F.prototype.fieldSpec.push(["code_bias_bound_sig","writeUInt8",1]),F.prototype.fieldSpec.push(["phase_bias_bound_mu","writeUInt8",1]),F.prototype.fieldSpec.push(["phase_bias_bound_sig","writeUInt8",1]);let B=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};(B.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",B.prototype.msg_type=1516,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_signals").array("satellites_signals",{type:F.prototype.parser,length:"n_sats_signals"}),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_signals","writeUInt8",1]),B.prototype.fieldSpec.push(["satellites_signals","array",F.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats_signals"]);let q=function(e,t){return r.call(this,e),this.messageType="OrbitClockBoundDegradation",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="OrbitClockBoundDegradation",q.prototype.constructor=q,q.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"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["orb_radial_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_radial_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_sig_dot","writeUInt8",1]);let z=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};(z.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",z.prototype.msg_type=1503,z.prototype.constructor=z,z.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:q.prototype.parser}),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(["sat_bitmask","writeUInt64LE",8]),z.prototype.fieldSpec.push(["orbit_clock_bounds_degradation",q.prototype.fieldSpec]),e.exports={CodeBiasesContent:a,PhaseBiasesContent:l,STECHeader:u,GriddedCorrectionHeader:c,STECSatElement:y,TroposphericDelayCorrectionNoStd:h,TroposphericDelayCorrection:f,STECResidualNoStd:d,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,MsgSsrTileDefinitionDep:v,1527:U,MsgSsrTileDefinition:U,SatelliteAPC:M,1540:D,MsgSsrSatelliteApc:D,1500:O,MsgSsrOrbitClockDepA:O,STECHeaderDepA:G,GriddedCorrectionHeaderDepA:A,GridDefinitionHeaderDepA:C,1515:R,MsgSsrStecCorrectionDepA:R,1520:P,MsgSsrGriddedCorrectionNoStdDepA:P,1530:N,MsgSsrGriddedCorrectionDepA:N,1525:j,MsgSsrGridDefinitionDepA:j,OrbitClockBound:x,1502:k,MsgSsrOrbitClockBounds:k,CodePhaseBiasesSatSig:F,1516:B,MsgSsrCodePhaseBiasesBounds:B,OrbitClockBoundDegradation:q,1503:z,MsgSsrOrbitClockBoundsDegradation:z}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 u=function(e,t){return r.call(this,e),this.messageType="StatusJournalItem",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="StatusJournalItem",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("uptime").nest("report",{type:a.prototype.parser}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),u.prototype.fieldSpec.push(["report",a.prototype.fieldSpec]);let c=function(e,t){return r.call(this,e),this.messageType="MSG_STATUS_JOURNAL",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_STATUS_JOURNAL",c.prototype.msg_type=65533,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("total_status_reports").uint8("sequence_descriptor").array("journal",{type:u.prototype.parser,readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),c.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),c.prototype.fieldSpec.push(["total_status_reports","writeUInt32LE",4]),c.prototype.fieldSpec.push(["sequence_descriptor","writeUInt8",1]),c.prototype.fieldSpec.push(["journal","array",u.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 h=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY",h.prototype.msg_type=65284,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["id","writeUInt8",1]),h.prototype.fieldSpec.push(["telemetry","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY_LABELS",f.prototype.msg_type=65285,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry_labels",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["id","writeUInt8",1]),f.prototype.fieldSpec.push(["telemetry_labels","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_INS_UPDATES",d.prototype.msg_type=65286,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("tow").uint8("gnsspos").uint8("gnssvel").uint8("wheelticks").uint8("speed").uint8("nhc").uint8("zerovel"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["gnsspos","writeUInt8",1]),d.prototype.fieldSpec.push(["gnssvel","writeUInt8",1]),d.prototype.fieldSpec.push(["wheelticks","writeUInt8",1]),d.prototype.fieldSpec.push(["speed","writeUInt8",1]),d.prototype.fieldSpec.push(["nhc","writeUInt8",1]),d.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:u,65533:c,MsgStatusJournal:c,65283:y,MsgInsStatus:y,65284:h,MsgCsacTelemetry:h,65285:f,MsgCsacTelemetryLabels:f,65286:d,MsgInsUpdates:d,65287:_,MsgGnssTimeOffset:_,65288:S,MsgPpsTime:S,65289:g,MsgSensorAidEvent:g,65290:w,MsgGroupMeta:w}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,u=(p(0).GPSTimeSec,p(0).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});(u.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",u.prototype.msg_type=33,u.prototype.constructor=u,u.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"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),u.prototype.fieldSpec.push(["tot",a.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",s.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 c=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP",c.prototype.msg_type=17,c.prototype.constructor=c,c.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"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),c.prototype.fieldSpec.push(["tot",l.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",n.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 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 h=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE",h.prototype.msg_type=65,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("states",{type:y.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["states","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let f=function(e,t){return r.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MeasurementState",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").nest("mesid",{type:s.prototype.parser}).uint8("cn0"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["mesid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["cn0","writeUInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_MEASUREMENT_STATE",d.prototype.msg_type=97,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("states",{type:f.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["states","array",f.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:u,MsgTrackingStateDetailedDepA:u,17:c,MsgTrackingStateDetailedDep:c,TrackingChannelState:y,65:h,MsgTrackingState:h,MeasurementState:f,97:d,MsgMeasurementState:d,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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}}]); \ No newline at end of file +function r(e,t){if(e===t)return 0;for(var p=e.length,r=t.length,o=0,i=Math.min(p,r);o=0;l--)if(c[l]!==u[l])return!1;for(l=c.length-1;l>=0;l--)if(a=c[l],!g(e[a],t[a],p,r))return!1;return!0}(e,t,p,s))}return p?e===t:e==t}function w(e){return"[object Arguments]"==Object.prototype.toString.call(e)}function E(e,t){if(!e||!t)return!1;if("[object RegExp]"==Object.prototype.toString.call(t))return t.test(e);try{if(e instanceof t)return!0}catch(e){}return!Error.isPrototypeOf(t)&&!0===t.call({},e)}function m(e,t,p,r){var o;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof p&&(r=p,p=null),o=function(e){var t;try{e()}catch(e){t=e}return t}(t),r=(p&&p.name?" ("+p.name+").":".")+(r?" "+r:"."),e&&!o&&_(o,p,"Missing expected exception"+r);var s="string"==typeof r,n=!e&&o&&!p;if((!e&&i.isError(o)&&s&&E(o,p)||n)&&_(o,p,"Got unwanted exception"+r),e&&o&&p&&!E(o,p)||!e&&o)throw o}u.AssertionError=function(e){this.name="AssertionError",this.actual=e.actual,this.expected=e.expected,this.operator=e.operator,e.message?(this.message=e.message,this.generatedMessage=!1):(this.message=function(e){return f(d(e.actual),128)+" "+e.operator+" "+f(d(e.expected),128)}(this),this.generatedMessage=!0);var t=e.stackStartFunction||_;if(Error.captureStackTrace)Error.captureStackTrace(this,t);else{var p=new Error;if(p.stack){var r=p.stack,o=h(t),i=r.indexOf("\n"+o);if(i>=0){var s=r.indexOf("\n",i+1);r=r.substring(s+1)}this.stack=r}}},i.inherits(u.AssertionError,Error),u.fail=_,u.ok=S,u.equal=function(e,t,p){e!=t&&_(e,t,p,"==",u.equal)},u.notEqual=function(e,t,p){e==t&&_(e,t,p,"!=",u.notEqual)},u.deepEqual=function(e,t,p){g(e,t,!1)||_(e,t,p,"deepEqual",u.deepEqual)},u.deepStrictEqual=function(e,t,p){g(e,t,!0)||_(e,t,p,"deepStrictEqual",u.deepStrictEqual)},u.notDeepEqual=function(e,t,p){g(e,t,!1)&&_(e,t,p,"notDeepEqual",u.notDeepEqual)},u.notDeepStrictEqual=function e(t,p,r){g(t,p,!0)&&_(t,p,r,"notDeepStrictEqual",e)},u.strictEqual=function(e,t,p){e!==t&&_(e,t,p,"===",u.strictEqual)},u.notStrictEqual=function(e,t,p){e===t&&_(e,t,p,"!==",u.notStrictEqual)},u.throws=function(e,t,p){m(!0,e,t,p)},u.doesNotThrow=function(e,t,p){m(!1,e,t,p)},u.ifError=function(e){if(e)throw e};var b=Object.keys||function(e){var t=[];for(var p in e)s.call(e,p)&&t.push(p);return t}}).call(this,p(5))},function(e,t,p){var r;!function(p){o(Math.pow(36,5)),o(Math.pow(16,7)),o(Math.pow(10,9)),o(Math.pow(2,30)),o(36),o(16),o(10),o(2);function o(e,t){return this instanceof o?(this._low=0,this._high=0,this.remainder=null,void 0===t?s.call(this,e):"string"==typeof e?n.call(this,e,t):void i.call(this,e,t)):new o(e,t)}function i(e,t){return this._low=0|e,this._high=0|t,this}function s(e){return this._low=65535&e,this._high=e>>>16,this}function n(e,t){var p=parseInt(e,t||10);return this._low=65535&p,this._high=p>>>16,this}o.prototype.fromBits=i,o.prototype.fromNumber=s,o.prototype.fromString=n,o.prototype.toNumber=function(){return 65536*this._high+this._low},o.prototype.toString=function(e){return this.toNumber().toString(e||10)},o.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},o.prototype.subtract=function(e){return this.add(e.clone().negate())},o.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},o.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 o(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 o(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},o.prototype.equals=o.prototype.eq=function(e){return this._low==e._low&&this._high==e._high},o.prototype.greaterThan=o.prototype.gt=function(e){return this._high>e._high||!(this._highe._low},o.prototype.lessThan=o.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},o.prototype.shiftLeft=o.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},o.prototype.rotateRight=o.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},o.prototype.clone=function(){return new o(this._low,this._high)},void 0===(r=function(){return o}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){var r;!function(p){var o={16:s(Math.pow(16,5)),10:s(Math.pow(10,5)),2:s(Math.pow(2,5))},i={16:s(16),10:s(10),2:s(2)};function s(e,t,p,r){return this instanceof s?(this.remainder=null,"string"==typeof e?l.call(this,e,t):void 0===t?a.call(this,e):void n.apply(this,arguments)):new s(e,t,p,r)}function n(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 a(e){return this._a00=65535&e,this._a16=e>>>16,this._a32=0,this._a48=0,this}function l(e,t){t=t||10,this._a00=0,this._a16=0,this._a32=0,this._a48=0;for(var p=o[t]||new s(Math.pow(t,5)),r=0,i=e.length;r=0&&(p.div(t),r[o]=p.remainder.toNumber().toString(e),p.gt(t));o--);return r[o-1]=p.toNumber().toString(e),r.join("")},s.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},s.prototype.subtract=function(e){return this.add(e.clone().negate())},s.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},s.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 s(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 s(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},s.prototype.equals=s.prototype.eq=function(e){return this._a48==e._a48&&this._a00==e._a00&&this._a32==e._a32&&this._a16==e._a16},s.prototype.greaterThan=s.prototype.gt=function(e){return this._a48>e._a48||!(this._a48e._a32||!(this._a32e._a16||!(this._a16e._a00))},s.prototype.lessThan=s.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},s.prototype.shiftLeft=s.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},s.prototype.rotateRight=s.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},s.prototype.clone=function(){return new s(this._a00,this._a16,this._a32,this._a48)},void 0===(r=function(){return s}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=(p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE",h.prototype.msg_type=46,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:u.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["acq_sv_profile","array",u.prototype.fieldSpec,function(){return this.fields.array.length},null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_ACQ_SV_PROFILE_DEP",f.prototype.msg_type=30,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:y.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.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:h,MsgAcqSvProfile:h,30:f,MsgAcqSvProfileDep:f}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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").array("contents",{type:"uint8",readUntil:"eof"}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),a.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},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 h=function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_FILEIO_CONFIG_RESP",h.prototype.msg_type=4098,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("window_size").uint32("batch_size").uint32("fileio_version"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),h.prototype.fieldSpec.push(["window_size","writeUInt32LE",4]),h.prototype.fieldSpec.push(["batch_size","writeUInt32LE",4]),h.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:h,MsgFileioConfigResp:h}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_STM_UNIQUE_ID_RESP",h.prototype.msg_type=229,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("stm_id",{length:12,type:"uint8"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["stm_id","array","writeUInt8",function(){return 1},12]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_M25_FLASH_WRITE_STATUS",f.prototype.msg_type=243,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("status",{length:1,type:"uint8"}),f.prototype.fieldSpec=[],f.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:h,MsgStmUniqueIdResp:h,243:f,MsgM25FlashWriteStatus:f}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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]),e.exports={2304:i,MsgImuRaw:i,2305:s,MsgImuAux:s}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal,p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),s=p(0).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").array("reserved",{length:6,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(["reserved","array","writeUInt8",function(){return 1},6]),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 h=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};(h.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",h.prototype.msg_type=3025,h.prototype.constructor=h,h.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"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),h.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),h.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),h.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]),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:h,MsgSsrFlagIonoGridPointSatLos:h}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_CPU_STATE",h.prototype.msg_type=32520,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["index","writeUInt8",1]),h.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),h.prototype.fieldSpec.push(["time","writeUInt32LE",4]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["tname","string",15]),h.prototype.fieldSpec.push(["cmdline","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_MEM_STATE",f.prototype.msg_type=32521,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").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(["pmem","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_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_LINUX_SYS_STATE",d.prototype.msg_type=32522,d.prototype.constructor=d,d.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"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),d.prototype.fieldSpec.push(["pmem","writeUInt8",1]),d.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),d.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]),d.prototype.fieldSpec.push(["time","writeUInt32LE",4]),d.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:h,MsgLinuxCpuState:h,32521:f,MsgLinuxMemState:f,32522:d,MsgLinuxSysState:d}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_COV",h.prototype.msg_type=529,h.prototype.constructor=h,h.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"),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(["cov_n_n","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="EstimatedHorizontalErrorEllipse",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").floatle("semi_major").floatle("semi_minor").floatle("orientation"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["semi_major","writeFloatLE",4]),f.prototype.fieldSpec.push(["semi_minor","writeFloatLE",4]),f.prototype.fieldSpec.push(["orientation","writeFloatLE",4]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_ACC",d.prototype.msg_type=536,d.prototype.constructor=d,d.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:f.prototype.parser}).uint8("confidence_and_geoid").uint8("n_sats").uint8("flags"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),d.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),d.prototype.fieldSpec.push(["height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["orthometric_height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["h_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["v_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["ct_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["at_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["h_ellipse",f.prototype.fieldSpec]),d.prototype.fieldSpec.push(["confidence_and_geoid","writeUInt8",1]),d.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),d.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 M=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_GNSS",M.prototype.msg_type=558,M.prototype.constructor=M,M.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"),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(["h_accuracy","writeUInt16LE",2]),M.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),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_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_VEL_NED_COV_GNSS",D.prototype.msg_type=562,D.prototype.constructor=D,D.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"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),D.prototype.fieldSpec.push(["n","writeInt32LE",4]),D.prototype.fieldSpec.push(["e","writeInt32LE",4]),D.prototype.fieldSpec.push(["d","writeInt32LE",4]),D.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),D.prototype.fieldSpec.push(["flags","writeUInt8",1]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_VEL_BODY",O.prototype.msg_type=531,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),O.prototype.fieldSpec.push(["x","writeInt32LE",4]),O.prototype.fieldSpec.push(["y","writeInt32LE",4]),O.prototype.fieldSpec.push(["z","writeInt32LE",4]),O.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),O.prototype.fieldSpec.push(["flags","writeUInt8",1]);let G=function(e,t){return r.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_VEL_COG",G.prototype.msg_type=540,G.prototype.constructor=G,G.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"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),G.prototype.fieldSpec.push(["cog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up","writeInt32LE",4]),G.prototype.fieldSpec.push(["cog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["flags","writeUInt16LE",2]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_AGE_CORRECTIONS",A.prototype.msg_type=528,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint32("tow").uint16("age"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),A.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 R=function(e,t){return r.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_DOPS_DEP_A",R.prototype.msg_type=518,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),R.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),R.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 N=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_DEP_A",N.prototype.msg_type=513,N.prototype.constructor=N,N.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"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),N.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),N.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),N.prototype.fieldSpec.push(["height","writeDoubleLE",8]),N.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),N.prototype.fieldSpec.push(["flags","writeUInt8",1]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_BASELINE_ECEF_DEP_A",j.prototype.msg_type=514,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),j.prototype.fieldSpec.push(["x","writeInt32LE",4]),j.prototype.fieldSpec.push(["y","writeInt32LE",4]),j.prototype.fieldSpec.push(["z","writeInt32LE",4]),j.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),j.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),j.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 H=function(e,t){return r.call(this,e),this.messageType="MSG_UTC_LEAP_SECOND",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_UTC_LEAP_SECOND",H.prototype.msg_type=570,H.prototype.constructor=H,H.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"),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["reserved_0","writeInt16LE",2]),H.prototype.fieldSpec.push(["reserved_1","writeInt16LE",2]),H.prototype.fieldSpec.push(["reserved_2","writeInt8",1]),H.prototype.fieldSpec.push(["count_before","writeInt8",1]),H.prototype.fieldSpec.push(["reserved_3","writeUInt16LE",2]),H.prototype.fieldSpec.push(["reserved_4","writeUInt16LE",2]),H.prototype.fieldSpec.push(["ref_wn","writeUInt16LE",2]),H.prototype.fieldSpec.push(["ref_dn","writeUInt8",1]),H.prototype.fieldSpec.push(["count_after","writeInt8",1]);let V=function(e,t){return r.call(this,e),this.messageType="MSG_REFERENCE_FRAME_PARAM",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="MSG_REFERENCE_FRAME_PARAM",V.prototype.msg_type=580,V.prototype.constructor=V,V.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"),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),V.prototype.fieldSpec.push(["sn","string",32]),V.prototype.fieldSpec.push(["tn","string",32]),V.prototype.fieldSpec.push(["sin","writeUInt8",1]),V.prototype.fieldSpec.push(["utn","writeUInt16LE",2]),V.prototype.fieldSpec.push(["re_t0","writeUInt16LE",2]),V.prototype.fieldSpec.push(["delta_X0","writeInt32LE",4]),V.prototype.fieldSpec.push(["delta_Y0","writeInt32LE",4]),V.prototype.fieldSpec.push(["delta_Z0","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_01","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_02","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_03","writeInt32LE",4]),V.prototype.fieldSpec.push(["scale","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_X0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_Y0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_Z0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_01","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_02","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_03","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_scale","writeInt16LE",2]);let Y=function(e,t){return r.call(this,e),this.messageType="MSG_POSE_RELATIVE",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(r.prototype)).messageType="MSG_POSE_RELATIVE",Y.prototype.msg_type=581,Y.prototype.constructor=Y,Y.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"),Y.prototype.fieldSpec=[],Y.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),Y.prototype.fieldSpec.push(["sensor_id","writeUInt8",1]),Y.prototype.fieldSpec.push(["timestamp_1","writeUInt32LE",4]),Y.prototype.fieldSpec.push(["timestamp_2","writeUInt32LE",4]),Y.prototype.fieldSpec.push(["trans","array","writeInt32LE",function(){return 4},3]),Y.prototype.fieldSpec.push(["w","writeInt32LE",4]),Y.prototype.fieldSpec.push(["x","writeInt32LE",4]),Y.prototype.fieldSpec.push(["y","writeInt32LE",4]),Y.prototype.fieldSpec.push(["z","writeInt32LE",4]),Y.prototype.fieldSpec.push(["cov_r_x_x","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_r_x_y","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_r_x_z","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_r_y_y","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_r_y_z","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_r_z_z","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_c_x_x","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_c_x_y","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_c_x_z","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_c_y_y","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_c_y_z","writeFloatLE",4]),Y.prototype.fieldSpec.push(["cov_c_z_z","writeFloatLE",4]),Y.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:h,MsgPosLlhCov:h,EstimatedHorizontalErrorEllipse:f,536:d,MsgPosLlhAcc:d,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:M,MsgVelNedGnss:M,562:D,MsgVelNedCovGnss:D,531:O,MsgVelBody:O,540:G,MsgVelCog:G,528:A,MsgAgeCorrections:A,256:C,MsgGpsTimeDepA:C,518:R,MsgDopsDepA:R,512:P,MsgPosEcefDepA:P,513:N,MsgPosLlhDepA:N,514:j,MsgBaselineEcefDepA:j,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:H,MsgUtcLeapSecond:H,580:V,MsgReferenceFrameParam:V,581:Y,MsgPoseRelative:Y}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,c=p(0).GPSTimeSec,u=(p(0).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 h=function(e,t){return r.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="PackedObsContent",h.prototype.constructor=h,h.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}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["P","writeUInt32LE",4]),h.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),h.prototype.fieldSpec.push(["D",y.prototype.fieldSpec]),h.prototype.fieldSpec.push(["cn0","writeUInt8",1]),h.prototype.fieldSpec.push(["lock","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);let f=function(e,t){return r.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="PackedOsrContent",f.prototype.constructor=f,f.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"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["P","writeUInt32LE",4]),f.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),f.prototype.fieldSpec.push(["lock","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["iono_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["tropo_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["range_std","writeUInt16LE",2]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_OBS",d.prototype.msg_type=74,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:h.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),d.prototype.fieldSpec.push(["obs","array",h.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 M=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_A",M.prototype.msg_type=130,M.prototype.constructor=M,M.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"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),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]),M.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),M.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_A",D.prototype.msg_type=131,D.prototype.constructor=D,D.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"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),D.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),D.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),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]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_B",O.prototype.msg_type=132,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["common",w.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 G=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_SBAS",G.prototype.msg_type=140,G.prototype.constructor=G,G.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"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),G.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["vel","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["a_gf0","writeFloatLE",4]),G.prototype.fieldSpec.push(["a_gf1","writeFloatLE",4]);let A=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_B",A.prototype.msg_type=133,A.prototype.constructor=A,A.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"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),A.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),A.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),A.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),A.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 R=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_D",R.prototype.msg_type=136,R.prototype.constructor=R,R.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"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),R.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),R.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["fcn","writeUInt8",1]),R.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 N=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_D",N.prototype.msg_type=128,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").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),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(["sid",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["iode","writeUInt8",1]),N.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),N.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_DEP_A",j.prototype.msg_type=26,j.prototype.constructor=j,j.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"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),j.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),j.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["w","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["valid","writeUInt8",1]),j.prototype.fieldSpec.push(["healthy","writeUInt8",1]),j.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 H=function(e,t){return r.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="PackedObsContentDepC",H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["P","writeUInt32LE",4]),H.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),H.prototype.fieldSpec.push(["cn0","writeUInt8",1]),H.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),H.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);let V=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_A",V.prototype.msg_type=69,V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),V.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);let Y=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(r.prototype)).messageType="MSG_OBS_DEP_B",Y.prototype.msg_type=67,Y.prototype.constructor=Y,Y.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:z.prototype.parser,readUntil:"eof"}),Y.prototype.fieldSpec=[],Y.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),Y.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:H.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",H.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 J=function(e,t){return r.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(r.prototype)).messageType="MSG_GNSS_CAPB",J.prototype.msg_type=150,J.prototype.constructor=J,J.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).nest("gc",{type:X.prototype.parser}),J.prototype.fieldSpec=[],J.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),J.prototype.fieldSpec.push(["gc",X.prototype.fieldSpec]);let Z=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",Z.prototype.msg_type=146,Z.prototype.constructor=Z,Z.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"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["prn","writeUInt8",1]),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 $=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",$.prototype.msg_type=147,$.prototype.constructor=$,$.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"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),$.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),$.prototype.fieldSpec.push(["valid","writeUInt8",1]),$.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),$.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:f.prototype.parser,readUntil:"eof"}),ce.prototype.fieldSpec=[],ce.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),ce.prototype.fieldSpec.push(["obs","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={ObservationHeader:u,Doppler:y,PackedObsContent:h,PackedOsrContent:f,74:d,MsgObs:d,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:M,MsgEphemerisSbasDepA:M,131:D,MsgEphemerisGloDepA:D,132:O,MsgEphemerisSbasDepB:O,140:G,MsgEphemerisSbas:G,133:A,MsgEphemerisGloDepB:A,135:C,MsgEphemerisGloDepC:C,136:R,MsgEphemerisGloDepD:R,139:P,MsgEphemerisGlo:P,128:N,MsgEphemerisDepD:N,26:j,MsgEphemerisDepA:j,70:x,MsgEphemerisDepB:x,71:F,MsgEphemerisDepC:F,ObservationHeaderDep:k,CarrierPhaseDepA:B,PackedObsContentDepA:q,PackedObsContentDepB:z,PackedObsContentDepC:H,69:V,MsgObsDepA:V,67:Y,MsgObsDepB:Y,73:W,MsgObsDepC:W,144:Q,MsgIono:Q,145:K,MsgSvConfigurationGpsDep:K,GnssCapb:X,150:J,MsgGnssCapb:J,146:Z,MsgGroupDelayDepA:Z,147:$,MsgGroupDelayDepB:$,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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=p(0).GPSTime,a=p(0).GPSTimeDep,l=(p(0).GPSTimeSec,p(0).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_CW_RESULTS",h.prototype.msg_type=192,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little"),h.prototype.fieldSpec=[];let f=function(e,t){return r.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CW_START",f.prototype.msg_type=193,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_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_RESET_FILTERS",d.prototype.msg_type=34,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("filter"),d.prototype.fieldSpec=[],d.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 M=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_RESP",M.prototype.msg_type=185,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("sequence").int32("code"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),M.prototype.fieldSpec.push(["code","writeInt32LE",4]);let D=function(e,t){return r.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_COMMAND_OUTPUT",D.prototype.msg_type=188,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("sequence").string("line",{greedy:!0}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),D.prototype.fieldSpec.push(["line","string",null]);let O=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_REQ",O.prototype.msg_type=186,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little"),O.prototype.fieldSpec=[];let G=function(e,t){return r.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="MSG_NETWORK_STATE_RESP",G.prototype.msg_type=187,G.prototype.constructor=G,G.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"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["ipv4_address","array","writeUInt8",function(){return 1},4]),G.prototype.fieldSpec.push(["ipv4_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["ipv6_address","array","writeUInt8",function(){return 1},16]),G.prototype.fieldSpec.push(["ipv6_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["interface_name","string",16]),G.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);let A=function(e,t){return r.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="NetworkUsage",A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint64("duration").uint64("total_bytes").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["duration","writeUInt64LE",8]),A.prototype.fieldSpec.push(["total_bytes","writeUInt64LE",8]),A.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),A.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:A.prototype.parser,readUntil:"eof"}),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["interfaces","array",A.prototype.fieldSpec,function(){return this.fields.array.length},null]);let R=function(e,t){return r.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_CELL_MODEM_STATUS",R.prototype.msg_type=190,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").int8("signal_strength").floatle("signal_error_rate").array("reserved",{type:"uint8",readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["signal_strength","writeInt8",1]),R.prototype.fieldSpec.push(["signal_error_rate","writeFloatLE",4]),R.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 N=function(e,t){return r.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SPECAN",N.prototype.msg_type=81,N.prototype.constructor=N,N.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"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),N.prototype.fieldSpec.push(["t",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);let j=function(e,t){return r.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_FRONT_END_GAIN",j.prototype.msg_type=191,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").array("rf_gain",{length:8,type:"int8"}).array("if_gain",{length:8,type:"int8"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["rf_gain","array","writeInt8",function(){return 1},8]),j.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:h,MsgCwResults:h,193:f,MsgCwStart:f,34:d,MsgResetFilters:d,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:M,MsgCommandResp:M,188:D,MsgCommandOutput:D,186:O,MsgNetworkStateReq:O,187:G,MsgNetworkStateResp:G,NetworkUsage:A,189:C,MsgNetworkBandwidthUsage:C,190:R,MsgCellModemStatus:R,80:P,MsgSpecanDep:P,81:N,MsgSpecan:N,191:j,MsgFrontEndGain:j}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER",h.prototype.msg_type=174,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["setting","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_SETTINGS_REGISTER_RESP",f.prototype.msg_type=431,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["status","writeUInt8",1]),f.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:h,MsgSettingsRegister:h,431:f,MsgSettingsRegisterResp:f}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal,p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE_DEP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE_DEP",i.prototype.msg_type=3073,i.prototype.constructor=i,i.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"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),i.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),i.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]);let s=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_CERTIFICATE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_CERTIFICATE",s.prototype.msg_type=3074,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("n_msg").array("fingerprint",{length:20,type:"uint8"}).array("certificate_bytes",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["n_msg","writeUInt8",1]),s.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),s.prototype.fieldSpec.push(["certificate_bytes","array","writeUInt8",function(){return 1},null]);let n=function(e,t){return r.call(this,e),this.messageType="MSG_ED25519_SIGNATURE",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="MSG_ED25519_SIGNATURE",n.prototype.msg_type=3075,n.prototype.constructor=n,n.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"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["stream_counter","writeUInt8",1]),n.prototype.fieldSpec.push(["on_demand_counter","writeUInt8",1]),n.prototype.fieldSpec.push(["signature","array","writeUInt8",function(){return 1},64]),n.prototype.fieldSpec.push(["fingerprint","array","writeUInt8",function(){return 1},20]),n.prototype.fieldSpec.push(["signed_messages","array","writeUInt32LE",function(){return 4},null]),e.exports={3073:i,MsgEd25519SignatureDep:i,3074:s,MsgEd25519Certificate:s,3075:n,MsgEd25519Signature:n}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),n=p(0).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 h=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrectionNoStd",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),h.prototype.fieldSpec.push(["wet","writeInt8",1]);let f=function(e,t){return r.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="TroposphericDelayCorrection",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet").uint8("stddev"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),f.prototype.fieldSpec.push(["wet","writeInt8",1]),f.prototype.fieldSpec.push(["stddev","writeUInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="STECResidualNoStd",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),d.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:f.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",f.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:f.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",f.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",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP",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",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION",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 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",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC",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 O=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};(O.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",O.prototype.msg_type=1500,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),O.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),O.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),O.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),O.prototype.fieldSpec.push(["iod","writeUInt8",1]),O.prototype.fieldSpec.push(["radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["along","writeInt32LE",4]),O.prototype.fieldSpec.push(["cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["c0","writeInt32LE",4]),O.prototype.fieldSpec.push(["c1","writeInt32LE",4]),O.prototype.fieldSpec.push(["c2","writeInt32LE",4]);let G=function(e,t){return r.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="STECHeaderDepA",G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),G.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),G.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),G.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),G.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);let A=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeaderDepA",A.prototype.constructor=A,A.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"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),A.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),A.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),A.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),A.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),A.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);let C=function(e,t){return r.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="GridDefinitionHeaderDepA",C.prototype.constructor=C,C.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"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),C.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),C.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:G.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["header",G.prototype.fieldSpec]),R.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let P=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};(P.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",P.prototype.msg_type=1520,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:h.prototype.parser}).array("stec_residuals",{type:d.prototype.parser,readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["header",A.prototype.fieldSpec]),P.prototype.fieldSpec.push(["index","writeUInt16LE",2]),P.prototype.fieldSpec.push(["tropo_delay_correction",h.prototype.fieldSpec]),P.prototype.fieldSpec.push(["stec_residuals","array",d.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_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",N.prototype.msg_type=1530,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["header",A.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",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);let j=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};(j.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",j.prototype.msg_type=1525,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("header",{type:C.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["header",C.prototype.fieldSpec]),j.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]);let x=function(e,t){return r.call(this,e),this.messageType="OrbitClockBound",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="OrbitClockBound",x.prototype.constructor=x,x.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"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_sig","writeUInt8",1]);let F=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",F.prototype.msg_type=1502,F.prototype.constructor=F,F.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:x.prototype.parser,length:"n_sats"}),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),F.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),F.prototype.fieldSpec.push(["const_id","writeUInt8",1]),F.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),F.prototype.fieldSpec.push(["orbit_clock_bounds","array",x.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);let k=function(e,t){return r.call(this,e),this.messageType="CodePhaseBiasesSatSig",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="CodePhaseBiasesSatSig",k.prototype.constructor=k,k.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"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),k.prototype.fieldSpec.push(["signal_id","writeUInt8",1]),k.prototype.fieldSpec.push(["code_bias_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["code_bias_bound_sig","writeUInt8",1]),k.prototype.fieldSpec.push(["phase_bias_bound_mu","writeUInt8",1]),k.prototype.fieldSpec.push(["phase_bias_bound_sig","writeUInt8",1]);let B=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};(B.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",B.prototype.msg_type=1516,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_signals").array("satellites_signals",{type:k.prototype.parser,length:"n_sats_signals"}),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_signals","writeUInt8",1]),B.prototype.fieldSpec.push(["satellites_signals","array",k.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats_signals"]);let q=function(e,t){return r.call(this,e),this.messageType="OrbitClockBoundDegradation",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="OrbitClockBoundDegradation",q.prototype.constructor=q,q.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"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["orb_radial_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_radial_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_sig_dot","writeUInt8",1]);let z=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};(z.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",z.prototype.msg_type=1503,z.prototype.constructor=z,z.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:q.prototype.parser}),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(["sat_bitmask","writeUInt64LE",8]),z.prototype.fieldSpec.push(["orbit_clock_bounds_degradation",q.prototype.fieldSpec]),e.exports={CodeBiasesContent:a,PhaseBiasesContent:l,STECHeader:c,GriddedCorrectionHeader:u,STECSatElement:y,TroposphericDelayCorrectionNoStd:h,TroposphericDelayCorrection:f,STECResidualNoStd:d,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,MsgSsrTileDefinitionDep:v,1527:U,MsgSsrTileDefinition:U,SatelliteAPC:M,1540:D,MsgSsrSatelliteApc:D,1500:O,MsgSsrOrbitClockDepA:O,STECHeaderDepA:G,GriddedCorrectionHeaderDepA:A,GridDefinitionHeaderDepA:C,1515:R,MsgSsrStecCorrectionDepA:R,1520:P,MsgSsrGriddedCorrectionNoStdDepA:P,1530:N,MsgSsrGriddedCorrectionDepA:N,1525:j,MsgSsrGridDefinitionDepA:j,OrbitClockBound:x,1502:F,MsgSsrOrbitClockBounds:F,CodePhaseBiasesSatSig:k,1516:B,MsgSsrCodePhaseBiasesBounds:B,OrbitClockBoundDegradation:q,1503:z,MsgSsrOrbitClockBoundsDegradation:z}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY",h.prototype.msg_type=65284,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["id","writeUInt8",1]),h.prototype.fieldSpec.push(["telemetry","string",null]);let f=function(e,t){return r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MSG_CSAC_TELEMETRY_LABELS",f.prototype.msg_type=65285,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry_labels",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["id","writeUInt8",1]),f.prototype.fieldSpec.push(["telemetry_labels","string",null]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_INS_UPDATES",d.prototype.msg_type=65286,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("tow").uint8("gnsspos").uint8("gnssvel").uint8("wheelticks").uint8("speed").uint8("nhc").uint8("zerovel"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["gnsspos","writeUInt8",1]),d.prototype.fieldSpec.push(["gnssvel","writeUInt8",1]),d.prototype.fieldSpec.push(["wheelticks","writeUInt8",1]),d.prototype.fieldSpec.push(["speed","writeUInt8",1]),d.prototype.fieldSpec.push(["nhc","writeUInt8",1]),d.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:h,MsgCsacTelemetry:h,65285:f,MsgCsacTelemetryLabels:f,65286:d,MsgInsUpdates:d,65287:_,MsgGnssTimeOffset:_,65288:S,MsgPpsTime:S,65289:g,MsgSensorAidEvent:g,65290:w,MsgGroupMeta:w}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,c=(p(0).GPSTimeSec,p(0).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 h=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE",h.prototype.msg_type=65,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("states",{type:y.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["states","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);let f=function(e,t){return r.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.prototype)).messageType="MeasurementState",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").nest("mesid",{type:s.prototype.parser}).uint8("cn0"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["mesid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["cn0","writeUInt8",1]);let d=function(e,t){return r.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.prototype)).messageType="MSG_MEASUREMENT_STATE",d.prototype.msg_type=97,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("states",{type:f.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["states","array",f.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:h,MsgTrackingState:h,MeasurementState:f,97:d,MsgMeasurementState:d,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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}},function(e,t,p){let r=p(2),o=p(4),i=(p(3),p(1).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}}]); \ No newline at end of file diff --git a/javascript/sbp/navigation.js b/javascript/sbp/navigation.js index 061a13aa3c..6834f8ee1b 100644 --- a/javascript/sbp/navigation.js +++ b/javascript/sbp/navigation.js @@ -2268,6 +2268,105 @@ MsgReferenceFrameParam.prototype.fieldSpec.push(['dot_theta_02', 'writeInt32LE', MsgReferenceFrameParam.prototype.fieldSpec.push(['dot_theta_03', 'writeInt32LE', 4]); MsgReferenceFrameParam.prototype.fieldSpec.push(['dot_scale', 'writeInt16LE', 2]); +/** + * SBP class for message MSG_POSE_RELATIVE (0x0245). + * + * This solution message reports the relative pose of a sensor between two time + * instances. The relative pose comprises of a rotation and a translation which + * relates the sensor (e.g. camera) frame at a given time (first keyframe) to the + * sensor frame at another time (second key frame). The relative translations is a + * 3x1 vector described in the first keyframe. Relative rotation is described by a + * quaternion from second keyframe to the first keyframe. + * + * Fields in the SBP payload (`sbp.payload`): + * @field tow number (unsigned 32-bit int, 4 bytes) GPS Time of Week + * @field sensor_id number (unsigned 8-bit int, 1 byte) ID of the sensor producing this message + * @field timestamp_1 number (unsigned 32-bit int, 4 bytes) Timestamp of first keyframe + * @field timestamp_2 number (unsigned 32-bit int, 4 bytes) Timestamp of second keyframe + * @field trans array Relative translation [x,y,z] described in first keyframe + * @field w number (signed 32-bit int, 4 bytes) Real component of quaternion to describe relative rotation (second to first + * keyframe) + * @field x number (signed 32-bit int, 4 bytes) 1st imaginary component of quaternion to describe relative rotation (second to + * first keyframe) + * @field y number (signed 32-bit int, 4 bytes) 2nd imaginary component of quaternion to describe relative rotation (second to + * first keyframe) + * @field z number (signed 32-bit int, 4 bytes) 3rd imaginary component of quaternion to describe relative rotation (second to + * first keyframe) + * @field cov_r_x_x number (float, 4 bytes) Estimated variance of x (relative translation) + * @field cov_r_x_y number (float, 4 bytes) Covariance of x and y (relative translation) + * @field cov_r_x_z number (float, 4 bytes) Covariance of x and z (relative translation) + * @field cov_r_y_y number (float, 4 bytes) Estimated variance of y (relative translation) + * @field cov_r_y_z number (float, 4 bytes) Covariance of y and z (relative translation) + * @field cov_r_z_z number (float, 4 bytes) Estimated variance of z (relative translation) + * @field cov_c_x_x number (float, 4 bytes) Estimated variance of x (relative rotation) + * @field cov_c_x_y number (float, 4 bytes) Covariance of x and y (relative rotation) + * @field cov_c_x_z number (float, 4 bytes) Covariance of x and z (relative rotation) + * @field cov_c_y_y number (float, 4 bytes) Estimated variance of y (relative rotation) + * @field cov_c_y_z number (float, 4 bytes) Covariance of y and z (relative rotation) + * @field cov_c_z_z number (float, 4 bytes) Estimated variance of z (relative rotation) + * @field flags number (unsigned 8-bit int, 1 byte) Status flags of relative translation and rotation + * + * @param sbp An SBP object with a payload to be decoded. + */ +let MsgPoseRelative = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_POSE_RELATIVE"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgPoseRelative.prototype = Object.create(SBP.prototype); +MsgPoseRelative.prototype.messageType = "MSG_POSE_RELATIVE"; +MsgPoseRelative.prototype.msg_type = 0x0245; +MsgPoseRelative.prototype.constructor = MsgPoseRelative; +MsgPoseRelative.prototype.parser = new Parser() + .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'); +MsgPoseRelative.prototype.fieldSpec = []; +MsgPoseRelative.prototype.fieldSpec.push(['tow', 'writeUInt32LE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['sensor_id', 'writeUInt8', 1]); +MsgPoseRelative.prototype.fieldSpec.push(['timestamp_1', 'writeUInt32LE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['timestamp_2', 'writeUInt32LE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['trans', 'array', 'writeInt32LE', function () { return 4; }, 3]); +MsgPoseRelative.prototype.fieldSpec.push(['w', 'writeInt32LE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['x', 'writeInt32LE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['y', 'writeInt32LE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['z', 'writeInt32LE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_r_x_x', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_r_x_y', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_r_x_z', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_r_y_y', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_r_y_z', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_r_z_z', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_c_x_x', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_c_x_y', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_c_x_z', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_c_y_y', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_c_y_z', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['cov_c_z_z', 'writeFloatLE', 4]); +MsgPoseRelative.prototype.fieldSpec.push(['flags', 'writeUInt8', 1]); + module.exports = { 0x0102: MsgGpsTime, MsgGpsTime: MsgGpsTime, @@ -2350,4 +2449,6 @@ module.exports = { MsgUtcLeapSecond: MsgUtcLeapSecond, 0x0244: MsgReferenceFrameParam, MsgReferenceFrameParam: MsgReferenceFrameParam, + 0x0245: MsgPoseRelative, + MsgPoseRelative: MsgPoseRelative, } \ No newline at end of file diff --git a/python/sbp/navigation.py b/python/sbp/navigation.py index e46d527b3e..a8a09d935f 100755 --- a/python/sbp/navigation.py +++ b/python/sbp/navigation.py @@ -5419,6 +5419,210 @@ def to_json_dict(self): d.update(j) return d +SBP_MSG_POSE_RELATIVE = 0x0245 +class MsgPoseRelative(SBP): + """SBP class for message MSG_POSE_RELATIVE (0x0245). + + You can have MSG_POSE_RELATIVE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This solution message reports the relative pose of a sensor between two time + instances. The relative pose comprises of a rotation and a translation which + relates the sensor (e.g. camera) frame at a given time (first keyframe) to + the sensor frame at another time (second key frame). The relative + translations is a 3x1 vector described in the first keyframe. Relative + rotation is described by a quaternion from second keyframe to the first + keyframe. + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + tow : int + GPS Time of Week + sensor_id : int + ID of the sensor producing this message + timestamp_1 : int + Timestamp of first keyframe + timestamp_2 : int + Timestamp of second keyframe + trans : array + Relative translation [x,y,z] described in first keyframe + w : int + Real component of quaternion to describe relative rotation (second to + first keyframe) + x : int + 1st imaginary component of quaternion to describe relative rotation + (second to first keyframe) + y : int + 2nd imaginary component of quaternion to describe relative rotation + (second to first keyframe) + z : int + 3rd imaginary component of quaternion to describe relative rotation + (second to first keyframe) + cov_r_x_x : float + Estimated variance of x (relative translation) + cov_r_x_y : float + Covariance of x and y (relative translation) + cov_r_x_z : float + Covariance of x and z (relative translation) + cov_r_y_y : float + Estimated variance of y (relative translation) + cov_r_y_z : float + Covariance of y and z (relative translation) + cov_r_z_z : float + Estimated variance of z (relative translation) + cov_c_x_x : float + Estimated variance of x (relative rotation) + cov_c_x_y : float + Covariance of x and y (relative rotation) + cov_c_x_z : float + Covariance of x and z (relative rotation) + cov_c_y_y : float + Estimated variance of y (relative rotation) + cov_c_y_z : float + Covariance of y and z (relative rotation) + cov_c_z_z : float + Estimated variance of z (relative rotation) + flags : int + Status flags of relative translation and rotation + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'tow' / construct.Int32ul, + 'sensor_id' / construct.Int8ul, + 'timestamp_1' / construct.Int32ul, + 'timestamp_2' / construct.Int32ul, + 'trans' / construct.Array(3, construct.Int32sl), + 'w' / construct.Int32sl, + 'x' / construct.Int32sl, + 'y' / construct.Int32sl, + 'z' / construct.Int32sl, + 'cov_r_x_x' / construct.Float32l, + 'cov_r_x_y' / construct.Float32l, + 'cov_r_x_z' / construct.Float32l, + 'cov_r_y_y' / construct.Float32l, + 'cov_r_y_z' / construct.Float32l, + 'cov_r_z_z' / construct.Float32l, + 'cov_c_x_x' / construct.Float32l, + 'cov_c_x_y' / construct.Float32l, + 'cov_c_x_z' / construct.Float32l, + 'cov_c_y_y' / construct.Float32l, + 'cov_c_y_z' / construct.Float32l, + 'cov_c_z_z' / construct.Float32l, + 'flags' / construct.Int8ul,) + __slots__ = [ + 'tow', + 'sensor_id', + 'timestamp_1', + 'timestamp_2', + 'trans', + 'w', + 'x', + 'y', + 'z', + 'cov_r_x_x', + 'cov_r_x_y', + 'cov_r_x_z', + 'cov_r_y_y', + 'cov_r_y_z', + 'cov_r_z_z', + 'cov_c_x_x', + 'cov_c_x_y', + 'cov_c_x_z', + 'cov_c_y_y', + 'cov_c_y_z', + 'cov_c_z_z', + 'flags', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgPoseRelative, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgPoseRelative, self).__init__() + self.msg_type = SBP_MSG_POSE_RELATIVE + self.sender = kwargs.pop('sender', SENDER_ID) + self.tow = kwargs.pop('tow') + self.sensor_id = kwargs.pop('sensor_id') + self.timestamp_1 = kwargs.pop('timestamp_1') + self.timestamp_2 = kwargs.pop('timestamp_2') + self.trans = kwargs.pop('trans') + self.w = kwargs.pop('w') + self.x = kwargs.pop('x') + self.y = kwargs.pop('y') + self.z = kwargs.pop('z') + self.cov_r_x_x = kwargs.pop('cov_r_x_x') + self.cov_r_x_y = kwargs.pop('cov_r_x_y') + self.cov_r_x_z = kwargs.pop('cov_r_x_z') + self.cov_r_y_y = kwargs.pop('cov_r_y_y') + self.cov_r_y_z = kwargs.pop('cov_r_y_z') + self.cov_r_z_z = kwargs.pop('cov_r_z_z') + self.cov_c_x_x = kwargs.pop('cov_c_x_x') + self.cov_c_x_y = kwargs.pop('cov_c_x_y') + self.cov_c_x_z = kwargs.pop('cov_c_x_z') + self.cov_c_y_y = kwargs.pop('cov_c_y_y') + self.cov_c_y_z = kwargs.pop('cov_c_y_z') + self.cov_c_z_z = kwargs.pop('cov_c_z_z') + self.flags = kwargs.pop('flags') + + 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 MsgPoseRelative.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgPoseRelative(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgPoseRelative._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 = MsgPoseRelative._parser.build(c) + return self.pack() + + 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 = MsgPoseRelative._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( MsgPoseRelative, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + msg_classes = { 0x0102: MsgGPSTime, @@ -5461,4 +5665,5 @@ def to_json_dict(self): 0x0217: MsgProtectionLevel, 0x023A: MsgUtcLeapSecond, 0x0244: MsgReferenceFrameParam, + 0x0245: MsgPoseRelative, } \ No newline at end of file diff --git a/rust/sbp/src/messages/mod.rs b/rust/sbp/src/messages/mod.rs index c4c32e0b97..bd511a2be7 100644 --- a/rust/sbp/src/messages/mod.rs +++ b/rust/sbp/src/messages/mod.rs @@ -111,6 +111,7 @@ use self::navigation::msg_pos_llh_cov::MsgPosLlhCov; use self::navigation::msg_pos_llh_cov_gnss::MsgPosLlhCovGnss; use self::navigation::msg_pos_llh_dep_a::MsgPosLlhDepA; use self::navigation::msg_pos_llh_gnss::MsgPosLlhGnss; +use self::navigation::msg_pose_relative::MsgPoseRelative; use self::navigation::msg_protection_level::MsgProtectionLevel; use self::navigation::msg_protection_level_dep_a::MsgProtectionLevelDepA; use self::navigation::msg_reference_frame_param::MsgReferenceFrameParam; @@ -662,6 +663,8 @@ pub enum Sbp { MsgUtcLeapSecond(MsgUtcLeapSecond), /// Reference Frame Transformation Parameters MsgReferenceFrameParam(MsgReferenceFrameParam), + /// Relative Pose + MsgPoseRelative(MsgPoseRelative), /// Navigation DataBase Event MsgNdbEvent(MsgNdbEvent), /// Plaintext logging messages with levels @@ -1294,6 +1297,9 @@ impl<'de> serde::Deserialize<'de> for Sbp { serde_json::from_value::(value) .map(Sbp::MsgReferenceFrameParam) } + Some(MsgPoseRelative::MESSAGE_TYPE) => { + serde_json::from_value::(value).map(Sbp::MsgPoseRelative) + } Some(MsgNdbEvent::MESSAGE_TYPE) => { serde_json::from_value::(value).map(Sbp::MsgNdbEvent) } @@ -2324,6 +2330,11 @@ impl Sbp { msg.set_sender_id(sender_id); Ok(Sbp::MsgReferenceFrameParam(msg)) } + MsgPoseRelative::MESSAGE_TYPE => { + let mut msg = MsgPoseRelative::parse(&mut payload)?; + msg.set_sender_id(sender_id); + Ok(Sbp::MsgPoseRelative(msg)) + } MsgNdbEvent::MESSAGE_TYPE => { let mut msg = MsgNdbEvent::parse(&mut payload)?; msg.set_sender_id(sender_id); @@ -2822,6 +2833,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelEcefCovGnss(msg) => msg.message_name(), Sbp::MsgUtcLeapSecond(msg) => msg.message_name(), Sbp::MsgReferenceFrameParam(msg) => msg.message_name(), + Sbp::MsgPoseRelative(msg) => msg.message_name(), Sbp::MsgNdbEvent(msg) => msg.message_name(), Sbp::MsgLog(msg) => msg.message_name(), Sbp::MsgFwd(msg) => msg.message_name(), @@ -3050,6 +3062,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelEcefCovGnss(msg) => msg.message_type(), Sbp::MsgUtcLeapSecond(msg) => msg.message_type(), Sbp::MsgReferenceFrameParam(msg) => msg.message_type(), + Sbp::MsgPoseRelative(msg) => msg.message_type(), Sbp::MsgNdbEvent(msg) => msg.message_type(), Sbp::MsgLog(msg) => msg.message_type(), Sbp::MsgFwd(msg) => msg.message_type(), @@ -3278,6 +3291,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelEcefCovGnss(msg) => msg.sender_id(), Sbp::MsgUtcLeapSecond(msg) => msg.sender_id(), Sbp::MsgReferenceFrameParam(msg) => msg.sender_id(), + Sbp::MsgPoseRelative(msg) => msg.sender_id(), Sbp::MsgNdbEvent(msg) => msg.sender_id(), Sbp::MsgLog(msg) => msg.sender_id(), Sbp::MsgFwd(msg) => msg.sender_id(), @@ -3506,6 +3520,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelEcefCovGnss(msg) => msg.set_sender_id(new_id), Sbp::MsgUtcLeapSecond(msg) => msg.set_sender_id(new_id), Sbp::MsgReferenceFrameParam(msg) => msg.set_sender_id(new_id), + Sbp::MsgPoseRelative(msg) => msg.set_sender_id(new_id), Sbp::MsgNdbEvent(msg) => msg.set_sender_id(new_id), Sbp::MsgLog(msg) => msg.set_sender_id(new_id), Sbp::MsgFwd(msg) => msg.set_sender_id(new_id), @@ -3734,6 +3749,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelEcefCovGnss(msg) => msg.encoded_len(), Sbp::MsgUtcLeapSecond(msg) => msg.encoded_len(), Sbp::MsgReferenceFrameParam(msg) => msg.encoded_len(), + Sbp::MsgPoseRelative(msg) => msg.encoded_len(), Sbp::MsgNdbEvent(msg) => msg.encoded_len(), Sbp::MsgLog(msg) => msg.encoded_len(), Sbp::MsgFwd(msg) => msg.encoded_len(), @@ -3965,6 +3981,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelEcefCovGnss(msg) => msg.gps_time(), Sbp::MsgUtcLeapSecond(msg) => msg.gps_time(), Sbp::MsgReferenceFrameParam(msg) => msg.gps_time(), + Sbp::MsgPoseRelative(msg) => msg.gps_time(), Sbp::MsgNdbEvent(msg) => msg.gps_time(), Sbp::MsgLog(msg) => msg.gps_time(), Sbp::MsgFwd(msg) => msg.gps_time(), @@ -4201,6 +4218,7 @@ impl WireFormat for Sbp { Sbp::MsgVelEcefCovGnss(msg) => WireFormat::write(msg, buf), Sbp::MsgUtcLeapSecond(msg) => WireFormat::write(msg, buf), Sbp::MsgReferenceFrameParam(msg) => WireFormat::write(msg, buf), + Sbp::MsgPoseRelative(msg) => WireFormat::write(msg, buf), Sbp::MsgNdbEvent(msg) => WireFormat::write(msg, buf), Sbp::MsgLog(msg) => WireFormat::write(msg, buf), Sbp::MsgFwd(msg) => WireFormat::write(msg, buf), @@ -4429,6 +4447,7 @@ impl WireFormat for Sbp { Sbp::MsgVelEcefCovGnss(msg) => WireFormat::len(msg), Sbp::MsgUtcLeapSecond(msg) => WireFormat::len(msg), Sbp::MsgReferenceFrameParam(msg) => WireFormat::len(msg), + Sbp::MsgPoseRelative(msg) => WireFormat::len(msg), Sbp::MsgNdbEvent(msg) => WireFormat::len(msg), Sbp::MsgLog(msg) => WireFormat::len(msg), Sbp::MsgFwd(msg) => WireFormat::len(msg), @@ -5436,6 +5455,12 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgPoseRelative) -> Self { + Sbp::MsgPoseRelative(msg) + } +} + impl From for Sbp { fn from(msg: MsgNdbEvent) -> Self { Sbp::MsgNdbEvent(msg) diff --git a/rust/sbp/src/messages/navigation.rs b/rust/sbp/src/messages/navigation.rs index 72198e5cfa..369488d7fc 100644 --- a/rust/sbp/src/messages/navigation.rs +++ b/rust/sbp/src/messages/navigation.rs @@ -59,6 +59,7 @@ pub use msg_pos_llh_cov::MsgPosLlhCov; pub use msg_pos_llh_cov_gnss::MsgPosLlhCovGnss; pub use msg_pos_llh_dep_a::MsgPosLlhDepA; pub use msg_pos_llh_gnss::MsgPosLlhGnss; +pub use msg_pose_relative::MsgPoseRelative; pub use msg_protection_level::MsgProtectionLevel; pub use msg_protection_level_dep_a::MsgProtectionLevelDepA; pub use msg_reference_frame_param::MsgReferenceFrameParam; @@ -2139,6 +2140,388 @@ pub mod msg_gps_time_gnss { } } +pub mod msg_pose_relative { + #![allow(unused_imports)] + + use super::*; + use crate::messages::lib::*; + + /// Relative Pose + /// + /// This solution message reports the relative pose of a sensor between two + /// time instances. The relative pose comprises of a rotation and a + /// translation which relates the sensor (e.g. camera) frame at a given time + /// (first keyframe) to the sensor frame at another time (second key frame). + /// The relative translations is a 3x1 vector described in the first keyframe. + /// Relative rotation is described by a quaternion from second keyframe to the + /// first keyframe. + /// + #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] + #[derive(Debug, PartialEq, Clone)] + pub struct MsgPoseRelative { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing, alias = "sender"))] + pub sender_id: Option, + /// GPS Time of Week + #[cfg_attr(feature = "serde", serde(rename = "tow"))] + pub tow: u32, + /// ID of the sensor producing this message + #[cfg_attr(feature = "serde", serde(rename = "sensor_id"))] + pub sensor_id: u8, + /// Timestamp of first keyframe + #[cfg_attr(feature = "serde", serde(rename = "timestamp_1"))] + pub timestamp_1: u32, + /// Timestamp of second keyframe + #[cfg_attr(feature = "serde", serde(rename = "timestamp_2"))] + pub timestamp_2: u32, + /// Relative translation \[x,y,z\] described in first keyframe + #[cfg_attr(feature = "serde", serde(rename = "trans"))] + pub trans: [i32; 3], + /// Real component of quaternion to describe relative rotation (second to + /// first keyframe) + #[cfg_attr(feature = "serde", serde(rename = "w"))] + pub w: i32, + /// 1st imaginary component of quaternion to describe relative rotation + /// (second to first keyframe) + #[cfg_attr(feature = "serde", serde(rename = "x"))] + pub x: i32, + /// 2nd imaginary component of quaternion to describe relative rotation + /// (second to first keyframe) + #[cfg_attr(feature = "serde", serde(rename = "y"))] + pub y: i32, + /// 3rd imaginary component of quaternion to describe relative rotation + /// (second to first keyframe) + #[cfg_attr(feature = "serde", serde(rename = "z"))] + pub z: i32, + /// Estimated variance of x (relative translation) + #[cfg_attr(feature = "serde", serde(rename = "cov_r_x_x"))] + pub cov_r_x_x: f32, + /// Covariance of x and y (relative translation) + #[cfg_attr(feature = "serde", serde(rename = "cov_r_x_y"))] + pub cov_r_x_y: f32, + /// Covariance of x and z (relative translation) + #[cfg_attr(feature = "serde", serde(rename = "cov_r_x_z"))] + pub cov_r_x_z: f32, + /// Estimated variance of y (relative translation) + #[cfg_attr(feature = "serde", serde(rename = "cov_r_y_y"))] + pub cov_r_y_y: f32, + /// Covariance of y and z (relative translation) + #[cfg_attr(feature = "serde", serde(rename = "cov_r_y_z"))] + pub cov_r_y_z: f32, + /// Estimated variance of z (relative translation) + #[cfg_attr(feature = "serde", serde(rename = "cov_r_z_z"))] + pub cov_r_z_z: f32, + /// Estimated variance of x (relative rotation) + #[cfg_attr(feature = "serde", serde(rename = "cov_c_x_x"))] + pub cov_c_x_x: f32, + /// Covariance of x and y (relative rotation) + #[cfg_attr(feature = "serde", serde(rename = "cov_c_x_y"))] + pub cov_c_x_y: f32, + /// Covariance of x and z (relative rotation) + #[cfg_attr(feature = "serde", serde(rename = "cov_c_x_z"))] + pub cov_c_x_z: f32, + /// Estimated variance of y (relative rotation) + #[cfg_attr(feature = "serde", serde(rename = "cov_c_y_y"))] + pub cov_c_y_y: f32, + /// Covariance of y and z (relative rotation) + #[cfg_attr(feature = "serde", serde(rename = "cov_c_y_z"))] + pub cov_c_y_z: f32, + /// Estimated variance of z (relative rotation) + #[cfg_attr(feature = "serde", serde(rename = "cov_c_z_z"))] + pub cov_c_z_z: f32, + /// Status flags of relative translation and rotation + #[cfg_attr(feature = "serde", serde(rename = "flags"))] + pub flags: u8, + } + + impl MsgPoseRelative { + /// Gets the [TimeSource][self::TimeSource] stored in the `flags` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `TimeSource` 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 `TimeSource` were added. + pub fn time_source(&self) -> Result { + get_bit_range!(self.flags, u8, u8, 5, 4).try_into() + } + + /// Set the bitrange corresponding to the [TimeSource][TimeSource] of the `flags` bitfield. + pub fn set_time_source(&mut self, time_source: TimeSource) { + set_bit_range!(&mut self.flags, time_source, u8, u8, 5, 4); + } + + /// Gets the [RelativeTranslationStatus][self::RelativeTranslationStatus] stored in the `flags` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `RelativeTranslationStatus` 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 `RelativeTranslationStatus` were added. + pub fn relative_translation_status(&self) -> Result { + get_bit_range!(self.flags, u8, u8, 3, 2).try_into() + } + + /// Set the bitrange corresponding to the [RelativeTranslationStatus][RelativeTranslationStatus] of the `flags` bitfield. + pub fn set_relative_translation_status( + &mut self, + relative_translation_status: RelativeTranslationStatus, + ) { + set_bit_range!(&mut self.flags, relative_translation_status, u8, u8, 3, 2); + } + + /// Gets the [RelativeRotationStatus][self::RelativeRotationStatus] stored in the `flags` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `RelativeRotationStatus` 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 `RelativeRotationStatus` were added. + pub fn relative_rotation_status(&self) -> Result { + get_bit_range!(self.flags, u8, u8, 1, 0).try_into() + } + + /// Set the bitrange corresponding to the [RelativeRotationStatus][RelativeRotationStatus] of the `flags` bitfield. + pub fn set_relative_rotation_status( + &mut self, + relative_rotation_status: RelativeRotationStatus, + ) { + set_bit_range!(&mut self.flags, relative_rotation_status, u8, u8, 1, 0); + } + } + + impl ConcreteMessage for MsgPoseRelative { + const MESSAGE_TYPE: u16 = 581; + const MESSAGE_NAME: &'static str = "MSG_POSE_RELATIVE"; + } + + impl SbpMessage for MsgPoseRelative { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::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 + } + #[cfg(feature = "swiftnav")] + fn gps_time(&self) -> Option> { + let tow_s = (self.tow as f64) / 1000.0; + let gps_time = match time::GpsTime::new(0, tow_s) { + Ok(gps_time) => gps_time.tow(), + Err(e) => return Some(Err(e.into())), + }; + Some(Ok(time::MessageTime::Rover(gps_time.into()))) + } + } + + impl TryFrom for MsgPoseRelative { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgPoseRelative(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgPoseRelative { + const MIN_LEN: usize = ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + <[i32; 3] as WireFormat>::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.tow) + + WireFormat::len(&self.sensor_id) + + WireFormat::len(&self.timestamp_1) + + WireFormat::len(&self.timestamp_2) + + WireFormat::len(&self.trans) + + WireFormat::len(&self.w) + + WireFormat::len(&self.x) + + WireFormat::len(&self.y) + + WireFormat::len(&self.z) + + WireFormat::len(&self.cov_r_x_x) + + WireFormat::len(&self.cov_r_x_y) + + WireFormat::len(&self.cov_r_x_z) + + WireFormat::len(&self.cov_r_y_y) + + WireFormat::len(&self.cov_r_y_z) + + WireFormat::len(&self.cov_r_z_z) + + WireFormat::len(&self.cov_c_x_x) + + WireFormat::len(&self.cov_c_x_y) + + WireFormat::len(&self.cov_c_x_z) + + WireFormat::len(&self.cov_c_y_y) + + WireFormat::len(&self.cov_c_y_z) + + WireFormat::len(&self.cov_c_z_z) + + WireFormat::len(&self.flags) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.tow, buf); + WireFormat::write(&self.sensor_id, buf); + WireFormat::write(&self.timestamp_1, buf); + WireFormat::write(&self.timestamp_2, buf); + WireFormat::write(&self.trans, buf); + WireFormat::write(&self.w, buf); + WireFormat::write(&self.x, buf); + WireFormat::write(&self.y, buf); + WireFormat::write(&self.z, buf); + WireFormat::write(&self.cov_r_x_x, buf); + WireFormat::write(&self.cov_r_x_y, buf); + WireFormat::write(&self.cov_r_x_z, buf); + WireFormat::write(&self.cov_r_y_y, buf); + WireFormat::write(&self.cov_r_y_z, buf); + WireFormat::write(&self.cov_r_z_z, buf); + WireFormat::write(&self.cov_c_x_x, buf); + WireFormat::write(&self.cov_c_x_y, buf); + WireFormat::write(&self.cov_c_x_z, buf); + WireFormat::write(&self.cov_c_y_y, buf); + WireFormat::write(&self.cov_c_y_z, buf); + WireFormat::write(&self.cov_c_z_z, buf); + WireFormat::write(&self.flags, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgPoseRelative { + sender_id: None, + tow: WireFormat::parse_unchecked(buf), + sensor_id: WireFormat::parse_unchecked(buf), + timestamp_1: WireFormat::parse_unchecked(buf), + timestamp_2: WireFormat::parse_unchecked(buf), + trans: WireFormat::parse_unchecked(buf), + w: WireFormat::parse_unchecked(buf), + x: WireFormat::parse_unchecked(buf), + y: WireFormat::parse_unchecked(buf), + z: WireFormat::parse_unchecked(buf), + cov_r_x_x: WireFormat::parse_unchecked(buf), + cov_r_x_y: WireFormat::parse_unchecked(buf), + cov_r_x_z: WireFormat::parse_unchecked(buf), + cov_r_y_y: WireFormat::parse_unchecked(buf), + cov_r_y_z: WireFormat::parse_unchecked(buf), + cov_r_z_z: WireFormat::parse_unchecked(buf), + cov_c_x_x: WireFormat::parse_unchecked(buf), + cov_c_x_y: WireFormat::parse_unchecked(buf), + cov_c_x_z: WireFormat::parse_unchecked(buf), + cov_c_y_y: WireFormat::parse_unchecked(buf), + cov_c_y_z: WireFormat::parse_unchecked(buf), + cov_c_z_z: WireFormat::parse_unchecked(buf), + flags: WireFormat::parse_unchecked(buf), + } + } + } + + /// Time source + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum TimeSource { + /// None (invalid) + None = 0, + + /// GNSS Solution (ms in week) + GnssSolution = 1, + + /// Local CPU Time (ms) + LocalCpuTime = 2, + } + + impl std::fmt::Display for TimeSource { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + TimeSource::None => f.write_str("None (invalid)"), + TimeSource::GnssSolution => f.write_str("GNSS Solution (ms in week)"), + TimeSource::LocalCpuTime => f.write_str("Local CPU Time (ms)"), + } + } + } + + impl TryFrom for TimeSource { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(TimeSource::None), + 1 => Ok(TimeSource::GnssSolution), + 2 => Ok(TimeSource::LocalCpuTime), + i => Err(i), + } + } + } + + /// Relative translation status + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum RelativeTranslationStatus { + /// Invalid + Invalid = 0, + + /// Valid + Valid = 1, + } + + impl std::fmt::Display for RelativeTranslationStatus { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + RelativeTranslationStatus::Invalid => f.write_str("Invalid"), + RelativeTranslationStatus::Valid => f.write_str("Valid"), + } + } + } + + impl TryFrom for RelativeTranslationStatus { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(RelativeTranslationStatus::Invalid), + 1 => Ok(RelativeTranslationStatus::Valid), + i => Err(i), + } + } + } + + /// Relative rotation status + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum RelativeRotationStatus { + /// Invalid + Invalid = 0, + + /// Valid + Valid = 1, + } + + impl std::fmt::Display for RelativeRotationStatus { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + RelativeRotationStatus::Invalid => f.write_str("Invalid"), + RelativeRotationStatus::Valid => f.write_str("Valid"), + } + } + } + + impl TryFrom for RelativeRotationStatus { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(RelativeRotationStatus::Invalid), + 1 => Ok(RelativeRotationStatus::Valid), + i => Err(i), + } + } + } +} + pub mod msg_pos_ecef { #![allow(unused_imports)] diff --git a/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_pose_relative.rs b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_pose_relative.rs new file mode 100644 index 0000000000..db2779acfa --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_pose_relative.rs @@ -0,0 +1,536 @@ +// +// 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 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/navigation/test_MsgPoseRelative.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_navigation_msg_pose_relative() { + { + let mut payload = Cursor::new(vec![ + 85, 69, 2, 66, 0, 90, 86, 4, 0, 0, 0, 86, 4, 0, 0, 172, 8, 0, 0, 76, 4, 0, 0, 38, 2, 0, + 0, 100, 0, 0, 0, 100, 3, 200, 204, 252, 168, 157, 255, 115, 53, 186, 144, 190, 48, 34, + 37, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, 63, 0, + 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 64, 5, 171, 187, + ]); + + // 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::MsgPoseRelative(msg) => { + assert_eq!( + msg.message_type(), + 0x245, + "Incorrect message type, expected 0x245, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x42, + "incorrect sender id, expected 0x42, is {}", + sender_id + ); + assert!( + msg.cov_c_x_x.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_x_x, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_x_x + ); + assert!( + msg.cov_c_x_y.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_x_y, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_x_y + ); + assert!( + msg.cov_c_x_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_x_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_x_z + ); + assert!( + msg.cov_c_y_y.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_y_y, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_y_y + ); + assert!( + msg.cov_c_y_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_y_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_y_z + ); + assert!( + msg.cov_c_z_z.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_z_z, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_z_z + ); + assert!( + msg.cov_r_x_x.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_x_x, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_x_x + ); + assert!( + msg.cov_r_x_y.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_x_y, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_x_y + ); + assert!( + msg.cov_r_x_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_x_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_x_z + ); + assert!( + msg.cov_r_y_y.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_y_y, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_y_y + ); + assert!( + msg.cov_r_y_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_y_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_y_z + ); + assert!( + msg.cov_r_z_z.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_z_z, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_z_z + ); + assert_eq!( + msg.flags, 5, + "incorrect value for flags, expected 5, is {}", + msg.flags + ); + assert_eq!( + msg.sensor_id, 0, + "incorrect value for sensor_id, expected 0, is {}", + msg.sensor_id + ); + assert_eq!( + msg.timestamp_1, 1110, + "incorrect value for timestamp_1, expected 1110, is {}", + msg.timestamp_1 + ); + assert_eq!( + msg.timestamp_2, 2220, + "incorrect value for timestamp_2, expected 2220, is {}", + msg.timestamp_2 + ); + assert_eq!( + msg.tow, 1110, + "incorrect value for tow, expected 1110, is {}", + msg.tow + ); + assert_eq!( + msg.trans[0], 1100, + "incorrect value for trans[0], expected 1100, is {}", + msg.trans[0] + ); + assert_eq!( + msg.trans[1], 550, + "incorrect value for trans[1], expected 550, is {}", + msg.trans[1] + ); + assert_eq!( + msg.trans[2], 100, + "incorrect value for trans[2], expected 100, is {}", + msg.trans[2] + ); + assert_eq!( + msg.w, -859307164, + "incorrect value for w, expected -859307164, is {}", + msg.w + ); + assert_eq!( + msg.x, -6444804, + "incorrect value for x, expected -6444804, is {}", + msg.x + ); + assert_eq!( + msg.y, -1866844813, + "incorrect value for y, expected -1866844813, is {}", + msg.y + ); + assert_eq!( + msg.z, 622997694, + "incorrect value for z, expected 622997694, is {}", + msg.z + ); + } + _ => panic!("Invalid message type! Expected a MsgPoseRelative"), + }; + 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_navigation_msg_pose_relative() { + { + let json_input = r#"{"preamble": 85, "msg_type": 581, "sender": 66, "length": 90, "payload": "VgQAAABWBAAArAgAAEwEAAAmAgAAZAAAAGQDyMz8qJ3/czW6kL4wIiUAAIA/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAABAAAAAAAAAAAAAAABAAAAAAAAAAEAF", "crc": 48043, "tow": 1110, "sensor_id": 0, "timestamp_1": 1110, "timestamp_2": 2220, "trans": [1100, 550, 100], "w": -859307164, "x": -6444804, "y": -1866844813, "z": 622997694, "cov_r_x_x": 1.0, "cov_r_x_y": 0.0, "cov_r_x_z": 0.0, "cov_r_y_y": 1.0, "cov_r_y_z": 0.0, "cov_r_z_z": 1.0, "cov_c_x_x": 2.0, "cov_c_x_y": 0.0, "cov_c_x_z": 0.0, "cov_c_y_y": 2.0, "cov_c_y_z": 0.0, "cov_c_z_z": 2.0, "flags": 5}"#.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::MsgPoseRelative(msg) => { + assert_eq!( + msg.message_type(), + 0x245, + "Incorrect message type, expected 0x245, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x42, + "incorrect sender id, expected 0x42, is {}", + sender_id + ); + assert!( + msg.cov_c_x_x.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_x_x, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_x_x + ); + assert!( + msg.cov_c_x_y.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_x_y, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_x_y + ); + assert!( + msg.cov_c_x_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_x_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_x_z + ); + assert!( + msg.cov_c_y_y.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_y_y, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_y_y + ); + assert!( + msg.cov_c_y_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_y_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_y_z + ); + assert!( + msg.cov_c_z_z.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_z_z, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_z_z + ); + assert!( + msg.cov_r_x_x.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_x_x, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_x_x + ); + assert!( + msg.cov_r_x_y.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_x_y, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_x_y + ); + assert!( + msg.cov_r_x_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_x_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_x_z + ); + assert!( + msg.cov_r_y_y.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_y_y, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_y_y + ); + assert!( + msg.cov_r_y_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_y_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_y_z + ); + assert!( + msg.cov_r_z_z.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_z_z, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_z_z + ); + assert_eq!( + msg.flags, 5, + "incorrect value for flags, expected 5, is {}", + msg.flags + ); + assert_eq!( + msg.sensor_id, 0, + "incorrect value for sensor_id, expected 0, is {}", + msg.sensor_id + ); + assert_eq!( + msg.timestamp_1, 1110, + "incorrect value for timestamp_1, expected 1110, is {}", + msg.timestamp_1 + ); + assert_eq!( + msg.timestamp_2, 2220, + "incorrect value for timestamp_2, expected 2220, is {}", + msg.timestamp_2 + ); + assert_eq!( + msg.tow, 1110, + "incorrect value for tow, expected 1110, is {}", + msg.tow + ); + assert_eq!( + msg.trans[0], 1100, + "incorrect value for trans[0], expected 1100, is {}", + msg.trans[0] + ); + assert_eq!( + msg.trans[1], 550, + "incorrect value for trans[1], expected 550, is {}", + msg.trans[1] + ); + assert_eq!( + msg.trans[2], 100, + "incorrect value for trans[2], expected 100, is {}", + msg.trans[2] + ); + assert_eq!( + msg.w, -859307164, + "incorrect value for w, expected -859307164, is {}", + msg.w + ); + assert_eq!( + msg.x, -6444804, + "incorrect value for x, expected -6444804, is {}", + msg.x + ); + assert_eq!( + msg.y, -1866844813, + "incorrect value for y, expected -1866844813, is {}", + msg.y + ); + assert_eq!( + msg.z, 622997694, + "incorrect value for z, expected 622997694, is {}", + msg.z + ); + } + _ => panic!("Invalid message type! Expected a MsgPoseRelative"), + }; + } +} + +/// Tests [`sbp::json::JsonEncoder`] for roundtrip SBP message -> JSON +/// +/// Assumes: +/// - [`self::test_auto_check_sbp_navigation_msg_pose_relative`] passes +/// +/// Asserts: +/// - SBP fields equates to that of the field +/// - Payload is identical +#[test] +#[cfg(feature = "json")] +fn test_sbp2json_auto_check_sbp_navigation_msg_pose_relative() { + { + let mut payload = Cursor::new(vec![ + 85, 69, 2, 66, 0, 90, 86, 4, 0, 0, 0, 86, 4, 0, 0, 172, 8, 0, 0, 76, 4, 0, 0, 38, 2, 0, + 0, 100, 0, 0, 0, 100, 3, 200, 204, 252, 168, 157, 255, 115, 53, 186, 144, 190, 48, 34, + 37, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 128, 63, 0, + 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 64, 5, 171, 187, + ]); + + // 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::MsgPoseRelative( + serde_json::from_str( + std::str::from_utf8(json_buffer.as_slice()) + .unwrap() + .to_string() + .as_str(), + ) + .unwrap(), + ); + match &sbp_msg { + sbp::messages::Sbp::MsgPoseRelative(msg) => { + assert_eq!( + msg.message_type(), + 0x245, + "Incorrect message type, expected 0x245, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x42, + "incorrect sender id, expected 0x42, is {}", + sender_id + ); + assert!( + msg.cov_c_x_x.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_x_x, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_x_x + ); + assert!( + msg.cov_c_x_y.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_x_y, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_x_y + ); + assert!( + msg.cov_c_x_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_x_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_x_z + ); + assert!( + msg.cov_c_y_y.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_y_y, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_y_y + ); + assert!( + msg.cov_c_y_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_c_y_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_c_y_z + ); + assert!( + msg.cov_c_z_z.almost_eq(2.00000000000000000e+00), + "incorrect value for cov_c_z_z, expected 2.00000000000000000e+00, is {:e}", + msg.cov_c_z_z + ); + assert!( + msg.cov_r_x_x.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_x_x, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_x_x + ); + assert!( + msg.cov_r_x_y.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_x_y, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_x_y + ); + assert!( + msg.cov_r_x_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_x_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_x_z + ); + assert!( + msg.cov_r_y_y.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_y_y, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_y_y + ); + assert!( + msg.cov_r_y_z.almost_eq(0.00000000000000000e+00), + "incorrect value for cov_r_y_z, expected 0.00000000000000000e+00, is {:e}", + msg.cov_r_y_z + ); + assert!( + msg.cov_r_z_z.almost_eq(1.00000000000000000e+00), + "incorrect value for cov_r_z_z, expected 1.00000000000000000e+00, is {:e}", + msg.cov_r_z_z + ); + assert_eq!( + msg.flags, 5, + "incorrect value for flags, expected 5, is {}", + msg.flags + ); + assert_eq!( + msg.sensor_id, 0, + "incorrect value for sensor_id, expected 0, is {}", + msg.sensor_id + ); + assert_eq!( + msg.timestamp_1, 1110, + "incorrect value for timestamp_1, expected 1110, is {}", + msg.timestamp_1 + ); + assert_eq!( + msg.timestamp_2, 2220, + "incorrect value for timestamp_2, expected 2220, is {}", + msg.timestamp_2 + ); + assert_eq!( + msg.tow, 1110, + "incorrect value for tow, expected 1110, is {}", + msg.tow + ); + assert_eq!( + msg.trans[0], 1100, + "incorrect value for trans[0], expected 1100, is {}", + msg.trans[0] + ); + assert_eq!( + msg.trans[1], 550, + "incorrect value for trans[1], expected 550, is {}", + msg.trans[1] + ); + assert_eq!( + msg.trans[2], 100, + "incorrect value for trans[2], expected 100, is {}", + msg.trans[2] + ); + assert_eq!( + msg.w, -859307164, + "incorrect value for w, expected -859307164, is {}", + msg.w + ); + assert_eq!( + msg.x, -6444804, + "incorrect value for x, expected -6444804, is {}", + msg.x + ); + assert_eq!( + msg.y, -1866844813, + "incorrect value for y, expected -1866844813, is {}", + msg.y + ); + assert_eq!( + msg.z, 622997694, + "incorrect value for z, expected 622997694, is {}", + msg.z + ); + } + _ => panic!("Invalid message type! Expected a MsgPoseRelative"), + }; + + // 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 6788fcdcaf..d883296a15 100644 --- a/rust/sbp/tests/integration/main.rs +++ b/rust/sbp/tests/integration/main.rs @@ -47,6 +47,7 @@ mod auto_check_sbp_navigation_msg_pos_llh_cov; mod auto_check_sbp_navigation_msg_pos_llh_cov_gnss; mod auto_check_sbp_navigation_msg_pos_llh_dep_a; mod auto_check_sbp_navigation_msg_pos_llh_gnss; +mod auto_check_sbp_navigation_msg_pose_relative; mod auto_check_sbp_navigation_msg_protection_level; mod auto_check_sbp_navigation_msg_reference_frame_param; mod auto_check_sbp_navigation_msg_utc_leap_second; From 3dd21f251ada28194a93417c0bd2449484015634 Mon Sep 17 00:00:00 2001 From: Navid Mahabadi Date: Thu, 17 Nov 2022 12:06:21 +0100 Subject: [PATCH 4/9] update documents --- README.md | 2 +- docs/sbp.pdf | Bin 581543 -> 581544 bytes 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 56610401f1..02174c90d6 100644 --- a/README.md +++ b/README.md @@ -196,7 +196,7 @@ python setup.py Run the following command: ```sh -pip install git+https://github.com/swift-nav/libsbp@#egg=sbp&subdirectory=python +pip install "git+https://github.com/swift-nav/libsbp@#egg=sbp&subdirectory=python" ``` Or add this to `requirements.txt`: diff --git a/docs/sbp.pdf b/docs/sbp.pdf index 8dacbabe96a4bce9c479eb6e1cf78d4a4b571236..6bbef58fce3e6d25d2c4964b6f4fe71189998ccb 100644 GIT binary patch delta 33525 zcmYhBRX|(M(}qccLveT4;w`Sl-KDq`3KVw_?ry;;PI1@bR@~hw?oNS1KK{Snd>6Ud zeRj^CJ=xircc-L_y0nYB27m?lkYobOP|t)VhDbUzPC0&7J^mw!e}sTKK=qu>nX%8_`!;ZiyX8y!ck1c5YYQ^ zWg_bQZP~6+hCmfw8ZZSI5*<&d?pa;G*Pw2D2*1V<3s>P z^pML?c$|9U3?_IyRuQKxe*UqPb0stzp{8p$zCY-5Ir|U}N_g!0`tKj$@SnnPW`B%1 z-P8sian}dO=*2?;k6MIJNqOIK>#>U=aQJVtQ};413b8fjoUQz@{ldKqwPzqctM4hF zKqZtl!^gb^VDC%CYXmE0cW@F7Z9@U-k}g|s<8kVLwp1e$Afq$R!C>zrKf`6FTiUnW zpM8D+dy#$EP6CYL)~EHTA>pgO%11JivTKW$?dB^pOBBt#kQ-`Po!0|Kzx}T>4o7{( ztcuOsTw;jGB(1*>dLI6GhoaRGX06ZeTjCWEmR#BgR>$o$)+t(22^VwTH<2hs{Ae6lCa(#rzKu;Q`t#HX=di&#{hP=yOF$_iz6&~|f~8k4oTJ2N?8;T}z3H=v5?<2nKP1x; zpp1;)t536!nedgBMmqW9g4*#xW*3Y<7y$Yo!kh%aVr45xv&g;hi_uA?N=K^U z7S!T-(YL!^x5)tyY>vO=wiEVTH7!8dnwZV6j-SqtFPMSwjuLH07&MGAcqiq`xsDCN zRYug&9;s5*UR(TF9{}WYi(1oX^I^tdWUjI1Uyxwb#^G989D2~zpeWxzT?jFG#Bz2R$`RavLDYc01* zrSzz2)lmSr$2^)dix6_bk(6o5m&uhn;Avj9!gH7BDCYb3WS@Ia(Y@1?iMz4Y^YdP& z#VwEsr9-E(W2L@%>B0s4uxG2u#2M&JwLQo;|Jq{ov4#h{!OcD5I{TTs-iPUK#(r!a zlCDDIwq^KXDc`@*^Vr$278!=@-0$&)CnccWvm!2cGN?+vZcu!&4O-}?I3$v`!1mn6 zp^K)0_Wdxppm5kTp6pAo*!wp^LPoFxO^QDm2D}zna=4zOse0qs*9Z8ckcOkWlU&&!trR|S(U^PfS_UGH`M}KO;hF%& z0$o)fqS3bG0yr6c*7`3w33zB3X5)r?4YW&47=vt59LZB1S`-l+i?WRw!^VSe9Zt^p zPppjL{dvu$yB*{cFGDP>LfJ1D01K3cl8FMOJ7)y9i_zgalDee&D#fUM&<=o=&tHYdo0R7E|6f4lQ6G0&5hWnJ`V4PW1WOY)~FTj<% zHTo)$dgUhq77^Z~!CFK`vx7LO>)=9SN3VO^aWf=m#1{qZC9&jQOFz2_G=i7%MfWTN zzTY(iq{(&vaX>FrsdE}u7OSIqM=w%Ai(O~}b`sub|NibqTug6&^*iO&#?9Q6A525; zJ@>JY#V~g@$h0$R{Zg2qeXk>?qjM;2#=rF9Q*#4(_j$=%!;+uxlAsOHvXSJsJ> z$Wt>{-=@INZpdyO&xj^Z!g?w3xYV7O-go1XA8hkQ@6*9-Sd@sS6n7_W!3|-5NbY-D z;!T+!hzc|tu*D<8Io+8BWm$#kcnM!xlqJdpHs6C4MZ$mBc?*7QY^)60;x~D>OPzx( z)Ep%-P_FlH zaSI!6*Pk3k=8Kf*@d`D?d<9&g@OzV0ZbQ+poY=}w$4zFEG(~>)TvT#FoJk0RsxsUT z#unFLp&SM}Vowc=>&p`4kwNmLbiqHv`E^$*rIAx(yUNC8HK#~A#6oDuPBeo*rm)mW z-Oy%8L3%%fih*jF7v;e*nh7;>uHt)nT4Fz|ak#a_c1lSEvm!l=7;PH7Z00UC`kzNk z3R29>5K5>v^e~7kiHKKA>1c4THtLov2bQ+LLf(9L?fEOCm^;T3u4x7&w|~Kj7z17w zkl`>=YqIx9qhhS*5^%NC<{vjVBdF^9hs-JP{mNqB|4~KyCHc0zD29wyj~F_pH&-QP z!@bQj=pKip`u^}Q)YSU6SBIfc&8HsUl-2}uDw42$UAKA-ZNf>7JPqJ>G1l}9iS=~cYBnzxjaFub z&n^zxGff+rzWFL4o@|K@EvsVc;7G5w zI!J30(R1TY)o#1xOO%SOzbh8F+7v4bJ}1f;b6gD@(tOnjfpbUqWg4};UFENSc$cY} zVS6wmzX%I#A#lz)rt#H5R_;;+{&gsu(=A6`1J-d5*Kj6nT5~*Ze!fw5VP)Nz zutAW~oVuU-!%fk6fJXiRA9IgRzDJ_h9c!fr=KV$NvdMTVh0hr)}? zUW&Bm#EsBP%OPM9mdb7!Ne4^^2i7T~TV(fH5Fmxaun6d56XN=pYA}V_bUXZF-|949OKF znj;fBqus7uBp>wrlAzM-7u-fuczjrfGd`@$rYQE|3zdH`O$b1i9H|EuY=)o69z@#K z5+72@d|>O*i5jdohN-0t-vra}j^$#+v{6v-8&ihLDrAae#)B{2_*eeAk*CY>(xeos z8l9E&-Sn@Kg@_SqOlmB(ERqpkiSAI;*?^!Gg-@XY_Uu{yUp~{nBRVMW;6oh`o&3~X zuPU31PIqy+JQYn6OJRao1x`-*1BvnD(oY%f1Z_#Y&;|r6EOlVBuKp%sV=H&d?Rf9D zN2&RTyYv$ljbFV%*XaooypGv-HkLb<3@Q#8k1=YJB|kA!InM3679Q)53S^P~7C#;a z2<`edq|elCoWQ*z)00A|2Uy%;w={j;ZbZ_0?}3@Ks^AfqEaYg~$d4w9t=R}}nh)-{ z80MJi2j!51zhU=jB~|x51%f|oF_&Ftid}xUq9h;`Wq<#?Kl<3kHNHXqUwD|^03b&p zSjp_~v^q~iaeWu)p~t4P5>p5TnMGr!|A!oO0SXa`Wo58t-x5FSIG)5@Opa+0L#4kw zWl)5n3|Eo=sMcQq1O!}eC_QpNk*(}?VMr5Ex!wsl55Dx{fBlD(0907qFj*-AVyost zm=$il%RKYHXlI1K{{F8YLNW&+NTPIQ1Q(?%ID$e|wD9;ABAQX&|?c@?hA!fz7sUQp<7zX-z= zD3FZ@Wzv+u^?!#pDHSJ)&@D+3__<@^EA^uSjUya40pu_F`E{+cUYK|Nv*Y#CWm&L|h zR8B8oa^pC@9EfXtNL93tJo3S;%0|hwQWs>GrJvg;B*Tr$t5i?+_N1blD9DUR<4C7uEM8?EKYu}Tqw`2a&QuF#h;MT03th~ zy}~{vv)nc(l~dgS;I5m4*UFzi_5y1#3mJVA_p4Ad@YATpUDG%jonvYUJSBQhu5IIM zS7>U$O8D6($e&vCB(c(Za#5FDsC132fkq}B(|NjYw_wHBsbR(7mZS;mta2GVq(NQo zyd_z&Z@?y;wjQzJzOo)+MZDQoTt7Vn@fAqPGerw3{2DkqQ-C4j9zO7Bdd@|y-e(@G z!yOhNRU9I}9`~6CVQtC!TrXmw`Q)`WqaJf!aBGNZbx&IJCM*4Di?ekf&ZX?|XZ-K7 z*2$RUic!*b7c^jOa;5x6oFPB>`BXl2qO-{IvCV{JZ&VuZpgT+lsa;sm`v}#jtXg>_SV_hUVz% zke7rf+EVR`+wuzvdi{)!MR0M7)q->Tc}r)y+q-oGgYpgg^Q|AilHb-~0cs1UmiK%F z()vsIDPMNIG092NDabs&IHFU7R@}wNDf2IzgKp0-uipRWTyNT2$pL)zw4QPAV6n9!FMH~Iahvf}i1|9ni%Aln z{ylyGIWe8OXsM@<#HUSf^_WT}mgX6kwUC6L2yY^wMutaoHu+&e0y4A=K$q1OJUM;F zpj*RLcom#Su*I@5f_Y6*1)4YT<&2B}4cAXO3A5ir@%HbUNBHB#XUA05DjociU@GT5 z$WIR=6#d~~`{*1R8}o|tPf7T&0{DbUkg%^9*^V?zs43Q93GQrlAji1o(WyJ){?CKw zod8x)@LM_}DziM#WD{V|HeJU5cJ#lZXg!{D{pZ7r9ssJ~i<~RRBoAgi#zlTLr>m!K zxuv|oLIa`Gk!EFdP@O0Rae;oY|F+1>AH`V^bzE?Qa#CFVaM-uA@S+I^^6D|4gtG#nfQ$0-Q;#@lZqNMt+bk}{xn_u!ce1- z5n-iBovqg3Z$@s_CWiIuI}X&ZHXWoEVfhnIgr_R<8dj1Y7)FYa+(c!<_+mt~v#ci^ zt;N!(&QO09pgM@*c2fcr--#mqE;YH%f@PLupQgvsRjYB!k~$kXA!5;1TH+u;rDbPm zk?W3zh&}>Hz~e+Tk3F>us!x@rp)m7vEB6#W@efoU$Jb}hDVZ5Uys7N+6srhK6*@awjZhnP)v}$YGlkd{V z5?l7_206c9HF4;r;8iwr6d0SN<`q*3Oa8c(+`~By0MoONWDz3JTO(F;z`xHj3M48~ zedZ)n8Y;zfK;mUC(%!NeUwrp<-X@x67M1Ge14eUSmLSzEuy~1kc-J!B4D*BnyB)@A zotINpJkIxwUp$6T-hFShefad7%SX4=CcB}kn+l!&2%uiE?ov4~fF<85B%+2yW={L<~xi0DrI{z*845hAXL<2Pn7FvR97E^y!tc|opx`Y>!gLo}T$TBoC zBz(p+PHbCkRl{!F;(0UQ)#av0pyLx4xGCPVhpeGq-WX0EHdR zKReHk!fmMPk1xX4mQ7Pjx;fHi|Tt1dzx|GFUucgv9+B(Six`N5)tzTtqN664n%+RDR6S6Ysb=~ z>i^-R$bQGVVC|e-Jdtf~>(8e~{lv0jw@_X{YV2oRjiyZw&b2F^yCDdV1*e9{ku1Lc>p%AC(=M?JdMTedq<@$uI3)e2URGvum*FEWDUY@k3ZVGaG_%4F6yc5{}Mxn-r5ZPCJ%DL^@DyS|-!! zW=+1PVd;csziRld>pfR{cQU>2dbHPhB?>z(HvZ(&Qr@bZQSqWVWjFu@Sj-2?BPZp5 z$7=ri7oh%*fFqBZZ@_?K$d}_oTt)d3gKIU~D>)-RALJ_ZP2t@`0!F~&U5mWw)j_R5 zU_~4;8qfURlSrJ~hvNSn7z6{D1WWKHiVq~CRn$^^$D}wvn>73LNzP!2O56i=B}4xOemKz)(Uu9%pXj%FTz6^Q}GW8 z5(4_56F?5L6&?yJQ3zGh&bqc4n!thkUBu|8-~KVoia;E6zyd^6ABYR9gI{m|uh~`~ z$Ok0gBri;x8SU<5g{8iqx%pK8S9eu;9~DjbA2VYJ)IcX%(@RC`)M4W+Ovs&jWkypk zsL6ML!i6|H`2C|a?11*@gb}atN0@D{{M1bRObyT?GtHX$fp9bdu|c!iQ~z4^nt&UK1Vx@Q<8sr)GGZ_d z(EgX>-7tG7sCSW`xcTkrjK~D)u1O3{dg?^KaT1Y8$=nm)#5O3py2Cm|%>3;SSTqbg zLnfd*rq$e@KAu7BROa?OAJn`F^hF`iOqWpPtQ?HyC`Bpy9i^1u+kXL->wPl)#~7ag_2G%GmupD7 z(>k<8mAbci30bRXUh({)fEcxi@PE|t70?Bi;5y$fnPI*DFiWNsrozxgwtajW?7yde z`j3gc2Pz>Fsh+Vh+TEjibufgdf5liZFd6v!wfz-T_NngQB@7%C*aJtHp8=_iZ%Y3~D3Gj){crKFVL`5l1ghiWk&I^?+8A(rS&jEhm?i#D5OQ1c=Kl~# z;yVxl#3Tg71paJbzsil{`%pbq&@f0MB9TBc71n4KglCmGe&kPy1eDa$H;K*u>{Nfc zcoCT_n3!NL$q1Cdp}kr2c12@jiwKhR4@w%&ycwRnXho(`lf^1}`ilvAureZQIH->6f0IVjqcHVENm$DrE^C_E>k2VXyI zkNy8|A1J~l2nJ^jeKNB3bN{~Xoh;v7wa>0>7*Y51ihL{3^oX!B)%`;rt$7N5NYq*I zJ8WSR&5Muv1pp08j?x>tM|@?Hi$2h!#fYFMj}GSM(aGpc7AIoRwF1z{@Kwz z@{)w?2O_bjd?IM6l1cxxwydTW9ej|@tA9DYQ#0MjOQ!V#e|o!3$gV}+1Yq5C{npsg zKFssHXYDZwH(${5^D9m&k16{_E0zpR4C8PQ>Xr$27J1~d!v?sACXCDfqIBCE-I9Kj zbgoh`3r27$^mx5Sx!z^;vwd=Ez0iWY(?V_M`~6ad^1ho^^o>hb%R}8x{w@2(^12a- zdVv12zA0Uu<;d}8p~_rbO~cI*4Ahun{W3RPb3=Z<7=m|QX_CZ|Jt|+#Q;TW_ zzh(t{s``%d6#IgcGQV}$P!n`{LGSB7cX2B9g*|=ju&Xo*kSD*-acjbH&)BXQkJDLb6T%5NzCu8ad6|r@jrNA~+^&sN?VbW@`{rr0MQ(f4zN;+tBJxGBHkDx00Nvo<}? z^MSMhU)A!Xr!DIOjH~cB>pIQM!h&hjMh$`kV?7HuQqdR)wPG z(U*jxQX0p_e)Z`84u~zN0?DD%6K~EsHn^(jt=tzAqr20X8?3z~pRKFkC=kkP52fah zRY7RL^62!eP>DXe_j@qu zDZWB$4qpME&1wOkLcPgsmAxoiOs*OP@OjU9Lg*e_wi^p=@B`|8`whqFXE-T|r+6lBLX8{FB;Up{H9XfQHj`k5#y3iY zOuN+aUewzVf@e6p!c%^cXl!Rch6;6Y%#A(sbXK>_lT2GJ+wtOXgNVmPG%%sq2hRn7 z)d}4#G96UpsfYk`ZTCThO0L&O{T$7~tPmr;c=Xx+NY#0yy-L}$fM)FOzT})b-xCq9 z+;-)vk`I$YVZrZP!k@4dC?Fl2V)frSW{(3pMI|Cq#}6R?vgH_Nd=Y&Mb_w8kcD;lG zMOGUZNNQO?WGRa8EBO{Lc`s9LN9;FI7a2(pPH(0B|1l7`5Rfvk%N~*$0{Q@6!IaPDh*Y?Uz|ueg>Z<2m zhViu`(Xm~bFF1GK z|I*q!crTCKKYeg?xEM}NLG45OpEMy9YiCE8{=1+$Sat8cC*wQv2t0UahE&=woNYw4 z{C($*0PsGdRS(7)YKk1*RF~BMw29-(=cM)rq?& zlc0pMtA)~1l#%I*utLz(U9%)bdvEf+^*gfOI=GKLn*WD#pQV#0aY2%NoY0`ET~ry2 zrhaa34w2PQxR2dAv0c{Hj~^ye=at$f3J{FeUnf6&<3Lg@$y*R}fy~i~vS=C*>kqke z*5qEyJGROR3C3#Q%gDAQ0^2CL}Yv6S>3Ss&+?^RH^a#`<-cc z-GcjOjzq*du@2rHH~QR#^SmoUGsGWqR3;nfu&dJ^qNy7Y7%h#@9~TH1p%+82@%Mo7 zfFGGnM(0SzDybc`D!cn}TIuZBe0@g`M}p~Zrqj}@@BBS`NI2d8>HWmz#)|P%f!(Y1 zc=Bmy+rFN@_0r8YNnC9VH7m~i#7AnW99r<^@7w+BRIP7azyGLk*61%IV}8YE&U6(g zS=EqnlKwag>k!L6;ld1ywSe2J!uUH=wZMpo@q^|eVT+g;P6`zIi87GE^BQii@GWNY zX^O@lr)i`nnP7wnT{C96Y+$1GNi5A`8GN zu*5#CSqjJL@1#@S$MJ|8OgFAA+OnLo&J4_!O@|a88yKs$Ec&1job-WmztnqZ#)akX z_#{YhK@Vr=89R3=JL?9hu13|@N>|23ZceAGn-12j1fSEw3mVoL`S?>hFT*l&JMsd%v@d8HSg&I1+ol9AUX};9DQ9&) zrpJBDNYRg(dD>@uVEO#p_Uee`r*~Nh-ME%*FzIkXU7%nww!OMG*LUNmIoydBYbWV* z>+aWz2kWasPY}a7&l+jz3L2gK$ff1d_-{C@<;`DQcVuMl)u4+%SUeSc$GBZ0tcin925a*jttm59S5>Rcq<{K9Y}U7 zWe%6{T0AG*P!fiM8u|R_{~7oK0bwHGmmX6NB;U6%hX->Wu7Au|yn+G-Y^}fk=go6- zKuc(N*Kb9H4QzXebMwznBfso=Ul8DhrI-KN$g2dkz~keRy=fs~?Z8xsn%46-4T0xZ zgfh1EHxIY}=COktKp4oleUegyCl1=CauWfy#gF>0=sgnoCI5hqPS6=VUNTsQqsaFh z>%lE`?v-eEd~TCUM*Q19Vr~EwgG?Zi@xN+OYGptLu26QQ>6+3U6lCX1M)r@1nF0kN z;ODQs6;z%%;+NU9i2RYiRPBC6pPEK4{)Y%Gf%cIJJr#39I!Oxy3}tl-V#MKYy= z>LD+UM>CDpPE<}i+92&Ch7Vbj z=E9Amq({p}m6xYY-KqxdXS}H@!JPM6zVj?!A~;4ItK2 z$Kzv!B1>aAXz#xpT{4&pwlK-8XY5ML!qG%WqOEBuxCFojP zS@ef^y|HK#jS}94#(I^7_!I&rV=PpFjb{odE9HbSifWxWC1`d4$@HWK>p%^)3JLA&C$~G(yULXQPv%RMGE7&@uKoC zn)LIkT4+C2*$F*wt@u7Qq{TQczLA=tdK%w za(=4lP8}ot*&8mDTz&Z=^|QRfX1`%Q*Sgez*1W(@cEL_Xng^T|l{wl}%zFMOA39VG zP6+)WN-KunUJq+~>5CM*-?Bb=tkH%%S?uH)(@5zXb~oqHmg4NiB=Of#_{BAjOFBfS zZPq%nV9P3nSt6)!O!(dr+mSz@2vD_;#j}G<+ldVs7c`#N6#v+3EqaGCD)sKOE9tBp zg0?}U0+a8D_=l4|x{Gv*R5REo9dsT5ou=8BLQLIk0jni&G%NniU2&RH3fj|&IS138 z)I1_h05&qEvgf~?R?F?uTPq8B}Embva%xSxWA3t z*xNI~oj*beVSInmR{v-b7dw{=DQkhWGE*~@?7Hks0wMDhux#LKN8v1M$LQ1P9-C^x zLq&7m)$CJ59zOc*@cO?YJ9!ee0@(_Jg57)uI|d!tWy3VJLBhlqsjH(f?HQREKr#Ehio6Ahz zuACx%mHFv%fi(jjeOHo%#Dwlb9p zf6q$nX{2v`C$YOfU_)qW$XZ$TRA;pggETIx45Dwe+G0&**BwipH8r!t?|A=;1|IO4 zwJ?jggmV%79T;vrPwQFbmZ^l#VSFa6WoGvQf8^&(mbehu>Yx$wkEaS+_ZboqB74+a^ugW}DLwBu@dI+T!PyK4{ncbAMv( zxVrFcZMeWCHqM%z@ z^QDsfw?E4MMdtKK+kC+pU+y%7g-I7QGh>E@`|9z*O4PI12*;L0mS(KaRqC>tex)&Q zJEgnbk)KydwD63d!NcZN2@p{uWg!Us>|A@ZGzO6J9Vm`)v(HFY(9z?GtQ)y zd!-cLaNGJbDm3-#HtT%nXooMyj{*l1%fy~jVh4qplv#Ihu4(2-A`^jt>PiwCi&vp2 z)Qf~Rjn?H5eged_BKQP0YJB)Na76 zNlv1X6j=r+M8>xD?0{RM{$Ak zj)VHdKe>6dLtaUDUisyYt#URQ(3qAEe#_7^;0J3KcfGZp2ObqAXWdW7;CC`ru~ZOpAjvB)LNx4jmL&UW(D%AxRk|?N$-3fdXLj*q zX$8Ndq)eGB2w9Ouz7)Z?$5(S{coIyaHmiO#I&tTIE>&O8nJ{7TopNOm*L5Oz)Y+&W zL*`dY4c5#kdS|f4e%hzz7GC?|#PsC(O!k-vYCzK!zlYEbekxBHd3tQeiQ6&Rr$z81xm+1ydClH@ zbU|;!R#_5ndswpbt?Dr@9F2X#ao$vORnm}JOI#-q-7#(4=#WIx3Y7u#hFIl$n(TT} zcG0J7H!h1eLO!*4zJ;ne*Tum-k5vH-1L(;~I49I)Z|>ji9>!r7KVtSbJDNDa4)=78g`Yb@g9k1}E$v zI6|2nVKs##G;L=rP)vmTM@kzHlqdA*}7p_i1$wTd!z!E3Fk<>ak z;d~VKR4%L^B@Z-tWjZq&dJ5~Rb!!d?xAs`_MMWS9!qG5QZph?w3 zDI@>$H*lLQ$z8eY_xG|^%=(XIBY2hfWB8r-nrp*oEMwH^FOjtP zGccr+2pK{RKjB73rEeLTua}u|bi#jyH?c~*prV;fz^Cw{vLK_=n-S*_+i z$;jL|TdWaRD>%R4SM1;Ba#kmpqy+Yre+jXI*;bR? ze6nsEzGz1|WKg%{ZM@!U6SYv{fcqstaUrh0LO5tH?uGGSw&}r1Zus#BUoZE8g467N z+f`fNi6^=~M}+$kOvB^?G!V!nNBvy7_!X>z`#py^pD7DQEm!;u7muMYn6zJaerYp` zYl_>PXlP7cM|dn5@dJ4wGS1hvoTBm5IJi8}V-U=~=k}i(o;&wq-OBD`rHDbbJ{?_z zk8LiCwbq2auY?vkwu5>;M1K#vkQJWsrmh%`?=2Yoj2}f5PQoliZ|xqop$QJO#>IxW zJ4g8vKN9XAi>P^v^TuZ(5-@j})(SG)&zapQ_@5_9f&frgvSy3w~K(ltpto;cZ z-?}xJXN!nL(ZiO(Z2DFM|J&7&6tTAr47dg|K^Dbe(E&}612I@KFlQ)CtN;7Pr*FQ; zVKk>Kf~Oti9of-_Mj^HIsw9$YnPWmqsxohJM!3^qny1m<=Mo!31pH(aC_hp#G>s*Z zpZR)gbvJ0pG(v(Tu&J-E?Zh^f-rNE6d2;``7!~n8N*AgWl`_NImKE(6jmXeXW;ISJ zqjIdcSirVf!xNMTMkkXJOx;Mr)Ay!~F@9&gGSW`I9$Qo2Yv~>$L4|tLI1gU$(uN;+ zo&WQD?@y8yxRV$m_&G`b#?#&N8<7!5i~7G?4njsc- z=SzBELp*z2M2g+et9tr;lXte3X5Hbvwgm-;!EA$urC;_Ja4Vrs(PO@0#&k7r|7wgC zu~Q7{JMq~^jNn(ULs&7>(8yN8bXr$aFGIRPzq)TWY69>qbwd=_vp=V~t7nMb1Sd`? zYh|31GfGtk&LQvQA;nwVC{ApLp>btgd7q_qxR-Fx39hX;q&_5OAJx5!H&*X zq_JGq*`uyvaQdEW8;nx!I1Xs?!%sWQ&Xg*tq*?iG&zg#t|I+5xvr%YD3sjp`W#d})s?{4eDCXY$!j1dU zG-J@pTHn>;XW4j(@E`1W;gUA==^(D>G^%a^z=peqY$)t>VY!|A znfdYfa|i`iyGEiWNnUdEP+NF8Mt(GflUkvk+Vl%!w)6}yI<51Jw@Et zVw+N9s1^}Fd}KqnIhw2+ZWu!erbOjuyP}5U&wAxxv*10k35jOYSrv}W`p)qoZ%B8c z1m(tOASPDrrN_C>7$&4&5?TT5rQ^@$UfF>$YT`YN4lpeu@I$DVD*Y2(K-M15NSiPu z0Imtgz^glv^ET0=cMGV*CP!K0zhe9qL*4#sApxBNUBC&y)p7S_DTXUot~rXdT&RH6 zElCKSc&a}jYO}uw01Ey6{hR3YLfFftEzRxQk3?RS7|Fm#FSq;ZuBVL8@oHaiV0pAQ z!P(g+xUUB{unA-O86{*?2mBtk=(d^=_r0|C9t&o1K@xd~PR(&q!hwfH&Ny~VqH z1iv@>JWZJD==bSQzV?+^$QDMn48|G9Q_*vpSAKZlufIajeTToO5w(KCbvZ5I?gM^L z{KuzXUOQB|Cr1Xmm4BUH&VEHY0k;jz+sQ7N_*Z|opG>(w{zeu@f6<3rB_ivOvrP3xztbtXqn%RnHI;0^(TyUXD21PSi$?jCF> z`R?8yyLZps{k7*bbE<2eD&Fp@>Z$5i>ShBt|FIVE*=b(WiszAwvK=A8IYiwQ=DvOY zZFEf_Ou^0hF~H}MGNaSbU_f2++WMg_?YBtiG$@32Q!)VS>i#iS4%a=%%NRA){QG

@^sY!dS|r!Ad4tPbF5OrJ1-Q1qw)s3! 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 LEv?iiX{7%H?R-)w delta 33615 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 Q2$TrCNVK$4D$+>*8vt^D$^ZZW From 435afd7e78e2bb3a457fe8f990cfdb42dcf17c23 Mon Sep 17 00:00:00 2001 From: Navid Mahabadi Date: Thu, 17 Nov 2022 17:27:53 +0100 Subject: [PATCH 5/9] fix pipeline test issue --- java/src/com/swiftnav/sbp/client/MessageTable.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index afbc4d1e75..88a5355b91 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -93,6 +93,7 @@ import com.swiftnav.sbp.navigation.MsgProtectionLevel; import com.swiftnav.sbp.navigation.MsgProtectionLevelDepA; import com.swiftnav.sbp.navigation.MsgReferenceFrameParam; +import com.swiftnav.sbp.navigation.MsgPoseRelative; import com.swiftnav.sbp.navigation.MsgUtcLeapSecond; import com.swiftnav.sbp.navigation.MsgUtcTime; import com.swiftnav.sbp.navigation.MsgUtcTimeGnss; @@ -429,6 +430,8 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgUtcLeapSecond(msg); case MsgReferenceFrameParam.TYPE: return new MsgReferenceFrameParam(msg); + case MsgPoseRelative.TYPE: + return new MsgPoseRelative(msg); case MsgNdbEvent.TYPE: return new MsgNdbEvent(msg); case MsgObs.TYPE: From fb06a235caebeeede7ca77581531fdefd192e88a Mon Sep 17 00:00:00 2001 From: Navid Mahabadi Date: Thu, 17 Nov 2022 18:39:19 +0100 Subject: [PATCH 6/9] final update, docs, fix pipeline issue --- c/include/libsbp/legacy/navigation.h | 2 +- .../libsbp/v4/navigation/MSG_POSE_RELATIVE.h | 7 +++---- docs/sbp.pdf | Bin 581544 -> 581544 bytes haskell/src/SwiftNav/SBP/Navigation.hs | 2 +- .../com/swiftnav/sbp/client/MessageTable.java | 2 +- python/docs/source/spelling_wordlist.txt | 1 + python/sbp/navigation.py | 2 +- spec/yaml/swiftnav/sbp/navigation.yaml | 2 +- 8 files changed, 9 insertions(+), 9 deletions(-) diff --git a/c/include/libsbp/legacy/navigation.h b/c/include/libsbp/legacy/navigation.h index f3ec35fa31..83febff523 100644 --- a/c/include/libsbp/legacy/navigation.h +++ b/c/include/libsbp/legacy/navigation.h @@ -974,7 +974,7 @@ typedef struct SBP_ATTR_PACKED { * This solution message reports the relative pose of a sensor between two * time instances. The relative pose comprises of a rotation and a translation * which relates the sensor (e.g. camera) frame at a given time (first - * keyframe) to the sensor frame at another time (second key frame). The + * keyframe) to the sensor frame at another time (second keyframe). The * relative translations is a 3x1 vector described in the first keyframe. * Relative rotation is described by a quaternion from second keyframe to the * first keyframe. diff --git a/c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h b/c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h index d69e014b51..0c0a2f33b4 100644 --- a/c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h +++ b/c/include/libsbp/v4/navigation/MSG_POSE_RELATIVE.h @@ -43,10 +43,9 @@ extern "C" { * This solution message reports the relative pose of a sensor between two time * instances. The relative pose comprises of a rotation and a translation which * relates the sensor (e.g. camera) frame at a given time (first keyframe) to - * the sensor frame at another time (second key frame). The relative - * translations is a 3x1 vector described in the first keyframe. Relative - * rotation is described by a quaternion from second keyframe to the first - * keyframe. + * the sensor frame at another time (second keyframe). The relative translations + * is a 3x1 vector described in the first keyframe. Relative rotation is + * described by a quaternion from second keyframe to the first keyframe. */ typedef struct { /** diff --git a/docs/sbp.pdf b/docs/sbp.pdf index 6bbef58fce3e6d25d2c4964b6f4fe71189998ccb..0469ffa1865540f9661059fa3748960a454628ac 100644 GIT binary patch delta 140 zcmZ3nUwOrT<%Sl<7N!>F7M2#)7Pc1lEgaJhDVZ4?nHolEa_Rf#r?@1Rq$+5*SQ!}@ z85tTHnj3;8x9>Q_!O7xm>}cU^U|?!$VPs(9>||`}>f~f%VQOS(YT{yOVeDpRr(i=! L$#$0G97`ks<~}6b delta 140 zcmZ3nUwOrT<%Sl<7N!>F7M2#)7Pc1lEgaJhDH$3V8<<9Ea_Rf#r?@1Rq$+5*SQ!}@ z85tTHnj3;8x9>Q_!O7xmZtCXhV(emQZen0&;%a1SU}$b`Zeir=W@>0=W@+qVr(i=! L$#$0G97`ks<@qGx diff --git a/haskell/src/SwiftNav/SBP/Navigation.hs b/haskell/src/SwiftNav/SBP/Navigation.hs index 2ae05b1ab1..f133fd8cc1 100644 --- a/haskell/src/SwiftNav/SBP/Navigation.hs +++ b/haskell/src/SwiftNav/SBP/Navigation.hs @@ -2465,7 +2465,7 @@ msgPoseRelative = 0x0245 -- This solution message reports the relative pose of a sensor between two -- time instances. The relative pose comprises of a rotation and a translation -- which relates the sensor (e.g. camera) frame at a given time (first --- keyframe) to the sensor frame at another time (second key frame). The +-- keyframe) to the sensor frame at another time (second keyframe). The -- relative translations is a 3x1 vector described in the first keyframe. -- Relative rotation is described by a quaternion from second keyframe to the -- first keyframe. diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index 88a5355b91..c9eac0eea8 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -90,10 +90,10 @@ import com.swiftnav.sbp.navigation.MsgPosLLHCovGnss; import com.swiftnav.sbp.navigation.MsgPosLLHDepA; import com.swiftnav.sbp.navigation.MsgPosLLHGnss; +import com.swiftnav.sbp.navigation.MsgPoseRelative; import com.swiftnav.sbp.navigation.MsgProtectionLevel; import com.swiftnav.sbp.navigation.MsgProtectionLevelDepA; import com.swiftnav.sbp.navigation.MsgReferenceFrameParam; -import com.swiftnav.sbp.navigation.MsgPoseRelative; import com.swiftnav.sbp.navigation.MsgUtcLeapSecond; import com.swiftnav.sbp.navigation.MsgUtcTime; import com.swiftnav.sbp.navigation.MsgUtcTimeGnss; diff --git a/python/docs/source/spelling_wordlist.txt b/python/docs/source/spelling_wordlist.txt index 11bd8176da..036b3dbc1d 100644 --- a/python/docs/source/spelling_wordlist.txt +++ b/python/docs/source/spelling_wordlist.txt @@ -2,6 +2,7 @@ AE Acq BBD +keyframe BCD BD Beidou diff --git a/python/sbp/navigation.py b/python/sbp/navigation.py index a8a09d935f..0ab4a9cd43 100755 --- a/python/sbp/navigation.py +++ b/python/sbp/navigation.py @@ -5431,7 +5431,7 @@ class MsgPoseRelative(SBP): This solution message reports the relative pose of a sensor between two time instances. The relative pose comprises of a rotation and a translation which relates the sensor (e.g. camera) frame at a given time (first keyframe) to - the sensor frame at another time (second key frame). The relative + the sensor frame at another time (second keyframe). The relative translations is a 3x1 vector described in the first keyframe. Relative rotation is described by a quaternion from second keyframe to the first keyframe. diff --git a/spec/yaml/swiftnav/sbp/navigation.yaml b/spec/yaml/swiftnav/sbp/navigation.yaml index 56d9df3cf4..5731812751 100644 --- a/spec/yaml/swiftnav/sbp/navigation.yaml +++ b/spec/yaml/swiftnav/sbp/navigation.yaml @@ -2563,7 +2563,7 @@ definitions: This solution message reports the relative pose of a sensor between two time instances. The relative pose comprises of a rotation and a translation which relates the sensor (e.g. camera) frame at a given - time (first keyframe) to the sensor frame at another time (second key frame). + time (first keyframe) to the sensor frame at another time (second keyframe). The relative translations is a 3x1 vector described in the first keyframe. Relative rotation is described by a quaternion from second keyframe to the first keyframe. fields: From abecf4ca93e4a0eb20fb12111390b0b2e8f130be Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Thu, 17 Nov 2022 11:31:34 -0800 Subject: [PATCH 7/9] Add missing Java methods --- java/src/com/swiftnav/sbp/SBPMessage.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/java/src/com/swiftnav/sbp/SBPMessage.java b/java/src/com/swiftnav/sbp/SBPMessage.java index 0b3467d677..df79f570a2 100644 --- a/java/src/com/swiftnav/sbp/SBPMessage.java +++ b/java/src/com/swiftnav/sbp/SBPMessage.java @@ -199,6 +199,16 @@ public long[] getArrayofU32(int n) { return ret; } + public int[] getArrayofS32() { + return getArrayofS32(buf.remaining() / 4); + } + + public int[] getArrayofS32(int n) { + int[] ret = new int[n]; + for (int i = 0; i < n; i++) ret[i] = getS32(); + return ret; + } + public float[] getArrayofFloat() { return getArrayofFloat(buf.remaining() / Float.BYTES); } @@ -360,6 +370,15 @@ public void putArrayofU32(long[] data, int n) { putArrayofU32(data); } + public void putArrayofS32(int[] data) { + for (int x : data) buf.putInt(x); + } + + public void putArrayofS32(int[] data, int n) { + assert (n == data.length); + putArrayofS32(data); + } + public void putArrayofDouble(double[] data) { for (double x : data) putDouble(x); } From 1d9c0779c95758d1e03ba00a0a526833bc14b116 Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Thu, 17 Nov 2022 11:32:00 -0800 Subject: [PATCH 8/9] Add missing Java tests --- .../sbp/navigation/MsgPoseRelative.java | 205 ++++++++++++++ ...ck_sbp_navigation_MsgPoseRelativeTest.java | 261 ++++++++++++++++++ 2 files changed, 466 insertions(+) create mode 100644 java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java create mode 100644 java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java b/java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java new file mode 100644 index 0000000000..d696a27525 --- /dev/null +++ b/java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java @@ -0,0 +1,205 @@ +/* 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 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.navigation; + +// This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import org.json.JSONArray; +import org.json.JSONObject; + +/** + * SBP class for message MSG_POSE_RELATIVE (0x0245). + * + *

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

This solution message reports the relative pose of a sensor between two time instances. The + * relative pose comprises of a rotation and a translation which relates the sensor (e.g. camera) + * frame at a given time (first keyframe) to the sensor frame at another time (second keyframe). The + * relative translations is a 3x1 vector described in the first keyframe. Relative rotation is + * described by a quaternion from second keyframe to the first keyframe. + */ +public class MsgPoseRelative extends SBPMessage { + public static final int TYPE = 0x0245; + + /** GPS Time of Week */ + public long tow; + + /** ID of the sensor producing this message */ + public int sensor_id; + + /** Timestamp of first keyframe */ + public long timestamp_1; + + /** Timestamp of second keyframe */ + public long timestamp_2; + + /** Relative translation [x,y,z] described in first keyframe */ + public int[] trans; + + /** Real component of quaternion to describe relative rotation (second to first keyframe) */ + public int w; + + /** + * 1st imaginary component of quaternion to describe relative rotation (second to first + * keyframe) + */ + public int x; + + /** + * 2nd imaginary component of quaternion to describe relative rotation (second to first + * keyframe) + */ + public int y; + + /** + * 3rd imaginary component of quaternion to describe relative rotation (second to first + * keyframe) + */ + public int z; + + /** Estimated variance of x (relative translation) */ + public float cov_r_x_x; + + /** Covariance of x and y (relative translation) */ + public float cov_r_x_y; + + /** Covariance of x and z (relative translation) */ + public float cov_r_x_z; + + /** Estimated variance of y (relative translation) */ + public float cov_r_y_y; + + /** Covariance of y and z (relative translation) */ + public float cov_r_y_z; + + /** Estimated variance of z (relative translation) */ + public float cov_r_z_z; + + /** Estimated variance of x (relative rotation) */ + public float cov_c_x_x; + + /** Covariance of x and y (relative rotation) */ + public float cov_c_x_y; + + /** Covariance of x and z (relative rotation) */ + public float cov_c_x_z; + + /** Estimated variance of y (relative rotation) */ + public float cov_c_y_y; + + /** Covariance of y and z (relative rotation) */ + public float cov_c_y_z; + + /** Estimated variance of z (relative rotation) */ + public float cov_c_z_z; + + /** Status flags of relative translation and rotation */ + public int flags; + + public MsgPoseRelative(int sender) { + super(sender, TYPE); + } + + public MsgPoseRelative() { + super(TYPE); + } + + public MsgPoseRelative(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + tow = parser.getU32(); + sensor_id = parser.getU8(); + timestamp_1 = parser.getU32(); + timestamp_2 = parser.getU32(); + trans = parser.getArrayofS32(3); + w = parser.getS32(); + x = parser.getS32(); + y = parser.getS32(); + z = parser.getS32(); + cov_r_x_x = parser.getFloat(); + cov_r_x_y = parser.getFloat(); + cov_r_x_z = parser.getFloat(); + cov_r_y_y = parser.getFloat(); + cov_r_y_z = parser.getFloat(); + cov_r_z_z = parser.getFloat(); + cov_c_x_x = parser.getFloat(); + cov_c_x_y = parser.getFloat(); + cov_c_x_z = parser.getFloat(); + cov_c_y_y = parser.getFloat(); + cov_c_y_z = parser.getFloat(); + cov_c_z_z = parser.getFloat(); + flags = parser.getU8(); + } + + @Override + protected void build(Builder builder) { + builder.putU32(tow); + builder.putU8(sensor_id); + builder.putU32(timestamp_1); + builder.putU32(timestamp_2); + builder.putArrayofS32(trans, 3); + builder.putS32(w); + builder.putS32(x); + builder.putS32(y); + builder.putS32(z); + builder.putFloat(cov_r_x_x); + builder.putFloat(cov_r_x_y); + builder.putFloat(cov_r_x_z); + builder.putFloat(cov_r_y_y); + builder.putFloat(cov_r_y_z); + builder.putFloat(cov_r_z_z); + builder.putFloat(cov_c_x_x); + builder.putFloat(cov_c_x_y); + builder.putFloat(cov_c_x_z); + builder.putFloat(cov_c_y_y); + builder.putFloat(cov_c_y_z); + builder.putFloat(cov_c_z_z); + builder.putU8(flags); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("tow", tow); + obj.put("sensor_id", sensor_id); + obj.put("timestamp_1", timestamp_1); + obj.put("timestamp_2", timestamp_2); + obj.put("trans", new JSONArray(trans)); + obj.put("w", w); + obj.put("x", x); + obj.put("y", y); + obj.put("z", z); + obj.put("cov_r_x_x", cov_r_x_x); + obj.put("cov_r_x_y", cov_r_x_y); + obj.put("cov_r_x_z", cov_r_x_z); + obj.put("cov_r_y_y", cov_r_y_y); + obj.put("cov_r_y_z", cov_r_y_z); + obj.put("cov_r_z_z", cov_r_z_z); + obj.put("cov_c_x_x", cov_c_x_x); + obj.put("cov_c_x_y", cov_c_x_y); + obj.put("cov_c_x_z", cov_c_x_z); + obj.put("cov_c_y_y", cov_c_y_y); + obj.put("cov_c_y_z", cov_c_y_z); + obj.put("cov_c_z_z", cov_c_z_z); + obj.put("flags", flags); + return obj; + } +} diff --git a/java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java b/java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java new file mode 100644 index 0000000000..d9c7874698 --- /dev/null +++ b/java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java @@ -0,0 +1,261 @@ +/* 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 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/navigation/test_MsgPoseRelative.yaml by generate.py. Do not modify +// by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.navigation.MsgPoseRelative; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_navigation_MsgPoseRelativeTest { + + 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_navigation_MsgPoseRelativeTest.test1"); + byte[] payload = + new byte[] { + (byte) 86, + (byte) 4, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 86, + (byte) 4, + (byte) 0, + (byte) 0, + (byte) 172, + (byte) 8, + (byte) 0, + (byte) 0, + (byte) 76, + (byte) 4, + (byte) 0, + (byte) 0, + (byte) 38, + (byte) 2, + (byte) 0, + (byte) 0, + (byte) 100, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 100, + (byte) 3, + (byte) 200, + (byte) 204, + (byte) 252, + (byte) 168, + (byte) 157, + (byte) 255, + (byte) 115, + (byte) 53, + (byte) 186, + (byte) 144, + (byte) 190, + (byte) 48, + (byte) 34, + (byte) 37, + (byte) 0, + (byte) 0, + (byte) 128, + (byte) 63, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 128, + (byte) 63, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 128, + (byte) 63, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 64, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 64, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 64, + (byte) 5, + }; + SBPMessage sbp = new SBPMessage(0x42, 0x245, payload); + MsgPoseRelative msg = new MsgPoseRelative(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + org.junit.Assert.assertEquals(msg.cov_c_x_x, 2.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_c_x_y, 0.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_c_x_z, 0.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_c_y_y, 2.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_c_y_z, 0.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_c_z_z, 2.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_r_x_x, 1.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_r_x_y, 0.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_r_x_z, 0.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_r_y_y, 1.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_r_y_z, 0.00000000000000000e+00, DELTA); + org.junit.Assert.assertEquals(msg.cov_r_z_z, 1.00000000000000000e+00, DELTA); + value = msg.flags; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.sensor_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.sensor_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.timestamp_1; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.timestamp_1 + "' != '" + 1110 + "'", + value.equals(BigInteger.valueOf(1110L))); + } else { + value = value.longValue(); + expected = 1110L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.timestamp_2; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.timestamp_2 + "' != '" + 2220 + "'", + value.equals(BigInteger.valueOf(2220L))); + } else { + value = value.longValue(); + expected = 2220L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.tow; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.tow + "' != '" + 1110 + "'", value.equals(BigInteger.valueOf(1110L))); + } else { + value = value.longValue(); + expected = 1110L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.trans[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.trans[0] + "' != '" + 1100 + "'", + value.equals(BigInteger.valueOf(1100L))); + } else { + value = value.longValue(); + expected = 1100L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.trans[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.trans[1] + "' != '" + 550 + "'", + value.equals(BigInteger.valueOf(550L))); + } else { + value = value.longValue(); + expected = 550L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.trans[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.trans[2] + "' != '" + 100 + "'", + value.equals(BigInteger.valueOf(100L))); + } else { + value = value.longValue(); + expected = 100L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.w; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.w + "' != '" + -859307164 + "'", + value.equals(BigInteger.valueOf(-859307164L))); + } else { + value = value.longValue(); + expected = -859307164L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.x; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.x + "' != '" + -6444804 + "'", + value.equals(BigInteger.valueOf(-6444804L))); + } else { + value = value.longValue(); + expected = -6444804L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.y; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.y + "' != '" + -1866844813 + "'", + value.equals(BigInteger.valueOf(-1866844813L))); + } else { + value = value.longValue(); + expected = -1866844813L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.z; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.z + "' != '" + 622997694 + "'", + value.equals(BigInteger.valueOf(622997694L))); + } else { + value = value.longValue(); + expected = 622997694L; + org.junit.Assert.assertEquals(value, expected); + } + } +} From 317bf5abae1e021770f24b37ba060ac2cbbf8a2d Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Thu, 17 Nov 2022 11:39:09 -0800 Subject: [PATCH 9/9] fix-up Rust --- rust/sbp/src/messages/navigation.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/sbp/src/messages/navigation.rs b/rust/sbp/src/messages/navigation.rs index 369488d7fc..41d24831e5 100644 --- a/rust/sbp/src/messages/navigation.rs +++ b/rust/sbp/src/messages/navigation.rs @@ -2151,7 +2151,7 @@ pub mod msg_pose_relative { /// This solution message reports the relative pose of a sensor between two /// time instances. The relative pose comprises of a rotation and a /// translation which relates the sensor (e.g. camera) frame at a given time - /// (first keyframe) to the sensor frame at another time (second key frame). + /// (first keyframe) to the sensor frame at another time (second keyframe). /// The relative translations is a 3x1 vector described in the first keyframe. /// Relative rotation is described by a quaternion from second keyframe to the /// first keyframe.