@math.gl/core 4.0.0-alpha.1 → 4.0.0-alpha.2

package/dist/index.cjs

@@ -1,9 +1,21 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,10 +28,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -35,7 +43,7 @@ __export(src_exports, {
   Vector3: () => Vector3,
   Vector4: () => Vector4,
   _Euler: () => Euler,
-  _MathUtils: () => math_utils_default,
+  _MathUtils: () => math_utils_exports,
   _Pose: () => Pose,
   _SphericalCoordinates: () => SphericalCoordinates,
   acos: () => acos,
@@ -65,14 +73,17 @@ module.exports = __toCommonJS(src_exports);
 // src/lib/common.ts
 var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
 var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-var config = {
+var DEFAULT_CONFIG = {
   EPSILON: 1e-12,
   debug: false,
   precision: 4,
   printTypes: false,
   printDegrees: false,
-  printRowMajor: true
+  printRowMajor: true,
+  _cartographicRadians: false
 };
+globalThis.mathgl = globalThis.mathgl || { config: __spreadValues({}, DEFAULT_CONFIG) };
+var config = globalThis.mathgl.config;
 function configure(options) {
   Object.assign(config, options);
   return config;
@@ -232,6 +243,9 @@ var MathArray = class extends Array {
     }
     return targetArray;
   }
+  toObject(targetObject) {
+    return targetObject;
+  }
   from(arrayOrObject) {
     return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
   }
@@ -330,14 +344,14 @@ var MathArray = class extends Array {
     }
     return this.check();
   }
-  scale(scale4) {
-    if (typeof scale4 === "number") {
+  scale(scale5) {
+    if (typeof scale5 === "number") {
       for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] *= scale4;
+        this[i] *= scale5;
       }
     } else {
-      for (let i = 0; i < this.ELEMENTS && i < scale4.length; ++i) {
-        this[i] *= scale4[i];
+      for (let i = 0; i < this.ELEMENTS && i < scale5.length; ++i) {
+        this[i] *= scale5[i];
       }
     }
     return this.check();
@@ -400,8 +414,8 @@ var MathArray = class extends Array {
 };
 
 // src/lib/validators.ts
-function validateVector(v, length3) {
-  if (v.length !== length3) {
+function validateVector(v, length4) {
+  if (v.length !== length4) {
     return false;
   }
   for (let i = 0; i < v.length; ++i) {
@@ -413,12 +427,12 @@ function validateVector(v, length3) {
 }
 function checkNumber(value) {
   if (!Number.isFinite(value)) {
-    throw new Error(`Invalid number ${value}`);
+    throw new Error(`Invalid number ${JSON.stringify(value)}`);
   }
   return value;
 }
-function checkVector(v, length3, callerName = "") {
-  if (config.debug && !validateVector(v, length3)) {
+function checkVector(v, length4, callerName = "") {
+  if (config.debug && !validateVector(v, length4)) {
     throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
   }
   return v;
@@ -452,11 +466,11 @@ var Vector = class extends MathArray {
     return this.len();
   }
   lengthSquared() {
-    let length3 = 0;
+    let length4 = 0;
     for (let i = 0; i < this.ELEMENTS; ++i) {
-      length3 += this[i] * this[i];
+      length4 += this[i] * this[i];
     }
-    return length3;
+    return length4;
   }
   magnitudeSquared() {
     return this.lengthSquared();
@@ -465,12 +479,12 @@ var Vector = class extends MathArray {
     return Math.sqrt(this.distanceSquared(mathArray));
   }
   distanceSquared(mathArray) {
-    let length3 = 0;
+    let length4 = 0;
     for (let i = 0; i < this.ELEMENTS; ++i) {
       const dist = this[i] - mathArray[i];
-      length3 += dist * dist;
+      length4 += dist * dist;
     }
-    return checkNumber(length3);
+    return checkNumber(length4);
   }
   dot(mathArray) {
     let product = 0;
@@ -480,10 +494,10 @@ var Vector = class extends MathArray {
     return checkNumber(product);
   }
   normalize() {
-    const length3 = this.magnitude();
-    if (length3 !== 0) {
+    const length4 = this.magnitude();
+    if (length4 !== 0) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] /= length3;
+        this[i] /= length4;
       }
     }
     return this.check();
@@ -536,8 +550,74 @@ var Vector = class extends MathArray {
   }
 };
 
-// src/classes/vector2.ts
-var vec2 = __toESM(require("gl-matrix/vec2"), 1);
+// src/gl-matrix/common.js
+var EPSILON = 1e-6;
+var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+var degree = Math.PI / 180;
+
+// src/gl-matrix/vec2.js
+function create() {
+  const out = new ARRAY_TYPE(2);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+  }
+  return out;
+}
+function transformMat2(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  out[0] = m[0] * x + m[2] * y;
+  out[1] = m[1] * x + m[3] * y;
+  return out;
+}
+function transformMat2d(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  out[0] = m[0] * x + m[2] * y + m[4];
+  out[1] = m[1] * x + m[3] * y + m[5];
+  return out;
+}
+function transformMat3(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  out[0] = m[0] * x + m[3] * y + m[6];
+  out[1] = m[1] * x + m[4] * y + m[7];
+  return out;
+}
+function transformMat4(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  out[0] = m[0] * x + m[4] * y + m[12];
+  out[1] = m[1] * x + m[5] * y + m[13];
+  return out;
+}
+var forEach = function() {
+  const vec = create();
+  return function(a, stride, offset, count, fn, arg) {
+    let i;
+    let l;
+    if (!stride) {
+      stride = 2;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+    }
+    return a;
+  };
+}();
 
 // src/lib/gl-matrix-extras.ts
 function vec2_transformMat4AsVector(out, a, m) {
@@ -638,7 +718,7 @@ var Vector2 = class extends Vector {
     return this.transformAsPoint(matrix4);
   }
   transformAsPoint(matrix4) {
-    vec2.transformMat4(this, this, matrix4);
+    transformMat4(this, this, matrix4);
     return this.check();
   }
   transformAsVector(matrix4) {
@@ -646,21 +726,200 @@ var Vector2 = class extends Vector {
     return this.check();
   }
   transformByMatrix3(matrix3) {
-    vec2.transformMat3(this, this, matrix3);
+    transformMat3(this, this, matrix3);
     return this.check();
   }
   transformByMatrix2x3(matrix2x3) {
-    vec2.transformMat2d(this, this, matrix2x3);
+    transformMat2d(this, this, matrix2x3);
     return this.check();
   }
   transformByMatrix2(matrix2) {
-    vec2.transformMat2(this, this, matrix2);
+    transformMat2(this, this, matrix2);
     return this.check();
   }
 };
 
+// src/gl-matrix/vec3.js
+function create2() {
+  const out = new ARRAY_TYPE(3);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+function length(a) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function fromValues(x, y, z) {
+  const out = new ARRAY_TYPE(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function normalize(out, a) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  let len2 = x * x + y * y + z * z;
+  if (len2 > 0) {
+    len2 = 1 / Math.sqrt(len2);
+  }
+  out[0] = a[0] * len2;
+  out[1] = a[1] * len2;
+  out[2] = a[2] * len2;
+  return out;
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(out, a, b) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const bx = b[0];
+  const by = b[1];
+  const bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function transformMat42(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  let w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  w = w || 1;
+  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+  return out;
+}
+function transformMat32(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  out[0] = x * m[0] + y * m[3] + z * m[6];
+  out[1] = x * m[1] + y * m[4] + z * m[7];
+  out[2] = x * m[2] + y * m[5] + z * m[8];
+  return out;
+}
+function transformQuat(out, a, q) {
+  const qx = q[0];
+  const qy = q[1];
+  const qz = q[2];
+  const qw = q[3];
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  let uvx = qy * z - qz * y;
+  let uvy = qz * x - qx * z;
+  let uvz = qx * y - qy * x;
+  let uuvx = qy * uvz - qz * uvy;
+  let uuvy = qz * uvx - qx * uvz;
+  let uuvz = qx * uvy - qy * uvx;
+  const w2 = qw * 2;
+  uvx *= w2;
+  uvy *= w2;
+  uvz *= w2;
+  uuvx *= 2;
+  uuvy *= 2;
+  uuvz *= 2;
+  out[0] = x + uvx + uuvx;
+  out[1] = y + uvy + uuvy;
+  out[2] = z + uvz + uuvz;
+  return out;
+}
+function rotateX(out, a, b, rad) {
+  const p = [];
+  const r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0];
+  r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+  r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateY(out, a, b, rad) {
+  const p = [];
+  const r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+  r[1] = p[1];
+  r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateZ(out, a, b, rad) {
+  const p = [];
+  const r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+  r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+  r[2] = p[2];
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function angle(a, b) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const bx = b[0];
+  const by = b[1];
+  const bz = b[2];
+  const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
+  const cosine = mag && dot(a, b) / mag;
+  return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+var len = length;
+var forEach2 = function() {
+  const vec = create2();
+  return function(a, stride, offset, count, fn, arg) {
+    let i;
+    let l;
+    if (!stride) {
+      stride = 3;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      vec[2] = a[i + 2];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+      a[i + 2] = vec[2];
+    }
+    return a;
+  };
+}();
+
 // src/classes/vector3.ts
-var vec3 = __toESM(require("gl-matrix/vec3"), 1);
 var ORIGIN = [0, 0, 0];
 var ZERO;
 var Vector3 = class extends Vector {
@@ -725,29 +984,29 @@ var Vector3 = class extends Vector {
     this[2] = checkNumber(value);
   }
   angle(vector) {
-    return vec3.angle(this, vector);
+    return angle(this, vector);
   }
   cross(vector) {
-    vec3.cross(this, this, vector);
+    cross(this, this, vector);
     return this.check();
   }
   rotateX({ radians: radians2, origin = ORIGIN }) {
-    vec3.rotateX(this, this, origin, radians2);
+    rotateX(this, this, origin, radians2);
     return this.check();
   }
   rotateY({ radians: radians2, origin = ORIGIN }) {
-    vec3.rotateY(this, this, origin, radians2);
+    rotateY(this, this, origin, radians2);
     return this.check();
   }
   rotateZ({ radians: radians2, origin = ORIGIN }) {
-    vec3.rotateZ(this, this, origin, radians2);
+    rotateZ(this, this, origin, radians2);
     return this.check();
   }
   transform(matrix4) {
     return this.transformAsPoint(matrix4);
   }
   transformAsPoint(matrix4) {
-    vec3.transformMat4(this, this, matrix4);
+    transformMat42(this, this, matrix4);
     return this.check();
   }
   transformAsVector(matrix4) {
@@ -755,7 +1014,7 @@ var Vector3 = class extends Vector {
     return this.check();
   }
   transformByMatrix3(matrix3) {
-    vec3.transformMat3(this, this, matrix3);
+    transformMat32(this, this, matrix3);
     return this.check();
   }
   transformByMatrix2(matrix2) {
@@ -763,13 +1022,12 @@ var Vector3 = class extends Vector {
     return this.check();
   }
   transformByQuaternion(quaternion) {
-    vec3.transformQuat(this, this, quaternion);
+    transformQuat(this, this, quaternion);
     return this.check();
   }
 };
 
 // src/classes/vector4.ts
-var vec4 = __toESM(require("gl-matrix/vec3"), 1);
 var ZERO2;
 var Vector4 = class extends Vector {
   static get ZERO() {
@@ -846,7 +1104,7 @@ var Vector4 = class extends Vector {
     this[3] = checkNumber(value);
   }
   transform(matrix4) {
-    vec4.transformMat4(this, this, matrix4);
+    transformMat42(this, this, matrix4);
     return this.check();
   }
   transformByMatrix3(matrix3) {
@@ -858,7 +1116,7 @@ var Vector4 = class extends Vector {
     return this.check();
   }
   transformByQuaternion(quaternion) {
-    vec4.transformQuat(this, this, quaternion);
+    transformQuat(this, this, quaternion);
     return this.check();
   }
   applyMatrix4(m) {
@@ -913,10 +1171,207 @@ var Matrix = class extends MathArray {
   }
 };
 
+// src/gl-matrix/mat3.js
+function create3() {
+  const out = new ARRAY_TYPE(9);
+  if (ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[5] = 0;
+    out[6] = 0;
+    out[7] = 0;
+  }
+  out[0] = 1;
+  out[4] = 1;
+  out[8] = 1;
+  return out;
+}
+function transpose(out, a) {
+  if (out === a) {
+    const a01 = a[1];
+    const a02 = a[2];
+    const a12 = a[5];
+    out[1] = a[3];
+    out[2] = a[6];
+    out[3] = a01;
+    out[5] = a[7];
+    out[6] = a02;
+    out[7] = a12;
+  } else {
+    out[0] = a[0];
+    out[1] = a[3];
+    out[2] = a[6];
+    out[3] = a[1];
+    out[4] = a[4];
+    out[5] = a[7];
+    out[6] = a[2];
+    out[7] = a[5];
+    out[8] = a[8];
+  }
+  return out;
+}
+function invert(out, a) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a10 = a[3];
+  const a11 = a[4];
+  const a12 = a[5];
+  const a20 = a[6];
+  const a21 = a[7];
+  const a22 = a[8];
+  const b01 = a22 * a11 - a12 * a21;
+  const b11 = -a22 * a10 + a12 * a20;
+  const b21 = a21 * a10 - a11 * a20;
+  let det = a00 * b01 + a01 * b11 + a02 * b21;
+  if (!det) {
+    return null;
+  }
+  det = 1 / det;
+  out[0] = b01 * det;
+  out[1] = (-a22 * a01 + a02 * a21) * det;
+  out[2] = (a12 * a01 - a02 * a11) * det;
+  out[3] = b11 * det;
+  out[4] = (a22 * a00 - a02 * a20) * det;
+  out[5] = (-a12 * a00 + a02 * a10) * det;
+  out[6] = b21 * det;
+  out[7] = (-a21 * a00 + a01 * a20) * det;
+  out[8] = (a11 * a00 - a01 * a10) * det;
+  return out;
+}
+function determinant(a) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a10 = a[3];
+  const a11 = a[4];
+  const a12 = a[5];
+  const a20 = a[6];
+  const a21 = a[7];
+  const a22 = a[8];
+  return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
+}
+function multiply(out, a, b) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a10 = a[3];
+  const a11 = a[4];
+  const a12 = a[5];
+  const a20 = a[6];
+  const a21 = a[7];
+  const a22 = a[8];
+  const b00 = b[0];
+  const b01 = b[1];
+  const b02 = b[2];
+  const b10 = b[3];
+  const b11 = b[4];
+  const b12 = b[5];
+  const b20 = b[6];
+  const b21 = b[7];
+  const b22 = b[8];
+  out[0] = b00 * a00 + b01 * a10 + b02 * a20;
+  out[1] = b00 * a01 + b01 * a11 + b02 * a21;
+  out[2] = b00 * a02 + b01 * a12 + b02 * a22;
+  out[3] = b10 * a00 + b11 * a10 + b12 * a20;
+  out[4] = b10 * a01 + b11 * a11 + b12 * a21;
+  out[5] = b10 * a02 + b11 * a12 + b12 * a22;
+  out[6] = b20 * a00 + b21 * a10 + b22 * a20;
+  out[7] = b20 * a01 + b21 * a11 + b22 * a21;
+  out[8] = b20 * a02 + b21 * a12 + b22 * a22;
+  return out;
+}
+function translate(out, a, v) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a10 = a[3];
+  const a11 = a[4];
+  const a12 = a[5];
+  const a20 = a[6];
+  const a21 = a[7];
+  const a22 = a[8];
+  const x = v[0];
+  const y = v[1];
+  out[0] = a00;
+  out[1] = a01;
+  out[2] = a02;
+  out[3] = a10;
+  out[4] = a11;
+  out[5] = a12;
+  out[6] = x * a00 + y * a10 + a20;
+  out[7] = x * a01 + y * a11 + a21;
+  out[8] = x * a02 + y * a12 + a22;
+  return out;
+}
+function rotate(out, a, rad) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a10 = a[3];
+  const a11 = a[4];
+  const a12 = a[5];
+  const a20 = a[6];
+  const a21 = a[7];
+  const a22 = a[8];
+  const s = Math.sin(rad);
+  const c = Math.cos(rad);
+  out[0] = c * a00 + s * a10;
+  out[1] = c * a01 + s * a11;
+  out[2] = c * a02 + s * a12;
+  out[3] = c * a10 - s * a00;
+  out[4] = c * a11 - s * a01;
+  out[5] = c * a12 - s * a02;
+  out[6] = a20;
+  out[7] = a21;
+  out[8] = a22;
+  return out;
+}
+function scale(out, a, v) {
+  const x = v[0];
+  const y = v[1];
+  out[0] = x * a[0];
+  out[1] = x * a[1];
+  out[2] = x * a[2];
+  out[3] = y * a[3];
+  out[4] = y * a[4];
+  out[5] = y * a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  return out;
+}
+function fromQuat(out, q) {
+  const x = q[0];
+  const y = q[1];
+  const z = q[2];
+  const w = q[3];
+  const x2 = x + x;
+  const y2 = y + y;
+  const z2 = z + z;
+  const xx = x * x2;
+  const yx = y * x2;
+  const yy = y * y2;
+  const zx = z * x2;
+  const zy = z * y2;
+  const zz = z * z2;
+  const wx = w * x2;
+  const wy = w * y2;
+  const wz = w * z2;
+  out[0] = 1 - yy - zz;
+  out[3] = yx - wz;
+  out[6] = zx + wy;
+  out[1] = yx + wz;
+  out[4] = 1 - xx - zz;
+  out[7] = zy - wx;
+  out[2] = zx - wy;
+  out[5] = zy + wx;
+  out[8] = 1 - xx - yy;
+  return out;
+}
+
 // src/classes/matrix3.ts
-var mat3 = __toESM(require("gl-matrix/mat3"), 1);
-var vec22 = __toESM(require("gl-matrix/vec2"), 1);
-var vec32 = __toESM(require("gl-matrix/vec3"), 1);
 var INDICES = /* @__PURE__ */ ((INDICES3) => {
   INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0";
   INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1";
@@ -975,7 +1430,7 @@ var Matrix3 = class extends Matrix {
     return this.check();
   }
   fromQuaternion(q) {
-    mat3.fromQuat(this, q);
+    fromQuat(this, q);
     return this.check();
   }
   set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
@@ -1003,48 +1458,48 @@ var Matrix3 = class extends Matrix {
     return this.check();
   }
   determinant() {
-    return mat3.determinant(this);
+    return determinant(this);
   }
   transpose() {
-    mat3.transpose(this, this);
+    transpose(this, this);
     return this.check();
   }
   invert() {
-    mat3.invert(this, this);
+    invert(this, this);
     return this.check();
   }
   multiplyLeft(a) {
-    mat3.multiply(this, a, this);
+    multiply(this, a, this);
     return this.check();
   }
   multiplyRight(a) {
-    mat3.multiply(this, this, a);
+    multiply(this, this, a);
     return this.check();
   }
   rotate(radians2) {
-    mat3.rotate(this, this, radians2);
+    rotate(this, this, radians2);
     return this.check();
   }
   scale(factor) {
     if (Array.isArray(factor)) {
-      mat3.scale(this, this, factor);
+      scale(this, this, factor);
     } else {
-      mat3.scale(this, this, [factor, factor]);
+      scale(this, this, [factor, factor]);
     }
     return this.check();
   }
   translate(vec) {
-    mat3.translate(this, this, vec);
+    translate(this, this, vec);
     return this.check();
   }
   transform(vector, result) {
     let out;
     switch (vector.length) {
       case 2:
-        out = vec22.transformMat3(result || [-0, -0], vector, this);
+        out = transformMat3(result || [-0, -0], vector, this);
         break;
       case 3:
-        out = vec32.transformMat3(result || [-0, -0, -0], vector, this);
+        out = transformMat32(result || [-0, -0, -0], vector, this);
         break;
       case 4:
         out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
@@ -1082,11 +1537,631 @@ function getIdentityMatrix() {
   return IDENTITY_MATRIX3;
 }
 
+// src/gl-matrix/mat4.js
+function identity(out) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function transpose2(out, a) {
+  if (out === a) {
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a23 = a[11];
+    out[1] = a[4];
+    out[2] = a[8];
+    out[3] = a[12];
+    out[4] = a01;
+    out[6] = a[9];
+    out[7] = a[13];
+    out[8] = a02;
+    out[9] = a12;
+    out[11] = a[14];
+    out[12] = a03;
+    out[13] = a13;
+    out[14] = a23;
+  } else {
+    out[0] = a[0];
+    out[1] = a[4];
+    out[2] = a[8];
+    out[3] = a[12];
+    out[4] = a[1];
+    out[5] = a[5];
+    out[6] = a[9];
+    out[7] = a[13];
+    out[8] = a[2];
+    out[9] = a[6];
+    out[10] = a[10];
+    out[11] = a[14];
+    out[12] = a[3];
+    out[13] = a[7];
+    out[14] = a[11];
+    out[15] = a[15];
+  }
+  return out;
+}
+function invert2(out, a) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a03 = a[3];
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a13 = a[7];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const a23 = a[11];
+  const a30 = a[12];
+  const a31 = a[13];
+  const a32 = a[14];
+  const a33 = a[15];
+  const b00 = a00 * a11 - a01 * a10;
+  const b01 = a00 * a12 - a02 * a10;
+  const b02 = a00 * a13 - a03 * a10;
+  const b03 = a01 * a12 - a02 * a11;
+  const b04 = a01 * a13 - a03 * a11;
+  const b05 = a02 * a13 - a03 * a12;
+  const b06 = a20 * a31 - a21 * a30;
+  const b07 = a20 * a32 - a22 * a30;
+  const b08 = a20 * a33 - a23 * a30;
+  const b09 = a21 * a32 - a22 * a31;
+  const b10 = a21 * a33 - a23 * a31;
+  const b11 = a22 * a33 - a23 * a32;
+  let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) {
+    return null;
+  }
+  det = 1 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+function determinant2(a) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a03 = a[3];
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a13 = a[7];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const a23 = a[11];
+  const a30 = a[12];
+  const a31 = a[13];
+  const a32 = a[14];
+  const a33 = a[15];
+  const b0 = a00 * a11 - a01 * a10;
+  const b1 = a00 * a12 - a02 * a10;
+  const b2 = a01 * a12 - a02 * a11;
+  const b3 = a20 * a31 - a21 * a30;
+  const b4 = a20 * a32 - a22 * a30;
+  const b5 = a21 * a32 - a22 * a31;
+  const b6 = a00 * b5 - a01 * b4 + a02 * b3;
+  const b7 = a10 * b5 - a11 * b4 + a12 * b3;
+  const b8 = a20 * b2 - a21 * b1 + a22 * b0;
+  const b9 = a30 * b2 - a31 * b1 + a32 * b0;
+  return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9;
+}
+function multiply2(out, a, b) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a03 = a[3];
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a13 = a[7];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const a23 = a[11];
+  const a30 = a[12];
+  const a31 = a[13];
+  const a32 = a[14];
+  const a33 = a[15];
+  let b0 = b[0];
+  let b1 = b[1];
+  let b2 = b[2];
+  let b3 = b[3];
+  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[4];
+  b1 = b[5];
+  b2 = b[6];
+  b3 = b[7];
+  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[8];
+  b1 = b[9];
+  b2 = b[10];
+  b3 = b[11];
+  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[12];
+  b1 = b[13];
+  b2 = b[14];
+  b3 = b[15];
+  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  return out;
+}
+function translate2(out, a, v) {
+  const x = v[0];
+  const y = v[1];
+  const z = v[2];
+  let a00;
+  let a01;
+  let a02;
+  let a03;
+  let a10;
+  let a11;
+  let a12;
+  let a13;
+  let a20;
+  let a21;
+  let a22;
+  let a23;
+  if (a === out) {
+    out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+    out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+    out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+    out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+  } else {
+    a00 = a[0];
+    a01 = a[1];
+    a02 = a[2];
+    a03 = a[3];
+    a10 = a[4];
+    a11 = a[5];
+    a12 = a[6];
+    a13 = a[7];
+    a20 = a[8];
+    a21 = a[9];
+    a22 = a[10];
+    a23 = a[11];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a03;
+    out[4] = a10;
+    out[5] = a11;
+    out[6] = a12;
+    out[7] = a13;
+    out[8] = a20;
+    out[9] = a21;
+    out[10] = a22;
+    out[11] = a23;
+    out[12] = a00 * x + a10 * y + a20 * z + a[12];
+    out[13] = a01 * x + a11 * y + a21 * z + a[13];
+    out[14] = a02 * x + a12 * y + a22 * z + a[14];
+    out[15] = a03 * x + a13 * y + a23 * z + a[15];
+  }
+  return out;
+}
+function scale2(out, a, v) {
+  const x = v[0];
+  const y = v[1];
+  const z = v[2];
+  out[0] = a[0] * x;
+  out[1] = a[1] * x;
+  out[2] = a[2] * x;
+  out[3] = a[3] * x;
+  out[4] = a[4] * y;
+  out[5] = a[5] * y;
+  out[6] = a[6] * y;
+  out[7] = a[7] * y;
+  out[8] = a[8] * z;
+  out[9] = a[9] * z;
+  out[10] = a[10] * z;
+  out[11] = a[11] * z;
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+function rotate2(out, a, rad, axis) {
+  let x = axis[0];
+  let y = axis[1];
+  let z = axis[2];
+  let len2 = Math.sqrt(x * x + y * y + z * z);
+  let c;
+  let s;
+  let t;
+  let a00;
+  let a01;
+  let a02;
+  let a03;
+  let a10;
+  let a11;
+  let a12;
+  let a13;
+  let a20;
+  let a21;
+  let a22;
+  let a23;
+  let b00;
+  let b01;
+  let b02;
+  let b10;
+  let b11;
+  let b12;
+  let b20;
+  let b21;
+  let b22;
+  if (len2 < EPSILON) {
+    return null;
+  }
+  len2 = 1 / len2;
+  x *= len2;
+  y *= len2;
+  z *= len2;
+  s = Math.sin(rad);
+  c = Math.cos(rad);
+  t = 1 - c;
+  a00 = a[0];
+  a01 = a[1];
+  a02 = a[2];
+  a03 = a[3];
+  a10 = a[4];
+  a11 = a[5];
+  a12 = a[6];
+  a13 = a[7];
+  a20 = a[8];
+  a21 = a[9];
+  a22 = a[10];
+  a23 = a[11];
+  b00 = x * x * t + c;
+  b01 = y * x * t + z * s;
+  b02 = z * x * t - y * s;
+  b10 = x * y * t - z * s;
+  b11 = y * y * t + c;
+  b12 = z * y * t + x * s;
+  b20 = x * z * t + y * s;
+  b21 = y * z * t - x * s;
+  b22 = z * z * t + c;
+  out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+  out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+  out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+  out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+  out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+  out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+  out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+  out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+  out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+  out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+  out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+  out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+  if (a !== out) {
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  return out;
+}
+function rotateX2(out, a, rad) {
+  const s = Math.sin(rad);
+  const c = Math.cos(rad);
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a13 = a[7];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const a23 = a[11];
+  if (a !== out) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[4] = a10 * c + a20 * s;
+  out[5] = a11 * c + a21 * s;
+  out[6] = a12 * c + a22 * s;
+  out[7] = a13 * c + a23 * s;
+  out[8] = a20 * c - a10 * s;
+  out[9] = a21 * c - a11 * s;
+  out[10] = a22 * c - a12 * s;
+  out[11] = a23 * c - a13 * s;
+  return out;
+}
+function rotateY2(out, a, rad) {
+  const s = Math.sin(rad);
+  const c = Math.cos(rad);
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a03 = a[3];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const a23 = a[11];
+  if (a !== out) {
+    out[4] = a[4];
+    out[5] = a[5];
+    out[6] = a[6];
+    out[7] = a[7];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[0] = a00 * c - a20 * s;
+  out[1] = a01 * c - a21 * s;
+  out[2] = a02 * c - a22 * s;
+  out[3] = a03 * c - a23 * s;
+  out[8] = a00 * s + a20 * c;
+  out[9] = a01 * s + a21 * c;
+  out[10] = a02 * s + a22 * c;
+  out[11] = a03 * s + a23 * c;
+  return out;
+}
+function rotateZ2(out, a, rad) {
+  const s = Math.sin(rad);
+  const c = Math.cos(rad);
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a03 = a[3];
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a13 = a[7];
+  if (a !== out) {
+    out[8] = a[8];
+    out[9] = a[9];
+    out[10] = a[10];
+    out[11] = a[11];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[0] = a00 * c + a10 * s;
+  out[1] = a01 * c + a11 * s;
+  out[2] = a02 * c + a12 * s;
+  out[3] = a03 * c + a13 * s;
+  out[4] = a10 * c - a00 * s;
+  out[5] = a11 * c - a01 * s;
+  out[6] = a12 * c - a02 * s;
+  out[7] = a13 * c - a03 * s;
+  return out;
+}
+function fromQuat2(out, q) {
+  const x = q[0];
+  const y = q[1];
+  const z = q[2];
+  const w = q[3];
+  const x2 = x + x;
+  const y2 = y + y;
+  const z2 = z + z;
+  const xx = x * x2;
+  const yx = y * x2;
+  const yy = y * y2;
+  const zx = z * x2;
+  const zy = z * y2;
+  const zz = z * z2;
+  const wx = w * x2;
+  const wy = w * y2;
+  const wz = w * z2;
+  out[0] = 1 - yy - zz;
+  out[1] = yx + wz;
+  out[2] = zx - wy;
+  out[3] = 0;
+  out[4] = yx - wz;
+  out[5] = 1 - xx - zz;
+  out[6] = zy + wx;
+  out[7] = 0;
+  out[8] = zx + wy;
+  out[9] = zy - wx;
+  out[10] = 1 - xx - yy;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function frustum(out, left, right, bottom, top, near, far) {
+  const rl = 1 / (right - left);
+  const tb = 1 / (top - bottom);
+  const nf = 1 / (near - far);
+  out[0] = near * 2 * rl;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = near * 2 * tb;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = (right + left) * rl;
+  out[9] = (top + bottom) * tb;
+  out[10] = (far + near) * nf;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = far * near * 2 * nf;
+  out[15] = 0;
+  return out;
+}
+function perspectiveNO(out, fovy, aspect, near, far) {
+  const f = 1 / Math.tan(fovy / 2);
+  out[0] = f / aspect;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = f;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[15] = 0;
+  if (far != null && far !== Infinity) {
+    const nf = 1 / (near - far);
+    out[10] = (far + near) * nf;
+    out[14] = 2 * far * near * nf;
+  } else {
+    out[10] = -1;
+    out[14] = -2 * near;
+  }
+  return out;
+}
+var perspective = perspectiveNO;
+function orthoNO(out, left, right, bottom, top, near, far) {
+  const lr = 1 / (left - right);
+  const bt = 1 / (bottom - top);
+  const nf = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 2 * nf;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = (far + near) * nf;
+  out[15] = 1;
+  return out;
+}
+var ortho = orthoNO;
+function lookAt(out, eye, center, up) {
+  let len2;
+  let x0;
+  let x1;
+  let x2;
+  let y0;
+  let y1;
+  let y2;
+  let z0;
+  let z1;
+  let z2;
+  const eyex = eye[0];
+  const eyey = eye[1];
+  const eyez = eye[2];
+  const upx = up[0];
+  const upy = up[1];
+  const upz = up[2];
+  const centerx = center[0];
+  const centery = center[1];
+  const centerz = center[2];
+  if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {
+    return identity(out);
+  }
+  z0 = eyex - centerx;
+  z1 = eyey - centery;
+  z2 = eyez - centerz;
+  len2 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+  z0 *= len2;
+  z1 *= len2;
+  z2 *= len2;
+  x0 = upy * z2 - upz * z1;
+  x1 = upz * z0 - upx * z2;
+  x2 = upx * z1 - upy * z0;
+  len2 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+  if (!len2) {
+    x0 = 0;
+    x1 = 0;
+    x2 = 0;
+  } else {
+    len2 = 1 / len2;
+    x0 *= len2;
+    x1 *= len2;
+    x2 *= len2;
+  }
+  y0 = z1 * x2 - z2 * x1;
+  y1 = z2 * x0 - z0 * x2;
+  y2 = z0 * x1 - z1 * x0;
+  len2 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+  if (!len2) {
+    y0 = 0;
+    y1 = 0;
+    y2 = 0;
+  } else {
+    len2 = 1 / len2;
+    y0 *= len2;
+    y1 *= len2;
+    y2 *= len2;
+  }
+  out[0] = x0;
+  out[1] = y0;
+  out[2] = z0;
+  out[3] = 0;
+  out[4] = x1;
+  out[5] = y1;
+  out[6] = z1;
+  out[7] = 0;
+  out[8] = x2;
+  out[9] = y2;
+  out[10] = z2;
+  out[11] = 0;
+  out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+  out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+  out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+  out[15] = 1;
+  return out;
+}
+
 // src/classes/matrix4.ts
-var mat4 = __toESM(require("gl-matrix/mat4"), 1);
-var vec23 = __toESM(require("gl-matrix/vec2"), 1);
-var vec33 = __toESM(require("gl-matrix/vec3"), 1);
-var vec42 = __toESM(require("gl-matrix/vec4"), 1);
 var INDICES2 = /* @__PURE__ */ ((INDICES3) => {
   INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0";
   INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1";
@@ -1218,7 +2293,7 @@ var Matrix4 = class extends Matrix {
     return this.check();
   }
   fromQuaternion(quaternion) {
-    mat4.fromQuat(this, quaternion);
+    fromQuat2(this, quaternion);
     return this.check();
   }
   frustum(view) {
@@ -1226,18 +2301,18 @@ var Matrix4 = class extends Matrix {
     if (far === Infinity) {
       computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
     } else {
-      mat4.frustum(this, left, right, bottom, top, near, far);
+      frustum(this, left, right, bottom, top, near, far);
     }
     return this.check();
   }
   lookAt(view) {
     const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
-    mat4.lookAt(this, eye, center, up);
+    lookAt(this, eye, center, up);
     return this.check();
   }
   ortho(view) {
     const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
-    mat4.ortho(this, left, right, bottom, top, near, far);
+    ortho(this, left, right, bottom, top, near, far);
     return this.check();
   }
   orthographic(view) {
@@ -1264,11 +2339,11 @@ var Matrix4 = class extends Matrix {
   perspective(view) {
     const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view;
     checkRadians(fovy);
-    mat4.perspective(this, fovy, aspect, near, far);
+    perspective(this, fovy, aspect, near, far);
     return this.check();
   }
   determinant() {
-    return mat4.determinant(this);
+    return determinant2(this);
   }
   getScale(result = [-0, -0, -0]) {
     result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
@@ -1285,10 +2360,10 @@ var Matrix4 = class extends Matrix {
   getRotation(result, scaleResult) {
     result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
     scaleResult = scaleResult || [-0, -0, -0];
-    const scale4 = this.getScale(scaleResult);
-    const inverseScale0 = 1 / scale4[0];
-    const inverseScale1 = 1 / scale4[1];
-    const inverseScale2 = 1 / scale4[2];
+    const scale5 = this.getScale(scaleResult);
+    const inverseScale0 = 1 / scale5[0];
+    const inverseScale1 = 1 / scale5[1];
+    const inverseScale2 = 1 / scale5[2];
     result[0] = this[0] * inverseScale0;
     result[1] = this[1] * inverseScale1;
     result[2] = this[2] * inverseScale2;
@@ -1310,10 +2385,10 @@ var Matrix4 = class extends Matrix {
   getRotationMatrix3(result, scaleResult) {
     result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
     scaleResult = scaleResult || [-0, -0, -0];
-    const scale4 = this.getScale(scaleResult);
-    const inverseScale0 = 1 / scale4[0];
-    const inverseScale1 = 1 / scale4[1];
-    const inverseScale2 = 1 / scale4[2];
+    const scale5 = this.getScale(scaleResult);
+    const inverseScale0 = 1 / scale5[0];
+    const inverseScale1 = 1 / scale5[1];
+    const inverseScale2 = 1 / scale5[2];
     result[0] = this[0] * inverseScale0;
     result[1] = this[1] * inverseScale1;
     result[2] = this[2] * inverseScale2;
@@ -1326,65 +2401,65 @@ var Matrix4 = class extends Matrix {
     return result;
   }
   transpose() {
-    mat4.transpose(this, this);
+    transpose2(this, this);
     return this.check();
   }
   invert() {
-    mat4.invert(this, this);
+    invert2(this, this);
     return this.check();
   }
   multiplyLeft(a) {
-    mat4.multiply(this, a, this);
+    multiply2(this, a, this);
     return this.check();
   }
   multiplyRight(a) {
-    mat4.multiply(this, this, a);
+    multiply2(this, this, a);
     return this.check();
   }
   rotateX(radians2) {
-    mat4.rotateX(this, this, radians2);
+    rotateX2(this, this, radians2);
     return this.check();
   }
   rotateY(radians2) {
-    mat4.rotateY(this, this, radians2);
+    rotateY2(this, this, radians2);
     return this.check();
   }
   rotateZ(radians2) {
-    mat4.rotateZ(this, this, radians2);
+    rotateZ2(this, this, radians2);
     return this.check();
   }
   rotateXYZ(angleXYZ) {
     return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
   }
   rotateAxis(radians2, axis) {
-    mat4.rotate(this, this, radians2, axis);
+    rotate2(this, this, radians2, axis);
     return this.check();
   }
   scale(factor) {
-    mat4.scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
+    scale2(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
     return this.check();
   }
   translate(vector) {
-    mat4.translate(this, this, vector);
+    translate2(this, this, vector);
     return this.check();
   }
   transform(vector, result) {
     if (vector.length === 4) {
-      result = vec42.transformMat4(result || [-0, -0, -0, -0], vector, this);
+      result = transformMat42(result || [-0, -0, -0, -0], vector, this);
       checkVector(result, 4);
       return result;
     }
     return this.transformAsPoint(vector, result);
   }
   transformAsPoint(vector, result) {
-    const { length: length3 } = vector;
+    const { length: length4 } = vector;
     let out;
-    switch (length3) {
+    switch (length4) {
       case 2:
-        out = vec23.transformMat4(result || [-0, -0], vector, this);
+        out = transformMat4(result || [-0, -0], vector, this);
         break;
       case 3:
-        out = vec33.transformMat4(result || [-0, -0, -0], vector, this);
+        out = transformMat42(result || [-0, -0, -0], vector, this);
         break;
       default:
         throw new Error("Illegal vector");
@@ -1471,9 +2546,363 @@ function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, n
   return result;
 }
 
+// src/gl-matrix/vec4.js
+function create4() {
+  const out = new ARRAY_TYPE(4);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+  }
+  return out;
+}
+function add(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  out[3] = a[3] + b[3];
+  return out;
+}
+function scale3(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  out[3] = a[3] * b;
+  return out;
+}
+function length2(a) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  const w = a[3];
+  return Math.sqrt(x * x + y * y + z * z + w * w);
+}
+function squaredLength(a) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  const w = a[3];
+  return x * x + y * y + z * z + w * w;
+}
+function normalize2(out, a) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  const w = a[3];
+  let len2 = x * x + y * y + z * z + w * w;
+  if (len2 > 0) {
+    len2 = 1 / Math.sqrt(len2);
+  }
+  out[0] = x * len2;
+  out[1] = y * len2;
+  out[2] = z * len2;
+  out[3] = w * len2;
+  return out;
+}
+function dot2(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+}
+function lerp2(out, a, b, t) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  out[2] = az + t * (b[2] - az);
+  out[3] = aw + t * (b[3] - aw);
+  return out;
+}
+function transformQuat2(out, a, q) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  const qx = q[0];
+  const qy = q[1];
+  const qz = q[2];
+  const qw = q[3];
+  const ix = qw * x + qy * z - qz * y;
+  const iy = qw * y + qz * x - qx * z;
+  const iz = qw * z + qx * y - qy * x;
+  const iw = -qx * x - qy * y - qz * z;
+  out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+  out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+  out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+  out[3] = a[3];
+  return out;
+}
+var forEach3 = function() {
+  const vec = create4();
+  return function(a, stride, offset, count, fn, arg) {
+    let i;
+    let l;
+    if (!stride) {
+      stride = 4;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      vec[2] = a[i + 2];
+      vec[3] = a[i + 3];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+      a[i + 2] = vec[2];
+      a[i + 3] = vec[3];
+    }
+    return a;
+  };
+}();
+
+// src/gl-matrix/quat.ts
+function create5() {
+  const out = new ARRAY_TYPE(4);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  out[3] = 1;
+  return out;
+}
+function identity2(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 1;
+  return out;
+}
+function setAxisAngle(out, axis, rad) {
+  rad = rad * 0.5;
+  const s = Math.sin(rad);
+  out[0] = s * axis[0];
+  out[1] = s * axis[1];
+  out[2] = s * axis[2];
+  out[3] = Math.cos(rad);
+  return out;
+}
+function multiply3(out, a, b) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const bx = b[0];
+  const by = b[1];
+  const bz = b[2];
+  const bw = b[3];
+  out[0] = ax * bw + aw * bx + ay * bz - az * by;
+  out[1] = ay * bw + aw * by + az * bx - ax * bz;
+  out[2] = az * bw + aw * bz + ax * by - ay * bx;
+  out[3] = aw * bw - ax * bx - ay * by - az * bz;
+  return out;
+}
+function rotateX3(out, a, rad) {
+  rad *= 0.5;
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const bx = Math.sin(rad);
+  const bw = Math.cos(rad);
+  out[0] = ax * bw + aw * bx;
+  out[1] = ay * bw + az * bx;
+  out[2] = az * bw - ay * bx;
+  out[3] = aw * bw - ax * bx;
+  return out;
+}
+function rotateY3(out, a, rad) {
+  rad *= 0.5;
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const by = Math.sin(rad);
+  const bw = Math.cos(rad);
+  out[0] = ax * bw - az * by;
+  out[1] = ay * bw + aw * by;
+  out[2] = az * bw + ax * by;
+  out[3] = aw * bw - ay * by;
+  return out;
+}
+function rotateZ3(out, a, rad) {
+  rad *= 0.5;
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const bz = Math.sin(rad);
+  const bw = Math.cos(rad);
+  out[0] = ax * bw + ay * bz;
+  out[1] = ay * bw - ax * bz;
+  out[2] = az * bw + aw * bz;
+  out[3] = aw * bw - az * bz;
+  return out;
+}
+function calculateW(out, a) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = Math.sqrt(Math.abs(1 - x * x - y * y - z * z));
+  return out;
+}
+function slerp(out, a, b, t) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  let bx = b[0];
+  let by = b[1];
+  let bz = b[2];
+  let bw = b[3];
+  let cosom;
+  let omega;
+  let scale0;
+  let scale1;
+  let sinom;
+  cosom = ax * bx + ay * by + az * bz + aw * bw;
+  if (cosom < 0) {
+    cosom = -cosom;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+  if (1 - cosom > EPSILON) {
+    omega = Math.acos(cosom);
+    sinom = Math.sin(omega);
+    scale0 = Math.sin((1 - t) * omega) / sinom;
+    scale1 = Math.sin(t * omega) / sinom;
+  } else {
+    scale0 = 1 - t;
+    scale1 = t;
+  }
+  out[0] = scale0 * ax + scale1 * bx;
+  out[1] = scale0 * ay + scale1 * by;
+  out[2] = scale0 * az + scale1 * bz;
+  out[3] = scale0 * aw + scale1 * bw;
+  return out;
+}
+function invert3(out, a) {
+  const a0 = a[0];
+  const a1 = a[1];
+  const a2 = a[2];
+  const a3 = a[3];
+  const dot4 = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
+  const invDot = dot4 ? 1 / dot4 : 0;
+  out[0] = -a0 * invDot;
+  out[1] = -a1 * invDot;
+  out[2] = -a2 * invDot;
+  out[3] = a3 * invDot;
+  return out;
+}
+function conjugate(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  out[3] = a[3];
+  return out;
+}
+function fromMat3(out, m) {
+  const fTrace = m[0] + m[4] + m[8];
+  let fRoot;
+  if (fTrace > 0) {
+    fRoot = Math.sqrt(fTrace + 1);
+    out[3] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[0] = (m[5] - m[7]) * fRoot;
+    out[1] = (m[6] - m[2]) * fRoot;
+    out[2] = (m[1] - m[3]) * fRoot;
+  } else {
+    let i = 0;
+    if (m[4] > m[0])
+      i = 1;
+    if (m[8] > m[i * 3 + i])
+      i = 2;
+    const j = (i + 1) % 3;
+    const k = (i + 2) % 3;
+    fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1);
+    out[i] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
+    out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
+    out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
+  }
+  return out;
+}
+var add2 = add;
+var scale4 = scale3;
+var dot3 = dot2;
+var lerp3 = lerp2;
+var length3 = length2;
+var squaredLength2 = squaredLength;
+var normalize3 = normalize2;
+var rotationTo = function() {
+  const tmpvec3 = create2();
+  const xUnitVec3 = fromValues(1, 0, 0);
+  const yUnitVec3 = fromValues(0, 1, 0);
+  return function(out, a, b) {
+    const dot4 = dot(a, b);
+    if (dot4 < -0.999999) {
+      cross(tmpvec3, xUnitVec3, a);
+      if (len(tmpvec3) < 1e-6)
+        cross(tmpvec3, yUnitVec3, a);
+      normalize(tmpvec3, tmpvec3);
+      setAxisAngle(out, tmpvec3, Math.PI);
+      return out;
+    } else if (dot4 > 0.999999) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+      out[3] = 1;
+      return out;
+    }
+    cross(tmpvec3, a, b);
+    out[0] = tmpvec3[0];
+    out[1] = tmpvec3[1];
+    out[2] = tmpvec3[2];
+    out[3] = 1 + dot4;
+    return normalize3(out, out);
+  };
+}();
+var sqlerp = function() {
+  const temp1 = create5();
+  const temp2 = create5();
+  return function(out, a, b, c, d, t) {
+    slerp(temp1, a, d, t);
+    slerp(temp2, b, c, t);
+    slerp(out, temp1, temp2, 2 * t * (1 - t));
+    return out;
+  };
+}();
+var setAxes = function() {
+  const matr = create3();
+  return function(out, view, right, up) {
+    matr[0] = right[0];
+    matr[3] = right[1];
+    matr[6] = right[2];
+    matr[1] = up[0];
+    matr[4] = up[1];
+    matr[7] = up[2];
+    matr[2] = -view[0];
+    matr[5] = -view[1];
+    matr[8] = -view[2];
+    return normalize3(out, fromMat3(out, matr));
+  };
+}();
+
 // src/classes/quaternion.ts
-var quat = __toESM(require("gl-matrix/quat"), 1);
-var vec43 = __toESM(require("gl-matrix/vec4"), 1);
 var IDENTITY_QUATERNION = [0, 0, 0, 1];
 var Quaternion = class extends MathArray {
   constructor(x = 0, y = 0, z = 0, w = 1) {
@@ -1506,15 +2935,15 @@ var Quaternion = class extends MathArray {
     return this.check();
   }
   fromMatrix3(m) {
-    quat.fromMat3(this, m);
+    fromMat3(this, m);
     return this.check();
   }
   fromAxisRotation(axis, rad) {
-    quat.setAxisAngle(this, axis, rad);
+    setAxisAngle(this, axis, rad);
     return this.check();
   }
   identity() {
-    quat.identity(this);
+    identity2(this);
     return this.check();
   }
   setAxisAngle(axis, rad) {
@@ -1548,75 +2977,75 @@ var Quaternion = class extends MathArray {
     this[3] = checkNumber(value);
   }
   len() {
-    return quat.length(this);
+    return length3(this);
   }
   lengthSquared() {
-    return quat.squaredLength(this);
+    return squaredLength2(this);
   }
   dot(a) {
-    return quat.dot(this, a);
+    return dot3(this, a);
   }
   rotationTo(vectorA, vectorB) {
-    quat.rotationTo(this, vectorA, vectorB);
+    rotationTo(this, vectorA, vectorB);
     return this.check();
   }
   add(a) {
-    quat.add(this, this, a);
+    add2(this, this, a);
     return this.check();
   }
   calculateW() {
-    quat.calculateW(this, this);
+    calculateW(this, this);
     return this.check();
   }
   conjugate() {
-    quat.conjugate(this, this);
+    conjugate(this, this);
     return this.check();
   }
   invert() {
-    quat.invert(this, this);
+    invert3(this, this);
     return this.check();
   }
   lerp(a, b, t) {
     if (t === void 0) {
       return this.lerp(this, a, b);
     }
-    quat.lerp(this, a, b, t);
+    lerp3(this, a, b, t);
     return this.check();
   }
   multiplyRight(a) {
-    quat.multiply(this, this, a);
+    multiply3(this, this, a);
     return this.check();
   }
   multiplyLeft(a) {
-    quat.multiply(this, a, this);
+    multiply3(this, a, this);
     return this.check();
   }
   normalize() {
-    const length3 = this.len();
-    const l = length3 > 0 ? 1 / length3 : 0;
+    const length4 = this.len();
+    const l = length4 > 0 ? 1 / length4 : 0;
     this[0] = this[0] * l;
     this[1] = this[1] * l;
     this[2] = this[2] * l;
     this[3] = this[3] * l;
-    if (length3 === 0) {
+    if (length4 === 0) {
       this[3] = 1;
     }
     return this.check();
   }
   rotateX(rad) {
-    quat.rotateX(this, this, rad);
+    rotateX3(this, this, rad);
     return this.check();
   }
   rotateY(rad) {
-    quat.rotateY(this, this, rad);
+    rotateY3(this, this, rad);
     return this.check();
   }
   rotateZ(rad) {
-    quat.rotateZ(this, this, rad);
+    rotateZ3(this, this, rad);
     return this.check();
   }
   scale(b) {
-    quat.scale(this, this, b);
+    scale4(this, this, b);
     return this.check();
   }
   slerp(arg0, arg1, arg2) {
@@ -1641,11 +3070,11 @@ var Quaternion = class extends MathArray {
         target = arg1;
         ratio = arg2;
     }
-    quat.slerp(this, start, target, ratio);
+    slerp(this, start, target, ratio);
     return this.check();
   }
   transformVector4(vector, result = new Vector4()) {
-    vec43.transformQuat(result, vector, this);
+    transformQuat2(result, vector, this);
     return checkVector(result, 4);
   }
   lengthSq() {
@@ -1663,8 +3092,7 @@ var Quaternion = class extends MathArray {
 };
 
 // src/classes/spherical-coordinates.ts
-var vec34 = __toESM(require("gl-matrix/vec3"), 1);
-var EPSILON = 1e-6;
+var EPSILON2 = 1e-6;
 var EARTH_RADIUS_METERS = 6371e3;
 var SphericalCoordinates = class {
   constructor({
@@ -1750,7 +3178,7 @@ var SphericalCoordinates = class {
     return this.check();
   }
   fromVector3(v) {
-    this.radius = vec34.length(v);
+    this.radius = length(v);
     if (this.radius > 0) {
       this.theta = Math.atan2(v[0], v[1]);
       this.phi = Math.acos(clamp(v[2] / this.radius, -1, 1));
@@ -1761,7 +3189,7 @@ var SphericalCoordinates = class {
     return new Vector3(0, 0, this.radius).rotateX({ radians: this.theta }).rotateZ({ radians: this.phi });
   }
   makeSafe() {
-    this.phi = Math.max(EPSILON, Math.min(Math.PI - EPSILON, this.phi));
+    this.phi = Math.max(EPSILON2, Math.min(Math.PI - EPSILON2, this.phi));
     return this;
   }
   check() {
@@ -1982,7 +3410,7 @@ var Euler = class extends MathArray {
   }
   getQuaternion() {
     const q = new Quaternion();
-    switch (this[4]) {
+    switch (this[3]) {
       case 5 /* XYZ */:
         return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
       case 1 /* YXZ */:
@@ -2307,29 +3735,54 @@ var Pose = class {
 };
 
 // src/lib/math-utils.ts
-var math_utils_default = {
-  EPSILON1: 0.1,
-  EPSILON2: 0.01,
-  EPSILON3: 1e-3,
-  EPSILON4: 1e-4,
-  EPSILON5: 1e-5,
-  EPSILON6: 1e-6,
-  EPSILON7: 1e-7,
-  EPSILON8: 1e-8,
-  EPSILON9: 1e-9,
-  EPSILON10: 1e-10,
-  EPSILON11: 1e-11,
-  EPSILON12: 1e-12,
-  EPSILON13: 1e-13,
-  EPSILON14: 1e-14,
-  EPSILON15: 1e-15,
-  EPSILON16: 1e-16,
-  EPSILON17: 1e-17,
-  EPSILON18: 1e-18,
-  EPSILON19: 1e-19,
-  EPSILON20: 1e-20,
-  PI_OVER_TWO: Math.PI / 2,
-  PI_OVER_FOUR: Math.PI / 4,
-  PI_OVER_SIX: Math.PI / 6,
-  TWO_PI: Math.PI * 2
-};
+var math_utils_exports = {};
+__export(math_utils_exports, {
+  EPSILON1: () => EPSILON1,
+  EPSILON10: () => EPSILON10,
+  EPSILON11: () => EPSILON11,
+  EPSILON12: () => EPSILON12,
+  EPSILON13: () => EPSILON13,
+  EPSILON14: () => EPSILON14,
+  EPSILON15: () => EPSILON15,
+  EPSILON16: () => EPSILON16,
+  EPSILON17: () => EPSILON17,
+  EPSILON18: () => EPSILON18,
+  EPSILON19: () => EPSILON19,
+  EPSILON2: () => EPSILON22,
+  EPSILON20: () => EPSILON20,
+  EPSILON3: () => EPSILON3,
+  EPSILON4: () => EPSILON4,
+  EPSILON5: () => EPSILON5,
+  EPSILON6: () => EPSILON6,
+  EPSILON7: () => EPSILON7,
+  EPSILON8: () => EPSILON8,
+  EPSILON9: () => EPSILON9,
+  PI_OVER_FOUR: () => PI_OVER_FOUR,
+  PI_OVER_SIX: () => PI_OVER_SIX,
+  PI_OVER_TWO: () => PI_OVER_TWO,
+  TWO_PI: () => TWO_PI
+});
+var EPSILON1 = 0.1;
+var EPSILON22 = 0.01;
+var EPSILON3 = 1e-3;
+var EPSILON4 = 1e-4;
+var EPSILON5 = 1e-5;
+var EPSILON6 = 1e-6;
+var EPSILON7 = 1e-7;
+var EPSILON8 = 1e-8;
+var EPSILON9 = 1e-9;
+var EPSILON10 = 1e-10;
+var EPSILON11 = 1e-11;
+var EPSILON12 = 1e-12;
+var EPSILON13 = 1e-13;
+var EPSILON14 = 1e-14;
+var EPSILON15 = 1e-15;
+var EPSILON16 = 1e-16;
+var EPSILON17 = 1e-17;
+var EPSILON18 = 1e-18;
+var EPSILON19 = 1e-19;
+var EPSILON20 = 1e-20;
+var PI_OVER_TWO = Math.PI / 2;
+var PI_OVER_FOUR = Math.PI / 4;
+var PI_OVER_SIX = Math.PI / 6;
+var TWO_PI = Math.PI * 2;