@pirireis/webglobeplugins 0.9.12 → 0.9.13

package/Math/angle-calculation.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bearingRealAngle = bearingRealAngle;
 function bearingRealAngle(long, lat, endLong, endLat) {
     const rLong = Radians * long;
     const rLat = Radians * lat;
@@ -13,3 +10,4 @@ function bearingRealAngle(long, lat, endLong, endLat) {
     initialBearing = (initialBearing + 360) % 360;
     return initialBearing;
 }
+export { bearingRealAngle };

package/Math/arc.js

@@ -1,21 +1,18 @@
-"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);
-exports.arc = Object.freeze({
+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_1.vec3.create(0, 0, 0);
-        vec3_1.vec3.cross(normal, 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_1.vec3.normalize(coverPlaneNormal, coverPlaneNormal);
-        const dot = vec3_1.vec3.dot(coverPlaneNormal, p0);
+        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
@@ -23,40 +20,40 @@ exports.arc = Object.freeze({
         };
     },
     set(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);
+        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_1.vec3.normalize(coverPlaneNormal, coverPlaneNormal);
+        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(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);
+        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(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(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;
+        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(a, b) {
-        return vec3_1.vec3.equals(a.p0, b.p0) && vec3_1.vec3.equals(a.p1, b.p1);
+        return vec3.equals(a.p0, b.p0) && vec3.equals(a.p1, b.p1);
     },
     populatePoints(out, arc, count) {
         // rotate p0 around normal vector with a quaternion

package/Math/bounds/line-bbox.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGreatCircleArcBBox = getGreatCircleArcBBox;
 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));
@@ -110,6 +107,7 @@ function degreesToRadians(deg) {
 function radiansToDegrees(rad) {
     return rad * 180 / Math.PI;
 }
+export { getGreatCircleArcBBox };
 // Test Case 1: London to Tokyo
 const lat1Deg = 51.5, lon1Deg = -0.1;
 const lat2Deg = 35.7, lon2Deg = 139.7;

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;
 const WORLD_RADIUS_3D = 6378.137;
-exports.WORLD_RADIUS_3D = WORLD_RADIUS_3D;
 const WORLD_RADIUS_MERCATOR = 6378136.99911;
-exports.WORLD_RADIUS_MERCATOR = WORLD_RADIUS_MERCATOR;
 const EPSILON = 1e-10; // Used for floating point comparisons
-exports.EPSILON = EPSILON;
+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;
-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();
+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;
-const _originSphere = /*@__PURE__*/ { center: vec3_1.vec3.create(0, 0, 0), radius: 1 };
-const _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 @@ const _intersectionPoints = /*@__PURE__*/ [vec3_1.vec3.create(), vec3_1.vec3.cre
  * @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
-    const coverRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(inArc.coverPlane);
-    const visibleRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(juctionPlane);
+    const coverRadiusAngle = plane.getUnitSphereRadiusAngle(inArc.coverPlane);
+    const visibleRadiusAngle = plane.getUnitSphereRadiusAngle(juctionPlane);
     // TODO: RESEARCH efficient approach --
-    const 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);
-    const 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
-    const 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
     }
-    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;
+    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
-        const p0i0DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
-        const p0i1DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
+        const p0i0DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
+        const p0i1DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
         const 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]);
+        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,14 +1,11 @@
-"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);
-function lineSphereIntersection(out, inLine, inSphere) {
-    vec3_1.vec3.subtract(_0vector, inLine.origin, inSphere.center);
-    const distanceSquared = vec3_1.vec3.lengthSquared(_0vector);
+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_1.vec3.dot(_0vector, inLine.direction);
+    const dot = vec3.dot(_0vector, inLine.direction);
     const dotSquared = dot * dot;
     const _a = dotSquared + radiusSquared - distanceSquared;
     if (_a < 0) {
@@ -18,8 +15,8 @@ function lineSphereIntersection(out, inLine, inSphere) {
         const a = Math.sqrt(_a);
         const t1 = dot - a;
         const t2 = dot + a;
-        line_1.line.at(out[0], inLine, t1);
-        line_1.line.at(out[1], inLine, t2);
+        line.at(out[0], inLine, t1);
+        line.at(out[1], inLine, t2);
         return true;
     }
 }

package/Math/juction/plane-plane.js

@@ -1,23 +1,20 @@
-"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();
-function planePlaneJuction(out, plane1, plane2) {
-    vec3_1.vec3.copy(_normal1, plane1.normal);
-    vec3_1.vec3.copy(_normal2, plane2.normal);
+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_1.vec3.dot(_normal1, _normal2);
-    if (Math.abs(dot) > 1 - constants_1.EPSILON) {
+    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);
-    const 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
     }
     const magnitude = Math.sqrt(magnitudeSquired);
@@ -28,7 +25,7 @@ function planePlaneJuction(out, plane1, plane2) {
     // 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;

package/Math/line.js

@@ -1,56 +1,53 @@
-"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);
-exports.line = Object.freeze({
-    create(origin = vec3_1.vec3.create(), direction = vec3_1.vec3.create()) {
-        const direction_ = vec3_1.vec3.clone(direction);
-        vec3_1.vec3.normalize(direction_, direction_);
+import { EPSILON } from './constants';
+import { vec3 } from './vec3';
+const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+export const line = Object.freeze({
+    create(origin = vec3.create(), direction = vec3.create()) {
+        const direction_ = vec3.clone(direction);
+        vec3.normalize(direction_, direction_);
         return {
-            origin: vec3_1.vec3.clone(origin),
+            origin: vec3.clone(origin),
             direction: direction_
         };
     },
     set(out, origin, direction) {
-        vec3_1.vec3.copy(out.origin, origin);
-        vec3_1.vec3.copy(out.direction, direction);
+        vec3.copy(out.origin, origin);
+        vec3.copy(out.direction, direction);
     },
     copy(out, a) {
-        out.origin = vec3_1.vec3.copy(out.origin, a.origin);
-        out.direction = vec3_1.vec3.copy(out.direction, a.direction);
+        out.origin = vec3.copy(out.origin, a.origin);
+        out.direction = vec3.copy(out.direction, a.direction);
     },
     clone(a) {
         return {
-            origin: vec3_1.vec3.clone(a.origin),
-            direction: vec3_1.vec3.clone(a.direction)
+            origin: vec3.clone(a.origin),
+            direction: vec3.clone(a.direction)
         };
     },
     fromTwoPoints(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);
+        vec3.subtract(out.direction, b, a);
+        vec3.normalize(out.direction, out.direction);
+        vec3.copy(out.origin, a);
     },
     at(out, line, distance) {
-        vec3_1.vec3.multiplyScalar(_0vector, line.direction, distance);
-        vec3_1.vec3.add(out, _0vector, line.origin);
+        vec3.multiplyScalar(_0vector, line.direction, distance);
+        vec3.add(out, _0vector, line.origin);
     },
     closestPoint(out, line, point) {
-        vec3_1.vec3.subtract(_0vector, point, line.origin);
-        const 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);
+        vec3.subtract(_0vector, point, line.origin);
+        const dot = vec3.dot(_0vector, line.direction);
+        vec3.copy(out, line.direction);
+        vec3.multiplyScalar(out, out, dot);
+        vec3.add(out, out, line.origin);
     },
     contains(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;
+        vec3.subtract(_0vector, point, line.origin);
+        vec3.cross(_0vector, _0vector, line.direction);
+        return vec3.lengthSquared(_0vector) < EPSILON;
     },
     applyQuaternion(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);
+        vec3.applyQuaternion(out.origin, line.origin, quaternion);
+        vec3.applyQuaternion(out.direction, line.direction, quaternion);
+        vec3.normalize(out.direction, out.direction);
     }
 });

package/Math/methods.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.globe2Dcoordinates = exports.globe3Dcoordinates = exports.pixelXYLenghtToUnitVectorWithHeight = exports.wgs84ToMercator = exports.wgs84ToCartesian3d = exports.wgs84ToUnitVector = exports.sphericalLinearInterpolation_Cartesian3d = exports.sphericalLinearInterpolation_Mercator = exports.sphericalLinearInterpolation_UnitVector = exports.radianToCartesian3d = exports.radianToMercator = exports.cartesian3dToRadian = exports.length3 = exports.dot3 = exports.normalize3 = exports.RADIANS = void 0;
-const constants_1 = require("./constants");
+import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants';
 /**
  * @typedef {Array<number>} vec3 [x, y, z]
  * @typedef {Array<number>} vec2 [x, y]
@@ -13,7 +10,6 @@ const constants_1 = require("./constants");
 // **************** VECTOR OPERATIONS **********************
 // *********************************************************
 const RADIANS = Math.PI / 180;
-exports.RADIANS = RADIANS;
 /**
  * @param {vec3} a
  * @returns {vec3}
@@ -22,7 +18,6 @@ const normalize3 = (a) => {
     const len = length3(a);
     return [a[0] / len, a[1] / len, a[2] / len];
 };
-exports.normalize3 = normalize3;
 /**
  * @param {vec3} a
  * @param {vec3} b
@@ -31,7 +26,6 @@ exports.normalize3 = normalize3;
 const dot3 = (a, b) => {
     return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 };
-exports.dot3 = dot3;
 /**
  * @param {vec3} a
  * @returns {number}
@@ -39,7 +33,6 @@ exports.dot3 = dot3;
 const length3 = (a) => {
     return Math.sqrt(dot3(a, a));
 };
-exports.length3 = length3;
 // *********************************************************
 // **************** TRANSFORMATIONS ************************
 // *********************************************************
@@ -56,15 +49,13 @@ const cartesian3dToRadian = (cartesian) => {
     const lat = Math.asin(z); // length);
     return [long, lat];
 };
-exports.cartesian3dToRadian = cartesian3dToRadian;
 /**
  * @param {vec2} xy long lat in radians
  * @returns {vec2} long lat in mercator meters
  */
 const radianToMercator = (xy) => {
-    return [constants_1.WORLD_RADIUS_MERCATOR * xy[0], constants_1.WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
+    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
 };
-exports.radianToMercator = radianToMercator;
 /**
  * @param {vec2} xy long lat radians
  * @returns {vec3} cartesian
@@ -75,7 +66,6 @@ const radianToCartesian3d = (xy) => {
     const z = -Math.sin(xy[1]);
     return [x, y, z];
 };
-exports.radianToCartesian3d = radianToCartesian3d;
 // *********************************************************
 // ***************** INTERPOLATIONS ************************
 // *********************************************************
@@ -97,7 +87,6 @@ const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio
     ];
     return result;
 };
-exports.sphericalLinearInterpolation_UnitVector = sphericalLinearInterpolation_UnitVector;
 /**
  * @param {vec3} normalizedA
  * @param {vec3} normalizedB
@@ -109,7 +98,6 @@ const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio)
     const angles = cartesian3dToRadian(unitVector);
     return radianToMercator(angles);
 };
-exports.sphericalLinearInterpolation_Mercator = sphericalLinearInterpolation_Mercator;
 /**
  * @param {vec4} a vec3 unit vector and length
  * @param {vec4} b vec3 unit vector and length
@@ -120,7 +108,6 @@ const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
     const height = a[3] + (b[3] - a[3]) * ratio;
     return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];
 };
-exports.sphericalLinearInterpolation_Cartesian3d = sphericalLinearInterpolation_Cartesian3d;
 /**
  *
  * @param {wgs84} coordinates
@@ -134,7 +121,6 @@ const wgs84ToUnitVector = (coordinates) => {
     const z = Math.sin(lat);
     return [x, y, z];
 };
-exports.wgs84ToUnitVector = wgs84ToUnitVector;
 /**
  * @param {number} long wgs84
  * @param {number} lat wgs84
@@ -147,19 +133,17 @@ const wgs84ToCartesian3d = (long, lat, height) => {
     const x = Math.cos(latRad) * Math.cos(longRad);
     const y = Math.cos(latRad) * Math.sin(longRad);
     const z = Math.sin(latRad);
-    const radius = constants_1.WORLD_RADIUS_3D + height;
+    const radius = WORLD_RADIUS_3D + height;
     return [x * radius, y * radius, z * radius];
 };
-exports.wgs84ToCartesian3d = wgs84ToCartesian3d;
 /**
  * @param {number} long
  * @param {number} lat
  * @returns {vec2} mercator
  */
 const wgs84ToMercator = (long, lat) => {
-    return [constants_1.WORLD_RADIUS_MERCATOR * long * RADIANS, constants_1.WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))];
+    return [WORLD_RADIUS_MERCATOR * long * RADIANS, WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))];
 };
-exports.wgs84ToMercator = wgs84ToMercator;
 /**
  * @param {vec2} pixelXY
  * @returns {vec2} long lat in radians
@@ -171,10 +155,9 @@ const pixelXYToRadians = (pixelXY) => {
 };
 const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
     const [long, lat] = pixelXYToRadians(pixelXYHeight);
-    const radius = constants_1.WORLD_RADIUS_3D + pixelXYHeight[2];
+    const radius = WORLD_RADIUS_3D + pixelXYHeight[2];
     return radianToCartesian3d([long, lat]).concat(radius);
 };
-exports.pixelXYLenghtToUnitVectorWithHeight = pixelXYLenghtToUnitVectorWithHeight;
 const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
     const len = longlats.length / 2;
     const result = new Float32Array(len * 3 + paddingCount * 3).fill(paddingValue);
@@ -186,7 +169,6 @@ const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0,
     }
     return result;
 };
-exports.globe3Dcoordinates = globe3Dcoordinates;
 const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
     const len = longlats.length / 2;
     const result = new Float32Array(len * 2 + paddingCount * 2).fill(paddingValue);
@@ -198,4 +180,4 @@ const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValu
     }
     return result;
 };
-exports.globe2Dcoordinates = globe2Dcoordinates;
+export { RADIANS, normalize3, dot3, length3, cartesian3dToRadian, radianToMercator, radianToCartesian3d, sphericalLinearInterpolation_UnitVector, sphericalLinearInterpolation_Mercator, sphericalLinearInterpolation_Cartesian3d, wgs84ToUnitVector, wgs84ToCartesian3d, wgs84ToMercator, pixelXYLenghtToUnitVectorWithHeight, globe3Dcoordinates, globe2Dcoordinates, };