@pirireis/webglobeplugins 0.9.11 → 0.9.13

package/Math/angle-calculation.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bearingRealAngle = bearingRealAngle;
 function bearingRealAngle(long, lat, endLong, endLat) {
-    var rLong = Radians * long;
-    var rLat = Radians * lat;
-    var rEndLong = Radians * endLong;
-    var rEndLat = Radians * endLat;
-    var delta_long = rEndLong - rLong;
-    var x = Math.sin(delta_long) * Math.cos(rEndLat);
-    var y = Math.cos(rLat) * Math.sin(rEndLat) - Math.sin(rLat) * Math.cos(rEndLat) * Math.cos(delta_long);
-    var initialBearing = Math.atan2(x, y) / Radians;
+    const rLong = Radians * long;
+    const rLat = Radians * lat;
+    const rEndLong = Radians * endLong;
+    const rEndLat = Radians * endLat;
+    const delta_long = rEndLong - rLong;
+    const x = Math.sin(delta_long) * Math.cos(rEndLat);
+    const y = Math.cos(rLat) * Math.sin(rEndLat) - Math.sin(rLat) * Math.cos(rEndLat) * Math.cos(delta_long);
+    let initialBearing = Math.atan2(x, y) / Radians;
     initialBearing = (initialBearing + 360) % 360;
     return initialBearing;
 }
+export { bearingRealAngle };

package/Math/arc.js

