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

package/dist/index.cjs

@@ -0,0 +1,2335 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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
+var src_exports = {};
+__export(src_exports, {
+  Euler: () => Euler,
+  Matrix3: () => Matrix3,
+  Matrix4: () => Matrix4,
+  Pose: () => Pose,
+  Quaternion: () => Quaternion,
+  SphericalCoordinates: () => SphericalCoordinates,
+  Vector2: () => Vector2,
+  Vector3: () => Vector3,
+  Vector4: () => Vector4,
+  _Euler: () => Euler,
+  _MathUtils: () => math_utils_default,
+  _Pose: () => Pose,
+  _SphericalCoordinates: () => SphericalCoordinates,
+  acos: () => acos,
+  asin: () => asin,
+  assert: () => assert,
+  atan: () => atan,
+  clamp: () => clamp,
+  clone: () => clone,
+  config: () => config,
+  configure: () => configure,
+  cos: () => cos,
+  degrees: () => degrees,
+  equals: () => equals,
+  exactEquals: () => exactEquals,
+  formatValue: () => formatValue,
+  isArray: () => isArray,
+  lerp: () => lerp,
+  radians: () => radians,
+  sin: () => sin,
+  tan: () => tan,
+  toDegrees: () => toDegrees,
+  toRadians: () => toRadians,
+  withEpsilon: () => withEpsilon
+});
+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 = {
+  EPSILON: 1e-12,
+  debug: false,
+  precision: 4,
+  printTypes: false,
+  printDegrees: false,
+  printRowMajor: true
+};
+function configure(options) {
+  Object.assign(config, options);
+  return config;
+}
+function formatValue(value, { precision = config.precision } = {}) {
+  value = round(value);
+  return `${parseFloat(value.toPrecision(precision))}`;
+}
+function isArray(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function clone(array) {
+  return "clone" in array ? array.clone() : array.slice();
+}
+function toRadians(degrees2) {
+  return radians(degrees2);
+}
+function toDegrees(radians2) {
+  return degrees(radians2);
+}
+function radians(degrees2, result) {
+  return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
+}
+function degrees(radians2, result) {
+  return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
+}
+function sin(radians2, result) {
+  return map(radians2, (angle2) => Math.sin(angle2), result);
+}
+function cos(radians2, result) {
+  return map(radians2, (angle2) => Math.cos(angle2), result);
+}
+function tan(radians2, result) {
+  return map(radians2, (angle2) => Math.tan(angle2), result);
+}
+function asin(radians2, result) {
+  return map(radians2, (angle2) => Math.asin(angle2), result);
+}
+function acos(radians2, result) {
+  return map(radians2, (angle2) => Math.acos(angle2), result);
+}
+function atan(radians2, result) {
+  return map(radians2, (angle2) => Math.atan(angle2), result);
+}
+function clamp(value, min, max) {
+  return map(value, (value2) => Math.max(min, Math.min(max, value2)));
+}
+function lerp(a, b, t) {
+  if (isArray(a)) {
+    return a.map((ai, i) => lerp(ai, b[i], t));
+  }
+  return t * b + (1 - t) * a;
+}
+function equals(a, b, epsilon) {
+  const oldEpsilon = config.EPSILON;
+  if (epsilon) {
+    config.EPSILON = epsilon;
+  }
+  try {
+    if (a === b) {
+      return true;
+    }
+    if (isArray(a) && isArray(b)) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; ++i) {
+        if (!equals(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a && a.equals) {
+      return a.equals(b);
+    }
+    if (b && b.equals) {
+      return b.equals(a);
+    }
+    if (typeof a === "number" && typeof b === "number") {
+      return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+    }
+    return false;
+  } finally {
+    config.EPSILON = oldEpsilon;
+  }
+}
+function exactEquals(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a && typeof a === "object" && b && typeof b === "object") {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (a.exactEquals) {
+      return a.exactEquals(b);
+    }
+  }
+  if (isArray(a) && isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; ++i) {
+      if (!exactEquals(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function withEpsilon(epsilon, func) {
+  const oldPrecision = config.EPSILON;
+  config.EPSILON = epsilon;
+  let value;
+  try {
+    value = func();
+  } finally {
+    config.EPSILON = oldPrecision;
+  }
+  return value;
+}
+function round(value) {
+  return Math.round(value / config.EPSILON) * config.EPSILON;
+}
+function duplicateArray(array) {
+  return array.clone ? array.clone() : new Array(array.length);
+}
+function map(value, func, result) {
+  if (isArray(value)) {
+    const array = value;
+    result = result || duplicateArray(array);
+    for (let i = 0; i < result.length && i < array.length; ++i) {
+      const val = typeof value === "number" ? value : value[i];
+      result[i] = func(val, i, result);
+    }
+    return result;
+  }
+  return func(value);
+}
+
+// src/classes/base/math-array.ts
+var MathArray = class extends Array {
+  clone() {
+    return new this.constructor().copy(this);
+  }
+  fromArray(array, offset = 0) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = array[i + offset];
+    }
+    return this.check();
+  }
+  toArray(targetArray = [], offset = 0) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      targetArray[offset + i] = this[i];
+    }
+    return targetArray;
+  }
+  from(arrayOrObject) {
+    return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+  }
+  to(arrayOrObject) {
+    if (arrayOrObject === this) {
+      return this;
+    }
+    return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+  }
+  toTarget(target) {
+    return target ? this.to(target) : this;
+  }
+  toFloat32Array() {
+    return new Float32Array(this);
+  }
+  toString() {
+    return this.formatString(config);
+  }
+  formatString(opts) {
+    let string = "";
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
+    }
+    return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
+  }
+  equals(array) {
+    if (!array || this.length !== array.length) {
+      return false;
+    }
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      if (!equals(this[i], array[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  exactEquals(array) {
+    if (!array || this.length !== array.length) {
+      return false;
+    }
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      if (this[i] !== array[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  negate() {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = -this[i];
+    }
+    return this.check();
+  }
+  lerp(a, b, t) {
+    if (t === void 0) {
+      return this.lerp(this, a, b);
+    }
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      const ai = a[i];
+      const endValue = typeof b === "number" ? b : b[i];
+      this[i] = ai + t * (endValue - ai);
+    }
+    return this.check();
+  }
+  min(vector) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.min(vector[i], this[i]);
+    }
+    return this.check();
+  }
+  max(vector) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.max(vector[i], this[i]);
+    }
+    return this.check();
+  }
+  clamp(minVector, maxVector) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
+    }
+    return this.check();
+  }
+  add(...vectors) {
+    for (const vector of vectors) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] += vector[i];
+      }
+    }
+    return this.check();
+  }
+  subtract(...vectors) {
+    for (const vector of vectors) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] -= vector[i];
+      }
+    }
+    return this.check();
+  }
+  scale(scale4) {
+    if (typeof scale4 === "number") {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] *= scale4;
+      }
+    } else {
+      for (let i = 0; i < this.ELEMENTS && i < scale4.length; ++i) {
+        this[i] *= scale4[i];
+      }
+    }
+    return this.check();
+  }
+  multiplyByScalar(scalar) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] *= scalar;
+    }
+    return this.check();
+  }
+  check() {
+    if (config.debug && !this.validate()) {
+      throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
+    }
+    return this;
+  }
+  validate() {
+    let valid = this.length === this.ELEMENTS;
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      valid = valid && Number.isFinite(this[i]);
+    }
+    return valid;
+  }
+  sub(a) {
+    return this.subtract(a);
+  }
+  setScalar(a) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = a;
+    }
+    return this.check();
+  }
+  addScalar(a) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] += a;
+    }
+    return this.check();
+  }
+  subScalar(a) {
+    return this.addScalar(-a);
+  }
+  multiplyScalar(scalar) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] *= scalar;
+    }
+    return this.check();
+  }
+  divideScalar(a) {
+    return this.multiplyByScalar(1 / a);
+  }
+  clampScalar(min, max) {
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      this[i] = Math.min(Math.max(this[i], min), max);
+    }
+    return this.check();
+  }
+  get elements() {
+    return this;
+  }
+};
+
+// src/lib/validators.ts
+function validateVector(v, length3) {
+  if (v.length !== length3) {
+    return false;
+  }
+  for (let i = 0; i < v.length; ++i) {
+    if (!Number.isFinite(v[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkNumber(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`Invalid number ${value}`);
+  }
+  return value;
+}
+function checkVector(v, length3, callerName = "") {
+  if (config.debug && !validateVector(v, length3)) {
+    throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
+  }
+  return v;
+}
+
+// src/lib/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`math.gl assertion ${message}`);
+  }
+}
+
+// src/classes/base/vector.ts
+var Vector = class extends MathArray {
+  get x() {
+    return this[0];
+  }
+  set x(value) {
+    this[0] = checkNumber(value);
+  }
+  get y() {
+    return this[1];
+  }
+  set y(value) {
+    this[1] = checkNumber(value);
+  }
+  len() {
+    return Math.sqrt(this.lengthSquared());
+  }
+  magnitude() {
+    return this.len();
+  }
+  lengthSquared() {
+    let length3 = 0;
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      length3 += this[i] * this[i];
+    }
+    return length3;
+  }
+  magnitudeSquared() {
+    return this.lengthSquared();
+  }
+  distance(mathArray) {
+    return Math.sqrt(this.distanceSquared(mathArray));
+  }
+  distanceSquared(mathArray) {
+    let length3 = 0;
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      const dist = this[i] - mathArray[i];
+      length3 += dist * dist;
+    }
+    return checkNumber(length3);
+  }
+  dot(mathArray) {
+    let product = 0;
+    for (let i = 0; i < this.ELEMENTS; ++i) {
+      product += this[i] * mathArray[i];
+    }
+    return checkNumber(product);
+  }
+  normalize() {
+    const length3 = this.magnitude();
+    if (length3 !== 0) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] /= length3;
+      }
+    }
+    return this.check();
+  }
+  multiply(...vectors) {
+    for (const vector of vectors) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] *= vector[i];
+      }
+    }
+    return this.check();
+  }
+  divide(...vectors) {
+    for (const vector of vectors) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] /= vector[i];
+      }
+    }
+    return this.check();
+  }
+  lengthSq() {
+    return this.lengthSquared();
+  }
+  distanceTo(vector) {
+    return this.distance(vector);
+  }
+  distanceToSquared(vector) {
+    return this.distanceSquared(vector);
+  }
+  getComponent(i) {
+    assert(i >= 0 && i < this.ELEMENTS, "index is out of range");
+    return checkNumber(this[i]);
+  }
+  setComponent(i, value) {
+    assert(i >= 0 && i < this.ELEMENTS, "index is out of range");
+    this[i] = value;
+    return this.check();
+  }
+  addVectors(a, b) {
+    return this.copy(a).add(b);
+  }
+  subVectors(a, b) {
+    return this.copy(a).subtract(b);
+  }
+  multiplyVectors(a, b) {
+    return this.copy(a).multiply(b);
+  }
+  addScaledVector(a, b) {
+    return this.add(new this.constructor(a).multiplyScalar(b));
+  }
+};
+
+// src/classes/vector2.ts
+var vec2 = __toESM(require("gl-matrix/vec2"), 1);
+
+// src/lib/gl-matrix-extras.ts
+function vec2_transformMat4AsVector(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  const w = m[3] * x + m[7] * y || 1;
+  out[0] = (m[0] * x + m[4] * y) / w;
+  out[1] = (m[1] * x + m[5] * y) / w;
+  return out;
+}
+function vec3_transformMat4AsVector(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  const w = m[3] * x + m[7] * y + m[11] * z || 1;
+  out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
+  out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
+  out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
+  return out;
+}
+function vec3_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;
+  out[2] = a[2];
+  return out;
+}
+function vec4_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;
+  out[2] = a[2];
+  out[3] = a[3];
+  return out;
+}
+function vec4_transformMat3(out, a, m) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  out[0] = m[0] * x + m[3] * y + m[6] * z;
+  out[1] = m[1] * x + m[4] * y + m[7] * z;
+  out[2] = m[2] * x + m[5] * y + m[8] * z;
+  out[3] = a[3];
+  return out;
+}
+
+// src/classes/vector2.ts
+var Vector2 = class extends Vector {
+  constructor(x = 0, y = 0) {
+    super(2);
+    if (isArray(x) && arguments.length === 1) {
+      this.copy(x);
+    } else {
+      if (config.debug) {
+        checkNumber(x);
+        checkNumber(y);
+      }
+      this[0] = x;
+      this[1] = y;
+    }
+  }
+  set(x, y) {
+    this[0] = x;
+    this[1] = y;
+    return this.check();
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    return this.check();
+  }
+  fromObject(object) {
+    if (config.debug) {
+      checkNumber(object.x);
+      checkNumber(object.y);
+    }
+    this[0] = object.x;
+    this[1] = object.y;
+    return this.check();
+  }
+  toObject(object) {
+    object.x = this[0];
+    object.y = this[1];
+    return object;
+  }
+  get ELEMENTS() {
+    return 2;
+  }
+  horizontalAngle() {
+    return Math.atan2(this.y, this.x);
+  }
+  verticalAngle() {
+    return Math.atan2(this.x, this.y);
+  }
+  transform(matrix4) {
+    return this.transformAsPoint(matrix4);
+  }
+  transformAsPoint(matrix4) {
+    vec2.transformMat4(this, this, matrix4);
+    return this.check();
+  }
+  transformAsVector(matrix4) {
+    vec2_transformMat4AsVector(this, this, matrix4);
+    return this.check();
+  }
+  transformByMatrix3(matrix3) {
+    vec2.transformMat3(this, this, matrix3);
+    return this.check();
+  }
+  transformByMatrix2x3(matrix2x3) {
+    vec2.transformMat2d(this, this, matrix2x3);
+    return this.check();
+  }
+  transformByMatrix2(matrix2) {
+    vec2.transformMat2(this, this, matrix2);
+    return this.check();
+  }
+};
+
+// src/classes/vector3.ts
+var vec3 = __toESM(require("gl-matrix/vec3"), 1);
+var ORIGIN = [0, 0, 0];
+var ZERO;
+var Vector3 = class extends Vector {
+  static get ZERO() {
+    if (!ZERO) {
+      ZERO = new Vector3(0, 0, 0);
+      Object.freeze(ZERO);
+    }
+    return ZERO;
+  }
+  constructor(x = 0, y = 0, z = 0) {
+    super(-0, -0, -0);
+    if (arguments.length === 1 && isArray(x)) {
+      this.copy(x);
+    } else {
+      if (config.debug) {
+        checkNumber(x);
+        checkNumber(y);
+        checkNumber(z);
+      }
+      this[0] = x;
+      this[1] = y;
+      this[2] = z;
+    }
+  }
+  set(x, y, z) {
+    this[0] = x;
+    this[1] = y;
+    this[2] = z;
+    return this.check();
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    return this.check();
+  }
+  fromObject(object) {
+    if (config.debug) {
+      checkNumber(object.x);
+      checkNumber(object.y);
+      checkNumber(object.z);
+    }
+    this[0] = object.x;
+    this[1] = object.y;
+    this[2] = object.z;
+    return this.check();
+  }
+  toObject(object) {
+    object.x = this[0];
+    object.y = this[1];
+    object.z = this[2];
+    return object;
+  }
+  get ELEMENTS() {
+    return 3;
+  }
+  get z() {
+    return this[2];
+  }
+  set z(value) {
+    this[2] = checkNumber(value);
+  }
+  angle(vector) {
+    return vec3.angle(this, vector);
+  }
+  cross(vector) {
+    vec3.cross(this, this, vector);
+    return this.check();
+  }
+  rotateX({ radians: radians2, origin = ORIGIN }) {
+    vec3.rotateX(this, this, origin, radians2);
+    return this.check();
+  }
+  rotateY({ radians: radians2, origin = ORIGIN }) {
+    vec3.rotateY(this, this, origin, radians2);
+    return this.check();
+  }
+  rotateZ({ radians: radians2, origin = ORIGIN }) {
+    vec3.rotateZ(this, this, origin, radians2);
+    return this.check();
+  }
+  transform(matrix4) {
+    return this.transformAsPoint(matrix4);
+  }
+  transformAsPoint(matrix4) {
+    vec3.transformMat4(this, this, matrix4);
+    return this.check();
+  }
+  transformAsVector(matrix4) {
+    vec3_transformMat4AsVector(this, this, matrix4);
+    return this.check();
+  }
+  transformByMatrix3(matrix3) {
+    vec3.transformMat3(this, this, matrix3);
+    return this.check();
+  }
+  transformByMatrix2(matrix2) {
+    vec3_transformMat2(this, this, matrix2);
+    return this.check();
+  }
+  transformByQuaternion(quaternion) {
+    vec3.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() {
+    if (!ZERO2) {
+      ZERO2 = new Vector4(0, 0, 0, 0);
+      Object.freeze(ZERO2);
+    }
+    return ZERO2;
+  }
+  constructor(x = 0, y = 0, z = 0, w = 0) {
+    super(-0, -0, -0, -0);
+    if (isArray(x) && arguments.length === 1) {
+      this.copy(x);
+    } else {
+      if (config.debug) {
+        checkNumber(x);
+        checkNumber(y);
+        checkNumber(z);
+        checkNumber(w);
+      }
+      this[0] = x;
+      this[1] = y;
+      this[2] = z;
+      this[3] = w;
+    }
+  }
+  set(x, y, z, w) {
+    this[0] = x;
+    this[1] = y;
+    this[2] = z;
+    this[3] = w;
+    return this.check();
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    this[3] = array[3];
+    return this.check();
+  }
+  fromObject(object) {
+    if (config.debug) {
+      checkNumber(object.x);
+      checkNumber(object.y);
+      checkNumber(object.z);
+      checkNumber(object.w);
+    }
+    this[0] = object.x;
+    this[1] = object.y;
+    this[2] = object.z;
+    this[3] = object.w;
+    return this;
+  }
+  toObject(object) {
+    object.x = this[0];
+    object.y = this[1];
+    object.z = this[2];
+    object.w = this[3];
+    return object;
+  }
+  get ELEMENTS() {
+    return 4;
+  }
+  get z() {
+    return this[2];
+  }
+  set z(value) {
+    this[2] = checkNumber(value);
+  }
+  get w() {
+    return this[3];
+  }
+  set w(value) {
+    this[3] = checkNumber(value);
+  }
+  transform(matrix4) {
+    vec4.transformMat4(this, this, matrix4);
+    return this.check();
+  }
+  transformByMatrix3(matrix3) {
+    vec4_transformMat3(this, this, matrix3);
+    return this.check();
+  }
+  transformByMatrix2(matrix2) {
+    vec4_transformMat2(this, this, matrix2);
+    return this.check();
+  }
+  transformByQuaternion(quaternion) {
+    vec4.transformQuat(this, this, quaternion);
+    return this.check();
+  }
+  applyMatrix4(m) {
+    m.transform(this, this);
+    return this;
+  }
+};
+
+// src/classes/base/matrix.ts
+var Matrix = class extends MathArray {
+  toString() {
+    let string = "[";
+    if (config.printRowMajor) {
+      string += "row-major:";
+      for (let row = 0; row < this.RANK; ++row) {
+        for (let col = 0; col < this.RANK; ++col) {
+          string += ` ${this[col * this.RANK + row]}`;
+        }
+      }
+    } else {
+      string += "column-major:";
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        string += ` ${this[i]}`;
+      }
+    }
+    string += "]";
+    return string;
+  }
+  getElementIndex(row, col) {
+    return col * this.RANK + row;
+  }
+  getElement(row, col) {
+    return this[col * this.RANK + row];
+  }
+  setElement(row, col, value) {
+    this[col * this.RANK + row] = checkNumber(value);
+    return this;
+  }
+  getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+    const firstIndex = columnIndex * this.RANK;
+    for (let i = 0; i < this.RANK; ++i) {
+      result[i] = this[firstIndex + i];
+    }
+    return result;
+  }
+  setColumn(columnIndex, columnVector) {
+    const firstIndex = columnIndex * this.RANK;
+    for (let i = 0; i < this.RANK; ++i) {
+      this[firstIndex + i] = columnVector[i];
+    }
+    return this;
+  }
+};
+
+// 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";
+  INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2";
+  INDICES3[INDICES3["COL1ROW0"] = 3] = "COL1ROW0";
+  INDICES3[INDICES3["COL1ROW1"] = 4] = "COL1ROW1";
+  INDICES3[INDICES3["COL1ROW2"] = 5] = "COL1ROW2";
+  INDICES3[INDICES3["COL2ROW0"] = 6] = "COL2ROW0";
+  INDICES3[INDICES3["COL2ROW1"] = 7] = "COL2ROW1";
+  INDICES3[INDICES3["COL2ROW2"] = 8] = "COL2ROW2";
+  return INDICES3;
+})(INDICES || {});
+var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+var Matrix3 = class extends Matrix {
+  static get IDENTITY() {
+    return getIdentityMatrix();
+  }
+  static get ZERO() {
+    return getZeroMatrix();
+  }
+  get ELEMENTS() {
+    return 9;
+  }
+  get RANK() {
+    return 3;
+  }
+  get INDICES() {
+    return INDICES;
+  }
+  constructor(array, ...args) {
+    super(-0, -0, -0, -0, -0, -0, -0, -0, -0);
+    if (arguments.length === 1 && Array.isArray(array)) {
+      this.copy(array);
+    } else if (args.length > 0) {
+      this.copy([array, ...args]);
+    } else {
+      this.identity();
+    }
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    this[3] = array[3];
+    this[4] = array[4];
+    this[5] = array[5];
+    this[6] = array[6];
+    this[7] = array[7];
+    this[8] = array[8];
+    return this.check();
+  }
+  identity() {
+    return this.copy(IDENTITY_MATRIX);
+  }
+  fromObject(object) {
+    return this.check();
+  }
+  fromQuaternion(q) {
+    mat3.fromQuat(this, q);
+    return this.check();
+  }
+  set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
+    this[0] = m00;
+    this[1] = m10;
+    this[2] = m20;
+    this[3] = m01;
+    this[4] = m11;
+    this[5] = m21;
+    this[6] = m02;
+    this[7] = m12;
+    this[8] = m22;
+    return this.check();
+  }
+  setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
+    this[0] = m00;
+    this[1] = m10;
+    this[2] = m20;
+    this[3] = m01;
+    this[4] = m11;
+    this[5] = m21;
+    this[6] = m02;
+    this[7] = m12;
+    this[8] = m22;
+    return this.check();
+  }
+  determinant() {
+    return mat3.determinant(this);
+  }
+  transpose() {
+    mat3.transpose(this, this);
+    return this.check();
+  }
+  invert() {
+    mat3.invert(this, this);
+    return this.check();
+  }
+  multiplyLeft(a) {
+    mat3.multiply(this, a, this);
+    return this.check();
+  }
+  multiplyRight(a) {
+    mat3.multiply(this, this, a);
+    return this.check();
+  }
+  rotate(radians2) {
+    mat3.rotate(this, this, radians2);
+    return this.check();
+  }
+  scale(factor) {
+    if (Array.isArray(factor)) {
+      mat3.scale(this, this, factor);
+    } else {
+      mat3.scale(this, this, [factor, factor]);
+    }
+    return this.check();
+  }
+  translate(vec) {
+    mat3.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);
+        break;
+      case 3:
+        out = vec32.transformMat3(result || [-0, -0, -0], vector, this);
+        break;
+      case 4:
+        out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
+        break;
+      default:
+        throw new Error("Illegal vector");
+    }
+    checkVector(out, vector.length);
+    return out;
+  }
+  transformVector(vector, result) {
+    return this.transform(vector, result);
+  }
+  transformVector2(vector, result) {
+    return this.transform(vector, result);
+  }
+  transformVector3(vector, result) {
+    return this.transform(vector, result);
+  }
+};
+var ZERO_MATRIX3;
+var IDENTITY_MATRIX3 = null;
+function getZeroMatrix() {
+  if (!ZERO_MATRIX3) {
+    ZERO_MATRIX3 = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    Object.freeze(ZERO_MATRIX3);
+  }
+  return ZERO_MATRIX3;
+}
+function getIdentityMatrix() {
+  if (!IDENTITY_MATRIX3) {
+    IDENTITY_MATRIX3 = new Matrix3();
+    Object.freeze(IDENTITY_MATRIX3);
+  }
+  return IDENTITY_MATRIX3;
+}
+
+// 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";
+  INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2";
+  INDICES3[INDICES3["COL0ROW3"] = 3] = "COL0ROW3";
+  INDICES3[INDICES3["COL1ROW0"] = 4] = "COL1ROW0";
+  INDICES3[INDICES3["COL1ROW1"] = 5] = "COL1ROW1";
+  INDICES3[INDICES3["COL1ROW2"] = 6] = "COL1ROW2";
+  INDICES3[INDICES3["COL1ROW3"] = 7] = "COL1ROW3";
+  INDICES3[INDICES3["COL2ROW0"] = 8] = "COL2ROW0";
+  INDICES3[INDICES3["COL2ROW1"] = 9] = "COL2ROW1";
+  INDICES3[INDICES3["COL2ROW2"] = 10] = "COL2ROW2";
+  INDICES3[INDICES3["COL2ROW3"] = 11] = "COL2ROW3";
+  INDICES3[INDICES3["COL3ROW0"] = 12] = "COL3ROW0";
+  INDICES3[INDICES3["COL3ROW1"] = 13] = "COL3ROW1";
+  INDICES3[INDICES3["COL3ROW2"] = 14] = "COL3ROW2";
+  INDICES3[INDICES3["COL3ROW3"] = 15] = "COL3ROW3";
+  return INDICES3;
+})(INDICES2 || {});
+var DEFAULT_FOVY = 45 * Math.PI / 180;
+var DEFAULT_ASPECT = 1;
+var DEFAULT_NEAR = 0.1;
+var DEFAULT_FAR = 500;
+var IDENTITY_MATRIX2 = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+var Matrix4 = class extends Matrix {
+  static get IDENTITY() {
+    return getIdentityMatrix2();
+  }
+  static get ZERO() {
+    return getZeroMatrix2();
+  }
+  get ELEMENTS() {
+    return 16;
+  }
+  get RANK() {
+    return 4;
+  }
+  get INDICES() {
+    return INDICES2;
+  }
+  constructor(array) {
+    super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);
+    if (arguments.length === 1 && Array.isArray(array)) {
+      this.copy(array);
+    } else {
+      this.identity();
+    }
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    this[3] = array[3];
+    this[4] = array[4];
+    this[5] = array[5];
+    this[6] = array[6];
+    this[7] = array[7];
+    this[8] = array[8];
+    this[9] = array[9];
+    this[10] = array[10];
+    this[11] = array[11];
+    this[12] = array[12];
+    this[13] = array[13];
+    this[14] = array[14];
+    this[15] = array[15];
+    return this.check();
+  }
+  set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
+    this[0] = m00;
+    this[1] = m10;
+    this[2] = m20;
+    this[3] = m30;
+    this[4] = m01;
+    this[5] = m11;
+    this[6] = m21;
+    this[7] = m31;
+    this[8] = m02;
+    this[9] = m12;
+    this[10] = m22;
+    this[11] = m32;
+    this[12] = m03;
+    this[13] = m13;
+    this[14] = m23;
+    this[15] = m33;
+    return this.check();
+  }
+  setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
+    this[0] = m00;
+    this[1] = m10;
+    this[2] = m20;
+    this[3] = m30;
+    this[4] = m01;
+    this[5] = m11;
+    this[6] = m21;
+    this[7] = m31;
+    this[8] = m02;
+    this[9] = m12;
+    this[10] = m22;
+    this[11] = m32;
+    this[12] = m03;
+    this[13] = m13;
+    this[14] = m23;
+    this[15] = m33;
+    return this.check();
+  }
+  toRowMajor(result) {
+    result[0] = this[0];
+    result[1] = this[4];
+    result[2] = this[8];
+    result[3] = this[12];
+    result[4] = this[1];
+    result[5] = this[5];
+    result[6] = this[9];
+    result[7] = this[13];
+    result[8] = this[2];
+    result[9] = this[6];
+    result[10] = this[10];
+    result[11] = this[14];
+    result[12] = this[3];
+    result[13] = this[7];
+    result[14] = this[11];
+    result[15] = this[15];
+    return result;
+  }
+  identity() {
+    return this.copy(IDENTITY_MATRIX2);
+  }
+  fromObject(object) {
+    return this.check();
+  }
+  fromQuaternion(quaternion) {
+    mat4.fromQuat(this, quaternion);
+    return this.check();
+  }
+  frustum(view) {
+    const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
+    if (far === Infinity) {
+      computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
+    } else {
+      mat4.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);
+    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);
+    return this.check();
+  }
+  orthographic(view) {
+    const {
+      fovy = DEFAULT_FOVY,
+      aspect = DEFAULT_ASPECT,
+      focalDistance = 1,
+      near = DEFAULT_NEAR,
+      far = DEFAULT_FAR
+    } = view;
+    checkRadians(fovy);
+    const halfY = fovy / 2;
+    const top = focalDistance * Math.tan(halfY);
+    const right = top * aspect;
+    return this.ortho({
+      left: -right,
+      right,
+      bottom: -top,
+      top,
+      near,
+      far
+    });
+  }
+  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);
+    return this.check();
+  }
+  determinant() {
+    return mat4.determinant(this);
+  }
+  getScale(result = [-0, -0, -0]) {
+    result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
+    result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
+    result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
+    return result;
+  }
+  getTranslation(result = [-0, -0, -0]) {
+    result[0] = this[12];
+    result[1] = this[13];
+    result[2] = this[14];
+    return result;
+  }
+  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];
+    result[0] = this[0] * inverseScale0;
+    result[1] = this[1] * inverseScale1;
+    result[2] = this[2] * inverseScale2;
+    result[3] = 0;
+    result[4] = this[4] * inverseScale0;
+    result[5] = this[5] * inverseScale1;
+    result[6] = this[6] * inverseScale2;
+    result[7] = 0;
+    result[8] = this[8] * inverseScale0;
+    result[9] = this[9] * inverseScale1;
+    result[10] = this[10] * inverseScale2;
+    result[11] = 0;
+    result[12] = 0;
+    result[13] = 0;
+    result[14] = 0;
+    result[15] = 1;
+    return result;
+  }
+  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];
+    result[0] = this[0] * inverseScale0;
+    result[1] = this[1] * inverseScale1;
+    result[2] = this[2] * inverseScale2;
+    result[3] = this[4] * inverseScale0;
+    result[4] = this[5] * inverseScale1;
+    result[5] = this[6] * inverseScale2;
+    result[6] = this[8] * inverseScale0;
+    result[7] = this[9] * inverseScale1;
+    result[8] = this[10] * inverseScale2;
+    return result;
+  }
+  transpose() {
+    mat4.transpose(this, this);
+    return this.check();
+  }
+  invert() {
+    mat4.invert(this, this);
+    return this.check();
+  }
+  multiplyLeft(a) {
+    mat4.multiply(this, a, this);
+    return this.check();
+  }
+  multiplyRight(a) {
+    mat4.multiply(this, this, a);
+    return this.check();
+  }
+  rotateX(radians2) {
+    mat4.rotateX(this, this, radians2);
+    return this.check();
+  }
+  rotateY(radians2) {
+    mat4.rotateY(this, this, radians2);
+    return this.check();
+  }
+  rotateZ(radians2) {
+    mat4.rotateZ(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);
+    return this.check();
+  }
+  scale(factor) {
+    mat4.scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
+    return this.check();
+  }
+  translate(vector) {
+    mat4.translate(this, this, vector);
+    return this.check();
+  }
+  transform(vector, result) {
+    if (vector.length === 4) {
+      result = vec42.transformMat4(result || [-0, -0, -0, -0], vector, this);
+      checkVector(result, 4);
+      return result;
+    }
+    return this.transformAsPoint(vector, result);
+  }
+  transformAsPoint(vector, result) {
+    const { length: length3 } = vector;
+    let out;
+    switch (length3) {
+      case 2:
+        out = vec23.transformMat4(result || [-0, -0], vector, this);
+        break;
+      case 3:
+        out = vec33.transformMat4(result || [-0, -0, -0], vector, this);
+        break;
+      default:
+        throw new Error("Illegal vector");
+    }
+    checkVector(out, vector.length);
+    return out;
+  }
+  transformAsVector(vector, result) {
+    let out;
+    switch (vector.length) {
+      case 2:
+        out = vec2_transformMat4AsVector(result || [-0, -0], vector, this);
+        break;
+      case 3:
+        out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);
+        break;
+      default:
+        throw new Error("Illegal vector");
+    }
+    checkVector(out, vector.length);
+    return out;
+  }
+  transformPoint(vector, result) {
+    return this.transformAsPoint(vector, result);
+  }
+  transformVector(vector, result) {
+    return this.transformAsPoint(vector, result);
+  }
+  transformDirection(vector, result) {
+    return this.transformAsVector(vector, result);
+  }
+  makeRotationX(radians2) {
+    return this.identity().rotateX(radians2);
+  }
+  makeTranslation(x, y, z) {
+    return this.identity().translate([x, y, z]);
+  }
+};
+var ZERO3;
+var IDENTITY;
+function getZeroMatrix2() {
+  if (!ZERO3) {
+    ZERO3 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    Object.freeze(ZERO3);
+  }
+  return ZERO3;
+}
+function getIdentityMatrix2() {
+  if (!IDENTITY) {
+    IDENTITY = new Matrix4();
+    Object.freeze(IDENTITY);
+  }
+  return IDENTITY;
+}
+function checkRadians(possiblyDegrees) {
+  if (possiblyDegrees > Math.PI * 2) {
+    throw Error("expected radians");
+  }
+}
+function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {
+  const column0Row0 = 2 * near / (right - left);
+  const column1Row1 = 2 * near / (top - bottom);
+  const column2Row0 = (right + left) / (right - left);
+  const column2Row1 = (top + bottom) / (top - bottom);
+  const column2Row2 = -1;
+  const column2Row3 = -1;
+  const column3Row2 = -2 * near;
+  result[0] = column0Row0;
+  result[1] = 0;
+  result[2] = 0;
+  result[3] = 0;
+  result[4] = 0;
+  result[5] = column1Row1;
+  result[6] = 0;
+  result[7] = 0;
+  result[8] = column2Row0;
+  result[9] = column2Row1;
+  result[10] = column2Row2;
+  result[11] = column2Row3;
+  result[12] = 0;
+  result[13] = 0;
+  result[14] = column3Row2;
+  result[15] = 0;
+  return result;
+}
+
+// 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) {
+    super(-0, -0, -0, -0);
+    if (Array.isArray(x) && arguments.length === 1) {
+      this.copy(x);
+    } else {
+      this.set(x, y, z, w);
+    }
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    this[3] = array[3];
+    return this.check();
+  }
+  set(x, y, z, w) {
+    this[0] = x;
+    this[1] = y;
+    this[2] = z;
+    this[3] = w;
+    return this.check();
+  }
+  fromObject(object) {
+    this[0] = object.x;
+    this[1] = object.y;
+    this[2] = object.z;
+    this[3] = object.w;
+    return this.check();
+  }
+  fromMatrix3(m) {
+    quat.fromMat3(this, m);
+    return this.check();
+  }
+  fromAxisRotation(axis, rad) {
+    quat.setAxisAngle(this, axis, rad);
+    return this.check();
+  }
+  identity() {
+    quat.identity(this);
+    return this.check();
+  }
+  setAxisAngle(axis, rad) {
+    return this.fromAxisRotation(axis, rad);
+  }
+  get ELEMENTS() {
+    return 4;
+  }
+  get x() {
+    return this[0];
+  }
+  set x(value) {
+    this[0] = checkNumber(value);
+  }
+  get y() {
+    return this[1];
+  }
+  set y(value) {
+    this[1] = checkNumber(value);
+  }
+  get z() {
+    return this[2];
+  }
+  set z(value) {
+    this[2] = checkNumber(value);
+  }
+  get w() {
+    return this[3];
+  }
+  set w(value) {
+    this[3] = checkNumber(value);
+  }
+  len() {
+    return quat.length(this);
+  }
+  lengthSquared() {
+    return quat.squaredLength(this);
+  }
+  dot(a) {
+    return quat.dot(this, a);
+  }
+  rotationTo(vectorA, vectorB) {
+    quat.rotationTo(this, vectorA, vectorB);
+    return this.check();
+  }
+  add(a) {
+    quat.add(this, this, a);
+    return this.check();
+  }
+  calculateW() {
+    quat.calculateW(this, this);
+    return this.check();
+  }
+  conjugate() {
+    quat.conjugate(this, this);
+    return this.check();
+  }
+  invert() {
+    quat.invert(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);
+    return this.check();
+  }
+  multiplyRight(a) {
+    quat.multiply(this, this, a);
+    return this.check();
+  }
+  multiplyLeft(a) {
+    quat.multiply(this, a, this);
+    return this.check();
+  }
+  normalize() {
+    const length3 = this.len();
+    const l = length3 > 0 ? 1 / length3 : 0;
+    this[0] = this[0] * l;
+    this[1] = this[1] * l;
+    this[2] = this[2] * l;
+    this[3] = this[3] * l;
+    if (length3 === 0) {
+      this[3] = 1;
+    }
+    return this.check();
+  }
+  rotateX(rad) {
+    quat.rotateX(this, this, rad);
+    return this.check();
+  }
+  rotateY(rad) {
+    quat.rotateY(this, this, rad);
+    return this.check();
+  }
+  rotateZ(rad) {
+    quat.rotateZ(this, this, rad);
+    return this.check();
+  }
+  scale(b) {
+    quat.scale(this, this, b);
+    return this.check();
+  }
+  slerp(arg0, arg1, arg2) {
+    let start;
+    let target;
+    let ratio;
+    switch (arguments.length) {
+      case 1:
+        ({
+          start = IDENTITY_QUATERNION,
+          target,
+          ratio
+        } = arg0);
+        break;
+      case 2:
+        start = this;
+        target = arg0;
+        ratio = arg1;
+        break;
+      default:
+        start = arg0;
+        target = arg1;
+        ratio = arg2;
+    }
+    quat.slerp(this, start, target, ratio);
+    return this.check();
+  }
+  transformVector4(vector, result = new Vector4()) {
+    vec43.transformQuat(result, vector, this);
+    return checkVector(result, 4);
+  }
+  lengthSq() {
+    return this.lengthSquared();
+  }
+  setFromAxisAngle(axis, rad) {
+    return this.setAxisAngle(axis, rad);
+  }
+  premultiply(a) {
+    return this.multiplyLeft(a);
+  }
+  multiply(a) {
+    return this.multiplyRight(a);
+  }
+};
+
+// src/classes/spherical-coordinates.ts
+var vec34 = __toESM(require("gl-matrix/vec3"), 1);
+var EPSILON = 1e-6;
+var EARTH_RADIUS_METERS = 6371e3;
+var SphericalCoordinates = class {
+  constructor({
+    phi = 0,
+    theta = 0,
+    radius = 1,
+    bearing,
+    pitch,
+    altitude,
+    radiusScale = EARTH_RADIUS_METERS
+  } = {}) {
+    this.phi = phi;
+    this.theta = theta;
+    this.radius = radius || altitude || 1;
+    this.radiusScale = radiusScale || 1;
+    if (bearing !== void 0) {
+      this.bearing = bearing;
+    }
+    if (pitch !== void 0) {
+      this.pitch = pitch;
+    }
+    this.check();
+  }
+  toString() {
+    return this.formatString(config);
+  }
+  formatString({ printTypes = false }) {
+    const f = formatValue;
+    return `${printTypes ? "Spherical" : ""}[rho:${f(this.radius)},theta:${f(this.theta)},phi:${f(this.phi)}]`;
+  }
+  equals(other) {
+    return equals(this.radius, other.radius) && equals(this.theta, other.theta) && equals(this.phi, other.phi);
+  }
+  exactEquals(other) {
+    return this.radius === other.radius && this.theta === other.theta && this.phi === other.phi;
+  }
+  get bearing() {
+    return 180 - degrees(this.phi);
+  }
+  set bearing(v) {
+    this.phi = Math.PI - radians(v);
+  }
+  get pitch() {
+    return degrees(this.theta);
+  }
+  set pitch(v) {
+    this.theta = radians(v);
+  }
+  get longitude() {
+    return degrees(this.phi);
+  }
+  get latitude() {
+    return degrees(this.theta);
+  }
+  get lng() {
+    return degrees(this.phi);
+  }
+  get lat() {
+    return degrees(this.theta);
+  }
+  get z() {
+    return (this.radius - 1) * this.radiusScale;
+  }
+  set(radius, phi, theta) {
+    this.radius = radius;
+    this.phi = phi;
+    this.theta = theta;
+    return this.check();
+  }
+  clone() {
+    return new SphericalCoordinates().copy(this);
+  }
+  copy(other) {
+    this.radius = other.radius;
+    this.phi = other.phi;
+    this.theta = other.theta;
+    return this.check();
+  }
+  fromLngLatZ([lng, lat, z]) {
+    this.radius = 1 + z / this.radiusScale;
+    this.phi = radians(lat);
+    this.theta = radians(lng);
+    return this.check();
+  }
+  fromVector3(v) {
+    this.radius = vec34.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));
+    }
+    return this.check();
+  }
+  toVector3() {
+    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));
+    return this;
+  }
+  check() {
+    if (!Number.isFinite(this.phi) || !Number.isFinite(this.theta) || !(this.radius > 0)) {
+      throw new Error("SphericalCoordinates: some fields set to invalid numbers");
+    }
+    return this;
+  }
+};
+
+// src/classes/euler.ts
+var ERR_UNKNOWN_ORDER = "Unknown Euler angle order";
+var ALMOST_ONE = 0.99999;
+var RotationOrder = /* @__PURE__ */ ((RotationOrder2) => {
+  RotationOrder2[RotationOrder2["ZYX"] = 0] = "ZYX";
+  RotationOrder2[RotationOrder2["YXZ"] = 1] = "YXZ";
+  RotationOrder2[RotationOrder2["XZY"] = 2] = "XZY";
+  RotationOrder2[RotationOrder2["ZXY"] = 3] = "ZXY";
+  RotationOrder2[RotationOrder2["YZX"] = 4] = "YZX";
+  RotationOrder2[RotationOrder2["XYZ"] = 5] = "XYZ";
+  return RotationOrder2;
+})(RotationOrder || {});
+var Euler = class extends MathArray {
+  static get ZYX() {
+    return 0 /* ZYX */;
+  }
+  static get YXZ() {
+    return 1 /* YXZ */;
+  }
+  static get XZY() {
+    return 2 /* XZY */;
+  }
+  static get ZXY() {
+    return 3 /* ZXY */;
+  }
+  static get YZX() {
+    return 4 /* YZX */;
+  }
+  static get XYZ() {
+    return 5 /* XYZ */;
+  }
+  static get RollPitchYaw() {
+    return 0 /* ZYX */;
+  }
+  static get DefaultOrder() {
+    return 0 /* ZYX */;
+  }
+  static get RotationOrders() {
+    return RotationOrder;
+  }
+  static rotationOrder(order) {
+    return RotationOrder[order];
+  }
+  get ELEMENTS() {
+    return 4;
+  }
+  constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
+    super(-0, -0, -0, -0);
+    if (arguments.length > 0 && Array.isArray(arguments[0])) {
+      this.fromVector3(...arguments);
+    } else {
+      this.set(x, y, z, order);
+    }
+  }
+  fromQuaternion(quaternion) {
+    const [x, y, z, w] = quaternion;
+    const ysqr = y * y;
+    const t0 = -2 * (ysqr + z * z) + 1;
+    const t1 = 2 * (x * y + w * z);
+    let t2 = -2 * (x * z - w * y);
+    const t3 = 2 * (y * z + w * x);
+    const t4 = -2 * (x * x + ysqr) + 1;
+    t2 = t2 > 1 ? 1 : t2;
+    t2 = t2 < -1 ? -1 : t2;
+    const roll = Math.atan2(t3, t4);
+    const pitch = Math.asin(t2);
+    const yaw = Math.atan2(t1, t0);
+    return this.set(roll, pitch, yaw, Euler.RollPitchYaw);
+  }
+  fromObject(object) {
+    throw new Error("not implemented");
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    this[3] = Number.isFinite(array[3]) || this.order;
+    return this.check();
+  }
+  set(x = 0, y = 0, z = 0, order) {
+    this[0] = x;
+    this[1] = y;
+    this[2] = z;
+    this[3] = Number.isFinite(order) ? order : this[3];
+    return this.check();
+  }
+  validate() {
+    return validateOrder(this[3]) && Number.isFinite(this[0]) && Number.isFinite(this[1]) && Number.isFinite(this[2]);
+  }
+  toArray(array = [], offset = 0) {
+    array[offset] = this[0];
+    array[offset + 1] = this[1];
+    array[offset + 2] = this[2];
+    return array;
+  }
+  toArray4(array = [], offset = 0) {
+    array[offset] = this[0];
+    array[offset + 1] = this[1];
+    array[offset + 2] = this[2];
+    array[offset + 3] = this[3];
+    return array;
+  }
+  toVector3(result = [-0, -0, -0]) {
+    result[0] = this[0];
+    result[1] = this[1];
+    result[2] = this[2];
+    return result;
+  }
+  get x() {
+    return this[0];
+  }
+  set x(value) {
+    this[0] = checkNumber(value);
+  }
+  get y() {
+    return this[1];
+  }
+  set y(value) {
+    this[1] = checkNumber(value);
+  }
+  get z() {
+    return this[2];
+  }
+  set z(value) {
+    this[2] = checkNumber(value);
+  }
+  get alpha() {
+    return this[0];
+  }
+  set alpha(value) {
+    this[0] = checkNumber(value);
+  }
+  get beta() {
+    return this[1];
+  }
+  set beta(value) {
+    this[1] = checkNumber(value);
+  }
+  get gamma() {
+    return this[2];
+  }
+  set gamma(value) {
+    this[2] = checkNumber(value);
+  }
+  get phi() {
+    return this[0];
+  }
+  set phi(value) {
+    this[0] = checkNumber(value);
+  }
+  get theta() {
+    return this[1];
+  }
+  set theta(value) {
+    this[1] = checkNumber(value);
+  }
+  get psi() {
+    return this[2];
+  }
+  set psi(value) {
+    this[2] = checkNumber(value);
+  }
+  get roll() {
+    return this[0];
+  }
+  set roll(value) {
+    this[0] = checkNumber(value);
+  }
+  get pitch() {
+    return this[1];
+  }
+  set pitch(value) {
+    this[1] = checkNumber(value);
+  }
+  get yaw() {
+    return this[2];
+  }
+  set yaw(value) {
+    this[2] = checkNumber(value);
+  }
+  get order() {
+    return this[3];
+  }
+  set order(value) {
+    this[3] = checkOrder(value);
+  }
+  fromVector3(v, order) {
+    return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);
+  }
+  fromArray(array, offset = 0) {
+    this[0] = array[0 + offset];
+    this[1] = array[1 + offset];
+    this[2] = array[2 + offset];
+    if (array[3] !== void 0) {
+      this[3] = array[3];
+    }
+    return this.check();
+  }
+  fromRollPitchYaw(roll, pitch, yaw) {
+    return this.set(roll, pitch, yaw, 0 /* ZYX */);
+  }
+  fromRotationMatrix(m, order = Euler.DefaultOrder) {
+    this._fromRotationMatrix(m, order);
+    return this.check();
+  }
+  getRotationMatrix(m) {
+    return this._getRotationMatrix(m);
+  }
+  getQuaternion() {
+    const q = new Quaternion();
+    switch (this[4]) {
+      case 5 /* XYZ */:
+        return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
+      case 1 /* YXZ */:
+        return q.rotateY(this[0]).rotateX(this[1]).rotateZ(this[2]);
+      case 3 /* ZXY */:
+        return q.rotateZ(this[0]).rotateX(this[1]).rotateY(this[2]);
+      case 0 /* ZYX */:
+        return q.rotateZ(this[0]).rotateY(this[1]).rotateX(this[2]);
+      case 4 /* YZX */:
+        return q.rotateY(this[0]).rotateZ(this[1]).rotateX(this[2]);
+      case 2 /* XZY */:
+        return q.rotateX(this[0]).rotateZ(this[1]).rotateY(this[2]);
+      default:
+        throw new Error(ERR_UNKNOWN_ORDER);
+    }
+  }
+  _fromRotationMatrix(m, order = Euler.DefaultOrder) {
+    const m11 = m[0], m12 = m[4], m13 = m[8];
+    const m21 = m[1], m22 = m[5], m23 = m[9];
+    const m31 = m[2], m32 = m[6], m33 = m[10];
+    order = order || this[3];
+    switch (order) {
+      case Euler.XYZ:
+        this[1] = Math.asin(clamp(m13, -1, 1));
+        if (Math.abs(m13) < ALMOST_ONE) {
+          this[0] = Math.atan2(-m23, m33);
+          this[2] = Math.atan2(-m12, m11);
+        } else {
+          this[0] = Math.atan2(m32, m22);
+          this[2] = 0;
+        }
+        break;
+      case Euler.YXZ:
+        this[0] = Math.asin(-clamp(m23, -1, 1));
+        if (Math.abs(m23) < ALMOST_ONE) {
+          this[1] = Math.atan2(m13, m33);
+          this[2] = Math.atan2(m21, m22);
+        } else {
+          this[1] = Math.atan2(-m31, m11);
+          this[2] = 0;
+        }
+        break;
+      case Euler.ZXY:
+        this[0] = Math.asin(clamp(m32, -1, 1));
+        if (Math.abs(m32) < ALMOST_ONE) {
+          this[1] = Math.atan2(-m31, m33);
+          this[2] = Math.atan2(-m12, m22);
+        } else {
+          this[1] = 0;
+          this[2] = Math.atan2(m21, m11);
+        }
+        break;
+      case Euler.ZYX:
+        this[1] = Math.asin(-clamp(m31, -1, 1));
+        if (Math.abs(m31) < ALMOST_ONE) {
+          this[0] = Math.atan2(m32, m33);
+          this[2] = Math.atan2(m21, m11);
+        } else {
+          this[0] = 0;
+          this[2] = Math.atan2(-m12, m22);
+        }
+        break;
+      case Euler.YZX:
+        this[2] = Math.asin(clamp(m21, -1, 1));
+        if (Math.abs(m21) < ALMOST_ONE) {
+          this[0] = Math.atan2(-m23, m22);
+          this[1] = Math.atan2(-m31, m11);
+        } else {
+          this[0] = 0;
+          this[1] = Math.atan2(m13, m33);
+        }
+        break;
+      case Euler.XZY:
+        this[2] = Math.asin(-clamp(m12, -1, 1));
+        if (Math.abs(m12) < ALMOST_ONE) {
+          this[0] = Math.atan2(m32, m22);
+          this[1] = Math.atan2(m13, m11);
+        } else {
+          this[0] = Math.atan2(-m23, m33);
+          this[1] = 0;
+        }
+        break;
+      default:
+        throw new Error(ERR_UNKNOWN_ORDER);
+    }
+    this[3] = order;
+    return this;
+  }
+  _getRotationMatrix(result) {
+    const te = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+    const x = this.x, y = this.y, z = this.z;
+    const a = Math.cos(x);
+    const c = Math.cos(y);
+    const e = Math.cos(z);
+    const b = Math.sin(x);
+    const d = Math.sin(y);
+    const f = Math.sin(z);
+    switch (this[3]) {
+      case Euler.XYZ: {
+        const ae = a * e, af = a * f, be = b * e, bf = b * f;
+        te[0] = c * e;
+        te[4] = -c * f;
+        te[8] = d;
+        te[1] = af + be * d;
+        te[5] = ae - bf * d;
+        te[9] = -b * c;
+        te[2] = bf - ae * d;
+        te[6] = be + af * d;
+        te[10] = a * c;
+        break;
+      }
+      case Euler.YXZ: {
+        const ce = c * e, cf = c * f, de = d * e, df = d * f;
+        te[0] = ce + df * b;
+        te[4] = de * b - cf;
+        te[8] = a * d;
+        te[1] = a * f;
+        te[5] = a * e;
+        te[9] = -b;
+        te[2] = cf * b - de;
+        te[6] = df + ce * b;
+        te[10] = a * c;
+        break;
+      }
+      case Euler.ZXY: {
+        const ce = c * e, cf = c * f, de = d * e, df = d * f;
+        te[0] = ce - df * b;
+        te[4] = -a * f;
+        te[8] = de + cf * b;
+        te[1] = cf + de * b;
+        te[5] = a * e;
+        te[9] = df - ce * b;
+        te[2] = -a * d;
+        te[6] = b;
+        te[10] = a * c;
+        break;
+      }
+      case Euler.ZYX: {
+        const ae = a * e, af = a * f, be = b * e, bf = b * f;
+        te[0] = c * e;
+        te[4] = be * d - af;
+        te[8] = ae * d + bf;
+        te[1] = c * f;
+        te[5] = bf * d + ae;
+        te[9] = af * d - be;
+        te[2] = -d;
+        te[6] = b * c;
+        te[10] = a * c;
+        break;
+      }
+      case Euler.YZX: {
+        const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+        te[0] = c * e;
+        te[4] = bd - ac * f;
+        te[8] = bc * f + ad;
+        te[1] = f;
+        te[5] = a * e;
+        te[9] = -b * e;
+        te[2] = -d * e;
+        te[6] = ad * f + bc;
+        te[10] = ac - bd * f;
+        break;
+      }
+      case Euler.XZY: {
+        const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+        te[0] = c * e;
+        te[4] = -f;
+        te[8] = d * e;
+        te[1] = ac * f + bd;
+        te[5] = a * e;
+        te[9] = ad * f - bc;
+        te[2] = bc * f - ad;
+        te[6] = b * e;
+        te[10] = bd * f + ac;
+        break;
+      }
+      default:
+        throw new Error(ERR_UNKNOWN_ORDER);
+    }
+    te[3] = 0;
+    te[7] = 0;
+    te[11] = 0;
+    te[12] = 0;
+    te[13] = 0;
+    te[14] = 0;
+    te[15] = 1;
+    return te;
+  }
+  toQuaternion() {
+    const cy = Math.cos(this.yaw * 0.5);
+    const sy = Math.sin(this.yaw * 0.5);
+    const cr = Math.cos(this.roll * 0.5);
+    const sr = Math.sin(this.roll * 0.5);
+    const cp = Math.cos(this.pitch * 0.5);
+    const sp = Math.sin(this.pitch * 0.5);
+    const w = cy * cr * cp + sy * sr * sp;
+    const x = cy * sr * cp - sy * cr * sp;
+    const y = cy * cr * sp + sy * sr * cp;
+    const z = sy * cr * cp - cy * sr * sp;
+    return new Quaternion(x, y, z, w);
+  }
+};
+function validateOrder(value) {
+  return value >= 0 && value < 6;
+}
+function checkOrder(value) {
+  if (value < 0 && value >= 6) {
+    throw new Error(ERR_UNKNOWN_ORDER);
+  }
+  return value;
+}
+
+// src/classes/pose.ts
+var Pose = class {
+  constructor({
+    x = 0,
+    y = 0,
+    z = 0,
+    roll = 0,
+    pitch = 0,
+    yaw = 0,
+    position,
+    orientation
+  } = {}) {
+    if (Array.isArray(position) && position.length === 3) {
+      this.position = new Vector3(position);
+    } else {
+      this.position = new Vector3(x, y, z);
+    }
+    if (Array.isArray(orientation) && orientation.length === 4) {
+      this.orientation = new Euler(orientation, orientation[3]);
+    } else {
+      this.orientation = new Euler(roll, pitch, yaw, Euler.RollPitchYaw);
+    }
+  }
+  get x() {
+    return this.position.x;
+  }
+  set x(value) {
+    this.position.x = value;
+  }
+  get y() {
+    return this.position.y;
+  }
+  set y(value) {
+    this.position.y = value;
+  }
+  get z() {
+    return this.position.z;
+  }
+  set z(value) {
+    this.position.z = value;
+  }
+  get roll() {
+    return this.orientation.roll;
+  }
+  set roll(value) {
+    this.orientation.roll = value;
+  }
+  get pitch() {
+    return this.orientation.pitch;
+  }
+  set pitch(value) {
+    this.orientation.pitch = value;
+  }
+  get yaw() {
+    return this.orientation.yaw;
+  }
+  set yaw(value) {
+    this.orientation.yaw = value;
+  }
+  getPosition() {
+    return this.position;
+  }
+  getOrientation() {
+    return this.orientation;
+  }
+  equals(pose) {
+    if (!pose) {
+      return false;
+    }
+    return this.position.equals(pose.position) && this.orientation.equals(pose.orientation);
+  }
+  exactEquals(pose) {
+    if (!pose) {
+      return false;
+    }
+    return this.position.exactEquals(pose.position) && this.orientation.exactEquals(pose.orientation);
+  }
+  getTransformationMatrix() {
+    const sr = Math.sin(this.roll);
+    const sp = Math.sin(this.pitch);
+    const sw = Math.sin(this.yaw);
+    const cr = Math.cos(this.roll);
+    const cp = Math.cos(this.pitch);
+    const cw = Math.cos(this.yaw);
+    return new Matrix4().setRowMajor(
+      cw * cp,
+      -sw * cr + cw * sp * sr,
+      sw * sr + cw * sp * cr,
+      this.x,
+      sw * cp,
+      cw * cr + sw * sp * sr,
+      -cw * sr + sw * sp * cr,
+      this.y,
+      -sp,
+      cp * sr,
+      cp * cr,
+      this.z,
+      0,
+      0,
+      0,
+      1
+    );
+  }
+  getTransformationMatrixFromPose(pose) {
+    return new Matrix4().multiplyRight(this.getTransformationMatrix()).multiplyRight(pose.getTransformationMatrix().invert());
+  }
+  getTransformationMatrixToPose(pose) {
+    return new Matrix4().multiplyRight(pose.getTransformationMatrix()).multiplyRight(this.getTransformationMatrix().invert());
+  }
+};
+
+// 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
+};