@ntf/math 1.3.0 → 1.3.1

package/dist/{index.cjs → index.js}

@@ -1,18 +1,91 @@
-'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-class MathFunction {
-}
+// source/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ATriangle: () => ATriangle,
+  BoundingBox: () => BoundingBox,
+  Circle: () => Circle,
+  DJB2_OFFSET: () => DJB2_OFFSET,
+  EPSILON: () => EPSILON,
+  FNV1_OFFSET: () => FNV1_OFFSET,
+  FNV1_PRIME: () => FNV1_PRIME,
+  HSLColor: () => HSLColor,
+  LinearFunction: () => LinearFunction,
+  MAX_ANGLE_DEGREE: () => MAX_ANGLE_DEGREE,
+  MD2: () => MD2,
+  Mat3: () => Mat3,
+  Mat4: () => Mat4,
+  MathFunction: () => MathFunction,
+  QuadFunction: () => QuadFunction,
+  Quaternion: () => Quaternion,
+  RGBAColor: () => RGBAColor,
+  Rectangle: () => Rectangle,
+  ResolveError: () => ResolveError,
+  Size: () => Size,
+  Transform: () => Transform,
+  Triangle2D: () => Triangle2D,
+  Triangle3D: () => Triangle3D,
+  Vec2: () => Vec2,
+  Vec3: () => Vec3,
+  cap_angle_degree: () => cap_angle_degree,
+  cap_angle_radian: () => cap_angle_radian,
+  castColor: () => castColor,
+  check_array: () => check_array,
+  check_hex: () => check_hex,
+  check_hex_digit: () => check_hex_digit,
+  check_number: () => check_number,
+  check_number_array: () => check_number_array,
+  check_string: () => check_string,
+  check_string_array: () => check_string_array,
+  clamp: () => clamp,
+  degree_to_radian: () => degree_to_radian,
+  djb2: () => djb2,
+  fnv1: () => fnv1,
+  get_hex_part: () => get_hex_part,
+  has_property: () => has_property,
+  log_hypot: () => log_hypot,
+  radian_to_degree: () => radian_to_degree,
+  resolveColor: () => resolveColor,
+  sdbm: () => sdbm,
+  sign_char: () => sign_char,
+  stringify: () => stringify
+});
+module.exports = __toCommonJS(index_exports);
+
+// source/algebra/function.ts
+var MathFunction = class {
+};
 
+// source/common/sign.ts
 function sign_char(num) {
   if (num == 0)
-    return undefined;
+    return void 0;
   if (num < 0)
     return "-";
   if (num > 0)
     return "+";
-  return undefined;
+  return void 0;
 }
 
+// source/common/types.ts
 function check_number(obj) {
   return obj != null && typeof obj == "number" && !isNaN(obj) && isFinite(obj);
 }
@@ -76,15 +149,17 @@ function has_property(obj, name, type) {
   return obj != null && typeof obj == "object" && name in obj && typeof obj[name] == type;
 }
 
-class ResolveError extends Error {
+// source/common/error.ts
+var ResolveError = class extends Error {
   constructor(target, value) {
     super(`can't resolve ${value} to ${target}`);
     this.target = target;
     this.value = value;
   }
-}
+};
 
-class Size {
+// source/geometry/size.ts
+var Size = class _Size {
   width;
   height;
   get aspectRatio() {
@@ -104,7 +179,7 @@ class Size {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 2))
       return new this(a[0], a[1]);
     if (has_property(a, "width", "number") && has_property(a, "height", "number"))
@@ -116,7 +191,7 @@ class Size {
     }
     if (check_number(a))
       return new this(a, a);
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -142,17 +217,18 @@ class Size {
     };
   }
   clone() {
-    return new Size(this.width, this.height);
+    return new _Size(this.width, this.height);
   }
   equals(square) {
-    const s = Size.resolve(square);
+    const s = _Size.resolve(square);
     return this.width == s.width && this.height == s.height;
   }
   toVec2() {
     return [this.width, this.height];
   }
-}
+};
 
+// source/utils.ts
 function clamp(value, min, max) {
   if (value <= min)
     return min;
@@ -172,9 +248,10 @@ function log_hypot(a, b) {
   const _a = a / 2, _b = b / 2;
   return 0.5 * Math.log(_a * _a + _b * _b) + Math.LN2;
 }
-const EPSILON = 1e-16;
+var EPSILON = 1e-16;
 
-class Vec3 {
+// source/vectors/vec3.ts
+var Vec3 = class _Vec3 {
   x;
   y;
   z;
@@ -187,22 +264,22 @@ class Vec3 {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 3) || check_number_array(a, 4))
-      return new this(a[0], a[1], a[2], check_number(a[3]) ? a[3] : undefined);
+      return new this(a[0], a[1], a[2], check_number(a[3]) ? a[3] : void 0);
     if (has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "z", "number"))
-      return new this(a.x, a.y, a.z, has_property(a, "w", "number") ? a.w : undefined);
+      return new this(a.x, a.y, a.z, has_property(a, "w", "number") ? a.w : void 0);
     if (check_string(a)) {
       const [sxyz, sw] = a.split(";");
       if (check_string(sxyz)) {
         const parts = sxyz.split(",");
         if (check_string_array(parts, 3))
-          return new this(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]), check_string(sw) ? parseFloat(sw) : undefined);
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]), check_string(sw) ? parseFloat(sw) : void 0);
       }
     }
     if (check_number(a))
       return new this(a, a, a);