@@ -1,64 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arc = void 0;
-var vec3_1 = require("./vec3");
-var constants_1 = require("./constants");
-var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
-var _1vector = /*@__PURE__*/ vec3_1.vec3.create(1, 1, 1);
-exports.arc = Object.freeze({
-    create: function (p0, p1) {
-        var normal = vec3_1.vec3.create(0, 0, 0);
-        vec3_1.vec3.cross(normal, p0, p1);
-        var coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
-        vec3_1.vec3.normalize(coverPlaneNormal, coverPlaneNormal);
-        var dot = vec3_1.vec3.dot(coverPlaneNormal, p0);
+import { vec3 } from "./vec3";
+import { EPSILON } from "./constants";
+const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+const _1vector = /*@__PURE__*/ vec3.create(1, 1, 1);
+export const arc = Object.freeze({
+    create(p0, p1) {
+        const normal = vec3.create(0, 0, 0);
+        vec3.cross(normal, p0, p1);
+        const coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
+        vec3.normalize(coverPlaneNormal, coverPlaneNormal);
+        const dot = vec3.dot(coverPlaneNormal, p0);
         return {
-            p0: vec3_1.vec3.clone(p0),
-            p1: vec3_1.vec3.clone(p1),
-            normal: vec3_1.vec3.clone(normal),
+            p0: vec3.clone(p0),
+            p1: vec3.clone(p1),
+            normal: vec3.clone(normal),
             coverPlane: {
                 normal: coverPlaneNormal,
                 distance: dot
             }
         };
     },
-    set: function (out, p0, p1) {
-        vec3_1.vec3.copy(out.p0, p0);
-        vec3_1.vec3.copy(out.p1, p1);
-        vec3_1.vec3.cross(out.normal, p0, p1);
-        var coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
-        vec3_1.vec3.normalize(coverPlaneNormal, coverPlaneNormal);
+    set(out, p0, p1) {
+        vec3.copy(out.p0, p0);
+        vec3.copy(out.p1, p1);
+        vec3.cross(out.normal, p0, p1);
+        const coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
+        vec3.normalize(coverPlaneNormal, coverPlaneNormal);
         out.coverPlane.normal = coverPlaneNormal;
-        out.coverPlane.distance = vec3_1.vec3.dot(coverPlaneNormal, p0);
+        out.coverPlane.distance = vec3.dot(coverPlaneNormal, p0);
     },
-    copy: function (out, a) {
-        vec3_1.vec3.copy(out.p0, a.p0);
-        vec3_1.vec3.copy(out.p1, a.p1);
-        vec3_1.vec3.copy(out.normal, a.normal);
-        out.coverPlane.normal = vec3_1.vec3.clone(a.coverPlane.normal);
+    copy(out, a) {
+        vec3.copy(out.p0, a.p0);
+        vec3.copy(out.p1, a.p1);
+        vec3.copy(out.normal, a.normal);
+        out.coverPlane.normal = vec3.clone(a.coverPlane.normal);
         out.coverPlane.distance = a.coverPlane.distance;
     },
-    clone: function (a) {
+    clone(a) {
         return {
-            p0: vec3_1.vec3.clone(a.p0),
-            p1: vec3_1.vec3.clone(a.p1),
-            normal: vec3_1.vec3.clone(a.normal),
+            p0: vec3.clone(a.p0),
+            p1: vec3.clone(a.p1),
+            normal: vec3.clone(a.normal),
             coverPlane: {
-                normal: vec3_1.vec3.clone(a.coverPlane.normal),
+                normal: vec3.clone(a.coverPlane.normal),
                 distance: a.coverPlane.distance
             }
         };
     },
-    isPointOn: function (arc, point) {
-        var alignment = Math.abs(vec3_1.vec3.dot(point, arc.normal)) < constants_1.EPSILON;
-        var distance = Math.abs(vec3_1.vec3.lengthSquared(point) - 1) < constants_1.EPSILON;
-        var cover = vec3_1.vec3.dot(arc.coverPlane.normal, point) >= arc.coverPlane.distance;
+    isPointOn(arc, point) {
+        const alignment = Math.abs(vec3.dot(point, arc.normal)) < EPSILON;
+        const distance = Math.abs(vec3.lengthSquared(point) - 1) < EPSILON;
+        const cover = vec3.dot(arc.coverPlane.normal, point) >= arc.coverPlane.distance;
         return alignment || distance || cover;
     },
-    equals: function (a, b) {
-        return vec3_1.vec3.equals(a.p0, b.p0) && vec3_1.vec3.equals(a.p1, b.p1);
+    equals(a, b) {
+        return vec3.equals(a.p0, b.p0) && vec3.equals(a.p1, b.p1);
     },
-    populatePoints: function (out, arc, count) {
+    populatePoints(out, arc, count) {
         // rotate p0 around normal vector with a quaternion
         // calculate angle
     }

package/Math/bounds/line-bbox.js

@@ -1,9 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGreatCircleArcBBox = getGreatCircleArcBBox;
-function isClose(a, b, rtol, atol) {
-    if (rtol === void 0) { rtol = 1e-5; }
-    if (atol === void 0) { atol = 1e-8; }
+function isClose(a, b, rtol = 1e-5, atol = 1e-8) {
     // JavaScript equivalent of NumPy's isclose
     return Math.abs(a - b) <= (atol + rtol * Math.abs(b));
 }
@@ -21,10 +16,10 @@ function calculateInitialBearing(phi1, lambda1, phi2, lambda2) {
             return 0; // Bearing is North
         }
     }
-    var deltaLambda = lambda2 - lambda1;
-    var y = Math.sin(deltaLambda) * Math.cos(phi2);
-    var x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(deltaLambda);
-    var theta = Math.atan2(y, x);
+    const deltaLambda = lambda2 - lambda1;
+    const y = Math.sin(deltaLambda) * Math.cos(phi2);
+    const x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(deltaLambda);
+    const theta = Math.atan2(y, x);
     return theta;
 }
 function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
@@ -37,23 +32,23 @@ function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
         return [phi1Rad, phi1Rad, lambda1Rad, lambda1Rad];
     }
     // === Edge Case: Antipodal Points ===
-    var deltaLambdaNorm = mod(lambda1Rad - lambda2Rad + Math.PI, 2 * Math.PI) - Math.PI;
+    const deltaLambdaNorm = mod(lambda1Rad - lambda2Rad + Math.PI, 2 * Math.PI) - Math.PI;
     if (isClose(phi1Rad, -phi2Rad) && isClose(Math.abs(deltaLambdaNorm), Math.PI)) {
         // Path covers all longitudes and passes through poles
         return [-Math.PI / 2, Math.PI / 2, -Math.PI, Math.PI];
     }
     // === Longitude Bounds ===
-    var lambda1Adj = lambda1Rad;
-    var lambda2Adj = lambda2Rad;
+    let lambda1Adj = lambda1Rad;
+    let lambda2Adj = lambda2Rad;
     // Handle antimeridian crossing
-    var deltaLambda = lambda2Rad - lambda1Rad;
+    let deltaLambda = lambda2Rad - lambda1Rad;
     if (deltaLambda > Math.PI) {
         deltaLambda -= 2 * Math.PI;
     }
     else if (deltaLambda <= -Math.PI) {
         deltaLambda += 2 * Math.PI;
     }
-    var crossesAntimeridian = Math.abs(lambda2Rad - lambda1Rad) > Math.PI;
+    const crossesAntimeridian = Math.abs(lambda2Rad - lambda1Rad) > Math.PI;
     if (crossesAntimeridian) {
         // Add 2*pi to the smaller longitude
         if (lambda1Rad < lambda2Rad) {
@@ -63,20 +58,20 @@ function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
             lambda2Adj += 2 * Math.PI;
         }
     }
-    var lambdaMin = Math.min(lambda1Adj, lambda2Adj);
-    var lambdaMax = Math.max(lambda1Adj, lambda2Adj);
+    const lambdaMin = Math.min(lambda1Adj, lambda2Adj);
+    const lambdaMax = Math.max(lambda1Adj, lambda2Adj);
     // === Latitude Bounds ===
-    var phiMin = Math.min(phi1Rad, phi2Rad);
-    var phiMax = Math.max(phi1Rad, phi2Rad);
+    let phiMin = Math.min(phi1Rad, phi2Rad);
+    let phiMax = Math.max(phi1Rad, phi2Rad);
     // === Vertex Check ===
     // Check the maximum/minimum latitude reached by the great circle
-    var theta12 = calculateInitialBearing(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad);
-    var theta21 = calculateInitialBearing(phi2Rad, lambda2Rad, phi1Rad, lambda1Rad);
-    var cosPhi1 = Math.cos(phi1Rad);
+    const theta12 = calculateInitialBearing(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad);
+    const theta21 = calculateInitialBearing(phi2Rad, lambda2Rad, phi1Rad, lambda1Rad);
+    const cosPhi1 = Math.cos(phi1Rad);
     if (!isClose(cosPhi1, 0)) { // Starting point is not a pole
         // Compute the absolute latitude of the vertex
-        var argAcos = Math.abs(Math.sin(theta12) * cosPhi1);
-        var phiVtxAbs = Math.acos(Math.min(Math.max(argAcos, -1.0), 1.0));
+        const argAcos = Math.abs(Math.sin(theta12) * cosPhi1);
+        const phiVtxAbs = Math.acos(Math.min(Math.max(argAcos, -1.0), 1.0));
         // Check if the path crosses the northern vertex
         if (isClose(theta12, 0) && phiVtxAbs > phiMax) { // Starting due north
             phiMax = phiVtxAbs;
@@ -86,7 +81,7 @@ function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
         }
         else {
             // General case: Check if the path crosses the vertex
-            var finalBearingAtP2 = mod(theta21 + Math.PI + Math.PI, 2 * Math.PI) - Math.PI;
+            const finalBearingAtP2 = mod(theta21 + Math.PI + Math.PI, 2 * Math.PI) - Math.PI;
             // Northern vertex check
             if ((-Math.PI / 2 < theta12 && theta12 < Math.PI / 2) &&
                 !(finalBearingAtP2 >= -Math.PI / 2 && finalBearingAtP2 <= Math.PI / 2)) {
@@ -112,79 +107,80 @@ function degreesToRadians(deg) {
 function radiansToDegrees(rad) {
     return rad * 180 / Math.PI;
 }
+export { getGreatCircleArcBBox };
 // Test Case 1: London to Tokyo
-var lat1Deg = 51.5, lon1Deg = -0.1;
-var lat2Deg = 35.7, lon2Deg = 139.7;
-var phi1 = degreesToRadians(lat1Deg);
-var lambda1 = degreesToRadians(lon1Deg);
-var phi2 = degreesToRadians(lat2Deg);
-var lambda2 = degreesToRadians(lon2Deg);
-var _a = getGreatCircleArcBBox(phi1, lambda1, phi2, lambda2), phiMinRad = _a[0], phiMaxRad = _a[1], lambdaMinRad = _a[2], lambdaMaxRad = _a[3];
-var phiMinDeg = radiansToDegrees(phiMinRad);
-var phiMaxDeg = radiansToDegrees(phiMaxRad);
-var lambdaMinDeg = radiansToDegrees(lambdaMinRad);
-var lambdaMaxDeg = radiansToDegrees(lambdaMaxRad);
+const lat1Deg = 51.5, lon1Deg = -0.1;
+const lat2Deg = 35.7, lon2Deg = 139.7;
+const phi1 = degreesToRadians(lat1Deg);
+const lambda1 = degreesToRadians(lon1Deg);
+const phi2 = degreesToRadians(lat2Deg);
+const lambda2 = degreesToRadians(lon2Deg);
+const [phiMinRad, phiMaxRad, lambdaMinRad, lambdaMaxRad] = getGreatCircleArcBBox(phi1, lambda1, phi2, lambda2);
+const phiMinDeg = radiansToDegrees(phiMinRad);
+const phiMaxDeg = radiansToDegrees(phiMaxRad);
+const lambdaMinDeg = radiansToDegrees(lambdaMinRad);
+const lambdaMaxDeg = radiansToDegrees(lambdaMaxRad);
 console.log("Input Points (Radians):");
-console.log("  P1: Latitude=".concat(lat1Deg, ", Longitude=").concat(lon1Deg));
-console.log("  P2: Latitude=".concat(lat2Deg, ", Longitude=").concat(lon2Deg));
-console.log("  P1: Latitude=".concat(phi1.toFixed(4), ", Longitude=").concat(lambda1.toFixed(4)));
-console.log("  P2: Latitude=".concat(phi2.toFixed(4), ", Longitude=").concat(lambda2.toFixed(4)));
+console.log(`  P1: Latitude=${lat1Deg}, Longitude=${lon1Deg}`);
+console.log(`  P2: Latitude=${lat2Deg}, Longitude=${lon2Deg}`);
+console.log(`  P1: Latitude=${phi1.toFixed(4)}, Longitude=${lambda1.toFixed(4)}`);
+console.log(`  P2: Latitude=${phi2.toFixed(4)}, Longitude=${lambda2.toFixed(4)}`);
 console.log("-".repeat(20));
 console.log("Bounding Box (Radians):");
 // console phys://console.log(`  Minimum Latitude (phi_min): ${phiMinRad.toFixed(4)}`);
-console.log("  Maximum Latitude (phi_max): ".concat(phiMaxRad.toFixed(4)));
-console.log("  Minimum Longitude (lambda_min): ".concat(lambdaMinRad.toFixed(4)));
-console.log("  Maximum Longitude (lambda_max): ".concat(lambdaMaxRad.toFixed(4)));
+console.log(`  Maximum Latitude (phi_max): ${phiMaxRad.toFixed(4)}`);
+console.log(`  Minimum Longitude (lambda_min): ${lambdaMinRad.toFixed(4)}`);
+console.log(`  Maximum Longitude (lambda_max): ${lambdaMaxRad.toFixed(4)}`);
 console.log("-".repeat(20));
 console.log("Bounding Box (Degrees):");
-console.log("  Minimum Latitude: ".concat(phiMinDeg.toFixed(2), "\u00B0"));
-console.log("  Maximum Latitude: ".concat(phiMaxDeg.toFixed(2), "\u00B0"));
-console.log("  Minimum Longitude: ".concat(lambdaMinDeg.toFixed(2), "\u00B0"));
-console.log("  Maximum Longitude: ".concat(lambdaMaxDeg.toFixed(2), "\u00B0"));
+console.log(`  Minimum Latitude: ${phiMinDeg.toFixed(2)}°`);
+console.log(`  Maximum Latitude: ${phiMaxDeg.toFixed(2)}°`);
+console.log(`  Minimum Longitude: ${lambdaMinDeg.toFixed(2)}°`);
+console.log(`  Maximum Longitude: ${lambdaMaxDeg.toFixed(2)}°`);
 // --- Antimeridian Crossing Test ---
 console.log("\n" + "=".repeat(30));
 console.log("Antimeridian Crossing Test");
-var lat1DegAm = -18, lon1DegAm = 178;
-var lat2DegAm = -14, lon2DegAm = -172;
-var phi1Am = degreesToRadians(lat1DegAm);
-var lambda1Am = degreesToRadians(lon1DegAm);
-var phi2Am = degreesToRadians(lat2DegAm);
-var lambda2Am = degreesToRadians(lon2DegAm);
-var _b = getGreatCircleArcBBox(phi1Am, lambda1Am, phi2Am, lambda2Am), phiMinRadAm = _b[0], phiMaxRadAm = _b[1], lambdaMinRadAm = _b[2], lambdaMaxRadAm = _b[3];
-var phiMinDegAm = radiansToDegrees(phiMinRadAm);
-var phiMaxDegAm = radiansToDegrees(phiMaxRadAm);
-var lambdaMinDegAm = radiansToDegrees(lambdaMinRadAm);
-var lambdaMaxDegAm = radiansToDegrees(lambdaMaxRadAm);
-console.log("Input Points (Degrees): P1=(".concat(lat1DegAm, ", ").concat(lon1DegAm, "), P2=(").concat(lat2DegAm, ", ").concat(lon2DegAm, ")"));
+const lat1DegAm = -18, lon1DegAm = 178;
+const lat2DegAm = -14, lon2DegAm = -172;
+const phi1Am = degreesToRadians(lat1DegAm);
+const lambda1Am = degreesToRadians(lon1DegAm);
+const phi2Am = degreesToRadians(lat2DegAm);
+const lambda2Am = degreesToRadians(lon2DegAm);
+const [phiMinRadAm, phiMaxRadAm, lambdaMinRadAm, lambdaMaxRadAm] = getGreatCircleArcBBox(phi1Am, lambda1Am, phi2Am, lambda2Am);
+const phiMinDegAm = radiansToDegrees(phiMinRadAm);
+const phiMaxDegAm = radiansToDegrees(phiMaxRadAm);
+const lambdaMinDegAm = radiansToDegrees(lambdaMinRadAm);
+const lambdaMaxDegAm = radiansToDegrees(lambdaMaxRadAm);
+console.log(`Input Points (Degrees): P1=(${lat1DegAm}, ${lon1DegAm}), P2=(${lat2DegAm}, ${lon2DegAm})`);
 console.log("Bounding Box (Radians):");
-console.log("  phi_min=".concat(phiMinRadAm.toFixed(4), ", phi_max=").concat(phiMaxRadAm.toFixed(4)));
-console.log("  lambda_min=".concat(lambdaMinRadAm.toFixed(4), ", lambda_max=").concat(lambdaMaxRadAm.toFixed(4)));
+console.log(`  phi_min=${phiMinRadAm.toFixed(4)}, phi_max=${phiMaxRadAm.toFixed(4)}`);
+console.log(`  lambda_min=${lambdaMinRadAm.toFixed(4)}, lambda_max=${lambdaMaxRadAm.toFixed(4)}`);
 console.log("Bounding Box (Degrees):");
-console.log("  Min Latitude: ".concat(phiMinDegAm.toFixed(2), "\u00B0"));
-console.log("  Max Latitude: ".concat(phiMaxDegAm.toFixed(2), "\u00B0"));
-console.log("  Min Longitude: ".concat(lambdaMinDegAm.toFixed(2), "\u00B0 (178\u00B0 expected)"));
-console.log("  Max Longitude: ".concat(lambdaMaxDegAm.toFixed(2), "\u00B0 (188\u00B0 expected, which is -172\u00B0 + 360\u00B0)"));
+console.log(`  Min Latitude: ${phiMinDegAm.toFixed(2)}°`);
+console.log(`  Max Latitude: ${phiMaxDegAm.toFixed(2)}°`);
+console.log(`  Min Longitude: ${lambdaMinDegAm.toFixed(2)}° (178° expected)`);
+console.log(`  Max Longitude: ${lambdaMaxDegAm.toFixed(2)}° (188° expected, which is -172° + 360°)`);
 // --- Polar Crossing Test ---
 console.log("\n" + "=".repeat(30));
 console.log("Polar Crossing Test");
-var lat1DegP = 80, lon1DegP = 20;
-var lat2DegP = 80, lon2DegP = -100;
-var phi1P = degreesToRadians(lat1DegP);
-var lambda1P = degreesToRadians(lon1DegP);
-var phi2P = degreesToRadians(lat2DegP);
-var lambda2P = degreesToRadians(lon2DegP);
-var _c = getGreatCircleArcBBox(phi1P, lambda1P, phi2P, lambda2P), phiMinRadP = _c[0], phiMaxRadP = _c[1], lambdaMinRadP = _c[2], lambdaMaxRadP = _c[3];
-var phiMinDegP = radiansToDegrees(phiMinRadP);
-var phiMaxDegP = radiansToDegrees(phiMaxRadP);
-var lambdaMinDegP = radiansToDegrees(lambdaMinRadP);
-var lambdaMaxDegP = radiansToDegrees(lambdaMaxRadP);
-console.log("Input Points (Degrees): P1=(".concat(lat1DegP, ", ").concat(lon1DegP, "), P2=(").concat(lat2DegP, ", ").concat(lon2DegP, ")"));
+const lat1DegP = 80, lon1DegP = 20;
+const lat2DegP = 80, lon2DegP = -100;
+const phi1P = degreesToRadians(lat1DegP);
+const lambda1P = degreesToRadians(lon1DegP);
+const phi2P = degreesToRadians(lat2DegP);
+const lambda2P = degreesToRadians(lon2DegP);
+const [phiMinRadP, phiMaxRadP, lambdaMinRadP, lambdaMaxRadP] = getGreatCircleArcBBox(phi1P, lambda1P, phi2P, lambda2P);
+const phiMinDegP = radiansToDegrees(phiMinRadP);
+const phiMaxDegP = radiansToDegrees(phiMaxRadP);
+const lambdaMinDegP = radiansToDegrees(lambdaMinRadP);
+const lambdaMaxDegP = radiansToDegrees(lambdaMaxRadP);
+console.log(`Input Points (Degrees): P1=(${lat1DegP}, ${lon1DegP}), P2=(${lat2DegP}, ${lon2DegP})`);
 console.log("Bounding Box (Radians):");
-console.log("  phi_min=".concat(phiMinRadP.toFixed(4), ", phi_max=").concat(phiMaxRadP.toFixed(4)));
-console.log("  lambda_min=".concat(lambdaMinRadP.toFixed(4), ", lambda_max=").concat(lambdaMaxRadP.toFixed(4)));
+console.log(`  phi_min=${phiMinRadP.toFixed(4)}, phi_max=${phiMaxRadP.toFixed(4)}`);
+console.log(`  lambda_min=${lambdaMinRadP.toFixed(4)}, lambda_max=${lambdaMaxRadP.toFixed(4)}`);
 console.log("Bounding Box (Degrees):");
-console.log("  Min Latitude: ".concat(phiMinDegP.toFixed(2), "\u00B0"));
-console.log("  Max Latitude: ".concat(phiMaxDegP.toFixed(2), "\u00B0 (Should be close to North Pole > 80\u00B0)"));
-console.log("  Min Longitude: ".concat(lambdaMinDegP.toFixed(2), "\u00B0"));
-console.log("  Max Longitude: ".concat(lambdaMaxDegP.toFixed(2), "\u00B0"));
+console.log(`  Min Latitude: ${phiMinDegP.toFixed(2)}°`);
+console.log(`  Max Latitude: ${phiMaxDegP.toFixed(2)}° (Should be close to North Pole > 80°)`);
+console.log(`  Min Longitude: ${lambdaMinDegP.toFixed(2)}°`);
+console.log(`  Max Longitude: ${lambdaMaxDegP.toFixed(2)}°`);
 // --- line points intersection with bbox ---

package/Math/constants.js

@@ -1,9 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EPSILON = exports.WORLD_RADIUS_MERCATOR = exports.WORLD_RADIUS_3D = void 0;
-var WORLD_RADIUS_3D = 6378.137;
-exports.WORLD_RADIUS_3D = WORLD_RADIUS_3D;
-var WORLD_RADIUS_MERCATOR = 6378136.99911;
-exports.WORLD_RADIUS_MERCATOR = WORLD_RADIUS_MERCATOR;
-var EPSILON = 1e-10; // Used for floating point comparisons
-exports.EPSILON = EPSILON;
+const WORLD_RADIUS_3D = 6378.137;
+const WORLD_RADIUS_MERCATOR = 6378136.99911;
+const EPSILON = 1e-10; // Used for floating point comparisons
+export { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR, EPSILON };

package/Math/frustum/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/Math/juction/arc-plane.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arcSlice = arcSlice;
-var constants_1 = require("../constants");
-var vec3_1 = require("../vec3");
-var line_1 = require("../line");
-var plane_1 = require("../plane");
-var arc_1 = require("../arc");
-var plane_plane_1 = require("./plane-plane");
-var line_sphere_1 = require("./line-sphere");
-var _intersectionLine = /*@__PURE__*/ line_1.line.create();
-var _originPlane = /*@__PURE__*/ plane_1.plane.create();
+import { EPSILON } from "../constants";
+import { vec3 } from "../vec3";
+import { line } from "../line";
+import { plane } from "../plane";
+import { arc } from "../arc";
+import { planePlaneJuction } from "./plane-plane";
+import { lineSphereIntersection } from "./line-sphere";
+const _intersectionLine = /*@__PURE__*/ line.create();
+const _originPlane = /*@__PURE__*/ plane.create();
 _originPlane.distance = 0;
-var _originSphere = /*@__PURE__*/ { center: vec3_1.vec3.create(0, 0, 0), radius: 1 };
-var _intersectionPoints = /*@__PURE__*/ [vec3_1.vec3.create(), vec3_1.vec3.create()];
+const _originSphere = /*@__PURE__*/ { center: vec3.create(0, 0, 0), radius: 1 };
+const _intersectionPoints = /*@__PURE__*/ [vec3.create(), vec3.create()];
 // TODO: out must be [Arc, Arc] there is a case where split into three arcs, visible by points or arcs but middle is not visible
 /**
  *
@@ -21,24 +18,24 @@ var _intersectionPoints = /*@__PURE__*/ [vec3_1.vec3.create(), vec3_1.vec3.creat
  * @param juctionPlane
  * @returns number of arcs segments in the junction divided by the junction plane.
  */
-function arcSlice(out, inArc, juctionPlane) {
+export function arcSlice(out, inArc, juctionPlane) {
     // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
-    var coverRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(inArc.coverPlane);
-    var visibleRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(juctionPlane);
+    const coverRadiusAngle = plane.getUnitSphereRadiusAngle(inArc.coverPlane);
+    const visibleRadiusAngle = plane.getUnitSphereRadiusAngle(juctionPlane);
     // TODO: RESEARCH efficient approach --
-    var angleBetween_Cover_Visible = Math.acos(vec3_1.vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
-    if (coverRadiusAngle + visibleRadiusAngle < angleBetween_Cover_Visible - constants_1.EPSILON) { // case A: out of range
+    const angleBetween_Cover_Visible = Math.acos(vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
+    if (coverRadiusAngle + visibleRadiusAngle < angleBetween_Cover_Visible - EPSILON) { // case A: out of range
         return 0; // No intersection
     }
     // ------------------------------------
     // the case when the arc is completely covered by the juction plane
-    if (visibleRadiusAngle + constants_1.EPSILON >= angleBetween_Cover_Visible + coverRadiusAngle) { // case B: fully visible
-        arc_1.arc.copy(out[0], inArc);
+    if (visibleRadiusAngle + EPSILON >= angleBetween_Cover_Visible + coverRadiusAngle) { // case B: fully visible
+        arc.copy(out[0], inArc);
         return 1;
     }
     // plane-plane intersection line should be calculated for the rest of the calculations
-    vec3_1.vec3.copy(_originPlane.normal, inArc.normal);
-    var isPlaneJunctions = (0, plane_plane_1.planePlaneJuction)(_intersectionLine, _originPlane, juctionPlane);
+    vec3.copy(_originPlane.normal, inArc.normal);
+    const isPlaneJunctions = planePlaneJuction(_intersectionLine, _originPlane, juctionPlane);
     if (!isPlaneJunctions) { // case C: planes are parallel. 
         // case A covers opposite directions
         // case B Covers they face each other
@@ -46,38 +43,38 @@ function arcSlice(out, inArc, juctionPlane) {
     }
     // --- read until here ---
     // calculate the intersection points
-    var isSphereIntersection = (0, line_sphere_1.lineSphereIntersection)(_intersectionPoints, _intersectionLine, _originSphere);
+    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
     if (!isSphereIntersection) {
         // other edge caes should be covered by now
         return 0; // No intersection
     }
-    var i0IsCovered = plane_1.plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -constants_1.EPSILON;
-    var i1IsCovered = plane_1.plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -constants_1.EPSILON;
-    var p0IsVisible = plane_1.plane.distanceToPoint(juctionPlane, inArc.p0) > -constants_1.EPSILON;
-    var p1IsVisible = plane_1.plane.distanceToPoint(juctionPlane, inArc.p1) > -constants_1.EPSILON;
+    const i0IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
+    const i1IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
+    const p0IsVisible = plane.distanceToPoint(juctionPlane, inArc.p0) > -EPSILON;
+    const p1IsVisible = plane.distanceToPoint(juctionPlane, inArc.p1) > -EPSILON;
     if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
         return 0; // No intersection
     }
     if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
         // calculate which points are closer
-        var p0i0DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
-        var p0i1DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
-        var case0 = p0i0DistanceSquared < p0i1DistanceSquared;
-        arc_1.arc.set(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
-        arc_1.arc.set(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        const p0i0DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
+        const p0i1DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
+        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
+        arc.set(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        arc.set(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
         return 2;
     }
     if (i0IsCovered && i1IsCovered) {
-        arc_1.arc.set(out[0], _intersectionPoints[0], _intersectionPoints[1]);
+        arc.set(out[0], _intersectionPoints[0], _intersectionPoints[1]);
         return 1;
     }
     if (p0IsVisible && p1IsVisible) {
-        arc_1.arc.copy(out[0], inArc);
+        arc.copy(out[0], inArc);
         return 1;
     }
     if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
         throw new Error("Unexpected case: one covered and one visible point must be present");
     }
-    arc_1.arc.set(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
+    arc.set(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
     return 1;
 }

package/Math/juction/line-sphere.js

@@ -1,25 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lineSphereIntersection = lineSphereIntersection;
-var vec3_1 = require("../vec3");
-var line_1 = require("../line");
-var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
-function lineSphereIntersection(out, inLine, inSphere) {
-    vec3_1.vec3.subtract(_0vector, inLine.origin, inSphere.center);
-    var distanceSquared = vec3_1.vec3.lengthSquared(_0vector);
-    var radiusSquared = inSphere.radius * inSphere.radius;
-    var dot = vec3_1.vec3.dot(_0vector, inLine.direction);
-    var dotSquared = dot * dot;
-    var _a = dotSquared + radiusSquared - distanceSquared;
+import { vec3 } from "../vec3";
+import { line } from "../line";
+const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+export function lineSphereIntersection(out, inLine, inSphere) {
+    vec3.subtract(_0vector, inLine.origin, inSphere.center);
+    const distanceSquared = vec3.lengthSquared(_0vector);
+    const radiusSquared = inSphere.radius * inSphere.radius;
+    const dot = vec3.dot(_0vector, inLine.direction);
+    const dotSquared = dot * dot;
+    const _a = dotSquared + radiusSquared - distanceSquared;
     if (_a < 0) {
         return false; // no intersection
     }
     else {
-        var a = Math.sqrt(_a);
-        var t1 = dot - a;
-        var t2 = dot + a;
-        line_1.line.at(out[0], inLine, t1);
-        line_1.line.at(out[1], inLine, t2);
+        const a = Math.sqrt(_a);
+        const t1 = dot - a;
+        const t2 = dot + a;
+        line.at(out[0], inLine, t1);
+        line.at(out[1], inLine, t2);
         return true;
     }
 }

package/Math/juction/plane-plane.js

@@ -1,34 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.planePlaneJuction = planePlaneJuction;
-var constants_1 = require("../constants");
-var vec3_1 = require("../vec3");
-var _normal1 = vec3_1.vec3.create();
-var _normal2 = vec3_1.vec3.create();
-function planePlaneJuction(out, plane1, plane2) {
-    vec3_1.vec3.copy(_normal1, plane1.normal);
-    vec3_1.vec3.copy(_normal2, plane2.normal);
-    var distance1 = plane1.distance;
-    var distance2 = plane2.distance;
-    var origin = out.origin, direction = out.direction;
-    var dot = vec3_1.vec3.dot(_normal1, _normal2);
-    if (Math.abs(dot) > 1 - constants_1.EPSILON) {
+import { EPSILON } from "../constants";
+import { vec3 } from "../vec3";
+const _normal1 = vec3.create();
+const _normal2 = vec3.create();
+export function planePlaneJuction(out, plane1, plane2) {
+    vec3.copy(_normal1, plane1.normal);
+    vec3.copy(_normal2, plane2.normal);
+    const distance1 = plane1.distance;
+    const distance2 = plane2.distance;
+    const { origin, direction } = out;
+    const dot = vec3.dot(_normal1, _normal2);
+    if (Math.abs(dot) > 1 - EPSILON) {
         return false; // Planes are parallel, no intersection
     }
-    vec3_1.vec3.cross(direction, _normal1, _normal2);
-    var magnitudeSquired = vec3_1.vec3.lengthSquared(out.direction);
-    if (magnitudeSquired < constants_1.EPSILON) {
+    vec3.cross(direction, _normal1, _normal2);
+    const magnitudeSquired = vec3.lengthSquared(out.direction);
+    if (magnitudeSquired < EPSILON) {
         return false; // No valid intersection line
     }
-    var magnitude = Math.sqrt(magnitudeSquired);
+    const magnitude = Math.sqrt(magnitudeSquired);
     direction[0] /= magnitude;
     direction[1] /= magnitude;
     direction[2] /= magnitude;
-    var determinant;
+    let determinant;
     // Calculate the intersection point
     // set z = 0
     determinant = _normal1[0] * _normal2[1] - _normal1[1] * _normal2[0];
-    if (Math.abs(determinant) > constants_1.EPSILON) {
+    if (Math.abs(determinant) > EPSILON) {
         origin[0] = (distance1 * _normal2[1] - distance2 * _normal1[1]) / determinant;
         origin[1] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
         origin[2] = 0;
@@ -36,7 +33,7 @@ function planePlaneJuction(out, plane1, plane2) {
     else {
         // set y = 0
         determinant = _normal1[0] * _normal2[2] - _normal1[2] * _normal2[0];
-        if (Math.abs(determinant) > constants_1.EPSILON) {
+        if (Math.abs(determinant) > EPSILON) {
             origin[0] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
             origin[1] = 0;
             origin[2] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
@@ -44,7 +41,7 @@ function planePlaneJuction(out, plane1, plane2) {
         else {
             // set x = 0
             determinant = _normal1[1] * _normal2[2] - _normal1[2] * _normal2[1];
-            if (Math.abs(determinant) > constants_1.EPSILON) {
+            if (Math.abs(determinant) > EPSILON) {
                 origin[0] = 0;
                 origin[1] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
                 origin[2] = (distance2 * _normal1[1] - distance1 * _normal2[1]) / determinant;