@ntf/math 1.3.2 → 1.4.0

package/dist/index.js

@@ -20,53 +20,53 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // source/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ATriangle: () => ATriangle,
+  AnyColor: () => AnyColor,
   BoundingBox: () => BoundingBox,
   Circle: () => Circle,
   DJB2_OFFSET: () => DJB2_OFFSET,
   EPSILON: () => EPSILON,
   FNV1_OFFSET: () => FNV1_OFFSET,
   FNV1_PRIME: () => FNV1_PRIME,
-  HSLColor: () => HSLColor,
+  HSLA: () => HSLA,
   LinearFunction: () => LinearFunction,
   MAX_ANGLE_DEGREE: () => MAX_ANGLE_DEGREE,
   MD2: () => MD2,
   Mat3: () => Mat3,
   Mat4: () => Mat4,
   MathFunction: () => MathFunction,
+  NodeJSCustomInspect: () => NodeJSCustomInspect,
   QuadFunction: () => QuadFunction,
   Quaternion: () => Quaternion,
-  RGBAColor: () => RGBAColor,
+  RGBA: () => RGBA,
   Rectangle: () => Rectangle,
   ResolveError: () => ResolveError,
   Size: () => Size,
-  Transform: () => Transform,
+  Transform2D: () => Transform2D,
+  Transform3D: () => Transform3D,
+  Triangle: () => Triangle,
   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,
+  checkArray: () => checkArray,
+  checkHex: () => checkHex,
+  checkNumber: () => checkNumber,
+  checkNumberArray: () => checkNumberArray,
+  checkString: () => checkString,
+  checkStringArray: () => checkStringArray,
   clamp: () => clamp,
-  degree_to_radian: () => degree_to_radian,
+  clampAngleDegree: () => clampAngleDegree,
+  clampAngleRadian: () => clampAngleRadian,
+  degreeToRadian: () => degreeToRadian,
   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,
+  getHexValue: () => getHexValue,
+  hasProperty: () => hasProperty,
+  lerp: () => lerp,
+  logHypot: () => logHypot,
+  radianToDegree: () => radianToDegree,
   sdbm: () => sdbm,
-  sign_char: () => sign_char,
-  stringify: () => stringify
+  signCharacter: () => signCharacter
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -75,7 +75,7 @@ var MathFunction = class {
 };
 
 // source/common/sign.ts
