@pirireis/webglobeplugins 0.9.10 → 0.9.11

package/Math/angle-calculation.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bearingRealAngle = bearingRealAngle;
 function bearingRealAngle(long, lat, endLong, endLat) {
-    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;
+    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;
     initialBearing = (initialBearing + 360) % 360;
     return initialBearing;
 }

package/Math/arc.js

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

package/Math/bounds/line-bbox.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGreatCircleArcBBox = getGreatCircleArcBBox;
-function isClose(a, b, rtol = 1e-5, atol = 1e-8) {
+function isClose(a, b, rtol, atol) {
+    if (rtol === void 0) { rtol = 1e-5; }
+    if (atol === void 0) { atol = 1e-8; }
     // JavaScript equivalent of NumPy's isclose
     return Math.abs(a - b) <= (atol + rtol * Math.abs(b));
 }
@@ -19,10 +21,10 @@ function calculateInitialBearing(phi1, lambda1, phi2, lambda2) {
             return 0; // Bearing is North
         }
     }
-    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);
+    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);
     return theta;
 }
 function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
@@ -35,23 +37,23 @@ function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
         return [phi1Rad, phi1Rad, lambda1Rad, lambda1Rad];
     }
     // === Edge Case: Antipodal Points ===
-    const deltaLambdaNorm = mod(lambda1Rad - lambda2Rad + Math.PI, 2 * Math.PI) - Math.PI;
+    var 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 ===
-    let lambda1Adj = lambda1Rad;
-    let lambda2Adj = lambda2Rad;
+    var lambda1Adj = lambda1Rad;
+    var lambda2Adj = lambda2Rad;
     // Handle antimeridian crossing
-    let deltaLambda = lambda2Rad - lambda1Rad;
+    var deltaLambda = lambda2Rad - lambda1Rad;
     if (deltaLambda > Math.PI) {
         deltaLambda -= 2 * Math.PI;
     }
     else if (deltaLambda <= -Math.PI) {
         deltaLambda += 2 * Math.PI;
     }
-    const crossesAntimeridian = Math.abs(lambda2Rad - lambda1Rad) > Math.PI;
+    var crossesAntimeridian = Math.abs(lambda2Rad - lambda1Rad) > Math.PI;
     if (crossesAntimeridian) {
         // Add 2*pi to the smaller longitude
         if (lambda1Rad < lambda2Rad) {
@@ -61,20 +63,20 @@ function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
             lambda2Adj += 2 * Math.PI;
         }
     }
-    const lambdaMin = Math.min(lambda1Adj, lambda2Adj);
-    const lambdaMax = Math.max(lambda1Adj, lambda2Adj);
+    var lambdaMin = Math.min(lambda1Adj, lambda2Adj);
+    var lambdaMax = Math.max(lambda1Adj, lambda2Adj);
     // === Latitude Bounds ===
-    let phiMin = Math.min(phi1Rad, phi2Rad);
-    let phiMax = Math.max(phi1Rad, phi2Rad);
+    var phiMin = Math.min(phi1Rad, phi2Rad);
+    var phiMax = Math.max(phi1Rad, phi2Rad);
     // === Vertex Check ===
     // Check the maximum/minimum latitude reached by the great circle
-    const theta12 = calculateInitialBearing(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad);
-    const theta21 = calculateInitialBearing(phi2Rad, lambda2Rad, phi1Rad, lambda1Rad);
-    const cosPhi1 = Math.cos(phi1Rad);
+    var theta12 = calculateInitialBearing(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad);
+    var theta21 = calculateInitialBearing(phi2Rad, lambda2Rad, phi1Rad, lambda1Rad);
+    var cosPhi1 = Math.cos(phi1Rad);
     if (!isClose(cosPhi1, 0)) { // Starting point is not a pole
         // Compute the absolute latitude of the vertex
-        const argAcos = Math.abs(Math.sin(theta12) * cosPhi1);
-        const phiVtxAbs = Math.acos(Math.min(Math.max(argAcos, -1.0), 1.0));
+        var argAcos = Math.abs(Math.sin(theta12) * cosPhi1);
+        var 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;
@@ -84,7 +86,7 @@ function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
         }
         else {
             // General case: Check if the path crosses the vertex
-            const finalBearingAtP2 = mod(theta21 + Math.PI + Math.PI, 2 * Math.PI) - Math.PI;
+            var 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)) {
@@ -111,78 +113,78 @@ function radiansToDegrees(rad) {
     return rad * 180 / Math.PI;
 }
 // Test Case 1: London to Tokyo
-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);
+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);
 console.log("Input Points (Radians):");
