@wemap/providers 14.6.0-beta.2 → 14.6.0-beta.4

package/dist/index.js

@@ -1,4 +1,5 @@
 import { AbsoluteHeading, Attitude, Constants, GeoRelativePosition, Level, RelativePosition, UserPosition } from "@wemap/geo";
+import { Matrix, Matrix3, Matrix4, Quaternion, Rotations, Vector, Vector3, deg2rad, diffAngle, diffAngleLines, rad2deg, std } from "@wemap/maths";
 import { Edge, ItineraryInfoManager } from "@wemap/routers";
 import { Browser, BrowserUtils, TimeUtils, UserAgentUtils } from "@wemap/utils";
 import { Camera, SharedCameras, base64ToCanvas, canvasToBase64, reduceImageSize } from "@wemap/camera";
@@ -11,1154 +12,6 @@ var RelativeAttitude = class extends Attitude {}, AbsoluteAttitude = class exten
 	get hasPoleStar() {
 		return this.optionalProviders.includes("PoleStar");
 	}
-}, __defProp$1 = Object.defineProperty, __defNormalProp$1 = (e, C, w) => C in e ? __defProp$1(e, C, {
-	enumerable: !0,
-	configurable: !0,
-	writable: !0,
-	value: w
-}) : e[C] = w, __publicField$1 = (e, C, w) => (__defNormalProp$1(e, typeof C == "symbol" ? C : C + "", w), w), Matrix = class {
-	static sum(e, C) {
-		let w = e.length, T = e[0].length, E = Array(w);
-		for (let D = 0; D < w; ++D) {
-			E[D] = Array(T);
-			for (let w = 0; w < T; ++w) E[D][w] = e[D][w] + C[D][w];
-		}
-		return E;
-	}
-	static concatRow(e, C) {
-		let w = e.length, T = C.length, E = Array(w + T);
-		for (let C = 0; C < w; ++C) E[C] = e[C].slice();
-		for (let e = 0; e < T; ++e) E[w + e] = C[e].slice();
-		return E;
-	}
-	static concatLine(e, C) {
-		let w = e.length, T = Array(w);
-		for (let E = 0; E < w; ++E) T[E] = e[E].concat(C[E]);
-		return T;
-	}
-	static diag(e) {
-		let C = Array(e.length);
-		for (let w = 0; w < e.length; w++) {
-			C[w] = Array(e.length);
-			for (let T = 0; T < e.length; T++) C[w][T] = w === T ? e[w] : 0;
-		}
-		return C;
-	}
-	static transpose(e) {
-		let C = e.length, w = e[0].length, T = Array(w);
-		for (let E = 0; E < w; E++) {
-			T[E] = Array(C);
-			for (let w = 0; w < C; w++) T[E][w] = e[w][E];
-		}
-		return T;
-	}
-	static multiply(e, C) {
-		let w = e.length, T = e[0].length, E = C[0].length, D = Array(w);
-		for (let O = 0; O < w; ++O) {
-			D[O] = Array(E);
-			for (let w = 0; w < E; ++w) {
-				D[O][w] = 0;
-				for (let E = 0; E < T; ++E) D[O][w] += e[O][E] * C[E][w];
-			}
-		}
-		return D;
-	}
-	static multiplyScalar(e, C) {
-		let w = e.length, T = e[0].length, E = Array(w);
-		for (let D = 0; D < w; ++D) {
-			E[D] = Array(T);
-			for (let w = 0; w < T; ++w) E[D][w] = e[D][w] * C;
-		}
-		return E;
-	}
-	static multiplyVector(e, C) {
-		let w = e.length, T = e[0].length, E = Array(w);
-		for (let D = 0; D < w; ++D) {
-			E[D] = 0;
-			for (let w = 0; w < T; ++w) E[D] += e[D][w] * C[w];
-		}
-		return E;
-	}
-	static inverse(e) {
-		if (e.length !== e[0].length) return null;
-		let C = 0, w = 0, T = 0, E = 0, D = e.length, O = [], k = [];
-		for (C = 0; C < D; C += 1) for (O[O.length] = [], k[k.length] = [], T = 0; T < D; T += 1) C === T ? O[C][T] = 1 : O[C][T] = 0, k[C][T] = e[C][T];
-		for (C = 0; C < D; C += 1) {
-			if (E = k[C][C], E === 0) {
-				for (w = C + 1; w < D; w += 1) if (k[w][C] !== 0) {
-					for (T = 0; T < D; T++) E = k[C][T], k[C][T] = k[w][T], k[w][T] = E, E = O[C][T], O[C][T] = O[w][T], O[w][T] = E;
-					break;
-				}
-				if (E = k[C][C], E === 0) return null;
-			}
-			for (T = 0; T < D; T++) k[C][T] = k[C][T] / E, O[C][T] = O[C][T] / E;
-			for (w = 0; w < D; w++) if (w !== C) for (E = k[w][C], T = 0; T < D; T++) k[w][T] -= E * k[C][T], O[w][T] -= E * O[C][T];
-		}
-		return O;
-	}
-}, Matrix3 = class {
-	static get identity() {
-		return [
-			[
-				1,
-				0,
-				0
-			],
-			[
-				0,
-				1,
-				0
-			],
-			[
-				0,
-				0,
-				1
-			]
-		];
-	}
-	static get zeros() {
-		return [
-			[
-				0,
-				0,
-				0
-			],
-			[
-				0,
-				0,
-				0
-			],
-			[
-				0,
-				0,
-				0
-			]
-		];
-	}
-	static diag(e) {
-		return [
-			[
-				e[0],
-				0,
-				0
-			],
-			[
-				0,
-				e[1],
-				0
-			],
-			[
-				0,
-				0,
-				e[2]
-			]
-		];
-	}
-	static sum(e, C) {
-		return [
-			[
-				e[0][0] + C[0][0],
-				e[0][1] + C[0][1],
-				e[0][2] + C[0][2]
-			],
-			[
-				e[1][0] + C[1][0],
-				e[1][1] + C[1][1],
-				e[1][2] + C[1][2]
-			],
-			[
-				e[2][0] + C[2][0],
-				e[2][1] + C[2][1],
-				e[2][2] + C[2][2]
-			]
-		];
-	}
-	static subtract(e, C) {
-		return [
-			[
-				e[0][0] - C[0][0],
-				e[0][1] - C[0][1],
-				e[0][2] - C[0][2]
-			],
-			[
-				e[1][0] - C[1][0],
-				e[1][1] - C[1][1],
-				e[1][2] - C[1][2]
-			],
-			[
-				e[2][0] - C[2][0],
-				e[2][1] - C[2][1],
-				e[2][2] - C[2][2]
-			]
-		];
-	}
-	static rotX(e) {
-		return [
-			[
-				1,
-				0,
-				0
-			],
-			[
-				0,
-				Math.cos(e),
-				-Math.sin(e)
-			],
-			[
-				0,
-				Math.sin(e),
-				Math.cos(e)
-			]
-		];
-	}
-	static rotY(e) {
-		return [
-			[
-				Math.cos(e),
-				0,
-				Math.sin(e)
-			],
-			[
-				0,
-				1,
-				0
-			],
-			[
-				-Math.sin(e),
-				0,
-				Math.cos(e)
-			]
-		];
-	}
-	static rotZ(e) {
-		return [
-			[
-				Math.cos(e),
-				-Math.sin(e),
-				0
-			],
-			[
-				Math.sin(e),
-				Math.cos(e),
-				0
-			],
-			[
-				0,
-				0,
-				1
-			]
-		];
-	}
-	static transpose(e) {
-		return [
-			[
-				e[0][0],
-				e[1][0],
-				e[2][0]
-			],
-			[
-				e[0][1],
-				e[1][1],
-				e[2][1]
-			],
-			[
-				e[0][2],
-				e[1][2],
-				e[2][2]
-			]
-		];
-	}
-	static multiplyScalar(e, C) {
-		return [
-			[
-				e[0][0] * C,
-				e[0][1] * C,
-				e[0][2] * C
-			],
-			[
-				e[1][0] * C,
-				e[1][1] * C,
-				e[1][2] * C
-			],
-			[
-				e[2][0] * C,
-				e[2][1] * C,
-				e[2][2] * C
-			]
-		];
-	}
-	static multiplyVector(e, C) {
-		let w = [
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 3; ++T) {
-			w[T] = 0;
-			for (let E = 0; E < 3; ++E) w[T] += e[T][E] * C[E];
-		}
-		return w;
-	}
-	static multiply(e, C) {
-		let w = [
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 3; ++T) {
-			w[T] = [
-				,
-				,
-				,
-			];
-			for (let E = 0; E < 3; ++E) {
-				w[T][E] = 0;
-				for (let D = 0; D < 3; ++D) w[T][E] += e[T][D] * C[D][E];
-			}
-		}
-		return w;
-	}
-	static skew(e) {
-		return [
-			[
-				0,
-				-e[2],
-				e[1]
-			],
-			[
-				e[2],
-				0,
-				-e[0]
-			],
-			[
-				-e[1],
-				e[0],
-				0
-			]
-		];
-	}
-	static inverse(e) {
-		let C = [
-			,
-			,
-			,
-		], w = e[0][0], T = e[0][1], E = e[0][2], D = e[1][0], O = e[1][1], k = e[1][2], A = e[2][0], j = e[2][1], M = e[2][2], N = M * O - k * j, F = k * A - M * D, I = j * D - O * A, L = w * N + T * F + E * I;
-		if (L === 0) return null;
-		C[0] = [
-			,
-			,
-			,
-		], C[1] = [
-			,
-			,
-			,
-		], C[2] = [
-			,
-			,
-			,
-		];
-		let R = 1 / L;
-		return C[0][0] = N * R, C[0][1] = (E * j - M * T) * R, C[0][2] = (k * T - E * O) * R, C[1][0] = F * R, C[1][1] = (M * w - E * A) * R, C[1][2] = (E * D - k * w) * R, C[2][0] = I * R, C[2][1] = (T * A - j * w) * R, C[2][2] = (O * w - T * D) * R, C;
-	}
-	static determinant(e) {
-		let C = e[0][0], w = e[1][0], T = e[2][0], E = e[0][1], D = e[1][1], O = e[2][1], k = e[0][2], A = e[1][2], j = e[2][2];
-		return C * D * j - C * O * A - w * E * j + w * O * k + T * E * A - T * D * k;
-	}
-	static trace(e) {
-		return e[0][0] + e[1][1] + e[2][2];
-	}
-}, Vector = class {
-	static concat(e, C) {
-		return e.concat(C);
-	}
-}, Vector3 = class e extends Vector {
-	static norm(e) {
-		return Math.sqrt(e[0] * e[0] + e[1] * e[1] + e[2] * e[2]);
-	}
-	static normalize(e) {
-		let C = this.norm(e), w = [
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 3; T++) w[T] = e[T] / C;
-		return w;
-	}
-	static sum(e, C) {
-		return [
-			e[0] + C[0],
-			e[1] + C[1],
-			e[2] + C[2]
-		];
-	}
-	static subtract(e, C) {
-		return [
-			e[0] - C[0],
-			e[1] - C[1],
-			e[2] - C[2]
-		];
-	}
-	static distance(C, w) {
-		return e.norm(e.subtract(C, w));
-	}
-	static cross(e, C) {
-		return [
-			e[1] * C[2] - e[2] * C[1],
-			e[2] * C[0] - e[0] * C[2],
-			e[0] * C[1] - e[1] * C[0]
-		];
-	}
-	static dot(e, C) {
-		return e[0] * C[0] + e[1] * C[1] + e[2] * C[2];
-	}
-	static multiplyScalar(e, C) {
-		let w = [
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 3; T++) w[T] = e[T] * C;
-		return w;
-	}
-}, Matrix4 = class e {
-	static get identity() {
-		return [
-			[
-				1,
-				0,
-				0,
-				0
-			],
-			[
-				0,
-				1,
-				0,
-				0
-			],
-			[
-				0,
-				0,
-				1,
-				0
-			],
-			[
-				0,
-				0,
-				0,
-				1
-			]
-		];
-	}
-	static clone(e) {
-		return [
-			e[0].slice(0),
-			e[1].slice(0),
-			e[2].slice(0),
-			e[3].slice(0)
-		];
-	}
-	static sum(e, C) {
-		return [
-			[
-				e[0][0] + C[0][0],
-				e[0][1] + C[0][1],
-				e[0][2] + C[0][2],
-				e[0][3] + C[0][3]
-			],
-			[
-				e[1][0] + C[1][0],
-				e[1][1] + C[1][1],
-				e[1][2] + C[1][2],
-				e[1][3] + C[1][3]
-			],
-			[
-				e[2][0] + C[2][0],
-				e[2][1] + C[2][1],
-				e[2][2] + C[2][2],
-				e[2][3] + C[2][3]
-			],
-			[
-				e[3][0] + C[3][0],
-				e[3][1] + C[3][1],
-				e[3][2] + C[3][2],
-				e[3][3] + C[3][3]
-			]
-		];
-	}
-	static subtract(e, C) {
-		return [
-			[
-				e[0][0] - C[0][0],
-				e[0][1] - C[0][1],
-				e[0][2] - C[0][2],
-				e[0][3] - C[0][3]
-			],
-			[
-				e[1][0] - C[1][0],
-				e[1][1] - C[1][1],
-				e[1][2] - C[1][2],
-				e[1][3] - C[1][3]
-			],
-			[
-				e[2][0] - C[2][0],
-				e[2][1] - C[2][1],
-				e[2][2] - C[2][2],
-				e[2][3] - C[2][3]
-			],
-			[
-				e[3][0] - C[3][0],
-				e[3][1] - C[3][1],
-				e[3][2] - C[3][2],
-				e[3][3] - C[3][3]
-			]
-		];
-	}
-	static fromMatrix3(e) {
-		return [
-			[
-				e[0][0],
-				e[0][1],
-				e[0][2],
-				0
-			],
-			[
-				e[1][0],
-				e[1][1],
-				e[1][2],
-				0
-			],
-			[
-				e[2][0],
-				e[2][1],
-				e[2][2],
-				0
-			],
-			[
-				0,
-				0,
-				0,
-				1
-			]
-		];
-	}
-	static fromDiagVector(e) {
-		return [
-			[
-				e[0],
-				0,
-				0,
-				0
-			],
-			[
-				0,
-				e[1],
-				0,
-				0
-			],
-			[
-				0,
-				0,
-				e[2],
-				0
-			],
-			[
-				0,
-				0,
-				0,
-				e[3]
-			]
-		];
-	}
-	static fromVector(e) {
-		return [
-			[
-				e[0],
-				e[4],
-				e[8],
-				e[12]
-			],
-			[
-				e[1],
-				e[5],
-				e[9],
-				e[13]
-			],
-			[
-				e[2],
-				e[6],
-				e[10],
-				e[14]
-			],
-			[
-				e[3],
-				e[7],
-				e[11],
-				e[15]
-			]
-		];
-	}
-	static toVector(e) {
-		return [
-			e[0][0],
-			e[1][0],
-			e[2][0],
-			e[3][0],
-			e[0][1],
-			e[1][1],
-			e[2][1],
-			e[3][1],
-			e[0][2],
-			e[1][2],
-			e[2][2],
-			e[3][2],
-			e[0][3],
-			e[1][3],
-			e[2][3],
-			e[3][3]
-		];
-	}
-	static multiply(e, C) {
-		let w = [
-			,
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 4; ++T) {
-			w[T] = [
-				,
-				,
-				,
-				,
-			];
-			for (let E = 0; E < 4; ++E) {
-				w[T][E] = 0;
-				for (let D = 0; D < 4; ++D) w[T][E] += e[T][D] * C[D][E];
-			}
-		}
-		return w;
-	}
-	static multiplyScalar(e, C) {
-		let w = [
-			,
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 4; ++T) {
-			w[T] = [
-				,
-				,
-				,
-				,
-			];
-			for (let E = 0; E < 4; ++E) w[T][E] = e[T][E] * C;
-		}
-		return w;
-	}
-	static multiplyVector(e, C) {
-		let w = [
-			,
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 4; ++T) {
-			w[T] = 0;
-			for (let E = 0; E < 4; ++E) w[T] += e[T][E] * C[E];
-		}
-		return w;
-	}
-	static multiplyVector3(C, w) {
-		return e.multiplyVector(C, [...w, 1]).slice(0, 3);
-	}
-	static transpose(e) {
-		return [
-			[
-				e[0][0],
-				e[1][0],
-				e[2][0],
-				e[3][0]
-			],
-			[
-				e[0][1],
-				e[1][1],
-				e[2][1],
-				e[3][1]
-			],
-			[
-				e[0][2],
-				e[1][2],
-				e[2][2],
-				e[3][2]
-			],
-			[
-				e[0][3],
-				e[1][3],
-				e[2][3],
-				e[3][3]
-			]
-		];
-	}
-	static invert(C) {
-		let w = e.toVector(C), T = w[0], E = w[1], D = w[2], O = w[3], k = w[4], A = w[5], j = w[6], M = w[7], N = w[8], F = w[9], I = w[10], L = w[11], R = w[12], z = w[13], B = w[14], V = w[15], H = F * B * M - z * I * M + z * j * L - A * B * L - F * j * V + A * I * V, U = R * I * M - N * B * M - R * j * L + k * B * L + N * j * V - k * I * V, W = N * z * M - R * F * M + R * A * L - k * z * L - N * A * V + k * F * V, G = R * F * j - N * z * j - R * A * I + k * z * I + N * A * B - k * F * B, K = T * H + E * U + D * W + O * G;
-		if (K === 0) return null;
-		let q = 1 / K;
-		return w[0] = H * q, w[1] = (z * I * O - F * B * O - z * D * L + E * B * L + F * D * V - E * I * V) * q, w[2] = (A * B * O - z * j * O + z * D * M - E * B * M - A * D * V + E * j * V) * q, w[3] = (F * j * O - A * I * O - F * D * M + E * I * M + A * D * L - E * j * L) * q, w[4] = U * q, w[5] = (N * B * O - R * I * O + R * D * L - T * B * L - N * D * V + T * I * V) * q, w[6] = (R * j * O - k * B * O - R * D * M + T * B * M + k * D * V - T * j * V) * q, w[7] = (k * I * O - N * j * O + N * D * M - T * I * M - k * D * L + T * j * L) * q, w[8] = W * q, w[9] = (R * F * O - N * z * O - R * E * L + T * z * L + N * E * V - T * F * V) * q, w[10] = (k * z * O - R * A * O + R * E * M - T * z * M - k * E * V + T * A * V) * q, w[11] = (N * A * O - k * F * O - N * E * M + T * F * M + k * E * L - T * A * L) * q, w[12] = G * q, w[13] = (N * z * D - R * F * D + R * E * I - T * z * I - N * E * B + T * F * B) * q, w[14] = (R * A * D - k * z * D - R * E * j + T * z * j + k * E * B - T * A * B) * q, w[15] = (k * F * D - N * A * D + N * E * j - T * F * j - k * E * I + T * A * I) * q, e.fromVector(w);
-	}
-	static determinant(e) {
-		let C = e[0][0], w = e[1][0], T = e[2][0], E = e[3][0], D = e[0][1], O = e[1][1], k = e[2][1], A = e[3][1], j = e[0][2], M = e[1][2], N = e[2][2], F = e[3][2], I = e[0][3], L = e[1][3], R = e[2][3], z = e[3][3];
-		return I * (Number(E) * k * M - T * A * M - E * O * N + w * A * N + T * O * F - w * k * F) + L * (Number(C) * k * F - C * A * N + E * D * N - T * D * F + T * A * j - E * k * j) + R * (Number(C) * A * M - C * O * F - E * D * M + w * D * F + E * O * j - w * A * j) + z * (-T * O * j - C * k * M + C * O * N + T * D * M - w * D * N + w * k * j);
-	}
-	static compose(e, C, w = [
-		1,
-		1,
-		1
-	]) {
-		let [T, E, D] = w;
-		return [
-			[
-				C[0][0] * T,
-				C[0][1] * E,
-				C[0][2] * D,
-				e[0]
-			],
-			[
-				C[1][0] * T,
-				C[1][1] * E,
-				C[1][2] * D,
-				e[1]
-			],
-			[
-				C[2][0] * T,
-				C[2][1] * E,
-				C[2][2] * D,
-				e[2]
-			],
-			[
-				0,
-				0,
-				0,
-				1
-			]
-		];
-	}
-	static decompose(C) {
-		let w = [
-			Vector3.norm([
-				C[0][0],
-				C[1][0],
-				C[2][0]
-			]),
-			Vector3.norm([
-				C[0][1],
-				C[1][1],
-				C[2][1]
-			]),
-			Vector3.norm([
-				C[0][2],
-				C[1][2],
-				C[2][2]
-			])
-		];
-		e.determinant(C) < 0 && (w[0] = -w[0]);
-		let T = [
-			C[0][3],
-			C[1][3],
-			C[2][3]
-		], E = 1 / w[0], D = 1 / w[1], O = 1 / w[2];
-		return {
-			translation: T,
-			scale: w,
-			rotation: [
-				[
-					C[0][0] * E,
-					C[0][1] * D,
-					C[0][2] * O
-				],
-				[
-					C[1][0] * E,
-					C[1][1] * D,
-					C[1][2] * O
-				],
-				[
-					C[2][0] * E,
-					C[2][1] * D,
-					C[2][2] * O
-				]
-			]
-		};
-	}
-	static extractRotation(e) {
-		let C = 1 / Vector3.norm([
-			e[0][0],
-			e[1][0],
-			e[2][0]
-		]), w = 1 / Vector3.norm([
-			e[0][1],
-			e[1][1],
-			e[2][1]
-		]), T = 1 / Vector3.norm([
-			e[0][2],
-			e[1][2],
-			e[2][2]
-		]);
-		return [
-			[
-				e[0][0] * C,
-				e[0][1] * w,
-				e[0][2] * T
-			],
-			[
-				e[1][0] * C,
-				e[1][1] * w,
-				e[1][2] * T
-			],
-			[
-				e[2][0] * C,
-				e[2][1] * w,
-				e[2][2] * T
-			]
-		];
-	}
-	static extractTranslation(e) {
-		return [
-			e[0][3],
-			e[1][3],
-			e[2][3]
-		];
-	}
-	static scaleTranslation(e, C) {
-		return [
-			[
-				e[0][0],
-				e[0][1],
-				e[0][2],
-				e[0][3] * C[0]
-			],
-			[
-				e[1][0],
-				e[1][1],
-				e[1][2],
-				e[1][3] * C[1]
-			],
-			[
-				e[2][0],
-				e[2][1],
-				e[2][2],
-				e[2][3] * C[2]
-			],
-			[
-				e[3][0],
-				e[3][1],
-				e[3][2],
-				e[3][3]
-			]
-		];
-	}
-	static setTranslation(e, C) {
-		return e[0][3] = C[0], e[1][3] = C[1], e[2][3] = C[2], e;
-	}
-	static toString(e) {
-		return "[\n" + e.map((e) => "	[" + e.map((e) => e.toFixed(2)).join(", ") + "]").join(",\n") + "\n]";
-	}
-}, _Quaternion = class e {
-	static get identity() {
-		return [
-			1,
-			0,
-			0,
-			0
-		];
-	}
-	static sum(e, C) {
-		return [
-			e[0] + C[0],
-			e[1] + C[1],
-			e[2] + C[2],
-			e[3] + C[3]
-		];
-	}
-	static rotateMatlab(e, C) {
-		let [w, T, E, D] = e, [O, k, A] = C;
-		return [
-			w * (w * O - E * A + D * k) - E * (w * A - T * k + E * O) + T * (T * O + E * k + D * A) + D * (w * k + T * A - D * O),
-			w * (w * k + T * A - D * O) + T * (w * A - T * k + E * O) + E * (T * O + E * k + D * A) - D * (w * O - E * A + D * k),
-			w * (w * A - T * k + E * O) - T * (w * k + T * A - D * O) + E * (w * O - E * A + D * k) + D * (T * O + E * k + D * A)
-		];
-	}
-	static rotate(e, C) {
-		let [w, T, E, D] = e, O = [
-			T,
-			E,
-			D
-		], k = Vector3.cross(O, C);
-		k = Vector3.sum(k, k);
-		let A = Vector3.sum(C, Vector3.multiplyScalar(k, w));
-		return Vector3.sum(A, Vector3.cross(O, k));
-	}
-	static inverse(e) {
-		return [
-			-e[0],
-			e[1],
-			e[2],
-			e[3]
-		];
-	}
-	static multiply(...C) {
-		if (C.length === 2) {
-			let [e, w, T, E] = C[0], [D, O, k, A] = C[1];
-			return [
-				e * D - w * O - T * k - E * A,
-				e * O + D * w + T * A - E * k,
-				e * k + D * T + E * O - w * A,
-				e * A + D * E + w * k - T * O
-			];
-		}
-		return C.reduce((e, C) => this.multiply(e, C), e.identity);
-	}
-	static fromAxisAngle(e, C) {
-		let w = Math.sin(C / 2);
-		return [
-			Math.cos(C / 2),
-			e[0] * w,
-			e[1] * w,
-			e[2] * w
-		];
-	}
-	static rotX(e) {
-		return this.fromAxisAngle([
-			1,
-			0,
-			0
-		], e);
-	}
-	static rotY(e) {
-		return this.fromAxisAngle([
-			0,
-			1,
-			0
-		], e);
-	}
-	static rotZ(e) {
-		return this.fromAxisAngle([
-			0,
-			0,
-			1
-		], e);
-	}
-	static fromMatrix3(e) {
-		let C = Math.sqrt(1 + e[0][0] + e[1][1] + e[2][2]) / 2;
-		return [
-			C,
-			(e[2][1] - e[1][2]) / (4 * C),
-			(e[0][2] - e[2][0]) / (4 * C),
-			(e[1][0] - e[0][1]) / (4 * C)
-		];
-	}
-	static fromMatrix3Matlab(e) {
-		let C = Math.sqrt(1 + e[0][0] + e[1][1] + e[2][2]) / 2;
-		return [
-			C,
-			(e[1][2] - e[2][1]) / (4 * C),
-			(e[2][0] - e[0][2]) / (4 * C),
-			(e[0][1] - e[1][0]) / (4 * C)
-		];
-	}
-	static toMatrix3(e) {
-		let [C, w, T, E] = e, D = C * w, O = C * T, k = C * E, A = w * w, j = w * T, M = w * E, N = T * T, F = T * E, I = E * E;
-		return [
-			[
-				1 - 2 * (N + I),
-				2 * (j - k),
-				2 * (M + O)
-			],
-			[
-				2 * (j + k),
-				1 - 2 * (A + I),
-				2 * (F - D)
-			],
-			[
-				2 * (M - O),
-				2 * (F + D),
-				1 - 2 * (A + N)
-			]
-		];
-	}
-	static wxyz2xyzw(e) {
-		return [
-			e[1],
-			e[2],
-			e[3],
-			e[0]
-		];
-	}
-	static xyzw2wxyz(e) {
-		return [
-			e[3],
-			e[0],
-			e[1],
-			e[2]
-		];
-	}
-	static distance(C, w) {
-		return Math.acos(Math.min(2 * e.dot(C, w) ** 2 - 1, 1));
-	}
-	static equals(C, w) {
-		return e.distance(C, w) < 1e-8;
-	}
-	static normalize(e) {
-		let C = this.norm(e), w = [
-			,
-			,
-			,
-			,
-		];
-		for (let T = 0; T < 4; T++) w[T] = e[T] / C;
-		return w;
-	}
-	static norm(e) {
-		return Math.sqrt(e[0] ** 2 + e[1] ** 2 + e[2] ** 2 + e[3] ** 2);
-	}
-	static dot(e, C) {
-		return e[0] * C[0] + e[1] * C[1] + e[2] * C[2] + e[3] * C[3];
-	}
-	static getRotationBetweenTwoVectors(C, w) {
-		let T = Vector3.normalize(C), E = Vector3.normalize(w), D = Vector3.dot(T, E), O;
-		if (D < -.999999) return O = Vector3.cross([
-			1,
-			0,
-			0
-		], T), Vector3.norm(O) < 1e-6 && (O = Vector3.cross([
-			0,
-			1,
-			0
-		], T)), O = Vector3.normalize(O), e.fromAxisAngle(O, Math.PI);
-		if (D > .999999) return e.identity;
-		O = Vector3.cross(T, E);
-		let k = [
-			1 + D,
-			O[0],
-			O[1],
-			O[2]
-		];
-		return e.normalize(k);
-	}
-	static slerp(C, w, T) {
-		let E = C[1], D = C[2], O = C[3], k = C[0], A = w[1], j = w[2], M = w[3], N = w[0], F, I, L;
-		F = E * A + D * j + O * M + k * N, F < 0 && (F = -F, N = -N, A = -A, j = -j, M = -M);
-		let R = 1 - F < 1e-6;
-		if (R) I = 1 - T, L = T;
-		else {
-			let e = Math.acos(F), C = Math.sin(e);
-			I = Math.sin((1 - T) * e) / C, L = Math.sin(T * e) / C;
-		}
-		let z = [
-			I * k + L * N,
-			I * E + L * A,
-			I * D + L * j,
-			I * O + L * M
-		];
-		return R && (z = e.normalize(z)), z;
-	}
-	static toString(e) {
-		return `[${e[0].toFixed(2)}, ${e[1].toFixed(2)}, ${e[2].toFixed(2)}, ${e[3].toFixed(2)}]`;
-	}
-	static fromUnitVectors(C, w) {
-		let T = Vector3.dot(C, w) + 1, E, D, O, k;
-		T < 2 ** -52 ? (T = 0, Math.abs(C[1]) > Math.abs(C[2]) ? (E = -C[1], D = C[0], O = 0, k = T) : (E = 0, D = -C[2], O = C[1], k = T)) : (E = C[1] * w[2] - C[2] * w[1], D = C[2] * w[0] - C[0] * w[2], O = C[0] * w[1] - C[1] * w[0], k = T);
-		let A = [
-			k,
-			E,
-			D,
-			O
-		];
-		return e.normalize(A);
-	}
-};
-__publicField$1(_Quaternion, "ROTX_PI2", _Quaternion.rotX(Math.PI / 2)), __publicField$1(_Quaternion, "ROTX_PI", _Quaternion.rotX(Math.PI)), __publicField$1(_Quaternion, "ROTX_MPI2", _Quaternion.rotX(-Math.PI / 2)), __publicField$1(_Quaternion, "ROTY_PI2", _Quaternion.rotY(Math.PI / 2)), __publicField$1(_Quaternion, "ROTY_PI", _Quaternion.rotY(Math.PI)), __publicField$1(_Quaternion, "ROTY_MPI2", _Quaternion.rotY(-Math.PI / 2)), __publicField$1(_Quaternion, "ROTZ_PI2", _Quaternion.rotZ(Math.PI / 2)), __publicField$1(_Quaternion, "ROTZ_PI", _Quaternion.rotZ(Math.PI)), __publicField$1(_Quaternion, "ROTZ_MPI2", _Quaternion.rotZ(-Math.PI / 2));
-var Quaternion = _Quaternion;
-function deg2rad(e) {
-	return e * (Math.PI / 180);
-}
-function rad2deg(e) {
-	return e * 180 / Math.PI;
-}
-function diffAngle(e, C) {
-	return Math.atan2(Math.sin(e - C), Math.cos(e - C));
-}
-function diffAngleLines(e, C) {
-	let w = Math.abs(diffAngle(e, C));
-	return w > Math.PI / 2 && (w = Math.PI - w), w;
-}
-function std(e) {
-	let C = e.length, w = e.reduce((e, C) => e + C) / C;
-	return Math.sqrt(e.map((e) => (e - w) ** 2).reduce((e, C) => e + C) / C);
-}
-var Rotations = class e {
-	static eulerToQuaternionZXYDegrees(C) {
-		let w = C.map((e) => deg2rad(e));
-		return e.eulerToQuaternionZXY(w);
-	}
-	static eulerToQuaternionZXY(e) {
-		let C = e[0], w = e[1], T = e[2], E = Math.cos(C / 2), D = Math.cos(w / 2), O = Math.cos(T / 2), k = Math.sin(C / 2), A = Math.sin(w / 2), j = Math.sin(T / 2), M = E * D * O - k * A * j, N = E * A * O - k * D * j, F = k * A * O + E * D * j, I = k * D * O + E * A * j;
-		return M < 0 && (M = -M, N = -N, F = -F, I = -I), [
-			M,
-			N,
-			F,
-			I
-		];
-	}
-	static quaternionToEulerZXYDegrees(C) {
-		return e.quaternionToEulerZXY(C).map((e) => rad2deg(e));
-	}
-	static quaternionToEulerZXY(e) {
-		let C = e[0], w = e[1], T = e[2], E = e[3], D, O, k, A = T * E + w * C;
-		return A > .499 ? (D = 2 * Math.atan2(T, C), O = Math.PI / 2, k = 0) : A < -.499 ? (D = -2 * Math.atan2(T, C), O = -Math.PI / 2, k = 0) : (D = Math.atan2(2 * E * C - 2 * T * w, 1 - 2 * E ** 2 - 2 * w ** 2), O = Math.asin(2 * A), k = Math.atan2(2 * T * C - 2 * E * w, 1 - 2 * T ** 2 - 2 * w ** 2)), D %= 2 * Math.PI, O %= Math.PI, k %= 2 * Math.PI, [
-			D,
-			O,
-			k
-		];
-	}
-	static quaternionToEulerDegrees(C, w) {
-		return e.quaternionToEuler(C, w).map((e) => rad2deg(e));
-	}
-	static quaternionToEuler(C, w) {
-		let T = C[0], E = C[1], D = C[2], O = C[3];
-		switch (w.toLowerCase()) {
-			case "zyx": return e._threeaxisrot(2 * (E * D + T * O), T ** 2 + E ** 2 - D ** 2 - O ** 2, -2 * (E * O - T * D), 2 * (D * O + T * E), T ** 2 - E ** 2 - D ** 2 + O ** 2);
-			case "zyz": return e._twoaxisrot(2 * (D * O - T * E), 2 * (E * O + T * D), T ** 2 - E ** 2 - D ** 2 + O ** 2, 2 * (D * O + T * E), -2 * (E * O - T * D));
-			case "zxy": return e._threeaxisrot(-2 * (E * D - T * O), T ** 2 - E ** 2 + D ** 2 - O ** 2, 2 * (D * O + T * E), -2 * (E * O - T * D), T ** 2 - E ** 2 - D ** 2 + O ** 2);
-			case "zxz": return e._twoaxisrot(2 * (E * O + T * D), -2 * (D * O - T * E), T ** 2 - E ** 2 - D ** 2 + O ** 2, 2 * (E * O - T * D), 2 * (D * O + T * E));
-			case "yxz": return e._threeaxisrot(2 * (E * O + T * D), T ** 2 - E ** 2 - D ** 2 + O ** 2, -2 * (D * O - T * E), 2 * (E * D + T * O), T ** 2 - E ** 2 + D ** 2 - O ** 2);
-			case "yxy": return e._twoaxisrot(2 * (E * D - T * O), 2 * (D * O + T * E), T ** 2 - E ** 2 + D ** 2 - O ** 2, 2 * (E * D + T * O), -2 * (D * O - T * E));
-			case "yzx": return e._threeaxisrot(-2 * (E * O - T * D), T ** 2 + E ** 2 - D ** 2 - O ** 2, 2 * (E * D + T * O), -2 * (D * O - T * E), T ** 2 - E ** 2 + D ** 2 - O ** 2);
-			case "yzy": return e._twoaxisrot(2 * (D * O + T * E), -2 * (E * D - T * O), T ** 2 - E ** 2 + D ** 2 - O ** 2, 2 * (D * O - T * E), 2 * (E * D + T * O));
-			case "xyz": return e._threeaxisrot(-2 * (D * O - T * E), T ** 2 - E ** 2 - D ** 2 + O ** 2, 2 * (E * O + T * D), -2 * (E * D - T * O), T ** 2 + E ** 2 - D ** 2 - O ** 2);
-			case "xyx": return e._twoaxisrot(2 * (E * D + T * O), -2 * (E * O - T * D), T ** 2 + E ** 2 - D ** 2 - O ** 2, 2 * (E * D - T * O), 2 * (E * O + T * D));
-			case "xzy": return e._threeaxisrot(2 * (D * O + T * E), T ** 2 - E ** 2 + D ** 2 - O ** 2, -2 * (E * D - T * O), 2 * (E * O + T * D), T ** 2 + E ** 2 - D ** 2 - O ** 2);
-			case "xzx": return e._twoaxisrot(2 * (E * O - T * D), 2 * (E * D + T * O), T ** 2 + E ** 2 - D ** 2 - O ** 2, 2 * (E * O + T * D), -2 * (E * D - T * O));
-		}
-		throw Error("unknown order");
-	}
-	static _threeaxisrot(e, C, w, T, E) {
-		return [
-			Math.atan2(e, C),
-			Math.asin(w),
-			Math.atan2(T, E)
-		];
-	}
-	static _twoaxisrot(e, C, w, T, E) {
-		return [
-			Math.atan2(e, C),
-			Math.acos(w),
-			Math.atan2(T, E)
-		];
-	}
-	static getHeadingFromQuaternion(e) {
-		let [C, w, T, E] = e, D = C * w, O = T * E, k = w ** 2;
-		return Math.asin(2 * (D + O)) < Math.PI / 4 && k + T ** 2 < .5 ? -Math.atan2(C * E - w * T, .5 - k - E ** 2) : -Math.atan2(w * E + C * T, D - O);
-	}
 }, __defProp = Object.defineProperty, __defNormalProp = (e, C, w) => C in e ? __defProp(e, C, {
 	enumerable: !0,
 	configurable: !0,
@@ -2522,39 +1375,39 @@ var field = function(e, C, w) {
 	}
 	update(e, C, w, T) {
 		if (!this.quaternion) return this.tryInitialize(C, T);
-		let E = this.quaternion, D = E, O = Vector3.multiplyScalar(w, .5 * e), k = this.computeC([
+		let E = this.quaternion, D = E, O = Vector3.multiplyScalar(w, .5 * e), N = this.computeC([
 			1,
 			O[0],
 			O[1],
 			O[2]
-		]), A = Matrix4.multiplyVector(k, E), j = Matrix3.diag([
+		]), L = Matrix4.multiplyVector(N, E), R = Matrix3.diag([
 			D[0],
 			D[0],
 			D[0]
-		]), M = Matrix3.skew([
+		]), z = Matrix3.skew([
 			D[1],
 			D[2],
 			D[3]
-		]), N = [
+		]), B = [
 			-1 * D[1],
 			-1 * D[2],
 			-1 * D[3]
-		], F = Matrix.concatRow([N], Matrix3.sum(M, j)), I = Matrix4.multiplyScalar(Matrix.multiply(Matrix.multiply(F, this.noises[T ? "absolute" : "relative"].gyr), Matrix.transpose(F)), (e / 2) ** 2), L = Matrix4.sum(Matrix4.multiply(Matrix4.multiply(k, this.P), Matrix4.transpose(k)), I), R = Vector3.normalize(C), z, B, V;
+		], V = Matrix.concatRow([B], Matrix3.sum(z, R)), H = Matrix4.multiplyScalar(Matrix.multiply(Matrix.multiply(V, this.noises[T ? "absolute" : "relative"].gyr), Matrix.transpose(V)), (e / 2) ** 2), U = Matrix4.sum(Matrix4.multiply(Matrix4.multiply(N, this.P), Matrix4.transpose(N)), H), W = Vector3.normalize(C), G, K, q;
 		if (T) {
-			let e = Vector3.normalize(T), C = Vector3.cross(R, e), w = Vector3.normalize(C), E = Vector3.subtract(w, Quaternion.rotateMatlab(A, this.cRef)), D = Vector3.subtract(R, Quaternion.rotateMatlab(A, this.accRef));
-			z = Vector.concat(E, D);
-			let O = this.jacobianES(A, this.cRef), k = this.jacobianES(A, this.accRef);
-			V = Matrix.concatRow(O, k);
-			let j = Matrix.concatLine(this.noises.absolute.yc, Matrix3.zeros), M = Matrix.concatLine(Matrix3.zeros, this.noises.absolute.acc), N = Matrix.concatRow(j, M);
-			B = Matrix.multiply(Matrix.multiply(L, Matrix.transpose(V)), Matrix.inverse(Matrix.sum(Matrix.multiply(Matrix.multiply(V, L), Matrix.transpose(V)), N)));
+			let e = Vector3.normalize(T), C = Vector3.cross(W, e), w = Vector3.normalize(C), E = Vector3.subtract(w, Quaternion.rotateMatlab(L, this.cRef)), D = Vector3.subtract(W, Quaternion.rotateMatlab(L, this.accRef));
+			G = Vector.concat(E, D);
+			let O = this.jacobianES(L, this.cRef), j = this.jacobianES(L, this.accRef);
+			q = Matrix.concatRow(O, j);
+			let N = Matrix.concatLine(this.noises.absolute.yc, Matrix3.zeros), R = Matrix.concatLine(Matrix3.zeros, this.noises.absolute.acc), z = Matrix.concatRow(N, R);
+			K = Matrix.multiply(Matrix.multiply(U, Matrix.transpose(q)), Matrix.inverse(Matrix.sum(Matrix.multiply(Matrix.multiply(q, U), Matrix.transpose(q)), z)));
 		} else {
-			z = Vector3.subtract(R, Quaternion.rotateMatlab(A, this.accRef)), V = this.jacobianES(A, this.accRef);
+			G = Vector3.subtract(W, Quaternion.rotateMatlab(L, this.accRef)), q = this.jacobianES(L, this.accRef);
 			let e = this.noises.relative.acc;
-			B = Matrix.multiply(Matrix.multiply(L, Matrix.transpose(V)), Matrix3.inverse(Matrix3.sum(Matrix.multiply(Matrix.multiply(V, L), Matrix.transpose(V)), e)));
+			K = Matrix.multiply(Matrix.multiply(U, Matrix.transpose(q)), Matrix3.inverse(Matrix3.sum(Matrix.multiply(Matrix.multiply(q, U), Matrix.transpose(q)), e)));
 		}
-		E = Quaternion.sum(A, Matrix.multiplyVector(B, z));
-		let H = Matrix4.multiply(Matrix4.subtract(Matrix4.identity, Matrix.multiply(B, V)), L);
-		return E = Quaternion.normalize(E), this.quaternion = E, this.P = H, E;
+		E = Quaternion.sum(L, Matrix.multiplyVector(K, G));
+		let J = Matrix4.multiply(Matrix4.subtract(Matrix4.identity, Matrix.multiply(K, q)), U);
+		return E = Quaternion.normalize(E), this.quaternion = E, this.P = J, E;
 	}
 	computeC(e) {
 		return [
@@ -3052,7 +1905,23 @@ var field = function(e, C, w) {
 	}
 }(), package_default = {
 	name: "@wemap/providers",
-	version: "14.6.0-beta.1",
+	version: "14.6.0-beta.3",
+	description: "Sensor, positioning and VPS providers for the Wemap SDK.",
+	license: "UNLICENSED",
+	author: "Wemap SAS",
+	homepage: "https://github.com/wemap/wemap-sdk-js#readme",
+	repository: {
+		type: "git",
+		url: "git+https://github.com/wemap/wemap-sdk-js.git",
+		directory: "packages/providers"
+	},
+	bugs: { url: "https://github.com/wemap/wemap-sdk-js/issues" },
+	keywords: [
+		"wemap",
+		"sdk",
+		"providers",
+		"vps"
+	],
 	type: "module",
 	publishConfig: { access: "public" },
 	main: "./dist/index.js",
@@ -3061,18 +1930,19 @@ var field = function(e, C, w) {
 		import: "./dist/index.js",
 		types: "./dist/index.d.ts"
 	} },
+	sideEffects: !1,
 	files: ["dist"],
 	dependencies: {
-		"@wemap/camera": "14.6.0-beta.1",
-		"@wemap/core": "14.6.0-beta.1",
-		"@wemap/geo": "14.6.0-beta.1",
-		"@wemap/osm": "14.6.0-beta.1",
-		"@wemap/routers": "14.6.0-beta.1",
-		"@wemap/utils": "14.6.0-beta.1"
+		"@wemap/camera": "14.6.0-beta.3",
+		"@wemap/core": "14.6.0-beta.3",
+		"@wemap/geo": "14.6.0-beta.3",
+		"@wemap/maths": "14.6.0-beta.3",
+		"@wemap/osm": "14.6.0-beta.3",
+		"@wemap/routers": "14.6.0-beta.3",
+		"@wemap/utils": "14.6.0-beta.3"
 	},
 	devDependencies: {
 		"@wemap/logger-legacy": "^13.3.0",
-		"@wemap/maths-legacy": "^13.3.0",
 		geomag: "^1.0.0"
 	}
 }, InclinationFromAccProvider_default = new class extends Provider_default {
@@ -3233,8 +2103,8 @@ var field = function(e, C, w) {
 			return Logger.debug("[VPS] Server respond error"), null;
 		}
 		if (j.status !== 200) return Logger.debug("[VPS] Server respond error"), null;
-		let M = await j.json(), F = VpsResponse_default.fromJson(M, k);
-		return Logger.debug(`[VPS] Server respond ${F.success ? "success" : "not found"}`), F;
+		let M = await j.json(), N = VpsResponse_default.fromJson(M, k);
+		return Logger.debug(`[VPS] Server respond ${N.success ? "success" : "not found"}`), N;
 	}
 	static getHeadingFromQuaternion(e) {
 		let [C, w, T, E] = e, D = Math.sqrt(2) / 2, O = [
@@ -3411,7 +2281,7 @@ var field = function(e, C, w) {
 				...k && { position: k },
 				...AbsoluteAttitudeProvider_default.lastEvent && { attitude: AbsoluteAttitudeProvider_default.lastEvent }
 			}), this._currentAttemptId === null && (this._attemptIdCounter += 1, this._currentAttemptId = this._attemptIdCounter);
-			let A = RelativeAttitudeProvider_default.lastEvent, j = GeoRelativePositionProvider_default.lastEvent, M = A && j ? {
+			let A = RelativeAttitudeProvider_default.lastEvent, j = GeoRelativePositionProvider_default.lastEvent, N = A && j ? {
 				position: Quaternion.rotate(e.ENU_TO_ARCORE_ROT, [
 					j.x,
 					j.y,
@@ -3423,7 +2293,7 @@ var field = function(e, C, w) {
 				installation_id: null,
 				...this._currentAttemptId !== null && { attempt_id: this._currentAttemptId },
 				caller: this._requestCaller
-			}, M);
+			}, N);
 			if (!F || !F.success) {
 				this._scanFailureCallbacks.forEach(({ id: e, callback: C }) => C({
 					listenerId: e,
@@ -3433,20 +2303,20 @@ var field = function(e, C, w) {
 				continue;
 			}
 			this._currentAttemptId = null;
-			let I = F.attitude.quaternion, L = Quaternion.multiply(I, e.CAMERA_TO_SMARTPHONE_ROT), R = Quaternion.multiply(Quaternion.fromAxisAngle([
+			let I = F.attitude.quaternion, R = Quaternion.multiply(I, e.CAMERA_TO_SMARTPHONE_ROT), z = Quaternion.multiply(Quaternion.fromAxisAngle([
 				0,
 				0,
 				1
-			], deg2rad(window.orientation || 0)), L), z = this._relativeRotationCalc?.tickEnd() || new Attitude([
+			], deg2rad(window.orientation || 0)), R), B = this._relativeRotationCalc?.tickEnd() || new Attitude([
 				1,
 				0,
 				0,
 				0
-			]), B = new AbsoluteAttitude(Quaternion.multiply(R, z.quaternion), F.attitude.time, F.attitude.accuracy), V = F.position.clone();
-			if (V.accuracy === null && (V.accuracy = 5), T()) break;
+			]), V = new AbsoluteAttitude(Quaternion.multiply(z, B.quaternion), F.attitude.time, F.attitude.accuracy), H = F.position.clone();
+			if (H.accuracy === null && (H.accuracy = 5), T()) break;
 			this.notify({
-				absoluteAttitude: B,
-				absolutePosition: V
+				absoluteAttitude: V,
+				absolutePosition: H
 			});
 		}
 	};
@@ -3511,6 +2381,7 @@ var field = function(e, C, w) {
 	useAllAbsolutePositions = !1;
 	_waitUntilNextVpsPosition = !1;
 	_lastPolestarFix = null;
+	ignoreGnssWifi = !1;
 	getName = () => "AbsolutePosition";
 	availability() {
 		return AvailabilityHelper.some([
@@ -3524,6 +2395,7 @@ var field = function(e, C, w) {
 		GeoRelativePositionProvider_default.getAvailability().then((e) => {
 			e || (this._relativePositionProviderId = GeoRelativePositionProvider_default.addEventListener((e) => this._onRelativePosition(e)));
 		}), this._gnssWifiProviderId = GnssWifiProvider_default.addEventListener((e) => {
+			if (this.ignoreGnssWifi) return;
 			let C = e.clone();
 			C.bearing = null, this._onAbsolutePosition(C, !1);
 		}), this._vpsProviderId = VpsProvider_default.addEventListener((e) => this._onAbsolutePosition(e.absolutePosition), this.notifyError, !1), ProvidersOptions_default.hasPoleStar && (this._polestarProviderId = PoleStarProvider_default.addEventListener((e) => {
@@ -3970,8 +2842,8 @@ var field = function(e, C, w) {
 		if (!(w instanceof Edge)) return;
 		let E, D = diffAngle(w.bearing, T.bearing), O = diffAngle(w.bearing + Math.PI, T.bearing);
 		E = Math.abs(D) < Math.abs(O) ? w.bearing : (w.bearing + Math.PI) % (2 * Math.PI);
-		let A = new AbsoluteHeading(E, T.time, 0);
-		AbsoluteAttitudeProvider_default._forceHeadingForRelative(A), this._countStepsFromLastMatching = 0;
+		let k = new AbsoluteHeading(E, T.time, 0);
+		AbsoluteAttitudeProvider_default._forceHeadingForRelative(k), this._countStepsFromLastMatching = 0;
 	}
 	getProjection(e, C, w) {
 		let T = {
@@ -4103,11 +2975,11 @@ var field = function(e, C, w) {
 			return;
 		}
 		if (e.isJump(T, w)) {
-			let E = this._smoothing === null ? T : this._smoothing.interpAttitude(T), D = E.heading, O = w.heading, k = diffAngle(O, D), A = Math.abs(k) < e.HIGH_JUMP_THRESHOLD ? e.ROTATION_SPEED_CONVERGENCE : e.ROTATION_SPEED_HIGH_JUMP_CONVERGENCE, j = E.time, M = Math.abs(k) / A, N = k < 0 ? -1 : 1;
+			let E = this._smoothing === null ? T : this._smoothing.interpAttitude(T), D = E.heading, O = w.heading, k = diffAngle(O, D), A = Math.abs(k) < e.HIGH_JUMP_THRESHOLD ? e.ROTATION_SPEED_CONVERGENCE : e.ROTATION_SPEED_HIGH_JUMP_CONVERGENCE, j = E.time, N = Math.abs(k) / A, F = k < 0 ? -1 : 1;
 			this._smoothing = {
-				toTime: j + M,
+				toTime: j + N,
 				interpAttitude: (e) => {
-					let w = D + A * (e.time - j) * N, T = Quaternion.fromAxisAngle([
+					let w = D + A * (e.time - j) * F, T = Quaternion.fromAxisAngle([
 						0,
 						0,
 						1