-function sign_char(num) {
+function signCharacter(num) {
   if (num == 0)
     return void 0;
   if (num < 0)
@@ -86,35 +86,10 @@ function sign_char(num) {
 }
 
 // source/common/types.ts
-function check_number(obj) {
-  return obj != null && typeof obj == "number" && !isNaN(obj) && isFinite(obj);
+function checkNumber(value) {
+  return value !== null && typeof value == "number" && !isNaN(value) && isFinite(value);
 }
-function check_hex_digit(obj) {
-  if (!check_string(obj) || obj.length != 1)
-    return false;
-  switch (obj.toUpperCase()) {
-    default:
-      return false;
-    case "0":
-    case "1":
-    case "2":
-    case "3":
-    case "4":
-    case "5":
-    case "6":
-    case "7":
-    case "8":
-    case "9":
-    case "A":
-    case "B":
-    case "C":
-    case "D":
-    case "E":
-    case "F":
-      return true;
-  }
-}
-function get_hex_part(string) {
+function getHexValue(string) {
   let offset = 0;
   if (string.startsWith("#") || string.startsWith("$"))
     offset = 1;
@@ -122,112 +97,48 @@ function get_hex_part(string) {
     offset = 2;
   return string.substring(offset);
 }
-function check_hex(obj) {
-  if (!check_string(obj))
+function checkHex(value) {
+  if (!checkString(value))
     return false;
-  const value = get_hex_part(obj).split("").map((char) => parseInt(char.toUpperCase(), 16));
-  return check_number_array(value);
+  const hexValue = getHexValue(value).split("").map((char) => parseInt(char.toUpperCase(), 16));
+  return checkNumberArray(hexValue);
 }
-function check_string(obj) {
-  return obj != null && typeof obj == "string" && obj.length > 0;
+function checkString(value) {
+  return value !== null && typeof value == "string" && value.length > 0;
 }
-function check_array(obj, predicate, requiredLength) {
-  if (!Array.isArray(obj)) return false;
-  if (requiredLength && requiredLength != obj.length) return false;
-  for (const item of obj)
-    if (predicate && !predicate(item))
+function checkArray(value, predicate, requiredLength) {
+  if (!Array.isArray(value)) return false;
+  if (typeof requiredLength == "number" && requiredLength !== value.length) return false;
+  for (const item of value)
+    if (typeof predicate == "function" && !predicate(item))
       return false;
   return true;
 }
-function check_number_array(obj, requiredLength) {
-  return check_array(obj, check_number, requiredLength);
+function checkNumberArray(value, requiredLength) {
+  return checkArray(value, checkNumber, requiredLength);
 }
-function check_string_array(obj, requiredLength) {
-  return check_array(obj, check_string, requiredLength);
+function checkStringArray(value, requiredLength) {
+  return checkArray(value, checkString, requiredLength);
 }
-function has_property(obj, name, type) {
-  return obj != null && typeof obj == "object" && name in obj && typeof obj[name] == type;
+function hasProperty(value, propertyName, type) {
+  return value !== null && typeof value == "object" && propertyName in value && typeof value[propertyName] == type;
 }
+var NodeJSCustomInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 
 // source/common/error.ts
 var ResolveError = class extends Error {
+  /**
+   * Create a resolve exception
+   * @param target The target type name
+   * @param value A value
+   */
   constructor(target, value) {
-    super(`can't resolve ${value} to ${target}`);
+    super(`Can't resolve ${value} to ${target}`);
     this.target = target;
     this.value = value;
   }
 };
 
-// source/geometry/size.ts
-var Size = class _Size {
-  width;
-  height;
-  get aspectRatio() {
-    return this.height / this.width;
-  }
-  get area() {
-    return this.width * this.height;
-  }
-  get perimeter() {
-    return this.width + this.width + this.height + this.height;
-  }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("Square", a);
-  }
-  static cast(a) {
-    if (a == null || typeof a == "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"))
-      return new this(a.width, a.height);
-    if (check_string(a)) {
-      const parts = a.split("x").map((v) => parseFloat(v));
-      if (check_number_array(parts, 2))
-        return this.cast(parts);
-    }
-    if (check_number(a))
-      return new this(a, a);
-    return void 0;
-  }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
-  }
-  constructor(width, height) {
-    if (!check_number(width))
-      throw new TypeError("expected number for width");
-    if (!check_number(height))
-      throw new TypeError("expected number for height");
-    this.width = width;
-    this.height = height;
-  }
-  toArray() {
-    return [this.width, this.height];
-  }
-  toString() {
-    return `${this.width}x${this.height}`;
-  }
-  toJSON() {
-    return {
-      width: this.width,
-      height: this.height
-    };
-  }
-  clone() {
-    return new _Size(this.width, this.height);
-  }
-  equals(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)
@@ -236,7 +147,7 @@ function clamp(value, min, max) {
     return max;
   return value;
 }
-function log_hypot(a, b) {
+function logHypot(a, b) {
   const a_abs = Math.abs(a);
   const b_abs = Math.abs(b);
   if (a == 0)
@@ -249,41 +160,43 @@ function log_hypot(a, b) {
   return 0.5 * Math.log(_a * _a + _b * _b) + Math.LN2;
 }
 var EPSILON = 1e-16;
+var lerp = (a, b, t) => ((typeof a == "number" ? 1 : 1n) - t) * a + t * b;
 
-// source/vectors/vec3.ts
-var Vec3 = class _Vec3 {
+// source/vectors/vec2.ts
+var Vec2 = class _Vec2 {
   x;
   y;
-  z;
   w;
   static resolve(a) {
     const value = this.cast(a);
     if (typeof value != "undefined")
       return value;
-    throw new ResolveError("Vec3", a);
+    throw new ResolveError("Vec2", a);
   }
   static cast(a) {
     if (a == null || typeof a == "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] : 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 : 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) : void 0);
+    if (checkNumberArray(a, 2) || checkNumberArray(a, 3))
+      return new this(a[0], a[1], checkNumber(a[2]) ? a[2] : void 0);
+    if (hasProperty(a, "toVec2", "function"))
+      return this.cast(a.toVec2());
+    if (hasProperty(a, "x", "number") && hasProperty(a, "y", "number"))
+      return new this(a.x, a.y, hasProperty(a, "w", "number") ? a.w : void 0);
+    if (checkString(a)) {
+      const [sxy, sw] = a.split(";");
+      if (checkString(sxy)) {
+        const parts = sxy.split(",");
+        if (checkStringArray(parts, 2))
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), checkString(sw) ? parseFloat(sw) : void 0);
       }
     }
-    if (check_number(a))
-      return new this(a, a, a);
+    if (checkNumber(a))
+      return new this(a, a);
     return void 0;
   }
   static resolveArgs(args) {
-    if (check_number_array(args, 3))
-      return new this(args[0], args[1], args[2]);
+    if (checkNumberArray(args, 2))
+      return new this(args[0], args[1]);
     return this.resolve(args[0]);
   }
   static is(a) {
@@ -292,63 +205,79 @@ var Vec3 = class _Vec3 {
   static fromPoints(a, b) {
     const veca = this.resolve(a);
     const vecb = this.resolve(b);
-    return new this(vecb.x - veca.x, vecb.y - veca.y, vecb.z - veca.z);
+    return new this(vecb.x - veca.x, vecb.y - veca.y);
   }
   static clamp(value, min, max) {
     const a = this.resolve(value), b = this.resolve(min), c = this.resolve(max);
     return new this(
       clamp(a.x, b.x, c.x),
-      clamp(a.y, b.y, c.y),
-      clamp(a.z, b.z, c.z)
+      clamp(a.y, b.y, c.y)
     );
   }
-  static intersectPlane(planeP, planeN, lineStart, lineEnd, t) {
-    planeN = this.resolve(planeN).normalize();
-    const plane_d = -this.resolve(planeN).dot(planeP);
-    const ad = this.resolve(lineStart).dot(planeN);
-    const bd = this.resolve(lineEnd).dot(planeN);
-    t = (-plane_d - ad) / (bd - ad);
-    const lineStartToEnd = this.resolve(lineEnd).subtract(lineStart);
-    const linetoIntersect = lineStartToEnd.multiply(t);
-    return _Vec3.resolve(lineStart).add(linetoIntersect);
+  static get zero() {
+    return new this(0, 0);
   }
-  constructor(x = 0, y = 0, z = 0, w = 1) {
-    if (!check_number(x))
+  static get one() {
+    return new this(1, 1);
+  }
+  constructor(x, y, w = 1) {
+    if (!checkNumber(x))
       throw new TypeError("expected number for x");
-    if (!check_number(y))
+    if (!checkNumber(y))
       throw new TypeError("expected number for y");
-    if (!check_number(z))
-      throw new TypeError("expected number for z");
-    if (!check_number(w))
+    if (!checkNumber(w))
       throw new TypeError("expected number for w");
     this.x = x;
     this.y = y;
-    this.z = z;
     this.w = w;
   }
-  toArray(w = false) {
-    return w ? [this.x, this.y, this.z] : [this.x, this.y, this.z, this.w];
+  toArray(w = this.w !== 1) {
+    return w ? [this.x, this.y, this.w] : [this.x, this.y];
   }
   toJSON() {
     return {
       x: this.x,
       y: this.y,
-      z: this.z,
       w: this.w
     };
   }
-  toString(w = false) {
-    return w ? `${this.x},${this.y},${this.z}` : `${this.x},${this.y},${this.z};${this.w}`;
+  toString(w = this.w !== 1) {
+    return w ? `${this.x},${this.y};${this.w}` : `${this.x},${this.y}`;
   }
-  toVec2() {
-    return [this.x, this.y, this.w];
+  get [Symbol.toStringTag]() {
+    return "Vec2";
+  }
+  [NodeJSCustomInspect]() {
+    return `Vec2 <${this.toString()}>`;
+  }
+  toSize() {
+    return [this.x, this.y];
+  }
+  toVec3(z = 0) {
+    return [this.x, this.y, z, this.w];
+  }
+  toRGB() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.w];
+  }
+  toRGBA() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.w, 1];
+  }
+  toHSL() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.w];
+  }
+  toHSLA() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.w, 1];
   }
   clone() {
-    return new _Vec3(this.x, this.y, this.z, this.w);
+    return new _Vec2(this.x, this.y, this.w);
   }
-  equals(vec) {
-    const a = _Vec3.resolve(vec);
-    return this.x == a.x && this.y == a.y && this.z == a.z;
+  equals(...args) {
+    const a = _Vec2.resolveArgs(args);
+    return this.x == a.x && this.y == a.y;
   }
   setX(x) {
     this.x = x;
@@ -358,319 +287,125 @@ var Vec3 = class _Vec3 {
     this.y = y;
     return this;
   }
-  setZ(z) {
-    this.z = z;
+  setW(w) {
+    this.w = w;
     return this;
   }
   set(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return this.setX(vec.x).setY(vec.y).setZ(vec.z);
+    const vec = _Vec2.resolveArgs(args);
+    return this.setX(vec.x).setY(vec.y);
   }
   add(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return new _Vec3(
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x + vec.x,
-      this.y + vec.y,
-      this.z + vec.z
+      this.y + vec.y
     );
   }
   offset(...args) {
-    const vec = _Vec3.resolveArgs(args);
+    const vec = _Vec2.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 = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x - vec.x,
-      this.y - vec.y,
-      this.z - vec.z
+      this.y - vec.y
     );
   }
   multiply(scalar) {
-    return new _Vec3(
+    return new _Vec2(
       this.x * scalar,
-      this.y * scalar,
-      this.z * scalar
+      this.y * scalar
     );
   }
   naiveMultiply(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return new _Vec3(
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x * vec.x,
-      this.y * vec.y,
-      this.z * vec.z
+      this.y * vec.y
     );
   }
   divide(...args) {
-    if (check_number_array(args, 1))
-      return new _Vec3(
+    if (checkNumberArray(args, 1))
+      return new _Vec2(
         this.x / args[0],
-        this.y / args[0],
-        this.z / args[0]
+        this.y / args[0]
       );
-    const vec = _Vec3.resolveArgs(args);
-    return new _Vec3(
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
       this.x / vec.x,
-      this.y / vec.y,
-      this.z / vec.z
+      this.y / vec.y
     );
   }
   dot(...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(
-      this.y * vec.z - this.z * vec.y,
-      this.z * vec.x - this.x * vec.z,
-      this.x * vec.y - this.y * vec.x
-    );
+    const vec = _Vec2.resolveArgs(args);
+    return this.x * vec.x + this.y * vec.y;
   }
   distance(...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);
+    const vec = _Vec2.resolveArgs(args);
+    return Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2);
   }
   distanceSquare(...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));
+    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 + this.z * this.z);
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  cartesianify() {
+    return new _Vec2(
+      this.x * Math.cos(this.y),
+      this.x * Math.sin(this.y)
+    );
+  }
+  polarify() {
+    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 _Vec3();
-    return new _Vec3(
+    if (length == 0) return _Vec2.zero;
+    return new _Vec2(
       this.x / length,
       this.y / length,
-      this.z / length
+      this.w / length
     );
   }
   invert() {
     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 _Vec2(Math.round(this.x), Math.round(this.y), Math.round(this.w));
   }
 };
 
-// source/vectors/vec2.ts
-var Vec2 = class _Vec2 {
-  x;
-  y;
-  w;
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("Vec2", a);
-  }
-  static cast(a) {
-    if (a == null || typeof a == "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] : 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 : 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) : void 0);
-      }
-    }
-    if (check_number(a))
-      return new this(a, a);
-    return void 0;
-  }
-  static resolveArgs(args) {
-    if (check_number_array(args, 2))
-      return new this(args[0], args[1]);
-    return this.resolve(args[0]);
-  }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
-  }
+// source/algebra/linear.ts
+var LinearFunction = class extends MathFunction {
+  /**
+   * The factor of the linear function
+   */
+  m;
+  /**
+   * The height of the linear function
+   */
+  b;
+  /**
+   * Create a linear function from two points
+   * @param a A point
+   * @param b A point
+   * @returns A linear function from two points
+   */
   static fromPoints(a, b) {
-    const veca = this.resolve(a);
-    const vecb = this.resolve(b);
-    return new this(vecb.x - veca.x, vecb.y - veca.y);
-  }
-  static clamp(value, min, max) {
-    const a = this.resolve(value), b = this.resolve(min), c = this.resolve(max);
-    return new this(
-      clamp(a.x, b.x, c.x),
-      clamp(a.y, b.y, c.y)
-    );
-  }
-  constructor(x = 0, y = 0, w = 1) {
-    if (!check_number(x))
-      throw new TypeError("expected number for x");
-    if (!check_number(y))
-      throw new TypeError("expected number for y");
-    if (!check_number(w))
-      throw new TypeError("expected number for w");
-    this.x = x;
-    this.y = y;
-    this.w = w;
-  }
-  toArray(w = false) {
-    return w ? [this.x, this.y] : [this.x, this.y, this.w];
-  }
-  toJSON() {
-    return {
-      x: this.x,
-      y: this.y,
-      w: this.w
-    };
-  }
-  toString(w = false) {
-    return w ? `${this.x},${this.y}` : `${this.x},${this.y};${this.w}`;
-  }
-  toSquare() {
-    return new Size(this.x, this.y);
-  }
-  toVec3(z) {
-    return new Vec3(this.x, this.y, z, this.w);
-  }
-  clone() {
-    return new _Vec2(this.x, this.y, this.w);
-  }
-  equals(vec) {
-    const a = _Vec2.resolve(vec);
-    return this.x == a.x && this.y == a.y;
-  }
-  setX(x) {
-    this.x = x;
-    return this;
-  }
-  setY(y) {
-    this.y = y;
-    return this;
-  }
-  setW(w) {
-    this.w = w;
-    return this;
-  }
-  set(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return this.setX(vec.x).setY(vec.y);
-  }
-  add(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return new _Vec2(
-      this.x + vec.x,
-      this.y + vec.y
-    );
-  }
-  offset(...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(
-      this.x - vec.x,
-      this.y - vec.y
-    );
-  }
-  multiply(scalar) {
-    return new _Vec2(
-      this.x * scalar,
-      this.y * scalar
-    );
-  }
-  naiveMultiply(...args) {
-    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(
-        this.x / args[0],
-        this.y / args[0]
-      );
-    const vec = _Vec2.resolveArgs(args);
-    return new _Vec2(
-      this.x / vec.x,
-      this.y / vec.y
-    );
-  }
-  dot(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return this.x * vec.x + this.y * vec.y;
-  }
-  distance(...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);
-    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(
-      this.x * Math.cos(this.y),
-      this.x * Math.sin(this.y)
-    );
-  }
-  polarify() {
-    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(
-      this.x / length,
-      this.y / length
-    );
-  }
-  invert() {
-    return this.multiply(-1);
-  }
-  round() {
-    return new _Vec2(Math.round(this.x), Math.round(this.y), Math.round(this.w));
-  }
-};
-
-// source/algebra/linear.ts
-var LinearFunction = class extends MathFunction {
-  /**
-   * The factor of the linear function
-   */
-  m;
-  /**
-   * The height of the linear function
-   */
-  b;
-  /**
-   * Create a linear function from two points
-   * @param a A point
-   * @param b A point
-   * @returns A linear function from two points
-   */
-  static fromPoints(a, b) {
-    const veca = Vec2.resolve(a);
-    const vecb = Vec2.resolve(b);
-    const m = (vecb.y - veca.y) / (vecb.x - veca.x);
-    const h = -m * veca.x + veca.y;
-    return new this(m, h);
+    const veca = Vec2.resolve(a);
+    const vecb = Vec2.resolve(b);
+    const m = (vecb.y - veca.y) / (vecb.x - veca.x);
+    const h = -m * veca.x + veca.y;
+    return new this(m, h);
   }
   /**
    * Create a linear function with a factor and height
@@ -679,30 +414,36 @@ var LinearFunction = class extends MathFunction {
    */
   constructor(m, b) {
     super();
-    if (!check_number(m))
+    if (!checkNumber(m))
       throw new TypeError("expected number for m");
-    if (!check_number(b))
+    if (!checkNumber(b))
       throw new TypeError("expected number for b");
     this.m = m;
     this.b = b;
   }
   get(x) {
-    if (!check_number(x))
+    if (!checkNumber(x))
       throw new TypeError("expected number for x");
     return this.m;
   }
   roots() {
     const x = -this.b / this.m;
     if (!isNaN(x))
-      return [new Vec2(x)];
+      return [new Vec2(x, 0)];
     return [];
   }
   toString() {
-    const bsign = sign_char(this.b);
+    const bsign = signCharacter(this.b);
     if (bsign)
       return `f(x) = ${this.m} * x ${bsign} ${Math.abs(this.b)}`;
     return `f(x) = ${this.m} * x`;
   }
+  get [Symbol.toStringTag]() {
+    return "LinearFunction";
+  }
+  [NodeJSCustomInspect]() {
+    return `LinearFunction <${this.toString()}>`;
+  }
 };
 
 // source/algebra/quad.ts
@@ -715,20 +456,20 @@ var QuadFunction = class extends MathFunction {
   }
   constructor(a, b, c) {
     super();
-    if (!check_number(a))
+    if (!checkNumber(a))
       throw new TypeError("expected number for a");
     if (a == 0)
       throw new TypeError("a cannot be 0");
-    if (!check_number(b))
+    if (!checkNumber(b))
       throw new TypeError("expected number for b");
-    if (!check_number(c))
+    if (!checkNumber(c))
       throw new TypeError("expected number for c");
     this.a = a;
     this.b = b;
     this.c = c;
   }
   get(x) {
-    if (!check_number(x))
+    if (!checkNumber(x))
       throw new TypeError("expected number for x");
     return this.a * x * x + this.b * x + this.c;
   }
@@ -738,17 +479,17 @@ var QuadFunction = class extends MathFunction {
     const n0 = (-this.b + Math.sqrt(discriminant)) / (2 * this.a);
     const n1 = (-this.b + Math.sqrt(discriminant)) / (2 * this.a);
     if (!isNaN(n0))
-      roots.push(new Vec2(n0));
+      roots.push(new Vec2(n0, 0));
     if (!isNaN(n1) && n0 != n1)
-      roots.push(new Vec2(n1));
+      roots.push(new Vec2(n1, 0));
     return roots;
   }
   toString(type = "standard") {
     switch (type) {
       default:
       case "standard": {
-        const bsign = sign_char(this.b);
-        const csign = sign_char(this.c);
+        const bsign = signCharacter(this.b);
+        const csign = signCharacter(this.c);
         if (bsign && csign)
           return `f(x) = ${this.a}x^2 ${bsign} ${Math.abs(this.b)}x ${csign} ${Math.abs(this.c)}`;
         if (bsign)
@@ -757,17 +498,18 @@ var QuadFunction = class extends MathFunction {
       }
     }
   }
+  get [Symbol.toStringTag]() {
+    return "QuadFunction";
+  }
+  [NodeJSCustomInspect]() {
+    return `QuadFunction <${this.toString()}>`;
+  }
 };
 
-// source/common/string.ts
-function stringify(value) {
-  return value != null && typeof value == "object" && "toString" in value && typeof value.toString == "function" ? value.toString() : String(value);
-}
-
 // source/crypto/hash.ts
 var DJB2_OFFSET = 5381n;
 function djb2(value) {
-  const string = stringify(value);
+  const string = String(value);
   let hash = DJB2_OFFSET;
   for (let i = 0; i < string.length; i++) {
     hash = (hash << 5n) + hash + BigInt(string.charCodeAt(i));
@@ -777,7 +519,7 @@ function djb2(value) {
 var FNV1_OFFSET = 14695981039346656037n;
 var FNV1_PRIME = 1099511628211n;
 function fnv1(value) {
-  const string = stringify(value);
+  const string = String(value);
   let hash = FNV1_OFFSET;
   for (let i = 0; i < string.length; i++) {
     hash *= FNV1_PRIME;
@@ -786,7 +528,7 @@ function fnv1(value) {
   return hash;
 }
 function sdbm(value) {
-  const string = stringify(value);
+  const string = String(value);
   let hash = 0n;
   for (let i = 0; i < string.length; i++) {
     hash = BigInt(string.charCodeAt(i)) + (hash << 6n) + (hash << 16n) - hash;
@@ -1103,14 +845,23 @@ var MD2 = class _MD2 {
     this._transform(this._checksum);
     return this._state.slice();
   }
+  toString() {
+    return "";
+  }
+  get [Symbol.toStringTag]() {
+    return "MD2";
+  }
+  [NodeJSCustomInspect]() {
+    return `MD2 <${this.toString()}>`;
+  }
 };
 
 // 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);
+var clampAngleDegree = (angle) => angle % MAX_ANGLE_DEGREE;
+var clampAngleRadian = (angle) => clampAngleDegree(degreeToRadian(angle));
+var radianToDegree = (angle) => angle * (180 / Math.PI);
+var degreeToRadian = (angle) => angle * (Math.PI / 180);
 
 // source/geometry/circle.ts
 var Circle = class _Circle {
@@ -1146,19 +897,28 @@ var Circle = class _Circle {
       return value;
     throw new ResolveError("Circle", a);
   }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 3))
+      return new this([args[0], args[1]], args[2]);
+    if (args.length === 2)
+      return new this(args[0], args[1]);
+    return this.resolve(args[0]);
+  }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (check_number_array(a, 3))
+    if (checkNumberArray(a, 3))
       return new this([a[0], a[1]], a[2]);
-    if (check_number_array(a, 4)) {
+    if (checkNumberArray(a, 4)) {
       const c = new this([a[0], a[1]], a[3]);
       c.w = a[2];
       return c;
     }
-    if (has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "radius", "number"))
-      return new this(has_property(a, "w", "number") ? [a.x, a.y, a.w] : [a.x, a.y], a.radius);
-    if (check_string(a)) {
+    if (hasProperty(a, "toCircle", "function"))
+      return this.cast(a.toCircle());
+    if (hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "radius", "number"))
+      return new this(hasProperty(a, "w", "number") ? [a.x, a.y, a.w] : [a.x, a.y], a.radius);
+    if (checkString(a)) {
       const [spos, sradius] = a.split("|");
       const pos = Vec2.cast(spos);
       if (typeof pos == "undefined")
@@ -1174,7 +934,7 @@ var Circle = class _Circle {
   }
   constructor(position, radius) {
     this.position = Vec2.resolve(position);
-    if (!check_number(radius))
+    if (!checkNumber(radius))
       throw new TypeError("expected number for radius");
     this.radius = radius;
   }
@@ -1190,22 +950,246 @@ var Circle = class _Circle {
   toString() {
     return `${this.position.toString()}|${this.radius}`;
   }
+  get [Symbol.toStringTag]() {
+    return "Circle";
+  }
+  [NodeJSCustomInspect]() {
+    return `Circle <${this.toString()}>`;
+  }
   clone() {
     return new _Circle(this.position.clone(), this.radius);
   }
-  equals(circle) {
-    const c = _Circle.resolve(circle);
+  toVec2() {
+    return [this.x, this.y, this.w];
+  }
+  equals(...args) {
+    const c = _Circle.resolveArgs(args);
     return c.position.equals(c.position) && this.radius == c.radius;
   }
-  inside(a) {
-    const circle = _Circle.resolve(a);
+  inside(...args) {
+    const circle = _Circle.resolveArgs(args);
     const distX = circle.x - this.x;
     const distY = circle.y - this.y;
     const dist = Math.sqrt(distX * distX + (distY + distY));
     return dist <= this.radius + circle.radius;
   }
-  insidePoint(a) {
-    return this.position.distance(a) <= this.radius;
+  insidePoint(...args) {
+    return this.position.distance(Vec2.resolveArgs(args)) <= this.radius;
+  }
+};
+
+// source/geometry/bbox.ts
+var BoundingBox = class _BoundingBox {
+  left;
+  right;
+  top;
+  bottom;
+  get width() {
+    return this.right - this.left;
+  }
+  set width(val) {
+    this.right = this.left + val;
+  }
+  get height() {
+    return this.bottom - this.top;
+  }
+  set height(val) {
+    this.bottom = this.top + val;
+  }
+  get x() {
+    return this.left;
+  }
+  set x(x) {
+    this.left = x;
+  }
+  get y() {
+    return this.top;
+  }
+  set y(y) {
+    this.top = y;
+  }
+  w = 1;
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("BoundingBox", a);
+  }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 4))
+      return new this(args[0], args[1], args[2], args[3]);
+    return this.resolve(args[0]);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (checkNumberArray(a, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if (hasProperty(a, "toBoundingBox", "function"))
+      return this.cast(a.toBoundingBox());
+    if (hasProperty(a, "left", "number") && hasProperty(a, "right", "number") && hasProperty(a, "top", "number") && hasProperty(a, "bottom", "number"))
+      return new this(a.left, a.right, a.top, a.bottom);
+    if (checkString(a)) {
+      const parts = a.split(",");
+      if (checkStringArray(parts, 4))
+        return this.cast(parts.map((v) => parseFloat(v)));
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(left, right, top, bottom) {
+    if (!checkNumber(left))
+      throw new TypeError("expected number for left");
+    if (!checkNumber(right))
+      throw new TypeError("expected number for right");
+    if (!checkNumber(top))
+      throw new TypeError("expected number for top");
+    if (!checkNumber(bottom))
+      throw new TypeError("expected number for bottom");
+    this.left = left;
+    this.right = right;
+    this.top = top;
+    this.bottom = bottom;
+  }
+  toArray() {
+    return [this.left, this.right, this.top, this.bottom];
+  }
+  toString() {
+    return `${this.left},${this.right},${this.top},${this.bottom}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "BoundingBox";
+  }
+  [NodeJSCustomInspect]() {
+    return `BoundingBox <${this.toString()}>`;
+  }
+  toJSON() {
+    return {
+      left: this.left,
+      top: this.top,
+      right: this.right,
+      bottom: this.bottom
+    };
+  }
+  clone() {
+    return new _BoundingBox(this.left, this.right, this.top, this.bottom);
+  }
+  equals(...args) {
+    const b = _BoundingBox.resolveArgs(args);
+    return this.left === b.left && this.right === b.right && this.top === b.top && this.bottom === b.bottom;
+  }
+  toSize() {
+    return [this.width, this.height];
+  }
+  toVec2() {
+    return [this.left, this.top];
+  }
+  toRectangle() {
+    return [this.left, this.top, this.width, this.height];
+  }
+  inside(...args) {
+    const bbox = _BoundingBox.resolve(args);
+    return this.right >= bbox.left && bbox.right >= this.left && this.bottom >= bbox.top && bbox.bottom >= this.top;
+  }
+  insidePoint(...args) {
+    const point = Vec2.resolveArgs(args);
+    return this.left <= point.x && this.right >= point.x && this.top <= point.y && this.bottom >= point.y;
+  }
+  insideCircle(...args) {
+    const circle = Circle.resolveArgs(args);
+    const center = Vec2.resolve(circle).add(circle.radius);
+    const bboxhe = new Vec2(this.width / 2, this.height / 2);
+    const bboxcenter = new Vec2(this.left + bboxhe.x, this.top + bboxhe.y);
+    let diff = center.subtract(bboxcenter);
+    const clamped = Vec2.clamp(diff, bboxhe.invert(), bboxhe);
+    const closest = bboxcenter.add(clamped);
+    diff = closest.subtract(center);
+    return diff.length() < circle.radius;
+  }
+};
+
+// source/geometry/size.ts
+var Size = class _Size {
+  width;
+  height;
+  get aspectRatio() {
+    return this.height / this.width;
+  }
+  get area() {
+    return this.width * this.height;
+  }
+  get perimeter() {
+    return this.width + this.width + this.height + this.height;
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Square", a);
+  }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 2))
+      return new this(args[0], args[1]);
+    return this.resolve(args[0]);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (checkNumberArray(a, 2))
+      return new this(a[0], a[1]);
+    if (hasProperty(a, "toSize", "function"))
+      return this.cast(a.toSize());
+    if (hasProperty(a, "width", "number") && hasProperty(a, "height", "number"))
+      return new this(a.width, a.height);
+    if (checkString(a)) {
+      const parts = a.split("x").map((v) => parseFloat(v));
+      if (checkNumberArray(parts, 2))
+        return this.cast(parts);
+    }
+    if (checkNumber(a))
+      return new this(a, a);
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(width, height) {
+    if (!checkNumber(width))
+      throw new TypeError("expected number for width");
+    if (!checkNumber(height))
+      throw new TypeError("expected number for height");
+    this.width = width;
+    this.height = height;
+  }
+  toArray() {
+    return [this.width, this.height];
+  }
+  toString() {
+    return `${this.width}x${this.height}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Size";
+  }
+  [NodeJSCustomInspect]() {
+    return `Size <${this.toString()}>`;
+  }
+  toJSON() {
+    return {
+      width: this.width,
+      height: this.height
+    };
+  }
+  clone() {
+    return new _Size(this.width, this.height);
+  }
+  equals(...args) {
+    const s = _Size.resolveArgs(args);
+    return this.width == s.width && this.height == s.height;
+  }
+  toVec2() {
+    return [this.width, this.height];
   }
 };
 
@@ -1255,17 +1239,22 @@ var Rectangle = class _Rectangle {
       return value;
     throw new ResolveError("Rectangle", a);
   }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 4))
+      return new this([args[0], args[1]], [args[2], args[3]]);
+    return this.resolve(args[0]);
+  }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (check_number_array(a, 4))
+    if (checkNumberArray(a, 4))
       return new this([a[0], a[1]], [a[2], a[3]]);
-    if (check_number_array(a, 5)) {
+    if (checkNumberArray(a, 5)) {
       const rect = new this([a[0], a[1]], [a[3], a[4]]);
       rect.w = a[2];
       return rect;
     }
-    if (check_string(a)) {
+    if (checkString(a)) {
       const [spos, ssize] = a.split("|");
       const pos = Vec2.cast(spos);
       const size = Size.cast(ssize);
@@ -1275,9 +1264,11 @@ var Rectangle = class _Rectangle {
       rect.w = pos.w;
       return rect;
     }
-    if (has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "width", "number") && has_property(a, "height", "number")) {
+    if (hasProperty(a, "toRectangle", "function"))
+      return this.cast(a.toRectangle());
+    if (hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "width", "number") && hasProperty(a, "height", "number")) {
       const rect = new this([a.x, a.y], [a.width, a.height]);
-      if (has_property(a, "w", "number"))
+      if (hasProperty(a, "w", "number"))
         rect.w = a.w;
       return rect;
     }
@@ -1290,132 +1281,286 @@ var Rectangle = class _Rectangle {
     this.position = Vec2.resolve(pos);
     this.size = Size.resolve(size);
   }
-  toArray(w = false) {
+  toArray(w = this.w !== 1) {
     return [...this.position.toArray(w), ...this.size.toArray()];
   }
-  toString(w = false) {
+  toString(w = this.w !== 1) {
     return `${this.position.toString(w)}|${this.size.toString()}`;
   }
+  get [Symbol.toStringTag]() {
+    return "Rectangle";
+  }
+  [NodeJSCustomInspect]() {
+    return `Rectangle <${this.toString()}>`;
+  }
   toJSON() {
     return { ...this.position.toJSON(), ...this.size.toJSON() };
   }
   toBoundingBox() {
     return [this.x, this.x + this.width, this.y, this.y + this.height];
   }
+  toVec2() {
+    return [this.x, this.y, this.w];
+  }
+  toSize() {
+    return [this.width, this.height];
+  }
   clone() {
     return new _Rectangle(this.position.clone(), this.size.clone());
   }
-  equals(rectangle) {
-    const rect = _Rectangle.resolve(rectangle);
+  equals(...args) {
+    const rect = _Rectangle.resolveArgs(args);
     return this.position.equals(rect.position) && this.size.equals(rect.size);
   }
 };
 
-// source/geometry/bbox.ts
-var BoundingBox = class _BoundingBox {
-  left;
-  right;
-  top;
-  bottom;
-  get width() {
-    return this.right - this.left;
+// source/common/string.ts
+function stringify(value) {
+  return value != null && typeof value == "object" && "toString" in value && typeof value.toString == "function" ? value.toString() : String(value);
+}
+
+// source/vectors/vec3.ts
+var Vec3 = class _Vec3 {
+  x;
+  y;
+  z;
+  w;
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Vec3", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (checkNumberArray(a, 3) || checkNumberArray(a, 4))
+      return new this(a[0], a[1], a[2], checkNumber(a[3]) ? a[3] : void 0);
+    if (hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "z", "number"))
+      return new this(a.x, a.y, a.z, hasProperty(a, "w", "number") ? a.w : void 0);
+    if (checkString(a)) {
+      const [sxyz, sw] = a.split(";");
+      if (checkString(sxyz)) {
+        const parts = sxyz.split(",");
+        if (checkStringArray(parts, 3))
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]), checkString(sw) ? parseFloat(sw) : void 0);
+      }
+    }
+    if (checkNumber(a))
+      return new this(a, a, a);
+    return void 0;
+  }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 3))
+      return new this(args[0], args[1], args[2]);
+    return this.resolve(args[0]);
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  static fromPoints(a, b) {
+    const veca = this.resolve(a);
+    const vecb = this.resolve(b);
+    return new this(vecb.x - veca.x, vecb.y - veca.y, vecb.z - veca.z);
+  }
+  static clamp(value, min, max) {
+    const a = this.resolve(value), b = this.resolve(min), c = this.resolve(max);
+    return new this(
+      clamp(a.x, b.x, c.x),
+      clamp(a.y, b.y, c.y),
+      clamp(a.z, b.z, c.z)
+    );
+  }
+  static intersectPlane(planeP, planeN, lineStart, lineEnd, t) {
+    planeN = this.resolve(planeN).normalize();
+    const plane_d = -this.resolve(planeN).dot(planeP);
+    const ad = this.resolve(lineStart).dot(planeN);
+    const bd = this.resolve(lineEnd).dot(planeN);
+    t = (-plane_d - ad) / (bd - ad);
+    const lineStartToEnd = this.resolve(lineEnd).subtract(lineStart);
+    const linetoIntersect = lineStartToEnd.multiply(t);
+    return _Vec3.resolve(lineStart).add(linetoIntersect);
+  }
+  static get zero() {
+    return new this(0, 0, 0);
+  }
+  static get one() {
+    return new this(1, 1, 1);
+  }
+  constructor(x, y, z, w = 1) {
+    if (!checkNumber(x))
+      throw new TypeError("expected number for x");
+    if (!checkNumber(y))
+      throw new TypeError("expected number for y");
+    if (!checkNumber(z))
+      throw new TypeError("expected number for z");
+    if (!checkNumber(w))
+      throw new TypeError("expected number for w");
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+  toArray(w = this.w !== 1) {
+    return w ? [this.x, this.y, this.z, this.w] : [this.x, this.y, this.z];
+  }
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+      w: this.w
+    };
+  }
+  toString(w = this.w !== 1) {
+    return w ? `${this.x},${this.y},${this.z};${this.w}` : `${this.x},${this.y},${this.z}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Vec3";
+  }
+  [NodeJSCustomInspect]() {
+    return `Vec3 <${this.toString()}>`;
+  }
+  toVec2() {
+    return [this.x, this.y, this.w];
+  }
+  toRGB() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z];
+  }
+  toRGBA() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z, vec.w];
+  }
+  toHSL() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z];
+  }
+  toHSLA() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z, vec.w];
   }
-  set width(val) {
-    this.right = this.left + val;
+  toQuaternion() {
+    return [this.w, this.x, this.y, this.z];
   }
-  get height() {
-    return this.bottom - this.top;
+  clone() {
+    return new _Vec3(this.x, this.y, this.z, this.w);
   }
-  set height(val) {
-    this.bottom = this.top + val;
+  equals(...args) {
+    const a = _Vec3.resolveArgs(args);
+    return this.x == a.x && this.y == a.y && this.z == a.z;
   }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("BoundingBox", a);
+  setX(x) {
+    this.x = x;
+    return this;
   }
-  static cast(a) {
-    if (a == null || typeof a == "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"))
-      return new this(a.left, a.right, a.top, a.bottom);
-    if (check_string(a)) {
-      const parts = a.split(",");
-      if (check_string_array(parts, 4))
-        return this.cast(parts.map((v) => parseFloat(v)));
-    }
-    return void 0;
+  setY(y) {
+    this.y = y;
+    return this;
   }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
+  setZ(z) {
+    this.z = z;
+    return this;
   }
-  constructor(left, right, top, bottom) {
-    if (!check_number(left))
-      throw new TypeError("expected number for left");
-    if (!check_number(right))
-      throw new TypeError("expected number for right");
-    if (!check_number(top))
-      throw new TypeError("expected number for top");
-    if (!check_number(bottom))
-      throw new TypeError("expected number for bottom");
-    this.left = left;
-    this.right = right;
-    this.top = top;
-    this.bottom = bottom;
+  set(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return this.setX(vec.x).setY(vec.y).setZ(vec.z);
   }
-  toArray() {
-    return [this.left, this.right, this.top, this.bottom];
+  add(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x + vec.x,
+      this.y + vec.y,
+      this.z + vec.z
+    );
   }
-  toString() {
-    return `${this.left},${this.right},${this.top},${this.bottom}`;
+  offset(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    this.x += vec.x;
+    this.y += vec.y;
+    this.z += vec.z;
+    return this;
   }
-  toJSON() {
-    return {
-      left: this.left,
-      top: this.top,
-      right: this.right,
-      bottom: this.bottom
-    };
+  subtract(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x - vec.x,
+      this.y - vec.y,
+      this.z - vec.z
+    );
   }
-  clone() {
-    return new _BoundingBox(this.left, this.right, this.top, this.bottom);
+  multiply(scalar) {
+    return new _Vec3(
+      this.x * scalar,
+      this.y * scalar,
+      this.z * scalar
+    );
   }
-  equals(bbox) {
-    const b = _BoundingBox.resolve(bbox);
-    return this.left == b.left && this.right == b.right && this.top == b.top && this.bottom == b.bottom;
+  naiveMultiply(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x * vec.x,
+      this.y * vec.y,
+      this.z * vec.z
+    );
   }
-  toSquare() {
-    return new Size(this.width, this.height);
+  divide(...args) {
+    if (checkNumberArray(args, 1))
+      return new _Vec3(
+        this.x / args[0],
+        this.y / args[0],
+        this.z / args[0]
+      );
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x / vec.x,
+      this.y / vec.y,
+      this.z / vec.z
+    );
   }
-  toRectangle() {
-    return new Rectangle([this.left, this.top], [this.width, this.height]);
+  dot(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return this.x * vec.x + this.y * vec.y + this.z * vec.z;
   }
-  inside(a) {
-    const bbox = _BoundingBox.resolve(a);
-    return this.right >= bbox.left && bbox.right >= this.left && this.bottom >= bbox.top && bbox.bottom >= this.top;
+  cross(...args) {
+    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
+    );
   }
-  insidePoint(a) {
-    const point = Vec2.resolve(a);
-    return this.left <= point.x && this.right >= point.x && this.top <= point.y && this.bottom >= point.y;
+  distance(...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);
   }
-  insideCircle(a) {
-    const circle = Circle.resolve(a);
-    const center = Vec2.resolve(circle).add(circle.radius);
-    const bboxhe = new Vec2(this.width / 2, this.height / 2);
-    const bboxcenter = new Vec2(this.left + bboxhe.x, this.top + bboxhe.y);
-    let diff = center.subtract(bboxcenter);
-    const clamped = Vec2.clamp(diff, bboxhe.invert(), bboxhe);
-    const closest = bboxcenter.add(clamped);
-    diff = closest.subtract(center);
-    return diff.length() < circle.radius;
+  distanceSquare(...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() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  normalize() {
+    const length = this.length();
+    if (length == 0) return _Vec3.zero;
+    return new _Vec3(
+      this.x / length,
+      this.y / length,
+      this.z / length,
+      this.w / length
+    );
+  }
+  invert() {
+    return this.multiply(-1);
+  }
+  round() {
+    return new _Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z), Math.round(this.w));
   }
 };
 
 // source/geometry/triangle.ts
-var ATriangle = class {
+var Triangle = class {
   constructor(A, B, C) {
     this.A = A;
     this.B = B;
@@ -1445,8 +1590,17 @@ var ATriangle = class {
   get height() {
     return 2 * (this.area / this.base);
   }
+  toString() {
+    return `${stringify(this.A)}|${stringify(this.B)}|${stringify(this.C)}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Triangle";
+  }
+  [NodeJSCustomInspect]() {
+    return `Triangle <${this.toString()}>`;
+  }
 };
-var Triangle2D = class extends ATriangle {
+var Triangle2D = class extends Triangle {
   get a() {
     return Vec2.fromPoints(this.B, this.C).length();
   }
@@ -1457,7 +1611,7 @@ var Triangle2D = class extends ATriangle {
     return Vec2.fromPoints(this.A, this.B).length();
   }
 };
-var Triangle3D = class extends ATriangle {
+var Triangle3D = class extends Triangle {
   get a() {
     return Vec3.fromPoints(this.B, this.C).length();
   }
@@ -1532,15 +1686,20 @@ var Mat3 = class _Mat3 {
       return value;
     throw new ResolveError("Mat3", a);
   }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 9))
+      return new this(args);
+    return this.resolve(args[0]);
+  }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (check_number_array(a, 9)) {
+    if (checkNumberArray(a, 9)) {
       return new this(a);
     }
-    if (check_array(a, void 0, 3)) {
+    if (checkArray(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))
+      if (checkNumberArray(row0, 3) && checkNumberArray(row1, 3) && checkNumberArray(row2, 3))
         return new this([
           row0[0],
           row0[1],
@@ -1553,12 +1712,14 @@ var Mat3 = class _Mat3 {
           row2[2]
         ]);
     }
-    if (check_string(a)) {
+    if (checkString(a)) {
       const parts = a.split(",");
-      if (check_string_array(parts, 9))
+      if (checkStringArray(parts, 9))
         return this.cast(parts.map((i) => parseFloat(i)));
     }
-    if (has_property(a, "m00", "number") && has_property(a, "m01", "number") && has_property(a, "m02", "number") && has_property(a, "m10", "number") && has_property(a, "m11", "number") && has_property(a, "m12", "number") && has_property(a, "m20", "number") && has_property(a, "m21", "number") && has_property(a, "m22", "number"))
+    if (hasProperty(a, "toMat3", "function"))
+      return this.cast(a.toMat3());
+    if (hasProperty(a, "m00", "number") && hasProperty(a, "m01", "number") && hasProperty(a, "m02", "number") && hasProperty(a, "m10", "number") && hasProperty(a, "m11", "number") && hasProperty(a, "m12", "number") && hasProperty(a, "m20", "number") && hasProperty(a, "m21", "number") && hasProperty(a, "m22", "number"))
       return new this([
         a.m00,
         a.m01,
@@ -1570,7 +1731,7 @@ var Mat3 = class _Mat3 {
         a.m21,
         a.m22
       ]);
-    if (check_number(a)) {
+    if (checkNumber(a)) {
       return new this([a, a, a, a, a, a, a, a, a]);
     }
     return void 0;
@@ -1592,7 +1753,7 @@ var Mat3 = class _Mat3 {
     ]);
   }
   constructor(init = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
-    if (!check_number_array(init, 9))
+    if (!checkNumberArray(init, 9))
       throw new TypeError("expected a number array with 9 elements");
     this._raw = init;
   }
@@ -1632,6 +1793,12 @@ var Mat3 = class _Mat3 {
   toString() {
     return `${this.m00},${this.m01},${this.m02},${this.m10},${this.m11},${this.m12},${this.m20},${this.m21},${this.m22}`;
   }
+  get [Symbol.toStringTag]() {
+    return "Mat3";
+  }
+  [NodeJSCustomInspect]() {
+    return `Mat3 <${this.toString()}>`;
+  }
   clone() {
     return new _Mat3([
       this.m00,
@@ -1645,41 +1812,41 @@ var Mat3 = class _Mat3 {
       this.m22
     ]);
   }
-  equals(mat) {
-    const m = _Mat3.resolve(mat);
+  equals(...args) {
+    const m = _Mat3.resolveArgs(args);
     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);
+  add(...args) {
+    const b = _Mat3.resolveArgs(args);
     const m = new _Mat3();
     for (let index = 0; index < this._raw.length; index++)
       m._raw[index] = this._raw[index] + b._raw[index];
     return m;
   }
-  subtract(mat) {
-    const b = _Mat3.resolve(mat);
+  subtract(...args) {
+    const b = _Mat3.resolveArgs(args);
     const m = new _Mat3();
     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))
+  multiply(...args) {
+    if (checkNumberArray(args, 1))
       return new _Mat3([
-        this.m00 * a,
-        this.m01 * a,
-        this.m02 * a,
-        this.m10 * a,
-        this.m11 * a,
-        this.m12 * a,
-        this.m20 * a,
-        this.m21 * a,
-        this.m22 * a
+        this.m00 * args[0],
+        this.m01 * args[0],
+        this.m02 * args[0],
+        this.m10 * args[0],
+        this.m11 * args[0],
+        this.m12 * args[0],
+        this.m20 * args[0],
+        this.m21 * args[0],
+        this.m22 * args[0]
       ]);
-    const b = _Mat3.resolve(a);
+    const b = _Mat3.resolveArgs(args);
     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,
@@ -1879,15 +2046,20 @@ var Mat4 = class _Mat4 {
       return value;
     throw new ResolveError("Mat4", a);
   }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 16))
+      return new this(args);
+    return this.resolve(args[0]);
+  }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (check_number_array(a, 16)) {
+    if (checkNumberArray(a, 16)) {
       return new this(a);
     }
-    if (check_array(a, void 0, 4)) {
+    if (checkArray(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))
+      if (checkNumberArray(row0, 4) && checkNumberArray(row1, 4) && checkNumberArray(row2, 4) && checkNumberArray(row3, 4))
         return new this([
           row0[0],
           row0[1],
@@ -1907,12 +2079,14 @@ var Mat4 = class _Mat4 {
           row3[3]
         ]);
     }
-    if (check_string(a)) {
+    if (checkString(a)) {
       const parts = a.split(",");
-      if (check_string_array(parts, 16))
+      if (checkStringArray(parts, 16))
         return this.cast(parts.map((i) => parseFloat(i)));
     }
-    if (has_property(a, "m00", "number") && has_property(a, "m01", "number") && has_property(a, "m02", "number") && has_property(a, "m03", "number") && has_property(a, "m10", "number") && has_property(a, "m11", "number") && has_property(a, "m12", "number") && has_property(a, "m13", "number") && has_property(a, "m20", "number") && has_property(a, "m21", "number") && has_property(a, "m22", "number") && has_property(a, "m23", "number") && has_property(a, "m30", "number") && has_property(a, "m31", "number") && has_property(a, "m32", "number") && has_property(a, "m33", "number"))
+    if (hasProperty(a, "toMat4", "function"))
+      return this.cast(a.toMat4());
+    if (hasProperty(a, "m00", "number") && hasProperty(a, "m01", "number") && hasProperty(a, "m02", "number") && hasProperty(a, "m03", "number") && hasProperty(a, "m10", "number") && hasProperty(a, "m11", "number") && hasProperty(a, "m12", "number") && hasProperty(a, "m13", "number") && hasProperty(a, "m20", "number") && hasProperty(a, "m21", "number") && hasProperty(a, "m22", "number") && hasProperty(a, "m23", "number") && hasProperty(a, "m30", "number") && hasProperty(a, "m31", "number") && hasProperty(a, "m32", "number") && hasProperty(a, "m33", "number"))
       return new this([
         a.m00,
         a.m01,
@@ -1931,7 +2105,7 @@ var Mat4 = class _Mat4 {
         a.m32,
         a.m33
       ]);
-    if (check_number(a)) {
+    if (checkNumber(a)) {
       return new this([a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a]);
     }
     return void 0;
@@ -1939,22 +2113,25 @@ var Mat4 = class _Mat4 {
   static is(a) {
     return typeof this.cast(a) != "undefined";
   }
-  static orthographic(left, right, bottom, top, near, far) {
+  static orthographic(...args) {
+    const bbox = checkNumberArray(args, 6) ? new BoundingBox(args[0], args[1], args[2], args[3]) : BoundingBox.resolve(args[0]);
+    const near = checkNumberArray(args, 6) ? args[4] : args[1];
+    const far = checkNumberArray(args, 6) ? args[5] : args[2];
     return new this([
-      2 / (right - left),
+      2 / (bbox.right - bbox.left),
       0,
       0,
       0,
       0,
-      2 / (top - bottom),
+      2 / (bbox.top - bbox.bottom),
       0,
       0,
       0,
       0,
       2 / (near - far),
       0,
-      (left + right) / (left - right),
-      (bottom + top) / (bottom - top),
+      (bbox.left + bbox.right) / (bbox.left - bbox.right),
+      (bbox.bottom + bbox.top) / (bbox.bottom - bbox.top),
       (near + far) / (near - far),
       1
     ]);
@@ -2007,7 +2184,7 @@ var Mat4 = class _Mat4 {
     ]);
   }
   constructor(init = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]) {
-    if (!check_number_array(init, 16))
+    if (!checkNumberArray(init, 16))
       throw new TypeError("expected a number array with 16 elements");
     this._raw = init;
   }
@@ -2062,6 +2239,12 @@ var Mat4 = class _Mat4 {
   toString() {
     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}`;
   }
+  get [Symbol.toStringTag]() {
+    return "Mat4";
+  }
+  [NodeJSCustomInspect]() {
+    return `Mat4 <${this.toString()}>`;
+  }
   clone() {
     return new _Mat4([
       this.m00,
@@ -2082,82 +2265,80 @@ var Mat4 = class _Mat4 {
       this.m33
     ]);
   }
-  equals(mat) {
-    const m = _Mat4.resolve(mat);
+  equals(...args) {
+    const m = _Mat4.resolveArgs(args);
     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);
+  add(...args) {
+    const b = _Mat4.resolveArgs(args);
     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);
+  subtract(...args) {
+    const b = _Mat4.resolveArgs(args);
     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([
-        this.m00 * a,
-        this.m01 * a,
-        this.m02 * a,
-        this.m03 * a,
-        this.m10 * a,
-        this.m11 * a,
-        this.m12 * a,
-        this.m13 * a,
-        this.m20 * a,
-        this.m21 * a,
-        this.m22 * a,
-        this.m23 * a,
-        this.m30 * a,
-        this.m31 * a,
-        this.m32 * a,
-        this.m33 * a
-      ]);
-    }
-    if (_Mat4.is(a)) {
-      const b = _Mat4.resolve(a);
+  multiply(...args) {
+    if (checkNumberArray(args, 1)) {
+      const scalar = args[0];
       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,
-        b.m00 * this.m03 + b.m01 * this.m13 + b.m02 * this.m23 + b.m03 * this.m33,
-        b.m10 * this.m00 + b.m11 * this.m10 + b.m12 * this.m20 + b.m13 * this.m30,
-        b.m10 * this.m01 + b.m11 * this.m11 + b.m12 * this.m21 + b.m13 * this.m31,
-        b.m10 * this.m02 + b.m11 * this.m12 + b.m12 * this.m22 + b.m13 * this.m32,
-        b.m10 * this.m03 + b.m11 * this.m13 + b.m12 * this.m23 + b.m13 * this.m33,
-        b.m20 * this.m00 + b.m21 * this.m10 + b.m22 * this.m20 + b.m23 * this.m30,
-        b.m20 * this.m01 + b.m21 * this.m11 + b.m22 * this.m21 + b.m23 * this.m31,
-        b.m20 * this.m02 + b.m21 * this.m12 + b.m22 * this.m22 + b.m23 * this.m32,
-        b.m20 * this.m03 + b.m21 * this.m13 + b.m22 * this.m23 + b.m23 * this.m33,
-        b.m30 * this.m00 + b.m31 * this.m10 + b.m32 * this.m20 + b.m33 * this.m30,
-        b.m30 * this.m01 + b.m31 * this.m11 + b.m32 * this.m21 + b.m33 * this.m31,
-        b.m30 * this.m02 + b.m31 * this.m12 + b.m32 * this.m22 + b.m33 * this.m32,
-        b.m30 * this.m03 + b.m31 * this.m13 + b.m32 * this.m23 + b.m33 * this.m33
+        this.m00 * scalar,
+        this.m01 * scalar,
+        this.m02 * scalar,
+        this.m03 * scalar,
+        this.m10 * scalar,
+        this.m11 * scalar,
+        this.m12 * scalar,
+        this.m13 * scalar,
+        this.m20 * scalar,
+        this.m21 * scalar,
+        this.m22 * scalar,
+        this.m23 * scalar,
+        this.m30 * scalar,
+        this.m31 * scalar,
+        this.m32 * scalar,
+        this.m33 * scalar
       ]);
     }
-    if (Vec3.is(a)) {
-      const b = Vec3.resolve(a);
-      const vec = new Vec3(
-        b.x * this.m00 + b.y * this.m10 + b.z * this.m20 + this.m30,
-        b.x * this.m01 + b.y * this.m11 + b.z * this.m21 + this.m31,
-        b.x * this.m02 + b.y * this.m12 + b.z * this.m22 + this.m32,
-        b.x * this.m03 + b.y * this.m13 + b.z * this.m23 + this.m33
+    const vec = Vec3.cast(args[0]);
+    if (vec !== void 0) {
+      const result = new Vec3(
+        vec.x * this.m00 + vec.y * this.m10 + vec.z * this.m20 + this.m30,
+        vec.x * this.m01 + vec.y * this.m11 + vec.z * this.m21 + this.m31,
+        vec.x * this.m02 + vec.y * this.m12 + vec.z * this.m22 + this.m32,
+        vec.x * this.m03 + vec.y * this.m13 + vec.z * this.m23 + this.m33
       );
-      if (vec.w != 0)
-        return vec.divide(vec.w);
-      return vec;
+      if (result.w != 0)
+        return result.divide(result.w);
+      return result;
     }
-    throw new ResolveError("Mat4 or Vec3 or number", a);
+    const mat = _Mat4.resolveArgs(args);
+    return new _Mat4([
+      mat.m00 * this.m00 + mat.m01 * this.m10 + mat.m02 * this.m20 + mat.m03 * this.m30,
+      mat.m00 * this.m01 + mat.m01 * this.m11 + mat.m02 * this.m21 + mat.m03 * this.m31,
+      mat.m00 * this.m02 + mat.m01 * this.m12 + mat.m02 * this.m22 + mat.m03 * this.m32,
+      mat.m00 * this.m03 + mat.m01 * this.m13 + mat.m02 * this.m23 + mat.m03 * this.m33,
+      mat.m10 * this.m00 + mat.m11 * this.m10 + mat.m12 * this.m20 + mat.m13 * this.m30,
+      mat.m10 * this.m01 + mat.m11 * this.m11 + mat.m12 * this.m21 + mat.m13 * this.m31,
+      mat.m10 * this.m02 + mat.m11 * this.m12 + mat.m12 * this.m22 + mat.m13 * this.m32,
+      mat.m10 * this.m03 + mat.m11 * this.m13 + mat.m12 * this.m23 + mat.m13 * this.m33,
+      mat.m20 * this.m00 + mat.m21 * this.m10 + mat.m22 * this.m20 + mat.m23 * this.m30,
+      mat.m20 * this.m01 + mat.m21 * this.m11 + mat.m22 * this.m21 + mat.m23 * this.m31,
+      mat.m20 * this.m02 + mat.m21 * this.m12 + mat.m22 * this.m22 + mat.m23 * this.m32,
+      mat.m20 * this.m03 + mat.m21 * this.m13 + mat.m22 * this.m23 + mat.m23 * this.m33,
+      mat.m30 * this.m00 + mat.m31 * this.m10 + mat.m32 * this.m20 + mat.m33 * this.m30,
+      mat.m30 * this.m01 + mat.m31 * this.m11 + mat.m32 * this.m21 + mat.m33 * this.m31,
+      mat.m30 * this.m02 + mat.m31 * this.m12 + mat.m32 * this.m22 + mat.m33 * this.m32,
+      mat.m30 * this.m03 + mat.m31 * this.m13 + mat.m32 * this.m23 + mat.m33 * this.m33
+    ]);
   }
   translate(...args) {
     const vec = Vec3.resolveArgs(args);
@@ -2307,33 +2488,31 @@ var Mat4 = class _Mat4 {
 };
 
 // source/color.ts
-function _hex_to_array(hex) {
-  if (!check_hex(hex))
+function __hex_to_array__(hex) {
+  if (!checkHex(hex))
     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;
-  const c = parseInt(part.substring(4, 6), 16) / 255;
-  const d = part.length == 8 ? parseInt(hex.substring(6, 8), 16) / 255 : 1;
-  return [a, b, c, d];
+  const part = getHexValue(hex);
+  const red = parseInt(part.substring(0, 2), 16) / 255;
+  const green = parseInt(part.substring(2, 4), 16) / 255;
+  const blue = parseInt(part.substring(4, 6), 16) / 255;
+  const alpha = part.length == 8 ? parseInt(hex.substring(6, 8), 16) / 255 : 1;
+  return [red, green, blue, alpha];
 }
-function _number_to_rgb(number) {
+function __number_to_rgb__(number) {
   const blue = number & 255;
   const green = (number & 65280) >>> 8;
   const red = (number & 16711680) >>> 16;
   return [red / 255, green / 255, blue / 255];
 }
-function _number_to_rgba(number) {
+function __number_to_rgba__(number) {
   const alpha = number & 255;
   const blue = (number & 65280) >>> 8;
   const green = (number & 16711680) >>> 16;
   const red = (number & 4278190080) >>> 24;
   return [red / 255, green / 255, blue / 255, alpha / 255];
 }
-function _fix_integer(number) {
-  return number * 255 | 0;
-}
-var RGBAColor = class _RGBAColor {
+var __to_byte__ = (scale) => clamp(scale * 255 | 0, 0, 255);
+var RGBA = class _RGBA {
   _red;
   get red() {
     return this._red;
@@ -2368,27 +2547,36 @@ var RGBAColor = class _RGBAColor {
       return value;
     throw new ResolveError("RGBAColor", a);
   }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 3) || checkNumberArray(args, 4))
+      return new this(args[0], args[1], args[2], args[3]);
+    return this.resolve(args[0]);
+  }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (check_number_array(a, 3) || check_number_array(a, 4))
+    if (checkNumberArray(a, 3) || checkNumberArray(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 : void 0);
-    if (check_number(a)) {
+    if (hasProperty(a, "toRGB", "function"))
+      return this.cast(a.toRGB());
+    if (hasProperty(a, "toRGBA", "function"))
+      return this.cast(a.toRGBA());
+    if (hasProperty(a, "red", "number") && hasProperty(a, "green", "number") && hasProperty(a, "blue", "number"))
+      return new this(a.red, a.green, a.blue, hasProperty(a, "alpha", "number") ? a.alpha : void 0);
+    if (checkNumber(a)) {
       const hex = a.toString(16);
-      const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
+      const convert = hex.length <= 6 ? __number_to_rgb__ : __number_to_rgba__;
       return this.cast(convert(a));
     }
-    if (check_string(a)) {
+    if (checkString(a)) {
       if (a.startsWith("rgb")) {
         const hasAlpha = a.startsWith("rgba");
         const offset = hasAlpha ? 5 : 4;
         const parts = a.substring(offset, a.indexOf(")", offset)).split(",");
-        if (check_string_array(parts, hasAlpha ? 4 : 3))
+        if (checkStringArray(parts, hasAlpha ? 4 : 3))
           return this.cast(parts.map((v) => parseInt(v) / 255));
       }
-      return this.cast(_hex_to_array(a));
+      return this.cast(__hex_to_array__(a));
     }
     return void 0;
   }
@@ -2401,38 +2589,57 @@ var RGBAColor = class _RGBAColor {
     this._blue = clamp(blue, 0, 1);
     this._alpha = clamp(alpha, 0, 1);
   }
-  toArray(withAlpha = false) {
-    return withAlpha ? [this.red, this.green, this.blue, this.alpha] : this.alpha == 1 ? [this.red, this.green, this.blue] : this.toArray(true);
+  toArray(withAlpha = this._alpha !== 1) {
+    return withAlpha ? [this.red, this.green, this.blue, this.alpha] : [this.red, this.green, this.blue];
   }
-  toJSON(withAlpha = false) {
+  toJSON(withAlpha = this._alpha !== 1) {
     return withAlpha ? {
       red: this.red,
       green: this.green,
       blue: this.blue,
       alpha: this.alpha
-    } : this.alpha == 1 ? { red: this.red, green: this.green, blue: this.blue } : this.toJSON(true);
+    } : {
+      red: this.red,
+      green: this.green,
+      blue: this.blue
+    };
+  }
+  toString(withAlpha = this._alpha !== 1) {
+    return withAlpha ? `rgba(${__to_byte__(this.red)},${__to_byte__(this.green)},${__to_byte__(this.blue)},${this.alpha})` : `rgb(${__to_byte__(this.red)},${__to_byte__(this.green)},${__to_byte__(this.blue)})`;
+  }
+  get [Symbol.toStringTag]() {
+    return "RGBA";
   }
-  toString(withAlpha = false) {
-    return withAlpha ? `rgba(${_fix_integer(this.red)},${_fix_integer(this.green)},${_fix_integer(this.blue)},${this.alpha})` : this.alpha == 1 ? `rgb(${_fix_integer(this.red)},${_fix_integer(this.green)},${_fix_integer(this.blue)})` : this.toString(true);
+  [NodeJSCustomInspect]() {
+    return `RGBA <${this.toString()}>`;
   }
-  toHSL(withAlpha = true) {
+  toVec2() {
+    return [this.red, this.green, this.blue];
+  }
+  toVec3() {
+    return [this.red, this.green, this.blue, this.alpha];
+  }
+  toHSL(withAlpha = this._alpha !== 1) {
     const red = this.red, green = this.green, blue = this.blue;
     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 : void 0);
+      return new HSLA(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)
-      return new HSLColor(((green - blue) / d + (green < blue ? 6 : 0)) / 6, saturation, luminace);
+      return new HSLA(((green - blue) / d + (green < blue ? 6 : 0)) / 6, saturation, luminace, withAlpha ? this.alpha : void 0);
     if (max == green)
-      return new HSLColor(((blue - red) / d + 2) / 6, saturation, luminace);
+      return new HSLA(((blue - red) / d + 2) / 6, saturation, luminace, withAlpha ? this.alpha : void 0);
     if (max == blue)
-      return new HSLColor(((red - green) / d + 4) / 6, saturation, luminace);
-    return new HSLColor(0, saturation, luminace, withAlpha ? this.alpha : void 0);
+      return new HSLA(((red - green) / d + 4) / 6, saturation, luminace, withAlpha ? this.alpha : void 0);
+    return new HSLA(0, saturation, luminace, withAlpha ? this.alpha : void 0);
+  }
+  toHSLA() {
+    return this.toHSL(true);
   }
-  invert(withAlpha = false) {
-    return new _RGBAColor(
+  invert(withAlpha = this._alpha !== 1) {
+    return new _RGBA(
       1 - this.red,
       1 - this.green,
       1 - this.blue,
@@ -2440,7 +2647,7 @@ var RGBAColor = class _RGBAColor {
     );
   }
 };
-var HSLColor = class _HSLColor {
+var HSLA = class _HSLA {
   _hue;
   get hue() {
     return this._hue;
@@ -2475,27 +2682,36 @@ var HSLColor = class _HSLColor {
       return value;
     throw new ResolveError("HSLColor", a);
   }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 3) || checkNumberArray(args, 4))
+      return new this(args[0], args[1], args[2], args[3]);
+    return this.resolve(args[0]);
+  }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (check_number_array(a, 3) || check_number_array(a, 4))
+    if (checkNumberArray(a, 3) || checkNumberArray(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 : void 0);
-    if (check_number(a)) {
+    if (hasProperty(a, "toHSL", "function"))
+      return this.cast(a.toHSL());
+    if (hasProperty(a, "toHSLA", "function"))
+      return this.cast(a.toHSLA());
+    if (hasProperty(a, "hue", "number") && hasProperty(a, "saturation", "number") && hasProperty(a, "luminace", "number"))
+      return new this(a.hue, a.saturation, a.luminace, hasProperty(a, "alpha", "number") ? a.alpha : void 0);
+    if (checkNumber(a)) {
       const hex = a.toString(16);
-      const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
+      const convert = hex.length <= 6 ? __number_to_rgb__ : __number_to_rgba__;
       return this.cast(convert(a));
     }
-    if (check_string(a)) {
+    if (checkString(a)) {
       if (a.startsWith("hsl")) {
         const hasAlpha = a.startsWith("hsla");
         const offset = hasAlpha ? 5 : 4;
         const parts = a.substring(offset, a.indexOf(")", offset)).split(",");
-        if (check_string_array(parts, hasAlpha ? 4 : 3))
+        if (checkStringArray(parts, hasAlpha ? 4 : 3))
           return this.cast(parts.map((v) => parseInt(v) / 255));
       }
-      return this.cast(_hex_to_array(a));
+      return this.cast(__hex_to_array__(a));
     }
     return void 0;
   }
@@ -2503,39 +2719,49 @@ var HSLColor = class _HSLColor {
     return typeof this.cast(a) != "undefined";
   }
   constructor(hue, saturation, luminace, alpha = 1) {
-    if (!check_number(hue))
+    if (!checkNumber(hue))
       throw new TypeError("expected number for hue");
-    if (!check_number(saturation))
+    if (!checkNumber(saturation))
       throw new TypeError("expected number for saturation");
-    if (!check_number(luminace))
+    if (!checkNumber(luminace))
       throw new TypeError("expected number for luminace");
-    if (!check_number(alpha))
+    if (!checkNumber(alpha))
       throw new TypeError("expected number for alpha");
     this._hue = clamp(hue, 0, 1);
     this._saturation = clamp(saturation, 0, 1);
     this._luminace = clamp(luminace, 0, 1);
     this._alpha = clamp(alpha, 0, 1);
   }
-  toArray(withAlpha = false) {
-    return withAlpha ? [this.hue, this.saturation, this.luminace, this.alpha] : this.alpha == 1 ? [this.hue, this.saturation, this.luminace] : this.toArray(true);
+  toArray(withAlpha = this._alpha !== 1) {
+    return withAlpha ? [this.hue, this.saturation, this.luminace, this.alpha] : [this.hue, this.saturation, this.luminace];
   }
-  toJSON(withAlpha = false) {
+  toJSON(withAlpha = this._alpha !== 1) {
     return withAlpha ? {
       hue: this.hue,
       saturation: this.saturation,
       luminace: this.luminace,
       alpha: this.alpha
-    } : this.alpha == 1 ? { hue: this.hue, saturation: this.saturation, luminace: this.luminace } : this.toJSON(true);
+    } : {
+      hue: this.hue,
+      saturation: this.saturation,
+      luminace: this.luminace
+    };
+  }
+  toString(withAlpha = this._alpha !== 1) {
+    return withAlpha ? `hsla(${__to_byte__(this.hue)},${__to_byte__(this.saturation)},${__to_byte__(this.luminace)},${this.alpha})` : `hsl(${__to_byte__(this.hue)},${__to_byte__(this.saturation)},${__to_byte__(this.luminace)})`;
+  }
+  get [Symbol.toStringTag]() {
+    return "HSLA";
   }
-  toString(withAlpha = false) {
-    return withAlpha ? `hsla(${_fix_integer(this.hue)},${_fix_integer(this.saturation)},${_fix_integer(this.luminace)},${this.alpha})` : this.alpha == 1 ? `hsl(${_fix_integer(this.hue)},${_fix_integer(this.saturation)},${_fix_integer(this.luminace)})` : this.toString(true);
+  [NodeJSCustomInspect]() {
+    return `HSLA <${this.toString()}>`;
   }
-  toRGB(withAlpha = true) {
+  toRGB(withAlpha = this._alpha !== 1) {
     if (this.saturation == 0)
-      return new RGBAColor(this.luminace * 255, this.luminace * 255, this.luminace * 255, withAlpha ? this.alpha : void 0);
+      return new RGBA(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) {
+    function __hue_2_rgb__(t) {
       let _t = t;
       if (_t < 0)
         _t++;
@@ -2549,10 +2775,19 @@ var HSLColor = 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 : void 0);
+    return new RGBA(__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(
+  toRGBA() {
+    return this.toRGB(true);
+  }
+  toVec2() {
+    return [this.hue, this.saturation, this.luminace];
+  }
+  toVec3() {
+    return [this.hue, this.saturation, this.luminace, this.alpha];
+  }
+  invert(withAlpha = this._alpha !== 1) {
+    return new _HSLA(
       1 - this.hue,
       1 - this.saturation,
       1 - this.luminace,
@@ -2560,33 +2795,44 @@ var HSLColor = class _HSLColor {
     );
   }
 };
-function resolveColor(a, preferHSL = false) {
-  const value = castColor(a, preferHSL);
-  if (typeof value != "undefined")
-    return value;
-  throw new ResolveError("Color", a);
-}
-function castColor(a, preferHSL = false) {
-  const results = [];
-  try {
-    const rgba = RGBAColor.resolve(a);
-    results.push(rgba);
-  } catch (e) {
-  }
-  try {
-    const hsla = HSLColor.resolve(a);
-    results.push(hsla);
-  } catch (e) {
-  }
-  let offset = preferHSL ? 1 : 0;
-  const firstItem = results[offset];
-  if (firstItem)
-    return firstItem;
-  const secondItem = results[offset + 1];
-  if (secondItem)
-    return secondItem;
-  return void 0;
-}
+var AnyColor;
+((AnyColor2) => {
+  function cast(a, preferHSL = false) {
+    const results = [];
+    try {
+      const rgba = RGBA.resolve(a);
+      results.push(rgba);
+    } catch (e) {
+    }
+    try {
+      const hsla = HSLA.resolve(a);
+      results.push(hsla);
+    } catch (e) {
+    }
+    let offset = preferHSL ? 1 : 0;
+    const firstItem = results[offset];
+    if (firstItem)
+      return firstItem;
+    const secondItem = results[offset + 1];
+    if (secondItem)
+      return secondItem;
+    return void 0;
+  }
+  AnyColor2.cast = cast;
+  function resolve(a, preferHSL = false) {
+    const value = cast(a, preferHSL);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Color", a);
+  }
+  AnyColor2.resolve = resolve;
+  function resolveArgs(args, preferHSL = false) {
+    if (checkNumberArray(args, 3) || checkNumberArray(args, 4))
+      return resolve(args, preferHSL);
+    return resolve(args[0], preferHSL);
+  }
+  AnyColor2.resolveArgs = resolveArgs;
+})(AnyColor || (AnyColor = {}));
 
 // source/quaternion.ts
 var Quaternion = class _Quaternion {
@@ -2603,16 +2849,23 @@ var Quaternion = class _Quaternion {
       return value;
     throw new ResolveError("Quaternion", a);
   }
+  static resolveArgs(args) {
+    if (checkNumberArray(args, 4))
+      return new this(args[0], args[1], args[2], args[3]);
+    return this.resolve(args[0]);
+  }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (check_number_array(a, 4))
+    if (checkNumberArray(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"))
+    if (hasProperty(a, "toQuaternion", "function"))
+      return this.cast(a.toQuaternion());
+    if (hasProperty(a, "w", "number") && hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "z", "number"))
       return new this(a.w, a.x, a.y, a.z);
-    if (check_string(a)) {
+    if (checkString(a)) {
       const parts = a.replaceAll(" ", "").split("+");
-      if (check_string_array(parts, 4)) {
+      if (checkStringArray(parts, 4)) {
         const [sw, sxi, syj, szk] = parts;
         if (sxi.endsWith("i") && syj.endsWith("j") && szk.endsWith("k"))
           return this.cast([
@@ -2625,7 +2878,9 @@ var Quaternion = class _Quaternion {
     }
     return void 0;
   }
-  static fromAxisAngle(axis, angle) {
+  static fromAxisAngle(...args) {
+    const axis = checkNumberArray(args, 4) ? new Vec3(args[0], args[1], args[2]) : Vec3.resolve(args[0]);
+    const angle = checkNumberArray(args, 4) ? args[3] : args[1];
     const vec = Vec3.resolve(axis);
     const hangle = angle * 0.5;
     const sin2 = Math.sin(hangle);
@@ -2645,14 +2900,17 @@ var Quaternion = class _Quaternion {
       sx * sy * cz + sz * cx * cy
     );
   }
-  constructor(w = 0, x = 0, y = 0, z = 0) {
-    if (!check_number(w))
+  static get zero() {
+    return new _Quaternion(0, 0, 0, 0);
+  }
+  constructor(w, x, y, z) {
+    if (!checkNumber(w))
       throw new TypeError("expected number for w");
-    if (!check_number(x))
+    if (!checkNumber(x))
       throw new TypeError("expected number for x");
-    if (!check_number(y))
+    if (!checkNumber(y))
       throw new TypeError("expected number for x");
-    if (!check_number(z))
+    if (!checkNumber(z))
       throw new TypeError("expected number for w");
     this.w = w;
     this.x = x;
@@ -2665,6 +2923,12 @@ var Quaternion = class _Quaternion {
   toString() {
     return `${this.w} + ${this.x}i + ${this.y}j + ${this.z}k`;
   }
+  get [Symbol.toStringTag]() {
+    return "Quaternion";
+  }
+  [NodeJSCustomInspect]() {
+    return `Quaternion <${this.toString()}>`;
+  }
   toJSON() {
     return {
       w: this.w,
@@ -2676,8 +2940,8 @@ var Quaternion = class _Quaternion {
   clone() {
     return new _Quaternion(this.w, this.x, this.y, this.z);
   }
-  add(a) {
-    const quat = _Quaternion.resolve(a);
+  add(...args) {
+    const quat = _Quaternion.resolveArgs(args);
     return new _Quaternion(
       this.w + quat.w,
       this.x + quat.x,
@@ -2685,16 +2949,16 @@ var Quaternion = class _Quaternion {
       this.z + quat.z
     );
   }
-  offset(a) {
-    const quat = _Quaternion.resolve(a);
+  offset(...args) {
+    const quat = _Quaternion.resolveArgs(args);
     this.w += quat.w;
     this.x += quat.x;
     this.y += quat.y;
     this.z += quat.z;
     return this;
   }
-  subtract(a) {
-    const quat = _Quaternion.resolve(a);
+  subtract(...args) {
+    const quat = _Quaternion.resolveArgs(args);
     return new _Quaternion(
       this.w - quat.w,
       this.x - quat.x,
@@ -2712,12 +2976,12 @@ var Quaternion = class _Quaternion {
   normalize() {
     let length = this.length();
     if (length < EPSILON)
-      return new _Quaternion();
+      return _Quaternion.zero;
     length = 1 / length;
     return new _Quaternion(this.w * length, this.x * length, this.y * length, this.z * length);
   }
-  multiply(a) {
-    const quat = _Quaternion.resolve(a);
+  multiply(...args) {
+    const quat = _Quaternion.resolveArgs(args);
     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,
@@ -2740,21 +3004,21 @@ var Quaternion = class _Quaternion {
   scale(scalar) {
     return new _Quaternion(this.w * scalar, this.x * scalar, this.y * scalar, this.z * scalar);
   }
-  dot(a) {
-    const quat = _Quaternion.resolve(a);
+  dot(...args) {
+    const quat = _Quaternion.resolveArgs(args);
     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 _Quaternion.zero;
     length = 1 / length;
     return new _Quaternion(this.w * length, -this.x * length, -this.y * length, -this.z * length);
   }
-  divide(a) {
-    const quat = _Quaternion.resolve(a);
+  divide(...args) {
+    const quat = _Quaternion.resolveArgs(args);
     let length = quat.length(false);
-    if (length == 0) return new _Quaternion();
+    if (length == 0) return _Quaternion.zero;
     length = 1 / length;
     return new _Quaternion(
       (this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z) * length,
@@ -2771,7 +3035,7 @@ var Quaternion = class _Quaternion {
     const exp = Math.exp(this.w);
     const scale = exp * Math.sin(length) / length;
     if (length == 0)
-      return new _Quaternion(exp);
+      return new _Quaternion(exp, 0, 0, 0);
     return new _Quaternion(
       exp * Math.cos(length),
       this.x * scale,
@@ -2781,14 +3045,14 @@ var Quaternion = 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(logHypot(this.w, this.x), Math.atan2(this.x, this.w), 0, 0);
     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);
   }
-  toVector() {
-    return new Vec3(this.x, this.y, this.z, this.w);
+  toVec3() {
+    return [this.x, this.y, this.z, this.w];
   }
   toAxisAngle() {
     const sin2 = 1 - this.w * this.w;
@@ -2799,17 +3063,17 @@ var Quaternion = class _Quaternion {
     return new Vec3(this.x * isin, this.y * isin, this.z * isin, angle);
   }
   toEuler() {
-    function asin(t) {
+    function __asin__(t) {
       return t >= 1 ? Math.PI / 2 : t <= -1 ? -Math.PI / 2 : Math.asin(t);
     }
     return new Vec3(
       -Math.atan2(2 * (this.y * this.z - this.w * this.x), 1 - 2 * (this.x * this.x + this.y * this.y)),
-      asin(2 * (this.x * this.z + this.w * this.y)),
+      __asin__(2 * (this.x * this.z + this.w * this.y)),
       -Math.atan2(2 * (this.x * this.y - this.w * this.z), 1 - 2 * (this.y * this.y + this.z * this.z))
     );
   }
   toMat3() {
-    return new Mat3([
+    return [
       1 - 2 * (this.y * this.y + this.z * this.z),
       2 * (this.x * this.y - this.w * this.z),
       2 * (this.x * this.z + this.w * this.y),
@@ -2819,10 +3083,10 @@ var Quaternion = class _Quaternion {
       2 * (this.x * this.z - this.w * this.y),
       2 * (this.y * this.z + this.w * this.x),
       1 - 2 * (this.x * this.x + this.y * this.y)
-    ]);
+    ];
   }
   toMat4() {
-    return new Mat4([
+    return [
       1 - 2 * (this.y * this.y + this.z * this.z),
       2 * (this.x * this.y - this.w * this.z),
       2 * (this.x * this.z + this.w * this.y),
@@ -2839,40 +3103,156 @@ var Quaternion = class _Quaternion {
       0,
       0,
       1
-    ]);
+    ];
   }
 };
 
 // source/transform.ts
-var Transform = class {
+var Transform2D = class {
+  constructor(position, rotation, scale, parent) {
+    this.parent = parent;
+    this.localPosition = Vec2.resolve(position);
+    this.localRotation = rotation;
+    this.localScale = Vec2.resolve(scale);
+  }
+  origin = Vec2.zero;
+  localPosition;
+  localRotation;
+  get localRotationDegree() {
+    return radianToDegree(this.localRotation);
+  }
+  set localRotationDegree(v) {
+    this.localRotation = degreeToRadian(v);
+  }
+  localScale;
+  get globalPosition() {
+    let position = Vec2.zero;
+    let transform = this;
+    while (transform !== void 0) {
+      position = position.add(transform.localPosition).add(transform.origin);
+      transform = transform.parent;
+    }
+    return position;
+  }
+  get globalRotation() {
+    let rotation = 0;
+    let transform = this;
+    while (transform !== void 0) {
+      rotation += transform.localRotation;
+      transform = transform.parent;
+    }
+    return rotation;
+  }
+  get globalRotationDegree() {
+    return radianToDegree(this.globalRotation);
+  }
+  get globalScale() {
+    let scale = Vec2.one;
+    let transform = this;
+    while (transform !== void 0) {
+      scale = scale.naiveMultiply(transform.localScale);
+      transform = transform.parent;
+    }
+    return scale;
+  }
+  toString() {
+    return `${this.localPosition.toString()}|${this.localRotation}|${this.localScale.toString()}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Transform2D";
+  }
+  [NodeJSCustomInspect]() {
+    return `Transform2D <${this.toString()}>`;
+  }
+  toMat3() {
+    return new Mat3().scale(this.localScale).rotate(this.localRotation).translate(this.localPosition);
+  }
+  toGlobalMat3() {
+    let result = new Mat3();
+    let transform = this;
+    while (transform !== void 0) {
+      result = result.multiply(transform.toMat3());
+      transform = transform.parent;
+    }
+    return result;
+  }
+};
+var Transform3D = class {
   /**
-   * The position of the object
+   * Create a new transform with `position`, `rotation` and `scale`
+   * @param position The position as a Vec3
+   * @param rotation The rotation as a Quaternion
+   * @param scale The scale as a Vec3
    */
-  position;
+  constructor(position, rotation, scale, parent) {
+    this.parent = parent;
+    this.localPosition = Vec3.resolve(position);
+    this.localRotation = Quaternion.resolve(rotation);
+    this.localScale = Vec3.resolve(scale);
+  }
+  origin = Vec3.zero;
   /**
-   * The rotation of the object
+   * The local position
    */
-  rotation;
+  localPosition;
   /**
-   * The scale of the object
+   * The local rotation
    */
-  scale;
+  localRotation;
   /**
-   * Create a new transform with `position`, `rotation` and `scale`
-   * @param position The position as a Vec3
-   * @param rotation The rotation as a Quaternion
-   * @param scale The scale as a Vec3
+   * The local scale
    */
-  constructor(position, rotation, scale) {
-    this.position = Vec3.resolve(position);
-    this.rotation = Quaternion.resolve(rotation);
-    this.scale = Vec3.resolve(scale);
+  localScale;
+  get globalPosition() {
+    let position = Vec3.zero;
+    let transform = this;
+    while (transform !== void 0) {
+      position = position.add(transform.localPosition).add(transform.origin);
+      transform = transform.parent;
+    }
+    return position;
+  }
+  get globalRotation() {
+    let rotation = Quaternion.zero;
+    let transform = this;
+    while (transform !== void 0) {
+      rotation = rotation.add(transform.localRotation);
+      transform = transform.parent;
+    }
+    return rotation;
+  }
+  get globalScale() {
+    let scale = Vec3.one;
+    let transform = this;
+    while (transform !== void 0) {
+      scale = scale.naiveMultiply(transform.localScale);
+      transform = transform.parent;
+    }
+    return scale;
+  }
+  toString() {
+    return `${this.localPosition.toString()}|${this.localRotation.toString()}|${this.localScale.toString()}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Transform2D";
+  }
+  [NodeJSCustomInspect]() {
+    return `Transform2D <${this.toString()}>`;
   }
   /**
    * Convert the transform into a 4x3 matrix
    * @returns A 4x4 matrix from the transform
    */
   toMat4() {
-    return new Mat4().translate(this.position).multiply(this.rotation.toMat4()).scale(this.scale);
+    return new Mat4().scale(this.localScale).multiply(this.localRotation).translate(this.localPosition);
+  }
+  toGlobalMat4() {
+    let result = new Mat4();
+    let transform = this;
+    while (transform !== void 0) {
+      result = result.multiply(transform.toMat4());
+      transform = transform.parent;
+    }
+    return result;
   }
 };