@wemap/providers 10.11.1 → 10.11.2

package/dist/index.js

@@ -0,0 +1,3273 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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" } });
+const geo = require("@wemap/geo");
+const maths = require("@wemap/maths");
+const routers = require("@wemap/routers");
+const utils = require("@wemap/utils");
+const Logger = require("@wemap/logger");
+const geomagnetism = require("@wemap/geomagnetism");
+const camera = require("@wemap/camera");
+const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
+const geomagnetism__default = /* @__PURE__ */ _interopDefaultLegacy(geomagnetism);
+class RelativeAttitude extends geo.Attitude {
+}
+class AbsoluteAttitude extends geo.Attitude {
+}
+class AbsolutePosition extends geo.UserPosition {
+}
+const ProvidersOptions = {
+  useMapMatching: true,
+  ignoreProviders: [],
+  optionalProviders: [],
+  stopOnError: true,
+  checkAvailabilityOnStart: true,
+  get hasPoleStar() {
+    return this.optionalProviders.includes("PoleStar");
+  }
+};
+class ProvidersLoggerOld {
+  constructor() {
+    __publicField(this, "_enabled", false);
+    __publicField(this, "currentId", 0);
+    __publicField(this, "objectsIdMap", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "pushEvents", {});
+    __publicField(this, "pushEventsRef", {});
+    __publicField(this, "interval");
+    __publicField(this, "initDate");
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(_newVal) {
+    this._enabled = _newVal;
+  }
+  initializeInterval() {
+    if (this.interval) {
+      return;
+    }
+    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");
+      }
+      this.pushEvents = {};
+      this.pushEventsRef = {};
+    }, 1e3);
+  }
+  getObjectId(object) {
+    if (!this.objectsIdMap.has(object)) {
+      this.objectsIdMap.set(object, ++this.currentId);
+    }
+    return this.objectsIdMap.get(object);
+  }
+  addEvent(object, method) {
+    if (!this.enabled) {
+      return;
+    }
+    if (!this.initDate) {
+      this.initDate = Date.now();
+    }
+    this.initializeInterval();
+    const objectId = this.getObjectId(object);
+    const objectClassName = object.getName();
+    Logger__default.default.debug(objectClassName + "[" + objectId + "]." + method);
+  }
+  incrementNotifications(object) {
+    if (!this.enabled) {
+      return;
+    }
+    const objectId = this.getObjectId(object);
+    let counter = this.pushEvents[objectId];
+    if (!counter) {
+      counter = 0;
+      this.pushEventsRef[objectId] = object;
+    }
+    this.pushEvents[objectId] = counter + 1;
+  }
+}
+const ProvidersLoggerOld$1 = new ProvidersLoggerOld();
+const _ContainsIgnoredProviderError = class extends Error {
+  constructor(message) {
+    super(message || _ContainsIgnoredProviderError.DEFAULT_MESSAGE);
+  }
+};
+let ContainsIgnoredProviderError = _ContainsIgnoredProviderError;
+__publicField(ContainsIgnoredProviderError, "DEFAULT_MESSAGE", "Contains ignored provider");
+const _Provider = class {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "state", "stopped");
+    __publicField(this, "_lastEvent", null);
+    __publicField(this, "_eventsCallbacks", []);
+    __publicField(this, "_monitoringCallbacks", []);
+    __publicField(this, "notify", (event) => {
+      ProvidersLoggerOld$1.incrementNotifications(this);
+      this._eventsCallbacks.forEach((cb) => {
+        var _a;
+        return (_a = cb.onEvent) == null ? void 0 : _a.call(cb, event);
+      });
+      this._lastEvent = event;
+    });
+    __publicField(this, "notifyError", (error) => {
+      this._eventsCallbacks.forEach(({
+        id,
+        onError
+      }) => {
+        if (ProvidersOptions.stopOnError) {
+          this.removeEventListener(id);
+        }
+        onError == null ? void 0 : onError(error);
+      });
+    });
+    this.id = _Provider._uniqueId++;
+    ProvidersLoggerOld$1.addEvent(this, "constructor");
+  }
+  getAvailability() {
+    if (ProvidersOptions.ignoreProviders.includes(this.getName())) {
+      return Promise.resolve(new ContainsIgnoredProviderError());
+    }
+    return this.availability();
+  }
+  get hasNativeInterface() {
+    return Boolean(this.nativeInterface);
+  }
+  get nativeInterface() {
+    return typeof window !== "undefined" && window.__nativeProviders || null;
+  }
+  get nativeJsInterface() {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    if (!window.__nativeJsProviders) {
+      window.__nativeJsProviders = {};
+    }
+    return window.__nativeJsProviders;
+  }
+  get useCameraNatively() {
+    return false;
+  }
+  addEventListener(onEvent = null, onError = null, startIfNecessary = true) {
+    const id = ++_Provider._callbackUniqueId;
+    this._eventsCallbacks.push({
+      id,
+      onEvent: onEvent || (() => {
+      }),
+      onError: onError || (() => {
+      }),
+      optional: !startIfNecessary
+    });
+    if (!startIfNecessary) {
+      return id;
+    }
+    if (this.state !== "stopped") {
+      return id;
+    }
+    this.state = "starting";
+    let availabilityPromise = Promise.resolve();
+    if (ProvidersOptions.checkAvailabilityOnStart) {
+      availabilityPromise = this.getAvailability();
+    }
+    (async () => {
+      const error = await availabilityPromise;
+      if (error) {
+        this.state = "stopped";
+        this.notifyError(error);
+        return;
+      }
+      ProvidersLoggerOld$1.addEvent(this, "start");
+      this.start();
+      this.state = "started";
+      this._monitoringCallbacks.forEach((cb) => {
+        var _a;
+        return (_a = cb.onStarted) == null ? void 0 : _a.call(cb);
+      });
+    })();
+    return id;
+  }
+  removeEventListener(callbackUniqueId) {
+    const callback = this._eventsCallbacks.find((_callback) => _callback.id === callbackUniqueId);
+    if (!callback) {
+      return;
+    }
+    this._eventsCallbacks = this._eventsCallbacks.filter((_callback) => _callback !== callback);
+    if (callback.optional) {
+      return;
+    }
+    if (this._eventsCallbacks.find((_callback) => !_callback.optional)) {
+      return;
+    }
+    if (this.state === "stopped") {
+      return;
+    }
+    ProvidersLoggerOld$1.addEvent(this, "stop");
+    this.stop();
+    this.state = "stopped";
+    this._monitoringCallbacks.forEach((cb) => {
+      var _a;
+      return (_a = cb.onStopped) == null ? void 0 : _a.call(cb);
+    });
+  }
+  addMonitoringListener(onStarted, onStopped) {
+    const id = _Provider._callbackUniqueId++;
+    this._monitoringCallbacks.push({
+      id,
+      onStarted: onStarted || null,
+      onStopped: onStopped || null
+    });
+    return id;
+  }
+  removeMonitoringListener(callbackUniqueId) {
+    this._monitoringCallbacks = this._monitoringCallbacks.filter(
+      (_callback) => _callback.id !== callbackUniqueId
+    );
+  }
+  get lastEvent() {
+    return this._lastEvent;
+  }
+};
+let Provider = _Provider;
+__publicField(Provider, "_callbackUniqueId", 0);
+__publicField(Provider, "_uniqueId", 1);
+class AvailabilityHelper {
+  static async every(availabilityPromises) {
+    for (const aPr of availabilityPromises) {
+      const error = await aPr;
+      if (error) {
+        return error;
+      }
+    }
+    return null;
+  }
+  static async some(availabilityPromises) {
+    let firstError;
+    for (const aPr of availabilityPromises) {
+      const error = await aPr;
+      if (!error) {
+        return null;
+      } else if (!firstError) {
+        firstError = error;
+      }
+    }
+    return firstError || null;
+  }
+}
+const _AskImuOnDesktopError = class extends Error {
+  constructor(message) {
+    super(message || _AskImuOnDesktopError.DEFAULT_MESSAGE);
+  }
+};
+let AskImuOnDesktopError = _AskImuOnDesktopError;
+__publicField(AskImuOnDesktopError, "DEFAULT_MESSAGE", "It seems that you ask for IMU events on a desktop browser");
+const _MissingSensorError = class extends Error {
+  constructor(message) {
+    super(message || _MissingSensorError.DEFAULT_MESSAGE);
+  }
+  from(fromMessage) {
+    this.message += " from " + fromMessage;
+    return this;
+  }
+};
+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 {
+  constructor(message) {
+    super(message || _GeolocationApiMissingError.DEFAULT_MESSAGE);
+  }
+};
+let GeolocationApiMissingError = _GeolocationApiMissingError;
+__publicField(GeolocationApiMissingError, "DEFAULT_MESSAGE", "Geolocation api is missing");
+const _GeolocationPermissionDeniedError = class extends Error {
+  constructor(message) {
+    super(message || _GeolocationPermissionDeniedError.DEFAULT_MESSAGE);
+  }
+};
+let GeolocationPermissionDeniedError = _GeolocationPermissionDeniedError;
+__publicField(GeolocationPermissionDeniedError, "DEFAULT_MESSAGE", "Geolocation permission denied");
+const _GeolocationPositionUnavailableError = class extends Error {
+  constructor(message) {
+    super(message || _GeolocationPositionUnavailableError.DEFAULT_MESSAGE);
+  }
+};
+let GeolocationPositionUnavailableError = _GeolocationPositionUnavailableError;
+__publicField(GeolocationPositionUnavailableError, "DEFAULT_MESSAGE", "Geolocation position unavailable");
+const Constants = {
+  DEFAULT_ALTITUDE: 1.6
+};
+const _GnssWifiProvider = class extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "geoLocationId");
+    __publicField(this, "getName", () => "GnssWifi");
+    __publicField(this, "onNewPosition", (geolocation) => {
+      const { coords } = geolocation;
+      if (!coords) {
+        return;
+      }
+      let bearing;
+      if (coords.heading) {
+        bearing = maths.deg2rad(coords.heading);
+      }
+      const timestamp = utils.TimeUtils.unixTimestampToPreciseTime(geolocation.timestamp) / 1e3;
+      const position = new geo.UserPosition(
+        coords.latitude,
+        coords.longitude,
+        Constants.DEFAULT_ALTITUDE,
+        null,
+        timestamp,
+        coords.accuracy,
+        bearing
+      );
+      this.notify(position);
+    });
+    __publicField(this, "onPositionError", (error) => {
+      Logger__default.default.warn(`[Providers] watchPosition error: [${error.code}] ${error.message}`);
+      let customError;
+      switch (error.code) {
+        case 1:
+          customError = new GeolocationPermissionDeniedError(error.message);
+          break;
+        case 2:
+          customError = new GeolocationPositionUnavailableError(error.message);
+          break;
+        default:
+          customError = new Error(error.message);
+      }
+      this.notifyError(customError);
+    });
+  }
+  availability() {
+    return typeof navigator === "object" && navigator.geolocation ? Promise.resolve() : Promise.resolve(new GeolocationApiMissingError());
+  }
+  start() {
+    setTimeout(() => {
+      this.geoLocationId = navigator.geolocation.watchPosition(
+        this.onNewPosition,
+        this.onPositionError,
+        _GnssWifiProvider.POSITION_OPTIONS
+      );
+    }, 150);
+  }
+  stop() {
+    if (typeof this.geoLocationId !== "undefined") {
+      navigator.geolocation.clearWatch(this.geoLocationId);
+    }
+  }
+};
+let GnssWifiProvider = _GnssWifiProvider;
+__publicField(GnssWifiProvider, "POSITION_OPTIONS", {
+  enableHighAccuracy: true,
+  timeout: Infinity,
+  maximumAge: 0
+});
+const GnssWifiProvider$1 = new GnssWifiProvider();
+const _MissingArCoreError = class extends Error {
+  constructor(message) {
+    super(message || _MissingArCoreError.DEFAULT_MESSAGE);
+  }
+};
+let MissingArCoreError = _MissingArCoreError;
+__publicField(MissingArCoreError, "DEFAULT_MESSAGE", "ARCore is missing");
+const _MissingNativeInterfaceError = class extends Error {
+  constructor(message) {
+    super(message || _MissingNativeInterfaceError.DEFAULT_MESSAGE);
+  }
+};
+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 {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_nativeProvider");
+    __publicField(this, "previousPosition", [0, 0, 0]);
+    __publicField(this, "getName", () => "ArCore");
+    __publicField(this, "pullDataLoop", () => {
+      if (this.state === "stopped") {
+        return;
+      }
+      const payload = JSON.parse(this.nativeProvider.getInfo());
+      if (payload.length > 1) {
+        this.parsePayload(payload);
+      }
+      requestAnimationFrame(this.pullDataLoop);
+    });
+  }
+  availability() {
+    try {
+      const nativeProvider = this.nativeProvider;
+      if (!nativeProvider.checkAvailability()) {
+        return Promise.resolve(new MissingArCoreError());
+      }
+    } catch (e) {
+      return Promise.resolve(e);
+    }
+    return Promise.resolve();
+  }
+  start() {
+    var _a;
+    (_a = this.nativeProvider) == null ? void 0 : _a.start();
+    this.pullDataLoop();
+  }
+  stop() {
+    var _a;
+    (_a = this.nativeProvider) == null ? void 0 : _a.stop();
+  }
+  parsePayload(payload) {
+    const ref = payload[0];
+    let bufferIndex = 1;
+    let attitude, position, cameraProjection, barcode;
+    const time = utils.TimeUtils.preciseTime() / 1e3;
+    if (ref & _ArCoreProvider.Payload.Pose.ref) {
+      attitude = new RelativeAttitude(
+        payload.slice(bufferIndex, bufferIndex + 4),
+        time,
+        _ArCoreProvider.RELATIVE_ATTITUDE_DRIFT
+      );
+      const newPosition = [
+        payload[bufferIndex + 4],
+        payload[bufferIndex + 5],
+        payload[bufferIndex + 6]
+      ];
+      position = new geo.RelativePosition(
+        newPosition[0] - this.previousPosition[0],
+        newPosition[1] - this.previousPosition[1],
+        newPosition[2] - this.previousPosition[2],
+        time,
+        1e-4
+      );
+      this.previousPosition = newPosition;
+      bufferIndex += _ArCoreProvider.Payload.Pose.size;
+    }
+    if (ref & _ArCoreProvider.Payload.Barcode.ref) {
+      barcode = payload[bufferIndex];
+      bufferIndex += _ArCoreProvider.Payload.Barcode.size;
+    }
+    if (ref & _ArCoreProvider.Payload.ProjMat.ref) {
+      cameraProjection = payload.slice(bufferIndex, bufferIndex + _ArCoreProvider.Payload.ProjMat.size);
+      bufferIndex += _ArCoreProvider.Payload.ProjMat.size;
+    }
+    this.notify({
+      relativePosition: position,
+      relativeAttitude: attitude,
+      ...barcode && { barcode },
+      ...cameraProjection && { cameraProjection }
+    });
+  }
+  get nativeProvider() {
+    if (!this._nativeProvider) {
+      if (!this.nativeInterface) {
+        throw new MissingNativeInterfaceError();
+      }
+      this._nativeProvider = this.nativeInterface.getArCoreProvider();
+      if (!this._nativeProvider) {
+        throw new MissingArCoreError();
+      }
+    }
+    return this._nativeProvider;
+  }
+  enableBarcodeScanner() {
+    try {
+      this.nativeProvider.enableBarcodeScanner();
+    } catch (e) {
+      this.notifyError(e);
+    }
+  }
+  disableBarcodeScanner() {
+    try {
+      this.nativeProvider.disableBarcodeScanner();
+    } catch (e) {
+      this.notifyError(e);
+    }
+  }
+  get useCameraNatively() {
+    return true;
+  }
+};
+let ArCoreProvider = _ArCoreProvider;
+__publicField(ArCoreProvider, "Payload", {
+  Pose: {
+    ref: 2 ** 0,
+    size: 7
+  },
+  Barcode: {
+    ref: 2 ** 1,
+    size: 1
+  },
+  ProjMat: {
+    ref: 2 ** 2,
+    size: 16
+  },
+  ImageRef: {
+    ref: 2 ** 3,
+    size: 1
+  }
+});
+__publicField(ArCoreProvider, "RELATIVE_ATTITUDE_DRIFT", maths.deg2rad(3) / 60);
+const ArCoreProvider$1 = new ArCoreProvider();
+class GeoRelativePositionFromArCoreProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "absoluteAttitudeProviderId");
+    __publicField(this, "arCoreProviderId");
+    __publicField(this, "absoluteAttitudeEvent");
+    __publicField(this, "getName", () => "GeoRelativePositionFromArCore");
+    __publicField(this, "onArCoreEvents", (event) => {
+      const relativeAttitudeEvent = event.relativeAttitude;
+      const relativePositionEvent = event.relativePosition;
+      if (relativeAttitudeEvent && relativePositionEvent && this.absoluteAttitudeEvent) {
+        this.compute(relativePositionEvent, relativeAttitudeEvent, this.absoluteAttitudeEvent);
+      }
+    });
+  }
+  availability() {
+    return AvailabilityHelper.every([
+      ArCoreProvider$1.getAvailability(),
+      AbsoluteAttitudeProvider$1.getAvailability()
+    ]);
+  }
+  start() {
+    this.arCoreProviderId = ArCoreProvider$1.addEventListener(
+      this.onArCoreEvents,
+      this.notifyError
+    );
+    this.absoluteAttitudeProviderId = AbsoluteAttitudeProvider$1.addEventListener(
+      (event) => this.absoluteAttitudeEvent = event,
+      this.notifyError
+    );
+  }
+  stop() {
+    ArCoreProvider$1.removeEventListener(this.arCoreProviderId);
+    AbsoluteAttitudeProvider$1.removeEventListener(this.absoluteAttitudeProviderId);
+  }
+  compute(relativePosition, relativeAttitude, absoluteAttitude) {
+    const rotation = absoluteAttitude.heading - relativeAttitude.heading;
+    const east = Math.cos(rotation) * relativePosition.x - Math.sin(rotation) * relativePosition.z;
+    const north = -Math.sin(rotation) * relativePosition.x - Math.cos(rotation) * relativePosition.z;
+    const up = relativePosition.y;
+    const position = new geo.GeoRelativePosition(
+      east,
+      north,
+      up,
+      relativePosition.time,
+      0,
+      absoluteAttitude.heading
+    );
+    this.notify(position);
+  }
+}
+const GeoRelativePositionFromArCoreProvider$1 = new GeoRelativePositionFromArCoreProvider();
+const DEFAULT_RELATIVE_NOISES = {
+  acc: 0.5,
+  gyr: 0.3
+};
+const DEFAULT_ABSOLUTE_NOISES = {
+  acc: 0.5,
+  gyr: 0.3,
+  yc: 2
+};
+class EkfAttitude {
+  constructor(accRef = [0, 0, 1], ycRef = [-1, 0, 0]) {
+    __publicField(this, "P");
+    __publicField(this, "accRef");
+    __publicField(this, "cRef");
+    __publicField(this, "noises");
+    __publicField(this, "quaternion");
+    this.accRef = accRef;
+    this.cRef = ycRef;
+    this.P = maths.Matrix4.fromDiagVector(Array(4).fill(0.1 ** 2));
+    this.quaternion = null;
+    this.noises = {};
+    this.setRelativeNoises(DEFAULT_RELATIVE_NOISES);
+    this.setAbsoluteNoises(DEFAULT_ABSOLUTE_NOISES);
+  }
+  setRelativeNoises(relativeNoises) {
+    this.noises.relative = {
+      acc: maths.Matrix3.diag(Array(3).fill(relativeNoises.acc ** 2)),
+      gyr: maths.Matrix3.diag(Array(3).fill(relativeNoises.gyr ** 2))
+    };
+  }
+  setAbsoluteNoises(absoluteNoises) {
+    this.noises.absolute = {
+      acc: maths.Matrix3.diag(Array(3).fill(absoluteNoises.acc ** 2)),
+      gyr: maths.Matrix3.diag(Array(3).fill(absoluteNoises.gyr ** 2)),
+      yc: maths.Matrix3.diag(Array(3).fill(absoluteNoises.yc ** 2))
+    };
+  }
+  tryInitialize(acc, mag) {
+    const accNormalized = maths.Vector3.normalize(acc);
+    if (mag) {
+      const magNormalized = maths.Vector3.normalize(mag);
+      const H = maths.Vector3.normalize(maths.Vector3.cross(magNormalized, accNormalized));
+      const M = maths.Vector3.cross(accNormalized, H);
+      const R = [
+        [H[0], M[0], accNormalized[0]],
+        [H[1], M[1], accNormalized[1]],
+        [H[2], M[2], accNormalized[2]]
+      ];
+      this.quaternion = maths.Quaternion.fromMatrix3Matlab(R);
+    } else {
+      const r = maths.Vector3.dot(accNormalized, this.accRef) + 1;
+      const v = maths.Vector3.cross(accNormalized, this.accRef);
+      let quaternion = [r, v[0], v[1], v[2]];
+      quaternion = maths.Quaternion.normalize(quaternion);
+      this.quaternion = quaternion;
+    }
+    return this.quaternion;
+  }
+  update(diffTime, acc, gyr, mag) {
+    if (!this.quaternion) {
+      return this.tryInitialize(acc, mag);
+    }
+    let q = this.quaternion;
+    const qArray = q;
+    const gyrInt = maths.Vector3.multiplyScalar(gyr, 0.5 * diffTime);
+    const F = this.computeC([1, gyrInt[0], gyrInt[1], gyrInt[2]]);
+    const qAPriori = maths.Matrix4.multiplyVector(F, q);
+    const E1 = maths.Matrix3.diag([qArray[0], qArray[0], qArray[0]]);
+    const eSkew = maths.Matrix3.skew([qArray[1], qArray[2], qArray[3]]);
+    const qPart = [-1 * qArray[1], -1 * qArray[2], -1 * qArray[3]];
+    const E = maths.Matrix.concatRow([qPart], maths.Matrix3.sum(eSkew, E1));
+    const Qk = maths.Matrix4.multiplyScalar(
+      maths.Matrix.multiply(
+        maths.Matrix.multiply(E, this.noises[mag ? "absolute" : "relative"].gyr),
+        maths.Matrix.transpose(E)
+      ),
+      (diffTime / 2) ** 2
+    );
+    const pAPriori = maths.Matrix4.sum(
+      maths.Matrix4.multiply(
+        maths.Matrix4.multiply(F, this.P),
+        maths.Matrix4.transpose(F)
+      ),
+      Qk
+    );
+    const accNormalized = maths.Vector3.normalize(acc);
+    let dz, K, H;
+    if (mag) {
+      const magNormalized = maths.Vector3.normalize(mag);
+      const yc = maths.Vector3.cross(accNormalized, magNormalized);
+      const ycNormalized = maths.Vector3.normalize(yc);
+      const dzYc = maths.Vector3.subtract(ycNormalized, maths.Quaternion.rotateMatlab(qAPriori, this.cRef));
+      const dzAcc = maths.Vector3.subtract(accNormalized, maths.Quaternion.rotateMatlab(qAPriori, this.accRef));
+      dz = maths.Vector.concat(dzYc, dzAcc);
+      const HYc = this.jacobianES(qAPriori, this.cRef);
+      const HAcc = this.jacobianES(qAPriori, this.accRef);
+      H = maths.Matrix.concatRow(HYc, HAcc);
+      const RYc = maths.Matrix.concatLine(this.noises.absolute.yc, maths.Matrix3.zeros);
+      const RAcc = maths.Matrix.concatLine(maths.Matrix3.zeros, this.noises.absolute.acc);
+      const R = maths.Matrix.concatRow(RYc, RAcc);
+      K = maths.Matrix.multiply(
+        maths.Matrix.multiply(pAPriori, maths.Matrix.transpose(H)),
+        maths.Matrix.inverse(
+          maths.Matrix.sum(
+            maths.Matrix.multiply(
+              maths.Matrix.multiply(H, pAPriori),
+              maths.Matrix.transpose(H)
+            ),
+            R
+          )
+        )
+      );
+    } else {
+      dz = maths.Vector3.subtract(accNormalized, maths.Quaternion.rotateMatlab(qAPriori, this.accRef));
+      H = this.jacobianES(qAPriori, this.accRef);
+      const R = this.noises.relative.acc;
+      K = maths.Matrix.multiply(
+        maths.Matrix.multiply(pAPriori, maths.Matrix.transpose(H)),
+        maths.Matrix3.inverse(
+          maths.Matrix3.sum(
+            maths.Matrix.multiply(
+              maths.Matrix.multiply(H, pAPriori),
+              maths.Matrix.transpose(H)
+            ),
+            R
+          )
+        )
+      );
+    }
+    q = maths.Quaternion.sum(
+      qAPriori,
+      maths.Matrix.multiplyVector(K, dz)
+    );
+    const P = maths.Matrix4.multiply(
+      maths.Matrix4.subtract(
+        maths.Matrix4.identity,
+        maths.Matrix.multiply(K, H)
+      ),
+      pAPriori
+    );
+    q = maths.Quaternion.normalize(q);
+    this.quaternion = q;
+    this.P = P;
+    return q;
+  }
+  computeC(b) {
+    return [
+      [b[0], -b[1], -b[2], -b[3]],
+      [b[1], b[0], b[3], -b[2]],
+      [b[2], -b[3], b[0], b[1]],
+      [b[3], b[2], -b[1], b[0]]
+    ];
+  }
+  jacobianES(q, v) {
+    const [qw, qx, qy, qz] = q;
+    const [vx, vy, vz] = v;
+    return [
+      [2 * qz * vy - 2 * qy * vz, 2 * qy * vy + 2 * qz * vz, 2 * qx * vy - 2 * qw * vz - 4 * qy * vx, 2 * qw * vy + 2 * qx * vz - 4 * qz * vx],
+      [2 * qx * vz - 2 * qz * vx, 2 * qw * vz - 4 * qx * vy + 2 * qy * vx, 2 * qx * vx + 2 * qz * vz, 2 * qy * vz - 2 * qw * vx - 4 * qz * vy],
+      [2 * qy * vx - 2 * qx * vy, 2 * qz * vx - 4 * qx * vz - 2 * qw * vy, 2 * qw * vx - 4 * qy * vz + 2 * qz * vy, 2 * qx * vx + 2 * qy * vy]
+    ];
+  }
+}
+class ImuProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "getName", () => "IMU");
+    __publicField(this, "parseDeviceMotionEvent", (e) => {
+      const timestamp = e.timeStamp / 1e3;
+      let acc;
+      if (e.accelerationIncludingGravity) {
+        const {
+          x,
+          y,
+          z
+        } = e.accelerationIncludingGravity;
+        if (typeof x === "number" && typeof y === "number" && typeof z === "number") {
+          acc = [x, y, z];
+          if (utils.BrowserUtils.name === utils.Browser.SAFARI || utils.BrowserUtils.name === utils.Browser.IOS_WEBVIEW) {
+            acc[0] *= -1;
+            acc[1] *= -1;
+            acc[2] *= -1;
+          }
+        }
+      }
+      let gyr;
+      if (e.rotationRate) {
+        const {
+          alpha,
+          beta,
+          gamma
+        } = e.rotationRate;
+        if (typeof alpha === "number" && typeof beta === "number" && typeof gamma === "number") {
+          gyr = [maths.deg2rad(alpha), maths.deg2rad(beta), maths.deg2rad(gamma)];
+        }
+      }
+      if (acc || gyr) {
+        this.notify({
+          ...acc && { acceleration: { timestamp, values: acc } },
+          ...gyr && { angularRate: { timestamp, values: gyr } }
+        });
+      }
+    });
+  }
+  availability() {
+    return utils.BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
+  }
+  start() {
+    const subscribe = () => window.addEventListener("devicemotion", this.parseDeviceMotionEvent, true);
+    const requestPermission = DeviceMotionEvent.requestPermission || void 0;
+    if (requestPermission) {
+      requestPermission().then((response) => {
+        if (response !== "granted") {
+          throw new Error("Permission not granted");
+        }
+        subscribe();
+      }).catch(this.notifyError);
+    } else {
+      subscribe();
+    }
+  }
+  stop() {
+    window.removeEventListener("devicemotion", this.parseDeviceMotionEvent, true);
+  }
+}
+const ImuProvider$1 = new ImuProvider();
+const _MissingAccelerometerError = class extends MissingSensorError {
+  constructor(message) {
+    super(message || _MissingAccelerometerError.DEFAULT_MESSAGE);
+  }
+};
+let MissingAccelerometerError = _MissingAccelerometerError;
+__publicField(MissingAccelerometerError, "DEFAULT_MESSAGE", "Impossible to retrieve Acceleration data");
+class AccelerometerProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "imuProviderId");
+    __publicField(this, "getName", () => "Accelerometer");
+    __publicField(this, "availability", () => ImuProvider$1.getAvailability());
+  }
+  start() {
+    this.imuProviderId = ImuProvider$1.addEventListener((event) => {
+      event.acceleration ? this.notify(event.acceleration) : this.notifyError(new MissingAccelerometerError().from("devicemotion"));
+    }, this.notifyError);
+  }
+  stop() {
+    ImuProvider$1.removeEventListener(this.imuProviderId);
+  }
+}
+const AccelerometerProvider$1 = new AccelerometerProvider();
+class MissingGyroscopeError extends MissingSensorError {
+  constructor(message) {
+    super(message || MissingSensorError.DEFAULT_MESSAGE);
+  }
+}
+__publicField(MissingGyroscopeError, "DEFAULT_MESSAGE", "Impossible to retrieve Angular Rate data");
+class GyroscopeProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "imuProviderId");
+    __publicField(this, "getName", () => "Gyroscope");
+    __publicField(this, "availability", () => ImuProvider$1.getAvailability());
+  }
+  start() {
+    this.imuProviderId = ImuProvider$1.addEventListener((event) => {
+      event.angularRate ? this.notify(event.angularRate) : this.notifyError(new MissingGyroscopeError().from("devicemotion"));
+    }, this.notifyError);
+  }
+  stop() {
+    ImuProvider$1.removeEventListener(this.imuProviderId);
+  }
+}
+const GyroscopeProvider$1 = new GyroscopeProvider();
+const _RelativeAttitudeFromEkf = class extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "accelerometerProviderId");
+    __publicField(this, "ekfAttitude", new EkfAttitude());
+    __publicField(this, "gyroscopeEvent");
+    __publicField(this, "gyroscopeProviderId");
+    __publicField(this, "lastTimestamp", 0);
+    __publicField(this, "getName", () => "RelativeAttitudeFromEkf");
+    __publicField(this, "onAccelerometerEvent", (accelerationEvent) => {
+      if (!this.gyroscopeEvent) {
+        return;
+      }
+      const {
+        values: acceleration,
+        timestamp
+      } = accelerationEvent;
+      if (this.lastTimestamp === 0) {
+        this.lastTimestamp = timestamp;
+        return;
+      }
+      const diffTime = timestamp - this.lastTimestamp;
+      this.lastTimestamp = timestamp;
+      const quaternion = this.ekfAttitude.update(
+        diffTime,
+        acceleration,
+        this.gyroscopeEvent.values
+      );
+      if (quaternion) {
+        const attitude = new RelativeAttitude(
+          quaternion,
+          timestamp,
+          _RelativeAttitudeFromEkf.DEFAULT_DRIFT
+        );
+        this.notify(attitude);
+      }
+    });
+  }
+  availability() {
+    return AvailabilityHelper.every([
+      AccelerometerProvider$1.getAvailability(),
+      GyroscopeProvider$1.getAvailability()
+    ]);
+  }
+  start() {
+    this.accelerometerProviderId = AccelerometerProvider$1.addEventListener(
+      (event) => this.onAccelerometerEvent(event),
+      (error) => this.notifyError(error)
+    );
+    this.gyroscopeProviderId = GyroscopeProvider$1.addEventListener(
+      (event) => this.gyroscopeEvent = event,
+      (error) => this.notifyError(error)
+    );
+  }
+  stop() {
+    AccelerometerProvider$1.removeEventListener(this.accelerometerProviderId);
+    GyroscopeProvider$1.removeEventListener(this.gyroscopeProviderId);
+  }
+};
+let RelativeAttitudeFromEkf = _RelativeAttitudeFromEkf;
+__publicField(RelativeAttitudeFromEkf, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
+const RelativeAttitudeFromEkfProvider = new RelativeAttitudeFromEkf();
+const _RelativeAttitudeFromBrowser = class extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "getName", () => "RelativeAttitudeFromBrowser");
+    __publicField(this, "onDeviceOrientationEvent", (e) => {
+      if (typeof e.alpha !== "number" || typeof e.beta !== "number" || typeof e.gamma !== "number") {
+        this.notifyError(new MissingSensorError().from("deviceorientation"));
+        return;
+      }
+      const quaternion = maths.Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
+      const attitude = new RelativeAttitude(
+        quaternion,
+        e.timeStamp / 1e3,
+        _RelativeAttitudeFromBrowser.DEFAULT_DRIFT
+      );
+      this.notify(attitude);
+    });
+  }
+  availability() {
+    return utils.BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
+  }
+  start() {
+    const subscribe = () => window.addEventListener("deviceorientation", this.onDeviceOrientationEvent, true);
+    const requestPermission = DeviceOrientationEvent.requestPermission || void 0;
+    if (requestPermission) {
+      requestPermission().then((response) => {
+        if (response !== "granted") {
+          throw new Error("Permission not granted");
+        }
+        subscribe();
+      }).catch((error) => this.notifyError(error));
+    } else {
+      subscribe();
+    }
+  }
+  stop() {
+    window.removeEventListener("deviceorientation", this.onDeviceOrientationEvent, true);
+  }
+};
+let RelativeAttitudeFromBrowser = _RelativeAttitudeFromBrowser;
+__publicField(RelativeAttitudeFromBrowser, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
+const RelativeAttitudeFromBrowser$1 = new RelativeAttitudeFromBrowser();
+const _HighRotationsProvider = class extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "gyroscopeProviderId");
+    __publicField(this, "getName", () => "HighRotationsProvider");
+    __publicField(this, "availability", () => GyroscopeProvider$1.getAvailability());
+    __publicField(this, "_parseGyroscopeEvent", (gyroscopeEvent) => {
+      const { values, timestamp } = gyroscopeEvent;
+      const speed = maths.Vector3.norm(values);
+      if (speed > _HighRotationsProvider.THRESHOLD) {
+        this.notify({ timestamp });
+      }
+    });
+  }
+  start() {
+    this.gyroscopeProviderId = GyroscopeProvider$1.addEventListener(
+      this._parseGyroscopeEvent,
+      this.notifyError
+    );
+  }
+  stop() {
+    GyroscopeProvider$1.removeEventListener(this.gyroscopeProviderId);
+  }
+  isInProgress() {
+    if (!this.lastEvent || !GyroscopeProvider$1.lastEvent) {
+      return false;
+    }
+    const diffTime = GyroscopeProvider$1.lastEvent.timestamp - this.lastEvent.timestamp;
+    return diffTime < _HighRotationsProvider.DELAY_CONSIDERATION;
+  }
+};
+let HighRotationsProvider = _HighRotationsProvider;
+__publicField(HighRotationsProvider, "THRESHOLD", 10);
+__publicField(HighRotationsProvider, "DELAY_CONSIDERATION", 3);
+const HighRotationsProvider$1 = new HighRotationsProvider();
+const _RelativeAttitudeFromInertial = class extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_highRotationsProviderId");
+    __publicField(this, "listenerId");
+    __publicField(this, "provider");
+    __publicField(this, "getName", () => "RelativeAttitudeFromInertial");
+  }
+  availability() {
+    return AvailabilityHelper.some([
+      RelativeAttitudeFromEkfProvider.getAvailability(),
+      RelativeAttitudeFromBrowser$1.getAvailability()
+    ]);
+  }
+  start() {
+    RelativeAttitudeFromEkfProvider.getAvailability().then((availabilityError) => {
+      this.provider = !availabilityError ? RelativeAttitudeFromEkfProvider : RelativeAttitudeFromBrowser$1;
+      this.listenerId = this.provider.addEventListener(
+        (event) => this._parseEvent(event),
+        this.notifyError
+      );
+      this._highRotationsProviderId = HighRotationsProvider$1.addEventListener(
+        null,
+        this.notifyError
+      );
+    });
+  }
+  _parseEvent(event) {
+    const relativeAttitude = event.clone();
+    if (HighRotationsProvider$1.isInProgress()) {
+      let accuracy = (relativeAttitude.accuracy || 0) + _RelativeAttitudeFromInertial.DEFAULT_DRIFT * 100;
+      accuracy = Math.min(accuracy, Math.PI);
+      relativeAttitude.accuracy = accuracy;
+    }
+    this.notify(relativeAttitude);
+  }
+  stop() {
+    if (this.provider) {
+      this.provider.removeEventListener(this.listenerId);
+      delete this.provider;
+    }
+    HighRotationsProvider$1.removeEventListener(this._highRotationsProviderId);
+  }
+};
+let RelativeAttitudeFromInertial = _RelativeAttitudeFromInertial;
+__publicField(RelativeAttitudeFromInertial, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
+const RelativeAttitudeFromInertialProvider = new RelativeAttitudeFromInertial();
+const _StepDetectionLadetto = class {
+  constructor() {
+    __publicField(this, "frequency", 0);
+    __publicField(this, "lastVerticalAcc", 0);
+    __publicField(this, "maxAcceleration", 0);
+    __publicField(this, "lastStepTimestamp", -_StepDetectionLadetto.MIN_TIME_BETWEEN_STEPS);
+  }
+  compute(timestamp, linearAcc) {
+    let stepDetected = false;
+    const verticalAcc = linearAcc[2];
+    const timeInterval = timestamp - this.lastStepTimestamp;
+    const upfront = verticalAcc > this.lastVerticalAcc;
+    if (upfront) {
+      if (verticalAcc > this.maxAcceleration) {
+        this.maxAcceleration = verticalAcc;
+      }
+    } else if (this.maxAcceleration > _StepDetectionLadetto.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD && timeInterval > _StepDetectionLadetto.MIN_TIME_BETWEEN_STEPS) {
+      this.maxAcceleration = 0;
+      const diffTime = timestamp - this.lastStepTimestamp;
+      this.frequency = Math.min(Math.max(1 / diffTime, _StepDetectionLadetto.MIN_FRENQUENCY), _StepDetectionLadetto.MAX_FRENQUENCY);
+      stepDetected = true;
+      this.lastStepTimestamp = timestamp;
+    } else {
+      this.maxAcceleration = 0;
+    }
+    this.lastVerticalAcc = verticalAcc;
+    return stepDetected;
+  }
+  get lastStepSize() {
+    if (!this.frequency) {
+      return 0;
+    }
+    const kParamA = 0.45;
+    const kParamB = 0.2;
+    return kParamA + kParamB * this.frequency;
+  }
+  get speed() {
+    return this.lastStepTimestamp ? this.lastStepSize * this.frequency : 0;
+  }
+};
+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 {
+  constructor() {
+    __publicField(this, "frequency", 0);
+    __publicField(this, "lastStepTimestamp", -_StepDetectionMinMaxPeaks.MIN_TIME_BETWEEN_STEPS);
+    __publicField(this, "slidingWindow", []);
+  }
+  compute(timestamp, linearAcc) {
+    if (this.lastStepTimestamp && this.lastStepTimestamp + _StepDetectionMinMaxPeaks.MIN_TIME_BETWEEN_STEPS > timestamp) {
+      return false;
+    }
+    let maxValue = Number.MIN_SAFE_INTEGER;
+    let minValue = Number.MAX_SAFE_INTEGER;
+    const windowTime = _StepDetectionMinMaxPeaks.WINDOW_TIME;
+    this.slidingWindow.forEach((item, index, object) => {
+      if (item.timestamp < timestamp - windowTime) {
+        object.splice(index, 1);
+      } else {
+        maxValue = Math.max(item.verticalAcc, maxValue);
+        minValue = Math.min(item.verticalAcc, minValue);
+      }
+    });
+    this.slidingWindow.push({
+      timestamp,
+      verticalAcc: linearAcc[2]
+    });
+    if (maxValue > _StepDetectionMinMaxPeaks.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD && minValue < _StepDetectionMinMaxPeaks.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
+      const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
+      this.frequency = Math.min(Math.max(1 / timeInterval, _StepDetectionMinMaxPeaks.MIN_FRENQUENCY), _StepDetectionMinMaxPeaks.MAX_FRENQUENCY);
+      this.lastStepTimestamp = timestamp;
+      return true;
+    }
+    return false;
+  }
+  get lastStepSize() {
+    if (!this.frequency) {
+      return 0;
+    }
+    const kParamA = 0.45;
+    const kParamB = 0.2;
+    return kParamA + kParamB * this.frequency;
+  }
+  get speed() {
+    return this.lastStepTimestamp ? this.lastStepSize * this.frequency : 0;
+  }
+};
+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 {
+  constructor() {
+    __publicField(this, "frequency", 0);
+    __publicField(this, "influence", 0.2);
+    __publicField(this, "slidingWindow", []);
+    __publicField(this, "lastStepTimestamp", -_StepDetectionMinMaxPeaks2.MIN_TIME_BETWEEN_STEPS);
+    __publicField(this, "previousVerticalAcc", 0);
+  }
+  compute(timestamp, linearAcc, angularRate) {
+    const verticalAcc = this.influence * (linearAcc[2] * 2) + (1 - this.influence) * this.previousVerticalAcc;
+    this.previousVerticalAcc = verticalAcc;
+    if (Math.sqrt(angularRate[0] ** 2 + angularRate[1] ** 2 + angularRate[2] ** 2) > 0.75) {
+      return false;
+    }
+    if (this.lastStepTimestamp && this.lastStepTimestamp + _StepDetectionMinMaxPeaks2.MIN_TIME_BETWEEN_STEPS > timestamp) {
+      return false;
+    }
+    let maxValue = Number.MIN_SAFE_INTEGER;
+    let minValue = Number.MAX_SAFE_INTEGER;
+    this.slidingWindow.forEach((item, index, object) => {
+      if (item.timestamp < timestamp - _StepDetectionMinMaxPeaks2.WINDOW_TIME) {
+        object.splice(index, 1);
+      } else {
+        maxValue = Math.max(item.verticalAcc, maxValue);
+        minValue = Math.min(item.verticalAcc, minValue);
+      }
+    });
+    this.slidingWindow.push({
+      timestamp,
+      verticalAcc
+    });
+    if (maxValue > _StepDetectionMinMaxPeaks2.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD && minValue < _StepDetectionMinMaxPeaks2.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
+      const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
+      this.frequency = Math.min(Math.max(1 / timeInterval, _StepDetectionMinMaxPeaks2.MIN_FRENQUENCY), _StepDetectionMinMaxPeaks2.MAX_FRENQUENCY);
+      this.lastStepTimestamp = timestamp;
+      return true;
+    }
+    return false;
+  }
+  get lastStepSize() {
+    if (!this.frequency) {
+      return 0;
+    }
+    const kParamA = 0.45;
+    const kParamB = 0.2;
+    return kParamA + kParamB * this.frequency;
+  }
+  get speed() {
+    return this.lastStepSize && this.frequency ? this.lastStepSize * this.frequency : 0;
+  }
+  mean(data) {
+    let sum = 0, mean = 0;
+    for (let i = 0; i < data.length; ++i) {
+      sum += data[i].verticalAcc;
+    }
+    mean = sum / data.length;
+    return mean;
+  }
+  stddev(data) {
+    const theMean = this.mean(data);
+    let standardDeviation = 0;
+    for (let i = 0; i < data.length; ++i) {
+      standardDeviation += (data[i].verticalAcc - theMean) ** 2;
+    }
+    return Math.sqrt(standardDeviation / data.length);
+  }
+};
+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 {
+  constructor() {
+    __publicField(this, "frequency", 0);
+    __publicField(this, "influence", 0.05);
+    __publicField(this, "slidingWindow", []);
+    __publicField(this, "lastStepTimestamp", -_StepDetectionMinMaxPeaks3.MIN_TIME_BETWEEN_STEPS);
+    __publicField(this, "previousVerticalAcc", 0);
+    __publicField(this, "previousHorizontalAcc", 0);
+  }
+  compute(timestamp, linearAcc) {
+    const verticalAcc = this.influence * linearAcc[2] + (1 - this.influence) * this.previousVerticalAcc;
+    this.previousVerticalAcc = verticalAcc;
+    this.slidingWindow = this.slidingWindow.filter(
+      (item) => item.timestamp >= timestamp - _StepDetectionMinMaxPeaks3.WINDOW_TIME
+    );
+    this.slidingWindow.push({ timestamp, verticalAcc });
+    const isTooEarlyForANewStep = this.lastStepTimestamp && this.lastStepTimestamp + _StepDetectionMinMaxPeaks3.MIN_TIME_BETWEEN_STEPS > timestamp;
+    if (isTooEarlyForANewStep) {
+      return false;
+    }
+    let maxValue = Number.MIN_VALUE;
+    let maxValueIdx = -1;
+    let foundMaxPeakHigherThanThreshold = false;
+    this.slidingWindow.forEach((item, idx) => {
+      if (item.verticalAcc > maxValue && item.verticalAcc >= _StepDetectionMinMaxPeaks3.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD) {
+        maxValue = item.verticalAcc;
+        maxValueIdx = idx;
+        foundMaxPeakHigherThanThreshold = true;
+      }
+    });
+    if (!foundMaxPeakHigherThanThreshold) {
+      return false;
+    }
+    let hasLowNegativeValueBeforeMaxPeak = false;
+    let minValueBeforeMaxPeak = Number.MAX_VALUE;
+    for (let i = 0; i < maxValueIdx; i++) {
+      const curValue = this.slidingWindow[i].verticalAcc;
+      minValueBeforeMaxPeak = Math.min(minValueBeforeMaxPeak, curValue);
+      if (curValue < _StepDetectionMinMaxPeaks3.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
+        hasLowNegativeValueBeforeMaxPeak = true;
+        break;
+      }
+    }
+    if (!hasLowNegativeValueBeforeMaxPeak) {
+      return false;
+    }
+    const diffMinMax = maxValue - minValueBeforeMaxPeak;
+    const targetValue = maxValue - 0.5 * diffMinMax;
+    let targetValueFoundAfterMaxPeak = false;
+    for (let i = maxValueIdx + 1; i < this.slidingWindow.length; i++) {
+      if (this.slidingWindow[i].verticalAcc <= targetValue) {
+        targetValueFoundAfterMaxPeak = true;
+        break;
+      }
+    }
+    if (!targetValueFoundAfterMaxPeak) {
+      return false;
+    }
+    const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
+    this.frequency = Math.min(Math.max(1 / timeInterval, _StepDetectionMinMaxPeaks3.MIN_FRENQUENCY), _StepDetectionMinMaxPeaks3.MAX_FRENQUENCY);
+    this.lastStepTimestamp = timestamp;
+    return true;
+  }
+  get lastStepSize() {
+    if (!this.frequency) {
+      return 0;
+    }
+    const kParamA = 0.45;
+    const kParamB = 0.2;
+    return kParamA + kParamB * this.frequency;
+  }
+  get speed() {
+    return this.lastStepSize && this.frequency ? this.lastStepSize * this.frequency : 0;
+  }
+  mean(data) {
+    let sum = 0, mean = 0;
+    for (let i = 0; i < data.length; ++i) {
+      sum += data[i];
+    }
+    mean = sum / data.length;
+    return mean;
+  }
+  stddev(data) {
+    const theMean = this.mean(data);
+    let standardDeviation = 0;
+    for (let i = 0; i < data.length; ++i) {
+      standardDeviation += (data[i] - theMean) ** 2;
+    }
+    return Math.sqrt(standardDeviation / data.length);
+  }
+};
+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 {
+  constructor() {
+    super();
+    __publicField(this, "accelerometerProviderId");
+    __publicField(this, "attitudeProviderId");
+    __publicField(this, "gyroscopeProviderId");
+    __publicField(this, "angularRateEvent");
+    __publicField(this, "attitudeEvent");
+    __publicField(this, "numOfSteps", 0);
+    __publicField(this, "stepDetector");
+    __publicField(this, "_stepSizeMultiplier", _StepProvider.DEFAULT_STEP_SIZE_MULTIPLIER);
+    __publicField(this, "_algorithm", _StepProvider.DEFAULT_ALGORITHM);
+    __publicField(this, "_accValues", []);
+    __publicField(this, "getName", () => "StepDetector");
+    this.algorithm = this._algorithm;
+  }
+  availability() {
+    return AvailabilityHelper.every([
+      AccelerometerProvider$1.getAvailability(),
+      GyroscopeProvider$1.getAvailability(),
+      RelativeAttitudeFromInertialProvider.getAvailability()
+    ]);
+  }
+  start() {
+    this.numOfSteps = 0;
+    this.accelerometerProviderId = AccelerometerProvider$1.addEventListener(
+      this.onAccelerometerEvent,
+      this.notifyError
+    );
+    this.gyroscopeProviderId = GyroscopeProvider$1.addEventListener(
+      (event) => this.angularRateEvent = event,
+      this.notifyError
+    );
+    this.attitudeProviderId = RelativeAttitudeFromInertialProvider.addEventListener(
+      (event) => this.attitudeEvent = event,
+      this.notifyError
+    );
+  }
+  stop() {
+    AccelerometerProvider$1.removeEventListener(this.accelerometerProviderId);
+    GyroscopeProvider$1.removeEventListener(this.gyroscopeProviderId);
+    RelativeAttitudeFromInertialProvider.removeEventListener(this.attitudeProviderId);
+  }
+  onAccelerometerEvent(accelerationEvent) {
+    if (!this.attitudeEvent || !this.angularRateEvent) {
+      return;
+    }
+    const {
+      values: acceleration,
+      timestamp
+    } = accelerationEvent;
+    const linearAcc = _StepProvider.computeLinearAcceleration(
+      this.attitudeEvent.quaternion,
+      acceleration
+    );
+    const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.values);
+    if (stepDetected) {
+      const size = this.stepDetector.lastStepSize * this._stepSizeMultiplier;
+      this.numOfSteps++;
+      this.notify({ size, number: this.numOfSteps });
+    }
+  }
+  static computeLinearAcceleration(quaternion, acc) {
+    const linearAcc = maths.Quaternion.rotateMatlab(maths.Quaternion.inverse(quaternion), acc);
+    linearAcc[2] -= geo.Constants.EARTH_GRAVITY;
+    return linearAcc;
+  }
+  set stepSizeMultiplier(stepSizeMultiplier) {
+    this._stepSizeMultiplier = stepSizeMultiplier;
+  }
+  get stepSizeMultiplier() {
+    return this._stepSizeMultiplier;
+  }
+  set algorithm(algorithm) {
+    switch (algorithm) {
+      case "ladetto":
+        this.stepDetector = new StepDetectionLadetto();
+        break;
+      case "minMaxPeaks":
+        this.stepDetector = new StepDetectionMinMaxPeaks();
+        break;
+      case "minMaxPeaks2":
+        this.stepDetector = new StepDetectionMinMaxPeaks2();
+        break;
+      case "minMaxPeaks3":
+      default:
+        algorithm = "minMaxPeaks3";
+        this.stepDetector = new StepDetectionMinMaxPeaks3();
+        break;
+    }
+    this._algorithm = algorithm;
+  }
+  get algorithm() {
+    return this._algorithm;
+  }
+};
+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() {
+    super(...arguments);
+    __publicField(this, "absoluteAttitudeProviderId");
+    __publicField(this, "stepDetectionProviderId");
+    __publicField(this, "attitudeEvent");
+    __publicField(this, "misalignmentError", maths.deg2rad(3));
+    __publicField(this, "getName", () => "Pdr");
+    __publicField(this, "onStepEvent", (stepEvent) => {
+      if (!this.attitudeEvent) {
+        return;
+      }
+      const stepSize = stepEvent.size;
+      const deviceAttitude = this.attitudeEvent;
+      const deviceDirection = deviceAttitude.heading;
+      const deviceDirectionAccuracy = deviceAttitude.accuracy + this.misalignmentError;
+      const accuracy = stepSize / 2 * Math.sin(deviceDirectionAccuracy / 2);
+      const timestamp = deviceAttitude.time;
+      const position = new geo.GeoRelativePosition(
+        stepSize * Math.sin(deviceDirection),
+        stepSize * Math.cos(deviceDirection),
+        0,
+        timestamp,
+        accuracy,
+        deviceDirection
+      );
+      this.notify(position);
+    });
+  }
+  availability() {
+    return AvailabilityHelper.every([
+      StepProvider$1.getAvailability(),
+      AbsoluteAttitudeProvider$1.getAvailability()
+    ]);
+  }
+  start() {
+    this.stepDetectionProviderId = StepProvider$1.addEventListener(
+      this.onStepEvent,
+      this.notifyError
+    );
+    this.absoluteAttitudeProviderId = AbsoluteAttitudeProvider$1.addEventListener(
+      (event) => this.attitudeEvent = event,
+      this.notifyError
+    );
+  }
+  stop() {
+    StepProvider$1.removeEventListener(this.stepDetectionProviderId);
+    AbsoluteAttitudeProvider$1.removeEventListener(this.absoluteAttitudeProviderId);
+  }
+}
+const PdrProvider$1 = new PdrProvider();
+class GeoRelativePositionProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "providerId");
+    __publicField(this, "geoRelativeProvider");
+    __publicField(this, "getName", () => "GeoRelativePosition");
+  }
+  availability() {
+    return AvailabilityHelper.some([
+      PdrProvider$1.getAvailability(),
+      GeoRelativePositionFromArCoreProvider$1.getAvailability()
+    ]);
+  }
+  async start() {
+    const availabilityError = await GeoRelativePositionFromArCoreProvider$1.getAvailability();
+    this.geoRelativeProvider = availabilityError ? PdrProvider$1 : GeoRelativePositionFromArCoreProvider$1;
+    this.providerId = this.geoRelativeProvider.addEventListener(this.notify, this.notifyError);
+  }
+  stop() {
+    var _a;
+    (_a = this.geoRelativeProvider) == null ? void 0 : _a.removeEventListener(this.providerId);
+    delete this.geoRelativeProvider;
+  }
+}
+const GeoRelativePositionProvider$1 = new GeoRelativePositionProvider();
+class InclinationFromAccProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "providerId");
+    __publicField(this, "getName", () => "InclinationFromAcc");
+    __publicField(this, "availability", () => AccelerometerProvider$1.getAvailability());
+    __publicField(this, "onAccelerometerEvent", (accelerometerEvent) => {
+      const acc = accelerometerEvent.values;
+      const screenOrientation = window.orientation || 0;
+      const sizeAcc = Math.sqrt(acc[0] * acc[0] + acc[1] * acc[1] + acc[2] * acc[2]);
+      const accNormalized = [acc[0] / sizeAcc, acc[1] / sizeAcc, acc[2] / sizeAcc];
+      const q = [accNormalized[2] + 1, accNormalized[1], -accNormalized[0], 0];
+      const qSize = Math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2]);
+      const qNormalized = [q[0] / qSize, q[1] / qSize, q[2] / qSize, 0];
+      let inclination;
+      if (screenOrientation === 0) {
+        inclination = Math.asin(2 * qNormalized[1] * qNormalized[0]);
+      } else if (screenOrientation === 90) {
+        inclination = -Math.asin(2 * qNormalized[2] * qNormalized[0]);
+      } else if (screenOrientation === -90) {
+        inclination = Math.asin(2 * qNormalized[2] * qNormalized[0]);
+      } else {
+        inclination = -Math.asin(2 * qNormalized[1] * qNormalized[0]);
+      }
+      this.notify(inclination);
+    });
+  }
+  start() {
+    this.providerId = AccelerometerProvider$1.addEventListener(
+      this.onAccelerometerEvent,
+      this.notifyError
+    );
+  }
+  stop() {
+    AccelerometerProvider$1.removeEventListener(this.providerId);
+  }
+}
+const InclinationFromAccProvider$1 = new InclinationFromAccProvider();
+class InclinationFromRelativeAttitudeProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "providerId");
+    __publicField(this, "getName", () => "InclinationFromRelativeAttitude");
+    __publicField(this, "availability", () => RelativeAttitudeFromInertialProvider.getAvailability());
+  }
+  start() {
+    this.providerId = RelativeAttitudeFromInertialProvider.addEventListener(
+      (attitudeEvent) => {
+        const inclination = this.enuQuatToInclination(attitudeEvent.quaternion);
+        this.notify(inclination);
+      },
+      this.notifyError
+    );
+  }
+  stop() {
+    RelativeAttitudeFromInertialProvider.removeEventListener(this.providerId);
+  }
+  enuQuatToInclination(q) {
+    const screenOrientation = window.orientation || 0;
+    if (screenOrientation === 0) {
+      return Math.asin(2 * (q[2] * q[3] + q[1] * q[0]));
+    } else if (screenOrientation === 90) {
+      return Math.asin(2 * (q[1] * q[3] - q[2] * q[0]));
+    } else if (screenOrientation === -90) {
+      return Math.asin(2 * (q[2] * q[0] - q[1] * q[3]));
+    }
+    return -Math.asin(2 * (q[2] * q[3] + q[1] * q[0]));
+  }
+}
+const InclinationFromRelativeAttitudeProvider$1 = new InclinationFromRelativeAttitudeProvider();
+class InclinationProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "provider");
+    __publicField(this, "providerId");
+    __publicField(this, "getName", () => "Inclination");
+  }
+  availability() {
+    return AvailabilityHelper.some([
+      InclinationFromAccProvider$1.getAvailability(),
+      InclinationFromRelativeAttitudeProvider$1.getAvailability()
+    ]);
+  }
+  async start() {
+    const startInclinationFromAcc = () => {
+      this.provider = InclinationFromAccProvider$1;
+      this.providerId = this.provider.addEventListener(
+        this.notify,
+        this.notifyError
+      );
+    };
+    if (await InclinationFromRelativeAttitudeProvider$1.getAvailability()) {
+      this.provider = InclinationFromRelativeAttitudeProvider$1;
+      this.providerId = this.provider.addEventListener(
+        this.notify,
+        () => {
+          InclinationFromRelativeAttitudeProvider$1.removeEventListener(this.providerId);
+          startInclinationFromAcc();
+        }
+      );
+    } else {
+      startInclinationFromAcc();
+    }
+  }
+  stop() {
+    if (this.provider) {
+      this.provider.removeEventListener(this.providerId);
+    }
+  }
+}
+const InclinationProvider$1 = new InclinationProvider();
+class VpsMetadata {
+  constructor(size, calibration = null, coarse = null, device = null) {
+    this.size = size;
+    this.calibration = calibration;
+    this.coarse = coarse;
+    this.device = device;
+  }
+  toJson() {
+    return {
+      size: [this.size.width, this.size.height],
+      ...this.calibration && { calibration: this.calibration },
+      ...this.coarse && {
+        coarse: {
+          ...this.coarse.attitude && { attitude: this.coarse.attitude.toJson() },
+          ...this.coarse.position && { position: this.coarse.position.toJson() }
+        }
+      },
+      ...typeof this.device === "object" && { device: this.device }
+    };
+  }
+  static fromJson(json) {
+    var _a, _b;
+    return new VpsMetadata(
+      {
+        width: json.size[0],
+        height: json.size[1]
+      },
+      json.calibration,
+      {
+        ...((_a = json.coarse) == null ? void 0 : _a.position) && { position: geo.UserPosition.fromJson(json.coarse.position) },
+        ...((_b = json.coarse) == null ? void 0 : _b.attitude) && { attitude: geo.Attitude.fromJson(json.coarse.attitude) }
+      },
+      json.device
+    );
+  }
+}
+class VpsRequest {
+  constructor(metadata, image) {
+    this.metadata = metadata;
+    this.image = image;
+  }
+  toJson() {
+    const base64Image = camera.canvasToBase64(this.image);
+    return {
+      image: base64Image,
+      ...this.metadata.toJson()
+    };
+  }
+  static fromJson(json) {
+    return new VpsRequest(
+      VpsMetadata.fromJson(json),
+      camera.base64ToCanvas(json.image)
+    );
+  }
+}
+class VpsResponse {
+  constructor(success, attitude = null, position = null) {
+    this.success = success;
+    this.attitude = attitude;
+    this.position = position;
+  }
+  toJson() {
+    var _a, _b;
+    return {
+      success: this.success,
+      attitude: (_a = this.attitude) == null ? void 0 : _a.toJson(),
+      position: (_b = this.position) == null ? void 0 : _b.toJson()
+    };
+  }
+  static fromJson(json, imageRecordTime = null) {
+    let attitude = null;
+    if (json.attitude) {
+      attitude = geo.Attitude.fromJson(json.attitude);
+      attitude.time = imageRecordTime;
+    }
+    let position = null;
+    if (json.position) {
+      position = geo.UserPosition.fromJson(json.position);
+      position.time = imageRecordTime;
+    }
+    return new VpsResponse(json.success, attitude, position);
+  }
+}
+class ImageRelocalization {
+  static _prepareRequest(imageCanvas, calibration = null, coarsePose = null) {
+    camera.convertToGrayscale(imageCanvas);
+    const reducedImage = camera.reduceImageSize(imageCanvas, 1280);
+    const metadata = new VpsMetadata(
+      { width: reducedImage.width, height: reducedImage.height },
+      calibration,
+      coarsePose,
+      utils.UserAgentUtils.getDeviceFromUserAgent()
+    );
+    return new VpsRequest(metadata, reducedImage);
+  }
+  static async relocalize(endpointUrl, imageCanvas, calibration = null, coarsePose = null, customHeaders = null) {
+    const timeBeforeRequest = utils.TimeUtils.preciseTime() / 1e3;
+    const vpsRequest = this._prepareRequest(imageCanvas, calibration, coarsePose);
+    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}`);
+      serverResponse = await fetch(endpointUrl, {
+        method: "POST",
+        body,
+        headers: Object.assign(
+          { "Content-Type": "application/json", "Accept": "application/json" },
+          customHeaders ? customHeaders : {}
+        )
+      });
+    } catch (e) {
+      Logger__default.default.debug("[VPS] Server respond error");
+      return null;
+    }
+    if (serverResponse.status !== 200) {
+      Logger__default.default.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"}`);
+    return res;
+  }
+  static getHeadingFromQuaternion(quaternion) {
+    const [qw, qx, qy, qz] = quaternion;
+    const s = Math.sqrt(2) / 2;
+    const C = [s * (qw - qx), s * (qw + qx), s * (qy + qz), s * (qz - qy)];
+    return -Math.atan2(2 * C[3] * C[0] - 2 * C[2] * C[1], 1 - 2 * C[1] ** 2 - 2 * C[3] ** 2);
+  }
+}
+class RelativeRotationCalc {
+  constructor() {
+    __publicField(this, "_providerId");
+    __publicField(this, "_isRunning", false);
+    __publicField(this, "_dataOnStart", null);
+  }
+  tickStart() {
+    this._dataOnStart = null;
+    if (this._isRunning) {
+      return;
+    }
+    this._isRunning = true;
+    this._providerId = RelativeAttitudeFromBrowser$1.addEventListener((event) => {
+      if (!this._dataOnStart) {
+        this._dataOnStart = event;
+      }
+    });
+  }
+  tickEnd() {
+    if (!this._isRunning) {
+      Logger__default.default.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.");
+      return null;
+    }
+    const dataOnEnd = RelativeAttitudeFromBrowser$1.lastEvent;
+    return geo.Attitude.diff(this._dataOnStart, dataOnEnd);
+  }
+  _internalStop() {
+    RelativeAttitudeFromBrowser$1.removeEventListener(this._providerId);
+    delete this._providerId;
+    this._isRunning = false;
+  }
+  release() {
+    if (this._isRunning) {
+      this._internalStop();
+    }
+  }
+}
+const _MissingPoleStarError = class extends Error {
+  constructor(message) {
+    super(message || _MissingPoleStarError.DEFAULT_MESSAGE);
+  }
+};
+let MissingPoleStarError = _MissingPoleStarError;
+__publicField(MissingPoleStarError, "DEFAULT_MESSAGE", "PoleStar is missing");
+class PoleStarProvider extends Provider {
+  constructor() {
+    super();
+    __publicField(this, "getName", () => "PoleStar");
+    this.addMethodsToNativeJsProvider();
+  }
+  availability() {
+    try {
+      this.nativeProvider.checkAvailability();
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.resolve(e);
+    }
+  }
+  setApiKey(apiKey) {
+    this.nativeProvider.setApiKey(apiKey);
+  }
+  start() {
+    this.nativeProvider.start();
+  }
+  stop() {
+    this.nativeProvider.stop();
+  }
+  get nativeProvider() {
+    if (!this.nativeInterface) {
+      throw new MissingNativeInterfaceError();
+    }
+    const nativeProvider = this.nativeInterface.getPoleStarProvider();
+    if (!nativeProvider) {
+      throw new MissingPoleStarError();
+    }
+    return nativeProvider;
+  }
+  addMethodsToNativeJsProvider() {
+    if (!this.nativeJsInterface) {
+      return;
+    }
+    this.nativeJsInterface.polestar = {
+      callbackError: (errorMessage) => this.notifyError(new Error(errorMessage)),
+      callbackPosition: (jsonString) => {
+        const json = JSON.parse(jsonString);
+        const timestamp = utils.TimeUtils.unixTimestampToPreciseTime(json.time) / 1e3;
+        const position = new AbsolutePosition(
+          json.lat,
+          json.lng,
+          Constants.DEFAULT_ALTITUDE,
+          json.alt / 5,
+          timestamp,
+          json.accuracy,
+          maths.deg2rad(json.bearing)
+        );
+        this.notify(position);
+      }
+    };
+  }
+}
+const PoleStarProvider$1 = new PoleStarProvider();
+const _VpsProvider = class extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_relativeRotationCalc");
+    __publicField(this, "_serverError", false);
+    __publicField(this, "_cameraError", false);
+    __publicField(this, "_camera", null);
+    __publicField(this, "_endpoint", null);
+    __publicField(this, "_inclinationProviderId");
+    __publicField(this, "_minInclinationForRequest", _VpsProvider.DEFAULT_MIN_INCLINATION_FOR_REQUEST);
+    __publicField(this, "_waitTimeMinInclinationForRequest", _VpsProvider.DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST);
+    __publicField(this, "_useCoarsePose", _VpsProvider.DEFAULT_USE_COARSE_POSE);
+    __publicField(this, "getName", () => "Vps");
+    __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...");
+      }
+      this._useCamera(camera2);
+    });
+    __publicField(this, "_onCameraRemoved", () => {
+      if (this._camera) {
+        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");
+      }
+      this._camera = null;
+    });
+    __publicField(this, "_internalStart", async () => {
+      var _a, _b;
+      if (!this._endpoint) {
+        this.notifyError(new Error("VPS endpoint has not been set before calling start()"));
+        return;
+      }
+      let lastRequestTime = null;
+      const isProviderStopped = () => this.state === "stopped";
+      while (!isProviderStopped()) {
+        if (lastRequestTime !== null) {
+          const diffTime = utils.TimeUtils.preciseTime() - lastRequestTime;
+          const timeToWait = Math.max(0, _VpsProvider.MIN_TIME_BETWEEN_TWO_REQUESTS - diffTime);
+          await new Promise((resolve) => setTimeout(resolve, timeToWait));
+        }
+        lastRequestTime = utils.TimeUtils.preciseTime();
+        if (isProviderStopped() || !this._camera || this._camera.state !== "started") {
+          break;
+        }
+        const inclination = InclinationProvider$1.lastEvent ? InclinationProvider$1.lastEvent : null;
+        if (inclination !== null && inclination < this._minInclinationForRequest) {
+          await new Promise((resolve) => setTimeout(resolve, this._waitTimeMinInclinationForRequest));
+          continue;
+        }
+        (_a = this._relativeRotationCalc) == null ? void 0 : _a.tickStart();
+        const image = await this._camera.currentImage;
+        if (!image) {
+          continue;
+        }
+        let coarsePose = null;
+        const bestCoarsePosition = AbsolutePositionProvider$1.getBestPositionEvent(GnssWifiProvider$1.lastEvent, PoleStarProvider$1.lastEvent);
+        if (this._useCoarsePose && (bestCoarsePosition || AbsoluteAttitudeProvider$1.lastEvent)) {
+          coarsePose = {
+            ...bestCoarsePosition && { position: bestCoarsePosition },
+            ...AbsoluteAttitudeProvider$1.lastEvent && { attitude: AbsoluteAttitudeProvider$1.lastEvent }
+          };
+        }
+        const res = await ImageRelocalization.relocalize(this._endpoint, image, null, coarsePose);
+        if (!res || !res.success) {
+          continue;
+        }
+        const enuToCameraRot = res.attitude.quaternion;
+        const enuToSmartphoneRot = maths.Quaternion.multiply(
+          enuToCameraRot,
+          _VpsProvider.CAMERA_TO_SMARTPHONE_ROT
+        );
+        const deviceQuaternion = maths.Quaternion.multiply(
+          maths.Quaternion.fromAxisAngle([0, 0, 1], maths.deg2rad(window.orientation || 0)),
+          enuToSmartphoneRot
+        );
+        const diffAttitude = ((_b = this._relativeRotationCalc) == null ? void 0 : _b.tickEnd()) || new geo.Attitude([1, 0, 0, 0]);
+        const deviceQuaternionWithRelOffset = maths.Quaternion.multiply(
+          deviceQuaternion,
+          diffAttitude.quaternion
+        );
+        const attitude = new AbsoluteAttitude(
+          deviceQuaternionWithRelOffset,
+          res.attitude.time,
+          res.attitude.accuracy
+        );
+        const devicePosition = res.position.clone();
+        if (devicePosition.accuracy === null) {
+          devicePosition.accuracy = 5;
+        }
+        if (isProviderStopped()) {
+          break;
+        }
+        this.notify({
+          absoluteAttitude: attitude,
+          absolutePosition: devicePosition
+        });
+      }
+    });
+    __publicField(this, "_internalStop", () => {
+    });
+  }
+  start() {
+    this._inclinationProviderId = InclinationProvider$1.addEventListener();
+    this._relativeRotationCalc = new RelativeRotationCalc();
+    camera.SharedCameras.on("added", this._onCameraDetected);
+    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...");
+      }
+      this._useCamera(camera.SharedCameras.list[0].camera);
+    }
+  }
+  stop() {
+    var _a;
+    InclinationProvider$1.removeEventListener(this._inclinationProviderId);
+    (_a = this._relativeRotationCalc) == null ? void 0 : _a.release();
+    camera.SharedCameras.off("added", this._onCameraDetected);
+    camera.SharedCameras.off("removed", this._onCameraRemoved);
+    this._camera = null;
+  }
+  _useCamera(camera2) {
+    this._camera = camera2;
+    camera2.on("started", this._internalStart);
+    camera2.on("stopped", this._internalStop);
+    if (camera2.state === "started") {
+      this._internalStart();
+    }
+  }
+  get endpoint() {
+    return this._endpoint;
+  }
+  set endpoint(endpoint) {
+    this._endpoint = endpoint;
+  }
+  get minInclinationForRequest() {
+    return this._minInclinationForRequest;
+  }
+  set minInclinationForRequest(minInclinationForRequest) {
+    this._minInclinationForRequest = minInclinationForRequest;
+  }
+  get waitTimeMinInclinationForRequest() {
+    return this._waitTimeMinInclinationForRequest;
+  }
+  set waitTimeMinInclinationForRequest(waitTimeMinInclinationForRequest) {
+    this._waitTimeMinInclinationForRequest = waitTimeMinInclinationForRequest;
+  }
+  get useCoarsePose() {
+    return this._useCoarsePose;
+  }
+  set useCoarsePose(useCoarsePose) {
+    this._useCoarsePose = useCoarsePose;
+  }
+};
+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 {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_polestarProviderId");
+    __publicField(this, "_vpsProviderId");
+    __publicField(this, "_gnssWifiProviderId");
+    __publicField(this, "_relativePositionProviderId");
+    __publicField(this, "_mapMatchingHandlerId");
+    __publicField(this, "useAllAbsolutePositions", false);
+    __publicField(this, "_waitUntilNextVpsPosition", false);
+    __publicField(this, "_lastPolestarFix", null);
+    __publicField(this, "getName", () => "AbsolutePosition");
+  }
+  availability() {
+    return AvailabilityHelper.some([
+      GeoRelativePositionProvider$1.getAvailability(),
+      GnssWifiProvider$1.getAvailability(),
+      ...ProvidersOptions.hasPoleStar ? [PoleStarProvider$1.getAvailability()] : [],
+      VpsProvider$1.getAvailability()
+    ]);
+  }
+  start() {
+    GeoRelativePositionProvider$1.getAvailability().then((error) => {
+      if (!error) {
+        this._relativePositionProviderId = GeoRelativePositionProvider$1.addEventListener(this._onRelativePosition);
+      }
+    });
+    this._gnssWifiProviderId = GnssWifiProvider$1.addEventListener(
+      (event) => {
+        const clone = event.clone();
+        clone.bearing = null;
+        this._onAbsolutePosition(clone, false);
+      }
+    );
+    this._vpsProviderId = VpsProvider$1.addEventListener(
+      (event) => this._onAbsolutePosition(event.absolutePosition),
+      this.notifyError,
+      false
+    );
+    if (ProvidersOptions.hasPoleStar) {
+      this._polestarProviderId = PoleStarProvider$1.addEventListener((polestarPositionEvent) => {
+        var _a;
+        this._lastPolestarFix = utils.TimeUtils.preciseTime();
+        const psPositionUsed = this._onAbsolutePosition(polestarPositionEvent);
+        if (!psPositionUsed && ((_a = this.lastEvent) == null ? void 0 : _a.level) === null) {
+          const lastPositionWithLevel = this.lastEvent.clone();
+          lastPositionWithLevel.level = polestarPositionEvent.level;
+          this.notify(lastPositionWithLevel);
+        }
+      });
+    }
+    this._mapMatchingHandlerId = MapMatchingHandler$1.addEventListener();
+  }
+  stop() {
+    if (this._relativePositionProviderId) {
+      GeoRelativePositionProvider$1.removeEventListener(this._relativePositionProviderId);
+      delete this._relativePositionProviderId;
+    }
+    if (this._gnssWifiProviderId) {
+      GnssWifiProvider$1.removeEventListener(this._gnssWifiProviderId);
+      delete this._gnssWifiProviderId;
+    }
+    if (this._vpsProviderId) {
+      VpsProvider$1.removeEventListener(this._vpsProviderId);
+      delete this._vpsProviderId;
+    }
+    if (this._polestarProviderId) {
+      PoleStarProvider$1.removeEventListener(this._polestarProviderId);
+      delete this._polestarProviderId;
+    }
+    MapMatchingHandler$1.removeEventListener(this._mapMatchingHandlerId);
+  }
+  _shouldTakeIntoAccountNewAbsolutePosition(newPositionEvent, canContainLevel = true) {
+    const newPosition = newPositionEvent;
+    const lastPosition = this.lastEvent || null;
+    if (!lastPosition) {
+      return true;
+    }
+    const isBetterEnough = newPosition.accuracy * _AbsolutePositionProvider.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
+    if (isBetterEnough) {
+      return true;
+    }
+    const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
+    if (isFarEnough) {
+      return true;
+    }
+    const isFarEnoughAndAccuracyIsBetter = isFarEnough && newPosition.accuracy <= lastPosition.accuracy;
+    if (isBetterEnough && isFarEnoughAndAccuracyIsBetter) {
+      return true;
+    }
+    const isChangingLevel = canContainLevel && !geo.Level.equals(newPosition.level, lastPosition.level);
+    if (isChangingLevel) {
+      return true;
+    }
+    return false;
+  }
+  _onAbsolutePosition(positionEvent, canContainLevel = true) {
+    if (!this._shouldTakeIntoAccountNewAbsolutePosition(positionEvent, canContainLevel) && !this.useAllAbsolutePositions) {
+      return false;
+    }
+    const newPosition = positionEvent.clone();
+    const lastPosition = this.lastEvent ? this.lastEvent : null;
+    if (lastPosition) {
+      if (!canContainLevel) {
+        newPosition.level = lastPosition.level;
+      }
+      if (newPosition.bearing === null) {
+        newPosition.bearing = lastPosition.bearing;
+      }
+    }
+    if (!MapMatchingHandler$1.canUseMapMatching()) {
+      this.notify(newPosition);
+      return true;
+    }
+    return MapMatchingHandler$1.notifyPositionFromAbsolute(newPosition);
+  }
+  _onRelativePosition(relativeEvent) {
+    if (!this.lastEvent || this._waitUntilNextVpsPosition) {
+      return false;
+    }
+    const lastPosition = this.lastEvent;
+    const offsetPos = relativeEvent;
+    const dist = Math.sqrt(offsetPos.x ** 2 + offsetPos.y ** 2);
+    const bearing = Math.atan2(offsetPos.x, offsetPos.y);
+    const alt = lastPosition.alt !== null ? offsetPos.z : null;
+    const newPosition = lastPosition.destinationPoint(dist, bearing, alt);
+    newPosition.bearing = offsetPos.bearing;
+    newPosition.time = offsetPos.time;
+    newPosition.accuracy += offsetPos.accuracy;
+    if (!MapMatchingHandler$1.canUseMapMatching()) {
+      this.notify(newPosition);
+      return true;
+    }
+    return MapMatchingHandler$1.notifyPositionFromRelative(newPosition);
+  }
+  feed(data) {
+    let newPositionEvent;
+    if (data instanceof geo.UserPosition) {
+      if (data.time === null) {
+        throw Error("the time of the position is not defined");
+      }
+      if (data.accuracy === null) {
+        throw Error("the accuracy of the position is not defined");
+      }
+      newPositionEvent = data;
+    } else {
+      throw new Error("data is nor an UserPosition or an AbsolutePositionEvent");
+    }
+    if (!_AbsolutePositionProvider.USE_MM_FOR_FEED || !MapMatchingHandler$1.canUseMapMatching()) {
+      this.notify(newPositionEvent);
+      return;
+    }
+    MapMatchingHandler$1.notifyPositionFromFeed(newPositionEvent);
+  }
+  getBestPositionEvent(...absolutePositionEvents) {
+    return absolutePositionEvents.reduce((best, value) => {
+      if (!best) {
+        return value;
+      }
+      if (!value || value.accuracy === null || value.time === null) {
+        return best;
+      }
+      const { accuracy: curAccuracy, time: curTime } = value;
+      const { accuracy: bestAccuracy, time: bestTime } = best;
+      return curAccuracy < bestAccuracy + 1.3888 * (curTime - bestTime) ? value : best;
+    }, null);
+  }
+};
+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);
+    __publicField(this, "DEFAULT_ACCURACY", maths.deg2rad(15));
+    __publicField(this, "absolutePositionProviderId");
+    __publicField(this, "absolutePositionEvent");
+    __publicField(this, "declinationQuaternion");
+    __publicField(this, "magQuaternion");
+    __publicField(this, "magQuaternionTimestamp");
+    __publicField(this, "iosPreviousQuat");
+    __publicField(this, "iosIsSkyMode", null);
+    __publicField(this, "getName", () => "AbsoluteAttitudeFromBrowser");
+    __publicField(this, "onDeviceOrientationChromeEvent", (e) => {
+      this.magQuaternionTimestamp = e.timeStamp / 1e3;
+      if (typeof e.alpha !== "number" || typeof e.beta !== "number" || typeof e.gamma !== "number") {
+        this.notifyError(new MissingSensorError().from("deviceorientationabsolute"));
+        return;
+      }
+      this.magQuaternion = maths.Rotations.eulerToQuaternionZXYDegrees(
+        [e.alpha, e.beta, e.gamma]
+      );
+      this.compute();
+    });
+    __publicField(this, "onDeviceOrientationSafariEvent", (e) => {
+      this.magQuaternionTimestamp = e.timeStamp / 1e3;
+      if (typeof e.beta !== "number" || typeof e.gamma !== "number") {
+        this.notifyError(new MissingSensorError().from("deviceorientation"));
+        return;
+      }
+      if (typeof e.webkitCompassHeading !== "number") {
+        super.notifyError(new MissingMagnetometerError().from("deviceorientation"));
+        return;
+      }
+      let alpha;
+      const [qw, qx, qy, qz] = maths.Rotations.eulerToQuaternionZXYDegrees([e.webkitCompassHeading, e.beta, e.gamma]);
+      const groundAngle = maths.rad2deg(Math.acos(qw ** 2 - qx ** 2 - qy ** 2 + qz ** 2));
+      let isSkyMode = null;
+      if (groundAngle > 136) {
+        isSkyMode = true;
+      } else if (groundAngle < 134) {
+        isSkyMode = false;
+      } else if (this.iosPreviousQuat && this.iosIsSkyMode !== null) {
+        isSkyMode = maths.Quaternion.distance([qw, qx, qy, qz], this.iosPreviousQuat) < 0.5 ? this.iosIsSkyMode : !this.iosIsSkyMode;
+      }
+      this.iosPreviousQuat = [qw, qx, qy, qz];
+      this.iosIsSkyMode = isSkyMode;
+      if (typeof isSkyMode === "undefined") {
+        return;
+      }
+      if (isSkyMode) {
+        alpha = 180 - e.webkitCompassHeading;
+      } else {
+        alpha = AbsoluteAttitudeFromBrowser.webkitCompassToHeading(
+          e.webkitCompassHeading,
+          e.beta,
+          e.gamma
+        );
+      }
+      this.magQuaternion = maths.Rotations.eulerToQuaternionZXYDegrees([alpha, e.beta, e.gamma]);
+      this.compute();
+    });
+    __publicField(this, "onAbsolutePositionEvent", (position) => {
+      this.absolutePositionEvent = position;
+      const wmmResult = geomagnetism__default.default.model().point([position.lat, position.lng]);
+      this.declinationQuaternion = maths.Quaternion.fromAxisAngle([0, 0, 1], -maths.deg2rad(wmmResult.decl));
+      AbsolutePositionProvider$1.removeEventListener(this.absolutePositionProviderId);
+      delete this.absolutePositionProviderId;
+      this.compute();
+    });
+  }
+  availability() {
+    return utils.BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
+  }
+  start() {
+    const subscribe = () => {
+      switch (utils.BrowserUtils.name) {
+        case utils.Browser.CHROME:
+          window.addEventListener(
+            "deviceorientationabsolute",
+            this.onDeviceOrientationChromeEvent,
+            true
+          );
+          break;
+        case utils.Browser.SAFARI:
+        case utils.Browser.IOS_WEBVIEW:
+          window.addEventListener(
+            "deviceorientation",
+            this.onDeviceOrientationSafariEvent,
+            true
+          );
+          break;
+      }
+    };
+    const requestPermission = DeviceOrientationEvent.requestPermission || void 0;
+    if (requestPermission) {
+      requestPermission().then((response) => {
+        if (response !== "granted") {
+          throw new Error("Permission not granted");
+        }
+        subscribe();
+      }).catch(this.notifyError);
+    } else {
+      subscribe();
+    }
+    const lastAbsolutePosition = AbsolutePositionProvider$1.lastEvent;
+    if (lastAbsolutePosition) {
+      this.onAbsolutePositionEvent(lastAbsolutePosition);
+    } else {
+      this.absolutePositionProviderId = AbsolutePositionProvider$1.addEventListener(
+        this.onAbsolutePositionEvent,
+        this.notifyError,
+        false
+      );
+    }
+  }
+  stop() {
+    switch (utils.BrowserUtils.name) {
+      case utils.Browser.CHROME:
+        window.removeEventListener(
+          "deviceorientationabsolute",
+          this.onDeviceOrientationChromeEvent,
+          true
+        );
+        break;
+      case utils.Browser.SAFARI:
+      case utils.Browser.IOS_WEBVIEW:
+        window.removeEventListener(
+          "deviceorientation",
+          this.onDeviceOrientationSafariEvent,
+          true
+        );
+        break;
+    }
+    AbsolutePositionProvider$1.removeEventListener(this.absolutePositionProviderId);
+  }
+  compute() {
+    if (!this.declinationQuaternion || !this.magQuaternion || !this.absolutePositionEvent) {
+      return;
+    }
+    const trueQuaternion = maths.Quaternion.multiply(this.declinationQuaternion, this.magQuaternion);
+    const attitude = new AbsoluteAttitude(trueQuaternion, this.magQuaternionTimestamp, this.DEFAULT_ACCURACY);
+    this.notify(attitude);
+  }
+  static webkitCompassToHeading(_webkitCompassHeading, _beta, _gamma) {
+    const webkitCompassHeading = maths.deg2rad(_webkitCompassHeading);
+    const beta = maths.deg2rad(_beta);
+    const gamma = maths.deg2rad(_gamma);
+    const c1 = Math.cos(webkitCompassHeading / 2);
+    const c2 = Math.cos(beta / 2);
+    const c3 = Math.cos(gamma / 2);
+    const s1 = Math.sin(webkitCompassHeading / 2);
+    const s2 = Math.sin(beta / 2);
+    const s3 = Math.sin(gamma / 2);
+    const qw = c1 * c2 * c3 - s1 * s2 * s3;
+    const qz = s1 * c2 * c3 + c1 * s2 * s3;
+    return maths.rad2deg(-2 * Math.atan(qz / qw));
+  }
+}
+const AbsoluteAttitudeFromBrowser$1 = new AbsoluteAttitudeFromBrowser();
+class RelativeAttitudeProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "arCoreMonitoringId");
+    __publicField(this, "arCoreProviderId");
+    __publicField(this, "inertialProviderId");
+    __publicField(this, "getName", () => "RelativeAttitude");
+    __publicField(this, "availability", () => RelativeAttitudeFromInertialProvider.getAvailability());
+    __publicField(this, "listenInertial", () => {
+      this.inertialProviderId = RelativeAttitudeFromInertialProvider.addEventListener(
+        this.notify,
+        this.notifyError
+      );
+    });
+    __publicField(this, "unlistenInertial", () => {
+      RelativeAttitudeFromInertialProvider.removeEventListener(this.inertialProviderId);
+    });
+    __publicField(this, "listenArCore", () => {
+      this.arCoreProviderId = ArCoreProvider$1.addEventListener(
+        (event) => this.notify(event.relativeAttitude),
+        null,
+        false
+      );
+    });
+    __publicField(this, "unlistenArCore", () => {
+      ArCoreProvider$1.removeEventListener(this.arCoreProviderId);
+    });
+  }
+  start() {
+    this.arCoreMonitoringId = ArCoreProvider$1.addMonitoringListener(
+      () => {
+        this.listenArCore();
+        this.unlistenInertial();
+      },
+      () => {
+        this.unlistenArCore();
+        this.listenInertial();
+      }
+    );
+    if (ArCoreProvider$1.state === "started") {
+      this.listenArCore();
+    } else {
+      this.listenInertial();
+    }
+  }
+  stop() {
+    ArCoreProvider$1.removeMonitoringListener(this.arCoreMonitoringId);
+    this.unlistenArCore();
+    this.unlistenInertial();
+  }
+}
+const RelativeAttitudeProvider$1 = new RelativeAttitudeProvider();
+const _AbsoluteAttitudeProvider = class extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_absAttitudeFromBrowser");
+    __publicField(this, "_vpsProviderId");
+    __publicField(this, "fromBrowserProviderId");
+    __publicField(this, "highRotationProviderId");
+    __publicField(this, "inclinationProviderId");
+    __publicField(this, "relativeAttitudeProviderId");
+    __publicField(this, "_attitudeFromBrowserErrored", false);
+    __publicField(this, "_attitudeFromRelativeErrored", false);
+    __publicField(this, "_relativeAttitude", null);
+    __publicField(this, "_relativeAccuracy", 0);
+    __publicField(this, "_lastForcedHeadingEvent");
+    __publicField(this, "_relAbsQuat");
+    __publicField(this, "_wasHighRotationInProgress", false);
+    __publicField(this, "_timeFirstDivergence", null);
+    __publicField(this, "_callbackMagCalibration");
+    __publicField(this, "getName", () => "AbsoluteAttitude");
+    __publicField(this, "_onError", (error) => {
+      if (this._attitudeFromBrowserErrored && this._attitudeFromRelativeErrored) {
+        this.notifyError(error);
+      }
+    });
+    __publicField(this, "_forceHeadingForRelative", (absoluteHeadingEvent) => {
+      if (this.lastEvent && absoluteHeadingEvent.accuracy > this.lastEvent.accuracy) {
+        return;
+      }
+      const calcForceHeading = (relativeAttitude) => {
+        const currentRelativeHeading = relativeAttitude.heading;
+        this._relAbsQuat = maths.Quaternion.fromAxisAngle(
+          [0, 0, 1],
+          currentRelativeHeading - absoluteHeadingEvent.heading
+        );
+        this._relativeAccuracy = 0;
+        this._lastForcedHeadingEvent = absoluteHeadingEvent;
+      };
+      if (this._relativeAttitude) {
+        calcForceHeading(this._relativeAttitude);
+        return;
+      }
+      const providerId = RelativeAttitudeProvider$1.addEventListener(
+        (event) => {
+          calcForceHeading(event);
+          RelativeAttitudeProvider$1.removeEventListener(providerId);
+        }
+      );
+    });
+    __publicField(this, "_onRelativeAttitudeEvent", (event) => {
+      var _a;
+      const { quaternion, accuracy, time } = event;
+      if (this._relativeAttitude) {
+        this._relativeAccuracy += (time - this._relativeAttitude.time) * accuracy;
+      }
+      this._relativeAttitude = event;
+      if (!this._lastForcedHeadingEvent || !this._relAbsQuat) {
+        return;
+      }
+      const accuracyWithRelative = Math.min(
+        (this._lastForcedHeadingEvent.accuracy || 0) + this._relativeAccuracy,
+        Math.PI
+      );
+      const highRotationInProgress = HighRotationsProvider$1.isInProgress();
+      let divergenceDetected = false;
+      if (this._absAttitudeFromBrowser) {
+        const {
+          accuracy: accuracyWithAbsolute,
+          heading: headingFromAbsolute
+        } = this._absAttitudeFromBrowser;
+        if (this._wasHighRotationInProgress && !highRotationInProgress) {
+          this._forceHeadingForRelative(this._absAttitudeFromBrowser);
+        } else if (accuracyWithAbsolute < accuracyWithRelative) {
+          const relativeQuaternion = maths.Quaternion.multiply(this._relAbsQuat, quaternion);
+          const relativeAttitude = new geo.Attitude(relativeQuaternion);
+          const angle = Math.abs(maths.diffAngle(relativeAttitude.heading, headingFromAbsolute));
+          const inclination = InclinationProvider$1.lastEvent;
+          if (angle > _AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_ANGLE_THRESHOLD && inclination !== null && Math.abs(inclination - Math.PI / 4) > _AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD) {
+            divergenceDetected = true;
+            if (this._timeFirstDivergence !== null && time - this._timeFirstDivergence > _AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_TIME_THRESHOLD) {
+              this._forceHeadingForRelative(this._absAttitudeFromBrowser);
+              (_a = this._callbackMagCalibration) == null ? void 0 : _a.call(this, { angle });
+              this._timeFirstDivergence = null;
+            } else if (this._timeFirstDivergence === null) {
+              this._timeFirstDivergence = time;
+            }
+          }
+        }
+      }
+      if (!divergenceDetected) {
+        this._timeFirstDivergence = null;
+      }
+      this._wasHighRotationInProgress = highRotationInProgress;
+      const absoluteQuat = maths.Quaternion.multiply(this._relAbsQuat, quaternion);
+      const attitude = new AbsoluteAttitude(absoluteQuat, time, accuracyWithRelative);
+      this.notify(attitude);
+    });
+    __publicField(this, "_onAttitudeFromBrowser", (event) => {
+      this._absAttitudeFromBrowser = event;
+      if (!this._lastForcedHeadingEvent) {
+        this._forceHeadingForRelative(event);
+        return;
+      }
+    });
+    __publicField(this, "_onAttitudeFromVps", (event) => {
+      this._forceHeadingForRelative(event);
+    });
+  }
+  availability() {
+    return AvailabilityHelper.some([
+      AbsoluteAttitudeFromBrowser$1.getAvailability(),
+      RelativeAttitudeProvider$1.getAvailability()
+    ]);
+  }
+  start() {
+    this.fromBrowserProviderId = AbsoluteAttitudeFromBrowser$1.addEventListener(
+      this._onAttitudeFromBrowser,
+      (error) => {
+        this._attitudeFromBrowserErrored = true;
+        this._onError(error);
+      }
+    );
+    this._vpsProviderId = VpsProvider$1.addEventListener(
+      (event) => this._onAttitudeFromVps(event.absoluteAttitude),
+      (error) => this.notifyError(error),
+      false
+    );
+    this.relativeAttitudeProviderId = RelativeAttitudeProvider$1.addEventListener(
+      this._onRelativeAttitudeEvent,
+      (error) => {
+        this._attitudeFromRelativeErrored = true;
+        this._onError(error);
+      }
+    );
+    this.inclinationProviderId = InclinationProvider$1.addEventListener();
+    this.highRotationProviderId = HighRotationsProvider$1.addEventListener();
+  }
+  stop() {
+    AbsoluteAttitudeFromBrowser$1.removeEventListener(this.fromBrowserProviderId);
+    RelativeAttitudeProvider$1.removeEventListener(this.relativeAttitudeProviderId);
+    InclinationProvider$1.removeEventListener(this.inclinationProviderId);
+    HighRotationsProvider$1.removeEventListener(this.highRotationProviderId);
+    VpsProvider$1.removeEventListener(this._vpsProviderId);
+  }
+  _setCallbackMagCalibration(cb) {
+    this._callbackMagCalibration = cb;
+  }
+  feed(data) {
+    if (data instanceof geo.AbsoluteHeading) {
+      if (data.time === null) {
+        throw Error("the time of the absolute heading is not defined");
+      }
+      if (data.accuracy === null) {
+        throw Error("the accuracy of the absolute heading is not defined");
+      }
+      this._forceHeadingForRelative(data);
+    } else if (data instanceof AbsoluteAttitude) {
+      if (data.time === null) {
+        throw Error("the time of the attitude is not defined");
+      }
+      if (data.accuracy === null) {
+        throw Error("the accuracy of the attitude is not defined");
+      }
+      this._forceHeadingForRelative(data);
+    } else {
+      throw new Error("data is nor an AbsoluteHeading or an Attitude object");
+    }
+  }
+};
+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 {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "providerId");
+    __publicField(this, "slidingWindow", []);
+    __publicField(this, "getName", () => "Turn");
+    __publicField(this, "availability", () => RelativeAttitudeProvider$1.getAvailability());
+    __publicField(this, "_parseRelativeAttitude", (relativeAttitudeEvent) => {
+      const { heading } = relativeAttitudeEvent;
+      const timestamp = relativeAttitudeEvent.time;
+      this.slidingWindow = this.slidingWindow.filter((item) => item[0] >= timestamp - _TurnProvider.SLIDING_WINDOW_TIME);
+      this.slidingWindow.push([timestamp, heading]);
+      const stdVal = maths.std(this.slidingWindow.map((item) => item[1]));
+      if (stdVal > _TurnProvider.STD_THRESHOLD) {
+        this.notify({ timestamp });
+      }
+    });
+  }
+  start() {
+    this.providerId = RelativeAttitudeProvider$1.addEventListener(
+      this._parseRelativeAttitude,
+      this.notifyError
+    );
+  }
+  stop() {
+    RelativeAttitudeProvider$1.removeEventListener(this.providerId);
+  }
+  isTurning() {
+    if (!this.lastEvent || !RelativeAttitudeProvider$1.lastEvent) {
+      return false;
+    }
+    const diffTime = RelativeAttitudeProvider$1.lastEvent.time - this.lastEvent.timestamp;
+    return diffTime < _TurnProvider.CONSIDER_TURN_UNTIL;
+  }
+};
+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 {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_turnProviderId");
+    __publicField(this, "_stepProviderId");
+    __publicField(this, "_countSteps", 0);
+    __publicField(this, "_stepsConsideredForStraightLine", _StraightLineProvider.DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE);
+    __publicField(this, "getName", () => "StraightLine");
+    __publicField(this, "_onTurn", () => {
+      if (this._countSteps >= this._stepsConsideredForStraightLine) {
+        this.notify(false);
+      }
+      this._countSteps = 0;
+    });
+    __publicField(this, "_onStep", () => {
+      this._countSteps++;
+      if (this._countSteps === this._stepsConsideredForStraightLine) {
+        this.notify(true);
+      }
+    });
+  }
+  availability() {
+    return AvailabilityHelper.every([
+      TurnProvider$1.getAvailability(),
+      StepProvider$1.getAvailability()
+    ]);
+  }
+  start() {
+    this._turnProviderId = TurnProvider$1.addEventListener(this._onTurn);
+    this._stepProviderId = StepProvider$1.addEventListener(this._onStep);
+  }
+  stop() {
+    TurnProvider$1.removeEventListener(this._turnProviderId);
+    StepProvider$1.removeEventListener(this._stepProviderId);
+  }
+  isStraight() {
+    return this._countSteps >= this._stepsConsideredForStraightLine;
+  }
+  get numStepsDetectedFromLastTurn() {
+    return this._countSteps;
+  }
+  get stepsConsideredForStraightLine() {
+    return this._stepsConsideredForStraightLine;
+  }
+  set stepsConsideredForStraightLine(stepsConsideredForStraightLine) {
+    this._stepsConsideredForStraightLine = stepsConsideredForStraightLine;
+  }
+};
+let StraightLineProvider = _StraightLineProvider;
+__publicField(StraightLineProvider, "DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE", 2);
+const StraightLineProvider$1 = new StraightLineProvider();
+const _MapMatchingHandler = class extends Provider {
+  constructor() {
+    super();
+    __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);
+    __publicField(this, "_hugeJumpDistance", _MapMatchingHandler.DEFAULT_MM_HUGE_JUMP_DISTANCE);
+    __publicField(this, "_disableMMCloseToATurnDistance", _MapMatchingHandler.DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE);
+    __publicField(this, "_minStepsBetweenOrientationMatching", _MapMatchingHandler.DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING);
+    __publicField(this, "_minStepsForOrientationMatching", _MapMatchingHandler.DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING);
+    __publicField(this, "_lastProjectionsWindowSize", _MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE);
+    __publicField(this, "_lastProjectionsEdgeAngleThreshold", _MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD);
+    __publicField(this, "_mapMatching");
+    __publicField(this, "_internalProvidersStarted", false);
+    __publicField(this, "_straightLineProviderId");
+    __publicField(this, "_turnProviderId");
+    __publicField(this, "_stepProviderId");
+    __publicField(this, "_projectionsWithAbsAndWithoutRelAttitudeInARow", []);
+    __publicField(this, "_countStepsFromLastMatching", 0);
+    __publicField(this, "_lastProjections", []);
+    __publicField(this, "_itineraryInfoManager", null);
+    __publicField(this, "getName", () => "MapMatchingHandler");
+    __publicField(this, "availability", () => Promise.resolve());
+    __publicField(this, "_manageStartStop", () => {
+      if (this.network && !this._internalProvidersStarted) {
+        this._startInternalProviders();
+      } else if (!this.network && this._internalProvidersStarted) {
+        this._stopInternalProviders();
+      }
+    });
+    this._mapMatching = new geo.MapMatching();
+    this._mapMatching.maxDistance = _MapMatchingHandler.DEFAULT_MM_MAX_DIST;
+    this._mapMatching.maxAngleBearing = _MapMatchingHandler.DEFAULT_MM_MAX_ANGLE;
+  }
+  start() {
+    if (this.network) {
+      this._startInternalProviders();
+    }
+  }
+  stop() {
+    this._stopInternalProviders();
+  }
+  _startInternalProviders() {
+    if (this.enabled && this._internalProvidersStarted) {
+      return;
+    }
+    this._straightLineProviderId = StraightLineProvider$1.addEventListener();
+    this._turnProviderId = TurnProvider$1.addEventListener();
+    this._stepProviderId = StepProvider$1.addEventListener(() => this._countStepsFromLastMatching++);
+    this._internalProvidersStarted = true;
+  }
+  _stopInternalProviders() {
+    if (this.enabled && !this._internalProvidersStarted) {
+      return;
+    }
+    StraightLineProvider$1.removeEventListener(this._straightLineProviderId);
+    TurnProvider$1.removeEventListener(this._turnProviderId);
+    StepProvider$1.removeEventListener(this._stepProviderId);
+    this._internalProvidersStarted = false;
+  }
+  get enabled() {
+    return ProvidersOptions.useMapMatching;
+  }
+  get network() {
+    return this._mapMatching.network;
+  }
+  set network(network) {
+    this._mapMatching.network = network;
+    this._itineraryInfoManager = null;
+    this.notify({ ...network && { network } });
+    this._manageStartStop();
+    if (this.canUseMapMatching())
+      ;
+  }
+  set itinerary(itinerary) {
+    this._mapMatching.network = itinerary ? itinerary.toNetwork() : null;
+    this._itineraryInfoManager = new routers.ItineraryInfoManager(itinerary);
+    this.notify({ ...itinerary && { itinerary } });
+    this._manageStartStop();
+    if (this.canUseMapMatching() && itinerary) {
+      this._notifyPositionFromItineraryInput(itinerary);
+    }
+  }
+  canUseMapMatching() {
+    return this.enabled && this.network;
+  }
+  _notifyPositionFromItineraryInput(itinerary) {
+    if (!this._useItineraryStartAsPosition || itinerary.from) {
+      return;
+    }
+    const lastPosition = AbsolutePositionProvider$1.lastEvent || null;
+    const newPosition = geo.UserPosition.fromCoordinates(itinerary.from);
+    if (lastPosition) {
+      newPosition.alt = lastPosition.alt;
+      newPosition.time = lastPosition.time;
+      newPosition.accuracy = lastPosition.accuracy + newPosition.distanceTo(lastPosition);
+      newPosition.bearing = lastPosition.bearing;
+    } else if (itinerary.coords.length >= 2) {
+      newPosition.alt = Constants.DEFAULT_ALTITUDE;
+      newPosition.time = utils.TimeUtils.preciseTime();
+      newPosition.accuracy = 0;
+      newPosition.bearing = itinerary.coords[0].bearingTo(itinerary.coords[1]);
+    } else {
+      return;
+    }
+    const projection = this.getProjection(newPosition, true);
+    if (projection) {
+      AbsolutePositionProvider$1.notify(projection.coords);
+    } else {
+      AbsolutePositionProvider$1.notify(newPosition);
+    }
+    return;
+  }
+  notifyPositionFromFeed(newPositionEvent) {
+    const projection = this.getProjection(newPositionEvent, true, false);
+    if (!projection) {
+      AbsolutePositionProvider$1.notify(newPositionEvent);
+      return;
+    }
+    AbsolutePositionProvider$1.notify(projection.coords);
+  }
+  notifyPositionFromAbsolute(newPosition) {
+    let projectionWithBearing = null;
+    if (newPosition.bearing !== null) {
+      projectionWithBearing = this.getProjection(newPosition, true, true);
+    }
+    if (!projectionWithBearing) {
+      AbsolutePositionProvider$1.notify(newPosition);
+      return true;
+    }
+    const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > this._hugeJumpDistance;
+    if (thisWillBeAHugeJump && !StraightLineProvider$1.isStraight()) {
+      return false;
+    }
+    if (thisWillBeAHugeJump && this._detectWrongBigJump(projectionWithBearing)) {
+      return false;
+    }
+    AbsolutePositionProvider$1.notify(projectionWithBearing.coords);
+    this.tryOrientationMatching(projectionWithBearing);
+    return true;
+  }
+  notifyPositionFromRelative(newPosition) {
+    var _a;
+    if (TurnProvider$1.isTurning()) {
+      this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+      this._lastProjections = [];
+      AbsolutePositionProvider$1.notify(newPosition);
+      return true;
+    }
+    const projection = this.getProjection(newPosition, true, true);
+    if (projection) {
+      this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+      this._lastProjections.push(projection);
+      if (this._lastProjections.length > this._lastProjectionsWindowSize) {
+        this._lastProjections.shift();
+      }
+      const thisWillBeAHugeJump = projection.distanceFromNearestElement > this._hugeJumpDistance;
+      if (thisWillBeAHugeJump && !StraightLineProvider$1.isStraight()) {
+        AbsolutePositionProvider$1.notify(newPosition);
+        return true;
+      }
+      if (thisWillBeAHugeJump && this._detectWrongBigJump(projection)) {
+        AbsolutePositionProvider$1.notify(newPosition);
+        return true;
+      }
+      if (!this._areLastProjectionsInTheSameDirection()) {
+        AbsolutePositionProvider$1.notify(newPosition);
+        return true;
+      }
+      if (this._disableMMCloseToATurnDistance > 0 && this._hasTurnInCircle(projection.coords, this._disableMMCloseToATurnDistance)) {
+        AbsolutePositionProvider$1.notify(newPosition);
+        return true;
+      }
+      AbsolutePositionProvider$1.notify(projection.coords);
+      this.tryOrientationMatching(projection);
+      return true;
+    }
+    if (StraightLineProvider$1.isStraight()) {
+      const testedPosition = newPosition.clone();
+      testedPosition.bearing = ((_a = AbsoluteAttitudeFromBrowser$1.lastEvent) == null ? void 0 : _a.heading) || null;
+      const projectionWithAbs = this.getProjection(testedPosition, true, true);
+      if (projectionWithAbs) {
+        this._projectionsWithAbsAndWithoutRelAttitudeInARow.push(projectionWithAbs);
+        if (this._projectionsWithAbsAndWithoutRelAttitudeInARow.length < 3) {
+          AbsolutePositionProvider$1.notify(newPosition);
+          return true;
+        }
+        this._lastProjections.push(projectionWithAbs);
+        if (this._lastProjections.length > this._lastProjectionsWindowSize) {
+          this._lastProjections.shift();
+        }
+        if (!this._areLastProjectionsInTheSameDirection()) {
+          AbsolutePositionProvider$1.notify(newPosition);
+          return true;
+        }
+        AbsolutePositionProvider$1.notify(projectionWithAbs.coords);
+        this.tryOrientationMatching(projectionWithAbs);
+        return true;
+      }
+    }
+    this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+    this._lastProjections = [];
+    AbsolutePositionProvider$1.notify(newPosition);
+    return true;
+  }
+  _detectWrongBigJump(projection) {
+    if (this._itineraryInfoManager && AbsolutePositionProvider$1.lastEvent) {
+      const infoPrevious = this._itineraryInfoManager.getInfo(AbsolutePositionProvider$1.lastEvent);
+      const infoProjection = this._itineraryInfoManager.getInfo(projection.coords);
+      if (infoPrevious && infoProjection && infoPrevious.traveledDistance > infoProjection.traveledDistance && infoPrevious.traveledDistance - infoProjection.traveledDistance > projection.origin.accuracy && projection.distanceFromNearestElement > projection.origin.accuracy && projection.origin.distanceTo(AbsolutePositionProvider$1.lastEvent) < projection.origin.accuracy + AbsolutePositionProvider$1.lastEvent.accuracy) {
+        return true;
+      }
+    }
+    return false;
+  }
+  _areLastProjectionsInTheSameDirection() {
+    if (this._lastProjections.length === 0) {
+      return false;
+    }
+    const firstProjection = this._lastProjections[0];
+    return !this._lastProjections.some(
+      (projection) => !(projection.nearestElement instanceof geo.GraphEdge) || !(firstProjection.nearestElement instanceof geo.GraphEdge) || maths.diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing) > this._lastProjectionsEdgeAngleThreshold
+    );
+  }
+  _nodeHasTurn(node) {
+    const { edges } = node;
+    for (let i = 0; i < edges.length; i++) {
+      for (let j = i + 1; j < edges.length; j++) {
+        const angle = maths.diffAngleLines(edges[i].bearing, edges[j].bearing);
+        if (angle > _MapMatchingHandler.DEFAULT_MM_MAX_ANGLE) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  _hasTurnInCircle(center, radius) {
+    const network = this._mapMatching.network;
+    if (!network) {
+      return false;
+    }
+    return network.nodes.filter(
+      (node) => node.coords.distanceTo(center) <= radius && geo.Level.intersect(node.coords.level, center.level)
+    ).some(this._nodeHasTurn);
+  }
+  tryOrientationMatching(projection) {
+    if (!this._useOrientationMatching) {
+      return;
+    }
+    if (this.state !== "started" || this._countStepsFromLastMatching < this._minStepsBetweenOrientationMatching || StraightLineProvider$1.numStepsDetectedFromLastTurn < this._minStepsForOrientationMatching) {
+      return;
+    }
+    const { nearestElement, origin } = projection;
+    if (!(nearestElement instanceof geo.GraphEdge)) {
+      return;
+    }
+    let matchingDirection;
+    const matchingDirectionAngle1 = maths.diffAngle(nearestElement.bearing, origin.bearing);
+    const matchingDirectionAngle2 = maths.diffAngle(nearestElement.bearing + Math.PI, origin.bearing);
+    if (Math.abs(matchingDirectionAngle1) < Math.abs(matchingDirectionAngle2)) {
+      matchingDirection = nearestElement.bearing;
+    } else {
+      matchingDirection = (nearestElement.bearing + Math.PI) % (2 * Math.PI);
+    }
+    const matchedHeading = new geo.AbsoluteHeading(
+      matchingDirection,
+      origin.time,
+      0
+    );
+    AbsoluteAttitudeProvider$1._forceHeadingForRelative(matchedHeading);
+    this._countStepsFromLastMatching = 0;
+  }
+  getProjection(position, useDistance, useBearing) {
+    return this._mapMatching.getProjection(position, useDistance, useBearing);
+  }
+  get maxDistance() {
+    return this._mapMatching.maxDistance;
+  }
+  set maxDistance(maxDistance) {
+    this._mapMatching.maxDistance = maxDistance;
+  }
+  get minDistance() {
+    return this._mapMatchingMinDistance;
+  }
+  set minDistance(minDistance) {
+    this._mapMatchingMinDistance = minDistance;
+  }
+  get maxAngleBearing() {
+    return this._mapMatching.maxAngleBearing;
+  }
+  set maxAngleBearing(maxAngleBearing) {
+    this._mapMatching.maxAngleBearing = maxAngleBearing;
+  }
+  get useItineraryStartAsPosition() {
+    return this._useItineraryStartAsPosition;
+  }
+  set useItineraryStartAsPosition(useItineraryStartAsPosition) {
+    this._useItineraryStartAsPosition = useItineraryStartAsPosition;
+  }
+  get useOrientationMatching() {
+    return this._useOrientationMatching;
+  }
+  set useOrientationMatching(useOrientationMatching) {
+    this._useOrientationMatching = useOrientationMatching;
+  }
+  get hugeJumpDistance() {
+    return this._hugeJumpDistance;
+  }
+  set hugeJumpDistance(hugeJumpDistance) {
+    this._hugeJumpDistance = hugeJumpDistance;
+  }
+  get disableMMCloseToATurnDistance() {
+    return this._disableMMCloseToATurnDistance;
+  }
+  set disableMMCloseToATurnDistance(disableMMCloseToATurnDistance) {
+    this._disableMMCloseToATurnDistance = disableMMCloseToATurnDistance;
+  }
+  get minStepsBetweenOrientationMatching() {
+    return this._minStepsBetweenOrientationMatching;
+  }
+  set minStepsBetweenOrientationMatching(minStepsBetweenOrientationMatching) {
+    this._minStepsBetweenOrientationMatching = minStepsBetweenOrientationMatching;
+  }
+  get minStepsForOrientationMatching() {
+    return this._minStepsForOrientationMatching;
+  }
+  set minStepsForOrientationMatching(minStepsForOrientationMatching) {
+    this._minStepsForOrientationMatching = minStepsForOrientationMatching;
+  }
+  get lastProjectionsWindowSize() {
+    return this._lastProjectionsWindowSize;
+  }
+  set lastProjectionsWindowSize(lastProjectionsWindowSize) {
+    this._lastProjectionsWindowSize = lastProjectionsWindowSize;
+  }
+  get lastProjectionsEdgeAngleThreshold() {
+    return this._lastProjectionsEdgeAngleThreshold;
+  }
+  set lastProjectionsEdgeAngleThreshold(lastProjectionsEdgeAngleThreshold) {
+    this._lastProjectionsEdgeAngleThreshold = lastProjectionsEdgeAngleThreshold;
+  }
+};
+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 {
+  constructor(callback, frequency = _PositionSmoother.DEFAULT_FREQUENCY) {
+    __publicField(this, "positionsQueue", []);
+    __publicField(this, "previousPosition", null);
+    __publicField(this, "timeoutNotify");
+    __publicField(this, "_notifyNext", () => {
+      var _a;
+      if (!this.positionsQueue.length)
+        return;
+      (_a = this.callback) == null ? void 0 : _a.call(this, this.positionsQueue.shift());
+      if (this.positionsQueue.length !== 0) {
+        this.timeoutNotify = setTimeout(this._notifyNext, 1e3 / this.frequency);
+      } else {
+        delete this.timeoutNotify;
+      }
+    });
+    this.callback = callback;
+    this.frequency = frequency;
+  }
+  feed(newPosition, flybyTime = _PositionSmoother.DEFAULT_FLYBY_TIME) {
+    if (!(newPosition instanceof geo.UserPosition)) {
+      throw new TypeError("newPosition is not instance of UserPosition");
+    }
+    if (newPosition.time === null) {
+      throw new Error("newPosition does not have time property");
+    }
+    let previousPosition;
+    if (this.positionsQueue.length !== 0) {
+      previousPosition = this.positionsQueue[0];
+      this.positionsQueue = [];
+    } else {
+      previousPosition = this.previousPosition;
+    }
+    if (previousPosition) {
+      const refTimestamp = newPosition.time;
+      const distance = previousPosition.distanceTo(newPosition);
+      const azimuth = previousPosition.bearingTo(newPosition);
+      let i = 1;
+      const nSamples = this.frequency * flybyTime + 1;
+      const newPositionLevel = geo.Level.clone(newPosition.level);
+      while (i < nSamples + 1) {
+        const smoothedPosition = previousPosition.destinationPoint(distance * i / nSamples, azimuth);
+        smoothedPosition.time = refTimestamp + (i - 1) / this.frequency;
+        smoothedPosition.level = newPositionLevel;
+        smoothedPosition.bearing = newPosition.bearing;
+        smoothedPosition.accuracy = Math.max(
+          smoothedPosition.accuracy + (newPosition.accuracy - smoothedPosition.accuracy) * i / nSamples,
+          0
+        );
+        this.positionsQueue.push(smoothedPosition);
+        i++;
+      }
+      if (this.timeoutNotify) {
+        clearTimeout(this.timeoutNotify);
+      }
+    } else {
+      this.positionsQueue.push(newPosition.clone());
+    }
+    this.previousPosition = newPosition;
+    this._notifyNext();
+  }
+  clear() {
+    clearTimeout(this.timeoutNotify);
+    delete this.timeoutNotify;
+    this.positionsQueue = [];
+  }
+};
+let PositionSmoother = _PositionSmoother;
+__publicField(PositionSmoother, "DEFAULT_FREQUENCY", 60);
+__publicField(PositionSmoother, "DEFAULT_FLYBY_TIME", 1);
+const _AttitudeSmoother = class {
+  constructor(callback) {
+    __publicField(this, "_previousAttitude");
+    __publicField(this, "_smoothing", null);
+    this.callback = callback;
+  }
+  feed(newAttitude) {
+    if (newAttitude.time === null) {
+      throw new Error("newAttitude does not have time property");
+    }
+    const { _previousAttitude: previousAttitude } = this;
+    this._previousAttitude = newAttitude;
+    if (!previousAttitude) {
+      this.callback(newAttitude);
+      return;
+    }
+    if (_AttitudeSmoother.isJump(previousAttitude, newAttitude)) {
+      const fromAttitude = this._smoothing === null ? previousAttitude : this._smoothing.interpAttitude(previousAttitude);
+      const fromHeading = fromAttitude.heading;
+      const toHeading = newAttitude.heading;
+      const diffAngleHeading = maths.diffAngle(toHeading, fromHeading);
+      const isHighJump = Math.abs(diffAngleHeading) < _AttitudeSmoother.HIGH_JUMP_THRESHOLD;
+      const rotationSpeedConvergence = isHighJump ? _AttitudeSmoother.ROTATION_SPEED_CONVERGENCE : _AttitudeSmoother.ROTATION_SPEED_HIGH_JUMP_CONVERGENCE;
+      const fromTime = fromAttitude.time;
+      const timeToConsume = Math.abs(diffAngleHeading) / rotationSpeedConvergence;
+      const multiplier = diffAngleHeading < 0 ? -1 : 1;
+      this._smoothing = {
+        toTime: fromTime + timeToConsume,
+        interpAttitude: (attitude) => {
+          const angle = rotationSpeedConvergence * (attitude.time - fromTime);
+          const interpHeading = fromHeading + angle * multiplier;
+          const offsetQuat = maths.Quaternion.fromAxisAngle([0, 0, 1], toHeading - interpHeading);
+          const interpQuat = maths.Quaternion.multiply(offsetQuat, attitude.quaternion);
+          return new geo.Attitude(interpQuat, attitude.time, attitude.accuracy);
+        }
+      };
+    }
+    if (this._smoothing !== null) {
+      if (newAttitude.time >= this._smoothing.toTime) {
+        this._smoothing = null;
+      } else {
+        const interpAttitude = this._smoothing.interpAttitude(newAttitude);
+        this.callback(interpAttitude);
+        return;
+      }
+    }
+    this.callback(newAttitude);
+  }
+  static isJump(previousAttitude, newAttitude) {
+    const fromHeading = previousAttitude.heading;
+    const toHeading = newAttitude.heading;
+    const diffAngleHeading = maths.diffAngle(toHeading, fromHeading);
+    const diffTime = newAttitude.time - previousAttitude.time;
+    const [qw, qx, qy, qz] = newAttitude.quaternion;
+    const distToPitchThreshold = Math.abs(Math.asin(2 * (qw * qx + qy * qz)) - Math.PI / 4);
+    if (distToPitchThreshold < _AttitudeSmoother.PITCH_UNCERTAINITY_HEADING_THRESHOLD) {
+      return false;
+    }
+    return Math.abs(diffAngleHeading) > _AttitudeSmoother.ROTATION_SPEED_JUMP_THRESHOLD * diffTime;
+  }
+};
+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();
+    __publicField(this, "getName", () => "MagnetometerCalibrationProvider");
+    __publicField(this, "availability", () => AbsoluteAttitudeProvider$1.getAvailability());
+    AbsoluteAttitudeProvider$1._setCallbackMagCalibration((e) => this.state === "started" && this.notify(e));
+  }
+  start() {
+  }
+  stop() {
+  }
+}
+const MagnetometerCalibrationProvider$1 = new MagnetometerCalibrationProvider();
+const _IpResolveServerError = class extends Error {
+  constructor(message) {
+    super(message || _IpResolveServerError.DEFAULT_MESSAGE);
+  }
+};
+let IpResolveServerError = _IpResolveServerError;
+__publicField(IpResolveServerError, "DEFAULT_MESSAGE", "IP Resolver failed");
+class IpProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "getName", () => "Ip");
+    __publicField(this, "availability", () => Promise.resolve());
+  }
+  async start() {
+    const response = await fetch("https://ipinfo.io/geo?token=24a7ca2f3b489d");
+    if (!response) {
+      this.notifyError(new IpResolveServerError());
+      return;
+    }
+    const timestamp = utils.TimeUtils.preciseTime() / 1e3;
+    const latLngStr = (await response.json()).loc.split(",");
+    const position = new geo.UserPosition(
+      parseFloat(latLngStr[0]),
+      parseFloat(latLngStr[1]),
+      null,
+      null,
+      timestamp,
+      1e5
+    );
+    this.notify(position);
+  }
+  stop() {
+  }
+}
+const IpProvider$1 = new IpProvider();
+class BarcodePoleStarProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "providerId");
+    __publicField(this, "getName", () => "Barcode");
+    __publicField(this, "availability", () => ArCoreProvider$1.getAvailability());
+  }
+  start() {
+    ArCoreProvider$1.enableBarcodeScanner();
+    this.providerId = ArCoreProvider$1.addEventListener(
+      (event) => event.barcode && this.notify(event.barcode),
+      this.notifyError
+    );
+  }
+  stop() {
+    ArCoreProvider$1.disableBarcodeScanner();
+    ArCoreProvider$1.removeEventListener(this.providerId);
+  }
+}
+const BarcodeProvider = new BarcodePoleStarProvider();
+class CameraNativeProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "providerId");
+    __publicField(this, "getName", () => "CameraNative");
+    __publicField(this, "availability", () => Promise.resolve());
+  }
+  start() {
+    if (ArCoreProvider$1.state !== "stopped") {
+      this.notify("started");
+    }
+    this.providerId = ArCoreProvider$1.addMonitoringListener(
+      () => this.notify("started"),
+      () => this.notify("stopped")
+    );
+  }
+  stop() {
+    ArCoreProvider$1.removeMonitoringListener(this.providerId);
+  }
+}
+const CameraNativeProvider$1 = new CameraNativeProvider();
+class CameraProjectionMatrixProvider extends Provider {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "providerId");
+    __publicField(this, "getName", () => "CameraProjectionMatrix");
+    __publicField(this, "availability", () => ArCoreProvider$1.getAvailability());
+  }
+  start() {
+    this.providerId = ArCoreProvider$1.addEventListener(
+      (event) => event.cameraProjection && this.notify(event.cameraProjection),
+      this.notifyError
+    );
+  }
+  stop() {
+    ArCoreProvider$1.removeEventListener(this.providerId);
+  }
+}
+const CameraProjectionMatrixProvider$1 = new CameraProjectionMatrixProvider();
+exports.AbsoluteAttitude = AbsoluteAttitude;
+exports.AbsoluteAttitudeFromBrowserProvider = AbsoluteAttitudeFromBrowser$1;
+exports.AbsoluteAttitudeProvider = AbsoluteAttitudeProvider$1;
+exports.AbsolutePosition = AbsolutePosition;
+exports.AbsolutePositionProvider = AbsolutePositionProvider$1;
+exports.AccelerometerProvider = AccelerometerProvider$1;
+exports.ArCoreProvider = ArCoreProvider$1;
+exports.AttitudeSmoother = AttitudeSmoother;
+exports.BarcodeProvider = BarcodeProvider;
+exports.CameraNativeProvider = CameraNativeProvider$1;
+exports.CameraProjectionMatrixProvider = CameraProjectionMatrixProvider$1;
+exports.GeoRelativePositionFromArCoreProvider = GeoRelativePositionFromArCoreProvider$1;
+exports.GeoRelativePositionProvider = GeoRelativePositionProvider$1;
+exports.GnssWifiProvider = GnssWifiProvider$1;
+exports.GyroscopeProvider = GyroscopeProvider$1;
+exports.HighRotationsProvider = HighRotationsProvider$1;
+exports.ImageRelocalization = ImageRelocalization;
+exports.ImuProvider = ImuProvider$1;
+exports.InclinationFromAccProvider = InclinationFromAccProvider$1;
+exports.InclinationFromRelativeAttitudeProvider = InclinationFromRelativeAttitudeProvider$1;
+exports.InclinationProvider = InclinationProvider$1;
+exports.IpProvider = IpProvider$1;
+exports.MagnetometerCalibrationProvider = MagnetometerCalibrationProvider$1;
+exports.MapMatchingHandler = MapMatchingHandler$1;
+exports.PdrProvider = PdrProvider$1;
+exports.PoleStarProvider = PoleStarProvider$1;
+exports.PositionSmoother = PositionSmoother;
+exports.ProvidersLoggerOld = ProvidersLoggerOld$1;
+exports.ProvidersOptions = ProvidersOptions;
+exports.RelativeAttitude = RelativeAttitude;
+exports.RelativeAttitudeFromBrowserProvider = RelativeAttitudeFromBrowser$1;
+exports.RelativeAttitudeFromEkfProvider = RelativeAttitudeFromEkfProvider;
+exports.RelativeAttitudeFromInertialProvider = RelativeAttitudeFromInertialProvider;
+exports.RelativeAttitudeProvider = RelativeAttitudeProvider$1;
+exports.StepDetectionMinMaxPeaks2 = StepDetectionMinMaxPeaks2;
+exports.StepDetectionMinMaxPeaks3 = StepDetectionMinMaxPeaks3;
+exports.StepProvider = StepProvider$1;
+exports.StraightLineProvider = StraightLineProvider$1;
+exports.TurnProvider = TurnProvider$1;
+exports.VpsMetadata = VpsMetadata;
+exports.VpsProvider = VpsProvider$1;
+exports.VpsRequest = VpsRequest;
+exports.VpsResponse = VpsResponse;
+//# sourceMappingURL=index.js.map