@wemap/providers 5.8.0 → 6.0.2

package/dist/wemap-providers.es.js

@@ -1,4663 +0,0 @@
-import { deg2rad, Vector3, Matrix, Quaternion, Matrix3, Matrix4, Vector, Rotations, std, diffAngleLines, diffAngle, rad2deg } from '@wemap/maths';
-import { BrowserUtils, Browser, PromiseUtils, TimeUtils } from '@wemap/utils';
-import Logger from '@wemap/logger';
-import { Attitude, RelativePosition, Constants as Constants$1, MapMatching, UserPosition, GraphEdge, AbsoluteHeading, GeoRelativePosition as GeoRelativePosition$1, Network } from '@wemap/geo';
-import geomagnetism from '@wemap/geomagnetism';
-import { Itinerary } from '@wemap/osm';
-
-/**
- * Event data types handled by {@link ProviderEvent}
- */
-var EventType = {
-    Unknown: 'UNKNOWN',
-
-    MagneticField: 'MAGNETIC_FIELD',
-    AngularRate: 'ANGULAR_RATE',
-    Acceleration: 'ACCELERATION',
-    MagnetometerNeedCalibration: 'MAGNETOMETER_NEED_CALIBRATION',
-
-    RelativeAttitude: 'RELATIVE_ATTITUDE',
-    AbsoluteAttitude: 'ABSOLUTE_ATTITUDE',
-    Attitude: 'ATTITUDE',
-
-    Inclination: 'INCLINATION',
-    AbsoluteHeading: 'ABSOLUTE_HEADING',
-    Turn: 'TURN',
-    HighRotation: 'HIGH_ROTATION',
-
-    RelativePosition: 'RELATIVE_POSITION',
-    GeoRelativePosition: 'GEO_RELATIVE_POSITION',
-    AbsolutePosition: 'ABSOLUTE_POSITION',
-
-    Step: 'STEP',
-    StraightLine: 'STRAIGHT_LINE',
-
-    Pressure: 'PRESSURE',
-    BluetoothSignals: 'BLUETOOTH_SIGNALS',
-    WifiSignals: 'WIFI_SIGNALS',
-    ScanId: 'SCAN_ID',
-    Barcode: 'BARCODE',
-    CameraProjectionMatrix: 'CAMERA_PROJECTION_MATRIX',
-    CameraNative: 'CAMERA_NATIVE',
-
-    Itinerary: 'ITINERARY',
-    Network: 'NETWORK'
-};
-
-/**
- * A provider event is an event which can be triggered by device sensors
- * or can be computed from raw providers.
- *
- * @template T
- */
-class ProviderEvent {
-
-    dataType = EventType.Unknown;
-    providersStack = [];
-
-    /** @type {T} */
-    data = null;
-
-    /**
-     * Create a Provider Event with the minimum information
-     * @param {EventType} dataType the type of event
-     * @param {Object} data the event data
-     */
-    constructor(dataType, data) {
-        this.dataType = dataType;
-        this.data = data;
-    }
-
-    /**
-     * @return {ProviderEvent<T>}
-     */
-    clone() {
-        const evt = new ProviderEvent(this.dataType, this.data);
-        evt.providersStack = this.providersStack.slice(0);
-        return evt;
-    }
-}
-
-var ProviderState = {
-    STARTING: 0,
-    STARTED: 1,
-    STOPPPED: 2
-};
-
-class ProvidersLoggerOld {
-
-    _enabled = false;
-
-    currentId = 0;
-    objectsIdMap = new WeakMap();
-
-    pushEvents = {};
-    pushEventsRef = {};
-
-    interval;
-    initDate;
-
-
-    get enabled() {
-        return this._enabled;
-    }
-
-    set enabled(_newVal) {
-        this._enabled = _newVal;
-    }
-
-    initializeInterval() {
-
-        if (this.interval) {
-            return;
-        }
-
-        this.interval = setInterval(() => {
-
-            for (const [key, value] of Object.entries(this.pushEvents)) {
-                Logger.debug('Received ' + value + ' notifications from ' + this.pushEventsRef[key].pname + ' last second');
-            }
-
-            this.pushEvents = {};
-            this.pushEventsRef = {};
-        }, 1000);
-    }
-
-    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.pname;
-
-        Logger.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;
-    }
-
-}
-var ProvidersLoggerOld$1 = new ProvidersLoggerOld();
-
-class ContainsIgnoredProviderError extends Error {
-
-    static DEFAULT_MESSAGE = 'Contains ignored provider';
-
-    constructor(message) {
-        super(message || ContainsIgnoredProviderError.DEFAULT_MESSAGE);
-    }
-}
-
-const ProvidersOptions = {
-
-    /**
-     * Does provider will use map to
-     */
-    useMapMatching: true,
-
-    /**
-     * Providers listed here will not be used by the system
-     * List of {@link Provider#name}
-     */
-    ignoreProviders: [],
-
-    /**
-     * Define the list of EventType that are optionals
-     * List of {@link EventType}
-     */
-    optionalEvents: [],
-
-    stopOnError: true,
-
-    checkAvailabilityOnStart: true,
-
-    stepdetectionlocker: true,
-
-    smoother: true
-};
-
-/**
- * A provider is a meta class to define an entity which can be
- * started / stopped and provides a data of {@link ProviderEvent#DataType}
- */
-class Provider {
-
-    /** @type {number} */
-    static _callbackUniqueId = 0;
-
-    /** @type {number} */
-    static _uniqueId = 1;
-
-
-    /** @type {number} */
-    id;
-
-    /** @type {number} */
-    state = ProviderState.STOPPPED;
-
-    /** @type {ProviderEvent[]} */
-    _lastEvents = null;
-
-    _eventsCallbacks = [];
-    _monitoringCallbacks = [];
-
-    /**
-     * Provider constructor
-     */
-    constructor() {
-
-        if (this.constructor === Provider) {
-            throw new Error('Can\'t instantiate Provider directly');
-        }
-
-        this.id = Provider._uniqueId++;
-
-        ProvidersLoggerOld$1.addEvent(this, 'constructor');
-    }
-
-    /**
-     * Get the provider name
-     * @type {String} the provider name
-     */
-    static get pname() {
-        return 'Unknown';
-    }
-
-    /** @type {String} */
-    get pname() {
-        return this.constructor.pname;
-    }
-
-    /**
-     * Get the list of events type which can be returned by the provider
-     * @returns {EventType[]} the list of events type
-     * @public
-     * @abstract
-     */
-    get eventsType() {
-        return [];
-    }
-
-    /**
-     * @type {Promise} returns an availability promise
-     */
-    get availability() {
-        if (ProvidersOptions.ignoreProviders.includes(this.pname)) {
-            return Promise.reject(new ContainsIgnoredProviderError());
-        }
-
-        return this._availability;
-    }
-
-    /** @type {Promise} */
-    get _availability() {
-        return Promise.resolve();
-    }
-
-    /**
-     * Create an event from current provider
-     * @param {String} dataType type of ProviderEvent (from EventType)
-     * @param {Object} data data exported to ProviderEvent
-     * @returns {ProviderEvent}
-     * @protected
-     */
-    static createEvent(dataType, data, fromEvents = []) {
-        const event = new ProviderEvent(dataType, data);
-        const newStack = fromEvents.reduce((acc, _event) => acc.concat(_event.providersStack), []);
-        // Remove duplicates and keep lasts
-        event.providersStack = [...new Set(newStack.reverse())].reverse();
-        return event;
-    }
-
-    /**
-     * Create an event from current provider
-     * @param {EventType} dataType type of ProviderEvent
-     * @param {Object} data data exported to ProviderEvent
-     * @param {ProviderEvent[]} fromEvents events used for the creation of the new one
-     * @returns {ProviderEvent}
-     * @protected
-     */
-    createEvent(dataType, data, fromEvents) {
-        return this.constructor.createEvent(dataType, data, fromEvents);
-    }
-
-    get hasNativeInterface() {
-        return Boolean(this.nativeInterface);
-    }
-
-    get nativeInterface() {
-        return typeof window !== 'undefined' ? (window.__nativeProviders || null) : null;
-    }
-
-    get useCameraNatively() {
-        return false;
-    }
-
-    /**
-     *
-     * @param {Function} onEvents
-     * @param {Function} onError
-     * @param {Boolean} startIfNecessary
-     * @returns {Number}
-     */
-    addEventListener(onEvents = () => {}, onError = () => {}, startIfNecessary = true) {
-        const id = ++Provider._callbackUniqueId;
-
-        /**
-         * Build callback
-         */
-        this._eventsCallbacks.push({
-            id,
-            onEvents,
-            onError,
-            optional: !startIfNecessary
-        });
-
-
-        // The caller just want to have callbacks without starting the provider,
-        // the routine can be stopped here
-        if (!startIfNecessary) {
-            return id;
-        }
-
-
-        // If the provider is already started do not go further
-        if (this.state !== ProviderState.STOPPPED) {
-            return id;
-        }
-        this.state = ProviderState.STARTING;
-
-        // Check availability on start if defined in options
-        let availabilityPromise = Promise.resolve();
-        if (ProvidersOptions.checkAvailabilityOnStart) {
-            availabilityPromise = this.availability;
-        }
-
-        availabilityPromise
-            .then(() => {
-
-                ProvidersLoggerOld$1.addEvent(this, 'start');
-                // Call the child start function
-                this.start();
-
-                this.state = ProviderState.STARTED;
-
-                this._monitoringCallbacks.forEach(({ onStarted }) => onStarted());
-            })
-            .catch(e => {
-                this.state = ProviderState.STOPPPED;
-                this.notifyError(e);
-            })
-            // notifyError can throw an error if onStop is not defined
-            .catch(() => {});
-
-        return id;
-    }
-
-    /**
-     *
-     * @param {Number} callbackUniqueId
-     */
-    removeEventListener(callbackUniqueId) {
-
-        // Search the caller object in callbacks list
-        const callback = this._eventsCallbacks.find(_callback => _callback.id === callbackUniqueId);
-        if (!callback) {
-            // The callback object is not found. Maybe it is already stopped.
-            return;
-        }
-
-        // Remove the current callback from the list of the callbacks
-        this._eventsCallbacks = this._eventsCallbacks.filter(_callback => _callback !== callback);
-
-        // If this callback was optional, do not go further to stop the provider
-        if (callback.optional) {
-            return;
-        }
-
-        // If there is callbacks that are not optionals for start, do not stop the provider
-        if (this._eventsCallbacks.find(_callback => !_callback.optional)) {
-            return;
-        }
-
-        // If the provider is already stopped, do not stop it again.
-        // This condition can be true if checkAvailabilityOnStart is true and returns an error
-        if (this.state === ProviderState.STOPPPED) {
-            return;
-        }
-
-        ProvidersLoggerOld$1.addEvent(this, 'stop');
-        // Call the child stop function
-        this.stop();
-
-        this.state = ProviderState.STOPPPED;
-
-        this._monitoringCallbacks.forEach(({ onStopped }) => onStopped());
-    }
-
-
-    /**
-     *
-     * @param {Function} onStarted
-     * @param {Function} onStopped
-     * @returns {Number}
-     */
-    addMonitoringListener(onStarted = () => {}, onStopped = () => {}) {
-        const id = ++this.constructor._callbackUniqueId;
-        this._monitoringCallbacks.push({
-            id,
-            onStarted,
-            onStopped
-        });
-        return id;
-    }
-
-    /**
-     *
-     * @param {Number} callbackUniqueId
-     */
-    removeMonitoringListener(callbackUniqueId) {
-        this._monitoringCallbacks = this._monitoringCallbacks.filter(
-            _callback => _callback.id !== callbackUniqueId
-        );
-    }
-
-    /**
-     * @abstract
-     */
-    start() {
-        throw new Error('Provider "' + this.pname + '" does not @override start()');
-    }
-
-    /**
-     * @abstract
-     */
-    stop() {
-        throw new Error('Provider "' + this.pname + '" does not @override stop()');
-    }
-
-
-    /**
-     * Notify the subscriber defined in {@link addEventListener}
-     * @param {ProviderEvent[]} events events to send to subscriber
-     */
-    notify(...events) {
-        // Logging
-        ProvidersLoggerOld$1.incrementNotifications(this);
-
-        // Add current provider to the list of providers for this event.
-        events.forEach(event => event.providersStack.unshift(this.pname));
-
-        // Notify callbacks
-        this._eventsCallbacks.forEach(({ onEvents }) => onEvents(events));
-
-        // Keep a trace of the last events.
-        this._lastEvents = events;
-    }
-
-    /**
-     * Notify the subscriber defined in {@link addEventListener}
-     * @param {Error} error The error raised
-     */
-    notifyError(error) {
-        this._eventsCallbacks.forEach(({
-            id, onError
-        }) => {
-            if (ProvidersOptions.stopOnError) {
-                this.removeEventListener(id);
-            }
-            onError(error);
-        });
-    }
-
-    /** @type {ProviderEvent} */
-    get lastEvent() {
-        return this._lastEvents ? this._lastEvents[0] : null;
-    }
-
-    /** @type {ProviderEvent[]} */
-    get lastEvents() {
-        return this._lastEvents;
-    }
-
-    /**
-     * Input data from external interface
-     * @param {ProviderEvent} event
-     * @param {EventType} eventType
-     */
-    // eslint-disable-next-line no-unused-vars
-    feed(event, eventType) {
-        throw new Error('Not implemented');
-    }
-}
-
-class AskImuOnDesktopError extends Error {
-
-    static DEFAULT_MESSAGE = 'It seems that you ask for IMU events on a desktop browser';
-
-    constructor(message) {
-        super(message || AskImuOnDesktopError.DEFAULT_MESSAGE);
-    }
-}
-
-/**
- * Imu (Inertial Measurement Unit) provider retrieve acceleration data
- *  and/or angular rate data from inertial sensors.
- *
- * -----------------------------------
- * Overview of compatibilities:
- * -----------------------------------
- *
- * Chrome Android (v72.0.3626): YES (via devicemotion)
- * Safari iOS (v12.0): YES (via devicemotion)
- * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent}
- * Firefox Android (v65.0.1): YES (via devicemotion)
- *
- * -----------------------------------
- */
-class Imu extends Provider {
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'IMU';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AngularRate, EventType.Acceleration];
-    }
-
-    /**
-     * @override
-     */
-    static get _availability() {
-        return BrowserUtils.isMobile
-            ? Promise.resolve()
-            : Promise.reject(new AskImuOnDesktopError());
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        const subscribe = () => window.addEventListener('devicemotion', this.parseDeviceMotionEvent, true);
-
-        if (typeof (DeviceMotionEvent) !== 'undefined' && typeof (DeviceMotionEvent.requestPermission) === 'function') {
-            DeviceMotionEvent
-                .requestPermission()
-                .then(response => {
-                    if (response !== 'granted') {
-                        throw new Error('Permission not granted');
-                    }
-                    subscribe();
-                })
-                .catch(error => this.notifyError(error));
-        } else {
-            subscribe();
-        }
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        window.removeEventListener('devicemotion', this.parseDeviceMotionEvent, true);
-    }
-
-    /**
-     * devicemotion callback
-     * @param {DeviceMotionEvent} e device motion event
-     * @returns {ProviderEvent[]} an array of provider events
-     * @private
-     */
-    parseDeviceMotionEvent = e => {
-        const events = [];
-
-        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 (BrowserUtils.name === Browser.SAFARI
-                    || BrowserUtils.name === Browser.IOS_WEBVIEW) {
-                    acc[0] *= -1;
-                    acc[1] *= -1;
-                    acc[2] *= -1;
-                }
-            }
-        }
-
-        if (acc) {
-            events.push(this.createEvent(EventType.Acceleration, {
-                timestamp,
-                values: acc
-            }));
-        }
-
-        let gyr;
-        if (e.rotationRate) {
-            const {
-                alpha, beta, gamma
-            } = e.rotationRate;
-
-            if (typeof alpha === 'number' && typeof beta === 'number' && typeof gamma === 'number') {
-                gyr = [deg2rad(alpha), deg2rad(beta), deg2rad(gamma)];
-            }
-        }
-
-        if (gyr) {
-            events.push(this.createEvent(EventType.AngularRate, {
-                timestamp,
-                values: gyr
-            }));
-        }
-
-        if (events.length !== 0) {
-            this.notify(...events);
-        }
-    }
-
-}
-
-var Imu$1 = new Imu();
-
-class MissingSensorError extends Error {
-
-    static DEFAULT_MESSAGE = 'Impossible to retrieve events, a sensor is missing';
-
-    constructor(message) {
-        super(message || MissingSensorError.DEFAULT_MESSAGE);
-    }
-
-    from(fromMessage) {
-        this.message += ' from ' + fromMessage;
-        return this;
-    }
-}
-
-class MissingAccelerometerError extends MissingSensorError {
-
-    static DEFAULT_MESSAGE = 'Impossible to retrieve Acceleration data';
-
-    constructor(message) {
-        super(message || MissingAccelerometerError.DEFAULT_MESSAGE);
-    }
-}
-
-class Accelerometer extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'Accelerometer';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Acceleration];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return Imu$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = Imu$1.addEventListener(
-            events => this.parseImuEvents(events),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        Imu$1.removeEventListener(this.providerId);
-    }
-
-    /**
-     * @private
-     */
-    parseImuEvents = events => {
-
-        const accelerationEvent = events.find(event => event.dataType === EventType.Acceleration);
-        if (!accelerationEvent) {
-            this.notifyError(new MissingAccelerometerError().from('devicemotion'));
-            return;
-        }
-        this.notify(accelerationEvent.clone());
-    }
-
-}
-
-var Accelerometer$1 = new Accelerometer();
-
-class MissingGyroscopeError extends MissingSensorError {
-
-    static DEFAULT_MESSAGE = 'Impossible to retrieve Angular Rate data';
-
-    constructor(message) {
-        super(message || MissingSensorError.DEFAULT_MESSAGE);
-    }
-}
-
-class Gyroscope extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'Gyroscope';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AngularRate];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return Imu$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = Imu$1.addEventListener(
-            events => this.parseImuEvents(events),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        Imu$1.removeEventListener(this.providerId);
-    }
-
-    /**
-     * @private
-     */
-    parseImuEvents = events => {
-
-        const gyroscopeEvent = events.find(event => event.dataType === EventType.AngularRate);
-        if (!gyroscopeEvent) {
-            this.notifyError(new MissingGyroscopeError().from('devicemotion'));
-            return;
-        }
-        this.notify(gyroscopeEvent.clone());
-    }
-
-}
-
-var Gyroscope$1 = new Gyroscope();
-
-class HighRotationsDetector extends Provider {
-
-    // in radians by second
-    static THRESHOLD = 10;
-
-    /** @type {number} in seconds */
-    static DELAY_CONSIDERATION = 3;
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'HighRotationsDetector';
-    }
-
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.HighRotation];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return Gyroscope$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = Gyroscope$1.addEventListener(
-            events => this._parseGyroscopeEvent(events[0]),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        Gyroscope$1.removeEventListener(this.providerId);
-    }
-
-    isInProgress() {
-        if (!this.lastEvent || !Gyroscope$1.lastEvent) {
-            return false;
-        }
-
-        const diffTime = Gyroscope$1.lastEvent.data.timestamp - this.lastEvent.data.timestamp;
-        return diffTime < HighRotationsDetector.DELAY_CONSIDERATION;
-    }
-
-    /**
-     * @private
-     */
-    _parseGyroscopeEvent = gyroscopeEvent => {
-
-        const { values, timestamp } = gyroscopeEvent.data;
-        const speed = Vector3.norm(values);
-        if (speed > HighRotationsDetector.THRESHOLD) {
-            this.notify(this.createEvent(EventType.HighRotation, { timestamp }, [gyroscopeEvent]));
-        }
-
-    }
-}
-
-var HighRotationsDetector$1 = new HighRotationsDetector();
-
-class MissingMagnetometerError extends MissingSensorError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-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]) {
-
-        this.accRef = accRef;
-        this.cRef = ycRef;
-
-        this.P = Matrix.diag(Array(4).fill(0.1 ** 2));
-
-        this.quaternion = null;
-
-
-        this.noises = {
-            relative: null,
-            absolute: null
-        };
-        this.setRelativeNoises(DEFAULT_RELATIVE_NOISES);
-        this.setAbsoluteNoises(DEFAULT_ABSOLUTE_NOISES);
-    }
-
-    setRelativeNoises(relativeNoises) {
-        this.noises.relative = {
-            accelerometer: Matrix.diag(Array(3).fill(relativeNoises.acc ** 2)),
-            gyroscope: Matrix.diag(Array(3).fill(relativeNoises.gyr ** 2))
-        };
-    }
-
-
-    setAbsoluteNoises(absoluteNoises) {
-        this.noises.absolute = {
-            accelerometer: Matrix.diag(Array(3).fill(absoluteNoises.acc ** 2)),
-            gyroscope: Matrix.diag(Array(3).fill(absoluteNoises.gyr ** 2)),
-            yc: Matrix.diag(Array(3).fill(absoluteNoises.yc ** 2))
-        };
-    }
-
-    /**
-     * Try to initialize filter.
-     * To initialize, we need at least current acceleration (acc)
-     */
-    tryInitialize(acc, mag) {
-
-        const accNormalized = Vector3.normalize(acc);
-
-        if (mag) {
-            const magNormalized = Vector3.normalize(mag);
-
-            const H = Vector3.normalize(Vector3.cross(magNormalized, accNormalized));
-            const M = 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 = Quaternion.fromMatrix3(R);
-
-        } else {
-
-            const r = Vector3.dot(accNormalized, this.accRef) + 1;
-            const v = Vector3.cross(accNormalized, this.accRef);
-
-            let quaternion = [r, v[0], v[1], v[2]];
-            quaternion = 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;
-
-        /* ------------
-         *   ESTIMATION
-         * ------------*/
-
-        const qArray = q;
-        const gyrInt = Vector3.multiplyScalar(gyr, 0.5 * diffTime);
-        const F = this.computeC([1, gyrInt[0], gyrInt[1], gyrInt[2]]);
-        const qAPriori = Matrix.multiplyVector(F, q);
-        const E1 = Matrix.diag([qArray[0], qArray[0], qArray[0]]);
-        const eSkew = Matrix3.skew([qArray[1], qArray[2], qArray[3]]);
-
-        const qPart = [-1 * qArray[1], -1 * qArray[2], -1 * qArray[3]];
-        const E = Matrix.concatRow([qPart], Matrix3.add(eSkew, E1));
-
-        const Qk = Matrix.multiplyScalar(
-            Matrix.multiply(
-                Matrix.multiply(E, this.noises[mag ? 'absolute' : 'relative'].gyroscope),
-                Matrix.transpose(E)
-            ),
-            (diffTime / 2) ** 2
-        );
-
-        const pAPriori = Matrix4.add(
-            Matrix.multiply(
-                Matrix.multiply(F, this.P),
-                Matrix.transpose(F)
-            ),
-            Qk
-        );
-
-        /* ------------
-         *   CORRECTION
-         * ------------*/
-
-        const accNormalized = Vector3.normalize(acc);
-        let dz, K, H;
-
-        if (mag) {
-
-            const magNormalized = Vector3.normalize(mag);
-            const yc = Vector3.cross(accNormalized, magNormalized);
-            const ycNormalized = Vector3.normalize(yc);
-
-            const dzYc = Vector3.subtract(ycNormalized, Quaternion.rotate(qAPriori, this.cRef));
-            const dzAcc = Vector3.subtract(accNormalized, Quaternion.rotate(qAPriori, this.accRef));
-            dz = Vector.concat(dzYc, dzAcc);
-
-            const HYc = this.jacobianES(qAPriori, this.cRef);
-            const HAcc = this.jacobianES(qAPriori, this.accRef);
-            H = Matrix.concatRow(HYc, HAcc);
-
-            const RYc = Matrix.concatLine(this.noises.absolute.yc, Matrix3.zeros);
-            const RAcc = Matrix.concatLine(Matrix3.zeros, this.noises.absolute.accelerometer);
-            const R = Matrix.concatRow(RYc, RAcc);
-
-            K = Matrix.multiply(
-                Matrix.multiply(pAPriori, Matrix.transpose(H)),
-                Matrix.inverse(
-                    Matrix.add(
-                        Matrix.multiply(
-                            Matrix.multiply(H, pAPriori),
-                            Matrix.transpose(H)
-                        ),
-                        R
-                    )
-                )
-            );
-        } else {
-            dz = Vector3.subtract(accNormalized, Quaternion.rotate(qAPriori, this.accRef));
-            H = this.jacobianES(qAPriori, this.accRef);
-            const R = this.noises.relative.accelerometer;
-
-            K = Matrix.multiply(
-                Matrix.multiply(pAPriori, Matrix.transpose(H)),
-                Matrix3.inverse(
-                    Matrix3.add(
-                        Matrix.multiply(
-                            Matrix.multiply(H, pAPriori),
-                            Matrix.transpose(H)
-                        ),
-                        R
-                    )
-                )
-            );
-        }
-
-        q = Quaternion.add(
-            qAPriori,
-            Matrix.multiplyVector(K, dz)
-        );
-        const P = Matrix.multiply(
-            Matrix4.subtract(
-                Matrix4.identity,
-                Matrix.multiply(K, H)
-            ),
-            pAPriori
-        );
-
-        q = 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]
-        ];
-    }
-}
-
-/**
- * Relative attitude provider gives the device attitude in East-North-Up (ENU) frame using
- *  browser deviceorientation
- * The provider does not work until an offset is given.
- */
-class RelativeAttitudeFromEkf extends Provider {
-
-    lastTimestamp = 0;
-
-    /**
-     * @override
-     */
-    constructor(context) {
-        super(context);
-        this.ekfAttitude = new EkfAttitude();
-    }
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'RelativeAttitudeFromEkf';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativeAttitude];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return Promise.all([
-            Accelerometer$1.availability,
-            Gyroscope$1.availability
-        ]);
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.accelerometerProviderId = Accelerometer$1.addEventListener(
-            events => this.onAccelerometerEvent(events[0]),
-            error => this.notifyError(error)
-        );
-
-        this.gyroscopeProviderId = Gyroscope$1.addEventListener(
-            events => (this.gyroscopeEvent = events[0]),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        Accelerometer$1.removeEventListener(this.accelerometerProviderId);
-        Gyroscope$1.removeEventListener(this.gyroscopeProviderId);
-    }
-
-    /**
-     * @private
-     */
-    onAccelerometerEvent = accelerationEvent => {
-
-        if (!this.gyroscopeEvent) {
-            return;
-        }
-
-        const {
-            values: acceleration, timestamp
-        } = accelerationEvent.data;
-
-        // Handle timestamps and dt
-        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.data.values);
-
-        if (quaternion) {
-            const attitude = new Attitude(quaternion,
-                timestamp,
-                RelativeAttitudeFromInertial$1.DEFAULT_DRIFT
-            );
-            this.notify(this.createEvent(
-                EventType.RelativeAttitude,
-                attitude,
-                [accelerationEvent, this.gyroscopeEvent]));
-        }
-    };
-}
-
-var RelativeAttitudeFromEkf$1 = new RelativeAttitudeFromEkf();
-
-/**
- * Relative attitude provider gives the device attitude in a custom frame (x-right, y-front, z-up) using
- *  browser deviceorientation
- *
- * -----------------------------------
- * Overview of compatibilities:
- * -----------------------------------
- *
- * Chrome Android (v72.0.3626): YES (via deviceorientation but deviceorientation.alpha is unreliable! Sometimes it starts at 0°, sometimes at 270°)
- * Safari iOS (v12.0): YES (via deviceorientation)
- * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation}
- * Firefox Android (v65.0.1): YES (via deviceorientation)
- *
- * -----------------------------------
- */
-class RelativeAttitudeFromBrowser extends Provider {
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'RelativeAttitudeFromBrowser';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativeAttitude];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return BrowserUtils.isMobile
-            ? Promise.resolve()
-            : Promise.reject(new AskImuOnDesktopError());
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        const subscribe = () => window.addEventListener('deviceorientation', this.onDeviceOrientationEvent, true);
-
-        if (typeof (DeviceOrientationEvent) !== 'undefined' && typeof (DeviceOrientationEvent.requestPermission) === 'function') {
-            DeviceOrientationEvent
-                .requestPermission()
-                .then(response => {
-                    if (response !== 'granted') {
-                        throw new Error('Permission not granted');
-                    }
-                    subscribe();
-                })
-                .catch(error => this.notifyError(error));
-        } else {
-            subscribe();
-        }
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        window.removeEventListener('deviceorientation', this.onDeviceOrientationEvent, true);
-    }
-
-
-    onDeviceOrientationEvent = e => {
-
-        if (typeof e.alpha !== 'number' || typeof e.beta !== 'number' || typeof e.gamma !== 'number') {
-            this.notifyError(new MissingSensorError().from('deviceorientation'));
-            return;
-        }
-
-        const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
-        const attitude = new Attitude(quaternion,
-            e.timeStamp / 1e3,
-            RelativeAttitudeFromInertial$1.DEFAULT_DRIFT
-        );
-        this.notify(this.createEvent(EventType.RelativeAttitude, attitude));
-    };
-}
-
-var RelativeAttitudeFromBrowser$1 = new RelativeAttitudeFromBrowser();
-
-class RelativeAttitudeFromInertial extends Provider {
-
-    /**
-     * default relative attitude drift in rad.second-1
-     */
-    DEFAULT_DRIFT = deg2rad(5) / 60;
-
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'RelativeAttitudeFromInertial';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativeAttitude];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return PromiseUtils.any([
-            RelativeAttitudeFromEkf$1.availability,
-            RelativeAttitudeFromBrowser$1.availability,
-            HighRotationsDetector$1.availability
-        ]);
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        RelativeAttitudeFromEkf$1.availability
-            .then(() => (this.provider = RelativeAttitudeFromEkf$1))
-            .catch(() => (this.provider = RelativeAttitudeFromBrowser$1))
-            .finally(() => {
-                this.listenerId = this.provider.addEventListener(
-                    events => this._parseEvent(events[0]),
-                    error => this.notifyError(error)
-                );
-                this._highRotationsDetector = HighRotationsDetector$1.addEventListener(
-                    () => {},
-                    error => this.notifyError(error)
-                );
-            });
-    }
-
-    /**
-     * @param {ProviderEvent<Attitude>} event
-     */
-    _parseEvent(event) {
-        const relativeAttitudeEvent = event.clone();
-        if (HighRotationsDetector$1.isInProgress()) {
-            let accuracy = relativeAttitudeEvent.data.accuracy + (this.DEFAULT_DRIFT * 100);
-            accuracy = Math.min(accuracy, Math.PI);
-            relativeAttitudeEvent.data.accuracy = accuracy;
-        }
-        this.notify(relativeAttitudeEvent);
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        if (this.provider) {
-            this.provider.removeEventListener(this.listenerId);
-            this.provider = null;
-        }
-        HighRotationsDetector$1.removeEventListener(this._highRotationsDetector);
-    }
-}
-
-var RelativeAttitudeFromInertial$1 = new RelativeAttitudeFromInertial();
-
-class MissingArCoreError extends Error {
-
-    static DEFAULT_MESSAGE = 'ARCore is missing';
-
-    constructor(message) {
-        super(message || MissingArCoreError.DEFAULT_MESSAGE);
-    }
-}
-
-class MissingNativeInterfaceError extends Error {
-
-    static DEFAULT_MESSAGE = 'Native interface is missing';
-
-    constructor(message) {
-        super(message || MissingNativeInterfaceError.DEFAULT_MESSAGE);
-    }
-}
-
-/* eslint-disable no-bitwise */
-class ArCore extends Provider {
-
-    static 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
-        }
-    };
-
-    /**
-     * default relative attitude drift in rad.second-1
-     */
-    static RELATIVE_ATTITUDE_DRIFT = deg2rad(3) / 60;
-
-    previousPosition = [0, 0, 0];
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'ArCore';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativeAttitude, EventType.RelativePosition, EventType.Barcode];
-    }
-
-
-    /**
-     * @override
-     */
-    start() {
-        if (this.nativeProvider) {
-            this.nativeProvider.start();
-        }
-
-        this.pullDataLoop();
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        if (this.nativeProvider) {
-            this.nativeProvider.stop();
-        }
-    }
-
-    pullDataLoop = () => {
-
-        if (this.state === ProviderState.STOPPPED) {
-            return;
-        }
-
-        const payload = JSON.parse(this.nativeProvider.getInfo());
-        if (payload.length > 1) {
-            this.parsePayload(payload);
-        }
-        requestAnimationFrame(this.pullDataLoop);
-    }
-
-    parsePayload(payload) {
-
-        const ref = payload[0];
-        let bufferIndex = 1;
-
-        const events = [];
-
-        const time = TimeUtils.preciseTime() / 1e3;
-
-        if (ref & ArCore.Payload.Pose.ref) {
-
-            const attitude = new Attitude(
-                payload.slice(bufferIndex, bufferIndex + 4),
-                time,
-                this.constructor.RELATIVE_ATTITUDE_DRIFT,
-            );
-            events.push(this.createEvent(EventType.RelativeAttitude, attitude));
-
-            const newPosition = [payload[bufferIndex + 4], payload[bufferIndex + 5], payload[bufferIndex + 6]];
-            const position = new RelativePosition(
-                newPosition[0] - this.previousPosition[0],
-                newPosition[1] - this.previousPosition[1],
-                newPosition[2] - this.previousPosition[2],
-                time,
-                1e-4
-            );
-            this.previousPosition = newPosition;
-            events.push(this.createEvent(EventType.RelativePosition, position));
-
-            bufferIndex += ArCore.Payload.Pose.size;
-        }
-
-        if (ref & ArCore.Payload.Barcode.ref) {
-            events.push(this.createEvent(EventType.Barcode, payload[bufferIndex]));
-            bufferIndex += ArCore.Payload.Barcode.size;
-        }
-
-        if (ref & ArCore.Payload.ProjMat.ref) {
-            const projMatrix = payload.slice(bufferIndex, bufferIndex + ArCore.Payload.ProjMat.size);
-            events.push(this.createEvent(EventType.CameraProjectionMatrix, projMatrix));
-            bufferIndex += ArCore.Payload.ProjMat.size;
-        }
-
-        if (events.length !== 0) {
-            this.notify(...events);
-        }
-    }
-
-
-    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;
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        try {
-            const nativeProvider = this.nativeProvider;
-
-            if (!nativeProvider.checkAvailability()) {
-                return Promise.reject(new MissingArCoreError());
-            }
-
-        } catch (e) {
-            return Promise.reject(e);
-        }
-
-        return Promise.resolve();
-    }
-
-    enableBarcodeScanner() {
-        try {
-            this.nativeProvider.enableBarcodeScanner();
-        } catch (e) {
-            this.notifyError(e);
-        }
-    }
-
-    disableBarcodeScanner() {
-        try {
-            this.nativeProvider.disableBarcodeScanner();
-        } catch (e) {
-            this.notifyError(e);
-        }
-    }
-
-    /**
-     * @override
-     */
-    static get useCameraNatively() {
-        return true;
-    }
-}
-
-var ArCore$1 = new ArCore();
-
-/**
- * Relative attitude provider gives the device attitude in East-North-Up (ENU) frame using
- *  browser deviceorientation
- * The provider does not work until an offset is given.
- */
-class RelativeAttitude extends Provider {
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'RelativeAttitude';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativeAttitude];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return RelativeAttitudeFromInertial$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.arCoreMonitoringId = ArCore$1.addMonitoringListener(
-            () => {
-                this.listenArCore();
-                this.unlistenInertial();
-            }, () => {
-                this.unlistenArCore();
-                this.listenInertial();
-            });
-
-        if (ArCore$1.state === ProviderState.STARTED) {
-            this.listenArCore();
-        } else {
-            this.listenInertial();
-        }
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        ArCore$1.removeMonitoringListener(this.arCoreMonitoringId);
-        this.unlistenArCore();
-        this.unlistenInertial();
-    }
-
-
-    listenInertial = () => {
-        this.inertialProviderId = RelativeAttitudeFromInertial$1.addEventListener(
-            events => this.notify(events[0].clone()),
-            error => this.notifyError(error)
-        );
-    }
-
-    unlistenInertial = () => {
-        RelativeAttitudeFromInertial$1.removeEventListener(this.inertialProviderId);
-    }
-
-    listenArCore = () => {
-        this.arCoreProviderId = ArCore$1.addEventListener(
-            events => {
-                const relativeAttitudeEvent = events.find(event => event.dataType === EventType.RelativeAttitude);
-                if (relativeAttitudeEvent) {
-                    this.notify(relativeAttitudeEvent.clone());
-                }
-            },
-            () => {},
-            false
-        );
-    };
-
-    unlistenArCore = () => {
-        ArCore$1.removeEventListener(this.arCoreProviderId);
-    }
-}
-
-var RelativeAttitude$1 = new RelativeAttitude();
-
-class TurnDetector extends Provider {
-
-    // in seconds
-    static SLIDING_WINDOW_TIME = 0.3;
-
-    static STD_THRESHOLD = 0.075;
-
-    /** @type {number} in seconds */
-    static CONSIDER_TURN_UNTIL = 1;
-
-    /** @type {number[]} */
-    slidingWindow = [];
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'TurnDetector';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Turn];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return RelativeAttitude$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = RelativeAttitude$1.addEventListener(
-            events => this._parseRelativeAttitude(events[0]),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        RelativeAttitude$1.removeEventListener(this.providerId);
-    }
-
-    isTurning() {
-        if (!this.lastEvent || !RelativeAttitude$1.lastEvent) {
-            return false;
-        }
-
-        const diffTime = RelativeAttitude$1.lastEvent.data.time - this.lastEvent.data.timestamp;
-        return diffTime < TurnDetector.CONSIDER_TURN_UNTIL;
-    }
-
-    /**
-     * @private
-     */
-    _parseRelativeAttitude = relativeAttitudeEvent => {
-
-        const { heading, time: timestamp } = relativeAttitudeEvent.data;
-
-        this.slidingWindow = this.slidingWindow.filter(item => item[0] >= timestamp - TurnDetector.SLIDING_WINDOW_TIME);
-        this.slidingWindow.push([timestamp, heading]);
-
-        const stdVal = std(this.slidingWindow.map(item => item[1]));
-        if (stdVal > TurnDetector.STD_THRESHOLD) {
-            this.notify(this.createEvent(EventType.Turn, { timestamp }, [relativeAttitudeEvent]));
-        }
-
-    }
-}
-
-var TurnDectector = new TurnDetector();
-
-const Constants = {
-    DEFAULT_ALTITUDE: 1.6
-};
-
-class StepDetectionMinMaxPeaks2 {
-
-    // in seconds
-    static WINDOW_TIME = 0.3;
-
-    // in seconds
-    static MIN_TIME_BETWEEN_STEPS = 0.4;
-
-    // in Hz
-    static MAX_FRENQUENCY = 4;
-    static MIN_FRENQUENCY = 1;
-
-    // in m.s-2
-    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.75;
-    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.3;
-
-
-    constructor() {
-        this.slidingWindow = [];
-
-        this.lastStepTimestamp = -StepDetectionMinMaxPeaks2.MIN_TIME_BETWEEN_STEPS;
-        this.previousVerticalAcc = 0;
-        this.influence = 0.2;
-    }
-
-
-    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(function(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: timestamp,
-            verticalAcc: 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.0, mean = 0.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);
-    }
-}
-
-class StepDetector extends Provider {
-
-    constructor() {
-        super();
-        this.stepDetector = new StepDetectionMinMaxPeaks2();
-    }
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'StepDetector';
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return Promise.all([
-            Accelerometer$1.availability,
-            Gyroscope$1.availability,
-            RelativeAttitudeFromInertial$1.availability
-        ]);
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        this.numOfSteps = 0;
-
-        this.accelerometerProviderId = Accelerometer$1.addEventListener(
-            events => this.onAccelerometerEvent(events[0]),
-            error => this.notifyError(error)
-        );
-
-        this.gyroscopeProviderId = Gyroscope$1.addEventListener(
-            events => (this.angularRateEvent = events[0]),
-            error => this.notifyError(error)
-        );
-
-        this.attitudeProviderId = RelativeAttitudeFromInertial$1.addEventListener(
-            events => (this.attitudeEvent = events[0]),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        Accelerometer$1.removeEventListener(this.accelerometerProviderId);
-        Gyroscope$1.removeEventListener(this.gyroscopeProviderId);
-        RelativeAttitudeFromInertial$1.removeEventListener(this.attitudeProviderId);
-    }
-
-    onAccelerometerEvent(accelerationEvent) {
-
-        if (!this.attitudeEvent || !this.angularRateEvent) {
-            return;
-        }
-
-        const {
-            values: acceleration, timestamp
-        } = accelerationEvent.data;
-
-        /**
-         * Step Detection and Step Size Detection
-         */
-        const linearAcc = this.constructor.computeLinearAcceleration(
-            this.attitudeEvent.data.quaternion, acceleration);
-        const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.data.values);
-
-        if (stepDetected) {
-            const size = this.stepDetector.lastStepSize;
-            this.numOfSteps++;
-            this.notify(this.createEvent(
-                EventType.Step, {
-                    size,
-                    number: this.numOfSteps
-                },
-                [accelerationEvent, this.angularRateEvent, this.attitudeEvent]
-            ));
-        }
-    }
-
-    // Linear acceleration in ENU
-    static computeLinearAcceleration(quaternion, acc) {
-        const linearAcc = Quaternion.rotate(Quaternion.inverse(quaternion), acc);
-        linearAcc[2] -= Constants$1.EARTH_GRAVITY;
-        return linearAcc;
-    }
-}
-
-var StepDetector$1 = new StepDetector();
-
-class StraightLineDetector extends Provider {
-
-    /** @type {number} */
-    static STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
-
-    /** @type {number?} */
-    _turnDetectorProviderId = null;
-
-    /** @type {number?} */
-    _stepDetectorProviderId = null;
-
-    /** @type {number} */
-    _countSteps = 0;
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'StraightLineDetector';
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this._turnDetectorProviderId = TurnDectector.addEventListener(this._onTurn);
-        this._stepDetectorProviderId = StepDetector$1.addEventListener(this._onStep);
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        TurnDectector.removeEventListener(this._turnDetectorProviderId);
-        StepDetector$1.removeEventListener(this._stepDetectorProviderId);
-    }
-
-    _onTurn = (event) => {
-        if (this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
-
-            const fromEvents = [event];
-            if (StepDetector$1.lastEvent !== null) {
-                fromEvents.push(StepDetector$1.lastEvent);
-            }
-
-            this.notify(this.createEvent(EventType.StraightLine, false, fromEvents));
-
-        }
-        this._countSteps = 0;
-    }
-
-    _onStep = (event) => {
-        this._countSteps++;
-
-        if (this._countSteps === StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
-
-            const fromEvents = [event];
-            if (TurnDectector.lastEvent !== null) {
-                fromEvents.push(TurnDectector.lastEvent);
-            }
-            this.notify(this.createEvent(EventType.StraightLine, true, fromEvents));
-
-        }
-
-    }
-
-    /**
-     * @returns {boolean}
-     */
-    isStraight() {
-        return this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE;
-    }
-
-    get numStepsDetectedFromLastTurn() {
-        return this._countSteps;
-    }
-}
-
-var StraightLineDetector$1 = new StraightLineDetector();
-
-/* eslint-disable max-statements */
-
-class MapMatchingHandler extends Provider {
-
-    /** @type {number} in radians */
-    static MM_MAX_ANGLE = deg2rad(30);
-
-    /** @type {number} in meters */
-    static MM_MAX_DIST = 30;
-
-    /** @type {number} in meters */
-    static MM_MIN_DIST = 0;
-
-    /** @type {boolean} */
-    static ORIENTATION_MATCHING = true;
-
-    /** @type {boolean} */
-    static USE_ITINERARY_START_AS_POSITION = true;
-
-    /** @type {number} in meters */
-    static MM_HUGE_JUMP_DISTANCE = 3;
-
-    /** @type {number} */
-    static MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
-
-    /** @type {number} */
-    static MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
-
-    /** @type {number} */
-    static LAST_PROJECTIONS_WINDOW_SIZE = 3;
-
-    /** @type {number} */
-    static LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
-
-    /** @type {MapMatching} */
-    _mapMatching;
-
-    /** @type {number} */
-    _mapMatchingMinDistance;
-
-    /** @type {boolean} */
-    _internalProvidersStarted = false;
-
-    /** @type {number?} */
-    _straightLineDetectorProviderId;
-
-    /** @type {number?} */
-    _turnDetectorProviderId;
-
-    /** @type {number?} */
-    _stepDetectorProviderId;
-
-    /** @type {GraphProjection[]} */
-    _projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-
-    /** @type {number} */
-    _countStepsFromLastMatching = 0;
-
-    /** @type {GraphProjection[]} */
-    _lastProjections = [];
-
-
-    constructor() {
-        super();
-
-        this._mapMatching = new MapMatching();
-        this._mapMatching.maxDistance = MapMatchingHandler.MM_MAX_DIST;
-        this._mapMatching.maxAngleBearing = MapMatchingHandler.MM_MAX_ANGLE;
-        this._mapMatchingMinDistance = MapMatchingHandler.MM_MIN_DIST;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        if (this.network) {
-            this._startInternalProviders();
-        }
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        this._stopInternalProviders();
-    }
-
-    _manageStartStop = () => {
-        if (this.network && !this._internalProvidersStarted) {
-            this._startInternalProviders();
-        } else if (!this.network && this._internalProvidersStarted) {
-            this._stopInternalProviders();
-        }
-    }
-
-    _startInternalProviders() {
-
-        if (this.enabled && this._internalProvidersStarted) {
-            return;
-        }
-
-        this._straightLineDetectorProviderId = StraightLineDetector$1.addEventListener();
-        this._turnDetectorProviderId = TurnDectector.addEventListener();
-        this._stepDetectorProviderId = StepDetector$1.addEventListener(() => (this._countStepsFromLastMatching++));
-
-        this._internalProvidersStarted = true;
-    }
-
-    _stopInternalProviders() {
-
-        if (this.enabled && !this._internalProvidersStarted) {
-            return;
-        }
-
-        StraightLineDetector$1.removeEventListener(this._straightLineDetectorProviderId);
-        TurnDectector.removeEventListener(this._turnDetectorProviderId);
-        StepDetector$1.removeEventListener(this._stepDetectorProviderId);
-
-        this._internalProvidersStarted = false;
-    }
-
-    get enabled() {
-        return ProvidersOptions.useMapMatching;
-    }
-
-    /** @type {?Network} */
-    get network() {
-        return this._mapMatching.network;
-    }
-
-    /** @type {?Network} */
-    set network(network) {
-
-        this._mapMatching.network = network;
-        this.notify(this.createEvent(EventType.Network, network));
-
-        this._manageStartStop();
-
-        if (this.canUseMapMatching()) ;
-    }
-
-    /** @type {?Itinerary} */
-    set itinerary(itinerary) {
-
-        this._mapMatching.network = itinerary ? itinerary.toNetwork() : null;
-        this.notify(this.createEvent(EventType.Itinerary, itinerary));
-
-        this._manageStartStop();
-
-        if (this.canUseMapMatching()) {
-            this._notifyPositionFromItineraryInput(itinerary);
-        }
-    }
-
-    /**
-     * @returns {boolean}
-     */
-    canUseMapMatching() {
-        return this.enabled && this.network;
-    }
-
-    /**
-     * @param {Itinerary} itinerary
-     */
-    _notifyPositionFromItineraryInput(itinerary) {
-
-        if (!MapMatchingHandler.USE_ITINERARY_START_AS_POSITION || itinerary.start) {
-            return;
-        }
-
-        const lastEvent = AbsolutePosition$1.lastEvent;
-        const lastPosition = lastEvent ? lastEvent.data : null;
-
-        const notify = (pos) => {
-            const newEvent = lastEvent
-                ? lastEvent.clone()
-                : new ProviderEvent(EventType.AbsolutePosition);
-            newEvent.data = pos;
-            AbsolutePosition$1.notify(newEvent);
-        };
-
-        // In case of an itinerary, use itinerary start as new position,
-        // but add the distance between lastPosition and itinerary start for the accuracy
-        const newPosition = 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 >= 2) {
-            newPosition.alt = Constants.DEFAULT_ALTITUDE;
-            newPosition.time = TimeUtils.preciseTime();
-            newPosition.accuracy = 0;
-            newPosition.bearing = itinerary.coords[0].bearingTo(itinerary.coords[1]);
-        } else {
-            return;
-        }
-
-        // if the distance between itinerary.start and itinerary.nodes[0] is less than MM_MAX_DIST,
-        //  projection.projection is itinerary.nodes[0]
-        const projection = this.getProjection(newPosition, true);
-        if (projection) {
-            notify(projection.projection);
-            // Do not notify for attitude projection because bearing has not been used.
-        } else {
-            // This means the first position is far from the network and the user has
-            //  to reach itinerary.nodes[0] before to continue
-            notify(newPosition);
-        }
-        return;
-    }
-
-    /**
-     * @param {ProviderEvent<UserPosition>} newPositionEvent
-     */
-    notifyPositionFromFeed(newPositionEvent) {
-
-        const projection = this.getProjection(newPositionEvent.data, true, false);
-        if (!projection) {
-            AbsolutePosition$1.notify(newPositionEvent);
-            return;
-        }
-
-        AbsolutePosition$1.notify(this.createEvent(
-            EventType.AbsolutePosition,
-            projection.projection,
-            [newPositionEvent]
-        ));
-    }
-
-
-    /**
-     * @param {ProviderEvent<UserPosition>} positionEvent
-     */
-    notifyPositionFromAbsolute(positionEvent) {
-
-        const newPosition = positionEvent.data;
-
-        let projectionWithBearing = null;
-        if (newPosition.bearing !== null) {
-            projectionWithBearing = this.getProjection(newPosition, true, true);
-        }
-
-        if (!projectionWithBearing) {
-            // Verify if the newPosition is far enough from the network to be used by the system.
-            const projectionWithoutBearing = this.getProjection(newPosition, true, false);
-            if (!projectionWithoutBearing) {
-                // In this case, the newPosition is far enough and can be used safely.
-                AbsolutePosition$1.notify(positionEvent);
-            }
-            return;
-        }
-
-        // newPosition must not be used after this line
-
-        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
-
-        // In case of a huge jump, be sure the user is in a straight line
-        if (thisWillBeAHugeJump && !StraightLineDetector$1.isStraight()) {
-            return;
-        }
-
-        // Detector to avoid big jumps in the wrong direction
-        if (thisWillBeAHugeJump && this._detectWrongBigJump(projectionWithBearing)) {
-            return;
-        }
-
-        AbsolutePosition$1.notify(this.createEvent(
-            EventType.AbsolutePosition,
-            projectionWithBearing.projection,
-            [positionEvent]
-        ));
-
-        this.tryOrientationMatching(projectionWithBearing);
-
-    }
-
-
-    /**
-     * @param {ProviderEvent<UserPosition>} positionEvent
-     */
-    notifyPositionFromRelative(positionEvent) {
-
-        if (TurnDectector.isTurning()) {
-            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-            this._lastProjections = [];
-            AbsolutePosition$1.notify(positionEvent);
-            return;
-        }
-
-        const newPosition = positionEvent.data;
-        const projection = this.getProjection(newPosition, true, true);
-
-        if (projection) {
-            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-            this._lastProjections.push(projection);
-            if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
-                this._lastProjections.shift();
-            }
-
-            const thisWillBeAHugeJump = projection.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
-
-            // In case of a huge jump, be sure the user is in a straight line
-            if (thisWillBeAHugeJump && !StraightLineDetector$1.isStraight()) {
-                AbsolutePosition$1.notify(positionEvent);
-                return;
-            }
-
-            // Detector to avoid big jumps in the wrong direction
-            if (thisWillBeAHugeJump && this._detectWrongBigJump(projection)) {
-                AbsolutePosition$1.notify(positionEvent);
-                return;
-            }
-
-            // Do not use projection if the neareast element is not the same direction than previous
-            if (!this._areLastProjectionsInTheSameDirection()) {
-                AbsolutePosition$1.notify(positionEvent);
-                return;
-            }
-
-            AbsolutePosition$1.notify(this.createEvent(
-                EventType.AbsolutePosition,
-                projection.projection,
-                [positionEvent]
-            ));
-            this.tryOrientationMatching(projection);
-
-        } else {
-
-            // Sometimes, the newPosition.bearing diverges due to the Absolute Attitude offset
-            // and the Orientation Matching. So, we created this detector to check if projection
-            // with bearing from "AbsoluteAttitudeFromBrowser" is better than the current bearing.
-            // /!\ This works only if the user is waking in the same direction than the smartphone orientation /!\
-            if (StraightLineDetector$1.isStraight()) {
-
-                const testedPosition = newPosition.clone();
-                testedPosition.bearing = AbsoluteAttitudeFromBrowser$1.lastEvent.data.heading;
-                const projectionWithAbs = this.getProjection(testedPosition, true, true);
-
-                if (projectionWithAbs) {
-
-                    this._projectionsWithAbsAndWithoutRelAttitudeInARow.push(projectionWithAbs);
-                    if (this._projectionsWithAbsAndWithoutRelAttitudeInARow.length < 3) {
-                        AbsolutePosition$1.notify(positionEvent);
-                        return;
-                    }
-
-                    this._lastProjections.push(projectionWithAbs);
-                    if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
-                        this._lastProjections.shift();
-                    }
-
-
-                    if (!this._areLastProjectionsInTheSameDirection()) {
-                        AbsolutePosition$1.notify(positionEvent);
-                        return;
-                    }
-
-                    AbsolutePosition$1.notify(this.createEvent(
-                        EventType.AbsolutePosition,
-                        projectionWithAbs.projection,
-                        [positionEvent]
-                    ));
-
-                    this.tryOrientationMatching(projectionWithAbs);
-                    return;
-                }
-            }
-
-            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-            this._lastProjections = [];
-
-            // If no projection found with both projection methods, simply use the newPosition.
-            AbsolutePosition$1.notify(positionEvent);
-        }
-
-    }
-
-    /**
-     * @param {Projection} projection
-     */
-    _detectWrongBigJump(projection) {
-
-        if (this.network instanceof Itinerary && AbsolutePosition$1.lastEvent) {
-            const itinerary = this.network;
-            const infoPrevious = itinerary.getInfo(AbsolutePosition$1.lastEvent.data);
-            const infoProjection = itinerary.getInfo(projection.projection);
-            if (infoPrevious
-                && infoProjection
-                && infoPrevious.traveledDistance > infoProjection.traveledDistance
-                && (infoPrevious.traveledDistance - infoProjection.traveledDistance) > projection.origin.accuracy
-                && projection.distanceFromNearestElement > projection.origin.accuracy
-                && projection.origin.distanceTo(AbsolutePosition$1.lastEvent.data) < projection.origin.accuracy + AbsolutePosition$1.lastEvent.data.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 GraphEdge)
-            || (diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing)
-                > MapMatchingHandler.LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD)
-        );
-    }
-
-    /**
-     * @param {Projection} projection
-     */
-    tryOrientationMatching(projection) {
-
-        if (!MapMatchingHandler.ORIENTATION_MATCHING) {
-            return;
-        }
-
-        if (this.state !== ProviderState.STARTED
-            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING
-            || StraightLineDetector$1.numStepsDetectedFromLastTurn < MapMatchingHandler.MIN_STEPS_FOR_ORIENTATION_MATCHING) {
-            return;
-        }
-
-        const { nearestElement, origin } = projection;
-        if (!(nearestElement instanceof GraphEdge)) {
-            return;
-        }
-
-        let matchingDirection;
-        const matchingDirectionAngle1 = diffAngle(nearestElement.bearing, origin.bearing);
-        const matchingDirectionAngle2 = 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 AbsoluteHeading(
-            matchingDirection,
-            origin.time,
-            0
-            // Math.min(Math.abs(matchingDirectionAngle1), Math.abs(matchingDirectionAngle2))
-        );
-
-        AbsoluteAttitude$1._forceHeadingForRelative(
-            new ProviderEvent(EventType.AbsoluteHeading, 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;
-    }
-}
-
-var MapMatchingHandler$1 = new MapMatchingHandler();
-
-class GeolocationApiMissingError extends Error {
-
-    static DEFAULT_MESSAGE = 'Geolocation api is missing';
-
-    constructor(message) {
-        super(message || GeolocationApiMissingError.DEFAULT_MESSAGE);
-    }
-}
-
-class GeolocationPermissionDeniedError extends Error {
-
-    static DEFAULT_MESSAGE = 'Geolocation permission denied';
-
-    constructor(message) {
-        super(message || GeolocationPermissionDeniedError.DEFAULT_MESSAGE);
-    }
-}
-
-class GeolocationPositionUnavailableError extends Error {
-
-    static DEFAULT_MESSAGE = 'Geolocation position unavailable';
-
-    constructor(message) {
-        super(message || GeolocationPositionUnavailableError.DEFAULT_MESSAGE);
-    }
-}
-
-/**
- * GnssWifiProvider is a provider based on navigator.geolocation.
- * This API does not allow us to know if the position returned is provided
- *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
- *  "GnssWifi".
- */
-class GnssWifi extends Provider {
-
-    static POSITION_OPTIONS = {
-        enableHighAccuracy: true,
-        timeout: Infinity,
-        maximumAge: 0
-    };
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'GnssWifi';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsolutePosition];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return typeof (navigator) === 'object' && navigator.geolocation
-            ? Promise.resolve()
-            : Promise.reject(new GeolocationApiMissingError());
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        this.geoLocationId = navigator.geolocation.watchPosition(
-            this.onNewPosition,
-            this.onPositionError,
-            GnssWifi.POSITION_OPTIONS
-        );
-
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-
-        navigator.geolocation.clearWatch(this.geoLocationId);
-
-    }
-
-    /**
-     * @private
-     */
-    onNewPosition = geolocation => {
-
-        const { coords } = geolocation;
-        if (!coords) {
-            return;
-        }
-
-        let bearing;
-        if (coords.heading) {
-            bearing = deg2rad(coords.heading);
-        }
-
-        const timestamp = TimeUtils.unixTimestampToPreciseTime(geolocation.timestamp) / 1e3;
-
-        const position = new UserPosition(
-            coords.latitude,
-            coords.longitude,
-            Constants.DEFAULT_ALTITUDE,
-            null,
-            timestamp,
-            coords.accuracy,
-            bearing,
-            this.pname);
-
-        this.notify(this.createEvent(
-            EventType.AbsolutePosition, position
-        ));
-
-    };
-
-    onPositionError = error => {
-
-        Logger.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);
-    };
-}
-
-var GnssWifi$1 = new GnssWifi();
-
-class GeoRelativePositionFromArCore extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'GeoRelativePositionFromArCore';
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return ArCore$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        this.arCoreProviderId = ArCore$1.addEventListener(
-            this.onArCoreEvents,
-            error => this.notifyError(error)
-        );
-
-        this.absoluteAttitudeProviderId = AbsoluteAttitude$1.addEventListener(
-            events => (this.absoluteAttitudeEvent = events[0]),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        ArCore$1.removeEventListener(this.arCoreProviderId);
-        AbsoluteAttitude$1.removeEventListener(this.absoluteAttitudeProviderId);
-    }
-
-    onArCoreEvents = events => {
-        const relativeAttitudeEvent = events.find(event => event.dataType === EventType.RelativeAttitude);
-        const relativePositionEvent = events.find(event => event.dataType === EventType.RelativePosition);
-
-        if (relativeAttitudeEvent && relativePositionEvent && this.absoluteAttitudeEvent) {
-            this.compute(relativePositionEvent, relativeAttitudeEvent, this.absoluteAttitudeEvent);
-        }
-    }
-
-    compute(relativePositionEvent, relativeAttitudeEvent, absoluteAttitudeEvent) {
-        const relativePosition = relativePositionEvent.data;
-        const relativeAttitude = relativeAttitudeEvent.data;
-        const absoluteAttitude = absoluteAttitudeEvent.data;
-
-        const rotation = absoluteAttitude.heading - relativeAttitude.heading;
-
-        /**
-         * Here, we transform "relativePosition" which is defined in ArCore frame to a relative "position" defined in ENU frame
-         */
-        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;
-
-        /**
-         * Relative position is defined in ENU frame
-         */
-        const position = new GeoRelativePosition$1(
-            east,
-            north,
-            up,
-            relativePosition.time,
-            0,
-            absoluteAttitude.heading
-        );
-
-        this.notify(this.createEvent(
-            EventType.GeoRelativePosition,
-            position,
-            [relativePositionEvent, relativeAttitudeEvent, absoluteAttitudeEvent]
-        ));
-    }
-}
-
-var GeoRelativePositionFromArCore$1 = new GeoRelativePositionFromArCore();
-
-class Pdr extends Provider {
-
-    // https://ieeexplore.ieee.org/document/7346766
-    misalignment = [1, 0, 0, 0];
-    misalignmentError = deg2rad(3);
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'PDR';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativePosition];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return Promise.all([
-            StepDetector$1.availability,
-            AbsoluteAttitude$1.availability
-        ]);
-    }
-
-
-    /**
-     * @override
-     */
-    start() {
-
-        this.stepDetectionProviderId = StepDetector$1.addEventListener(
-            events => this.onStepEvent(events[0]),
-            error => this.notifyError(error)
-        );
-
-        this.absoluteAttitudeProviderId = AbsoluteAttitude$1.addEventListener(
-            events => (this.attitudeEvent = events[0]),
-            error => this.notifyError(error)
-        );
-
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        StepDetector$1.removeEventListener(this.stepDetectionProviderId);
-        AbsoluteAttitude$1.removeEventListener(this.absoluteAttitudeProviderId);
-    }
-
-    /**
-     * @private
-     */
-    onStepEvent = stepEvent => {
-
-        if (!this.attitudeEvent) {
-            return;
-        }
-
-        const stepSize = stepEvent.data.size;
-
-        /**
-         * There is three frames because (device heading != walking direction):
-         *
-         * Device frame (x-Device Right, y-Device Top, z-Device Front)
-         * Navigation frame (x-Nav East, y-Nav North, z-Nav Up)
-         * Earth local frame (x-East y-North z-Up)
-         *
-         *
-         * For the PDR, in order to find the step direction,
-         *  we are looking for the rotation between the device frame and the navigation frame.
-         * Attitude is the rotation from the device frame to the earth local frame.
-         * Misalignment is the rotation from the navigation frame to the earth local frame
-         */
-        const deviceAttitude = this.attitudeEvent.data;
-
-        /**
-         * For optimisation, as we define misalignment to identity, we do not process the quat mulitply formula.
-         */
-        // const deviceInNavFrame = Quaternion.multiply(deviceAttitude.quaternion, this.misalignment);
-        // const deviceDirection = new Attitude(deviceInNavFrame).heading;
-        const deviceDirection = deviceAttitude.heading;
-
-        /**
-         * A bad accuracy from PDR is due to three things:
-         * - Attitude accuracy
-         * - Misalignement (device heading != walking direction)
-         * - Step detection false positives / false negatives
-         * Following formula only use attitude accuracy with cone formula
-         */
-        const deviceDirectionAccuracy = deviceAttitude.accuracy + this.misalignmentError;
-        const accuracy = (stepSize / 2) * Math.sin(deviceDirectionAccuracy / 2);
-        const timestamp = deviceAttitude.time;
-
-        /**
-         * Relative position is defined in ENU frame
-         */
-        const position = new GeoRelativePosition$1(
-            stepSize * Math.sin(deviceDirection),
-            stepSize * Math.cos(deviceDirection),
-            0,
-            timestamp,
-            accuracy,
-            deviceDirection
-        );
-
-        this.notify(this.createEvent(
-            EventType.GeoRelativePosition,
-            position,
-            [stepEvent, this.attitudeEvent]
-        ));
-    }
-
-}
-
-var Pdr$1 = new Pdr();
-
-class GeoRelativePosition extends Provider {
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'GeoRelativePosition';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.GeoRelativePosition];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return PromiseUtils.any([
-            Pdr$1.availability,
-            GeoRelativePositionFromArCore$1.availability
-        ]);
-    }
-
-
-    /**
-     * @override
-     */
-    start() {
-
-        GeoRelativePositionFromArCore$1.availability
-            .then(() => (this.geoRelativeProvider = GeoRelativePositionFromArCore$1))
-            .catch(() => (this.geoRelativeProvider = Pdr$1))
-            .finally(() => {
-                this.providerId = this.geoRelativeProvider.addEventListener(
-                    events => {
-                        const event = events.find(_event => _event.dataType === EventType.GeoRelativePosition);
-                        if (event) {
-                            this.notify(event.clone());
-                        }
-                    },
-                    error => this.notifyError(error)
-                );
-            });
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        if (this.geoRelativeProvider) {
-            this.geoRelativeProvider.removeEventListener(this.providerId);
-            this.geoRelativeProvider = null;
-        }
-    }
-}
-
-var GeoRelativePositionProvider = new GeoRelativePosition();
-
-class AbsolutePosition extends Provider {
-
-    // Use the new absolute position if its accuracy is at least x times better than the last one.
-    static ACCURACY_RELOC_RATIO = 1.5;
-
-    /** @type {boolean} */
-    static USE_MM_FOR_FEED = true;
-
-
-    /** @type {number?} */
-    _gnssWifiProviderId;
-
-    /** @type {number?} */
-    _relativePositionProviderId;
-
-    /** @type {number?} */
-    _mapMatchingHandlerId
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'AbsolutePosition';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsolutePosition];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return PromiseUtils.any([
-            GeoRelativePositionProvider.availability,
-            GnssWifi$1.availability
-        ]);
-    }
-
-
-    /**
-     * @override
-     */
-    start() {
-        GeoRelativePositionProvider.availability
-            .then(() => {
-                this._relativePositionProviderId = GeoRelativePositionProvider.addEventListener(
-                    events => this._onRelativePosition(events[0])
-                );
-            })
-            .catch(() => {
-                // do nothing
-            });
-
-        this._gnssWifiProviderId = GnssWifi$1.addEventListener(
-            events => {
-                // bearing from GnssWifi is not reliable for our usecase
-                events[0].data.bearing = null;
-                this._onAbsolutePosition(events[0], false);
-            }
-        );
-
-        this._mapMatchingHandlerId = MapMatchingHandler$1.addEventListener();
-    }
-
-
-    /**
-     * @override
-     */
-    stop() {
-        if (this._relativePositionProviderId) {
-            GeoRelativePositionProvider.removeEventListener(this._relativePositionProviderId);
-        }
-        GnssWifi$1.removeEventListener(this._gnssWifiProviderId);
-
-        MapMatchingHandler$1.removeEventListener(this._mapMatchingHandlerId);
-    }
-
-    /**
-     * @param {ProviderEvent<UserPosition>} positionEvent
-     * @param {boolean} canContainLevel
-     */
-    _onAbsolutePosition(positionEvent, canContainLevel = true) {
-
-        const newPosition = positionEvent.data.clone();
-        const lastPosition = this.lastEvent ? this.lastEvent.data : null;
-
-        if (lastPosition) {
-
-            // Is the new position accuracy is better enough than the last position accuracy
-            const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO < lastPosition.accuracy;
-
-            // Is the new position is far from the new one (regarding accuracy)
-            // This is important if the person put the current page in the background during a while
-            const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
-
-            if (!isBetterEnough && !isFarEnough) {
-                return;
-            }
-
-            if (!canContainLevel) {
-                newPosition.level = lastPosition.level;
-            }
-
-            // If the new position does not have a bearing, retrieve the bearing from the last position
-            if (newPosition.bearing === null) {
-                newPosition.bearing = lastPosition.bearing;
-            }
-        }
-
-
-        const newPositionEvent = this.createEvent(
-            EventType.AbsolutePosition,
-            newPosition,
-            [positionEvent]
-        );
-
-        // If the MM is disable or the network is not set yet, use the new position as it is.
-        // If the position bearing is null, do not use MM, it is too dangerous.
-        if (!MapMatchingHandler$1.canUseMapMatching()) {
-            this.notify(newPositionEvent);
-            return;
-        }
-
-        MapMatchingHandler$1.notifyPositionFromAbsolute(newPositionEvent);
-    }
-
-    /**
-     * @param {ProviderEvent<GeoRelativePosition>} relativeEvent
-     */
-    _onRelativePosition(relativeEvent) {
-
-        if (!this.lastEvent) {
-            return;
-        }
-
-        const lastPosition = this.lastEvent.data;
-
-        const offsetPos = relativeEvent.data;
-
-        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;
-
-
-        const newPositionEvent = this.createEvent(
-            EventType.AbsolutePosition,
-            newPosition,
-            [relativeEvent]
-        );
-
-
-        if (!MapMatchingHandler$1.canUseMapMatching()) {
-            this.notify(newPositionEvent);
-            return;
-        }
-
-        MapMatchingHandler$1.notifyPositionFromRelative(newPositionEvent);
-    }
-
-
-    /**
-     * @override
-     * @param {UserPosition|ProviderEvent} data
-     */
-    feed(data) {
-
-        /** @type {ProviderEvent<UserPosition>} */
-        let newPositionEvent;
-
-        if (data instanceof 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 = new ProviderEvent(EventType.AbsolutePosition, data);
-
-        } else if (data instanceof ProviderEvent) {
-
-            if (data.dataType !== EventType.AbsolutePosition
-                || !(data.data instanceof UserPosition)) {
-                throw Error('the provider event is not an UserPosition');
-            }
-
-            newPositionEvent = data;
-
-        } else {
-            throw new Error('data is nor an UserPosition or a ProviderEvent');
-        }
-
-        // If the MM is disable or the network is not set yet, use the new position as it is.
-        if (!AbsolutePosition.USE_MM_FOR_FEED || !MapMatchingHandler$1.canUseMapMatching()) {
-            this.notify(newPositionEvent);
-            return;
-        }
-
-        MapMatchingHandler$1.notifyPositionFromFeed(newPositionEvent);
-    }
-}
-
-var AbsolutePosition$1 = new AbsolutePosition();
-
-/**
- * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame using
- *  browser deviceorientation or deviceorientationabsolute
- * The provider does not work until an AbsolutePosition is given. This is necessary to
- *  calculate declination.
- *
- * -----------------------------------
- * Overview of compatibilities:
- * -----------------------------------
- *
- * Chrome Android (v72.0.3626): YES (via deviceorientationabsolute)
- * Safari iOS (v12.0): YES (via deviceorientation and event.webkitCompassHeading)
- * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation}
- * Firefox Android (v65.0.1): NO {@link https://www.fxsitecompat.com/en-CA/docs/2018/various-device-sensor-apis-are-now-deprecated/}
- *
- * -----------------------------------
- */
-class AbsoluteAttitudeFromBrowser extends Provider {
-
-    // from http://tyrex.inria.fr/mobile/benchmarks-attitude/
-    static DEFAULT_ACCURACY = deg2rad(15);
-
-    absolutePositionProviderId = null;
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'AbsoluteAttitudeFromBrowser';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return BrowserUtils.isMobile
-            ? Promise.resolve()
-            : Promise.reject(new AskImuOnDesktopError());
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        const subscribe = () => {
-            switch (BrowserUtils.name) {
-            case Browser.CHROME:
-                window.addEventListener('deviceorientationabsolute',
-                    this.onDeviceOrientationChromeEvent, true);
-                break;
-
-            case Browser.SAFARI:
-            case Browser.IOS_WEBVIEW:
-                window.addEventListener('deviceorientation',
-                    this.onDeviceOrientationSafariEvent, true);
-                break;
-            }
-        };
-
-        if (typeof (DeviceOrientationEvent) !== 'undefined' && typeof (DeviceOrientationEvent.requestPermission) === 'function') {
-            DeviceOrientationEvent
-                .requestPermission()
-                .then(response => {
-                    if (response !== 'granted') {
-                        throw new Error('Permission not granted');
-                    }
-                    subscribe();
-                })
-                .catch(error => this.notifyError(error));
-        } else {
-            subscribe();
-        }
-
-
-        const lastAbsolutePosition = AbsolutePosition$1.lastEvent;
-        if (lastAbsolutePosition) {
-            this.onAbsolutePositionEvent(lastAbsolutePosition);
-        } else {
-            this.absolutePositionProviderId = AbsolutePosition$1.addEventListener(
-                events => this.onAbsolutePositionEvent(events[0]),
-                error => this.notifyError(error),
-                false
-            );
-        }
-
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        switch (BrowserUtils.name) {
-        case Browser.CHROME:
-            window.removeEventListener('deviceorientationabsolute',
-                this.onDeviceOrientationChromeEvent, true);
-            break;
-
-        case Browser.SAFARI:
-        case Browser.IOS_WEBVIEW:
-            window.removeEventListener('deviceorientation',
-                this.onDeviceOrientationSafariEvent, true);
-            break;
-        }
-
-        if (this.absolutePositionProviderId !== null) {
-            AbsolutePosition$1.removeEventListener(this.absolutePositionProviderId);
-        }
-    }
-
-
-    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 = Rotations.eulerToQuaternionZXYDegrees(
-            [e.alpha, e.beta, e.gamma]);
-
-        this.compute();
-    };
-
-
-    iosPreviousQuat = null;
-    iosIsSkyMode;
-
-    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;
-        }
-
-        /**
-         * Trying the best to retrieve a good quaternion from devicemotion event.
-         */
-
-        let alpha;
-        const [qw, qx, qy, qz] = Rotations.eulerToQuaternionZXYDegrees([e.webkitCompassHeading, e.beta, e.gamma]);
-        const groundAngle = rad2deg(Math.acos(qw ** 2 - qx ** 2 - qy ** 2 + qz ** 2));
-
-        let isSkyMode;
-        if (groundAngle > 136) {
-            isSkyMode = true;
-        } else if (groundAngle < 134) {
-            isSkyMode = false;
-        } else if (this.iosPreviousQuat && this.iosIsSkyMode !== null) {
-            /**
-             * This condition is true only if :
-             * - we are in the [134°; 136°] ground angle range
-             * - we know the previous quaternion
-             * - one of the both previous condition has been reached during this session
-             *
-             * In this case, we define a threshold to detect if there is a "jump" in the quaternion calculation,
-             * then, the mode is switched.
-             */
-            isSkyMode = 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') {
-            // Algorithm uncertainity
-            return;
-        }
-
-        if (isSkyMode) {
-            alpha = 180 - e.webkitCompassHeading;
-        } else {
-            alpha = AbsoluteAttitudeFromBrowser.webkitCompassToHeading(
-                e.webkitCompassHeading, e.beta, e.gamma);
-        }
-
-        this.magQuaternion = Rotations.eulerToQuaternionZXYDegrees([alpha, e.beta, e.gamma]);
-
-        this.compute();
-    };
-
-
-    compute() {
-
-        if (!this.declinationQuaternion || !this.magQuaternion) {
-            return;
-        }
-
-        const trueQuaternion = Quaternion.multiply(this.declinationQuaternion, this.magQuaternion);
-        const attitude = new Attitude(trueQuaternion, this.magQuaternionTimestamp,
-            this.constructor.DEFAULT_ACCURACY, this.pname);
-        this.notify(this.createEvent(
-            EventType.AbsoluteAttitude,
-            attitude,
-            [this.absolutePositionEvent]
-        ));
-    }
-
-    /**
-     * Initialized declination quaternion using current position.
-     * This method should be theoretically called every time the user moves.
-     * But in reality declination does not change as much.
-     * @param {Coordinates} positionEvent user position event
-     */
-    onAbsolutePositionEvent = positionEvent => {
-
-        if (!positionEvent) {
-            return;
-        }
-
-        this.absolutePositionEvent = positionEvent;
-
-        const position = positionEvent.data;
-        const wmmResult = geomagnetism.model().point([position.lat, position.lng]);
-        // Declination is given in NED frame and our code use ENU, that is why we have: "-decl"
-        this.declinationQuaternion = Quaternion.fromAxisAngle([0, 0, 1], - deg2rad(wmmResult.decl));
-
-        AbsolutePosition$1.removeEventListener(this.absolutePositionProviderId);
-        this.absolutePositionProviderId = null;
-        this.compute();
-    }
-
-    static webkitCompassToHeading(_webkitCompassHeading, _beta, _gamma) {
-        const webkitCompassHeading = deg2rad(_webkitCompassHeading);
-        const beta = deg2rad(_beta);
-        const gamma = 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 rad2deg(-2 * Math.atan(qz / qw));
-    }
-}
-
-var AbsoluteAttitudeFromBrowser$1 = new AbsoluteAttitudeFromBrowser();
-
-/**
- * Inclination provider gives the inclination of the device using Imu Sensor
- * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
- *              when the device is layed on a table, inclination = 0
- * This provider use window.orientation to return a result in function of screen orientation
- */
-class InclinationFromAcc extends Provider {
-
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'InclinationFromAcc';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Inclination];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return Accelerometer$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = Accelerometer$1.addEventListener(
-            events => this.onAccelerometerEvent(events[0]),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        Accelerometer$1.removeEventListener(this.providerId);
-    }
-
-    /**
-     * @private
-     */
-    onAccelerometerEvent = accelerometerEvent => {
-        const acc = accelerometerEvent.data.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 if (screenOrientation === 180) {
-            inclination = -Math.asin(2 * qNormalized[1] * qNormalized[0]);
-        }
-
-        this.notify(this.createEvent(
-            EventType.Inclination,
-            inclination,
-            [accelerometerEvent]
-        ));
-    };
-}
-
-var InclinationFromAcc$1 = new InclinationFromAcc();
-
-/**
- * Inclination provider gives the inclination of the device using Relative Attitude
- * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
- *              when the device is layed on a table, inclination = 0
- * This provider use window.orientation to return a result in function of screen orientation
- */
-class InclinationFromRelativeAttitude extends Provider {
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'InclinationFromRelativeAttitude';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Inclination];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return RelativeAttitudeFromInertial$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = RelativeAttitudeFromInertial$1.addEventListener(
-            events => {
-                const attitudeEvent = events[0];
-                const inclination = this.constructor.enuQuatToInclination(
-                    attitudeEvent.data.quaternion
-                );
-                this.notify(this.createEvent(
-                    EventType.Inclination,
-                    inclination,
-                    [attitudeEvent]
-                ));
-            },
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        RelativeAttitudeFromInertial$1.removeEventListener(this.providerId);
-    }
-
-    static 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]));
-        }
-        // else if (screenOrientation === 180)
-        return -Math.asin(2 * (q[2] * q[3] + q[1] * q[0]));
-    }
-}
-
-var InclinationFromRelativeAttitude$1 = new InclinationFromRelativeAttitude();
-
-/**
- * Inclination provider gives the inclination of the device using Imu Sensor
- * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
- *              when the device is layed on a table, inclination = 0
- * This provider use window.orientation to return a result in function of screen orientation
- */
-class Inclination extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'InclinationProvider';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Inclination];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return PromiseUtils.any([
-            InclinationFromAcc$1.availability,
-            InclinationFromRelativeAttitude$1.availability
-        ]);
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        const startInclinationFromAcc = () => {
-            this.provider = InclinationFromAcc$1;
-            this.providerId = this.provider.addEventListener(
-                events => this.notify(events[0].clone()),
-                error => this.notifyError(error)
-            );
-        };
-
-        if (InclinationFromRelativeAttitude$1.availability) {
-            this.provider = InclinationFromRelativeAttitude$1;
-            this.providerId = this.provider.addEventListener(
-                events => this.notify(events[0].clone()),
-                () => {
-                    InclinationFromRelativeAttitude$1.removeEventListener(this.providerId);
-                    startInclinationFromAcc();
-                }
-            );
-        } else {
-            startInclinationFromAcc();
-        }
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        if (this.provider) {
-            this.provider.removeEventListener(this.providerId);
-        }
-    }
-}
-
-var Inclination$1 = new Inclination();
-
-/* eslint-disable max-statements */
-
-/**
- * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
- */
-class AbsoluteAttitude extends Provider {
-
-    /** @type {number} */
-    static REL_ABS_DIVERGENCE_ANGLE_THRESHOLD = deg2rad(25);
-
-    /** @type {number} in seconds */
-    static REL_ABS_DIVERGENCE_TIME_THRESHOLD = 2.5;
-
-    /** @type {number} */
-    static REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD = deg2rad(15);
-
-    /** @type {boolean} */
-    _attitudeFromBrowserErrored = false;
-
-    /** @type {boolean} */
-    _attitudeFromRelativeErrored = false;
-
-    /*
-     * RELATIVE
-     */
-
-    /** @type {Attitude} */
-    _relativeAttitude = null;
-
-    /** @type {number} in radians/s */
-    _relativeAccuracy = 0;
-
-    /** @type {ProviderEvent<Attitude|AbsoluteHeading>} */
-    _lastForcedHeadingEvent;
-
-    /** @type {number[]} quaternion offset from relative to absolute */
-    _relAbsQuat;
-
-    /** @type {boolean} */
-    _wasHighRotationInProgress = false;
-
-    /** @type {?number} */
-    _timeFirstDivergence = null;
-
-
-    constructor() {
-        super();
-
-        this._attitudeFromBrowserErrored = false;
-        this._attitudeFromRelativeErrored = false;
-    }
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'AbsoluteAttitude';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return PromiseUtils.any([
-            AbsoluteAttitudeFromBrowser$1.availability,
-            RelativeAttitude$1.availability
-        ]);
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        this.fromBrowserProviderId = AbsoluteAttitudeFromBrowser$1.addEventListener(
-            events => this._onAttitudeFromBrowser(events[0]),
-            error => {
-                this._attitudeFromBrowserErrored = true;
-                this.onError(error);
-            }
-        );
-
-        this.relativeAttitudeProviderId = RelativeAttitude$1.addEventListener(
-            events => this._onRelativeAttitudeEvent(events[0]),
-            error => {
-                this._attitudeFromRelativeErrored = true;
-                this.onError(error);
-            }
-        );
-
-        this.inclinationProviderId = Inclination$1.addEventListener();
-
-        this.highRotationDetectorId = HighRotationsDetector$1.addEventListener();
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        AbsoluteAttitudeFromBrowser$1.removeEventListener(this.fromBrowserProviderId);
-        RelativeAttitude$1.removeEventListener(this.relativeAttitudeProviderId);
-        Inclination$1.removeEventListener(this.inclinationProviderId);
-        HighRotationsDetector$1.removeEventListener(this.highRotationDetectorId);
-    }
-
-    onError(error) {
-        if (this._attitudeFromBrowserErrored && this._attitudeFromRelativeErrored) {
-            this.notifyError(error);
-        }
-    }
-
-
-    /**
-     * @param {ProviderEvent<Attitude|AbsoluteHeading>} absoluteHeadingEvent
-     */
-    _forceHeadingForRelative = (absoluteHeadingEvent) => {
-
-        if (this.lastEvent && absoluteHeadingEvent.data.accuracy > this.lastEvent.data.accuracy) {
-            return;
-        }
-
-
-        /**
-         * @param {Attitude} relativeAttitude
-         */
-        const calcForceHeading = (relativeAttitude) => {
-            const currentRelativeHeading = relativeAttitude.heading;
-
-            this._relAbsQuat = Quaternion.fromAxisAngle(
-                [0, 0, 1],
-                currentRelativeHeading - absoluteHeadingEvent.data.heading
-            );
-
-            this._relativeAccuracy = 0;
-            this._lastForcedHeadingEvent = absoluteHeadingEvent;
-        };
-
-        // If relativeAttitude does not exist yet, wait the next
-        if (this._relativeAttitude) {
-            calcForceHeading(this._relativeAttitude);
-            return;
-        }
-
-        // If this._relativeAttitude does not exist, wait the first value
-        // /!\ This works only if the relative attitude event is provided rapidly.
-        const providerId = RelativeAttitude$1.addEventListener(
-            events => {
-                calcForceHeading(events[0].data);
-                RelativeAttitude$1.removeEventListener(providerId);
-            }
-        );
-
-    };
-
-    /**
-     * @param {ProviderEvent<Attitude>} event
-     */
-    _onRelativeAttitudeEvent(event) {
-
-        const { quaternion, accuracy, time } = event.data;
-
-        // Calculate relative accuracy
-        if (this._relativeAttitude) {
-            this._relativeAccuracy += (time - this._relativeAttitude.time) * accuracy;
-        }
-
-        // Keep the relative attitude event for the calculation of relAbsQuat
-        // /!\ Keep this even if forced heading is not set /!\
-        this._relativeAttitude = event.data;
-
-
-        if (!this._lastForcedHeadingEvent) {
-            return;
-        }
-
-        const accuracyWithRelative = Math.min(
-            this._lastForcedHeadingEvent.data.accuracy + this._relativeAccuracy,
-            Math.PI
-        );
-
-        const highRotationInProgress = HighRotationsDetector$1.isInProgress();
-
-        let magnetometerNeedCalibrationEvent = null;
-        let divergenceDetected = false;
-
-        if (this._eventFromBrowser) {
-
-            const {
-                accuracy: accuracyWithAbsolute,
-                heading: headingFromAbsolute
-            } = this._eventFromBrowser.data;
-
-            if (this._wasHighRotationInProgress && !highRotationInProgress) {
-                // Update heading for relative if it the end of high rotations
-                // (probably due to a magnetometer calibratiton)
-                this._forceHeadingForRelative(this._eventFromBrowser);
-
-            } else if (accuracyWithAbsolute < accuracyWithRelative) {
-                // Update heading for relative if:
-                // (1) accuracy from absolute is better than relative
-                // (2) heading divergence is greater than REL_ABS_DIVERGENCE_THRESHOLD
-                const relativeQuaternion = Quaternion.multiply(this._relAbsQuat, quaternion);
-                const relativeAttitude = new Attitude(relativeQuaternion);
-                const angle = Math.abs(diffAngle(relativeAttitude.heading, headingFromAbsolute));
-                const inclination = Inclination$1.lastEvent.data;
-
-
-                if (angle > AbsoluteAttitude.REL_ABS_DIVERGENCE_ANGLE_THRESHOLD
-                    && Math.abs(inclination - Math.PI / 4) > AbsoluteAttitude.REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD
-                ) {
-                    divergenceDetected = true;
-
-                    // Be sure before forcing heading
-                    if (this._timeFirstDivergence !== null
-                        && time - this._timeFirstDivergence > AbsoluteAttitude.REL_ABS_DIVERGENCE_TIME_THRESHOLD) {
-
-                        this._forceHeadingForRelative(this._eventFromBrowser);
-                        magnetometerNeedCalibrationEvent = this.createEvent(
-                            EventType.MagnetometerNeedCalibration,
-                            {
-                                angle
-                            }, [event, this._lastForcedHeadingEvent]
-                        );
-                        this._timeFirstDivergence = null;
-                    } else if (this._timeFirstDivergence === null) {
-                        this._timeFirstDivergence = time;
-                    }
-
-                }
-            }
-
-        }
-
-        if (!divergenceDetected) {
-            this._timeFirstDivergence = null;
-        }
-
-        this._wasHighRotationInProgress = highRotationInProgress;
-
-        const absoluteQuat = Quaternion.multiply(this._relAbsQuat, quaternion);
-        const attitude = new Attitude(absoluteQuat, time, accuracyWithRelative);
-
-        const eventsToNotify = [
-            this.createEvent(
-                EventType.AbsoluteAttitude,
-                attitude,
-                [event, this._lastForcedHeadingEvent]
-            )
-        ];
-        if (magnetometerNeedCalibrationEvent) {
-            eventsToNotify.push(magnetometerNeedCalibrationEvent);
-        }
-
-        this.notify(...eventsToNotify);
-    }
-
-
-    /**
-     * @param {ProviderEvent<Attitude>} event
-     */
-    _onAttitudeFromBrowser(event) {
-        this._eventFromBrowser = event;
-
-        if (!this._lastForcedHeadingEvent) {
-            this._forceHeadingForRelative(event);
-            return;
-        }
-
-        // Absolute attitude from browser is not used anymore due to magnetometer inaccuracy on pitch and roll
-    }
-
-    /**
-     * @override
-     * @param {AbsoluteHeading|Attitude|ProviderEvent} data
-     */
-    feed(data) {
-
-        if (data instanceof 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(new ProviderEvent(EventType.AbsoluteHeading, data));
-
-        } else if (data instanceof Attitude) {
-
-            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(new ProviderEvent(EventType.AbsoluteHeading, data));
-
-        } else if (data instanceof ProviderEvent) {
-
-            if (data.dataType !== EventType.AbsoluteHeading
-                || !(data.data instanceof AbsoluteHeading)) {
-                throw Error('the provider event is not an AbsoluteHeading');
-            }
-
-            this._forceHeadingForRelative(data);
-
-        } else {
-            throw new Error('data is nor an AbsoluteHeading or an Attitude object');
-        }
-    }
-}
-
-var AbsoluteAttitude$1 = new AbsoluteAttitude();
-
-class MagnetometerCalibrationDetector extends Provider {
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'MagnetometerCalibrationDetector';
-    }
-
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.MagnetometerNeedCalibration];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return AbsoluteAttitude$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = AbsoluteAttitude$1.addEventListener(
-            events => this._parseAbsoluteAttitudeEvents(events),
-            error => this.notifyError(error),
-            false
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        AbsoluteAttitude$1.removeEventListener(this.providerId);
-    }
-
-    /**
-     * @private
-     * @param {ProviderEvent[]} absoluteAttitudeEvents
-     */
-    _parseAbsoluteAttitudeEvents = absoluteAttitudeEvents => {
-
-        if (absoluteAttitudeEvents.length < 2) {
-            return;
-        }
-
-        const magnetometerNeedCalibrationEvent = absoluteAttitudeEvents[1];
-        if (magnetometerNeedCalibrationEvent.dataType !== EventType.MagnetometerNeedCalibration) {
-            return;
-        }
-
-        this.notify(magnetometerNeedCalibrationEvent);
-    }
-}
-
-var MagnetometerCalibrationDetector$1 = new MagnetometerCalibrationDetector();
-
-class IpResolveServerError extends Error {
-
-    static DEFAULT_MESSAGE = 'IP Resolver failed';
-
-    constructor(message) {
-        super(message || IpResolveServerError.DEFAULT_MESSAGE);
-    }
-}
-
-/**
- * GnssWifiProvider is a provider based on navigator.geolocation.
- * This API does not allow us to know if the position returned is provided
- *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
- *  "GnssWifi".
- */
-class Ip extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'IP';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsolutePosition];
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        fetch('https://ipinfo.io/geo?token=24a7ca2f3b489d')
-            .then((response) => {
-                if (!response) {
-                    this.notifyError(new IpResolveServerError());
-                    return;
-                }
-
-                const timestamp = TimeUtils.preciseTime() / 1e3;
-
-                const latLngStr = response.loc.split(',');
-                const position = new UserPosition(
-                    parseFloat(latLngStr[0]),
-                    parseFloat(latLngStr[1]),
-                    null,
-                    null,
-                    timestamp
-                );
-
-                this.notify(this.createEvent(EventType.AbsolutePosition, position));
-            });
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-
-    }
-
-}
-
-var Ip$1 = new Ip();
-
-class Barcode extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'Barcode';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Barcode];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return ArCore$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        ArCore$1.enableBarcodeScanner();
-
-        this.providerId = ArCore$1.addEventListener(
-            events => {
-                const barcodeEvent = events.find(event => event.dataType === EventType.Barcode);
-                if (barcodeEvent) {
-                    this.notify(barcodeEvent);
-                }
-            },
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        ArCore$1.disableBarcodeScanner();
-        ArCore$1.removeEventListener(this.providerId);
-    }
-}
-
-var Barcode$1 = new Barcode();
-
-class CameraNative extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'CameraNative';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.CameraNative];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return new Promise((resolve, reject) => {
-            ArCore$1.availability
-                .then(output => resolve(output))
-                .catch(() => reject('Providers will not use the camera.'));
-        });
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        if (ArCore$1.state !== ProviderState.STOPPPED) {
-            this.notify(this.createEvent(EventType.CameraNative, 'started'));
-        }
-        this.providerId = ArCore$1.addMonitoringListener(
-            () => this.notify(this.createEvent(EventType.CameraNative, 'started')),
-            () => this.notify(this.createEvent(EventType.CameraNative, 'stopped'))
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        ArCore$1.removeMonitoringListener(this.providerId);
-    }
-}
-
-var CameraNative$1 = new CameraNative();
-
-class CameraProjectionMatrix extends Provider {
-
-    /**
-     * @override
-     */
-    static get pname() {
-        return 'CameraProjectionMatrix';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.CameraProjectionMatrix];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return ArCore$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = ArCore$1.addEventListener(
-            events => {
-                const projMatrixEvent = events.find(event => event.dataType === EventType.CameraProjectionMatrix);
-                if (projMatrixEvent) {
-                    this.notify(projMatrixEvent);
-                }
-            },
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        ArCore$1.removeEventListener(this.providerId);
-    }
-}
-
-var CameraProjectionMatrix$1 = new CameraProjectionMatrix();
-
-/* eslint-disable max-len */
-
-var Providers = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Imu: Imu$1,
-    Accelerometer: Accelerometer$1,
-    Gyroscope: Gyroscope$1,
-    HighRotationsDetector: HighRotationsDetector$1,
-    MagnetometerCalibrationDetector: MagnetometerCalibrationDetector$1,
-    RelativeAttitudeFromBrowser: RelativeAttitudeFromBrowser$1,
-    RelativeAttitudeFromEkf: RelativeAttitudeFromEkf$1,
-    RelativeAttitudeFromInertial: RelativeAttitudeFromInertial$1,
-    RelativeAttitude: RelativeAttitude$1,
-    AbsoluteAttitudeFromBrowser: AbsoluteAttitudeFromBrowser$1,
-    AbsoluteAttitude: AbsoluteAttitude$1,
-    TurnDetector: TurnDectector,
-    InclinationFromAcc: InclinationFromAcc$1,
-    InclinationFromRelativeAttitude: InclinationFromRelativeAttitude$1,
-    Inclination: Inclination$1,
-    StepDetector: StepDetector$1,
-    StraightLineDetector: StraightLineDetector$1,
-    ArCore: ArCore$1,
-    Pdr: Pdr$1,
-    GeoRelativePositionFromArCore: GeoRelativePositionFromArCore$1,
-    GeoRelativePosition: GeoRelativePositionProvider,
-    GnssWifi: GnssWifi$1,
-    Ip: Ip$1,
-    AbsolutePosition: AbsolutePosition$1,
-    Barcode: Barcode$1,
-    CameraNative: CameraNative$1,
-    CameraProjectionMatrix: CameraProjectionMatrix$1
-});
-
-class ProvidersInterface {
-
-    static idListeners = new Map();
-
-    /**
-     * @param {EventType} eventType
-     * @param {Function} onEvent
-     * @param {Function} onError
-     * @param {Boolean} watchOnly if true, addEventListener does not start any provider, it just watches for events
-     * @returns {Number}
-     */
-    static addEventListener(eventType, onEvent, onError, watchOnly = false) {
-        const provider = this._getProviderFromEventType(eventType);
-        const id = provider.addEventListener(events => onEvent(events[0].data), onError, !watchOnly);
-        this.idListeners.set(id, provider);
-        return id;
-    }
-
-    /**
-     * @see addEventListener
-     * @param {Number} id
-     */
-    static removeEventListener(id) {
-        const provider = this.idListeners.get(id);
-        if (provider) {
-            return provider.removeEventListener(id);
-        }
-        return null;
-    }
-
-
-    /**
-     * @param {EventType} eventType
-     * @param {Object} data
-     */
-    static feed(eventType, data) {
-        this._checkEventTypeDataConsistency(eventType, data);
-        if (eventType === EventType.Network) {
-            MapMatchingHandler$1.network = data;
-            return;
-        }
-        if (eventType === EventType.Itinerary) {
-            MapMatchingHandler$1.itinerary = data;
-            return;
-        }
-        this._getProviderFromEventType(eventType).feed(data, eventType);
-    }
-
-    /**
-     * @param {EventType} eventType
-     */
-    static getLastKnown(eventType) {
-        const { lastEvent } = this._getProviderFromEventType(eventType);
-        return lastEvent ? lastEvent.data : null;
-    }
-
-    /**
-     * @param {EventType} eventType
-     * @returns {Provider}
-     */
-    static _getProviderFromEventType(eventType) {
-
-        switch (eventType) {
-        case EventType.AbsoluteAttitude:
-        case EventType.AbsoluteHeading:
-            return AbsoluteAttitude$1;
-
-        case EventType.AbsolutePosition:
-            return AbsolutePosition$1;
-
-        case EventType.RelativeAttitude:
-            return RelativeAttitude$1;
-
-        case EventType.Inclination:
-            return Inclination$1;
-
-        case EventType.CameraNative:
-            return CameraNative$1;
-
-        case EventType.Barcode:
-            return Barcode$1;
-
-        case EventType.CameraProjectionMatrix:
-            return CameraProjectionMatrix$1;
-
-        default:
-            throw new Error(`Unable to deal with this event type: ${eventType}`);
-        }
-    }
-
-    static _checkEventTypeDataConsistency(eventType, data) {
-        const errorFn = expectedType =>
-            new Error(`Event type (${eventType}) is not an instance of ${expectedType}`);
-
-        switch (eventType) {
-        case EventType.AbsoluteAttitude:
-            if (!(data instanceof Attitude)) {
-                throw errorFn('Attitude');
-            }
-            break;
-        case EventType.AbsoluteHeading:
-            if (!(data instanceof AbsoluteHeading)) {
-                throw errorFn('AbsoluteHeading');
-            }
-            break;
-        case EventType.AbsolutePosition:
-            if (!(data instanceof UserPosition)) {
-                throw errorFn('UserPosition');
-            }
-            break;
-        case EventType.Network:
-            if (!(data instanceof Network || data === null)) {
-                throw errorFn('Network');
-            }
-            break;
-        case EventType.Itinerary:
-            if (!(data instanceof Itinerary || data === null)) {
-                throw errorFn('Itinerary');
-            }
-            break;
-        default:
-            throw new Error(`Unable to deal with this event type: ${eventType}`);
-        }
-    }
-
-    /**
-     * @param {Boolean} enabled
-     */
-    static set logger(enabled) {
-        ProvidersLoggerOld$1.enabled = enabled;
-    }
-
-    static get mapMatchingMaxDistance() {
-        return MapMatchingHandler$1.maxDistance;
-    }
-
-    static set mapMatchingMaxDistance(maxDistance) {
-        MapMatchingHandler$1.maxDistance = maxDistance;
-    }
-
-    static get mapMatchingMinDistance() {
-        return MapMatchingHandler$1.minDistance;
-    }
-
-    static set mapMatchingMinDistance(minDistance) {
-        MapMatchingHandler$1.minDistance = minDistance;
-    }
-
-    static get mapMatchingMaxAngleBearing() {
-        return MapMatchingHandler$1.maxAngleBearing;
-    }
-
-    static set mapMatchingMaxAngleBearing(maxAngleBearing) {
-        MapMatchingHandler$1.maxAngleBearing = maxAngleBearing;
-    }
-}
-
-/* eslint-disable max-statements */
-
-class PositionSmoother {
-
-
-    // Generated positions by second
-    static DEFAULT_FREQUENCY = 60;
-
-    // flyby (in second)
-    static DEFAULT_FLYBY_TIME = 1;
-
-
-    /**
-     * @param {Function} callback
-     * @param {Number} frequency in Hz
-     */
-    constructor(callback, frequency = this.constructor.DEFAULT_FREQUENCY) {
-        this.callback = callback;
-        this.positionsQueue = [];
-        this.frequency = frequency;
-    }
-
-    /**
-     * @param {UserPosition} newPosition
-     * @param {Number} flybyTime in seconds
-     */
-    feed(newPosition, flybyTime = this.constructor.DEFAULT_FLYBY_TIME) {
-
-        if (!(newPosition instanceof 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;
-
-            let newPositionLevel = null;
-            if (newPosition.level !== null) {
-                newPositionLevel = newPosition.level.clone();
-            }
-
-            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();
-    }
-
-    _notifyNext = () => {
-        this.callback(this.positionsQueue.shift());
-        if (this.positionsQueue.length !== 0) {
-            this.timeoutNotify = setTimeout(this._notifyNext, 1e3 / this.frequency);
-        } else {
-            delete this.timeoutNotify;
-        }
-    }
-
-    clear() {
-        clearTimeout(this.timeoutNotify);
-        delete this.timeoutNotify;
-        this.positionsQueue = [];
-    }
-}
-
-/* eslint-disable max-statements */
-
-class AttitudeSmoother {
-
-    /** @type {number} in radians/s */
-    static ROTATION_SPEED_JUMP_THRESHOLD = deg2rad(180);
-
-    /** @type {number} in radians/s */
-    static ROTATION_SPEED_CONVERGENCE = deg2rad(10);
-
-    /** @type {number} in radians/s */
-    static HIGH_JUMP_THRESHOLD = deg2rad(20);
-
-    /** @type {number} in radians/s */
-    static ROTATION_SPEED_HIGH_JUMP_CONVERGENCE = deg2rad(100);
-
-    /** @type {number} in radians */
-    static PITCH_UNCERTAINITY_HEADING_THRESHOLD = deg2rad(5);
-
-    /** @type {Function} */
-    _callback;
-
-    /** @type {object?} */
-    _smoothing = null;
-
-    /**
-     * @param {Function} callback
-     */
-    constructor(callback) {
-        this._callback = callback;
-    }
-
-    /**
-     * @param {Attitude} attitude
-     */
-    feed(newAttitude) {
-
-        if (!(newAttitude instanceof Attitude)) {
-            throw new TypeError('newAttitude is not instance of Attitude');
-        }
-
-        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;
-        }
-
-        /*
-         * Comparison between two successive Attitude from the "feed" function
-         */
-        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 = 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,
-
-                /**
-                 * @param {Attitude} attitude
-                 */
-                interpAttitude: attitude => {
-                    const angle = rotationSpeedConvergence * (attitude.time - fromTime);
-                    const interpHeading = fromHeading + angle * multiplier;
-                    const offsetQuat = Quaternion.fromAxisAngle([0, 0, 1], toHeading - interpHeading);
-                    const interpQuat = Quaternion.multiply(offsetQuat, attitude.quaternion);
-                    return new Attitude(interpQuat, attitude.time, attitude.accuracy);
-                }
-            };
-        }
-
-        if (this._smoothing !== null) {
-            if (newAttitude.time >= this._smoothing.toTime) {
-                // This means that is the last epoch for smoothing
-                this._smoothing = null;
-            } else {
-                const interpAttitude = this._smoothing.interpAttitude(newAttitude);
-                this._callback(interpAttitude);
-                return;
-            }
-        }
-
-        this._callback(newAttitude);
-    }
-
-    /**
-     * @param {Attitude} previousAttitude
-     * @param {Attitude} newAttitude
-     * @returns {boolean}
-     */
-    static isJump(previousAttitude, newAttitude) {
-        const fromHeading = previousAttitude.heading;
-        const toHeading = newAttitude.heading;
-        const diffAngleHeading = diffAngle(toHeading, fromHeading);
-        const diffTime = newAttitude.time - previousAttitude.time;
-
-        /**
-         * Heading is calculated from two different formulas in function of the pitch angle.
-         * Do not consider a jump if attitude is close to the change of the methods
-         * @see MathsRotations#getHeadingFromQuaternion()
-         */
-        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;
-    }
-
-}
-
-export { AttitudeSmoother, EventType, PositionSmoother, ProviderEvent, ProviderState, Providers, ProvidersInterface, ProvidersLoggerOld$1 as ProvidersLoggerOld, ProvidersOptions };
-//# sourceMappingURL=wemap-providers.es.js.map