@ntf/math 1.3.0 → 1.3.1

package/dist/index.mjs

@@ -1,16 +1,19 @@
-class MathFunction {
-}
+// 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);
 }
@@ -74,15 +77,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() {
@@ -102,7 +107,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"))
@@ -114,7 +119,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";
@@ -140,17 +145,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;
@@ -170,9 +176,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;
@@ -185,22 +192,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))
@@ -231,7 +238,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))
@@ -265,10 +272,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) {
@@ -284,42 +291,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
@@ -327,36 +334,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() {
@@ -364,8 +371,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
@@ -375,11 +382,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;
@@ -391,22 +399,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))
@@ -459,10 +467,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) {
@@ -478,85 +486,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
     );
@@ -565,11 +573,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
    */
@@ -622,9 +631,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;
@@ -675,13 +685,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;
@@ -690,8 +702,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;
@@ -710,13 +722,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;
@@ -751,7 +1076,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)) {
@@ -765,12 +1090,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";
@@ -794,14 +1119,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));
@@ -810,9 +1135,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() {
@@ -859,7 +1185,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)) {
@@ -872,7 +1198,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;
@@ -883,14 +1209,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");
@@ -919,15 +1245,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;
@@ -952,7 +1279,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"))
@@ -962,7 +1289,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";
@@ -996,10 +1323,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() {
@@ -1009,12 +1336,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);
@@ -1027,9 +1354,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;
@@ -1059,8 +1387,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();
   }
@@ -1070,8 +1398,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();
   }
@@ -1081,9 +1409,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];
@@ -1147,11 +1476,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([
@@ -1186,7 +1515,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";
@@ -1246,7 +1575,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,
@@ -1259,29 +1588,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,
@@ -1292,8 +1621,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,
@@ -1353,7 +1682,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,
@@ -1385,9 +1714,10 @@ class Mat3 {
       1
     ];
   }
-}
+};
 
-class Mat4 {
+// source/matrices/mat4.ts
+var Mat4 = class _Mat4 {
   _raw;
   get m00() {
     return this._raw[0];
@@ -1493,11 +1823,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([
@@ -1546,7 +1876,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";
@@ -1675,7 +2005,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,
@@ -1695,29 +2025,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,
@@ -1736,9 +2066,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,
@@ -1884,7 +2214,7 @@ class Mat4 {
     ]);
   }
   inverse() {
-    return new Mat4([
+    return new _Mat4([
       this.m00,
       this.m10,
       this.m20,
@@ -1916,11 +2246,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;
@@ -1944,7 +2275,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;
@@ -1981,11 +2312,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;
@@ -2001,7 +2332,7 @@ class RGBAColor {
       }
       return this.cast(_hex_to_array(a));
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -2031,7 +2362,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)
@@ -2040,18 +2371,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;
@@ -2088,11 +2419,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;
@@ -2108,7 +2439,7 @@ class HSLColor {
       }
       return this.cast(_hex_to_array(a));
     }
-    return undefined;
+    return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
@@ -2143,7 +2474,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) {
@@ -2160,17 +2491,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")
@@ -2196,10 +2527,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;
@@ -2215,7 +2547,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"))
@@ -2233,7 +2565,7 @@ class Quaternion {
           ]);
       }
     }
-    return undefined;
+    return void 0;
   }
   static fromAxisAngle(axis, angle) {
     const vec = Vec3.resolve(axis);
@@ -2248,7 +2580,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,
@@ -2284,11 +2616,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,
@@ -2296,7 +2628,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;
@@ -2304,8 +2636,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,
@@ -2313,7 +2645,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;
@@ -2322,13 +2654,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,
@@ -2348,25 +2680,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,
@@ -2374,15 +2706,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,
@@ -2391,11 +2723,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);
@@ -2451,9 +2783,10 @@ class Quaternion {
       1
     ]);
   }
-}
+};
 
-class Transform {
+// source/transform.ts
+var Transform = class {
   /**
    * The position of the object
    */
@@ -2484,6 +2817,53 @@ class Transform {
   toMat4() {
     return new Mat4().translate(this.position).multiply(this.rotation.toMat4()).scale(this.scale);
   }
-}
-
-export { ATriangle, BoundingBox, Circle, DJB2_OFFSET, EPSILON, FNV1_OFFSET, FNV1_PRIME, HSLColor, LinearFunction, MAX_ANGLE_DEGREE, Mat3, Mat4, MathFunction, QuadFunction, Quaternion, RGBAColor, Rectangle, ResolveError, Size, Transform, Triangle2D, Triangle3D, Vec2, Vec3, cap_angle_degree, cap_angle_radian, castColor, check_array, check_hex, check_hex_digit, check_number, check_number_array, check_string, check_string_array, clamp, degree_to_radian, djb2, fnv1, get_hex_part, has_property, log_hypot, radian_to_degree, resolveColor, sdbm, sign_char, stringify };
+};
+export {
+  ATriangle,
+  BoundingBox,
+  Circle,
+  DJB2_OFFSET,
+  EPSILON,
+  FNV1_OFFSET,
+  FNV1_PRIME,
+  HSLColor,
+  LinearFunction,
+  MAX_ANGLE_DEGREE,
+  MD2,
+  Mat3,
+  Mat4,
+  MathFunction,
+  QuadFunction,
+  Quaternion,
+  RGBAColor,
+  Rectangle,
+  ResolveError,
+  Size,
+  Transform,
+  Triangle2D,
+  Triangle3D,
+  Vec2,
+  Vec3,
+  cap_angle_degree,
+  cap_angle_radian,
+  castColor,
+  check_array,
+  check_hex,
+  check_hex_digit,
+  check_number,
+  check_number_array,
+  check_string,
+  check_string_array,
+  clamp,
+  degree_to_radian,
+  djb2,
+  fnv1,
+  get_hex_part,
+  has_property,
+  log_hypot,
+  radian_to_degree,
+  resolveColor,
+  sdbm,
+  sign_char,
+  stringify
+};