@wemap/providers 11.6.0 → 11.6.1

package/dist/index.js

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const geo = require("@wemap/geo");
 const maths = require("@wemap/maths");
 const routers = require("@wemap/routers");
@@ -13,10 +13,7 @@ const utils = require("@wemap/utils");
 const Logger = require("@wemap/logger");
 const geomag = require("geomag");
 const camera = require("@wemap/camera");
-const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-function _interopNamespace(e) {
-  if (e && e.__esModule)
-    return e;
+function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
     for (const k in e) {
@@ -32,8 +29,7 @@ function _interopNamespace(e) {
   n.default = e;
   return Object.freeze(n);
 }
-const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
-const geomag__namespace = /* @__PURE__ */ _interopNamespace(geomag);
+const geomag__namespace = /* @__PURE__ */ _interopNamespaceDefault(geomag);
 class RelativeAttitude extends geo.Attitude {
 }
 class AbsoluteAttitude extends geo.Attitude {
@@ -41,8 +37,21 @@ class AbsoluteAttitude extends geo.Attitude {
 class AbsolutePosition extends geo.UserPosition {
 }
 const ProvidersOptions = {
+  /**
+   * Does provider will use map to
+   */
   useMapMatching: true,
+  /**
+   * Providers listed here will not be used by the system
+   * List of {@link Provider#pname}
+   */
   ignoreProviders: [],
+  /**
+   * Some providers are not used by default (i.e. PoleStar) because they
+   * require data from an optional external service or because they drain more
+   * battery. They can be added to this list to be used
+   * List of {@link Provider#pname}
+   */
   optionalProviders: [],
   stopOnError: true,
   checkAvailabilityOnStart: true,
@@ -72,7 +81,7 @@ class ProvidersLoggerOld {
     }
     this.interval = window.setInterval(() => {
       for (const [key, value] of Object.entries(this.pushEvents)) {
-        Logger__default.default.debug("Received " + value + " notifications from " + this.pushEventsRef[Number(key)].getName() + " last second");
+        Logger.debug("Received " + value + " notifications from " + this.pushEventsRef[Number(key)].getName() + " last second");
       }
       this.pushEvents = {};
       this.pushEventsRef = {};
@@ -94,7 +103,7 @@ class ProvidersLoggerOld {
     this.initializeInterval();
     const objectId = this.getObjectId(object);
     const objectClassName = object.getName();
-    Logger__default.default.debug(objectClassName + "[" + objectId + "]." + method);
+    Logger.debug(objectClassName + "[" + objectId + "]." + method);
   }
   incrementNotifications(object) {
     if (!this.enabled) {
@@ -110,20 +119,26 @@ class ProvidersLoggerOld {
   }
 }
 const ProvidersLoggerOld$1 = new ProvidersLoggerOld();
-const _ContainsIgnoredProviderError = class extends Error {
+const _ContainsIgnoredProviderError = class _ContainsIgnoredProviderError extends Error {
   constructor(message) {
     super(message || _ContainsIgnoredProviderError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_ContainsIgnoredProviderError, "DEFAULT_MESSAGE", "Contains ignored provider");
 let ContainsIgnoredProviderError = _ContainsIgnoredProviderError;
-__publicField(ContainsIgnoredProviderError, "DEFAULT_MESSAGE", "Contains ignored provider");
-const _Provider = class {
+const _Provider = class _Provider {
+  /**
+   * Provider constructor
+   */
   constructor() {
     __publicField(this, "id");
     __publicField(this, "state", "stopped");
     __publicField(this, "_lastEvent", null);
     __publicField(this, "_eventsCallbacks", []);
     __publicField(this, "_monitoringCallbacks", []);
+    /**
+     * Notify the subscriber defined in {@link addEventListener}
+     */
     __publicField(this, "notify", (event) => {
       ProvidersLoggerOld$1.incrementNotifications(this);
       this._eventsCallbacks.forEach((cb) => {
@@ -132,6 +147,9 @@ const _Provider = class {
       });
       this._lastEvent = event;
     });
+    /**
+     * Notify the subscriber defined in {@link addEventListener}
+     */
     __publicField(this, "notifyError", (error) => {
       this._eventsCallbacks.forEach(({
         id,
@@ -146,6 +164,9 @@ const _Provider = class {
     this.id = _Provider._uniqueId++;
     ProvidersLoggerOld$1.addEvent(this, "constructor");
   }
+  /**
+   * Resolve with an error if the provider is not available
+   */
   getAvailability() {
     if (ProvidersOptions.ignoreProviders.includes(this.getName())) {
       return Promise.resolve(new ContainsIgnoredProviderError());
@@ -249,9 +270,9 @@ const _Provider = class {
     return this._lastEvent;
   }
 };
+__publicField(_Provider, "_callbackUniqueId", 0);
+__publicField(_Provider, "_uniqueId", 1);
 let Provider = _Provider;
-__publicField(Provider, "_callbackUniqueId", 0);
-__publicField(Provider, "_uniqueId", 1);
 class AvailabilityHelper {
   static async every(availabilityPromises) {
     for (const aPr of availabilityPromises) {
@@ -275,14 +296,14 @@ class AvailabilityHelper {
     return firstError || null;
   }
 }
-const _AskImuOnDesktopError = class extends Error {
+const _AskImuOnDesktopError = class _AskImuOnDesktopError extends Error {
   constructor(message) {
     super(message || _AskImuOnDesktopError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_AskImuOnDesktopError, "DEFAULT_MESSAGE", "It seems that you ask for IMU events on a desktop browser");
 let AskImuOnDesktopError = _AskImuOnDesktopError;
-__publicField(AskImuOnDesktopError, "DEFAULT_MESSAGE", "It seems that you ask for IMU events on a desktop browser");
-const _MissingSensorError = class extends Error {
+const _MissingSensorError = class _MissingSensorError extends Error {
   constructor(message) {
     super(message || _MissingSensorError.DEFAULT_MESSAGE);
   }
@@ -291,38 +312,38 @@ const _MissingSensorError = class extends Error {
     return this;
   }
 };
+__publicField(_MissingSensorError, "DEFAULT_MESSAGE", "Impossible to retrieve events, a sensor is missing");
 let MissingSensorError = _MissingSensorError;
-__publicField(MissingSensorError, "DEFAULT_MESSAGE", "Impossible to retrieve events, a sensor is missing");
 class MissingMagnetometerError extends MissingSensorError {
   constructor(message) {
     super(message);
   }
 }
-const _GeolocationApiMissingError = class extends Error {
+const _GeolocationApiMissingError = class _GeolocationApiMissingError extends Error {
   constructor(message) {
     super(message || _GeolocationApiMissingError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_GeolocationApiMissingError, "DEFAULT_MESSAGE", "Geolocation api is missing");
 let GeolocationApiMissingError = _GeolocationApiMissingError;
-__publicField(GeolocationApiMissingError, "DEFAULT_MESSAGE", "Geolocation api is missing");
-const _GeolocationPermissionDeniedError = class extends Error {
+const _GeolocationPermissionDeniedError = class _GeolocationPermissionDeniedError extends Error {
   constructor(message) {
     super(message || _GeolocationPermissionDeniedError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_GeolocationPermissionDeniedError, "DEFAULT_MESSAGE", "Geolocation permission denied");
 let GeolocationPermissionDeniedError = _GeolocationPermissionDeniedError;
-__publicField(GeolocationPermissionDeniedError, "DEFAULT_MESSAGE", "Geolocation permission denied");
-const _GeolocationPositionUnavailableError = class extends Error {
+const _GeolocationPositionUnavailableError = class _GeolocationPositionUnavailableError extends Error {
   constructor(message) {
     super(message || _GeolocationPositionUnavailableError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_GeolocationPositionUnavailableError, "DEFAULT_MESSAGE", "Geolocation position unavailable");
 let GeolocationPositionUnavailableError = _GeolocationPositionUnavailableError;
-__publicField(GeolocationPositionUnavailableError, "DEFAULT_MESSAGE", "Geolocation position unavailable");
 const Constants = {
   DEFAULT_ALTITUDE: 1.6
 };
-const _GnssWifiProvider = class extends Provider {
+const _GnssWifiProvider = class _GnssWifiProvider extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "discardPositionsAbove", _GnssWifiProvider.DEFAULT_DISCARD_POSITIONS_ABOVE);
@@ -353,7 +374,7 @@ const _GnssWifiProvider = class extends Provider {
       this.notify(position);
     });
     __publicField(this, "onPositionError", (error) => {
-      Logger__default.default.warn(`[Providers] watchPosition error: [${error.code}] ${error.message}`);
+      Logger.warn(`[Providers] watchPosition error: [${error.code}] ${error.message}`);
       let customError;
       switch (error.code) {
         case 1:
@@ -386,29 +407,29 @@ const _GnssWifiProvider = class extends Provider {
     }
   }
 };
-let GnssWifiProvider = _GnssWifiProvider;
-__publicField(GnssWifiProvider, "POSITION_OPTIONS", {
+__publicField(_GnssWifiProvider, "POSITION_OPTIONS", {
   enableHighAccuracy: true,
   timeout: Infinity,
   maximumAge: 0
 });
-__publicField(GnssWifiProvider, "DEFAULT_DISCARD_POSITIONS_ABOVE", 50);
+__publicField(_GnssWifiProvider, "DEFAULT_DISCARD_POSITIONS_ABOVE", 50);
+let GnssWifiProvider = _GnssWifiProvider;
 const GnssWifiProvider$1 = new GnssWifiProvider();
-const _MissingArCoreError = class extends Error {
+const _MissingArCoreError = class _MissingArCoreError extends Error {
   constructor(message) {
     super(message || _MissingArCoreError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_MissingArCoreError, "DEFAULT_MESSAGE", "ARCore is missing");
 let MissingArCoreError = _MissingArCoreError;
-__publicField(MissingArCoreError, "DEFAULT_MESSAGE", "ARCore is missing");
-const _MissingNativeInterfaceError = class extends Error {
+const _MissingNativeInterfaceError = class _MissingNativeInterfaceError extends Error {
   constructor(message) {
     super(message || _MissingNativeInterfaceError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_MissingNativeInterfaceError, "DEFAULT_MESSAGE", "Native interface is missing. You are maybe trying to execute a code which is not available in a web browser");
 let MissingNativeInterfaceError = _MissingNativeInterfaceError;
-__publicField(MissingNativeInterfaceError, "DEFAULT_MESSAGE", "Native interface is missing. You are maybe trying to execute a code which is not available in a web browser");
-const _ArCoreProvider = class extends Provider {
+const _ArCoreProvider = class _ArCoreProvider extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "_nativeProvider");
@@ -516,8 +537,7 @@ const _ArCoreProvider = class extends Provider {
     return true;
   }
 };
-let ArCoreProvider = _ArCoreProvider;
-__publicField(ArCoreProvider, "Payload", {
+__publicField(_ArCoreProvider, "Payload", {
   Pose: {
     ref: 2 ** 0,
     size: 7
@@ -535,7 +555,11 @@ __publicField(ArCoreProvider, "Payload", {
     size: 1
   }
 });
-__publicField(ArCoreProvider, "RELATIVE_ATTITUDE_DRIFT", maths.deg2rad(3) / 60);
+/**
+ * default relative attitude drift in rad.second-1
+ */
+__publicField(_ArCoreProvider, "RELATIVE_ATTITUDE_DRIFT", maths.deg2rad(3) / 60);
+let ArCoreProvider = _ArCoreProvider;
 const ArCoreProvider$1 = new ArCoreProvider();
 class GeoRelativePositionFromArCoreProvider extends Provider {
   constructor() {
@@ -626,6 +650,10 @@ class EkfAttitude {
       yc: maths.Matrix3.diag(Array(3).fill(absoluteNoises.yc ** 2))
     };
   }
+  /**
+   * Try to initialize filter.
+   * To initialize, we need at least current acceleration (acc)
+   */
   tryInitialize(acc, mag) {
     const accNormalized = maths.Vector3.normalize(acc);
     if (mag) {
@@ -756,6 +784,9 @@ class ImuProvider extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "getName", () => "IMU");
+    /**
+     * devicemotion callback
+     */
     __publicField(this, "parseDeviceMotionEvent", (e) => {
       const timestamp = e.timeStamp / 1e3;
       let acc;
@@ -815,13 +846,13 @@ class ImuProvider extends Provider {
   }
 }
 const ImuProvider$1 = new ImuProvider();
-const _MissingAccelerometerError = class extends MissingSensorError {
+const _MissingAccelerometerError = class _MissingAccelerometerError extends MissingSensorError {
   constructor(message) {
     super(message || _MissingAccelerometerError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_MissingAccelerometerError, "DEFAULT_MESSAGE", "Impossible to retrieve Acceleration data");
 let MissingAccelerometerError = _MissingAccelerometerError;
-__publicField(MissingAccelerometerError, "DEFAULT_MESSAGE", "Impossible to retrieve Acceleration data");
 class AccelerometerProvider extends Provider {
   constructor() {
     super(...arguments);
@@ -862,7 +893,7 @@ class GyroscopeProvider extends Provider {
   }
 }
 const GyroscopeProvider$1 = new GyroscopeProvider();
-const _RelativeAttitudeFromEkf = class extends Provider {
+const _RelativeAttitudeFromEkf = class _RelativeAttitudeFromEkf extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "accelerometerProviderId");
@@ -921,10 +952,13 @@ const _RelativeAttitudeFromEkf = class extends Provider {
     GyroscopeProvider$1.removeEventListener(this.gyroscopeProviderId);
   }
 };
+/**
+ * default relative attitude drift in rad.second-1
+ */
+__publicField(_RelativeAttitudeFromEkf, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
 let RelativeAttitudeFromEkf = _RelativeAttitudeFromEkf;
-__publicField(RelativeAttitudeFromEkf, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
 const RelativeAttitudeFromEkfProvider = new RelativeAttitudeFromEkf();
-const _RelativeAttitudeFromBrowser = class extends Provider {
+const _RelativeAttitudeFromBrowser = class _RelativeAttitudeFromBrowser extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "getName", () => "RelativeAttitudeFromBrowser");
@@ -963,12 +997,16 @@ const _RelativeAttitudeFromBrowser = class extends Provider {
     window.removeEventListener("deviceorientation", this.onDeviceOrientationEvent, true);
   }
 };
+/**
+ * default relative attitude drift in rad.second-1
+ */
+__publicField(_RelativeAttitudeFromBrowser, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
 let RelativeAttitudeFromBrowser = _RelativeAttitudeFromBrowser;
-__publicField(RelativeAttitudeFromBrowser, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
 const RelativeAttitudeFromBrowser$1 = new RelativeAttitudeFromBrowser();
-const _HighRotationsProvider = class extends Provider {
+const _HighRotationsProvider = class _HighRotationsProvider extends Provider {
   constructor() {
     super(...arguments);
+    // in seconds
     __publicField(this, "gyroscopeProviderId");
     __publicField(this, "getName", () => "HighRotationsProvider");
     __publicField(this, "availability", () => GyroscopeProvider$1.getAvailability());
@@ -997,11 +1035,12 @@ const _HighRotationsProvider = class extends Provider {
     return diffTime < _HighRotationsProvider.DELAY_CONSIDERATION;
   }
 };
+__publicField(_HighRotationsProvider, "THRESHOLD", 10);
+// in radians by second
+__publicField(_HighRotationsProvider, "DELAY_CONSIDERATION", 3);
 let HighRotationsProvider = _HighRotationsProvider;
-__publicField(HighRotationsProvider, "THRESHOLD", 10);
-__publicField(HighRotationsProvider, "DELAY_CONSIDERATION", 3);
 const HighRotationsProvider$1 = new HighRotationsProvider();
-const _RelativeAttitudeFromInertial = class extends Provider {
+const _RelativeAttitudeFromInertial = class _RelativeAttitudeFromInertial extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "_highRotationsProviderId");
@@ -1045,11 +1084,15 @@ const _RelativeAttitudeFromInertial = class extends Provider {
     HighRotationsProvider$1.removeEventListener(this._highRotationsProviderId);
   }
 };
+/**
+ * default relative attitude drift in rad.second-1
+ */
+__publicField(_RelativeAttitudeFromInertial, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
 let RelativeAttitudeFromInertial = _RelativeAttitudeFromInertial;
-__publicField(RelativeAttitudeFromInertial, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
 const RelativeAttitudeFromInertialProvider = new RelativeAttitudeFromInertial();
-const _StepDetectionLadetto = class {
+const _StepDetectionLadetto = class _StepDetectionLadetto {
   constructor() {
+    // in m.s-2
     __publicField(this, "frequency", 0);
     __publicField(this, "lastVerticalAcc", 0);
     __publicField(this, "maxAcceleration", 0);
@@ -1088,13 +1131,17 @@ const _StepDetectionLadetto = class {
     return this.lastStepTimestamp ? this.lastStepSize * this.frequency : 0;
   }
 };
+__publicField(_StepDetectionLadetto, "MIN_TIME_BETWEEN_STEPS", 0.4);
+// in seconds
+__publicField(_StepDetectionLadetto, "MAX_FRENQUENCY", 4);
+// in Hz
+__publicField(_StepDetectionLadetto, "MIN_FRENQUENCY", 1);
+// in Hz
+__publicField(_StepDetectionLadetto, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 1);
 let StepDetectionLadetto = _StepDetectionLadetto;
-__publicField(StepDetectionLadetto, "MIN_TIME_BETWEEN_STEPS", 0.4);
-__publicField(StepDetectionLadetto, "MAX_FRENQUENCY", 4);
-__publicField(StepDetectionLadetto, "MIN_FRENQUENCY", 1);
-__publicField(StepDetectionLadetto, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 1);
-const _StepDetectionMinMaxPeaks = class {
+const _StepDetectionMinMaxPeaks = class _StepDetectionMinMaxPeaks {
   constructor() {
+    // in m.s-2
     __publicField(this, "frequency", 0);
     __publicField(this, "lastStepTimestamp", -_StepDetectionMinMaxPeaks.MIN_TIME_BETWEEN_STEPS);
     __publicField(this, "slidingWindow", []);
@@ -1138,15 +1185,21 @@ const _StepDetectionMinMaxPeaks = class {
     return this.lastStepTimestamp ? this.lastStepSize * this.frequency : 0;
   }
 };
+__publicField(_StepDetectionMinMaxPeaks, "WINDOW_TIME", 0.3);
+// in seconds
+__publicField(_StepDetectionMinMaxPeaks, "MIN_TIME_BETWEEN_STEPS", 0.4);
+// in seconds
+__publicField(_StepDetectionMinMaxPeaks, "MAX_FRENQUENCY", 4);
+// in Hz
+__publicField(_StepDetectionMinMaxPeaks, "MIN_FRENQUENCY", 1);
+// in Hz
+__publicField(_StepDetectionMinMaxPeaks, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 1.5);
+// in m.s-2
+__publicField(_StepDetectionMinMaxPeaks, "VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD", -1);
 let StepDetectionMinMaxPeaks = _StepDetectionMinMaxPeaks;
-__publicField(StepDetectionMinMaxPeaks, "WINDOW_TIME", 0.3);
-__publicField(StepDetectionMinMaxPeaks, "MIN_TIME_BETWEEN_STEPS", 0.4);
-__publicField(StepDetectionMinMaxPeaks, "MAX_FRENQUENCY", 4);
-__publicField(StepDetectionMinMaxPeaks, "MIN_FRENQUENCY", 1);
-__publicField(StepDetectionMinMaxPeaks, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 1.5);
-__publicField(StepDetectionMinMaxPeaks, "VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD", -1);
-const _StepDetectionMinMaxPeaks2 = class {
+const _StepDetectionMinMaxPeaks2 = class _StepDetectionMinMaxPeaks2 {
   constructor() {
+    // in m.s-2
     __publicField(this, "frequency", 0);
     __publicField(this, "influence", 0.2);
     __publicField(this, "slidingWindow", []);
@@ -1212,15 +1265,21 @@ const _StepDetectionMinMaxPeaks2 = class {
     return Math.sqrt(standardDeviation / data.length);
   }
 };
+__publicField(_StepDetectionMinMaxPeaks2, "WINDOW_TIME", 0.3);
+// in seconds
+__publicField(_StepDetectionMinMaxPeaks2, "MIN_TIME_BETWEEN_STEPS", 0.4);
+// in seconds
+__publicField(_StepDetectionMinMaxPeaks2, "MAX_FRENQUENCY", 4);
+// in Hz
+__publicField(_StepDetectionMinMaxPeaks2, "MIN_FRENQUENCY", 1);
+// in Hz
+__publicField(_StepDetectionMinMaxPeaks2, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 0.75);
+// in m.s-2
+__publicField(_StepDetectionMinMaxPeaks2, "VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD", -0.3);
 let StepDetectionMinMaxPeaks2 = _StepDetectionMinMaxPeaks2;
-__publicField(StepDetectionMinMaxPeaks2, "WINDOW_TIME", 0.3);
-__publicField(StepDetectionMinMaxPeaks2, "MIN_TIME_BETWEEN_STEPS", 0.4);
-__publicField(StepDetectionMinMaxPeaks2, "MAX_FRENQUENCY", 4);
-__publicField(StepDetectionMinMaxPeaks2, "MIN_FRENQUENCY", 1);
-__publicField(StepDetectionMinMaxPeaks2, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 0.75);
-__publicField(StepDetectionMinMaxPeaks2, "VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD", -0.3);
-const _StepDetectionMinMaxPeaks3 = class {
+const _StepDetectionMinMaxPeaks3 = class _StepDetectionMinMaxPeaks3 {
   constructor() {
+    // in m.s-2
     __publicField(this, "frequency", 0);
     __publicField(this, "influence", 0.05);
     __publicField(this, "slidingWindow", []);
@@ -1310,14 +1369,19 @@ const _StepDetectionMinMaxPeaks3 = class {
     return Math.sqrt(standardDeviation / data.length);
   }
 };
+__publicField(_StepDetectionMinMaxPeaks3, "WINDOW_TIME", 0.6);
+// in seconds
+__publicField(_StepDetectionMinMaxPeaks3, "MIN_TIME_BETWEEN_STEPS", 0.6);
+// in seconds
+__publicField(_StepDetectionMinMaxPeaks3, "MAX_FRENQUENCY", 4);
+// in Hz
+__publicField(_StepDetectionMinMaxPeaks3, "MIN_FRENQUENCY", 1);
+// in Hz
+__publicField(_StepDetectionMinMaxPeaks3, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 0.2);
+// in m.s-2
+__publicField(_StepDetectionMinMaxPeaks3, "VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD", -0.1);
 let StepDetectionMinMaxPeaks3 = _StepDetectionMinMaxPeaks3;
-__publicField(StepDetectionMinMaxPeaks3, "WINDOW_TIME", 0.6);
-__publicField(StepDetectionMinMaxPeaks3, "MIN_TIME_BETWEEN_STEPS", 0.6);
-__publicField(StepDetectionMinMaxPeaks3, "MAX_FRENQUENCY", 4);
-__publicField(StepDetectionMinMaxPeaks3, "MIN_FRENQUENCY", 1);
-__publicField(StepDetectionMinMaxPeaks3, "VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD", 0.2);
-__publicField(StepDetectionMinMaxPeaks3, "VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD", -0.1);
-const _StepProvider = class extends Provider {
+const _StepProvider = class _StepProvider extends Provider {
   constructor() {
     super();
     __publicField(this, "accelerometerProviderId");
@@ -1379,6 +1443,7 @@ const _StepProvider = class extends Provider {
     GyroscopeProvider$1.removeEventListener(this.gyroscopeProviderId);
     RelativeAttitudeFromInertialProvider.removeEventListener(this.attitudeProviderId);
   }
+  // Linear acceleration in ENU
   static computeLinearAcceleration(quaternion, acc) {
     const linearAcc = maths.Quaternion.rotateMatlab(maths.Quaternion.inverse(quaternion), acc);
     linearAcc[2] -= geo.Constants.EARTH_GRAVITY;
@@ -1413,9 +1478,9 @@ const _StepProvider = class extends Provider {
     return this._algorithm;
   }
 };
+__publicField(_StepProvider, "DEFAULT_STEP_SIZE_MULTIPLIER", 1);
+__publicField(_StepProvider, "DEFAULT_ALGORITHM", "minMaxPeaks3");
 let StepProvider = _StepProvider;
-__publicField(StepProvider, "DEFAULT_STEP_SIZE_MULTIPLIER", 1);
-__publicField(StepProvider, "DEFAULT_ALGORITHM", "minMaxPeaks3");
 const StepProvider$1 = new StepProvider();
 class PdrProvider extends Provider {
   constructor() {
@@ -1423,6 +1488,8 @@ class PdrProvider extends Provider {
     __publicField(this, "absoluteAttitudeProviderId");
     __publicField(this, "stepDetectionProviderId");
     __publicField(this, "attitudeEvent");
+    // https://ieeexplore.ieee.org/document/7346766
+    // private misalignment = [1, 0, 0, 0];
     __publicField(this, "misalignmentError", maths.deg2rad(3));
     __publicField(this, "getName", () => "Pdr");
     __publicField(this, "onStepEvent", (stepEvent) => {
@@ -1705,7 +1772,7 @@ class ImageRelocalization {
     let serverResponse;
     try {
       const body = JSON.stringify(vpsRequest.toJson());
-      Logger__default.default.debug(`[VPS] Request (${(body.length / 1024).toFixed(0)} kB) sent to server ${endpointUrl}`);
+      Logger.debug(`[VPS] Request (${(body.length / 1024).toFixed(0)} kB) sent to server ${endpointUrl}`);
       serverResponse = await fetch(endpointUrl, {
         method: "POST",
         body,
@@ -1715,16 +1782,16 @@ class ImageRelocalization {
         )
       });
     } catch (e) {
-      Logger__default.default.debug("[VPS] Server respond error");
+      Logger.debug("[VPS] Server respond error");
       return null;
     }
     if (serverResponse.status !== 200) {
-      Logger__default.default.debug("[VPS] Server respond error");
+      Logger.debug("[VPS] Server respond error");
       return null;
     }
     const json = await serverResponse.json();
     const res = VpsResponse.fromJson(json, timeBeforeRequest);
-    Logger__default.default.debug(`[VPS] Server respond ${res.success ? "success" : "not found"}`);
+    Logger.debug(`[VPS] Server respond ${res.success ? "success" : "not found"}`);
     return res;
   }
   static getHeadingFromQuaternion(quaternion) {
@@ -1754,12 +1821,12 @@ class RelativeRotationCalc {
   }
   tickEnd() {
     if (!this._isRunning) {
-      Logger__default.default.warn("You have to call tickStart before tickEnd");
+      Logger.warn("You have to call tickStart before tickEnd");
       return null;
     }
     this._internalStop();
     if (!this._dataOnStart) {
-      Logger__default.default.warn("Delay was too short between tickStart and tickEnd or RelativeAttitudeProvider cannot be retrieved.");
+      Logger.warn("Delay was too short between tickStart and tickEnd or RelativeAttitudeProvider cannot be retrieved.");
       return null;
     }
     const dataOnEnd = RelativeAttitudeFromBrowser$1.lastEvent;
@@ -1776,13 +1843,13 @@ class RelativeRotationCalc {
     }
   }
 }
-const _MissingPoleStarError = class extends Error {
+const _MissingPoleStarError = class _MissingPoleStarError extends Error {
   constructor(message) {
     super(message || _MissingPoleStarError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_MissingPoleStarError, "DEFAULT_MESSAGE", "PoleStar is missing");
 let MissingPoleStarError = _MissingPoleStarError;
-__publicField(MissingPoleStarError, "DEFAULT_MESSAGE", "PoleStar is missing");
 class PoleStarProvider extends Provider {
   constructor() {
     super();
@@ -1840,7 +1907,7 @@ class PoleStarProvider extends Provider {
   }
 }
 const PoleStarProvider$1 = new PoleStarProvider();
-const _VpsProvider = class extends Provider {
+const _VpsProvider = class _VpsProvider extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "_relativeRotationCalc");
@@ -1856,7 +1923,7 @@ const _VpsProvider = class extends Provider {
     __publicField(this, "availability", () => camera.Camera.checkAvailability());
     __publicField(this, "_onCameraDetected", ({ camera: camera2 }) => {
       if (this._camera) {
-        Logger__default.default.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
+        Logger.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
       }
       this._useCamera(camera2);
     });
@@ -1865,7 +1932,7 @@ const _VpsProvider = class extends Provider {
         this._camera.off("started", this._internalStart);
         this._camera.off("stopped", this._internalStop);
       } else {
-        Logger__default.default.warn("There is no previously detected camera but once has stopped");
+        Logger.warn("There is no previously detected camera but once has stopped");
       }
       this._camera = null;
     });
@@ -1951,7 +2018,7 @@ const _VpsProvider = class extends Provider {
     camera.SharedCameras.on("removed", this._onCameraRemoved);
     if (camera.SharedCameras.list.length) {
       if (camera.SharedCameras.list.length > 1) {
-        Logger__default.default.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
+        Logger.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
       }
       this._useCamera(camera.SharedCameras.list[0].camera);
     }
@@ -1997,14 +2064,17 @@ const _VpsProvider = class extends Provider {
     this._useCoarsePose = useCoarsePose;
   }
 };
+__publicField(_VpsProvider, "MIN_TIME_BETWEEN_TWO_REQUESTS", 1e3);
+// in ms
+__publicField(_VpsProvider, "DEFAULT_MIN_INCLINATION_FOR_REQUEST", maths.deg2rad(60));
+// in radians
+__publicField(_VpsProvider, "DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST", 200);
+// in ms
+__publicField(_VpsProvider, "DEFAULT_USE_COARSE_POSE", true);
+__publicField(_VpsProvider, "CAMERA_TO_SMARTPHONE_ROT", maths.Quaternion.fromAxisAngle([1, 0, 0], Math.PI));
 let VpsProvider = _VpsProvider;
-__publicField(VpsProvider, "MIN_TIME_BETWEEN_TWO_REQUESTS", 1e3);
-__publicField(VpsProvider, "DEFAULT_MIN_INCLINATION_FOR_REQUEST", maths.deg2rad(60));
-__publicField(VpsProvider, "DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST", 200);
-__publicField(VpsProvider, "DEFAULT_USE_COARSE_POSE", true);
-__publicField(VpsProvider, "CAMERA_TO_SMARTPHONE_ROT", maths.Quaternion.fromAxisAngle([1, 0, 0], Math.PI));
 const VpsProvider$1 = new VpsProvider();
-const _AbsolutePositionProvider = class extends Provider {
+const _AbsolutePositionProvider = class _AbsolutePositionProvider extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "_polestarProviderId");
@@ -2059,6 +2129,9 @@ const _AbsolutePositionProvider = class extends Provider {
     }
     this._mapMatchingHandlerId = MapMatchingHandler$1.addEventListener();
   }
+  /**
+   * @override
+   */
   stop() {
     if (this._relativePositionProviderId) {
       GeoRelativePositionProvider$1.removeEventListener(this._relativePositionProviderId);
@@ -2102,6 +2175,9 @@ const _AbsolutePositionProvider = class extends Provider {
     }
     return false;
   }
+  /**
+   * @returns if input position is used by the system (true = used, false = discarded)
+   */
   _onAbsolutePosition(positionEvent, canContainLevel = true) {
     if (!this._shouldTakeIntoAccountNewAbsolutePosition(positionEvent, canContainLevel) && !this.useAllAbsolutePositions) {
       return false;
@@ -2122,6 +2198,9 @@ const _AbsolutePositionProvider = class extends Provider {
     }
     return MapMatchingHandler$1.notifyPositionFromAbsolute(newPosition);
   }
+  /**
+   * @returns if input position is used by the system (true = used, false = discarded)
+   */
   _onRelativePosition(relativeEvent) {
     if (!this.lastEvent || this._waitUntilNextVpsPosition) {
       return false;
@@ -2174,13 +2253,16 @@ const _AbsolutePositionProvider = class extends Provider {
     }, null);
   }
 };
+// Use the new absolute position if its accuracy is at least x times better than the last one.
+__publicField(_AbsolutePositionProvider, "ACCURACY_RELOC_RATIO", 1);
+// or 1.5
+__publicField(_AbsolutePositionProvider, "USE_MM_FOR_FEED", true);
 let AbsolutePositionProvider = _AbsolutePositionProvider;
-__publicField(AbsolutePositionProvider, "ACCURACY_RELOC_RATIO", 1);
-__publicField(AbsolutePositionProvider, "USE_MM_FOR_FEED", true);
 const AbsolutePositionProvider$1 = new AbsolutePositionProvider();
 class AbsoluteAttitudeFromBrowser extends Provider {
   constructor() {
     super(...arguments);
+    // from http://tyrex.inria.fr/mobile/benchmarks-attitude/
     __publicField(this, "DEFAULT_ACCURACY", maths.deg2rad(15));
     __publicField(this, "absolutePositionProviderId");
     __publicField(this, "absolutePositionEvent");
@@ -2239,6 +2321,11 @@ class AbsoluteAttitudeFromBrowser extends Provider {
       this.magQuaternion = maths.Rotations.eulerToQuaternionZXYDegrees([alpha, e.beta, e.gamma]);
       this.compute();
     });
+    /**
+     * Initialized declination quaternion using current position.
+     * This method should be theoretically called every time the user moves.
+     * But in reality declination does not change as much.
+     */
     __publicField(this, "onAbsolutePositionEvent", (position) => {
       this.absolutePositionEvent = position;
       const wmmResult = geomag__namespace.field(position.lat, position.lng);
@@ -2382,6 +2469,9 @@ class RelativeAttitudeProvider extends Provider {
       this.listenInertial();
     }
   }
+  /**
+   * @override
+   */
   stop() {
     ArCoreProvider$1.removeMonitoringListener(this.arCoreMonitoringId);
     this.unlistenArCore();
@@ -2389,9 +2479,10 @@ class RelativeAttitudeProvider extends Provider {
   }
 }
 const RelativeAttitudeProvider$1 = new RelativeAttitudeProvider();
-const _AbsoluteAttitudeProvider = class extends Provider {
+const _AbsoluteAttitudeProvider = class _AbsoluteAttitudeProvider extends Provider {
   constructor() {
     super(...arguments);
+    // in radians;
     __publicField(this, "_absAttitudeFromBrowser");
     __publicField(this, "_vpsProviderId");
     __publicField(this, "fromBrowserProviderId");
@@ -2400,8 +2491,12 @@ const _AbsoluteAttitudeProvider = class extends Provider {
     __publicField(this, "relativeAttitudeProviderId");
     __publicField(this, "_attitudeFromBrowserErrored", false);
     __publicField(this, "_attitudeFromRelativeErrored", false);
+    /*
+     * RELATIVE
+     */
     __publicField(this, "_relativeAttitude", null);
     __publicField(this, "_relativeAccuracy", 0);
+    // in radians/s
     __publicField(this, "_lastForcedHeadingEvent");
     __publicField(this, "_relAbsQuat");
     __publicField(this, "_wasHighRotationInProgress", false);
@@ -2557,14 +2652,17 @@ const _AbsoluteAttitudeProvider = class extends Provider {
     }
   }
 };
+__publicField(_AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_ANGLE_THRESHOLD", maths.deg2rad(25));
+// in radians;
+__publicField(_AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_TIME_THRESHOLD", 2.5);
+// in seconds
+__publicField(_AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD", maths.deg2rad(15));
 let AbsoluteAttitudeProvider = _AbsoluteAttitudeProvider;
-__publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_ANGLE_THRESHOLD", maths.deg2rad(25));
-__publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_TIME_THRESHOLD", 2.5);
-__publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD", maths.deg2rad(15));
 const AbsoluteAttitudeProvider$1 = new AbsoluteAttitudeProvider();
-const _TurnProvider = class extends Provider {
+const _TurnProvider = class _TurnProvider extends Provider {
   constructor() {
     super(...arguments);
+    // in seconds
     __publicField(this, "providerId");
     __publicField(this, "slidingWindow", []);
     __publicField(this, "getName", () => "Turn");
@@ -2597,12 +2695,13 @@ const _TurnProvider = class extends Provider {
     return diffTime < _TurnProvider.CONSIDER_TURN_UNTIL;
   }
 };
+__publicField(_TurnProvider, "SLIDING_WINDOW_TIME", 0.3);
+// in seconds
+__publicField(_TurnProvider, "STD_THRESHOLD", 0.075);
+__publicField(_TurnProvider, "CONSIDER_TURN_UNTIL", 1);
 let TurnProvider = _TurnProvider;
-__publicField(TurnProvider, "SLIDING_WINDOW_TIME", 0.3);
-__publicField(TurnProvider, "STD_THRESHOLD", 0.075);
-__publicField(TurnProvider, "CONSIDER_TURN_UNTIL", 1);
 const TurnProvider$1 = new TurnProvider();
-const _StraightLineProvider = class extends Provider {
+const _StraightLineProvider = class _StraightLineProvider extends Provider {
   constructor() {
     super(...arguments);
     __publicField(this, "_turnProviderId");
@@ -2650,12 +2749,13 @@ const _StraightLineProvider = class extends Provider {
     this._stepsConsideredForStraightLine = stepsConsideredForStraightLine;
   }
 };
+__publicField(_StraightLineProvider, "DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE", 2);
 let StraightLineProvider = _StraightLineProvider;
-__publicField(StraightLineProvider, "DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE", 2);
 const StraightLineProvider$1 = new StraightLineProvider();
-const _MapMatchingHandler = class extends Provider {
+const _MapMatchingHandler = class _MapMatchingHandler extends Provider {
   constructor() {
     super();
+    // radians
     __publicField(this, "_mapMatchingMinDistance", _MapMatchingHandler.DEFAULT_MM_MIN_DIST);
     __publicField(this, "_useItineraryStartAsPosition", _MapMatchingHandler.DEFAULT_USE_ITINERARY_START_AS_POSITION);
     __publicField(this, "_useOrientationMatching", _MapMatchingHandler.DEFAULT_USE_ORIENTATION_MATCHING);
@@ -2774,6 +2874,9 @@ const _MapMatchingHandler = class extends Provider {
     }
     AbsolutePositionProvider$1.notify(projection.coords);
   }
+  /**
+   * @returns if input position is used by the system (true = used, false = discarded)
+   */
   notifyPositionFromAbsolute(newPosition) {
     let projectionWithBearing = null;
     if (newPosition.bearing !== null) {
@@ -2794,6 +2897,9 @@ const _MapMatchingHandler = class extends Provider {
     this.tryOrientationMatching(projectionWithBearing);
     return true;
   }
+  /**
+   * @returns if input position is used by the system (true = used, false = discarded)
+   */
   notifyPositionFromRelative(newPosition) {
     var _a;
     if (TurnProvider$1.isTurning()) {
@@ -2921,6 +3027,7 @@ const _MapMatchingHandler = class extends Provider {
       matchingDirection,
       origin.time,
       0
+      // Math.min(Math.abs(matchingDirectionAngle1), Math.abs(matchingDirectionAngle2))
     );
     AbsoluteAttitudeProvider$1._forceHeadingForRelative(matchedHeading);
     this._countStepsFromLastMatching = 0;
@@ -2995,20 +3102,29 @@ const _MapMatchingHandler = class extends Provider {
     this._lastProjectionsEdgeAngleThreshold = lastProjectionsEdgeAngleThreshold;
   }
 };
+__publicField(_MapMatchingHandler, "DEFAULT_MM_MAX_ANGLE", maths.deg2rad(30));
+// radians
+__publicField(_MapMatchingHandler, "DEFAULT_MM_MAX_DIST", 30);
+// meters
+__publicField(_MapMatchingHandler, "DEFAULT_MM_MIN_DIST", 0);
+// meters
+__publicField(_MapMatchingHandler, "DEFAULT_USE_ITINERARY_START_AS_POSITION", false);
+__publicField(_MapMatchingHandler, "DEFAULT_USE_ORIENTATION_MATCHING", true);
+__publicField(_MapMatchingHandler, "DEFAULT_MM_HUGE_JUMP_DISTANCE", 3);
+// meters
+__publicField(_MapMatchingHandler, "DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE", 2);
+// meters
+__publicField(_MapMatchingHandler, "DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING", 3);
+__publicField(_MapMatchingHandler, "DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING", 5);
+__publicField(_MapMatchingHandler, "DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE", 3);
+__publicField(_MapMatchingHandler, "DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD", maths.deg2rad(3));
 let MapMatchingHandler = _MapMatchingHandler;
-__publicField(MapMatchingHandler, "DEFAULT_MM_MAX_ANGLE", maths.deg2rad(30));
-__publicField(MapMatchingHandler, "DEFAULT_MM_MAX_DIST", 30);
-__publicField(MapMatchingHandler, "DEFAULT_MM_MIN_DIST", 0);
-__publicField(MapMatchingHandler, "DEFAULT_USE_ITINERARY_START_AS_POSITION", false);
-__publicField(MapMatchingHandler, "DEFAULT_USE_ORIENTATION_MATCHING", true);
-__publicField(MapMatchingHandler, "DEFAULT_MM_HUGE_JUMP_DISTANCE", 3);
-__publicField(MapMatchingHandler, "DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE", 2);
-__publicField(MapMatchingHandler, "DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING", 3);
-__publicField(MapMatchingHandler, "DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING", 5);
-__publicField(MapMatchingHandler, "DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE", 3);
-__publicField(MapMatchingHandler, "DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD", maths.deg2rad(3));
 const MapMatchingHandler$1 = new MapMatchingHandler();
-const _PositionSmoother = class {
+const _PositionSmoother = class _PositionSmoother {
+  // can be number if web or NodeJS.Timer
+  /**
+   * @param frequency in Hz
+   */
   constructor(callback, frequency = _PositionSmoother.DEFAULT_FREQUENCY) {
     __publicField(this, "positionsQueue", []);
     __publicField(this, "previousPosition", null);
@@ -3027,6 +3143,9 @@ const _PositionSmoother = class {
     this.callback = callback;
     this.frequency = frequency;
   }
+  /**
+   * @param flybyTime in seconds
+   */
   feed(newPosition, flybyTime = _PositionSmoother.DEFAULT_FLYBY_TIME) {
     if (!(newPosition instanceof geo.UserPosition)) {
       throw new TypeError("newPosition is not instance of UserPosition");
@@ -3075,11 +3194,14 @@ const _PositionSmoother = class {
     this.positionsQueue = [];
   }
 };
+// Generated positions by second
+__publicField(_PositionSmoother, "DEFAULT_FREQUENCY", 60);
+// flyby (in second)
+__publicField(_PositionSmoother, "DEFAULT_FLYBY_TIME", 1);
 let PositionSmoother = _PositionSmoother;
-__publicField(PositionSmoother, "DEFAULT_FREQUENCY", 60);
-__publicField(PositionSmoother, "DEFAULT_FLYBY_TIME", 1);
-const _AttitudeSmoother = class {
+const _AttitudeSmoother = class _AttitudeSmoother {
   constructor(callback) {
+    // in radians/s
     __publicField(this, "_previousAttitude");
     __publicField(this, "_smoothing", null);
     this.callback = callback;
@@ -3126,6 +3248,11 @@ const _AttitudeSmoother = class {
     }
     this.callback(newAttitude);
   }
+  /**
+   * @param {Attitude} previousAttitude
+   * @param {Attitude} newAttitude
+   * @returns {boolean}
+   */
   static isJump(previousAttitude, newAttitude) {
     const fromHeading = previousAttitude.heading;
     const toHeading = newAttitude.heading;
@@ -3139,12 +3266,16 @@ const _AttitudeSmoother = class {
     return Math.abs(diffAngleHeading) > _AttitudeSmoother.ROTATION_SPEED_JUMP_THRESHOLD * diffTime;
   }
 };
+__publicField(_AttitudeSmoother, "ROTATION_SPEED_JUMP_THRESHOLD", maths.deg2rad(180));
+// in radians/s
+__publicField(_AttitudeSmoother, "ROTATION_SPEED_CONVERGENCE", maths.deg2rad(10));
+// in radians/s
+__publicField(_AttitudeSmoother, "HIGH_JUMP_THRESHOLD", maths.deg2rad(20));
+// in radians/s
+__publicField(_AttitudeSmoother, "ROTATION_SPEED_HIGH_JUMP_CONVERGENCE", maths.deg2rad(100));
+// in radians/s
+__publicField(_AttitudeSmoother, "PITCH_UNCERTAINITY_HEADING_THRESHOLD", maths.deg2rad(5));
 let AttitudeSmoother = _AttitudeSmoother;
-__publicField(AttitudeSmoother, "ROTATION_SPEED_JUMP_THRESHOLD", maths.deg2rad(180));
-__publicField(AttitudeSmoother, "ROTATION_SPEED_CONVERGENCE", maths.deg2rad(10));
-__publicField(AttitudeSmoother, "HIGH_JUMP_THRESHOLD", maths.deg2rad(20));
-__publicField(AttitudeSmoother, "ROTATION_SPEED_HIGH_JUMP_CONVERGENCE", maths.deg2rad(100));
-__publicField(AttitudeSmoother, "PITCH_UNCERTAINITY_HEADING_THRESHOLD", maths.deg2rad(5));
 class MagnetometerCalibrationProvider extends Provider {
   constructor() {
     super();
@@ -3158,13 +3289,13 @@ class MagnetometerCalibrationProvider extends Provider {
   }
 }
 const MagnetometerCalibrationProvider$1 = new MagnetometerCalibrationProvider();
-const _IpResolveServerError = class extends Error {
+const _IpResolveServerError = class _IpResolveServerError extends Error {
   constructor(message) {
     super(message || _IpResolveServerError.DEFAULT_MESSAGE);
   }
 };
+__publicField(_IpResolveServerError, "DEFAULT_MESSAGE", "IP Resolver failed");
 let IpResolveServerError = _IpResolveServerError;
-__publicField(IpResolveServerError, "DEFAULT_MESSAGE", "IP Resolver failed");
 class IpProvider extends Provider {
   constructor() {
     super(...arguments);