-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("  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("-".repeat(20));
 console.log("Bounding Box (Radians):");
 // console phys://console.log(`  Minimum Latitude (phi_min): ${phiMinRad.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("  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("-".repeat(20));
 console.log("Bounding Box (Degrees):");
-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)}°`);
+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"));
 // --- Antimeridian Crossing Test ---
 console.log("\n" + "=".repeat(30));
 console.log("Antimeridian Crossing Test");
-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})`);
+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, ")"));
 console.log("Bounding Box (Radians):");
-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("  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("Bounding Box (Degrees):");
-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°)`);
+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)"));
 // --- Polar Crossing Test ---
 console.log("\n" + "=".repeat(30));
 console.log("Polar Crossing Test");
-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})`);
+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, ")"));
 console.log("Bounding Box (Radians):");
-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("  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("Bounding Box (Degrees):");
-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)}°`);
+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"));
 // --- line points intersection with bbox ---

package/Math/constants.js

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

package/Math/juction/arc-plane.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.arcSlice = arcSlice;
-const constants_1 = require("../constants");
-const vec3_1 = require("../vec3");
-const line_1 = require("../line");
-const plane_1 = require("../plane");
-const arc_1 = require("../arc");
-const plane_plane_1 = require("./plane-plane");
-const line_sphere_1 = require("./line-sphere");
-const _intersectionLine = /*@__PURE__*/ line_1.line.create();
-const _originPlane = /*@__PURE__*/ plane_1.plane.create();
+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();
 _originPlane.distance = 0;
-const _originSphere = /*@__PURE__*/ { center: vec3_1.vec3.create(0, 0, 0), radius: 1 };
-const _intersectionPoints = /*@__PURE__*/ [vec3_1.vec3.create(), vec3_1.vec3.create()];
+var _originSphere = /*@__PURE__*/ { center: vec3_1.vec3.create(0, 0, 0), radius: 1 };
+var _intersectionPoints = /*@__PURE__*/ [vec3_1.vec3.create(), vec3_1.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
 /**
  *
@@ -23,10 +23,10 @@ const _intersectionPoints = /*@__PURE__*/ [vec3_1.vec3.create(), vec3_1.vec3.cre
  */
 function arcSlice(out, inArc, juctionPlane) {
     // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
-    const coverRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(inArc.coverPlane);
-    const visibleRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(juctionPlane);
+    var coverRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(inArc.coverPlane);
+    var visibleRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(juctionPlane);
     // TODO: RESEARCH efficient approach --
-    const angleBetween_Cover_Visible = Math.acos(vec3_1.vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
+    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
         return 0; // No intersection
     }
@@ -38,7 +38,7 @@ function arcSlice(out, inArc, juctionPlane) {
     }
     // plane-plane intersection line should be calculated for the rest of the calculations
     vec3_1.vec3.copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = (0, plane_plane_1.planePlaneJuction)(_intersectionLine, _originPlane, juctionPlane);
+    var isPlaneJunctions = (0, plane_plane_1.planePlaneJuction)(_intersectionLine, _originPlane, juctionPlane);
     if (!isPlaneJunctions) { // case C: planes are parallel. 
         // case A covers opposite directions
         // case B Covers they face each other
@@ -46,23 +46,23 @@ function arcSlice(out, inArc, juctionPlane) {
     }
     // --- read until here ---
     // calculate the intersection points
-    const isSphereIntersection = (0, line_sphere_1.lineSphereIntersection)(_intersectionPoints, _intersectionLine, _originSphere);
+    var isSphereIntersection = (0, line_sphere_1.lineSphereIntersection)(_intersectionPoints, _intersectionLine, _originSphere);
     if (!isSphereIntersection) {
         // other edge caes should be covered by now
         return 0; // No intersection
     }
-    const i0IsCovered = plane_1.plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -constants_1.EPSILON;
-    const i1IsCovered = plane_1.plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -constants_1.EPSILON;
-    const p0IsVisible = plane_1.plane.distanceToPoint(juctionPlane, inArc.p0) > -constants_1.EPSILON;
-    const p1IsVisible = plane_1.plane.distanceToPoint(juctionPlane, inArc.p1) > -constants_1.EPSILON;
+    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;
     if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
         return 0; // No intersection
     }
     if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
         // calculate which points are closer
-        const p0i0DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
-        const p0i1DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
-        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
+        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]);
         return 2;

package/Math/juction/line-sphere.js

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lineSphereIntersection = lineSphereIntersection;
-const vec3_1 = require("../vec3");
-const line_1 = require("../line");
-const _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
+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);
-    const distanceSquared = vec3_1.vec3.lengthSquared(_0vector);
-    const radiusSquared = inSphere.radius * inSphere.radius;
-    const dot = vec3_1.vec3.dot(_0vector, inLine.direction);
-    const dotSquared = dot * dot;
-    const _a = dotSquared + radiusSquared - distanceSquared;
+    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;
     if (_a < 0) {
         return false; // no intersection
     }
     else {
-        const a = Math.sqrt(_a);
-        const t1 = dot - a;
-        const t2 = dot + a;
+        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);
         return true;

package/Math/juction/plane-plane.js

@@ -1,30 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.planePlaneJuction = planePlaneJuction;
-const constants_1 = require("../constants");
-const vec3_1 = require("../vec3");
-const _normal1 = vec3_1.vec3.create();
-const _normal2 = vec3_1.vec3.create();
+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);
-    const distance1 = plane1.distance;
-    const distance2 = plane2.distance;
-    const { origin, direction } = out;
-    const dot = vec3_1.vec3.dot(_normal1, _normal2);
+    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) {
         return false; // Planes are parallel, no intersection
     }
     vec3_1.vec3.cross(direction, _normal1, _normal2);
-    const magnitudeSquired = vec3_1.vec3.lengthSquared(out.direction);
+    var magnitudeSquired = vec3_1.vec3.lengthSquared(out.direction);
     if (magnitudeSquired < constants_1.EPSILON) {
         return false; // No valid intersection line
     }
-    const magnitude = Math.sqrt(magnitudeSquired);
+    var magnitude = Math.sqrt(magnitudeSquired);
     direction[0] /= magnitude;
     direction[1] /= magnitude;
     direction[2] /= magnitude;
-    let determinant;
+    var determinant;
     // Calculate the intersection point
     // set z = 0
     determinant = _normal1[0] * _normal2[1] - _normal1[1] * _normal2[0];

package/Math/line.js

@@ -1,54 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.line = void 0;
-const constants_1 = require("./constants");
-const vec3_1 = require("./vec3");
-const _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
+var constants_1 = require("./constants");
+var vec3_1 = require("./vec3");
+var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
 exports.line = Object.freeze({
-    create(origin = vec3_1.vec3.create(), direction = vec3_1.vec3.create()) {
-        const direction_ = vec3_1.vec3.clone(direction);
+    create: function (origin, direction) {
+        if (origin === void 0) { origin = vec3_1.vec3.create(); }
+        if (direction === void 0) { direction = vec3_1.vec3.create(); }
+        var direction_ = vec3_1.vec3.clone(direction);
         vec3_1.vec3.normalize(direction_, direction_);
         return {
             origin: vec3_1.vec3.clone(origin),
             direction: direction_
         };
     },
-    set(out, origin, direction) {
+    set: function (out, origin, direction) {
         vec3_1.vec3.copy(out.origin, origin);
         vec3_1.vec3.copy(out.direction, direction);
     },
-    copy(out, a) {
+    copy: function (out, a) {
         out.origin = vec3_1.vec3.copy(out.origin, a.origin);
         out.direction = vec3_1.vec3.copy(out.direction, a.direction);
     },
-    clone(a) {
+    clone: function (a) {
         return {
             origin: vec3_1.vec3.clone(a.origin),
             direction: vec3_1.vec3.clone(a.direction)
         };
     },
-    fromTwoPoints(out, a, b) {
+    fromTwoPoints: function (out, a, b) {
         vec3_1.vec3.subtract(out.direction, b, a);
         vec3_1.vec3.normalize(out.direction, out.direction);
         vec3_1.vec3.copy(out.origin, a);
     },
-    at(out, line, distance) {
+    at: function (out, line, distance) {
         vec3_1.vec3.multiplyScalar(_0vector, line.direction, distance);
         vec3_1.vec3.add(out, _0vector, line.origin);
     },
-    closestPoint(out, line, point) {
+    closestPoint: function (out, line, point) {
         vec3_1.vec3.subtract(_0vector, point, line.origin);
-        const dot = vec3_1.vec3.dot(_0vector, line.direction);
+        var dot = vec3_1.vec3.dot(_0vector, line.direction);
         vec3_1.vec3.copy(out, line.direction);
         vec3_1.vec3.multiplyScalar(out, out, dot);
         vec3_1.vec3.add(out, out, line.origin);
     },
-    contains(line, point) {
+    contains: function (line, point) {
         vec3_1.vec3.subtract(_0vector, point, line.origin);
         vec3_1.vec3.cross(_0vector, _0vector, line.direction);
         return vec3_1.vec3.lengthSquared(_0vector) < constants_1.EPSILON;
     },
-    applyQuaternion(out, line, quaternion) {
+    applyQuaternion: function (out, line, quaternion) {
         vec3_1.vec3.applyQuaternion(out.origin, line.origin, quaternion);
         vec3_1.vec3.applyQuaternion(out.direction, line.direction, quaternion);
         vec3_1.vec3.normalize(out.direction, out.direction);