@wemap/providers 11.0.0-alpha.18 → 11.0.0-alpha.2

package/dist/index.js

@@ -1,26 +1,21 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const geo = require("@wemap/geo");
-const maths = require("@wemap/maths");
-const routers = require("@wemap/routers");
-const utils = require("@wemap/utils");
-const Logger = require("@wemap/logger");
-const geomagnetism = require("@wemap/geomagnetism");
-const camera = require("@wemap/camera");
-const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
-const geomagnetism__default = /* @__PURE__ */ _interopDefaultLegacy(geomagnetism);
-class RelativeAttitude extends geo.Attitude {
+import { Attitude, UserPosition, RelativePosition, GeoRelativePosition, Constants as Constants$1, Level, AbsoluteHeading, MapMatching, GraphEdge } from "@wemap/geo";
+import { deg2rad, Matrix4, Matrix3, Vector3, Quaternion, Matrix, Vector, Rotations, rad2deg, diffAngle, std, diffAngleLines } from "@wemap/maths";
+import { ItineraryInfoManager } from "@wemap/routers";
+import { TimeUtils, BrowserUtils, Browser, UserAgentUtils } from "@wemap/utils";
+import Logger from "@wemap/logger";
+import geomagnetism from "@wemap/geomagnetism";
+import { canvasToBase64, base64ToCanvas, convertToGrayscale, reduceImageSize, Camera, SharedCameras } from "@wemap/camera";
+class RelativeAttitude extends Attitude {
 }
-class AbsoluteAttitude extends geo.Attitude {
+class AbsoluteAttitude extends Attitude {
 }
-class AbsolutePosition extends geo.UserPosition {
+class AbsolutePosition extends UserPosition {
 }
 const ProvidersOptions = {
   useMapMatching: true,
@@ -54,7 +49,7 @@ class ProvidersLoggerOld {
     }
     this.interval = window.setInterval(() => {
       for (const [key, value] of Object.entries(this.pushEvents)) {
-        Logger__default.default.debug("Received " + value + " notifications from " + this.pushEventsRef[Number(key)].getName() + " last second");
+        Logger.debug("Received " + value + " notifications from " + this.pushEventsRef[Number(key)].getName() + " last second");
       }
       this.pushEvents = {};
       this.pushEventsRef = {};
@@ -76,7 +71,7 @@ class ProvidersLoggerOld {
     this.initializeInterval();
     const objectId = this.getObjectId(object);
     const objectClassName = object.getName();
-    Logger__default.default.debug(objectClassName + "[" + objectId + "]." + method);
+    Logger.debug(objectClassName + "[" + objectId + "]." + method);
   }
   incrementNotifications(object) {
     if (!this.enabled) {
@@ -307,7 +302,6 @@ const Constants = {
 const _GnssWifiProvider = class extends Provider {
   constructor() {
     super(...arguments);
-    __publicField(this, "discardPositionsAbove", _GnssWifiProvider.DEFAULT_DISCARD_POSITIONS_ABOVE);
     __publicField(this, "geoLocationId");
     __publicField(this, "getName", () => "GnssWifi");
     __publicField(this, "onNewPosition", (geolocation) => {
@@ -317,10 +311,10 @@ const _GnssWifiProvider = class extends Provider {
       }
       let bearing;
       if (coords.heading) {
-        bearing = maths.deg2rad(coords.heading);
+        bearing = deg2rad(coords.heading);
       }
-      const timestamp = utils.TimeUtils.unixTimestampToPreciseTime(geolocation.timestamp) / 1e3;
-      const position = new geo.UserPosition(
+      const timestamp = TimeUtils.unixTimestampToPreciseTime(geolocation.timestamp) / 1e3;
+      const position = new UserPosition(
         coords.latitude,
         coords.longitude,
         Constants.DEFAULT_ALTITUDE,
@@ -329,13 +323,10 @@ const _GnssWifiProvider = class extends Provider {
         coords.accuracy,
         bearing
       );
-      if (typeof this.discardPositionsAbove === "number" && coords.accuracy > this.discardPositionsAbove) {
-        return;
-      }
       this.notify(position);
     });
     __publicField(this, "onPositionError", (error) => {
-      Logger__default.default.warn(`[Providers] watchPosition error: [${error.code}] ${error.message}`);
+      Logger.warn(`[Providers] watchPosition error: [${error.code}] ${error.message}`);
       let customError;
       switch (error.code) {
         case 1:
@@ -374,7 +365,6 @@ __publicField(GnssWifiProvider, "POSITION_OPTIONS", {
   timeout: Infinity,
   maximumAge: 0
 });
-__publicField(GnssWifiProvider, "DEFAULT_DISCARD_POSITIONS_ABOVE", 50);
 const GnssWifiProvider$1 = new GnssWifiProvider();
 const _MissingArCoreError = class extends Error {
   constructor(message) {
@@ -431,7 +421,7 @@ const _ArCoreProvider = class extends Provider {
     const ref = payload[0];
     let bufferIndex = 1;
     let attitude, position, cameraProjection, barcode;
-    const time = utils.TimeUtils.preciseTime() / 1e3;
+    const time = TimeUtils.preciseTime() / 1e3;
     if (ref & _ArCoreProvider.Payload.Pose.ref) {
       attitude = new RelativeAttitude(
         payload.slice(bufferIndex, bufferIndex + 4),
@@ -443,7 +433,7 @@ const _ArCoreProvider = class extends Provider {
         payload[bufferIndex + 5],
         payload[bufferIndex + 6]
       ];
-      position = new geo.RelativePosition(
+      position = new RelativePosition(
         newPosition[0] - this.previousPosition[0],
         newPosition[1] - this.previousPosition[1],
         newPosition[2] - this.previousPosition[2],
@@ -517,7 +507,7 @@ __publicField(ArCoreProvider, "Payload", {
     size: 1
   }
 });
-__publicField(ArCoreProvider, "RELATIVE_ATTITUDE_DRIFT", maths.deg2rad(3) / 60);
+__publicField(ArCoreProvider, "RELATIVE_ATTITUDE_DRIFT", deg2rad(3) / 60);
 const ArCoreProvider$1 = new ArCoreProvider();
 class GeoRelativePositionFromArCoreProvider extends Provider {
   constructor() {
@@ -559,7 +549,7 @@ class GeoRelativePositionFromArCoreProvider extends Provider {
     const east = Math.cos(rotation) * relativePosition.x - Math.sin(rotation) * relativePosition.z;
     const north = -Math.sin(rotation) * relativePosition.x - Math.cos(rotation) * relativePosition.z;
     const up = relativePosition.y;
-    const position = new geo.GeoRelativePosition(
+    const position = new GeoRelativePosition(
       east,
       north,
       up,
@@ -589,7 +579,7 @@ class EkfAttitude {
     __publicField(this, "quaternion");
     this.accRef = accRef;
     this.cRef = ycRef;
-    this.P = maths.Matrix4.fromDiagVector(Array(4).fill(0.1 ** 2));
+    this.P = Matrix4.fromDiagVector(Array(4).fill(0.1 ** 2));
     this.quaternion = null;
     this.noises = {};
     this.setRelativeNoises(DEFAULT_RELATIVE_NOISES);
@@ -597,34 +587,34 @@ class EkfAttitude {
   }
   setRelativeNoises(relativeNoises) {
     this.noises.relative = {
-      acc: maths.Matrix3.diag(Array(3).fill(relativeNoises.acc ** 2)),
-      gyr: maths.Matrix3.diag(Array(3).fill(relativeNoises.gyr ** 2))
+      acc: Matrix3.diag(Array(3).fill(relativeNoises.acc ** 2)),
+      gyr: Matrix3.diag(Array(3).fill(relativeNoises.gyr ** 2))
     };
   }
   setAbsoluteNoises(absoluteNoises) {
     this.noises.absolute = {
-      acc: maths.Matrix3.diag(Array(3).fill(absoluteNoises.acc ** 2)),
-      gyr: maths.Matrix3.diag(Array(3).fill(absoluteNoises.gyr ** 2)),
-      yc: maths.Matrix3.diag(Array(3).fill(absoluteNoises.yc ** 2))
+      acc: Matrix3.diag(Array(3).fill(absoluteNoises.acc ** 2)),
+      gyr: Matrix3.diag(Array(3).fill(absoluteNoises.gyr ** 2)),
+      yc: Matrix3.diag(Array(3).fill(absoluteNoises.yc ** 2))
     };
   }
   tryInitialize(acc, mag) {
-    const accNormalized = maths.Vector3.normalize(acc);
+    const accNormalized = Vector3.normalize(acc);
     if (mag) {
-      const magNormalized = maths.Vector3.normalize(mag);
-      const H = maths.Vector3.normalize(maths.Vector3.cross(magNormalized, accNormalized));
-      const M = maths.Vector3.cross(accNormalized, H);
+      const 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 = maths.Quaternion.fromMatrix3Matlab(R);
+      this.quaternion = Quaternion.fromMatrix3Matlab(R);
     } else {
-      const r = maths.Vector3.dot(accNormalized, this.accRef) + 1;
-      const v = maths.Vector3.cross(accNormalized, this.accRef);
+      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 = maths.Quaternion.normalize(quaternion);
+      quaternion = Quaternion.normalize(quaternion);
       this.quaternion = quaternion;
     }
     return this.quaternion;
@@ -635,83 +625,83 @@ class EkfAttitude {
     }
     let q = this.quaternion;
     const qArray = q;
-    const gyrInt = maths.Vector3.multiplyScalar(gyr, 0.5 * diffTime);
+    const gyrInt = Vector3.multiplyScalar(gyr, 0.5 * diffTime);
     const F = this.computeC([1, gyrInt[0], gyrInt[1], gyrInt[2]]);
-    const qAPriori = maths.Matrix4.multiplyVector(F, q);
-    const E1 = maths.Matrix3.diag([qArray[0], qArray[0], qArray[0]]);
-    const eSkew = maths.Matrix3.skew([qArray[1], qArray[2], qArray[3]]);
+    const qAPriori = Matrix4.multiplyVector(F, q);
+    const E1 = Matrix3.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 = maths.Matrix.concatRow([qPart], maths.Matrix3.sum(eSkew, E1));
-    const Qk = maths.Matrix4.multiplyScalar(
-      maths.Matrix.multiply(
-        maths.Matrix.multiply(E, this.noises[mag ? "absolute" : "relative"].gyr),
-        maths.Matrix.transpose(E)
+    const E = Matrix.concatRow([qPart], Matrix3.sum(eSkew, E1));
+    const Qk = Matrix4.multiplyScalar(
+      Matrix.multiply(
+        Matrix.multiply(E, this.noises[mag ? "absolute" : "relative"].gyr),
+        Matrix.transpose(E)
       ),
       (diffTime / 2) ** 2
     );
-    const pAPriori = maths.Matrix4.sum(
-      maths.Matrix4.multiply(
-        maths.Matrix4.multiply(F, this.P),
-        maths.Matrix4.transpose(F)
+    const pAPriori = Matrix4.sum(
+      Matrix4.multiply(
+        Matrix4.multiply(F, this.P),
+        Matrix4.transpose(F)
       ),
       Qk
     );
-    const accNormalized = maths.Vector3.normalize(acc);
+    const accNormalized = Vector3.normalize(acc);
     let dz, K, H;
     if (mag) {
-      const magNormalized = maths.Vector3.normalize(mag);
-      const yc = maths.Vector3.cross(accNormalized, magNormalized);
-      const ycNormalized = maths.Vector3.normalize(yc);
-      const dzYc = maths.Vector3.subtract(ycNormalized, maths.Quaternion.rotateMatlab(qAPriori, this.cRef));
-      const dzAcc = maths.Vector3.subtract(accNormalized, maths.Quaternion.rotateMatlab(qAPriori, this.accRef));
-      dz = maths.Vector.concat(dzYc, dzAcc);
+      const magNormalized = Vector3.normalize(mag);
+      const yc = Vector3.cross(accNormalized, magNormalized);
+      const ycNormalized = Vector3.normalize(yc);
+      const dzYc = Vector3.subtract(ycNormalized, Quaternion.rotateMatlab(qAPriori, this.cRef));
+      const dzAcc = Vector3.subtract(accNormalized, Quaternion.rotateMatlab(qAPriori, this.accRef));
+      dz = Vector.concat(dzYc, dzAcc);
       const HYc = this.jacobianES(qAPriori, this.cRef);
       const HAcc = this.jacobianES(qAPriori, this.accRef);
-      H = maths.Matrix.concatRow(HYc, HAcc);
-      const RYc = maths.Matrix.concatLine(this.noises.absolute.yc, maths.Matrix3.zeros);
-      const RAcc = maths.Matrix.concatLine(maths.Matrix3.zeros, this.noises.absolute.acc);
-      const R = maths.Matrix.concatRow(RYc, RAcc);
-      K = maths.Matrix.multiply(
-        maths.Matrix.multiply(pAPriori, maths.Matrix.transpose(H)),
-        maths.Matrix.inverse(
-          maths.Matrix.sum(
-            maths.Matrix.multiply(
-              maths.Matrix.multiply(H, pAPriori),
-              maths.Matrix.transpose(H)
+      H = Matrix.concatRow(HYc, HAcc);
+      const RYc = Matrix.concatLine(this.noises.absolute.yc, Matrix3.zeros);
+      const RAcc = Matrix.concatLine(Matrix3.zeros, this.noises.absolute.acc);
+      const R = Matrix.concatRow(RYc, RAcc);
+      K = Matrix.multiply(
+        Matrix.multiply(pAPriori, Matrix.transpose(H)),
+        Matrix.inverse(
+          Matrix.sum(
+            Matrix.multiply(
+              Matrix.multiply(H, pAPriori),
+              Matrix.transpose(H)
             ),
             R
           )
         )
       );
     } else {
-      dz = maths.Vector3.subtract(accNormalized, maths.Quaternion.rotateMatlab(qAPriori, this.accRef));
+      dz = Vector3.subtract(accNormalized, Quaternion.rotateMatlab(qAPriori, this.accRef));
       H = this.jacobianES(qAPriori, this.accRef);
       const R = this.noises.relative.acc;
-      K = maths.Matrix.multiply(
-        maths.Matrix.multiply(pAPriori, maths.Matrix.transpose(H)),
-        maths.Matrix3.inverse(
-          maths.Matrix3.sum(
-            maths.Matrix.multiply(
-              maths.Matrix.multiply(H, pAPriori),
-              maths.Matrix.transpose(H)
+      K = Matrix.multiply(
+        Matrix.multiply(pAPriori, Matrix.transpose(H)),
+        Matrix3.inverse(
+          Matrix3.sum(
+            Matrix.multiply(
+              Matrix.multiply(H, pAPriori),
+              Matrix.transpose(H)
             ),
             R
           )
         )
       );
     }
-    q = maths.Quaternion.sum(
+    q = Quaternion.sum(
       qAPriori,
-      maths.Matrix.multiplyVector(K, dz)
+      Matrix.multiplyVector(K, dz)
     );
-    const P = maths.Matrix4.multiply(
-      maths.Matrix4.subtract(
-        maths.Matrix4.identity,
-        maths.Matrix.multiply(K, H)
+    const P = Matrix4.multiply(
+      Matrix4.subtract(
+        Matrix4.identity,
+        Matrix.multiply(K, H)
       ),
       pAPriori
     );
-    q = maths.Quaternion.normalize(q);
+    q = Quaternion.normalize(q);
     this.quaternion = q;
     this.P = P;
     return q;
@@ -749,7 +739,7 @@ class ImuProvider extends Provider {
         } = e.accelerationIncludingGravity;
         if (typeof x === "number" && typeof y === "number" && typeof z === "number") {
           acc = [x, y, z];
-          if (utils.BrowserUtils.name === utils.Browser.SAFARI || utils.BrowserUtils.name === utils.Browser.IOS_WEBVIEW) {
+          if (BrowserUtils.name === Browser.SAFARI || BrowserUtils.name === Browser.IOS_WEBVIEW) {
             acc[0] *= -1;
             acc[1] *= -1;
             acc[2] *= -1;
@@ -764,7 +754,7 @@ class ImuProvider extends Provider {
           gamma
         } = e.rotationRate;
         if (typeof alpha === "number" && typeof beta === "number" && typeof gamma === "number") {
-          gyr = [maths.deg2rad(alpha), maths.deg2rad(beta), maths.deg2rad(gamma)];
+          gyr = [deg2rad(alpha), deg2rad(beta), deg2rad(gamma)];
         }
       }
       if (acc || gyr) {
@@ -776,7 +766,7 @@ class ImuProvider extends Provider {
     });
   }
   availability() {
-    return utils.BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
+    return BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
   }
   start() {
     const subscribe = () => window.addEventListener("devicemotion", this.parseDeviceMotionEvent, true);
@@ -904,7 +894,7 @@ const _RelativeAttitudeFromEkf = class extends Provider {
   }
 };
 let RelativeAttitudeFromEkf = _RelativeAttitudeFromEkf;
-__publicField(RelativeAttitudeFromEkf, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
+__publicField(RelativeAttitudeFromEkf, "DEFAULT_DRIFT", deg2rad(5) / 60);
 const RelativeAttitudeFromEkfProvider = new RelativeAttitudeFromEkf();
 const _RelativeAttitudeFromBrowser = class extends Provider {
   constructor() {
@@ -915,7 +905,7 @@ const _RelativeAttitudeFromBrowser = class extends Provider {
         this.notifyError(new MissingSensorError().from("deviceorientation"));
         return;
       }
-      const quaternion = maths.Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
+      const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
       const attitude = new RelativeAttitude(
         quaternion,
         e.timeStamp / 1e3,
@@ -925,7 +915,7 @@ const _RelativeAttitudeFromBrowser = class extends Provider {
     });
   }
   availability() {
-    return utils.BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
+    return BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
   }
   start() {
     const subscribe = () => window.addEventListener("deviceorientation", this.onDeviceOrientationEvent, true);
@@ -946,7 +936,7 @@ const _RelativeAttitudeFromBrowser = class extends Provider {
   }
 };
 let RelativeAttitudeFromBrowser = _RelativeAttitudeFromBrowser;
-__publicField(RelativeAttitudeFromBrowser, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
+__publicField(RelativeAttitudeFromBrowser, "DEFAULT_DRIFT", deg2rad(5) / 60);
 const RelativeAttitudeFromBrowser$1 = new RelativeAttitudeFromBrowser();
 const _HighRotationsProvider = class extends Provider {
   constructor() {
@@ -956,7 +946,7 @@ const _HighRotationsProvider = class extends Provider {
     __publicField(this, "availability", () => GyroscopeProvider$1.getAvailability());
     __publicField(this, "_parseGyroscopeEvent", (gyroscopeEvent) => {
       const { values, timestamp } = gyroscopeEvent;
-      const speed = maths.Vector3.norm(values);
+      const speed = Vector3.norm(values);
       if (speed > _HighRotationsProvider.THRESHOLD) {
         this.notify({ timestamp });
       }
@@ -1028,7 +1018,7 @@ const _RelativeAttitudeFromInertial = class extends Provider {
   }
 };
 let RelativeAttitudeFromInertial = _RelativeAttitudeFromInertial;
-__publicField(RelativeAttitudeFromInertial, "DEFAULT_DRIFT", maths.deg2rad(5) / 60);
+__publicField(RelativeAttitudeFromInertial, "DEFAULT_DRIFT", deg2rad(5) / 60);
 const RelativeAttitudeFromInertialProvider = new RelativeAttitudeFromInertial();
 const _StepDetectionLadetto = class {
   constructor() {
@@ -1313,25 +1303,6 @@ const _StepProvider = class extends Provider {
     __publicField(this, "_algorithm", _StepProvider.DEFAULT_ALGORITHM);
     __publicField(this, "_accValues", []);
     __publicField(this, "getName", () => "StepDetector");
-    __publicField(this, "onAccelerometerEvent", (accelerationEvent) => {
-      if (!this.attitudeEvent || !this.angularRateEvent) {
-        return;
-      }
-      const {
-        values: acceleration,
-        timestamp
-      } = accelerationEvent;
-      const linearAcc = _StepProvider.computeLinearAcceleration(
-        this.attitudeEvent.quaternion,
-        acceleration
-      );
-      const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.values);
-      if (stepDetected) {
-        const size = this.stepDetector.lastStepSize * this._stepSizeMultiplier;
-        this.numOfSteps++;
-        this.notify({ size, number: this.numOfSteps });
-      }
-    });
     this.algorithm = this._algorithm;
   }
   availability() {
@@ -1361,9 +1332,28 @@ const _StepProvider = class extends Provider {
     GyroscopeProvider$1.removeEventListener(this.gyroscopeProviderId);
     RelativeAttitudeFromInertialProvider.removeEventListener(this.attitudeProviderId);
   }
+  onAccelerometerEvent(accelerationEvent) {
+    if (!this.attitudeEvent || !this.angularRateEvent) {
+      return;
+    }
+    const {
+      values: acceleration,
+      timestamp
+    } = accelerationEvent;
+    const linearAcc = _StepProvider.computeLinearAcceleration(
+      this.attitudeEvent.quaternion,
+      acceleration
+    );
+    const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.values);
+    if (stepDetected) {
+      const size = this.stepDetector.lastStepSize * this._stepSizeMultiplier;
+      this.numOfSteps++;
+      this.notify({ size, number: this.numOfSteps });
+    }
+  }
   static computeLinearAcceleration(quaternion, acc) {
-    const linearAcc = maths.Quaternion.rotateMatlab(maths.Quaternion.inverse(quaternion), acc);
-    linearAcc[2] -= geo.Constants.EARTH_GRAVITY;
+    const linearAcc = Quaternion.rotateMatlab(Quaternion.inverse(quaternion), acc);
+    linearAcc[2] -= Constants$1.EARTH_GRAVITY;
     return linearAcc;
   }
   set stepSizeMultiplier(stepSizeMultiplier) {
@@ -1405,7 +1395,7 @@ class PdrProvider extends Provider {
     __publicField(this, "absoluteAttitudeProviderId");
     __publicField(this, "stepDetectionProviderId");
     __publicField(this, "attitudeEvent");
-    __publicField(this, "misalignmentError", maths.deg2rad(3));
+    __publicField(this, "misalignmentError", deg2rad(3));
     __publicField(this, "getName", () => "Pdr");
     __publicField(this, "onStepEvent", (stepEvent) => {
       if (!this.attitudeEvent) {
@@ -1417,7 +1407,7 @@ class PdrProvider extends Provider {
       const deviceDirectionAccuracy = deviceAttitude.accuracy + this.misalignmentError;
       const accuracy = stepSize / 2 * Math.sin(deviceDirectionAccuracy / 2);
       const timestamp = deviceAttitude.time;
-      const position = new geo.GeoRelativePosition(
+      const position = new GeoRelativePosition(
         stepSize * Math.sin(deviceDirection),
         stepSize * Math.cos(deviceDirection),
         0,
@@ -1615,8 +1605,8 @@ class VpsMetadata {
       },
       json.calibration,
       {
-        ...((_a = json.coarse) == null ? void 0 : _a.position) && { position: geo.UserPosition.fromJson(json.coarse.position) },
-        ...((_b = json.coarse) == null ? void 0 : _b.attitude) && { attitude: geo.Attitude.fromJson(json.coarse.attitude) }
+        ...((_a = json.coarse) == null ? void 0 : _a.position) && { position: UserPosition.fromJson(json.coarse.position) },
+        ...((_b = json.coarse) == null ? void 0 : _b.attitude) && { attitude: Attitude.fromJson(json.coarse.attitude) }
       },
       json.device
     );
@@ -1628,7 +1618,7 @@ class VpsRequest {
     this.image = image;
   }
   toJson() {
-    const base64Image = camera.canvasToBase64(this.image);
+    const base64Image = canvasToBase64(this.image);
     return {
       image: base64Image,
       ...this.metadata.toJson()
@@ -1637,7 +1627,7 @@ class VpsRequest {
   static fromJson(json) {
     return new VpsRequest(
       VpsMetadata.fromJson(json),
-      camera.base64ToCanvas(json.image)
+      base64ToCanvas(json.image)
     );
   }
 }
@@ -1658,12 +1648,12 @@ class VpsResponse {
   static fromJson(json, imageRecordTime = null) {
     let attitude = null;
     if (json.attitude) {
-      attitude = geo.Attitude.fromJson(json.attitude);
+      attitude = Attitude.fromJson(json.attitude);
       attitude.time = imageRecordTime;
     }
     let position = null;
     if (json.position) {
-      position = geo.UserPosition.fromJson(json.position);
+      position = UserPosition.fromJson(json.position);
       position.time = imageRecordTime;
     }
     return new VpsResponse(json.success, attitude, position);
@@ -1671,23 +1661,23 @@ class VpsResponse {
 }
 class ImageRelocalization {
   static _prepareRequest(imageCanvas, calibration = null, coarsePose = null) {
-    camera.convertToGrayscale(imageCanvas);
-    const reducedImage = camera.reduceImageSize(imageCanvas, 1280);
+    convertToGrayscale(imageCanvas);
+    const reducedImage = reduceImageSize(imageCanvas, 1280);
     const metadata = new VpsMetadata(
       { width: reducedImage.width, height: reducedImage.height },
       calibration,
       coarsePose,
-      utils.UserAgentUtils.getDeviceFromUserAgent()
+      UserAgentUtils.getDeviceFromUserAgent()
     );
     return new VpsRequest(metadata, reducedImage);
   }
   static async relocalize(endpointUrl, imageCanvas, calibration = null, coarsePose = null, customHeaders = null) {
-    const timeBeforeRequest = utils.TimeUtils.preciseTime() / 1e3;
+    const timeBeforeRequest = TimeUtils.preciseTime() / 1e3;
     const vpsRequest = this._prepareRequest(imageCanvas, calibration, coarsePose);
     let serverResponse;
     try {
       const body = JSON.stringify(vpsRequest.toJson());
-      Logger__default.default.debug(`[VPS] Request (${(body.length / 1024).toFixed(0)} kB) sent to server ${endpointUrl}`);
+      Logger.debug(`[VPS] Request (${(body.length / 1024).toFixed(0)} kB) sent to server ${endpointUrl}`);
       serverResponse = await fetch(endpointUrl, {
         method: "POST",
         body,
@@ -1697,16 +1687,16 @@ class ImageRelocalization {
         )
       });
     } catch (e) {
-      Logger__default.default.debug("[VPS] Server respond error");
+      Logger.debug("[VPS] Server respond error");
       return null;
     }
     if (serverResponse.status !== 200) {
-      Logger__default.default.debug("[VPS] Server respond error");
+      Logger.debug("[VPS] Server respond error");
       return null;
     }
     const json = await serverResponse.json();
     const res = VpsResponse.fromJson(json, timeBeforeRequest);
-    Logger__default.default.debug(`[VPS] Server respond ${res.success ? "success" : "not found"}`);
+    Logger.debug(`[VPS] Server respond ${res.success ? "success" : "not found"}`);
     return res;
   }
   static getHeadingFromQuaternion(quaternion) {
@@ -1736,16 +1726,16 @@ class RelativeRotationCalc {
   }
   tickEnd() {
     if (!this._isRunning) {
-      Logger__default.default.warn("You have to call tickStart before tickEnd");
+      Logger.warn("You have to call tickStart before tickEnd");
       return null;
     }
     this._internalStop();
     if (!this._dataOnStart) {
-      Logger__default.default.warn("Delay was too short between tickStart and tickEnd or RelativeAttitudeProvider cannot be retrieved.");
+      Logger.warn("Delay was too short between tickStart and tickEnd or RelativeAttitudeProvider cannot be retrieved.");
       return null;
     }
     const dataOnEnd = RelativeAttitudeFromBrowser$1.lastEvent;
-    return geo.Attitude.diff(this._dataOnStart, dataOnEnd);
+    return Attitude.diff(this._dataOnStart, dataOnEnd);
   }
   _internalStop() {
     RelativeAttitudeFromBrowser$1.removeEventListener(this._providerId);
@@ -1806,7 +1796,7 @@ class PoleStarProvider extends Provider {
       callbackError: (errorMessage) => this.notifyError(new Error(errorMessage)),
       callbackPosition: (jsonString) => {
         const json = JSON.parse(jsonString);
-        const timestamp = utils.TimeUtils.unixTimestampToPreciseTime(json.time) / 1e3;
+        const timestamp = TimeUtils.unixTimestampToPreciseTime(json.time) / 1e3;
         const position = new AbsolutePosition(
           json.lat,
           json.lng,
@@ -1814,7 +1804,7 @@ class PoleStarProvider extends Provider {
           json.alt / 5,
           timestamp,
           json.accuracy,
-          maths.deg2rad(json.bearing)
+          deg2rad(json.bearing)
         );
         this.notify(position);
       }
@@ -1835,19 +1825,19 @@ const _VpsProvider = class extends Provider {
     __publicField(this, "_waitTimeMinInclinationForRequest", _VpsProvider.DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST);
     __publicField(this, "_useCoarsePose", _VpsProvider.DEFAULT_USE_COARSE_POSE);
     __publicField(this, "getName", () => "Vps");
-    __publicField(this, "availability", () => camera.Camera.checkAvailability());
-    __publicField(this, "_onCameraDetected", ({ camera: camera2 }) => {
+    __publicField(this, "availability", () => Camera.checkAvailability());
+    __publicField(this, "_onCameraDetected", ({ camera }) => {
       if (this._camera) {
-        Logger__default.default.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
+        Logger.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
       }
-      this._useCamera(camera2);
+      this._useCamera(camera);
     });
     __publicField(this, "_onCameraRemoved", () => {
       if (this._camera) {
         this._camera.off("started", this._internalStart);
         this._camera.off("stopped", this._internalStop);
       } else {
-        Logger__default.default.warn("There is no previously detected camera but once has stopped");
+        Logger.warn("There is no previously detected camera but once has stopped");
       }
       this._camera = null;
     });
@@ -1861,11 +1851,11 @@ const _VpsProvider = class extends Provider {
       const isProviderStopped = () => this.state === "stopped";
       while (!isProviderStopped()) {
         if (lastRequestTime !== null) {
-          const diffTime = utils.TimeUtils.preciseTime() - lastRequestTime;
+          const diffTime = TimeUtils.preciseTime() - lastRequestTime;
           const timeToWait = Math.max(0, _VpsProvider.MIN_TIME_BETWEEN_TWO_REQUESTS - diffTime);
           await new Promise((resolve) => setTimeout(resolve, timeToWait));
         }
-        lastRequestTime = utils.TimeUtils.preciseTime();
+        lastRequestTime = TimeUtils.preciseTime();
         if (isProviderStopped() || !this._camera || this._camera.state !== "started") {
           break;
         }
@@ -1892,16 +1882,16 @@ const _VpsProvider = class extends Provider {
           continue;
         }
         const enuToCameraRot = res.attitude.quaternion;
-        const enuToSmartphoneRot = maths.Quaternion.multiply(
+        const enuToSmartphoneRot = Quaternion.multiply(
           enuToCameraRot,
           _VpsProvider.CAMERA_TO_SMARTPHONE_ROT
         );
-        const deviceQuaternion = maths.Quaternion.multiply(
-          maths.Quaternion.fromAxisAngle([0, 0, 1], maths.deg2rad(window.orientation || 0)),
+        const deviceQuaternion = Quaternion.multiply(
+          Quaternion.fromAxisAngle([0, 0, 1], deg2rad(window.orientation || 0)),
           enuToSmartphoneRot
         );
-        const diffAttitude = ((_b = this._relativeRotationCalc) == null ? void 0 : _b.tickEnd()) || new geo.Attitude([1, 0, 0, 0]);
-        const deviceQuaternionWithRelOffset = maths.Quaternion.multiply(
+        const diffAttitude = ((_b = this._relativeRotationCalc) == null ? void 0 : _b.tickEnd()) || new Attitude([1, 0, 0, 0]);
+        const deviceQuaternionWithRelOffset = Quaternion.multiply(
           deviceQuaternion,
           diffAttitude.quaternion
         );
@@ -1929,28 +1919,28 @@ const _VpsProvider = class extends Provider {
   start() {
     this._inclinationProviderId = InclinationProvider$1.addEventListener();
     this._relativeRotationCalc = new RelativeRotationCalc();
-    camera.SharedCameras.on("added", this._onCameraDetected);
-    camera.SharedCameras.on("removed", this._onCameraRemoved);
-    if (camera.SharedCameras.list.length) {
-      if (camera.SharedCameras.list.length > 1) {
-        Logger__default.default.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
+    SharedCameras.on("added", this._onCameraDetected);
+    SharedCameras.on("removed", this._onCameraRemoved);
+    if (SharedCameras.list.length) {
+      if (SharedCameras.list.length > 1) {
+        Logger.warn("It seems that more than 1 camera has been detected for VPS. Taking the first...");
       }
-      this._useCamera(camera.SharedCameras.list[0].camera);
+      this._useCamera(SharedCameras.list[0].camera);
     }
   }
   stop() {
     var _a;
     InclinationProvider$1.removeEventListener(this._inclinationProviderId);
     (_a = this._relativeRotationCalc) == null ? void 0 : _a.release();
-    camera.SharedCameras.off("added", this._onCameraDetected);
-    camera.SharedCameras.off("removed", this._onCameraRemoved);
+    SharedCameras.off("added", this._onCameraDetected);
+    SharedCameras.off("removed", this._onCameraRemoved);
     this._camera = null;
   }
-  _useCamera(camera2) {
-    this._camera = camera2;
-    camera2.on("started", this._internalStart);
-    camera2.on("stopped", this._internalStop);
-    if (camera2.state === "started") {
+  _useCamera(camera) {
+    this._camera = camera;
+    camera.on("started", this._internalStart);
+    camera.on("stopped", this._internalStop);
+    if (camera.state === "started") {
       this._internalStart();
     }
   }
@@ -1981,10 +1971,10 @@ const _VpsProvider = class extends Provider {
 };
 let VpsProvider = _VpsProvider;
 __publicField(VpsProvider, "MIN_TIME_BETWEEN_TWO_REQUESTS", 1e3);
-__publicField(VpsProvider, "DEFAULT_MIN_INCLINATION_FOR_REQUEST", maths.deg2rad(60));
+__publicField(VpsProvider, "DEFAULT_MIN_INCLINATION_FOR_REQUEST", deg2rad(60));
 __publicField(VpsProvider, "DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST", 200);
 __publicField(VpsProvider, "DEFAULT_USE_COARSE_POSE", true);
-__publicField(VpsProvider, "CAMERA_TO_SMARTPHONE_ROT", maths.Quaternion.fromAxisAngle([1, 0, 0], Math.PI));
+__publicField(VpsProvider, "CAMERA_TO_SMARTPHONE_ROT", Quaternion.fromAxisAngle([1, 0, 0], Math.PI));
 const VpsProvider$1 = new VpsProvider();
 const _AbsolutePositionProvider = class extends Provider {
   constructor() {
@@ -2010,9 +2000,7 @@ const _AbsolutePositionProvider = class extends Provider {
   start() {
     GeoRelativePositionProvider$1.getAvailability().then((error) => {
       if (!error) {
-        this._relativePositionProviderId = GeoRelativePositionProvider$1.addEventListener(
-          (e) => this._onRelativePosition(e)
-        );
+        this._relativePositionProviderId = GeoRelativePositionProvider$1.addEventListener(this._onRelativePosition);
       }
     });
     this._gnssWifiProviderId = GnssWifiProvider$1.addEventListener(
@@ -2030,7 +2018,7 @@ const _AbsolutePositionProvider = class extends Provider {
     if (ProvidersOptions.hasPoleStar) {
       this._polestarProviderId = PoleStarProvider$1.addEventListener((polestarPositionEvent) => {
         var _a;
-        this._lastPolestarFix = utils.TimeUtils.preciseTime();
+        this._lastPolestarFix = TimeUtils.preciseTime();
         const psPositionUsed = this._onAbsolutePosition(polestarPositionEvent);
         if (!psPositionUsed && ((_a = this.lastEvent) == null ? void 0 : _a.level) === null) {
           const lastPositionWithLevel = this.lastEvent.clone();
@@ -2078,7 +2066,7 @@ const _AbsolutePositionProvider = class extends Provider {
     if (isBetterEnough && isFarEnoughAndAccuracyIsBetter) {
       return true;
     }
-    const isChangingLevel = canContainLevel && !geo.Level.equals(newPosition.level, lastPosition.level);
+    const isChangingLevel = canContainLevel && !Level.equals(newPosition.level, lastPosition.level);
     if (isChangingLevel) {
       return true;
     }
@@ -2125,7 +2113,7 @@ const _AbsolutePositionProvider = class extends Provider {
   }
   feed(data) {
     let newPositionEvent;
-    if (data instanceof geo.UserPosition) {
+    if (data instanceof AbsolutePosition) {
       if (data.time === null) {
         throw Error("the time of the position is not defined");
       }
@@ -2163,7 +2151,7 @@ const AbsolutePositionProvider$1 = new AbsolutePositionProvider();
 class AbsoluteAttitudeFromBrowser extends Provider {
   constructor() {
     super(...arguments);
-    __publicField(this, "DEFAULT_ACCURACY", maths.deg2rad(15));
+    __publicField(this, "DEFAULT_ACCURACY", deg2rad(15));
     __publicField(this, "absolutePositionProviderId");
     __publicField(this, "absolutePositionEvent");
     __publicField(this, "declinationQuaternion");
@@ -2178,7 +2166,7 @@ class AbsoluteAttitudeFromBrowser extends Provider {
         this.notifyError(new MissingSensorError().from("deviceorientationabsolute"));
         return;
       }
-      this.magQuaternion = maths.Rotations.eulerToQuaternionZXYDegrees(
+      this.magQuaternion = Rotations.eulerToQuaternionZXYDegrees(
         [e.alpha, e.beta, e.gamma]
       );
       this.compute();
@@ -2194,15 +2182,15 @@ class AbsoluteAttitudeFromBrowser extends Provider {
         return;
       }
       let alpha;
-      const [qw, qx, qy, qz] = maths.Rotations.eulerToQuaternionZXYDegrees([e.webkitCompassHeading, e.beta, e.gamma]);
-      const groundAngle = maths.rad2deg(Math.acos(qw ** 2 - qx ** 2 - qy ** 2 + qz ** 2));
+      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 = null;
       if (groundAngle > 136) {
         isSkyMode = true;
       } else if (groundAngle < 134) {
         isSkyMode = false;
       } else if (this.iosPreviousQuat && this.iosIsSkyMode !== null) {
-        isSkyMode = maths.Quaternion.distance([qw, qx, qy, qz], this.iosPreviousQuat) < 0.5 ? this.iosIsSkyMode : !this.iosIsSkyMode;
+        isSkyMode = Quaternion.distance([qw, qx, qy, qz], this.iosPreviousQuat) < 0.5 ? this.iosIsSkyMode : !this.iosIsSkyMode;
       }
       this.iosPreviousQuat = [qw, qx, qy, qz];
       this.iosIsSkyMode = isSkyMode;
@@ -2218,33 +2206,33 @@ class AbsoluteAttitudeFromBrowser extends Provider {
           e.gamma
         );
       }
-      this.magQuaternion = maths.Rotations.eulerToQuaternionZXYDegrees([alpha, e.beta, e.gamma]);
+      this.magQuaternion = Rotations.eulerToQuaternionZXYDegrees([alpha, e.beta, e.gamma]);
       this.compute();
     });
     __publicField(this, "onAbsolutePositionEvent", (position) => {
       this.absolutePositionEvent = position;
-      const wmmResult = geomagnetism__default.default.model().point([position.lat, position.lng]);
-      this.declinationQuaternion = maths.Quaternion.fromAxisAngle([0, 0, 1], -maths.deg2rad(wmmResult.decl));
+      const wmmResult = geomagnetism.model().point([position.lat, position.lng]);
+      this.declinationQuaternion = Quaternion.fromAxisAngle([0, 0, 1], -deg2rad(wmmResult.decl));
       AbsolutePositionProvider$1.removeEventListener(this.absolutePositionProviderId);
       delete this.absolutePositionProviderId;
       this.compute();
     });
   }
   availability() {
-    return utils.BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
+    return BrowserUtils.isMobile ? Promise.resolve() : Promise.resolve(new AskImuOnDesktopError());
   }
   start() {
     const subscribe = () => {
-      switch (utils.BrowserUtils.name) {
-        case utils.Browser.CHROME:
+      switch (BrowserUtils.name) {
+        case Browser.CHROME:
           window.addEventListener(
             "deviceorientationabsolute",
             this.onDeviceOrientationChromeEvent,
             true
           );
           break;
-        case utils.Browser.SAFARI:
-        case utils.Browser.IOS_WEBVIEW:
+        case Browser.SAFARI:
+        case Browser.IOS_WEBVIEW:
           window.addEventListener(
             "deviceorientation",
             this.onDeviceOrientationSafariEvent,
@@ -2276,16 +2264,16 @@ class AbsoluteAttitudeFromBrowser extends Provider {
     }
   }
   stop() {
-    switch (utils.BrowserUtils.name) {
-      case utils.Browser.CHROME:
+    switch (BrowserUtils.name) {
+      case Browser.CHROME:
         window.removeEventListener(
           "deviceorientationabsolute",
           this.onDeviceOrientationChromeEvent,
           true
         );
         break;
-      case utils.Browser.SAFARI:
-      case utils.Browser.IOS_WEBVIEW:
+      case Browser.SAFARI:
+      case Browser.IOS_WEBVIEW:
         window.removeEventListener(
           "deviceorientation",
           this.onDeviceOrientationSafariEvent,
@@ -2299,14 +2287,14 @@ class AbsoluteAttitudeFromBrowser extends Provider {
     if (!this.declinationQuaternion || !this.magQuaternion || !this.absolutePositionEvent) {
       return;
     }
-    const trueQuaternion = maths.Quaternion.multiply(this.declinationQuaternion, this.magQuaternion);
+    const trueQuaternion = Quaternion.multiply(this.declinationQuaternion, this.magQuaternion);
     const attitude = new AbsoluteAttitude(trueQuaternion, this.magQuaternionTimestamp, this.DEFAULT_ACCURACY);
     this.notify(attitude);
   }
   static webkitCompassToHeading(_webkitCompassHeading, _beta, _gamma) {
-    const webkitCompassHeading = maths.deg2rad(_webkitCompassHeading);
-    const beta = maths.deg2rad(_beta);
-    const gamma = maths.deg2rad(_gamma);
+    const 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);
@@ -2315,7 +2303,7 @@ class AbsoluteAttitudeFromBrowser extends Provider {
     const s3 = Math.sin(gamma / 2);
     const qw = c1 * c2 * c3 - s1 * s2 * s3;
     const qz = s1 * c2 * c3 + c1 * s2 * s3;
-    return maths.rad2deg(-2 * Math.atan(qz / qw));
+    return rad2deg(-2 * Math.atan(qz / qw));
   }
 }
 const AbsoluteAttitudeFromBrowser$1 = new AbsoluteAttitudeFromBrowser();
@@ -2401,7 +2389,7 @@ const _AbsoluteAttitudeProvider = class extends Provider {
       }
       const calcForceHeading = (relativeAttitude) => {
         const currentRelativeHeading = relativeAttitude.heading;
-        this._relAbsQuat = maths.Quaternion.fromAxisAngle(
+        this._relAbsQuat = Quaternion.fromAxisAngle(
           [0, 0, 1],
           currentRelativeHeading - absoluteHeadingEvent.heading
         );
@@ -2443,9 +2431,9 @@ const _AbsoluteAttitudeProvider = class extends Provider {
         if (this._wasHighRotationInProgress && !highRotationInProgress) {
           this._forceHeadingForRelative(this._absAttitudeFromBrowser);
         } else if (accuracyWithAbsolute < accuracyWithRelative) {
-          const relativeQuaternion = maths.Quaternion.multiply(this._relAbsQuat, quaternion);
-          const relativeAttitude = new geo.Attitude(relativeQuaternion);
-          const angle = Math.abs(maths.diffAngle(relativeAttitude.heading, headingFromAbsolute));
+          const relativeQuaternion = Quaternion.multiply(this._relAbsQuat, quaternion);
+          const relativeAttitude = new Attitude(relativeQuaternion);
+          const angle = Math.abs(diffAngle(relativeAttitude.heading, headingFromAbsolute));
           const inclination = InclinationProvider$1.lastEvent;
           if (angle > _AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_ANGLE_THRESHOLD && inclination !== null && Math.abs(inclination - Math.PI / 4) > _AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD) {
             divergenceDetected = true;
@@ -2463,7 +2451,7 @@ const _AbsoluteAttitudeProvider = class extends Provider {
         this._timeFirstDivergence = null;
       }
       this._wasHighRotationInProgress = highRotationInProgress;
-      const absoluteQuat = maths.Quaternion.multiply(this._relAbsQuat, quaternion);
+      const absoluteQuat = Quaternion.multiply(this._relAbsQuat, quaternion);
       const attitude = new AbsoluteAttitude(absoluteQuat, time, accuracyWithRelative);
       this.notify(attitude);
     });
@@ -2518,7 +2506,7 @@ const _AbsoluteAttitudeProvider = class extends Provider {
     this._callbackMagCalibration = cb;
   }
   feed(data) {
-    if (data instanceof geo.AbsoluteHeading) {
+    if (data instanceof AbsoluteHeading) {
       if (data.time === null) {
         throw Error("the time of the absolute heading is not defined");
       }
@@ -2540,9 +2528,9 @@ const _AbsoluteAttitudeProvider = class extends Provider {
   }
 };
 let AbsoluteAttitudeProvider = _AbsoluteAttitudeProvider;
-__publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_ANGLE_THRESHOLD", maths.deg2rad(25));
+__publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_ANGLE_THRESHOLD", deg2rad(25));
 __publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_TIME_THRESHOLD", 2.5);
-__publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD", maths.deg2rad(15));
+__publicField(AbsoluteAttitudeProvider, "REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD", deg2rad(15));
 const AbsoluteAttitudeProvider$1 = new AbsoluteAttitudeProvider();
 const _TurnProvider = class extends Provider {
   constructor() {
@@ -2556,7 +2544,7 @@ const _TurnProvider = class extends Provider {
       const timestamp = relativeAttitudeEvent.time;
       this.slidingWindow = this.slidingWindow.filter((item) => item[0] >= timestamp - _TurnProvider.SLIDING_WINDOW_TIME);
       this.slidingWindow.push([timestamp, heading]);
-      const stdVal = maths.std(this.slidingWindow.map((item) => item[1]));
+      const stdVal = std(this.slidingWindow.map((item) => item[1]));
       if (stdVal > _TurnProvider.STD_THRESHOLD) {
         this.notify({ timestamp });
       }
@@ -2665,7 +2653,7 @@ const _MapMatchingHandler = class extends Provider {
         this._stopInternalProviders();
       }
     });
-    this._mapMatching = new geo.MapMatching();
+    this._mapMatching = new MapMatching();
     this._mapMatching.maxDistance = _MapMatchingHandler.DEFAULT_MM_MAX_DIST;
     this._mapMatching.maxAngleBearing = _MapMatchingHandler.DEFAULT_MM_MAX_ANGLE;
   }
@@ -2711,7 +2699,7 @@ const _MapMatchingHandler = class extends Provider {
   }
   set itinerary(itinerary) {
     this._mapMatching.network = itinerary ? itinerary.toNetwork() : null;
-    this._itineraryInfoManager = new routers.ItineraryInfoManager(itinerary);
+    this._itineraryInfoManager = new ItineraryInfoManager(itinerary);
     this.notify({ ...itinerary && { itinerary } });
     this._manageStartStop();
     if (this.canUseMapMatching() && itinerary) {
@@ -2726,7 +2714,7 @@ const _MapMatchingHandler = class extends Provider {
       return;
     }
     const lastPosition = AbsolutePositionProvider$1.lastEvent || null;
-    const newPosition = geo.UserPosition.fromCoordinates(itinerary.from);
+    const newPosition = UserPosition.fromCoordinates(itinerary.from);
     if (lastPosition) {
       newPosition.alt = lastPosition.alt;
       newPosition.time = lastPosition.time;
@@ -2734,7 +2722,7 @@ const _MapMatchingHandler = class extends Provider {
       newPosition.bearing = lastPosition.bearing;
     } else if (itinerary.coords.length >= 2) {
       newPosition.alt = Constants.DEFAULT_ALTITUDE;
-      newPosition.time = utils.TimeUtils.preciseTime();
+      newPosition.time = TimeUtils.preciseTime();
       newPosition.accuracy = 0;
       newPosition.bearing = itinerary.coords[0].bearingTo(itinerary.coords[1]);
     } else {
@@ -2856,14 +2844,14 @@ const _MapMatchingHandler = class extends Provider {
     }
     const firstProjection = this._lastProjections[0];
     return !this._lastProjections.some(
-      (projection) => !(projection.nearestElement instanceof geo.GraphEdge) || !(firstProjection.nearestElement instanceof geo.GraphEdge) || maths.diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing) > this._lastProjectionsEdgeAngleThreshold
+      (projection) => !(projection.nearestElement instanceof GraphEdge) || !(firstProjection.nearestElement instanceof GraphEdge) || diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing) > this._lastProjectionsEdgeAngleThreshold
     );
   }
   _nodeHasTurn(node) {
     const { edges } = node;
     for (let i = 0; i < edges.length; i++) {
       for (let j = i + 1; j < edges.length; j++) {
-        const angle = maths.diffAngleLines(edges[i].bearing, edges[j].bearing);
+        const angle = diffAngleLines(edges[i].bearing, edges[j].bearing);
         if (angle > _MapMatchingHandler.DEFAULT_MM_MAX_ANGLE) {
           return true;
         }
@@ -2877,7 +2865,7 @@ const _MapMatchingHandler = class extends Provider {
       return false;
     }
     return network.nodes.filter(
-      (node) => node.coords.distanceTo(center) <= radius && geo.Level.intersect(node.coords.level, center.level)
+      (node) => node.coords.distanceTo(center) <= radius && Level.intersect(node.coords.level, center.level)
     ).some(this._nodeHasTurn);
   }
   tryOrientationMatching(projection) {
@@ -2888,18 +2876,18 @@ const _MapMatchingHandler = class extends Provider {
       return;
     }
     const { nearestElement, origin } = projection;
-    if (!(nearestElement instanceof geo.GraphEdge)) {
+    if (!(nearestElement instanceof GraphEdge)) {
       return;
     }
     let matchingDirection;
-    const matchingDirectionAngle1 = maths.diffAngle(nearestElement.bearing, origin.bearing);
-    const matchingDirectionAngle2 = maths.diffAngle(nearestElement.bearing + Math.PI, origin.bearing);
+    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 geo.AbsoluteHeading(
+    const matchedHeading = new AbsoluteHeading(
       matchingDirection,
       origin.time,
       0
@@ -2978,7 +2966,7 @@ const _MapMatchingHandler = class extends Provider {
   }
 };
 let MapMatchingHandler = _MapMatchingHandler;
-__publicField(MapMatchingHandler, "DEFAULT_MM_MAX_ANGLE", maths.deg2rad(30));
+__publicField(MapMatchingHandler, "DEFAULT_MM_MAX_ANGLE", deg2rad(30));
 __publicField(MapMatchingHandler, "DEFAULT_MM_MAX_DIST", 30);
 __publicField(MapMatchingHandler, "DEFAULT_MM_MIN_DIST", 0);
 __publicField(MapMatchingHandler, "DEFAULT_USE_ITINERARY_START_AS_POSITION", false);
@@ -2988,7 +2976,7 @@ __publicField(MapMatchingHandler, "DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE",
 __publicField(MapMatchingHandler, "DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING", 3);
 __publicField(MapMatchingHandler, "DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING", 5);
 __publicField(MapMatchingHandler, "DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE", 3);
-__publicField(MapMatchingHandler, "DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD", maths.deg2rad(3));
+__publicField(MapMatchingHandler, "DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD", deg2rad(3));
 const MapMatchingHandler$1 = new MapMatchingHandler();
 const _PositionSmoother = class {
   constructor(callback, frequency = _PositionSmoother.DEFAULT_FREQUENCY) {
@@ -3010,7 +2998,7 @@ const _PositionSmoother = class {
     this.frequency = frequency;
   }
   feed(newPosition, flybyTime = _PositionSmoother.DEFAULT_FLYBY_TIME) {
-    if (!(newPosition instanceof geo.UserPosition)) {
+    if (!(newPosition instanceof UserPosition)) {
       throw new TypeError("newPosition is not instance of UserPosition");
     }
     if (newPosition.time === null) {
@@ -3029,7 +3017,7 @@ const _PositionSmoother = class {
       const azimuth = previousPosition.bearingTo(newPosition);
       let i = 1;
       const nSamples = this.frequency * flybyTime + 1;
-      const newPositionLevel = geo.Level.clone(newPosition.level);
+      const newPositionLevel = Level.clone(newPosition.level);
       while (i < nSamples + 1) {
         const smoothedPosition = previousPosition.destinationPoint(distance * i / nSamples, azimuth);
         smoothedPosition.time = refTimestamp + (i - 1) / this.frequency;
@@ -3080,7 +3068,7 @@ const _AttitudeSmoother = class {
       const fromAttitude = this._smoothing === null ? previousAttitude : this._smoothing.interpAttitude(previousAttitude);
       const fromHeading = fromAttitude.heading;
       const toHeading = newAttitude.heading;
-      const diffAngleHeading = maths.diffAngle(toHeading, fromHeading);
+      const 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;
@@ -3091,9 +3079,9 @@ const _AttitudeSmoother = class {
         interpAttitude: (attitude) => {
           const angle = rotationSpeedConvergence * (attitude.time - fromTime);
           const interpHeading = fromHeading + angle * multiplier;
-          const offsetQuat = maths.Quaternion.fromAxisAngle([0, 0, 1], toHeading - interpHeading);
-          const interpQuat = maths.Quaternion.multiply(offsetQuat, attitude.quaternion);
-          return new geo.Attitude(interpQuat, attitude.time, attitude.accuracy);
+          const offsetQuat = Quaternion.fromAxisAngle([0, 0, 1], toHeading - interpHeading);
+          const interpQuat = Quaternion.multiply(offsetQuat, attitude.quaternion);
+          return new Attitude(interpQuat, attitude.time, attitude.accuracy);
         }
       };
     }
@@ -3111,7 +3099,7 @@ const _AttitudeSmoother = class {
   static isJump(previousAttitude, newAttitude) {
     const fromHeading = previousAttitude.heading;
     const toHeading = newAttitude.heading;
-    const diffAngleHeading = maths.diffAngle(toHeading, fromHeading);
+    const diffAngleHeading = diffAngle(toHeading, fromHeading);
     const diffTime = newAttitude.time - previousAttitude.time;
     const [qw, qx, qy, qz] = newAttitude.quaternion;
     const distToPitchThreshold = Math.abs(Math.asin(2 * (qw * qx + qy * qz)) - Math.PI / 4);
@@ -3122,11 +3110,11 @@ const _AttitudeSmoother = class {
   }
 };
 let AttitudeSmoother = _AttitudeSmoother;
-__publicField(AttitudeSmoother, "ROTATION_SPEED_JUMP_THRESHOLD", maths.deg2rad(180));
-__publicField(AttitudeSmoother, "ROTATION_SPEED_CONVERGENCE", maths.deg2rad(10));
-__publicField(AttitudeSmoother, "HIGH_JUMP_THRESHOLD", maths.deg2rad(20));
-__publicField(AttitudeSmoother, "ROTATION_SPEED_HIGH_JUMP_CONVERGENCE", maths.deg2rad(100));
-__publicField(AttitudeSmoother, "PITCH_UNCERTAINITY_HEADING_THRESHOLD", maths.deg2rad(5));
+__publicField(AttitudeSmoother, "ROTATION_SPEED_JUMP_THRESHOLD", deg2rad(180));
+__publicField(AttitudeSmoother, "ROTATION_SPEED_CONVERGENCE", deg2rad(10));
+__publicField(AttitudeSmoother, "HIGH_JUMP_THRESHOLD", deg2rad(20));
+__publicField(AttitudeSmoother, "ROTATION_SPEED_HIGH_JUMP_CONVERGENCE", deg2rad(100));
+__publicField(AttitudeSmoother, "PITCH_UNCERTAINITY_HEADING_THRESHOLD", deg2rad(5));
 class MagnetometerCalibrationProvider extends Provider {
   constructor() {
     super();
@@ -3159,9 +3147,9 @@ class IpProvider extends Provider {
       this.notifyError(new IpResolveServerError());
       return;
     }
-    const timestamp = utils.TimeUtils.preciseTime() / 1e3;
+    const timestamp = TimeUtils.preciseTime() / 1e3;
     const latLngStr = (await response.json()).loc.split(",");
-    const position = new geo.UserPosition(
+    const position = new UserPosition(
       parseFloat(latLngStr[0]),
       parseFloat(latLngStr[1]),
       null,
@@ -3234,47 +3222,49 @@ class CameraProjectionMatrixProvider extends Provider {
   }
 }
 const CameraProjectionMatrixProvider$1 = new CameraProjectionMatrixProvider();
-exports.AbsoluteAttitude = AbsoluteAttitude;
-exports.AbsoluteAttitudeFromBrowserProvider = AbsoluteAttitudeFromBrowser$1;
-exports.AbsoluteAttitudeProvider = AbsoluteAttitudeProvider$1;
-exports.AbsolutePosition = AbsolutePosition;
-exports.AbsolutePositionProvider = AbsolutePositionProvider$1;
-exports.AccelerometerProvider = AccelerometerProvider$1;
-exports.ArCoreProvider = ArCoreProvider$1;
-exports.AttitudeSmoother = AttitudeSmoother;
-exports.BarcodeProvider = BarcodeProvider;
-exports.CameraNativeProvider = CameraNativeProvider$1;
-exports.CameraProjectionMatrixProvider = CameraProjectionMatrixProvider$1;
-exports.GeoRelativePositionFromArCoreProvider = GeoRelativePositionFromArCoreProvider$1;
-exports.GeoRelativePositionProvider = GeoRelativePositionProvider$1;
-exports.GnssWifiProvider = GnssWifiProvider$1;
-exports.GyroscopeProvider = GyroscopeProvider$1;
-exports.HighRotationsProvider = HighRotationsProvider$1;
-exports.ImageRelocalization = ImageRelocalization;
-exports.ImuProvider = ImuProvider$1;
-exports.InclinationFromAccProvider = InclinationFromAccProvider$1;
-exports.InclinationFromRelativeAttitudeProvider = InclinationFromRelativeAttitudeProvider$1;
-exports.InclinationProvider = InclinationProvider$1;
-exports.IpProvider = IpProvider$1;
-exports.MagnetometerCalibrationProvider = MagnetometerCalibrationProvider$1;
-exports.MapMatchingHandler = MapMatchingHandler$1;
-exports.PdrProvider = PdrProvider$1;
-exports.PoleStarProvider = PoleStarProvider$1;
-exports.PositionSmoother = PositionSmoother;
-exports.ProvidersLoggerOld = ProvidersLoggerOld$1;
-exports.ProvidersOptions = ProvidersOptions;
-exports.RelativeAttitude = RelativeAttitude;
-exports.RelativeAttitudeFromBrowserProvider = RelativeAttitudeFromBrowser$1;
-exports.RelativeAttitudeFromEkfProvider = RelativeAttitudeFromEkfProvider;
-exports.RelativeAttitudeFromInertialProvider = RelativeAttitudeFromInertialProvider;
-exports.RelativeAttitudeProvider = RelativeAttitudeProvider$1;
-exports.StepDetectionMinMaxPeaks2 = StepDetectionMinMaxPeaks2;
-exports.StepDetectionMinMaxPeaks3 = StepDetectionMinMaxPeaks3;
-exports.StepProvider = StepProvider$1;
-exports.StraightLineProvider = StraightLineProvider$1;
-exports.TurnProvider = TurnProvider$1;
-exports.VpsMetadata = VpsMetadata;
-exports.VpsProvider = VpsProvider$1;
-exports.VpsRequest = VpsRequest;
-exports.VpsResponse = VpsResponse;
+export {
+  AbsoluteAttitude,
+  AbsoluteAttitudeFromBrowser$1 as AbsoluteAttitudeFromBrowserProvider,
+  AbsoluteAttitudeProvider$1 as AbsoluteAttitudeProvider,
+  AbsolutePosition,
+  AbsolutePositionProvider$1 as AbsolutePositionProvider,
+  AccelerometerProvider$1 as AccelerometerProvider,
+  ArCoreProvider$1 as ArCoreProvider,
+  AttitudeSmoother,
+  BarcodeProvider,
+  CameraNativeProvider$1 as CameraNativeProvider,
+  CameraProjectionMatrixProvider$1 as CameraProjectionMatrixProvider,
+  GeoRelativePositionFromArCoreProvider$1 as GeoRelativePositionFromArCoreProvider,
+  GeoRelativePositionProvider$1 as GeoRelativePositionProvider,
+  GnssWifiProvider$1 as GnssWifiProvider,
+  GyroscopeProvider$1 as GyroscopeProvider,
+  HighRotationsProvider$1 as HighRotationsProvider,
+  ImageRelocalization,
+  ImuProvider$1 as ImuProvider,
+  InclinationFromAccProvider$1 as InclinationFromAccProvider,
+  InclinationFromRelativeAttitudeProvider$1 as InclinationFromRelativeAttitudeProvider,
+  InclinationProvider$1 as InclinationProvider,
+  IpProvider$1 as IpProvider,
+  MagnetometerCalibrationProvider$1 as MagnetometerCalibrationProvider,
+  MapMatchingHandler$1 as MapMatchingHandler,
+  PdrProvider$1 as PdrProvider,
+  PoleStarProvider$1 as PoleStarProvider,
+  PositionSmoother,
+  ProvidersLoggerOld$1 as ProvidersLoggerOld,
+  ProvidersOptions,
+  RelativeAttitude,
+  RelativeAttitudeFromBrowser$1 as RelativeAttitudeFromBrowserProvider,
+  RelativeAttitudeFromEkfProvider,
+  RelativeAttitudeFromInertialProvider,
+  RelativeAttitudeProvider$1 as RelativeAttitudeProvider,
+  StepDetectionMinMaxPeaks2,
+  StepDetectionMinMaxPeaks3,
+  StepProvider$1 as StepProvider,
+  StraightLineProvider$1 as StraightLineProvider,
+  TurnProvider$1 as TurnProvider,
+  VpsMetadata,
+  VpsProvider$1 as VpsProvider,
+  VpsRequest,
+  VpsResponse
+};
 //# sourceMappingURL=index.js.map