@wemap/geo 14.3.1 → 14.5.0

package/dist/index.js

@@ -1,11 +1,11 @@
 import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
-var __defProp$1 = Object.defineProperty, __export = (a) => {
-	let A = {};
-	for (var j in a) __defProp$1(A, j, {
-		get: a[j],
+var __defProp$1 = Object.defineProperty, __export = (e) => {
+	let T = {};
+	for (var E in e) __defProp$1(T, E, {
+		get: e[E],
 		enumerable: !0
 	});
-	return A;
+	return T;
 }, Constants_exports = /* @__PURE__ */ __export({
 	CIRCUMFERENCE: () => CIRCUMFERENCE,
 	EARTH_GRAVITY: () => EARTH_GRAVITY,
@@ -22,65 +22,65 @@ var __defProp$1 = Object.defineProperty, __export = (a) => {
 	R_MINOR_4: () => R_MINOR_4
 });
 const R_MAJOR = 6378137, R_MINOR = 6356752.3142, EARTH_GRAVITY = 9.80665, EPS_DEG_MM = 1e-8, EPS_MM = .001, ELLIPSOID_FLATNESS = (R_MAJOR - R_MINOR) / R_MAJOR, ECCENTRICITY = Math.sqrt(ELLIPSOID_FLATNESS * (2 - ELLIPSOID_FLATNESS)), ECCENTRICITY_2 = ECCENTRICITY * ECCENTRICITY, R_MAJOR_2 = R_MAJOR * R_MAJOR, R_MAJOR_4 = R_MAJOR_2 * R_MAJOR_2, R_MINOR_2 = R_MINOR * R_MINOR, R_MINOR_4 = R_MINOR_2 * R_MINOR_2, CIRCUMFERENCE = R_MAJOR * 2 * Math.PI;
-var __defProp = Object.defineProperty, __defNormalProp = (a, k, A) => k in a ? __defProp(a, k, {
+var __defProp = Object.defineProperty, __defNormalProp = (e, w, T) => w in e ? __defProp(e, w, {
 	enumerable: !0,
 	configurable: !0,
 	writable: !0,
-	value: A
-}) : a[k] = A, __publicField = (a, k, A) => (__defNormalProp(a, typeof k == "symbol" ? k : k + "", A), A), Vector = class {
-	static concat(a, k) {
-		return a.concat(k);
+	value: T
+}) : e[w] = T, __publicField = (e, w, T) => (__defNormalProp(e, typeof w == "symbol" ? w : w + "", T), T), Vector = class {
+	static concat(e, w) {
+		return e.concat(w);
 	}
-}, Vector3 = class a extends Vector {
-	static norm(a) {
-		return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+}, 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(a) {
-		let k = this.norm(a), A = [
+	static normalize(e) {
+		let w = this.norm(e), T = [
 			,
 			,
 			,
 		];
-		for (let j = 0; j < 3; j++) A[j] = a[j] / k;
-		return A;
+		for (let E = 0; E < 3; E++) T[E] = e[E] / w;
+		return T;
 	}
-	static sum(a, k) {
+	static sum(e, w) {
 		return [
-			a[0] + k[0],
-			a[1] + k[1],
-			a[2] + k[2]
+			e[0] + w[0],
+			e[1] + w[1],
+			e[2] + w[2]
 		];
 	}
-	static subtract(a, k) {
+	static subtract(e, w) {
 		return [
-			a[0] - k[0],
-			a[1] - k[1],
-			a[2] - k[2]
+			e[0] - w[0],
+			e[1] - w[1],
+			e[2] - w[2]
 		];
 	}
-	static distance(k, A) {
-		return a.norm(a.subtract(k, A));
+	static distance(w, T) {
+		return e.norm(e.subtract(w, T));
 	}
-	static cross(a, k) {
+	static cross(e, w) {
 		return [
-			a[1] * k[2] - a[2] * k[1],
-			a[2] * k[0] - a[0] * k[2],
-			a[0] * k[1] - a[1] * k[0]
+			e[1] * w[2] - e[2] * w[1],
+			e[2] * w[0] - e[0] * w[2],
+			e[0] * w[1] - e[1] * w[0]
 		];
 	}
-	static dot(a, k) {
-		return a[0] * k[0] + a[1] * k[1] + a[2] * k[2];
+	static dot(e, w) {
+		return e[0] * w[0] + e[1] * w[1] + e[2] * w[2];
 	}
-	static multiplyScalar(a, k) {
-		let A = [
+	static multiplyScalar(e, w) {
+		let T = [
 			,
 			,
 			,
 		];
-		for (let j = 0; j < 3; j++) A[j] = a[j] * k;
-		return A;
+		for (let E = 0; E < 3; E++) T[E] = e[E] * w;
+		return T;
 	}
-}, _Quaternion = class a {
+}, _Quaternion = class e {
 	static get identity() {
 		return [
 			1,
@@ -89,361 +89,361 @@ var __defProp = Object.defineProperty, __defNormalProp = (a, k, A) => k in a ? _
 			0
 		];
 	}
-	static sum(a, k) {
+	static sum(e, w) {
 		return [
-			a[0] + k[0],
-			a[1] + k[1],
-			a[2] + k[2],
-			a[3] + k[3]
+			e[0] + w[0],
+			e[1] + w[1],
+			e[2] + w[2],
+			e[3] + w[3]
 		];
 	}
-	static rotateMatlab(a, k) {
-		let [A, j, M, N] = a, [P, F, I] = k;
+	static rotateMatlab(e, w) {
+		let [T, E, D, O] = e, [k, A, j] = w;
 		return [
-			A * (A * P - M * I + N * F) - M * (A * I - j * F + M * P) + j * (j * P + M * F + N * I) + N * (A * F + j * I - N * P),
-			A * (A * F + j * I - N * P) + j * (A * I - j * F + M * P) + M * (j * P + M * F + N * I) - N * (A * P - M * I + N * F),
-			A * (A * I - j * F + M * P) - j * (A * F + j * I - N * P) + M * (A * P - M * I + N * F) + N * (j * P + M * F + N * I)
+			T * (T * k - D * j + O * A) - D * (T * j - E * A + D * k) + E * (E * k + D * A + O * j) + O * (T * A + E * j - O * k),
+			T * (T * A + E * j - O * k) + E * (T * j - E * A + D * k) + D * (E * k + D * A + O * j) - O * (T * k - D * j + O * A),
+			T * (T * j - E * A + D * k) - E * (T * A + E * j - O * k) + D * (T * k - D * j + O * A) + O * (E * k + D * A + O * j)
 		];
 	}
-	static rotate(a, k) {
-		let [A, j, M, N] = a, P = [
-			j,
-			M,
-			N
-		], F = Vector3.cross(P, k);
-		F = Vector3.sum(F, F);
-		let I = Vector3.sum(k, Vector3.multiplyScalar(F, A));
-		return Vector3.sum(I, Vector3.cross(P, F));
-	}
-	static inverse(a) {
+	static rotate(e, w) {
+		let [T, E, D, O] = e, k = [
+			E,
+			D,
+			O
+		], A = Vector3.cross(k, w);
+		A = Vector3.sum(A, A);
+		let j = Vector3.sum(w, Vector3.multiplyScalar(A, T));
+		return Vector3.sum(j, Vector3.cross(k, A));
+	}
+	static inverse(e) {
 		return [
-			-a[0],
-			a[1],
-			a[2],
-			a[3]
+			-e[0],
+			e[1],
+			e[2],
+			e[3]
 		];
 	}
-	static multiply(...k) {
-		if (k.length === 2) {
-			let [a, A, j, M] = k[0], [N, P, F, I] = k[1];
+	static multiply(...w) {
+		if (w.length === 2) {
+			let [e, T, E, D] = w[0], [O, k, A, j] = w[1];
 			return [
-				a * N - A * P - j * F - M * I,
-				a * P + N * A + j * I - M * F,
-				a * F + N * j + M * P - A * I,
-				a * I + N * M + A * F - j * P
+				e * O - T * k - E * A - D * j,
+				e * k + O * T + E * j - D * A,
+				e * A + O * E + D * k - T * j,
+				e * j + O * D + T * A - E * k
 			];
 		}
-		return k.reduce((a, k) => this.multiply(a, k), a.identity);
+		return w.reduce((e, w) => this.multiply(e, w), e.identity);
 	}
-	static fromAxisAngle(a, k) {
-		let A = Math.sin(k / 2);
+	static fromAxisAngle(e, w) {
+		let T = Math.sin(w / 2);
 		return [
-			Math.cos(k / 2),
-			a[0] * A,
-			a[1] * A,
-			a[2] * A
+			Math.cos(w / 2),
+			e[0] * T,
+			e[1] * T,
+			e[2] * T
 		];
 	}
-	static rotX(a) {
+	static rotX(e) {
 		return this.fromAxisAngle([
 			1,
 			0,
 			0
-		], a);
+		], e);
 	}
-	static rotY(a) {
+	static rotY(e) {
 		return this.fromAxisAngle([
 			0,
 			1,
 			0
-		], a);
+		], e);
 	}
-	static rotZ(a) {
+	static rotZ(e) {
 		return this.fromAxisAngle([
 			0,
 			0,
 			1
-		], a);
+		], e);
 	}
-	static fromMatrix3(a) {
-		let k = Math.sqrt(1 + a[0][0] + a[1][1] + a[2][2]) / 2;
+	static fromMatrix3(e) {
+		let w = Math.sqrt(1 + e[0][0] + e[1][1] + e[2][2]) / 2;
 		return [
-			k,
-			(a[2][1] - a[1][2]) / (4 * k),
-			(a[0][2] - a[2][0]) / (4 * k),
-			(a[1][0] - a[0][1]) / (4 * k)
+			w,
+			(e[2][1] - e[1][2]) / (4 * w),
+			(e[0][2] - e[2][0]) / (4 * w),
+			(e[1][0] - e[0][1]) / (4 * w)
 		];
 	}
-	static fromMatrix3Matlab(a) {
-		let k = Math.sqrt(1 + a[0][0] + a[1][1] + a[2][2]) / 2;
+	static fromMatrix3Matlab(e) {
+		let w = Math.sqrt(1 + e[0][0] + e[1][1] + e[2][2]) / 2;
 		return [
-			k,
-			(a[1][2] - a[2][1]) / (4 * k),
-			(a[2][0] - a[0][2]) / (4 * k),
-			(a[0][1] - a[1][0]) / (4 * k)
+			w,
+			(e[1][2] - e[2][1]) / (4 * w),
+			(e[2][0] - e[0][2]) / (4 * w),
+			(e[0][1] - e[1][0]) / (4 * w)
 		];
 	}
-	static toMatrix3(a) {
-		let [k, A, j, M] = a, N = k * A, P = k * j, F = k * M, I = A * A, L = A * j, R = A * M, z = j * j, B = j * M, V = M * M;
+	static toMatrix3(e) {
+		let [w, T, E, D] = e, O = w * T, k = w * E, A = w * D, j = T * T, M = T * E, N = T * D, P = E * E, F = E * D, I = D * D;
 		return [
 			[
-				1 - 2 * (z + V),
-				2 * (L - F),
-				2 * (R + P)
+				1 - 2 * (P + I),
+				2 * (M - A),
+				2 * (N + k)
 			],
 			[
-				2 * (L + F),
-				1 - 2 * (I + V),
-				2 * (B - N)
+				2 * (M + A),
+				1 - 2 * (j + I),
+				2 * (F - O)
 			],
 			[
-				2 * (R - P),
-				2 * (B + N),
-				1 - 2 * (I + z)
+				2 * (N - k),
+				2 * (F + O),
+				1 - 2 * (j + P)
 			]
 		];
 	}
-	static wxyz2xyzw(a) {
+	static wxyz2xyzw(e) {
 		return [
-			a[1],
-			a[2],
-			a[3],
-			a[0]
+			e[1],
+			e[2],
+			e[3],
+			e[0]
 		];
 	}
-	static xyzw2wxyz(a) {
+	static xyzw2wxyz(e) {
 		return [
-			a[3],
-			a[0],
-			a[1],
-			a[2]
+			e[3],
+			e[0],
+			e[1],
+			e[2]
 		];
 	}
-	static distance(k, A) {
-		return Math.acos(Math.min(2 * a.dot(k, A) ** 2 - 1, 1));
+	static distance(w, T) {
+		return Math.acos(Math.min(2 * e.dot(w, T) ** 2 - 1, 1));
 	}
-	static equals(k, A) {
-		return a.distance(k, A) < 1e-8;
+	static equals(w, T) {
+		return e.distance(w, T) < 1e-8;
 	}
-	static normalize(a) {
-		let k = this.norm(a), A = [
+	static normalize(e) {
+		let w = this.norm(e), T = [
 			,
 			,
 			,
 			,
 		];
-		for (let j = 0; j < 4; j++) A[j] = a[j] / k;
-		return A;
+		for (let E = 0; E < 4; E++) T[E] = e[E] / w;
+		return T;
 	}
-	static norm(a) {
-		return Math.sqrt(a[0] ** 2 + a[1] ** 2 + a[2] ** 2 + a[3] ** 2);
+	static norm(e) {
+		return Math.sqrt(e[0] ** 2 + e[1] ** 2 + e[2] ** 2 + e[3] ** 2);
 	}
-	static dot(a, k) {
-		return a[0] * k[0] + a[1] * k[1] + a[2] * k[2] + a[3] * k[3];
+	static dot(e, w) {
+		return e[0] * w[0] + e[1] * w[1] + e[2] * w[2] + e[3] * w[3];
 	}
-	static getRotationBetweenTwoVectors(k, A) {
-		let j = Vector3.normalize(k), M = Vector3.normalize(A), N = Vector3.dot(j, M), P;
-		if (N < -.999999) return P = Vector3.cross([
+	static getRotationBetweenTwoVectors(w, T) {
+		let E = Vector3.normalize(w), D = Vector3.normalize(T), O = Vector3.dot(E, D), k;
+		if (O < -.999999) return k = Vector3.cross([
 			1,
 			0,
 			0
-		], j), Vector3.norm(P) < 1e-6 && (P = Vector3.cross([
+		], E), Vector3.norm(k) < 1e-6 && (k = Vector3.cross([
 			0,
 			1,
 			0
-		], j)), P = Vector3.normalize(P), a.fromAxisAngle(P, Math.PI);
-		if (N > .999999) return a.identity;
-		P = Vector3.cross(j, M);
-		let F = [
-			1 + N,
-			P[0],
-			P[1],
-			P[2]
+		], E)), k = Vector3.normalize(k), e.fromAxisAngle(k, Math.PI);
+		if (O > .999999) return e.identity;
+		k = Vector3.cross(E, D);
+		let A = [
+			1 + O,
+			k[0],
+			k[1],
+			k[2]
 		];
-		return a.normalize(F);
+		return e.normalize(A);
 	}
-	static slerp(k, A, j) {
-		let M = k[1], N = k[2], P = k[3], F = k[0], I = A[1], L = A[2], R = A[3], z = A[0], B, V, H;
-		B = M * I + N * L + P * R + F * z, B < 0 && (B = -B, z = -z, I = -I, L = -L, R = -R);
-		let U = 1 - B < 1e-6;
-		if (U) V = 1 - j, H = j;
+	static slerp(w, T, E) {
+		let D = w[1], O = w[2], k = w[3], A = w[0], j = T[1], M = T[2], N = T[3], P = T[0], F, I, L;
+		F = D * j + O * M + k * N + A * P, F < 0 && (F = -F, P = -P, j = -j, M = -M, N = -N);
+		let R = 1 - F < 1e-6;
+		if (R) I = 1 - E, L = E;
 		else {
-			let a = Math.acos(B), k = Math.sin(a);
-			V = Math.sin((1 - j) * a) / k, H = Math.sin(j * a) / k;
+			let e = Math.acos(F), w = Math.sin(e);
+			I = Math.sin((1 - E) * e) / w, L = Math.sin(E * e) / w;
 		}
-		let W = [
-			V * F + H * z,
-			V * M + H * I,
-			V * N + H * L,
-			V * P + H * R
+		let z = [
+			I * A + L * P,
+			I * D + L * j,
+			I * O + L * M,
+			I * k + L * N
 		];
-		return U && (W = a.normalize(W)), W;
-	}
-	static toString(a) {
-		return `[${a[0].toFixed(2)}, ${a[1].toFixed(2)}, ${a[2].toFixed(2)}, ${a[3].toFixed(2)}]`;
-	}
-	static fromUnitVectors(k, A) {
-		let j = Vector3.dot(k, A) + 1, M, N, P, F;
-		j < 2 ** -52 ? (j = 0, Math.abs(k[1]) > Math.abs(k[2]) ? (M = -k[1], N = k[0], P = 0, F = j) : (M = 0, N = -k[2], P = k[1], F = j)) : (M = k[1] * A[2] - k[2] * A[1], N = k[2] * A[0] - k[0] * A[2], P = k[0] * A[1] - k[1] * A[0], F = j);
-		let I = [
-			F,
-			M,
-			N,
-			P
+		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(w, T) {
+		let E = Vector3.dot(w, T) + 1, D, O, k, A;
+		E < 2 ** -52 ? (E = 0, Math.abs(w[1]) > Math.abs(w[2]) ? (D = -w[1], O = w[0], k = 0, A = E) : (D = 0, O = -w[2], k = w[1], A = E)) : (D = w[1] * T[2] - w[2] * T[1], O = w[2] * T[0] - w[0] * T[2], k = w[0] * T[1] - w[1] * T[0], A = E);
+		let j = [
+			A,
+			D,
+			O,
+			k
 		];
-		return a.normalize(I);
+		return e.normalize(j);
 	}
 };
 __publicField(_Quaternion, "ROTX_PI2", _Quaternion.rotX(Math.PI / 2)), __publicField(_Quaternion, "ROTX_PI", _Quaternion.rotX(Math.PI)), __publicField(_Quaternion, "ROTX_MPI2", _Quaternion.rotX(-Math.PI / 2)), __publicField(_Quaternion, "ROTY_PI2", _Quaternion.rotY(Math.PI / 2)), __publicField(_Quaternion, "ROTY_PI", _Quaternion.rotY(Math.PI)), __publicField(_Quaternion, "ROTY_MPI2", _Quaternion.rotY(-Math.PI / 2)), __publicField(_Quaternion, "ROTZ_PI2", _Quaternion.rotZ(Math.PI / 2)), __publicField(_Quaternion, "ROTZ_PI", _Quaternion.rotZ(Math.PI)), __publicField(_Quaternion, "ROTZ_MPI2", _Quaternion.rotZ(-Math.PI / 2));
 var Quaternion = _Quaternion;
-function deg2rad(a) {
-	return a * (Math.PI / 180);
+function deg2rad(e) {
+	return e * (Math.PI / 180);
 }
-function rad2deg(a) {
-	return a * 180 / Math.PI;
+function rad2deg(e) {
+	return e * 180 / Math.PI;
 }
-function positiveMod(a, k) {
-	return (a % k + k) % k;
+function positiveMod(e, w) {
+	return (e % w + w) % w;
 }
-function wrap(a, k, A) {
-	let j = A - k, M = ((a - k) % j + j) % j + k;
-	return M === k ? A : M;
+function wrap(e, w, T) {
+	let E = T - w, D = ((e - w) % E + E) % E + w;
+	return D === w ? T : D;
 }
-var Rotations = class a {
-	static eulerToQuaternionZXYDegrees(k) {
-		let A = k.map((a) => deg2rad(a));
-		return a.eulerToQuaternionZXY(A);
-	}
-	static eulerToQuaternionZXY(a) {
-		let k = a[0], A = a[1], j = a[2], M = Math.cos(k / 2), N = Math.cos(A / 2), P = Math.cos(j / 2), F = Math.sin(k / 2), I = Math.sin(A / 2), L = Math.sin(j / 2), R = M * N * P - F * I * L, z = M * I * P - F * N * L, B = F * I * P + M * N * L, V = F * N * P + M * I * L;
-		return R < 0 && (R = -R, z = -z, B = -B, V = -V), [
-			R,
-			z,
-			B,
-			V
+var Rotations = class e {
+	static eulerToQuaternionZXYDegrees(w) {
+		let T = w.map((e) => deg2rad(e));
+		return e.eulerToQuaternionZXY(T);
+	}
+	static eulerToQuaternionZXY(e) {
+		let w = e[0], T = e[1], E = e[2], D = Math.cos(w / 2), O = Math.cos(T / 2), k = Math.cos(E / 2), A = Math.sin(w / 2), j = Math.sin(T / 2), M = Math.sin(E / 2), N = D * O * k - A * j * M, P = D * j * k - A * O * M, F = A * j * k + D * O * M, I = A * O * k + D * j * M;
+		return N < 0 && (N = -N, P = -P, F = -F, I = -I), [
+			N,
+			P,
+			F,
+			I
 		];
 	}
-	static quaternionToEulerZXYDegrees(k) {
-		return a.quaternionToEulerZXY(k).map((a) => rad2deg(a));
+	static quaternionToEulerZXYDegrees(w) {
+		return e.quaternionToEulerZXY(w).map((e) => rad2deg(e));
 	}
-	static quaternionToEulerZXY(a) {
-		let k = a[0], A = a[1], j = a[2], M = a[3], N, P, F, I = j * M + A * k;
-		return I > .499 ? (N = 2 * Math.atan2(j, k), P = Math.PI / 2, F = 0) : I < -.499 ? (N = -2 * Math.atan2(j, k), P = -Math.PI / 2, F = 0) : (N = Math.atan2(2 * M * k - 2 * j * A, 1 - 2 * M ** 2 - 2 * A ** 2), P = Math.asin(2 * I), F = Math.atan2(2 * j * k - 2 * M * A, 1 - 2 * j ** 2 - 2 * A ** 2)), N %= 2 * Math.PI, P %= Math.PI, F %= 2 * Math.PI, [
-			N,
-			P,
-			F
+	static quaternionToEulerZXY(e) {
+		let w = e[0], T = e[1], E = e[2], D = e[3], O, k, A, j = E * D + T * w;
+		return j > .499 ? (O = 2 * Math.atan2(E, w), k = Math.PI / 2, A = 0) : j < -.499 ? (O = -2 * Math.atan2(E, w), k = -Math.PI / 2, A = 0) : (O = Math.atan2(2 * D * w - 2 * E * T, 1 - 2 * D ** 2 - 2 * T ** 2), k = Math.asin(2 * j), A = Math.atan2(2 * E * w - 2 * D * T, 1 - 2 * E ** 2 - 2 * T ** 2)), O %= 2 * Math.PI, k %= Math.PI, A %= 2 * Math.PI, [
+			O,
+			k,
+			A
 		];
 	}
-	static quaternionToEulerDegrees(k, A) {
-		return a.quaternionToEuler(k, A).map((a) => rad2deg(a));
-	}
-	static quaternionToEuler(k, A) {
-		let j = k[0], M = k[1], N = k[2], P = k[3];
-		switch (A.toLowerCase()) {
-			case "zyx": return a._threeaxisrot(2 * (M * N + j * P), j ** 2 + M ** 2 - N ** 2 - P ** 2, -2 * (M * P - j * N), 2 * (N * P + j * M), j ** 2 - M ** 2 - N ** 2 + P ** 2);
-			case "zyz": return a._twoaxisrot(2 * (N * P - j * M), 2 * (M * P + j * N), j ** 2 - M ** 2 - N ** 2 + P ** 2, 2 * (N * P + j * M), -2 * (M * P - j * N));
-			case "zxy": return a._threeaxisrot(-2 * (M * N - j * P), j ** 2 - M ** 2 + N ** 2 - P ** 2, 2 * (N * P + j * M), -2 * (M * P - j * N), j ** 2 - M ** 2 - N ** 2 + P ** 2);
-			case "zxz": return a._twoaxisrot(2 * (M * P + j * N), -2 * (N * P - j * M), j ** 2 - M ** 2 - N ** 2 + P ** 2, 2 * (M * P - j * N), 2 * (N * P + j * M));
-			case "yxz": return a._threeaxisrot(2 * (M * P + j * N), j ** 2 - M ** 2 - N ** 2 + P ** 2, -2 * (N * P - j * M), 2 * (M * N + j * P), j ** 2 - M ** 2 + N ** 2 - P ** 2);
-			case "yxy": return a._twoaxisrot(2 * (M * N - j * P), 2 * (N * P + j * M), j ** 2 - M ** 2 + N ** 2 - P ** 2, 2 * (M * N + j * P), -2 * (N * P - j * M));
-			case "yzx": return a._threeaxisrot(-2 * (M * P - j * N), j ** 2 + M ** 2 - N ** 2 - P ** 2, 2 * (M * N + j * P), -2 * (N * P - j * M), j ** 2 - M ** 2 + N ** 2 - P ** 2);
-			case "yzy": return a._twoaxisrot(2 * (N * P + j * M), -2 * (M * N - j * P), j ** 2 - M ** 2 + N ** 2 - P ** 2, 2 * (N * P - j * M), 2 * (M * N + j * P));
-			case "xyz": return a._threeaxisrot(-2 * (N * P - j * M), j ** 2 - M ** 2 - N ** 2 + P ** 2, 2 * (M * P + j * N), -2 * (M * N - j * P), j ** 2 + M ** 2 - N ** 2 - P ** 2);
-			case "xyx": return a._twoaxisrot(2 * (M * N + j * P), -2 * (M * P - j * N), j ** 2 + M ** 2 - N ** 2 - P ** 2, 2 * (M * N - j * P), 2 * (M * P + j * N));
-			case "xzy": return a._threeaxisrot(2 * (N * P + j * M), j ** 2 - M ** 2 + N ** 2 - P ** 2, -2 * (M * N - j * P), 2 * (M * P + j * N), j ** 2 + M ** 2 - N ** 2 - P ** 2);
-			case "xzx": return a._twoaxisrot(2 * (M * P - j * N), 2 * (M * N + j * P), j ** 2 + M ** 2 - N ** 2 - P ** 2, 2 * (M * P + j * N), -2 * (M * N - j * P));
+	static quaternionToEulerDegrees(w, T) {
+		return e.quaternionToEuler(w, T).map((e) => rad2deg(e));
+	}
+	static quaternionToEuler(w, T) {
+		let E = w[0], D = w[1], O = w[2], k = w[3];
+		switch (T.toLowerCase()) {
+			case "zyx": return e._threeaxisrot(2 * (D * O + E * k), E ** 2 + D ** 2 - O ** 2 - k ** 2, -2 * (D * k - E * O), 2 * (O * k + E * D), E ** 2 - D ** 2 - O ** 2 + k ** 2);
+			case "zyz": return e._twoaxisrot(2 * (O * k - E * D), 2 * (D * k + E * O), E ** 2 - D ** 2 - O ** 2 + k ** 2, 2 * (O * k + E * D), -2 * (D * k - E * O));
+			case "zxy": return e._threeaxisrot(-2 * (D * O - E * k), E ** 2 - D ** 2 + O ** 2 - k ** 2, 2 * (O * k + E * D), -2 * (D * k - E * O), E ** 2 - D ** 2 - O ** 2 + k ** 2);
+			case "zxz": return e._twoaxisrot(2 * (D * k + E * O), -2 * (O * k - E * D), E ** 2 - D ** 2 - O ** 2 + k ** 2, 2 * (D * k - E * O), 2 * (O * k + E * D));
+			case "yxz": return e._threeaxisrot(2 * (D * k + E * O), E ** 2 - D ** 2 - O ** 2 + k ** 2, -2 * (O * k - E * D), 2 * (D * O + E * k), E ** 2 - D ** 2 + O ** 2 - k ** 2);
+			case "yxy": return e._twoaxisrot(2 * (D * O - E * k), 2 * (O * k + E * D), E ** 2 - D ** 2 + O ** 2 - k ** 2, 2 * (D * O + E * k), -2 * (O * k - E * D));
+			case "yzx": return e._threeaxisrot(-2 * (D * k - E * O), E ** 2 + D ** 2 - O ** 2 - k ** 2, 2 * (D * O + E * k), -2 * (O * k - E * D), E ** 2 - D ** 2 + O ** 2 - k ** 2);
+			case "yzy": return e._twoaxisrot(2 * (O * k + E * D), -2 * (D * O - E * k), E ** 2 - D ** 2 + O ** 2 - k ** 2, 2 * (O * k - E * D), 2 * (D * O + E * k));
+			case "xyz": return e._threeaxisrot(-2 * (O * k - E * D), E ** 2 - D ** 2 - O ** 2 + k ** 2, 2 * (D * k + E * O), -2 * (D * O - E * k), E ** 2 + D ** 2 - O ** 2 - k ** 2);
+			case "xyx": return e._twoaxisrot(2 * (D * O + E * k), -2 * (D * k - E * O), E ** 2 + D ** 2 - O ** 2 - k ** 2, 2 * (D * O - E * k), 2 * (D * k + E * O));
+			case "xzy": return e._threeaxisrot(2 * (O * k + E * D), E ** 2 - D ** 2 + O ** 2 - k ** 2, -2 * (D * O - E * k), 2 * (D * k + E * O), E ** 2 + D ** 2 - O ** 2 - k ** 2);
+			case "xzx": return e._twoaxisrot(2 * (D * k - E * O), 2 * (D * O + E * k), E ** 2 + D ** 2 - O ** 2 - k ** 2, 2 * (D * k + E * O), -2 * (D * O - E * k));
 		}
 		throw Error("unknown order");
 	}
-	static _threeaxisrot(a, k, A, j, M) {
+	static _threeaxisrot(e, w, T, E, D) {
 		return [
-			Math.atan2(a, k),
-			Math.asin(A),
-			Math.atan2(j, M)
+			Math.atan2(e, w),
+			Math.asin(T),
+			Math.atan2(E, D)
 		];
 	}
-	static _twoaxisrot(a, k, A, j, M) {
+	static _twoaxisrot(e, w, T, E, D) {
 		return [
-			Math.atan2(a, k),
-			Math.acos(A),
-			Math.atan2(j, M)
+			Math.atan2(e, w),
+			Math.acos(T),
+			Math.atan2(E, D)
 		];
 	}
-	static getHeadingFromQuaternion(a) {
-		let [k, A, j, M] = a, N = k * A, P = j * M, F = A ** 2;
-		return Math.asin(2 * (N + P)) < Math.PI / 4 && F + j ** 2 < .5 ? -Math.atan2(k * M - A * j, .5 - F - M ** 2) : -Math.atan2(A * M + k * j, N - P);
+	static getHeadingFromQuaternion(e) {
+		let [w, T, E, D] = e, O = w * T, k = E * D, A = T ** 2;
+		return Math.asin(2 * (O + k)) < Math.PI / 4 && A + E ** 2 < .5 ? -Math.atan2(w * D - T * E, .5 - A - D ** 2) : -Math.atan2(T * D + w * E, O - k);
 	}
-}, Level_default = class a {
+}, Level_default = class e {
 	static VERIFY_TYPING = !1;
-	static checkType(a) {
-		if (a !== null && !(typeof a == "number" && !isNaN(a))) {
-			if (Array.isArray(a) && a.length === 2) {
-				let [k, A] = a;
-				if (typeof k == "number" && !isNaN(k) && typeof A == "number" && !isNaN(A)) {
-					if (k > A || k === A) throw Error(`Invalid level range: [${k}, ${A}]`);
+	static checkType(e) {
+		if (e !== null && !(typeof e == "number" && !isNaN(e))) {
+			if (Array.isArray(e) && e.length === 2) {
+				let [w, T] = e;
+				if (typeof w == "number" && !isNaN(w) && typeof T == "number" && !isNaN(T)) {
+					if (w > T || w === T) throw Error(`Invalid level range: [${w}, ${T}]`);
 					return;
 				}
 			}
-			throw Error(`Unknown level format: ${a}`);
+			throw Error(`Unknown level format: ${e}`);
 		}
 	}
-	static isRange(k) {
-		return a.VERIFY_TYPING && a.checkType(k), Array.isArray(k);
+	static isRange(w) {
+		return e.VERIFY_TYPING && e.checkType(w), Array.isArray(w);
 	}
-	static clone(k) {
-		return a.VERIFY_TYPING && a.checkType(k), k === null ? null : typeof k == "number" ? k : [k[0], k[1]];
+	static clone(w) {
+		return e.VERIFY_TYPING && e.checkType(w), w === null ? null : typeof w == "number" ? w : [w[0], w[1]];
 	}
-	static fromString(k) {
-		if (k === null) return null;
-		if (typeof k != "string" || !k.length) throw Error(`argument must be a non empty string, got ${typeof k}`);
-		if (!isNaN(Number(k))) return parseFloat(k);
-		let A = k.split(";");
-		if (A.length > 1) {
-			let k = A.map((a) => Number(a)), j = Math.min(...k), M = Math.max(...k);
-			return a.checkType([j, M]), [j, M];
+	static fromString(w) {
+		if (w === null) return null;
+		if (typeof w != "string" || !w.length) throw Error(`argument must be a non empty string, got ${typeof w}`);
+		if (!isNaN(Number(w))) return parseFloat(w);
+		let T = w.split(";");
+		if (T.length > 1) {
+			let w = T.map((e) => Number(e)), E = Math.min(...w), D = Math.max(...w);
+			return e.checkType([E, D]), [E, D];
 		} else {
-			let A = k.substring(1).indexOf("-") + 1;
-			if (A > 0) {
-				let j = Number(k.substring(0, A)), M = Number(k.substring(A + 1));
-				return a.checkType([j, M]), [j, M];
+			let T = w.substring(1).indexOf("-") + 1;
+			if (T > 0) {
+				let E = Number(w.substring(0, T)), D = Number(w.substring(T + 1));
+				return e.checkType([E, D]), [E, D];
 			}
 		}
-		throw Error(`Cannot parse following level: ${k}`);
+		throw Error(`Cannot parse following level: ${w}`);
 	}
-	static contains(k, A) {
-		return a.VERIFY_TYPING && (a.checkType(k), a.checkType(A)), k === A ? !0 : Array.isArray(k) ? Array.isArray(A) ? k[0] <= A[0] && k[1] >= A[1] : A === null ? !1 : k[0] <= A && k[1] >= A : k === null || A === null ? !1 : k <= A[0] && k >= A[1];
+	static contains(w, T) {
+		return e.VERIFY_TYPING && (e.checkType(w), e.checkType(T)), w === T ? !0 : Array.isArray(w) ? Array.isArray(T) ? w[0] <= T[0] && w[1] >= T[1] : T === null ? !1 : w[0] <= T && w[1] >= T : w === null || T === null ? !1 : w <= T[0] && w >= T[1];
 	}
-	static intersection(k, A) {
-		if (a.VERIFY_TYPING && (a.checkType(k), a.checkType(A)), k === null || A === null) return null;
-		if (a.equals(k, A)) return a.clone(k);
-		if (typeof k == "number" && typeof A == "number") return k === A ? k : null;
-		if (Array.isArray(k) && !Array.isArray(A)) return a.contains(k, A) ? A : null;
-		if (!Array.isArray(k) && Array.isArray(A)) return a.contains(A, k) ? k : null;
-		let j = Math.max(k[0], A[0]), M = Math.min(k[1], A[1]);
-		return M === j ? M : M < j ? null : [j, M];
+	static intersection(w, T) {
+		if (e.VERIFY_TYPING && (e.checkType(w), e.checkType(T)), w === null || T === null) return null;
+		if (e.equals(w, T)) return e.clone(w);
+		if (typeof w == "number" && typeof T == "number") return w === T ? w : null;
+		if (Array.isArray(w) && !Array.isArray(T)) return e.contains(w, T) ? T : null;
+		if (!Array.isArray(w) && Array.isArray(T)) return e.contains(T, w) ? w : null;
+		let E = Math.max(w[0], T[0]), D = Math.min(w[1], T[1]);
+		return D === E ? D : D < E ? null : [E, D];
 	}
-	static intersect(k, A) {
-		return a.VERIFY_TYPING && (a.checkType(k), a.checkType(A)), k === null && A === null ? !0 : a.intersection(k, A) !== null;
+	static intersect(w, T) {
+		return e.VERIFY_TYPING && (e.checkType(w), e.checkType(T)), w === null && T === null ? !0 : e.intersection(w, T) !== null;
 	}
-	static union(k, A) {
-		if (a.VERIFY_TYPING && (a.checkType(k), a.checkType(A)), k === A) return a.clone(k);
-		if (A === null || k === null) return null;
-		let j, M;
-		return !Array.isArray(k) && !Array.isArray(A) ? (j = Math.min(k, A), M = Math.max(k, A)) : Array.isArray(k) && !Array.isArray(A) ? (j = Math.min(k[0], A), M = Math.max(k[1], A)) : !Array.isArray(k) && Array.isArray(A) ? (j = Math.min(A[0], k), M = Math.max(A[1], k)) : (j = Math.min(k[0], A[0]), M = Math.max(k[1], A[1])), j === M ? j : [j, M];
+	static union(w, T) {
+		if (e.VERIFY_TYPING && (e.checkType(w), e.checkType(T)), w === T) return e.clone(w);
+		if (T === null || w === null) return null;
+		let E, D;
+		return !Array.isArray(w) && !Array.isArray(T) ? (E = Math.min(w, T), D = Math.max(w, T)) : Array.isArray(w) && !Array.isArray(T) ? (E = Math.min(w[0], T), D = Math.max(w[1], T)) : !Array.isArray(w) && Array.isArray(T) ? (E = Math.min(T[0], w), D = Math.max(T[1], w)) : (E = Math.min(w[0], T[0]), D = Math.max(w[1], T[1])), E === D ? E : [E, D];
 	}
-	static multiplyBy(k, A) {
-		return a.VERIFY_TYPING && a.checkType(k), k === null ? null : Array.isArray(k) ? [k[0] * A, k[1] * A] : k * A;
+	static multiplyBy(w, T) {
+		return e.VERIFY_TYPING && e.checkType(w), w === null ? null : Array.isArray(w) ? [w[0] * T, w[1] * T] : w * T;
 	}
-	static toString(k) {
-		return a.VERIFY_TYPING && a.checkType(k), k === null ? null : Array.isArray(k) ? k[0] + ";" + k[1] : String(k);
+	static toString(w) {
+		return e.VERIFY_TYPING && e.checkType(w), w === null ? null : Array.isArray(w) ? w[0] + ";" + w[1] : String(w);
 	}
-	static equals(k, A) {
-		return a.VERIFY_TYPING && (a.checkType(k), a.checkType(A)), k === A ? !0 : Array.isArray(k) && Array.isArray(A) ? k[0] === A[0] && k[1] === A[1] : !1;
+	static equals(w, T) {
+		return e.VERIFY_TYPING && (e.checkType(w), e.checkType(T)), w === T ? !0 : Array.isArray(w) && Array.isArray(T) ? w[0] === T[0] && w[1] === T[1] : !1;
 	}
-	static diff(k, A) {
-		return a.VERIFY_TYPING && (a.checkType(k), a.checkType(A)), k === null || A === null ? null : !Array.isArray(k) && !Array.isArray(A) ? A - k : Array.isArray(k) && !Array.isArray(A) ? k[0] === A ? A - k[1] : k[1] === A ? A - k[0] : null : Array.isArray(A) && !Array.isArray(k) ? k === A[0] ? A[1] - k : k === A[1] ? A[0] - k : null : a.equals(k, A) ? 0 : null;
+	static diff(w, T) {
+		return e.VERIFY_TYPING && (e.checkType(w), e.checkType(T)), w === null || T === null ? null : !Array.isArray(w) && !Array.isArray(T) ? T - w : Array.isArray(w) && !Array.isArray(T) ? w[0] === T ? T - w[1] : w[1] === T ? T - w[0] : null : Array.isArray(T) && !Array.isArray(w) ? w === T[0] ? T[1] - w : w === T[1] ? T[0] - w : null : e.equals(w, T) ? 0 : null;
 	}
-}, Coordinates_default = class a {
+}, Coordinates_default = class e {
 	_lat;
 	_lng;
 	_alt = null;
@@ -452,156 +452,156 @@ var Rotations = class a {
 	_heightFromGround = null;
 	_ecef;
 	autoWrap = !0;
-	constructor(a, k, A = null, j = null) {
-		this.lat = a, this.lng = k, this.alt = A, this.level = j, this._ecef = null;
+	constructor(e, w, T = null, E = null) {
+		this.lat = e, this.lng = w, this.alt = T, this.level = E, this._ecef = null;
 	}
 	get lat() {
 		return this._lat;
 	}
-	set lat(a) {
-		if (Math.abs(a) <= 90) this._lat = a;
-		else throw Error(`lat argument is not in [-90; 90], value is ${a}`);
+	set lat(e) {
+		if (Math.abs(e) <= 90) this._lat = e;
+		else throw Error(`lat argument is not in [-90; 90], value is ${e}`);
 		this._ecef = null;
 	}
 	get latitude() {
 		return this._lat;
 	}
-	set latitude(a) {
+	set latitude(e) {
 		throw Error("Please use Coordinates#lat setter instead of Coordinate#latitude");
 	}
 	get lng() {
 		return this._lng;
 	}
-	set lng(a) {
-		this._lng = a, this.autoWrap && this.wrap(), this._ecef = null;
+	set lng(e) {
+		this._lng = e, this.autoWrap && this.wrap(), this._ecef = null;
 	}
 	get longitude() {
 		return this._lng;
 	}
-	set longitude(a) {
+	set longitude(e) {
 		throw Error("Please use Coordinates#lng setter instead of Coordinate#longitude");
 	}
 	get alt() {
 		return this._alt;
 	}
-	set alt(a) {
-		this._alt = a, this._ecef = null;
+	set alt(e) {
+		this._alt = e, this._ecef = null;
 	}
 	get level() {
 		return this._level;
 	}
-	set level(a) {
-		Level_default.checkType(a), this._level = a;
+	set level(e) {
+		Level_default.checkType(e), this._level = e;
 	}
 	get heightFromFloor() {
 		return this._heightFromFloor;
 	}
-	set heightFromFloor(a) {
-		this._heightFromFloor = a;
+	set heightFromFloor(e) {
+		this._heightFromFloor = e;
 	}
 	get heightFromGround() {
 		return this._heightFromGround;
 	}
-	set heightFromGround(a) {
-		this._heightFromGround = a;
+	set heightFromGround(e) {
+		this._heightFromGround = e;
 	}
 	clone() {
-		let k = new a(this.lat, this.lng, this.alt);
-		return this.level !== null && (k.level = Level_default.clone(this.level)), k;
+		let w = new e(this.lat, this.lng, this.alt);
+		return this.level !== null && (w.level = Level_default.clone(this.level)), w;
 	}
 	wrap() {
 		(this._lng <= -180 || this._lng > 180) && (this._lng = wrap(this._lng, -180, 180));
 	}
-	static equals(a, k, A = EPS_DEG_MM, j = EPS_MM) {
-		return this.equalsWithoutLevel(a, k, A, j) ? a === null || k === null ? !0 : Level_default.equals(a.level, k.level) : !1;
+	static equals(e, w, T = EPS_DEG_MM, E = EPS_MM) {
+		return this.equalsWithoutLevel(e, w, T, E) ? e === null || w === null ? !0 : Level_default.equals(e.level, w.level) : !1;
 	}
-	equals(k) {
-		return a.equals(this, k);
+	equals(w) {
+		return e.equals(this, w);
 	}
-	static equalsWithoutLevel(k, A, j = EPS_DEG_MM, M = EPS_MM) {
-		return k === null && k === A ? !0 : !(k instanceof a) || !(A instanceof a) ? !1 : Math.abs(A.lat - k.lat) < j && Math.abs(A.lng - k.lng) < j && (k.alt === A.alt || k.alt !== null && A.alt !== null && Math.abs(A.alt - k.alt) < M);
+	static equalsWithoutLevel(w, T, E = EPS_DEG_MM, D = EPS_MM) {
+		return w === null && w === T ? !0 : !(w instanceof e) || !(T instanceof e) ? !1 : Math.abs(T.lat - w.lat) < E && Math.abs(T.lng - w.lng) < E && (w.alt === T.alt || w.alt !== null && T.alt !== null && Math.abs(T.alt - w.alt) < D);
 	}
-	equalsWithoutLevel(k, A = EPS_DEG_MM, j = EPS_MM) {
-		return a.equalsWithoutLevel(this, k, A, j);
+	equalsWithoutLevel(w, T = EPS_DEG_MM, E = EPS_MM) {
+		return e.equalsWithoutLevel(this, w, T, E);
 	}
-	destinationPoint(a, k, A = null) {
-		let j = this.clone();
-		return j.move(a, k, A), j;
+	destinationPoint(e, w, T = null) {
+		let E = this.clone();
+		return E.move(e, w, T), E;
 	}
-	move(a, k, A = null) {
-		let j = a / R_MAJOR, N = Math.cos(j), P = Math.sin(j), F = deg2rad(this.lat), I = deg2rad(this.lng), L = Math.asin(Math.sin(F) * N + Math.cos(F) * P * Math.cos(k)), R = I + Math.atan2(Math.sin(k) * P * Math.cos(F), N - Math.sin(F) * Math.sin(L));
-		if (this.lat = rad2deg(L), this.lng = rad2deg(R), A !== null) {
+	move(e, w, T = null) {
+		let E = e / R_MAJOR, O = Math.cos(E), k = Math.sin(E), A = deg2rad(this.lat), j = deg2rad(this.lng), M = Math.asin(Math.sin(A) * O + Math.cos(A) * k * Math.cos(w)), N = j + Math.atan2(Math.sin(w) * k * Math.cos(A), O - Math.sin(A) * Math.sin(M));
+		if (this.lat = rad2deg(M), this.lng = rad2deg(N), T !== null) {
 			if (this.alt === null) throw Error("Point altitude is not defined");
-			this.alt += A;
+			this.alt += T;
 		}
 		return this;
 	}
-	distanceTo(a) {
-		let k = this.lat, A = this.lng, j = a.lat, N = a.lng, P = deg2rad(j - k), F = deg2rad(N - A), I = Math.sin(F / 2), L = Math.sin(P / 2), R = deg2rad(k), z = Math.cos(R), B = deg2rad(j), V = Math.cos(B), H = L * L + z * V * I * I, U = Math.sqrt(H), W = Math.sqrt(1 - H);
-		return R_MAJOR * (2 * Math.atan2(U, W));
+	distanceTo(e) {
+		let w = this.lat, T = this.lng, E = e.lat, O = e.lng, k = deg2rad(E - w), A = deg2rad(O - T), j = Math.sin(A / 2), M = Math.sin(k / 2), N = deg2rad(w), P = Math.cos(N), F = deg2rad(E), I = Math.cos(F), L = M * M + P * I * j * j, R = Math.sqrt(L), z = Math.sqrt(1 - L);
+		return R_MAJOR * (2 * Math.atan2(R, z));
 	}
-	static distanceBetween(a, k) {
-		return a.distanceTo(k);
+	static distanceBetween(e, w) {
+		return e.distanceTo(w);
 	}
-	bearingTo(a) {
-		let k = deg2rad(this.lat), A = deg2rad(a.lat), j = deg2rad(a.lng - this.lng);
-		return Math.atan2(Math.sin(j) * Math.cos(A), Math.cos(k) * Math.sin(A) - Math.sin(k) * Math.cos(A) * Math.cos(j));
+	bearingTo(e) {
+		let w = deg2rad(this.lat), T = deg2rad(e.lat), E = deg2rad(e.lng - this.lng);
+		return Math.atan2(Math.sin(E) * Math.cos(T), Math.cos(w) * Math.sin(T) - Math.sin(w) * Math.cos(T) * Math.cos(E));
 	}
-	static bearingTo(a, k) {
-		return a.bearingTo(k);
+	static bearingTo(e, w) {
+		return e.bearingTo(w);
 	}
 	get enuToEcefRotation() {
-		let a = Quaternion.fromAxisAngle([
+		let e = Quaternion.fromAxisAngle([
 			0,
 			0,
 			1
-		], Math.PI / 2 + deg2rad(this.lng)), k = Quaternion.fromAxisAngle([
+		], Math.PI / 2 + deg2rad(this.lng)), w = Quaternion.fromAxisAngle([
 			1,
 			0,
 			0
 		], Math.PI / 2 - deg2rad(this.lat));
-		return Quaternion.multiply(a, k);
+		return Quaternion.multiply(e, w);
 	}
 	get ecefToEnuRotation() {
-		let a = Quaternion.fromAxisAngle([
+		let e = Quaternion.fromAxisAngle([
 			1,
 			0,
 			0
-		], deg2rad(this.lat) - Math.PI / 2), k = Quaternion.fromAxisAngle([
+		], deg2rad(this.lat) - Math.PI / 2), w = Quaternion.fromAxisAngle([
 			0,
 			0,
 			1
 		], -deg2rad(this.lng) - Math.PI / 2);
-		return Quaternion.multiply(a, k);
+		return Quaternion.multiply(e, w);
 	}
 	get ecef() {
 		if (!this._ecef) {
-			let a = deg2rad(this.lat), k = deg2rad(this.lng), A = this.alt || 0;
+			let e = deg2rad(this.lat), w = deg2rad(this.lng), T = this.alt || 0;
 			this._ecef = [
-				(R_MAJOR + A) * Math.cos(a) * Math.cos(k),
-				(R_MAJOR + A) * Math.cos(a) * Math.sin(k),
-				(R_MAJOR + A) * Math.sin(a)
+				(R_MAJOR + T) * Math.cos(e) * Math.cos(w),
+				(R_MAJOR + T) * Math.cos(e) * Math.sin(w),
+				(R_MAJOR + T) * Math.sin(e)
 			];
 		}
 		return this._ecef;
 	}
-	static fromECEF(k) {
-		let A = k[0], j = k[1], N = k[2], P = Math.sqrt(A ** 2 + j ** 2), F = Math.atan2(j, A), I = Math.atan2(N, P), L = P / Math.cos(I) - R_MAJOR;
-		F %= 2 * Math.PI;
-		let R = new a(rad2deg(I), rad2deg(F), L);
-		return R._ecef = k, R;
+	static fromECEF(w) {
+		let T = w[0], E = w[1], O = w[2], k = Math.sqrt(T ** 2 + E ** 2), A = Math.atan2(E, T), j = Math.atan2(O, k), M = k / Math.cos(j) - R_MAJOR;
+		A %= 2 * Math.PI;
+		let N = new e(rad2deg(j), rad2deg(A), M);
+		return N._ecef = w, N;
 	}
-	getSegmentProjection(k, A) {
-		let j = Vector3.normalize(k.ecef), N = Vector3.normalize(A.ecef), P = Vector3.normalize(this.ecef), F = Vector3.cross(j, N);
-		if (Vector3.norm(F) === 0) return null;
-		let I = Vector3.cross(P, F), L = Vector3.normalize(Vector3.cross(F, I)), R = Vector3.multiplyScalar(L, R_MAJOR), z = a.fromECEF(R), B;
-		k.alt !== null && A.alt !== null && (B = (k.alt + A.alt) / 2);
-		let V = new a(z.lat, z.lng, B, Level_default.union(k.level, A.level));
-		return Math.abs(k.distanceTo(A) - k.distanceTo(V) - A.distanceTo(V)) > .001 ? null : V;
+	getSegmentProjection(w, T) {
+		let E = Vector3.normalize(w.ecef), O = Vector3.normalize(T.ecef), k = Vector3.normalize(this.ecef), A = Vector3.cross(E, O);
+		if (Vector3.norm(A) === 0) return null;
+		let j = Vector3.cross(k, A), M = Vector3.normalize(Vector3.cross(A, j)), N = Vector3.multiplyScalar(M, R_MAJOR), P = e.fromECEF(N), F;
+		w.alt !== null && T.alt !== null && (F = (w.alt + T.alt) / 2);
+		let I = new e(P.lat, P.lng, F, Level_default.union(w.level, T.level));
+		return Math.abs(w.distanceTo(T) - w.distanceTo(I) - T.distanceTo(I)) > .001 ? null : I;
 	}
 	toString() {
-		let a = "[" + this._lat.toFixed(7) + ", " + this._lng.toFixed(7);
-		return this._alt !== null && (a += ", " + this._alt.toFixed(2)), this._level !== null && (a += ", [" + Level_default.toString(this._level) + "]"), a += "]", a;
+		let e = "[" + this._lat.toFixed(7) + ", " + this._lng.toFixed(7);
+		return this._alt !== null && (e += ", " + this._alt.toFixed(2)), this._level !== null && (e += ", [" + Level_default.toString(this._level) + "]"), e += "]", e;
 	}
 	toJson() {
 		return {
@@ -611,8 +611,8 @@ var Rotations = class a {
 			...this.level !== null && { level: this.level }
 		};
 	}
-	static fromJson(k) {
-		return new a(k.lat, k.lng, k.alt, k.level);
+	static fromJson(w) {
+		return new e(w.lat, w.lng, w.alt, w.level);
 	}
 	toCompressedJson() {
 		return this.level === null ? [Number(this.lat.toFixed(8)), Number(this.lng.toFixed(8))] : [
@@ -621,55 +621,55 @@ var Rotations = class a {
 			this.level
 		];
 	}
-	static fromCompressedJson(k) {
-		let A = new a(k[0], k[1]);
-		return k.length > 2 && (A.level = k[2]), A;
+	static fromCompressedJson(w) {
+		let T = new e(w[0], w[1]);
+		return w.length > 2 && (T.level = w[2]), T;
 	}
-}, UserPosition_default = class a extends Coordinates_default {
+}, UserPosition_default = class e extends Coordinates_default {
 	_time = null;
 	_accuracy = null;
 	_bearing = null;
-	constructor(a, k, A = null, j = null, M = null, N = null, P = null) {
-		super(a, k, A, j), this.time = M, this.accuracy = N, this.bearing = P;
+	constructor(e, w, T = null, E = null, D = null, O = null, k = null) {
+		super(e, w, T, E), this.time = D, this.accuracy = O, this.bearing = k;
 	}
 	get time() {
 		return this._time;
 	}
-	set time(a) {
-		this._time = a;
+	set time(e) {
+		this._time = e;
 	}
 	get accuracy() {
 		return this._accuracy;
 	}
-	set accuracy(a) {
-		if (a !== null && a < 0) throw Error("accuracy argument is not a positive number");
-		this._accuracy = a;
+	set accuracy(e) {
+		if (e !== null && e < 0) throw Error("accuracy argument is not a positive number");
+		this._accuracy = e;
 	}
 	get bearing() {
 		return this._bearing;
 	}
-	set bearing(a) {
-		this._bearing = a === null ? null : a % (2 * Math.PI);
+	set bearing(e) {
+		this._bearing = e === null ? null : e % (2 * Math.PI);
 	}
-	move(a, k, A = null) {
-		return super.move(a, k, A), this;
+	move(e, w, T = null) {
+		return super.move(e, w, T), this;
 	}
-	destinationPoint(a, k, A = null) {
-		let j = this.clone();
-		return j.move(a, k, A), j;
+	destinationPoint(e, w, T = null) {
+		let E = this.clone();
+		return E.move(e, w, T), E;
 	}
-	static fromCoordinates(k) {
-		return new a(k.lat, k.lng, k.alt, k.level);
+	static fromCoordinates(w) {
+		return new e(w.lat, w.lng, w.alt, w.level);
 	}
 	clone() {
-		let k = a.fromCoordinates(super.clone());
-		return k.time = this.time, k.accuracy = this.accuracy, k.bearing = this.bearing, k;
+		let w = e.fromCoordinates(super.clone());
+		return w.time = this.time, w.accuracy = this.accuracy, w.bearing = this.bearing, w;
 	}
-	static equals(k, A, j = EPS_DEG_MM, M = EPS_MM) {
-		return k === null && k === A ? !0 : !(k instanceof a) || !(A instanceof a) || !super.equals(k, A, j, M) ? !1 : k.time === A.time && k.accuracy === A.accuracy && k.bearing === A.bearing;
+	static equals(w, T, E = EPS_DEG_MM, D = EPS_MM) {
+		return w === null && w === T ? !0 : !(w instanceof e) || !(T instanceof e) || !super.equals(w, T, E, D) ? !1 : w.time === T.time && w.accuracy === T.accuracy && w.bearing === T.bearing;
 	}
-	equals(k, A = EPS_DEG_MM, j = EPS_MM) {
-		return a.equals(this, k, A, j);
+	equals(w, T = EPS_DEG_MM, E = EPS_MM) {
+		return e.equals(this, w, T, E);
 	}
 	toJson() {
 		return {
@@ -679,114 +679,124 @@ var Rotations = class a {
 			...this.bearing !== null && { bearing: this.bearing }
 		};
 	}
-	static fromJson(k) {
-		let A = a.fromCoordinates(Coordinates_default.fromJson(k));
-		return k.time !== void 0 && (A.time = k.time), k.accuracy !== void 0 && (A.accuracy = k.accuracy), k.bearing !== void 0 && (A.bearing = k.bearing), A;
+	static fromJson(w) {
+		let T = e.fromCoordinates(Coordinates_default.fromJson(w));
+		return w.time !== void 0 && (T.time = w.time), w.accuracy !== void 0 && (T.accuracy = w.accuracy), w.bearing !== void 0 && (T.bearing = w.bearing), T;
 	}
 }, Utils_exports = /* @__PURE__ */ __export({
 	calcDistance: () => calcDistance,
 	createSegmentsAtLevel: () => createSegmentsAtLevel,
 	geolocationPositionToUserPosition: () => geolocationPositionToUserPosition,
 	sampleRoute: () => sampleRoute,
+	segmentIntersection: () => segmentIntersection,
 	simplifyRoute: () => simplifyRoute,
 	trimRoute: () => trimRoute
 });
-function sampleRoute(a, k = .7, A = 0, j = Number.MAX_VALUE) {
-	let M = A + j, N = [], P, F = 0, I = 0, L = !1;
-	for (let j = 0; j < a.length - 1; j++) {
-		let R = a[j], z = a[j + 1], B = R.distanceTo(z), V = R.bearingTo(z), H = 0;
-		if (!L) if (A < F + B) L = !0, I = A - F;
+function sampleRoute(e, w = .7, T = 0, E = Number.MAX_VALUE) {
+	let D = T + E, O = [], k, A = 0, j = 0, M = !1;
+	for (let E = 0; E < e.length - 1; E++) {
+		let N = e[E], P = e[E + 1], F = N.distanceTo(P), I = N.bearingTo(P), L = 0;
+		if (!M) if (T < A + F) M = !0, j = T - A;
 		else {
-			F += B;
+			A += F;
 			continue;
 		}
-		for (P = Object.assign(R.clone(), { bearing: V }); H + I < B && F + I <= M;) {
-			let a = P.destinationPoint(I, V);
-			a.bearing = V, N.push(a), P = a, H += I, F += I, I = k;
+		for (k = Object.assign(N.clone(), { bearing: I }); L + j < F && A + j <= D;) {
+			let e = k.destinationPoint(j, I);
+			e.bearing = I, O.push(e), k = e, L += j, A += j, j = w;
 		}
-		if (F + I > M) break;
-		let U = B - H;
-		F += U, I -= U;
+		if (A + j > D) break;
+		let R = F - L;
+		A += R, j -= R;
 	}
-	return N;
+	return O;
 }
-function trimRoute(a, k = a[0], A = Number.MAX_VALUE) {
-	let j = [], M = null, N, P = 0;
-	if (a.length <= 1) throw Error("Route must have at least 2 points");
-	for (N = 1; N < a.length; N++) {
-		let A = a[N - 1], P = a[N];
-		if (Coordinates_default.equals(k, A)) {
-			j.push(A), M = A;
+function trimRoute(e, w = e[0], T = Number.MAX_VALUE) {
+	let E = [], D = null, O, k = 0;
+	if (e.length <= 1) throw Error("Route must have at least 2 points");
+	for (O = 1; O < e.length; O++) {
+		let T = e[O - 1], k = e[O];
+		if (Coordinates_default.equals(w, T)) {
+			E.push(T), D = T;
 			break;
 		}
-		let F = k.getSegmentProjection(A, P);
-		if (F && Coordinates_default.equals(k, F) && !F.equals(P)) {
-			j.push(F), M = F;
+		let A = w.getSegmentProjection(T, k);
+		if (A && Coordinates_default.equals(w, A) && !A.equals(k)) {
+			E.push(A), D = A;
 			break;
 		}
 	}
-	if (!j.length) throw Error("startPosition is not on the route");
-	for (; M && N < a.length;) {
-		let k = a[N], F = M.distanceTo(k);
-		if (P + F >= A || Math.abs(P + F - A) <= .001) {
-			let a = M.bearingTo(k), N = A - P, F = M.destinationPoint(N, a);
-			j.push(F);
+	if (!E.length) throw Error("startPosition is not on the route");
+	for (; D && O < e.length;) {
+		let w = e[O], A = D.distanceTo(w);
+		if (k + A >= T || Math.abs(k + A - T) <= .001) {
+			let e = D.bearingTo(w), O = T - k, A = D.destinationPoint(O, e);
+			E.push(A);
 			break;
 		}
-		j.push(k), M = k, P += F, N++;
+		E.push(w), D = w, k += A, O++;
 	}
-	return j;
+	return E;
 }
-function simplifyRoute(a, k = deg2rad(5)) {
-	let A = a[0].equals(a[a.length - 1]), j = a.slice(0, a.length - (A ? 1 : 0)), M = j.length;
-	for (let N = A ? 0 : 1; N < M; N++) {
-		let A = a[positiveMod(N - 1, M)], P = a[N], F = a[positiveMod(N + 1, M)], I = A.bearingTo(P), L = P.bearingTo(F);
-		Math.abs(L - I) < k && (j = j.filter((a) => a !== P));
+function simplifyRoute(e, w = deg2rad(5)) {
+	let T = e[0].equals(e[e.length - 1]), E = e.slice(0, e.length - (T ? 1 : 0)), D = E.length;
+	for (let O = T ? 0 : 1; O < D; O++) {
+		let T = e[positiveMod(O - 1, D)], k = e[O], A = e[positiveMod(O + 1, D)], j = T.bearingTo(k), M = k.bearingTo(A);
+		Math.abs(M - j) < w && (E = E.filter((e) => e !== k));
 	}
-	return A && j.push(j[0]), j;
+	return T && E.push(E[0]), E;
 }
-function geolocationPositionToUserPosition(a) {
-	if (a === null) return null;
-	let { latitude: k, longitude: A, accuracy: j, heading: M } = a.coords, N = new UserPosition_default(k, A);
-	return N.time = a.timestamp, N.accuracy = j, N.bearing = M ? deg2rad(M) : null, N;
+function geolocationPositionToUserPosition(e) {
+	if (e === null) return null;
+	let { latitude: w, longitude: T, accuracy: E, heading: D } = e.coords, O = new UserPosition_default(w, T);
+	return O.time = e.timestamp, O.accuracy = E, O.bearing = D ? deg2rad(D) : null, O;
 }
-function calcDistance(a) {
-	return a.reduce((a, k, A, j) => a + (A ? j[A - 1].distanceTo(k) : 0), 0);
+function calcDistance(e) {
+	return e.reduce((e, w, T, E) => e + (T ? E[T - 1].distanceTo(w) : 0), 0);
 }
-function createSegmentsAtLevel(a, k, A = !0) {
-	let j = a.length, M = !1, N = [], P = [];
-	for (let F = 0; F < j; F++) {
-		let j = a[F], I = Level_default.intersect(k, j.level);
-		A && !I && M ? P.push(j) : I && (M || (P = [], N.push(P), A && F !== 0 && P.push(a[F - 1])), P.push(j)), M = I;
+function createSegmentsAtLevel(e, w, T = !0) {
+	let E = e.length, D = !1, O = [], k = [];
+	for (let A = 0; A < E; A++) {
+		let E = e[A], j = Level_default.intersect(w, E.level);
+		T && !j && D ? k.push(E) : j && (D || (k = [], O.push(k), T && A !== 0 && k.push(e[A - 1])), k.push(E)), D = j;
 	}
-	return N;
+	return O;
+}
+function segmentIntersection(e, w, T, E) {
+	let O = (e) => e * Math.PI / 180, k = (e.lat + w.lat + T.lat + E.lat) / 4, A = R_MAJOR * 180 / Math.PI, j = R_MAJOR * 180 / Math.PI * Math.cos(O(k)), M = (e) => ({
+		x: e.lng * j,
+		y: e.lat * A
+	}), N = M(e), P = M(w), F = M(T), I = M(E), L = P.x - N.x, R = P.y - N.y, z = I.x - F.x, B = I.y - F.y, V = L * B - R * z;
+	if (Math.abs(V) < 1e-10) return null;
+	let H = F.x - N.x, U = F.y - N.y, W = (H * B - U * z) / V, G = (H * R - U * L) / V;
+	return W < 0 || W > 1 || G < 0 || G > 1 ? null : new Coordinates_default((N.y + W * R) / A, (N.x + W * L) / j);
 }
-var BoundingBox_default = class a {
+var BoundingBox_default = class e {
 	northEast;
 	southWest;
-	constructor(a, k) {
-		if (this.northEast = a, this.southWest = k, this.northEast && this.southWest && this.getNorth() < this.getSouth()) throw Error("Incorrect bounding box");
+	constructor(e, w) {
+		if (this.northEast = e, this.southWest = w, this.northEast && this.southWest && this.getNorth() < this.getSouth()) throw Error("Incorrect bounding box");
 	}
 	get center() {
 		return new Coordinates_default((this.southWest.lat + this.northEast.lat) / 2, (this.northEast.lng + this.southWest.lng) / 2);
 	}
-	contains(a) {
-		return a.lat <= this.northEast.lat && a.lat >= this.southWest.lat && a.lng <= this.northEast.lng && a.lng >= this.southWest.lng;
+	contains(e) {
+		return e.lat <= this.northEast.lat && e.lat >= this.southWest.lat && e.lng <= this.northEast.lng && e.lng >= this.southWest.lng;
 	}
-	extend(k) {
-		let A = this.southWest, j = this.northEast, M, N;
-		if (k instanceof Coordinates_default) M = k, N = k;
-		else if (k instanceof a) M = k.southWest, N = k.northEast;
+	extend(w) {
+		let T = this.southWest, E = this.northEast, D, O;
+		if (w instanceof Coordinates_default) D = w, O = w;
+		else if (w instanceof e) D = w.southWest, O = w.northEast;
 		else throw Error("Unknown parameter");
-		return this.southWest = new Coordinates_default(Math.min(M.lat, A.lat), Math.min(M.lng, A.lng)), this.northEast = new Coordinates_default(Math.max(N.lat, j.lat), Math.max(N.lng, j.lng)), this;
+		return this.southWest = new Coordinates_default(Math.min(D.lat, T.lat), Math.min(D.lng, T.lng)), this.northEast = new Coordinates_default(Math.max(O.lat, E.lat), Math.max(O.lng, E.lng)), this;
 	}
-	extendsWithMeasure(a) {
-		if (typeof a != "number") throw Error("measure is not a number");
-		return this.northEast = this.northEast.destinationPoint(a, 0).move(a, Math.PI / 2), this.southWest = this.southWest.clone().destinationPoint(a, -Math.PI / 2).destinationPoint(a, Math.PI), this;
+	extendsWithMeasure(e) {
+		if (typeof e != "number") throw Error("measure is not a number");
+		return this.northEast = this.northEast.destinationPoint(e, 0).move(e, Math.PI / 2), this.southWest = this.southWest.clone().destinationPoint(e, -Math.PI / 2).destinationPoint(e, Math.PI), this;
 	}
-	pad(a) {
-		let k = this.southWest, A = this.northEast, j = Math.abs(k.lat - A.lat) * a, M = Math.abs(k.lng - A.lng) * a;
-		return this.southWest = new Coordinates_default(k.lat - j, k.lng - M), this.northEast = new Coordinates_default(A.lat + j, A.lng + M), this;
+	pad(e) {
+		let w = this.southWest, T = this.northEast, E = Math.abs(w.lat - T.lat) * e, D = Math.abs(w.lng - T.lng) * e;
+		return this.southWest = new Coordinates_default(w.lat - E, w.lng - D), this.northEast = new Coordinates_default(T.lat + E, T.lng + D), this;
 	}
 	getSouthWest() {
 		return this.southWest;
@@ -812,17 +822,17 @@ var BoundingBox_default = class a {
 	getNorth() {
 		return this.northEast.lat;
 	}
-	static equals(a, k) {
-		return Coordinates_default.equals(a.northEast, k.northEast) && Coordinates_default.equals(a.southWest, k.southWest);
+	static equals(e, w) {
+		return Coordinates_default.equals(e.northEast, w.northEast) && Coordinates_default.equals(e.southWest, w.southWest);
 	}
-	equals(k) {
-		return a.equals(this, k);
+	equals(w) {
+		return e.equals(this, w);
 	}
-	static fromArray(k) {
-		return new a(new Coordinates_default(k[3], k[2]), new Coordinates_default(k[1], k[0]));
+	static fromArray(w) {
+		return new e(new Coordinates_default(w[3], w[2]), new Coordinates_default(w[1], w[0]));
 	}
-	static fromCoordinates(k) {
-		return k.length === 0 ? null : k.reduce((a, k) => a.extend(k), new a(k[0], k[0]));
+	static fromCoordinates(w) {
+		return w.length === 0 ? null : w.reduce((e, w) => e.extend(w), new e(w[0], w[0]));
 	}
 	toArray() {
 		return [
@@ -832,37 +842,37 @@ var BoundingBox_default = class a {
 			this.getNorth()
 		];
 	}
-}, RelativePosition_default = class a {
+}, RelativePosition_default = class e {
 	x;
 	y;
 	z;
 	time = null;
 	_accuracy = null;
 	_bearing = null;
-	constructor(a, k, A, j = null, M = null, N = null) {
-		this.x = a, this.y = k, this.z = A, this.time = j, this.accuracy = M, this.bearing = N;
+	constructor(e, w, T, E = null, D = null, O = null) {
+		this.x = e, this.y = w, this.z = T, this.time = E, this.accuracy = D, this.bearing = O;
 	}
 	get accuracy() {
 		return this._accuracy;
 	}
-	set accuracy(a) {
-		if (a !== null && a < 0) throw Error("accuracy argument is not a positive number");
-		this._accuracy = a;
+	set accuracy(e) {
+		if (e !== null && e < 0) throw Error("accuracy argument is not a positive number");
+		this._accuracy = e;
 	}
 	get bearing() {
 		return this._bearing;
 	}
-	set bearing(a) {
-		this._bearing = a === null ? null : a % (2 * Math.PI);
+	set bearing(e) {
+		this._bearing = e === null ? null : e % (2 * Math.PI);
 	}
 	clone() {
-		return new a(this.x, this.y, this.z, this.time, this.accuracy, this.bearing);
+		return new e(this.x, this.y, this.z, this.time, this.accuracy, this.bearing);
 	}
-	static equals(k, A, j = EPS_MM) {
-		return k === null && k === A ? !0 : !(k instanceof a) || !(A instanceof a) ? !1 : Math.abs(A.x - k.x) < j && Math.abs(A.y - k.y) < j && Math.abs(A.z - k.z) < j && k.time === A.time && k.accuracy === A.accuracy && k.bearing === A.bearing;
+	static equals(w, T, E = EPS_MM) {
+		return w === null && w === T ? !0 : !(w instanceof e) || !(T instanceof e) ? !1 : Math.abs(T.x - w.x) < E && Math.abs(T.y - w.y) < E && Math.abs(T.z - w.z) < E && w.time === T.time && w.accuracy === T.accuracy && w.bearing === T.bearing;
 	}
-	equals(k) {
-		return a.equals(this, k);
+	equals(w) {
+		return e.equals(this, w);
 	}
 	toJson() {
 		return {
@@ -874,42 +884,42 @@ var BoundingBox_default = class a {
 			...this.bearing !== null && { bearing: this.bearing }
 		};
 	}
-	static fromJson(k) {
-		return new a(k.x, k.y, k.z, k.time, k.accuracy, k.bearing);
+	static fromJson(w) {
+		return new e(w.x, w.y, w.z, w.time, w.accuracy, w.bearing);
 	}
-}, GeoRelativePosition_default = class extends RelativePosition_default {}, GeoRef_default = class k {
+}, GeoRelativePosition_default = class extends RelativePosition_default {}, GeoRef_default = class w {
 	scale = 1;
 	heading = 0;
 	origin;
 	buildingLevels;
-	constructor(a, k = []) {
-		this.origin = a, this.buildingLevels = k;
+	constructor(e, w = []) {
+		this.origin = e, this.buildingLevels = w;
 	}
-	localToWorld(k) {
-		let A = Vector3.multiplyScalar(k, this.scale), j = Quaternion.fromAxisAngle([
+	localToWorld(w) {
+		let T = Vector3.multiplyScalar(w, this.scale), E = Quaternion.fromAxisAngle([
 			0,
 			0,
 			1
-		], this.heading), M = Quaternion.multiply(j, this.origin.enuToEcefRotation), N = Quaternion.rotate(M, A), P = Vector3.sum(this.origin.ecef, N), F = Coordinates_default.fromECEF(P), I = F.alt;
-		F.heightFromGround = F.alt - this.origin.alt;
-		let L = (a) => {
-			F.level = a.id, F.heightFromFloor = I - a.floorAltitude;
+		], this.heading), D = Quaternion.multiply(E, this.origin.enuToEcefRotation), O = Quaternion.rotate(D, T), k = Vector3.sum(this.origin.ecef, O), A = Coordinates_default.fromECEF(k), j = A.alt;
+		A.heightFromGround = A.alt - this.origin.alt;
+		let M = (e) => {
+			A.level = e.id, A.heightFromFloor = j - e.floorAltitude;
 		};
-		if (!this.buildingLevels.length) return F;
-		let R = this.buildingLevels.filter((a) => I >= a.floorAltitude && I <= a.ceilingAltitude);
-		if (!R.length) return F;
-		let z = R[0], B = [F.lng, F.lat], V = R.filter((a) => a.geometries.length);
-		if (!V.length) return L(z), F;
-		let H = V.filter((k) => k.geometries.some((k) => booleanPointInPolygon(B, k)))[0];
-		return H && L(H), F;
-	}
-	worldToLocal(a) {
-		let k = Quaternion.fromAxisAngle([
+		if (!this.buildingLevels.length) return A;
+		let N = this.buildingLevels.filter((e) => j >= e.floorAltitude && j <= e.ceilingAltitude);
+		if (!N.length) return A;
+		let P = N[0], F = [A.lng, A.lat], I = N.filter((e) => e.geometries.length);
+		if (!I.length) return M(P), A;
+		let L = I.filter((w) => w.geometries.some((w) => booleanPointInPolygon(F, w)))[0];
+		return L && M(L), A;
+	}
+	worldToLocal(e) {
+		let w = Quaternion.fromAxisAngle([
 			0,
 			0,
 			1
-		], -this.heading), A = Quaternion.multiply(this.origin.ecefToEnuRotation, k), j = Vector3.subtract(a.ecef, this.origin.ecef), M = Vector3.multiplyScalar(j, 1 / this.scale);
-		return Quaternion.rotate(A, M);
+		], -this.heading), T = Quaternion.multiply(this.origin.ecefToEnuRotation, w), E = Vector3.subtract(e.ecef, this.origin.ecef), D = Vector3.multiplyScalar(E, 1 / this.scale);
+		return Quaternion.rotate(T, D);
 	}
 	toJson() {
 		return {
@@ -918,11 +928,11 @@ var BoundingBox_default = class a {
 			...this.heading !== 0 && { heading: this.heading }
 		};
 	}
-	static fromJson(a) {
-		let A = new k(Coordinates_default.fromJson(a.origin));
-		return A.scale = a.scale === void 0 ? 1 : a.scale, A.heading = a.heading === void 0 ? 0 : a.heading, A;
+	static fromJson(e) {
+		let T = new w(Coordinates_default.fromJson(e.origin));
+		return T.scale = e.scale === void 0 ? 1 : e.scale, T.heading = e.heading === void 0 ? 0 : e.heading, T;
 	}
-}, Attitude_default = class a {
+}, Attitude_default = class e {
 	_quaternion = [
 		1,
 		0,
@@ -933,11 +943,11 @@ var BoundingBox_default = class a {
 	_eulerAngles = null;
 	_time = null;
 	_accuracy = null;
-	constructor(a, k = null, A = null) {
-		this.quaternion = a, this.time = k, this.accuracy = A;
+	constructor(e, w = null, T = null) {
+		this.quaternion = e, this.time = w, this.accuracy = T;
 	}
 	static unitary() {
-		return new a([
+		return new e([
 			1,
 			0,
 			0,
@@ -947,44 +957,44 @@ var BoundingBox_default = class a {
 	get quaternion() {
 		return this._quaternion;
 	}
-	set quaternion(a) {
-		if (Math.abs(1 - Quaternion.norm(a)) > 1e-4) throw Error("quaternion is not a unit quaternion");
-		this._quaternion = a, this._heading = null, this._eulerAngles = null;
+	set quaternion(e) {
+		if (Math.abs(1 - Quaternion.norm(e)) > 1e-4) throw Error("quaternion is not a unit quaternion");
+		this._quaternion = e, this._heading = null, this._eulerAngles = null;
 	}
 	get time() {
 		return this._time;
 	}
-	set time(a) {
-		this._time = a;
+	set time(e) {
+		this._time = e;
 	}
 	get accuracy() {
 		return this._accuracy;
 	}
-	set accuracy(a) {
-		if (a !== null && (a < 0 || a > Math.PI)) throw Error("accuracy argument (" + a + ") is not in range [0; PI]");
-		this._accuracy = a;
+	set accuracy(e) {
+		if (e !== null && (e < 0 || e > Math.PI)) throw Error("accuracy argument (" + e + ") is not in range [0; PI]");
+		this._accuracy = e;
 	}
 	get eulerAngles() {
 		return this._eulerAngles === null && (this._eulerAngles = Rotations.quaternionToEulerZXY(this.quaternion)), this._eulerAngles;
 	}
 	get eulerAnglesDegrees() {
-		return this.eulerAngles.map((a) => rad2deg(a));
+		return this.eulerAngles.map((e) => rad2deg(e));
 	}
 	get heading() {
 		if (this._heading === null) {
-			let a = 0;
-			typeof window < "u" && window && window.orientation && (a = deg2rad(window.orientation)), this._heading = Rotations.getHeadingFromQuaternion(this.quaternion) + a;
+			let e = 0;
+			typeof window < "u" && window && window.orientation && (e = deg2rad(window.orientation)), this._heading = Rotations.getHeadingFromQuaternion(this.quaternion) + e;
 		}
 		return this._heading;
 	}
 	get headingDegrees() {
 		return rad2deg(this.heading);
 	}
-	static equals(k, A) {
-		return k === null && k === A ? !0 : !(k instanceof a) || !(A instanceof a) ? !1 : k === A ? !0 : Quaternion.equals(k.quaternion, A.quaternion);
+	static equals(w, T) {
+		return w === null && w === T ? !0 : !(w instanceof e) || !(T instanceof e) ? !1 : w === T ? !0 : Quaternion.equals(w.quaternion, T.quaternion);
 	}
-	equals(k) {
-		return a.equals(this, k);
+	equals(w) {
+		return e.equals(this, w);
 	}
 	toJson() {
 		return this.time === null && this.accuracy === null ? this.quaternion : {
@@ -993,31 +1003,31 @@ var BoundingBox_default = class a {
 			...this.accuracy !== null && { accuracy: this.accuracy }
 		};
 	}
-	static fromJson(k) {
-		return Array.isArray(k) ? new a(k, null, null) : new a(k.q, k.time, k.accuracy);
+	static fromJson(w) {
+		return Array.isArray(w) ? new e(w, null, null) : new e(w.q, w.time, w.accuracy);
 	}
 	clone() {
-		return new a(this.quaternion.slice(0), this.time, this.accuracy);
+		return new e(this.quaternion.slice(0), this.time, this.accuracy);
 	}
-	static diff(k, A) {
-		let j = Quaternion.multiply(Quaternion.inverse(k.quaternion), A.quaternion), M = null;
-		A.time !== null && k.time !== null && (M = A.time - k.time);
-		let N = null;
-		return k.accuracy !== null && A.accuracy !== null && (N = Math.max(A.accuracy - k.accuracy)), new a(j, M, N);
+	static diff(w, T) {
+		let E = Quaternion.multiply(Quaternion.inverse(w.quaternion), T.quaternion), D = null;
+		T.time !== null && w.time !== null && (D = T.time - w.time);
+		let O = null;
+		return w.accuracy !== null && T.accuracy !== null && (O = Math.max(T.accuracy - w.accuracy)), new e(E, D, O);
 	}
-}, AbsoluteHeading_default = class a {
+}, AbsoluteHeading_default = class e {
 	heading;
 	time = null;
 	_accuracy = null;
-	constructor(a, k = null, A = null) {
-		this.heading = a, this.time = k, this.accuracy = A;
+	constructor(e, w = null, T = null) {
+		this.heading = e, this.time = w, this.accuracy = T;
 	}
 	get accuracy() {
 		return this._accuracy;
 	}
-	set accuracy(a) {
-		if (a !== null && (a < 0 || a > Math.PI)) throw Error("accuracy argument (" + a + ") is not in range [0; PI]");
-		this._accuracy = a;
+	set accuracy(e) {
+		if (e !== null && (e < 0 || e > Math.PI)) throw Error("accuracy argument (" + e + ") is not in range [0; PI]");
+		this._accuracy = e;
 	}
 	toAttitude() {
 		return new Attitude_default(Quaternion.fromAxisAngle([
@@ -1026,11 +1036,11 @@ var BoundingBox_default = class a {
 			1
 		], -this.heading), this.time, this.accuracy);
 	}
-	static equals(k, A) {
-		return k === null && k === A ? !0 : !(k instanceof a) || !(A instanceof a) ? !1 : Math.abs(k.heading - A.heading) < 1e-8;
+	static equals(w, T) {
+		return w === null && w === T ? !0 : !(w instanceof e) || !(T instanceof e) ? !1 : Math.abs(w.heading - T.heading) < 1e-8;
 	}
-	equals(k) {
-		return a.equals(this, k);
+	equals(w) {
+		return e.equals(this, w);
 	}
 	toJson() {
 		return {
@@ -1039,11 +1049,11 @@ var BoundingBox_default = class a {
 			...this.accuracy !== null && { accuracy: this.accuracy }
 		};
 	}
-	static fromJson(k) {
-		return new a(k.heading, k.time, k.accuracy);
+	static fromJson(w) {
+		return new e(w.heading, w.time, w.accuracy);
 	}
 	clone() {
-		return new a(this.heading, this.time, this.accuracy);
+		return new e(this.heading, this.time, this.accuracy);
 	}
 };
 export { AbsoluteHeading_default as AbsoluteHeading, Attitude_default as Attitude, BoundingBox_default as BoundingBox, Constants_exports as Constants, Coordinates_default as Coordinates, GeoRef_default as GeoRef, GeoRelativePosition_default as GeoRelativePosition, Level_default as Level, RelativePosition_default as RelativePosition, UserPosition_default as UserPosition, Utils_exports as Utils };