@pirireis/webglobeplugins 0.9.11 → 0.9.13

package/Math/line.js

@@ -1,58 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.line = void 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: 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_);
+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: function (out, origin, direction) {
-        vec3_1.vec3.copy(out.origin, origin);
-        vec3_1.vec3.copy(out.direction, direction);
+    set(out, origin, direction) {
+        vec3.copy(out.origin, origin);
+        vec3.copy(out.direction, direction);
     },
-    copy: function (out, a) {
-        out.origin = vec3_1.vec3.copy(out.origin, a.origin);
-        out.direction = vec3_1.vec3.copy(out.direction, a.direction);
+    copy(out, a) {
+        out.origin = vec3.copy(out.origin, a.origin);
+        out.direction = vec3.copy(out.direction, a.direction);
     },
-    clone: function (a) {
+    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: 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: function (out, line, distance) {
-        vec3_1.vec3.multiplyScalar(_0vector, line.direction, distance);
-        vec3_1.vec3.add(out, _0vector, line.origin);
-    },
-    closestPoint: function (out, line, point) {
-        vec3_1.vec3.subtract(_0vector, point, line.origin);
-        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: 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: 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);
+    fromTwoPoints(out, a, b) {
+        vec3.subtract(out.direction, b, a);
+        vec3.normalize(out.direction, out.direction);
+        vec3.copy(out.origin, a);
+    },
+    at(out, line, distance) {
+        vec3.multiplyScalar(_0vector, line.direction, distance);
+        vec3.add(out, _0vector, line.origin);
+    },
+    closestPoint(out, line, point) {
+        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.subtract(_0vector, point, line.origin);
+        vec3.cross(_0vector, _0vector, line.direction);
+        return vec3.lengthSquared(_0vector) < EPSILON;
+    },
+    applyQuaternion(out, line, quaternion) {
+        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;
-var 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]
@@ -12,34 +9,30 @@ var constants_1 = require("./constants");
 // *********************************************************
 // **************** VECTOR OPERATIONS **********************
 // *********************************************************
-var RADIANS = Math.PI / 180;
-exports.RADIANS = RADIANS;
+const RADIANS = Math.PI / 180;
 /**
  * @param {vec3} a
  * @returns {vec3}
  */
-var normalize3 = function (a) {
-    var len = length3(a);
+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
  * @returns {number}
  */
-var dot3 = function (a, b) {
+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}
  */
-var length3 = function (a) {
+const length3 = (a) => {
     return Math.sqrt(dot3(a, a));
 };
-exports.length3 = length3;
 // *********************************************************
 // **************** TRANSFORMATIONS ************************
 // *********************************************************
@@ -47,35 +40,32 @@ exports.length3 = length3;
  * @param {vec3} cartesian
  * @returns {vec2} long lat in radians
  */
-var cartesian3dToRadian = function (cartesian) {
-    var x = cartesian[0];
-    var y = cartesian[1];
-    var z = cartesian[2];
+const cartesian3dToRadian = (cartesian) => {
+    const x = cartesian[0];
+    const y = cartesian[1];
+    const z = cartesian[2];
     // const length = Math.sqrt(x * x + y * y + z * z);
-    var long = Math.atan2(y, x);
-    var lat = Math.asin(z); // length);
+    const long = Math.atan2(y, x);
+    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
  */
-var radianToMercator = function (xy) {
-    return [constants_1.WORLD_RADIUS_MERCATOR * xy[0], constants_1.WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
+const radianToMercator = (xy) => {
+    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
  */
-var radianToCartesian3d = function (xy) {
-    var x = Math.cos(xy[1]) * Math.cos(xy[0]);
-    var y = Math.cos(xy[1]) * Math.sin(xy[0]);
-    var z = -Math.sin(xy[1]);
+const radianToCartesian3d = (xy) => {
+    const x = Math.cos(xy[1]) * Math.cos(xy[0]);
+    const y = Math.cos(xy[1]) * Math.sin(xy[0]);
+    const z = -Math.sin(xy[1]);
     return [x, y, z];
 };
-exports.radianToCartesian3d = radianToCartesian3d;
 // *********************************************************
 // ***************** INTERPOLATIONS ************************
 // *********************************************************
@@ -85,122 +75,109 @@ exports.radianToCartesian3d = radianToCartesian3d;
  * @param {fraction} ratio
  * @returns {vec3}
  */
-var sphericalLinearInterpolation_UnitVector = function (normalizedA, normalizedB, ratio) {
-    var theta = Math.acos(dot3(normalizedA, normalizedB));
+const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {
+    const theta = Math.acos(dot3(normalizedA, normalizedB));
     if (theta < 0.000001)
         return normalizedA; // CALIBRATE?
-    var sinTheta = Math.sin(theta);
-    var result = [
+    const sinTheta = Math.sin(theta);
+    const result = [
         (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,
         (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,
         (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta
     ];
     return result;
 };
-exports.sphericalLinearInterpolation_UnitVector = sphericalLinearInterpolation_UnitVector;
 /**
  * @param {vec3} normalizedA
  * @param {vec3} normalizedB
  * @param {fraction} ratio
  * @returns
  */
-var sphericalLinearInterpolation_Mercator = function (normalizedA, normalizedB, ratio) {
-    var unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
-    var angles = cartesian3dToRadian(unitVector);
+const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(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
  * @param {fraction} ratio
  */
-var sphericalLinearInterpolation_Cartesian3d = function (a, b, ratio) {
-    var unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
-    var height = a[3] + (b[3] - a[3]) * ratio;
+const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(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
  * @returns {vec3}
  */
-var wgs84ToUnitVector = function (coordinates) {
-    var long = coordinates[0] * RADIANS;
-    var lat = coordinates[1] * RADIANS;
-    var x = Math.cos(lat) * Math.cos(long);
-    var y = Math.cos(lat) * Math.sin(long);
-    var z = Math.sin(lat);
+const wgs84ToUnitVector = (coordinates) => {
+    const long = coordinates[0] * RADIANS;
+    const lat = coordinates[1] * RADIANS;
+    const x = Math.cos(lat) * Math.cos(long);
+    const y = Math.cos(lat) * Math.sin(long);
+    const z = Math.sin(lat);
     return [x, y, z];
 };
-exports.wgs84ToUnitVector = wgs84ToUnitVector;
 /**
  * @param {number} long wgs84
  * @param {number} lat wgs84
  * @param {number} height
  * @returns {vec3} cartesian3D
  */
-var wgs84ToCartesian3d = function (long, lat, height) {
-    var longRad = long * RADIANS;
-    var latRad = lat * RADIANS;
-    var x = Math.cos(latRad) * Math.cos(longRad);
-    var y = Math.cos(latRad) * Math.sin(longRad);
-    var z = Math.sin(latRad);
-    var radius = constants_1.WORLD_RADIUS_3D + height;
+const wgs84ToCartesian3d = (long, lat, height) => {
+    const longRad = long * RADIANS;
+    const latRad = lat * RADIANS;
+    const x = Math.cos(latRad) * Math.cos(longRad);
+    const y = Math.cos(latRad) * Math.sin(longRad);
+    const z = Math.sin(latRad);
+    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
  */
-var wgs84ToMercator = function (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))];
+const wgs84ToMercator = (long, lat) => {
+    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
  */
-var pixelXYToRadians = function (pixelXY) {
-    var long = (2.0 * pixelXY[0] - 1.0) * Math.PI;
-    var lat = (2.0 * pixelXY[1] - 1.0) * Math.PI / 2.0;
+const pixelXYToRadians = (pixelXY) => {
+    const long = (2.0 * pixelXY[0] - 1.0) * Math.PI;
+    const lat = (2.0 * pixelXY[1] - 1.0) * Math.PI / 2.0;
     return [long, lat];
 };
-var pixelXYLenghtToUnitVectorWithHeight = function (pixelXYHeight) {
-    var _a = pixelXYToRadians(pixelXYHeight), long = _a[0], lat = _a[1];
-    var radius = constants_1.WORLD_RADIUS_3D + pixelXYHeight[2];
+const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
+    const [long, lat] = pixelXYToRadians(pixelXYHeight);
+    const radius = WORLD_RADIUS_3D + pixelXYHeight[2];
     return radianToCartesian3d([long, lat]).concat(radius);
 };
-exports.pixelXYLenghtToUnitVectorWithHeight = pixelXYLenghtToUnitVectorWithHeight;
-var globe3Dcoordinates = function (globe, height) {
-    if (height === void 0) { height = 0; }
-    return function (longlats, _a) {
-        var _b = _a.paddingCount, paddingCount = _b === void 0 ? 0 : _b, _c = _a.paddingValue, paddingValue = _c === void 0 ? NaN : _c;
-        var len = longlats.length / 2;
-        var result = new Float32Array(len * 3 + paddingCount * 3).fill(paddingValue);
-        for (var i = 0; i < len; i++) {
-            var long = longlats[i * 2];
-            var lat = longlats[i * 2 + 1];
-            var xyz = globe.api_GetCartesian3DPoint(long, lat, height, 0);
-            result.set(xyz, i * 3);
-        }
-        return result;
-    };
-};
-exports.globe3Dcoordinates = globe3Dcoordinates;
-var globe2Dcoordinates = function (globe) { return function (longlats, _a) {
-    var _b = _a.paddingCount, paddingCount = _b === void 0 ? 0 : _b, _c = _a.paddingValue, paddingValue = _c === void 0 ? NaN : _c;
-    var len = longlats.length / 2;
-    var result = new Float32Array(len * 2 + paddingCount * 2).fill(paddingValue);
-    for (var i = 0; i < len; i++) {
-        var long = longlats[i * 2];
-        var lat = longlats[i * 2 + 1];
-        var xyz = globe.api_GetMercator2DPoint(long, lat);
+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);
+    for (let i = 0; i < len; i++) {
+        const long = longlats[i * 2];
+        const lat = longlats[i * 2 + 1];
+        const xyz = globe.api_GetCartesian3DPoint(long, lat, height, 0);
+        result.set(xyz, i * 3);
+    }
+    return result;
+};
+const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
+    const len = longlats.length / 2;
+    const result = new Float32Array(len * 2 + paddingCount * 2).fill(paddingValue);
+    for (let i = 0; i < len; i++) {
+        const long = longlats[i * 2];
+        const lat = longlats[i * 2 + 1];
+        const xyz = globe.api_GetMercator2DPoint(long, lat);
         result.set(xyz, i * 2);
     }
     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, };

package/Math/plane.js

@@ -1,62 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.plane = void 0;
-var constants_1 = require("./constants");
-var vec3_1 = require("./vec3");
-var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
-var _1vector = /*@__PURE__*/ vec3_1.vec3.create(1, 1, 1);
-exports.plane = Object.freeze({
-    create: function (normal, distance) {
-        if (normal === void 0) { normal = vec3_1.vec3.create(); }
-        if (distance === void 0) { distance = 0; }
+import { EPSILON } from "./constants";
+import { vec3 } from "./vec3";
+const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+const _1vector = /*@__PURE__*/ vec3.create(1, 1, 1);
+export const plane = Object.freeze({
+    create(normal = vec3.create(), distance = 0) {
         return {
-            normal: vec3_1.vec3.clone(normal),
+            normal: vec3.clone(normal),
             distance: distance
         };
     },
-    set: function (out, normal, distance) {
-        vec3_1.vec3.copy(out.normal, normal);
+    set(out, normal, distance) {
+        vec3.copy(out.normal, normal);
         out.distance = distance;
         return out;
     },
-    fromValues: function (out, nx, ny, nz, distance) {
-        vec3_1.vec3.set(out.normal, nx, ny, nz);
+    fromValues(out, nx, ny, nz, distance) {
+        vec3.set(out.normal, nx, ny, nz);
         out.distance = distance;
     },
-    copy: function (out, a) {
-        vec3_1.vec3.copy(out.normal, a.normal);
+    copy(out, a) {
+        vec3.copy(out.normal, a.normal);
         out.distance = a.distance;
         return out;
     },
-    clone: function (a) {
+    clone(a) {
         return {
-            normal: vec3_1.vec3.clone(a.normal),
+            normal: vec3.clone(a.normal),
             distance: a.distance
         };
     },
-    distanceToPoint: function (plane, point) {
-        return vec3_1.vec3.dot(plane.normal, point) - plane.distance;
+    distanceToPoint(plane, point) {
+        return vec3.dot(plane.normal, point) - plane.distance;
     },
-    projectPoint: function (out, plane, point) {
-        var distance = this.distanceToPoint(plane, point);
-        vec3_1.vec3.multiplyScalar(out, plane.normal, distance);
-        vec3_1.vec3.subtract(out, point, out);
+    projectPoint(out, plane, point) {
+        const distance = this.distanceToPoint(plane, point);
+        vec3.multiplyScalar(out, plane.normal, distance);
+        vec3.subtract(out, point, out);
     },
-    equals: function (plane, other) {
-        return vec3_1.vec3.equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < constants_1.EPSILON;
+    equals(plane, other) {
+        return vec3.equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < EPSILON;
     },
-    fromNormalAndCoplanarPoint: function (out, normal, point) {
-        vec3_1.vec3.copy(out.normal, normal);
-        out.distance = vec3_1.vec3.dot(point, normal);
+    fromNormalAndCoplanarPoint(out, normal, point) {
+        vec3.copy(out.normal, normal);
+        out.distance = vec3.dot(point, normal);
     },
-    fromPoints: function (out, a, b, c) {
-        vec3_1.vec3.subtract(_0vector, b, a);
-        vec3_1.vec3.subtract(_1vector, c, a);
-        vec3_1.vec3.cross(out.normal, _0vector, _1vector);
-        vec3_1.vec3.normalize(out.normal, out.normal);
-        out.distance = vec3_1.vec3.dot(out.normal, a);
+    fromPoints(out, a, b, c) {
+        vec3.subtract(_0vector, b, a);
+        vec3.subtract(_1vector, c, a);
+        vec3.cross(out.normal, _0vector, _1vector);
+        vec3.normalize(out.normal, out.normal);
+        out.distance = vec3.dot(out.normal, a);
     },
-    getUnitSphereRadiusAngle: function (plane) {
+    getUnitSphereRadiusAngle(plane) {
         return Math.acos(Math.max(Math.min(plane.distance, 1), -1));
     }
 });

package/Math/quaternion.js

@@ -1,80 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.quaternion = void 0;
-var vec3_1 = require("./vec3");
-var constants_1 = require("./constants");
-exports.quaternion = Object.freeze({
-    create: function (x, y, z, w) {
-        if (x === void 0) { x = 0; }
-        if (y === void 0) { y = 0; }
-        if (z === void 0) { z = 0; }
-        if (w === void 0) { w = 1; }
+import { vec3 } from './vec3';
+import { EPSILON } from './constants';
+export const quaternion = Object.freeze({
+    create(x = 0, y = 0, z = 0, w = 1) {
         return [x, y, z, w];
     },
-    set: function (out, x, y, z, w) {
+    set(out, x, y, z, w) {
         out[0] = x;
         out[1] = y;
         out[2] = z;
         out[3] = w;
     },
-    copy: function (out, a) {
+    copy(out, a) {
         out[0] = a[0];
         out[1] = a[1];
         out[2] = a[2];
         out[3] = a[3];
     },
-    clone: function (a) {
+    clone(a) {
         return [a[0], a[1], a[2], a[3]];
     },
-    multiply: function (out, a, b) {
-        var x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
-        var y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
-        var z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
-        var w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+    multiply(out, a, b) {
+        const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+        const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+        const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+        const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
         this.set(out, x, y, z, w);
         return out;
     },
-    randomUnit: function (out) {
-        var u1 = Math.random();
-        var u2 = Math.random();
-        var u3 = Math.random();
-        var sqrt1MinusU1 = Math.sqrt(1 - u1);
-        var sqrtU1 = Math.sqrt(u1);
-        var x = sqrt1MinusU1 * Math.sin(2 * Math.PI * u2);
-        var y = sqrt1MinusU1 * Math.cos(2 * Math.PI * u2);
-        var z = sqrtU1 * Math.sin(2 * Math.PI * u3);
-        var w = sqrtU1 * Math.cos(2 * Math.PI * u3);
+    randomUnit(out) {
+        const u1 = Math.random();
+        const u2 = Math.random();
+        const u3 = Math.random();
+        const sqrt1MinusU1 = Math.sqrt(1 - u1);
+        const sqrtU1 = Math.sqrt(u1);
+        const x = sqrt1MinusU1 * Math.sin(2 * Math.PI * u2);
+        const y = sqrt1MinusU1 * Math.cos(2 * Math.PI * u2);
+        const z = sqrtU1 * Math.sin(2 * Math.PI * u3);
+        const w = sqrtU1 * Math.cos(2 * Math.PI * u3);
         this.set(out, x, y, z, w);
         this.normalize(out, out);
         return out;
     },
-    rotateQuaternion: function (out, a, b) {
-        var x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
-        var y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
-        var z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
-        var w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+    rotateQuaternion(out, a, b) {
+        const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+        const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+        const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+        const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
         this.set(out, x, y, z, w);
         this.normalize(out, out);
     },
-    lengthSquared: function (a) {
+    lengthSquared(a) {
         return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
     },
-    length: function (a) {
+    length(a) {
         return Math.sqrt(this.lengthSquared(a));
     },
-    normalize: function (out, input) {
-        var len = Math.sqrt(this.lengthSquared(input));
-        if (len < constants_1.EPSILON) {
+    normalize(out, input) {
+        const len = Math.sqrt(this.lengthSquared(input));
+        if (len < EPSILON) {
             this.set(out, 0, 0, 0, 1);
         }
         else {
-            var invLen = 1 / len;
+            const invLen = 1 / len;
             this.set(out, input[0] * invLen, input[1] * invLen, input[2] * invLen, input[3] * invLen);
         }
     },
-    fromUnitVectors: function (out, from, to) {
-        var d = vec3_1.vec3.dot(from, to) + 1;
-        if (d < constants_1.EPSILON) {
+    fromUnitVectors(out, from, to) {
+        const d = vec3.dot(from, to) + 1;
+        if (d < EPSILON) {
             if (Math.abs(from[0]) > Math.abs(from[2])) {
                 this.set(out, -from[1], from[0], 0, 0);
             }
@@ -83,26 +76,26 @@ exports.quaternion = Object.freeze({
             }
         }
         else {
-            var x = from[1] * to[2] - from[2] * to[1];
-            var y = from[2] * to[0] - from[0] * to[2];
-            var z = from[0] * to[1] - from[1] * to[0];
+            const x = from[1] * to[2] - from[2] * to[1];
+            const y = from[2] * to[0] - from[0] * to[2];
+            const z = from[0] * to[1] - from[1] * to[0];
             this.set(out, x, y, z, d);
         }
     },
-    fromTwoQuaternions: function (out, from, to) {
-        var x = from[0] * to[3] + from[3] * to[0] + from[1] * to[2] - from[2] * to[1];
-        var y = from[1] * to[3] + from[3] * to[1] + from[2] * to[0] - from[0] * to[2];
-        var z = from[2] * to[3] + from[3] * to[2] + from[0] * to[1] - from[1] * to[0];
-        var w = from[3] * to[3] - from[0] * to[0] - from[1] * to[1] - from[2] * to[2];
+    fromTwoQuaternions(out, from, to) {
+        const x = from[0] * to[3] + from[3] * to[0] + from[1] * to[2] - from[2] * to[1];
+        const y = from[1] * to[3] + from[3] * to[1] + from[2] * to[0] - from[0] * to[2];
+        const z = from[2] * to[3] + from[3] * to[2] + from[0] * to[1] - from[1] * to[0];
+        const w = from[3] * to[3] - from[0] * to[0] - from[1] * to[1] - from[2] * to[2];
         this.set(out, x, y, z, w);
         this.normalize(out, out);
     },
-    conjugate: function (out, a) {
+    conjugate(out, a) {
         this.set(out, -a[0], -a[1], -a[2], a[3]);
     },
-    fromAxisAngle: function (out, axis, angle) {
-        var halfAngle = angle / 2;
-        var s = Math.sin(halfAngle);
+    fromAxisAngle(out, axis, angle) {
+        const halfAngle = angle / 2;
+        const s = Math.sin(halfAngle);
         this.set(out, axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(halfAngle));
     },
 });

package/Math/types.js

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

package/Math/utils.js

@@ -1,4 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var vector3d_1 = require("./vector3d");
-var quaternion_1 = require("./quaternion");
+import { Vector3D } from "./vector3d";
+import { Quaternion } from "./quaternion";