@wemap/providers 5.1.12 → 5.3.0

package/dist/wemap-providers.es.js

@@ -0,0 +1,4526 @@
+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, AbsoluteHeading, Constants as Constants$1, MapMatching, UserPosition, GraphEdge, 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',
+
+    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;
+    }
+}
+
+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
+};
+
+var ProviderState = {
+    STARTING: 0,
+    STARTED: 1,
+    STOPPPED: 2
+};
+
+/**
+ * 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();
+
+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();
+
+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();
+
+/**
+ * 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 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 MissingMagnetometerError extends MissingSensorError {
+    constructor(message) {
+        super(message);
+    }
+}
+
+/**
+ * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
+ */
+class AbsoluteAttitude extends Provider {
+
+    /** @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;
+
+
+    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);
+            }
+        );
+
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        AbsoluteAttitudeFromBrowser$1.removeEventListener(this.fromBrowserProviderId);
+        RelativeAttitude$1.removeEventListener(this.relativeAttitudeProviderId);
+    }
+
+    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
+        );
+
+        let newAccuracy = accuracyWithRelative;
+        let relAbsQuat = this._relAbsQuat;
+
+        if (this._eventFromBrowser) {
+
+            const {
+                accuracy: accuracyWithAbsolute,
+                heading: headingFromAbsolute
+            } = this._eventFromBrowser.data;
+
+            if (accuracyWithAbsolute < accuracyWithRelative) {
+                newAccuracy = accuracyWithAbsolute;
+                relAbsQuat = Quaternion.fromAxisAngle([0, 0, 1], event.data.heading - headingFromAbsolute);
+            }
+        }
+
+        const absoluteQuat = Quaternion.multiply(relAbsQuat, quaternion);
+        const attitude = new Attitude(absoluteQuat, time, newAccuracy);
+
+        this.notify(this.createEvent(
+            EventType.AbsoluteAttitude,
+            attitude,
+            [event, this._lastForcedHeadingEvent]
+        ));
+    }
+
+
+    /**
+     * @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 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();
+
+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,
+    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, Providers, ProvidersInterface, ProvidersLoggerOld$1 as ProvidersLoggerOld, ProvidersOptions };
+//# sourceMappingURL=wemap-providers.es.js.map