-    return undefined;
+    return void 0;
   }
   static resolveArgs(args) {
     if (check_number_array(args, 3))
@@ -233,7 +310,7 @@ class Vec3 {
     t = (-plane_d - ad) / (bd - ad);
     const lineStartToEnd = this.resolve(lineEnd).subtract(lineStart);
     const linetoIntersect = lineStartToEnd.multiply(t);
-    return Vec3.resolve(lineStart).add(linetoIntersect);
+    return _Vec3.resolve(lineStart).add(linetoIntersect);
   }
   constructor(x = 0, y = 0, z = 0, w = 1) {
     if (!check_number(x))
@@ -267,10 +344,10 @@ class Vec3 {
     return [this.x, this.y, this.w];
   }
   clone() {
-    return new Vec3(this.x, this.y, this.z, this.w);
+    return new _Vec3(this.x, this.y, this.z, this.w);
   }
   equals(vec) {
-    const a = Vec3.resolve(vec);
+    const a = _Vec3.resolve(vec);
     return this.x == a.x && this.y == a.y && this.z == a.z;
   }
   setX(x) {
@@ -286,42 +363,42 @@ class Vec3 {
     return this;
   }
   set(...args) {
-    const vec = Vec3.resolveArgs(args);
+    const vec = _Vec3.resolveArgs(args);
     return this.setX(vec.x).setY(vec.y).setZ(vec.z);
   }
   add(...args) {
-    const vec = Vec3.resolveArgs(args);
-    return new Vec3(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x + vec.x,
       this.y + vec.y,
       this.z + vec.z
     );
   }
   offset(...args) {
-    const vec = Vec3.resolveArgs(args);
+    const vec = _Vec3.resolveArgs(args);
     this.x += vec.x;
     this.y += vec.y;
     this.z += vec.z;
     return this;
   }
   subtract(...args) {
-    const vec = Vec3.resolveArgs(args);
-    return new Vec3(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x - vec.x,
       this.y - vec.y,
       this.z - vec.z
     );
   }
   multiply(scalar) {
-    return new Vec3(
+    return new _Vec3(
       this.x * scalar,
       this.y * scalar,
       this.z * scalar
     );
   }
   naiveMultiply(...args) {
-    const vec = Vec3.resolveArgs(args);
-    return new Vec3(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x * vec.x,
       this.y * vec.y,
       this.z * vec.z
@@ -329,36 +406,36 @@ class Vec3 {
   }
   divide(...args) {
     if (check_number_array(args, 1))
-      return new Vec3(
+      return new _Vec3(
         this.x / args[0],
         this.y / args[0],
         this.z / args[0]
       );
-    const vec = Vec3.resolveArgs(args);
-    return new Vec3(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x / vec.x,
       this.y / vec.y,
       this.z / vec.z
     );
   }
   dot(...args) {
-    const vec = Vec3.resolveArgs(args);
+    const vec = _Vec3.resolveArgs(args);
     return this.x * vec.x + this.y * vec.y + this.z * vec.z;
   }
   cross(...args) {
-    const vec = Vec3.resolveArgs(args);
-    return new Vec3(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.y * vec.z - this.z * vec.y,
       this.z * vec.x - this.x * vec.z,
       this.x * vec.y - this.y * vec.x
     );
   }
   distance(...args) {
-    const vec = Vec3.resolveArgs(args);
+    const vec = _Vec3.resolveArgs(args);
     return Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2) + Math.pow(vec.z - this.z, 2);
   }
   distanceSquare(...args) {
-    const vec = Vec3.resolveArgs(args);
+    const vec = _Vec3.resolveArgs(args);
     return Math.sqrt(Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2) + Math.pow(vec.z - this.z, 2));
   }
   length() {
@@ -366,8 +443,8 @@ class Vec3 {
   }
   normalize() {
     const length = this.length();
-    if (length == 0) return new Vec3();
-    return new Vec3(
+    if (length == 0) return new _Vec3();
+    return new _Vec3(
       this.x / length,
       this.y / length,
       this.z / length
@@ -377,11 +454,12 @@ class Vec3 {
     return this.multiply(-1);
   }
   round() {
-    return new Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z), Math.round(this.w));
+    return new _Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z), Math.round(this.w));
   }
-}
+};
 
-class Vec2 {
+// source/vectors/vec2.ts
+var Vec2 = class _Vec2 {
   x;
   y;
   w;
@@ -393,22 +471,22 @@ class Vec2 {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 2) || check_number_array(a, 3))
-      return new this(a[0], a[1], check_number(a[2]) ? a[2] : undefined);
+      return new this(a[0], a[1], check_number(a[2]) ? a[2] : void 0);
     if (has_property(a, "x", "number") && has_property(a, "y", "number"))
-      return new this(a.x, a.y, has_property(a, "w", "number") ? a.w : undefined);
+      return new this(a.x, a.y, has_property(a, "w", "number") ? a.w : void 0);
     if (check_string(a)) {
       const [sxy, sw] = a.split(";");
       if (check_string(sxy)) {
         const parts = sxy.split(",");
         if (check_string_array(parts, 2))
-          return new this(parseFloat(parts[0]), parseFloat(parts[1]), check_string(sw) ? parseFloat(sw) : undefined);
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), check_string(sw) ? parseFloat(sw) : void 0);
       }
     }
     if (check_number(a))
       return new this(a, a);
-    return undefined;
+    return void 0;
   }
   static resolveArgs(args) {
     if (check_number_array(args, 2))
@@ -461,10 +539,10 @@ class Vec2 {
     return new Vec3(this.x, this.y, z, this.w);
   }
   clone() {
-    return new Vec2(this.x, this.y, this.w);
+    return new _Vec2(this.x, this.y, this.w);
   }
   equals(vec) {
-    const a = Vec2.resolve(vec);
+    const a = _Vec2.resolve(vec);
     return this.x == a.x && this.y == a.y;
   }
   setX(x) {
@@ -480,85 +558,85 @@ class Vec2 {
     return this;
   }
   set(...args) {
-    const vec = Vec2.resolveArgs(args);
+    const vec = _Vec2.resolveArgs(args);
     return this.setX(vec.x).setY(vec.y);
   }
   add(...args) {
-    const vec = Vec2.resolveArgs(args);
-    return new Vec2(
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x + vec.x,
       this.y + vec.y
     );
   }
   offset(...args) {
-    const vec = Vec2.resolveArgs(args);
+    const vec = _Vec2.resolveArgs(args);
     this.x += vec.x;
     this.y += vec.y;
     return this;
   }
   subtract(...args) {
-    const vec = Vec2.resolveArgs(args);
-    return new Vec2(
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x - vec.x,
       this.y - vec.y
     );
   }
   multiply(scalar) {
-    return new Vec2(
+    return new _Vec2(
       this.x * scalar,
       this.y * scalar
     );
   }
   naiveMultiply(...args) {
-    const vec = Vec2.resolveArgs(args);
-    return new Vec2(
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x * vec.x,
       this.y * vec.y
     );
   }
   divide(...args) {
     if (check_number_array(args, 1))
-      return new Vec2(
+      return new _Vec2(
         this.x / args[0],
         this.y / args[0]
       );
-    const vec = Vec2.resolveArgs(args);
-    return new Vec2(
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x / vec.x,
       this.y / vec.y
     );
   }
   dot(...args) {
-    const vec = Vec2.resolveArgs(args);
+    const vec = _Vec2.resolveArgs(args);
     return this.x * vec.x + this.y * vec.y;
   }
   distance(...args) {
-    const vec = Vec2.resolveArgs(args);
+    const vec = _Vec2.resolveArgs(args);
     return Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2);
   }
   distanceSquare(...args) {
-    const vec = Vec2.resolveArgs(args);
+    const vec = _Vec2.resolveArgs(args);
     return Math.sqrt(Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2));
   }
   length() {
     return Math.sqrt(this.x * this.x + this.y * this.y);
   }
   cartesianify() {
-    return new Vec2(
+    return new _Vec2(
       this.x * Math.cos(this.y),
       this.x * Math.sin(this.y)
     );
   }
   polarify() {
-    return new Vec2(
+    return new _Vec2(
       Math.sqrt(this.x * this.x + this.y * this.y),
       Math.atan(this.y / this.x)
     );
   }
   normalize() {
     const length = this.length();
-    if (length == 0) return new Vec2();
-    return new Vec2(
+    if (length == 0) return new _Vec2();
+    return new _Vec2(
       this.x / length,
       this.y / length
     );
@@ -567,11 +645,12 @@ class Vec2 {
     return this.multiply(-1);
   }
   round() {
-    return new Vec2(Math.round(this.x), Math.round(this.y), Math.round(this.w));
+    return new _Vec2(Math.round(this.x), Math.round(this.y), Math.round(this.w));
   }
-}
+};
 
-class LinearFunction extends MathFunction {
+// source/algebra/linear.ts
+var LinearFunction = class extends MathFunction {
   /**
    * The factor of the linear function
    */
@@ -624,9 +703,10 @@ class LinearFunction extends MathFunction {
       return `f(x) = ${this.m} * x ${bsign} ${Math.abs(this.b)}`;
     return `f(x) = ${this.m} * x`;
   }
-}
+};
 
-class QuadFunction extends MathFunction {
+// source/algebra/quad.ts
+var QuadFunction = class extends MathFunction {
   a;
   b;
   c;
@@ -677,13 +757,15 @@ class QuadFunction extends MathFunction {
       }
     }
   }
-}
+};
 
+// source/common/string.ts
 function stringify(value) {
   return value != null && typeof value == "object" && "toString" in value && typeof value.toString == "function" ? value.toString() : String(value);
 }
 
-const DJB2_OFFSET = 5381n;
+// source/crypto/hash.ts
+var DJB2_OFFSET = 5381n;
 function djb2(value) {
   const string = stringify(value);
   let hash = DJB2_OFFSET;
@@ -692,8 +774,8 @@ function djb2(value) {
   }
   return hash;
 }
-const FNV1_OFFSET = 14695981039346656037n;
-const FNV1_PRIME = 1099511628211n;
+var FNV1_OFFSET = 14695981039346656037n;
+var FNV1_PRIME = 1099511628211n;
 function fnv1(value) {
   const string = stringify(value);
   let hash = FNV1_OFFSET;
@@ -712,13 +794,326 @@ function sdbm(value) {
   return hash;
 }
 
-const MAX_ANGLE_DEGREE = 360;
-const cap_angle_degree = (angle) => angle % MAX_ANGLE_DEGREE;
-const cap_angle_radian = (angle) => cap_angle_degree(degree_to_radian(angle));
-const radian_to_degree = (angle) => angle * (180 / Math.PI);
-const degree_to_radian = (angle) => angle * (Math.PI / 180);
+// source/crypto/md2.ts
+var STABLE = [
+  41,
+  46,
+  67,
+  201,
+  162,
+  216,
+  124,
+  1,
+  61,
+  54,
+  84,
+  161,
+  236,
+  240,
+  6,
+  19,
+  98,
+  167,
+  5,
+  243,
+  192,
+  199,
+  115,
+  140,
+  152,
+  147,
+  43,
+  217,
+  188,
+  76,
+  130,
+  202,
+  30,
+  155,
+  87,
+  60,
+  253,
+  212,
+  224,
+  22,
+  103,
+  66,
+  111,
+  24,
+  138,
+  23,
+  229,
+  18,
+  190,
+  78,
+  196,
+  214,
+  218,
+  158,
+  222,
+  73,
+  160,
+  251,
+  245,
+  142,
+  187,
+  47,
+  238,
+  122,
+  169,
+  104,
+  121,
+  145,
+  21,
+  178,
+  7,
+  63,
+  148,
+  194,
+  16,
+  137,
+  11,
+  34,
+  95,
+  33,
+  128,
+  127,
+  93,
+  154,
+  90,
+  144,
+  50,
+  39,
+  53,
+  62,
+  204,
+  231,
+  191,
+  247,
+  151,
+  3,
+  255,
+  25,
+  48,
+  179,
+  72,
+  165,
+  181,
+  209,
+  215,
+  94,
+  146,
+  42,
+  172,
+  86,
+  170,
+  198,
+  79,
+  184,
+  56,
+  210,
+  150,
+  164,
+  125,
+  182,
+  118,
+  252,
+  107,
+  226,
+  156,
+  116,
+  4,
+  241,
+  69,
+  157,
+  112,
+  89,
+  100,
+  113,
+  135,
+  32,
+  134,
+  91,
+  207,
+  101,
+  230,
+  45,
+  168,
+  2,
+  27,
+  96,
+  37,
+  173,
+  174,
+  176,
+  185,
+  246,
+  28,
+  70,
+  97,
+  105,
+  52,
+  64,
+  126,
+  15,
+  85,
+  71,
+  163,
+  35,
+  221,
+  81,
+  175,
+  58,
+  195,
+  92,
+  249,
+  206,
+  186,
+  197,
+  234,
+  38,
+  44,
+  83,
+  13,
+  110,
+  133,
+  40,
+  132,
+  9,
+  211,
+  223,
+  205,
+  244,
+  65,
+  129,
+  77,
+  82,
+  106,
+  220,
+  55,
+  200,
+  108,
+  193,
+  171,
+  250,
+  36,
+  225,
+  123,
+  8,
+  12,
+  189,
+  177,
+  74,
+  120,
+  136,
+  149,
+  139,
+  227,
+  99,
+  232,
+  109,
+  233,
+  203,
+  213,
+  254,
+  59,
+  0,
+  29,
+  57,
+  242,
+  239,
+  183,
+  14,
+  102,
+  88,
+  208,
+  228,
+  166,
+  119,
+  114,
+  248,
+  235,
+  117,
+  75,
+  10,
+  49,
+  68,
+  80,
+  180,
+  143,
+  237,
+  31,
+  26,
+  219,
+  153,
+  141,
+  51,
+  159,
+  17,
+  131,
+  20
+];
+var MD2 = class _MD2 {
+  static BLOCK_SIZE = 16;
+  _data = new Uint8Array(16);
+  _state = new Uint8Array(48);
+  _checksum = new Uint8Array(16);
+  _length = 0;
+  constructor() {
+    for (let i = 0; i < this._state.length; i++)
+      this._state[i] = 0;
+    for (let i = 0; i < this._checksum.length; i++)
+      this._checksum[i] = 0;
+  }
+  update(input) {
+    for (let i = 0; i < input.length; i++) {
+      this._data[this._length] = input[i];
+      this._length++;
+      if (this._length == _MD2.BLOCK_SIZE) {
+        this._transform(input);
+        this._length = 0;
+      }
+    }
+    return this;
+  }
+  _transform(data) {
+    for (let i = 0; i < 16; ++i) {
+      this._state[i + 16] = this._data[i];
+      this._state[i + 32] = this._state[i + 16] ^ this._state[i];
+    }
+    let t = 0;
+    for (let i = 0; i < 18; ++i) {
+      for (let j = 0; j < 48; ++j) {
+        this._state[j] ^= STABLE[t];
+        t = this._state[j];
+      }
+      t = t + i & 255;
+    }
+    t = this._checksum[15];
+    for (let i = 0; i < 16; ++i) {
+      this._checksum[i] ^= STABLE[this._data[i] ^ t];
+      t = this._checksum[i];
+    }
+  }
+  digest() {
+    const toPad = _MD2.BLOCK_SIZE - this._length;
+    while (this._length < _MD2.BLOCK_SIZE)
+      this._data[this._length++] = toPad;
+    this._transform(this._data);
+    this._transform(this._checksum);
+    return this._state.slice();
+  }
+};
+
+// source/geometry/angle.ts
+var MAX_ANGLE_DEGREE = 360;
+var cap_angle_degree = (angle) => angle % MAX_ANGLE_DEGREE;
+var cap_angle_radian = (angle) => cap_angle_degree(degree_to_radian(angle));
+var radian_to_degree = (angle) => angle * (180 / Math.PI);
+var degree_to_radian = (angle) => angle * (Math.PI / 180);
 
-class Circle {
+// source/geometry/circle.ts
+var Circle = class _Circle {
   radius;
   get perimeter() {
     return this.radius * Math.PI * 2;
@@ -753,7 +1148,7 @@ class Circle {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 3))
       return new this([a[0], a[1]], a[2]);
     if (check_number_array(a, 4)) {
@@ -767,12 +1162,12 @@ class Circle {
       const [spos, sradius] = a.split("|");
       const pos = Vec2.cast(spos);
       if (typeof pos == "undefined")
-        return undefined;
+        return void 0;
       const radius = parseFloat(sradius);
       if (!isNaN(radius))
         return new this(pos, radius);
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -796,14 +1191,14 @@ class Circle {
     return `${this.position.toString()}|${this.radius}`;
   }
   clone() {
-    return new Circle(this.position.clone(), this.radius);
+    return new _Circle(this.position.clone(), this.radius);
   }
   equals(circle) {
-    const c = Circle.resolve(circle);
+    const c = _Circle.resolve(circle);
     return c.position.equals(c.position) && this.radius == c.radius;
   }
   inside(a) {
-    const circle = Circle.resolve(a);
+    const circle = _Circle.resolve(a);
     const distX = circle.x - this.x;
     const distY = circle.y - this.y;
     const dist = Math.sqrt(distX * distX + (distY + distY));
@@ -812,9 +1207,10 @@ class Circle {
   insidePoint(a) {
     return this.position.distance(a) <= this.radius;
   }
-}
+};
 
-class Rectangle {
+// source/geometry/rectangle.ts
+var Rectangle = class _Rectangle {
   position;
   size;
   get area() {
@@ -861,7 +1257,7 @@ class Rectangle {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 4))
       return new this(a[0], a[1], a[2], a[3]);
     if (check_number_array(a, 5)) {
@@ -874,7 +1270,7 @@ class Rectangle {
       const pos = Vec2.cast(spos);
       const size = Size.cast(ssize);
       if (typeof pos == "undefined" || typeof size == "undefined")
-        return undefined;
+        return void 0;
       const rect = new this(pos.x, pos.y, size.width, size.height);
       rect.w = pos.w;
       return rect;
@@ -885,14 +1281,14 @@ class Rectangle {
         rect.w = a.w;
       return rect;
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
   }
   constructor(a, b, c, d) {
-    const vec = Vec2.is(a) ? Vec2.resolve(a) : undefined;
-    const size = Size.is(b) ? Size.resolve(b) : undefined;
+    const vec = Vec2.is(a) ? Vec2.resolve(a) : void 0;
+    const size = Size.is(b) ? Size.resolve(b) : void 0;
     const x = typeof a == "number" ? a : vec?.x;
     if (!check_number(x))
       throw new TypeError("expected number for x position");
@@ -921,15 +1317,16 @@ class Rectangle {
     return [this.x, this.x + this.width, this.y, this.y + this.height];
   }
   clone() {
-    return new Rectangle(this.position.clone(), this.size.clone());
+    return new _Rectangle(this.position.clone(), this.size.clone());
   }
   equals(rectangle) {
-    const rect = Rectangle.resolve(rectangle);
+    const rect = _Rectangle.resolve(rectangle);
     return this.position.equals(rect.position) && this.size.equals(rect.size);
   }
-}
+};
 
-class BoundingBox {
+// source/geometry/bbox.ts
+var BoundingBox = class _BoundingBox {
   left;
   right;
   top;
@@ -954,7 +1351,7 @@ class BoundingBox {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 4))
       return new this(a[0], a[1], a[2], a[3]);
     if (has_property(a, "left", "number") && has_property(a, "right", "number") && has_property(a, "top", "number") && has_property(a, "bottom", "number"))
@@ -964,7 +1361,7 @@ class BoundingBox {
       if (check_string_array(parts, 4))
         return this.cast(parts.map((v) => parseFloat(v)));
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -998,10 +1395,10 @@ class BoundingBox {
     };
   }
   clone() {
-    return new BoundingBox(this.left, this.right, this.top, this.bottom);
+    return new _BoundingBox(this.left, this.right, this.top, this.bottom);
   }
   equals(bbox) {
-    const b = BoundingBox.resolve(bbox);
+    const b = _BoundingBox.resolve(bbox);
     return this.left == b.left && this.right == b.right && this.top == b.top && this.bottom == b.bottom;
   }
   toSquare() {
@@ -1011,12 +1408,12 @@ class BoundingBox {
     return new Rectangle(this.left, this.top, this.width, this.height);
   }
   inside(a) {
-    const bbox = BoundingBox.resolve(a);
+    const bbox = _BoundingBox.resolve(a);
     return this.right >= bbox.left && bbox.right >= this.left && this.bottom >= bbox.top && bbox.bottom >= this.top;
   }
   insidePoint(a) {
     const point = Vec2.resolve(a);
-    return this.left <= point.x && this.right >= point.x && this.top >= point.y && this.bottom <= point.y;
+    return this.left <= point.x && this.right >= point.x && this.top <= point.y && this.bottom >= point.y;
   }
   insideCircle(a) {
     const circle = Circle.resolve(a);
@@ -1029,9 +1426,10 @@ class BoundingBox {
     diff = closest.subtract(center);
     return diff.length() < circle.radius;
   }
-}
+};
 
-class ATriangle {
+// source/geometry/triangle.ts
+var ATriangle = class {
   constructor(A, B, C) {
     this.A = A;
     this.B = B;
@@ -1061,8 +1459,8 @@ class ATriangle {
   get height() {
     return 2 * (this.area / this.base);
   }
-}
-class Triangle2D extends ATriangle {
+};
+var Triangle2D = class extends ATriangle {
   get a() {
     return Vec2.fromPoints(this.B, this.C).length();
   }
@@ -1072,8 +1470,8 @@ class Triangle2D extends ATriangle {
   get c() {
     return Vec2.fromPoints(this.A, this.B).length();
   }
-}
-class Triangle3D extends ATriangle {
+};
+var Triangle3D = class extends ATriangle {
   get a() {
     return Vec3.fromPoints(this.B, this.C).length();
   }
@@ -1083,9 +1481,10 @@ class Triangle3D extends ATriangle {
   get c() {
     return Vec3.fromPoints(this.A, this.B).length();
   }
-}
+};
 
-class Mat3 {
+// source/matrices/mat3.ts
+var Mat3 = class _Mat3 {
   _raw;
   get m00() {
     return this._raw[0];
@@ -1149,11 +1548,11 @@ class Mat3 {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 9)) {
       return new this(a);
     }
-    if (check_array(a, undefined, 3)) {
+    if (check_array(a, void 0, 3)) {
       const row0 = a[0], row1 = a[1], row2 = a[2];
       if (check_number_array(row0, 3) && check_number_array(row1, 3) && check_number_array(row2, 3))
         return new this([
@@ -1188,7 +1587,7 @@ class Mat3 {
     if (check_number(a)) {
       return new this([a, a, a, a, a, a, a, a, a]);
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -1248,7 +1647,7 @@ class Mat3 {
     return `${this.m00},${this.m01},${this.m02},${this.m10},${this.m11},${this.m12},${this.m20},${this.m21},${this.m22}`;
   }
   clone() {
-    return new Mat3([
+    return new _Mat3([
       this.m00,
       this.m01,
       this.m02,
@@ -1261,29 +1660,29 @@ class Mat3 {
     ]);
   }
   equals(mat) {
-    const m = Mat3.resolve(mat);
+    const m = _Mat3.resolve(mat);
     for (let index = 0; index < this._raw.length; index++)
       if (this._raw[index] != m._raw[index])
         return false;
     return true;
   }
   add(mat) {
-    const b = Mat3.resolve(mat);
-    const m = new Mat3();
+    const b = _Mat3.resolve(mat);
+    const m = new _Mat3();
     for (let index = 0; index < this._raw.length; index++)
       m._raw[index] = this._raw[index] + b._raw[index];
-    return this;
+    return m;
   }
   subtract(mat) {
-    const b = Mat3.resolve(mat);
-    const m = new Mat3();
+    const b = _Mat3.resolve(mat);
+    const m = new _Mat3();
     for (let index = 0; index < this._raw.length; index++)
       m._raw[index] = this._raw[index] - b._raw[index];
-    return this;
+    return m;
   }
   multiply(a) {
     if (check_number(a))
-      return new Mat3([
+      return new _Mat3([
         this.m00 * a,
         this.m01 * a,
         this.m02 * a,
@@ -1294,8 +1693,8 @@ class Mat3 {
         this.m21 * a,
         this.m22 * a
       ]);
-    const b = Mat3.resolve(a);
-    return new Mat3([
+    const b = _Mat3.resolve(a);
+    return new _Mat3([
       b.m00 * this.m00 + b.m01 * this.m10 + b.m02 * this.m20,
       b.m00 * this.m01 + b.m01 * this.m11 + b.m02 * this.m21,
       b.m00 * this.m02 + b.m01 * this.m12 + b.m02 * this.m22,
@@ -1355,7 +1754,7 @@ class Mat3 {
   }
   inverse() {
     const det = this.determinant();
-    return new Mat3([
+    return new _Mat3([
       (this.m11 * this.m22 - this.m21 * this.m12) * det,
       (this.m02 * this.m21 - this.m01 * this.m22) * det,
       (this.m01 * this.m12 - this.m02 * this.m11) * det,
@@ -1387,9 +1786,10 @@ class Mat3 {
       1
     ];
   }
-}
+};
 
-class Mat4 {
+// source/matrices/mat4.ts
+var Mat4 = class _Mat4 {
   _raw;
   get m00() {
     return this._raw[0];
@@ -1495,11 +1895,11 @@ class Mat4 {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 16)) {
       return new this(a);
     }
-    if (check_array(a, undefined, 4)) {
+    if (check_array(a, void 0, 4)) {
       const row0 = a[0], row1 = a[1], row2 = a[2], row3 = a[3];
       if (check_number_array(row0, 4) && check_number_array(row1, 4) && check_number_array(row2, 4) && check_number_array(row3, 4))
         return new this([
@@ -1548,7 +1948,7 @@ class Mat4 {
     if (check_number(a)) {
       return new this([a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a]);
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -1677,7 +2077,7 @@ class Mat4 {
     return `${this.m00},${this.m01},${this.m02},${this.m03},${this.m10},${this.m11},${this.m12},${this.m13},${this.m20},${this.m21},${this.m22},${this.m23},${this.m30},${this.m31},${this.m32},${this.m33}`;
   }
   clone() {
-    return new Mat4([
+    return new _Mat4([
       this.m00,
       this.m01,
       this.m02,
@@ -1697,29 +2097,29 @@ class Mat4 {
     ]);
   }
   equals(mat) {
-    const m = Mat4.resolve(mat);
+    const m = _Mat4.resolve(mat);
     for (let index = 0; index < this._raw.length; index++)
       if (this._raw[index] != m._raw[index])
         return false;
     return true;
   }
   add(mat) {
-    const b = Mat4.resolve(mat);
-    const m = new Mat4();
+    const b = _Mat4.resolve(mat);
+    const m = new _Mat4();
     for (let index = 0; index < this._raw.length; index++)
       m._raw[index] = this._raw[index] + b._raw[index];
     return m;
   }
   subtract(mat) {
-    const b = Mat4.resolve(mat);
-    const m = new Mat4();
+    const b = _Mat4.resolve(mat);
+    const m = new _Mat4();
     for (let index = 0; index < this._raw.length; index++)
       m._raw[index] = this._raw[index] - b._raw[index];
     return m;
   }
   multiply(a) {
     if (check_number(a)) {
-      return new Mat4([
+      return new _Mat4([
         this.m00 * a,
         this.m01 * a,
         this.m02 * a,
@@ -1738,9 +2138,9 @@ class Mat4 {
         this.m33 * a
       ]);
     }
-    if (Mat4.is(a)) {
-      const b = Mat4.resolve(a);
-      return new Mat4([
+    if (_Mat4.is(a)) {
+      const b = _Mat4.resolve(a);
+      return new _Mat4([
         b.m00 * this.m00 + b.m01 * this.m10 + b.m02 * this.m20 + b.m03 * this.m30,
         b.m00 * this.m01 + b.m01 * this.m11 + b.m02 * this.m21 + b.m03 * this.m31,
         b.m00 * this.m02 + b.m01 * this.m12 + b.m02 * this.m22 + b.m03 * this.m32,
@@ -1886,7 +2286,7 @@ class Mat4 {
     ]);
   }
   inverse() {
-    return new Mat4([
+    return new _Mat4([
       this.m00,
       this.m10,
       this.m20,
@@ -1918,11 +2318,12 @@ class Mat4 {
       this.m33
     ];
   }
-}
+};
 
+// source/color.ts
 function _hex_to_array(hex) {
   if (!check_hex(hex))
-    return undefined;
+    return void 0;
   const part = get_hex_part(hex);
   const a = parseInt(part.substring(0, 2), 16) / 255;
   const b = parseInt(part.substring(2, 4), 16) / 255;
@@ -1946,7 +2347,7 @@ function _number_to_rgba(number) {
 function _fix_integer(number) {
   return number * 255 | 0;
 }
-class RGBAColor {
+var RGBAColor = class _RGBAColor {
   _red;
   get red() {
     return this._red;
@@ -1983,11 +2384,11 @@ class RGBAColor {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 3) || check_number_array(a, 4))
       return new this(a[0], a[1], a[2], a[3]);
     if (has_property(a, "red", "number") && has_property(a, "green", "number") && has_property(a, "blue", "number"))
-      return new this(a.red, a.green, a.blue, has_property(a, "alpha", "number") ? a.alpha : undefined);
+      return new this(a.red, a.green, a.blue, has_property(a, "alpha", "number") ? a.alpha : void 0);
     if (check_number(a)) {
       const hex = a.toString(16);
       const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
@@ -2003,7 +2404,7 @@ class RGBAColor {
       }
       return this.cast(_hex_to_array(a));
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -2033,7 +2434,7 @@ class RGBAColor {
     const min = Math.min(red, green, blue), max = Math.max(red, green, blue);
     const luminace = (min + max) / 2;
     if (min == max)
-      return new HSLColor(0, 0, luminace, withAlpha ? this.alpha : undefined);
+      return new HSLColor(0, 0, luminace, withAlpha ? this.alpha : void 0);
     const d = max - min;
     const saturation = luminace > 0.5 ? d / (2 - max - min) : d / (max + min);
     if (max == red)
@@ -2042,18 +2443,18 @@ class RGBAColor {
       return new HSLColor(((blue - red) / d + 2) / 6, saturation, luminace);
     if (max == blue)
       return new HSLColor(((red - green) / d + 4) / 6, saturation, luminace);
-    return new HSLColor(0, saturation, luminace, withAlpha ? this.alpha : undefined);
+    return new HSLColor(0, saturation, luminace, withAlpha ? this.alpha : void 0);
   }
   invert(withAlpha = false) {
-    return new RGBAColor(
+    return new _RGBAColor(
       1 - this.red,
       1 - this.green,
       1 - this.blue,
       withAlpha ? 1 - this.alpha : this.alpha
     );
   }
-}
-class HSLColor {
+};
+var HSLColor = class _HSLColor {
   _hue;
   get hue() {
     return this._hue;
@@ -2090,11 +2491,11 @@ class HSLColor {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 3) || check_number_array(a, 4))
       return new this(a[0], a[1], a[2], a[3]);
     if (has_property(a, "hue", "number") && has_property(a, "saturation", "number") && has_property(a, "luminace", "number"))
-      return new this(a.hue, a.saturation, a.luminace, has_property(a, "alpha", "number") ? a.alpha : undefined);
+      return new this(a.hue, a.saturation, a.luminace, has_property(a, "alpha", "number") ? a.alpha : void 0);
     if (check_number(a)) {
       const hex = a.toString(16);
       const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
@@ -2110,7 +2511,7 @@ class HSLColor {
       }
       return this.cast(_hex_to_array(a));
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -2145,7 +2546,7 @@ class HSLColor {
   }
   toRGB(withAlpha = true) {
     if (this.saturation == 0)
-      return new RGBAColor(this.luminace * 255, this.luminace * 255, this.luminace * 255, withAlpha ? this.alpha : undefined);
+      return new RGBAColor(this.luminace * 255, this.luminace * 255, this.luminace * 255, withAlpha ? this.alpha : void 0);
     const q = this.luminace < 0.5 ? this.luminace * (1 + this.saturation) : this.luminace + this.saturation - this.luminace * this.saturation;
     const p = 2 * this.luminace - q;
     function _hue_2_rgb(t) {
@@ -2162,17 +2563,17 @@ class HSLColor {
         return p + (q - p) * (2 / 3 - _t) * 6;
       return p;
     }
-    return new RGBAColor(_hue_2_rgb(this.hue + 1 / 3) * 255, _hue_2_rgb(this.hue) * 255, _hue_2_rgb(this.hue - 1 / 3) * 255, withAlpha ? this.alpha : undefined);
+    return new RGBAColor(_hue_2_rgb(this.hue + 1 / 3) * 255, _hue_2_rgb(this.hue) * 255, _hue_2_rgb(this.hue - 1 / 3) * 255, withAlpha ? this.alpha : void 0);
   }
   invert(withAlpha = false) {
-    return new HSLColor(
+    return new _HSLColor(
       1 - this.hue,
       1 - this.saturation,
       1 - this.luminace,
       withAlpha ? 1 - this.alpha : this.alpha
     );
   }
-}
+};
 function resolveColor(a, preferHSL = false) {
   const value = castColor(a, preferHSL);
   if (typeof value != "undefined")
@@ -2198,10 +2599,11 @@ function castColor(a, preferHSL = false) {
   const secondItem = results[offset + 1];
   if (secondItem)
     return secondItem;
-  return undefined;
+  return void 0;
 }
 
-class Quaternion {
+// source/quaternion.ts
+var Quaternion = class _Quaternion {
   w;
   x;
   y;
@@ -2217,7 +2619,7 @@ class Quaternion {
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
-      return undefined;
+      return void 0;
     if (check_number_array(a, 4))
       return new this(a[0], a[1], a[2], a[3]);
     if (has_property(a, "w", "number") && has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "z", "number"))
@@ -2235,7 +2637,7 @@ class Quaternion {
           ]);
       }
     }
-    return undefined;
+    return void 0;
   }
   static fromAxisAngle(axis, angle) {
     const vec = Vec3.resolve(axis);
@@ -2250,7 +2652,7 @@ class Quaternion {
     const x2 = vec.x * 0.5, y2 = vec.y * 0.5, z2 = vec.z * 0.5;
     const cx = Math.cos(x2), cy = Math.cos(y2), cz = Math.cos(z2);
     const sx = Math.sin(x2), sy = Math.sin(y2), sz = Math.sin(z2);
-    return new Quaternion(
+    return new _Quaternion(
       cx * cy * cz - sx * sy * sz,
       sx * cy * cz - sy * sz * cx,
       sy * cx * cz - sx * sz * cy,
@@ -2286,11 +2688,11 @@ class Quaternion {
     };
   }
   clone() {
-    return new Quaternion(this.w, this.x, this.y, this.z);
+    return new _Quaternion(this.w, this.x, this.y, this.z);
   }
   add(a) {
-    const quat = Quaternion.resolve(a);
-    return new Quaternion(
+    const quat = _Quaternion.resolve(a);
+    return new _Quaternion(
       this.w + quat.w,
       this.x + quat.x,
       this.y + quat.y,
@@ -2298,7 +2700,7 @@ class Quaternion {
     );
   }
   offset(a) {
-    const quat = Quaternion.resolve(a);
+    const quat = _Quaternion.resolve(a);
     this.w += quat.w;
     this.x += quat.x;
     this.y += quat.y;
@@ -2306,8 +2708,8 @@ class Quaternion {
     return this;
   }
   subtract(a) {
-    const quat = Quaternion.resolve(a);
-    return new Quaternion(
+    const quat = _Quaternion.resolve(a);
+    return new _Quaternion(
       this.w - quat.w,
       this.x - quat.x,
       this.y - quat.y,
@@ -2315,7 +2717,7 @@ class Quaternion {
     );
   }
   negative() {
-    return new Quaternion(-this.w, -this.x, -this.y, -this.z);
+    return new _Quaternion(-this.w, -this.x, -this.y, -this.z);
   }
   length(sqrt = true) {
     const value = this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
@@ -2324,13 +2726,13 @@ class Quaternion {
   normalize() {
     let length = this.length();
     if (length < EPSILON)
-      return new Quaternion();
+      return new _Quaternion();
     length = 1 / length;
-    return new Quaternion(this.w * length, this.x * length, this.y * length, this.z * length);
+    return new _Quaternion(this.w * length, this.x * length, this.y * length, this.z * length);
   }
   multiply(a) {
-    const quat = Quaternion.resolve(a);
-    return new Quaternion(
+    const quat = _Quaternion.resolve(a);
+    return new _Quaternion(
       this.w * quat.w - this.x * quat.x - this.y * quat.y - this.z * quat.z,
       this.w * quat.x + this.x * quat.w + this.y * quat.z - this.z * quat.y,
       this.w * quat.y + this.y * quat.w + this.z * quat.x - this.x * quat.z,
@@ -2350,25 +2752,25 @@ class Quaternion {
     );
   }
   scale(scalar) {
-    return new Quaternion(this.w * scalar, this.x * scalar, this.y * scalar, this.z * scalar);
+    return new _Quaternion(this.w * scalar, this.x * scalar, this.y * scalar, this.z * scalar);
   }
   dot(a) {
-    const quat = Quaternion.resolve(a);
+    const quat = _Quaternion.resolve(a);
     return this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z;
   }
   inverse() {
     let length = this.length(false);
     if (length == 0)
-      return new Quaternion();
+      return new _Quaternion();
     length = 1 / length;
-    return new Quaternion(this.w * length, -this.x * length, -this.y * length, -this.z * length);
+    return new _Quaternion(this.w * length, -this.x * length, -this.y * length, -this.z * length);
   }
   divide(a) {
-    const quat = Quaternion.resolve(a);
+    const quat = _Quaternion.resolve(a);
     let length = quat.length(false);
-    if (length == 0) return new Quaternion();
+    if (length == 0) return new _Quaternion();
     length = 1 / length;
-    return new Quaternion(
+    return new _Quaternion(
       (this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z) * length,
       (this.x * quat.w - this.w * quat.x - this.y * quat.z + this.z * quat.y) * length,
       (this.y * quat.w - this.w * quat.y - this.z * quat.x + this.x * quat.z) * length,
@@ -2376,15 +2778,15 @@ class Quaternion {
     );
   }
   conjugate() {
-    return new Quaternion(this.w, -this.x, -this.y, -this.z);
+    return new _Quaternion(this.w, -this.x, -this.y, -this.z);
   }
   exp() {
     const length = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
     const exp = Math.exp(this.w);
     const scale = exp * Math.sin(length) / length;
     if (length == 0)
-      return new Quaternion(exp);
-    return new Quaternion(
+      return new _Quaternion(exp);
+    return new _Quaternion(
       exp * Math.cos(length),
       this.x * scale,
       this.y * scale,
@@ -2393,11 +2795,11 @@ class Quaternion {
   }
   log() {
     if (this.x == 0 && this.z == 0)
-      return new Quaternion(log_hypot(this.w, this.x), Math.atan2(this.x, this.w));
+      return new _Quaternion(log_hypot(this.w, this.x), Math.atan2(this.x, this.w));
     const length = this.length(false);
     const length2 = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
     const scale = Math.atan2(length2, this.w) / length;
-    return new Quaternion(Math.log(length) * 0.5, this.x * scale, this.y * scale, this.z * scale);
+    return new _Quaternion(Math.log(length) * 0.5, this.x * scale, this.y * scale, this.z * scale);
   }
   toVector() {
     return new Vec3(this.x, this.y, this.z, this.w);
@@ -2453,9 +2855,10 @@ class Quaternion {
       1
     ]);
   }
-}
+};
 
-class Transform {
+// source/transform.ts
+var Transform = class {
   /**
    * The position of the object
    */
@@ -2486,51 +2889,4 @@ class Transform {
   toMat4() {
     return new Mat4().translate(this.position).multiply(this.rotation.toMat4()).scale(this.scale);
   }
-}
-
-exports.ATriangle = ATriangle;
-exports.BoundingBox = BoundingBox;
-exports.Circle = Circle;
-exports.DJB2_OFFSET = DJB2_OFFSET;
-exports.EPSILON = EPSILON;
-exports.FNV1_OFFSET = FNV1_OFFSET;
-exports.FNV1_PRIME = FNV1_PRIME;
-exports.HSLColor = HSLColor;
-exports.LinearFunction = LinearFunction;
-exports.MAX_ANGLE_DEGREE = MAX_ANGLE_DEGREE;
-exports.Mat3 = Mat3;
-exports.Mat4 = Mat4;
-exports.MathFunction = MathFunction;
-exports.QuadFunction = QuadFunction;
-exports.Quaternion = Quaternion;
-exports.RGBAColor = RGBAColor;
-exports.Rectangle = Rectangle;
-exports.ResolveError = ResolveError;
-exports.Size = Size;
-exports.Transform = Transform;
-exports.Triangle2D = Triangle2D;
-exports.Triangle3D = Triangle3D;
-exports.Vec2 = Vec2;
-exports.Vec3 = Vec3;
-exports.cap_angle_degree = cap_angle_degree;
-exports.cap_angle_radian = cap_angle_radian;
-exports.castColor = castColor;
-exports.check_array = check_array;
-exports.check_hex = check_hex;
-exports.check_hex_digit = check_hex_digit;
-exports.check_number = check_number;
-exports.check_number_array = check_number_array;
-exports.check_string = check_string;
-exports.check_string_array = check_string_array;
-exports.clamp = clamp;
-exports.degree_to_radian = degree_to_radian;
-exports.djb2 = djb2;
-exports.fnv1 = fnv1;
-exports.get_hex_part = get_hex_part;
-exports.has_property = has_property;
-exports.log_hypot = log_hypot;
-exports.radian_to_degree = radian_to_degree;
-exports.resolveColor = resolveColor;
-exports.sdbm = sdbm;
-exports.sign_char = sign_char;
-exports.stringify = stringify;
+};