@ntf/math 1.3.2 → 1.4.1

package/dist/index.js

@@ -20,14 +20,14 @@ 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,
@@ -36,37 +36,30 @@ __export(index_exports, {
   MathFunction: () => MathFunction,
   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,
   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,
+  lerp: () => lerp,
+  logHypot: () => logHypot,
+  numberToRGB: () => numberToRGB,
+  numberToRGBA: () => numberToRGBA,
+  radianToDegree: () => radianToDegree,
   sdbm: () => sdbm,
-  sign_char: () => sign_char,
-  stringify: () => stringify
+  signCharacter: () => signCharacter
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -74,8 +67,11 @@ module.exports = __toCommonJS(index_exports);
 var MathFunction = class {
 };
 
+// source/algebra/linear.ts
+var import_types2 = require("@ntf/types");
+
 // source/common/sign.ts
-function sign_char(num) {
+function signCharacter(num) {
   if (num == 0)
     return void 0;
   if (num < 0)
@@ -85,148 +81,22 @@ function sign_char(num) {
   return void 0;
 }
 
-// source/common/types.ts
-function check_number(obj) {
-  return obj != null && typeof obj == "number" && !isNaN(obj) && isFinite(obj);
-}
-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) {
-  let offset = 0;
-  if (string.startsWith("#") || string.startsWith("$"))
-    offset = 1;
-  if (string.startsWith("0x"))
-    offset = 2;
-  return string.substring(offset);
-}
-function check_hex(obj) {
-  if (!check_string(obj))
-    return false;
-  const value = get_hex_part(obj).split("").map((char) => parseInt(char.toUpperCase(), 16));
-  return check_number_array(value);
-}
-function check_string(obj) {
-  return obj != null && typeof obj == "string" && obj.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))
-      return false;
-  return true;
-}
-function check_number_array(obj, requiredLength) {
-  return check_array(obj, check_number, requiredLength);
-}
-function check_string_array(obj, requiredLength) {
-  return check_array(obj, check_string, requiredLength);
-}
-function has_property(obj, name, type) {
-  return obj != null && typeof obj == "object" && name in obj && typeof obj[name] == type;
-}
-
 // 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/vectors/vec2.ts
+var import_types = require("@ntf/types");
 
 // source/utils.ts
 function clamp(value, min, max) {
@@ -236,7 +106,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 +119,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 ((0, import_types.isFixedTypeArray)(a, import_types.isValidNumber, 2) || (0, import_types.isFixedTypeArray)(a, import_types.isValidNumber, 3))
+      return new this(a[0], a[1], a[2]);
+    if ((0, import_types.hasObjectProperty)(a, "toVec2", "function"))
+      return this.cast(a.toVec2());
+    if ((0, import_types.hasObjectProperty)(a, "x", "number") && (0, import_types.hasObjectProperty)(a, "y", "number"))
+      return new this(a.x, a.y, (0, import_types.hasObjectProperty)(a, "w", "number") ? a.w : void 0);
+    if ((0, import_types.isValidString)(a)) {
+      const [sxy, sw] = a.split(";");
+      if ((0, import_types.isValidString)(sxy)) {
+        const parts = sxy.split(",");
+        if ((0, import_types.isFixedTypeArray)(parts, import_types.isValidString, 2))
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), (0, import_types.isValidString)(sw) ? parseFloat(sw) : void 0);
       }
     }
-    if (check_number(a))
-      return new this(a, a, a);
+    if ((0, import_types.isValidNumber)(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 ((0, import_types.isFixedTypeArray)(args, import_types.isValidNumber, 2))
+      return new this(args[0], args[1]);
     return this.resolve(args[0]);
   }
   static is(a) {
@@ -292,63 +164,76 @@ 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);
+  }
+  static get one() {
+    return new this(1, 1);
   }
-  constructor(x = 0, y = 0, z = 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(z))
-      throw new TypeError("expected number for z");
-    if (!check_number(w))
-      throw new TypeError("expected number for w");
+  constructor(x, y, w = 1) {
+    (0, import_types.checkValidNumber)(x);
+    (0, import_types.checkValidNumber)(y);
+    (0, import_types.checkValidNumber)(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";
+  }
+  [import_types.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,139 +243,257 @@ 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 ((0, import_types.isFixedTypeArray)(args, import_types.isValidNumber, 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);
+// 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);
   }
-  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;
+  /**
+   * Create a linear function with a factor and height
+   * @param m The factor
+   * @param b The height
+   */
+  constructor(m, b) {
+    super();
+    (0, import_types2.checkValidNumber)(m);
+    (0, import_types2.checkValidNumber)(b);
+    this.m = m;
+    this.b = b;
+  }
+  get(x) {
+    (0, import_types2.checkValidNumber)(x);
+    return this.m * x + this.b;
+  }
+  roots() {
+    const x = -this.b / this.m;
+    if (!isNaN(x))
+      return [new Vec2(x, 0)];
+    return [];
+  }
+  toString() {
+    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";
+  }
+  [import_types2.NodeJSCustomInspect]() {
+    return `LinearFunction <${this.toString()}>`;
+  }
+};
+
+// source/algebra/quad.ts
+var import_types3 = require("@ntf/types");
+var QuadFunction = class extends MathFunction {
+  a;
+  b;
+  c;
+  static get(a, b, c, x) {
+    return new this(a, b, c).get(x);
+  }
+  constructor(a, b, c) {
+    super();
+    (0, import_types3.checkValidNumber)(a);
+    if (a === 0)
+      throw new import_types3.ExpectedTypeError("non-zero valid number", a);
+    (0, import_types3.checkValidNumber)(b);
+    (0, import_types3.checkValidNumber)(c);
+    this.a = a;
+    this.b = b;
+    this.c = c;
+  }
+  get(x) {
+    (0, import_types3.checkValidNumber)(x);
+    return this.a * x * x + this.b * x + this.c;
+  }
+  roots() {
+    const roots = new Array();
+    const discriminant = this.b * this.b - 4 * this.a * this.c;
+    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, 0));
+    if (!isNaN(n1) && n0 != n1)
+      roots.push(new Vec2(n1, 0));
+    return roots;
+  }
+  toString(type = "standard") {
+    switch (type) {
+      default:
+      case "standard": {
+        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)
+          return `f(x) = ${this.a}x^2 ${bsign} ${Math.abs(this.b)}x`;
+        return `f(x) = ${this.a}x^2`;
+      }
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return "QuadFunction";
+  }
+  [import_types3.NodeJSCustomInspect]() {
+    return `QuadFunction <${this.toString()}>`;
+  }
+};
+
+// source/algebra/quaternion.ts
+var import_types5 = require("@ntf/types");
+
+// source/vectors/vec3.ts
+var import_types4 = require("@ntf/types");
+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 ((0, import_types4.isFixedTypeArray)(a, import_types4.isValidNumber, 3) || (0, import_types4.isFixedTypeArray)(a, import_types4.isValidNumber, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if ((0, import_types4.hasObjectProperty)(a, "x", "number") && (0, import_types4.hasObjectProperty)(a, "y", "number") && (0, import_types4.hasObjectProperty)(a, "z", "number"))
+      return new this(a.x, a.y, a.z, (0, import_types4.hasObjectProperty)(a, "w", "number") ? a.w : void 0);
+    if ((0, import_types4.isValidString)(a)) {
+      const [sxyz, sw] = a.split(";");
+      if ((0, import_types4.isValidString)(sxyz)) {
+        const parts = sxyz.split(",");
+        if ((0, import_types4.isFixedTypeArray)(parts, import_types4.isValidString, 3))
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]), (0, import_types4.isValidString)(sw) ? parseFloat(sw) : void 0);
+      }
+    }
+    if ((0, import_types4.isValidNumber)(a))
+      return new this(a, a, a);
+    return void 0;
   }
   static resolveArgs(args) {
-    if (check_number_array(args, 2))
-      return new this(args[0], args[1]);
+    if ((0, import_types4.isFixedTypeArray)(args, import_types4.isValidNumber, 3))
+      return new this(args[0], args[1], args[2]);
     return this.resolve(args[0]);
   }
   static is(a) {
@@ -499,51 +502,90 @@ var Vec2 = class _Vec2 {
   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);
+    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.y, b.y, c.y),
+      clamp(a.z, b.z, c.z)
     );
   }
-  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");
+  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) {
+    (0, import_types4.checkValidNumber)(x);
+    (0, import_types4.checkValidNumber)(y);
+    (0, import_types4.checkValidNumber)(z);
+    (0, import_types4.checkValidNumber)(w);
     this.x = x;
     this.y = y;
+    this.z = z;
     this.w = w;
   }
-  toArray(w = false) {
-    return w ? [this.x, this.y] : [this.x, this.y, this.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 = false) {
-    return w ? `${this.x},${this.y}` : `${this.x},${this.y};${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";
   }
-  toSquare() {
-    return new Size(this.x, this.y);
+  [import_types4.NodeJSCustomInspect]() {
+    return `Vec3 <${this.toString()}>`;
   }
-  toVec3(z) {
-    return new Vec3(this.x, this.y, z, this.w);
+  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];
+  }
+  toQuaternion() {
+    return [this.w, this.x, this.y, this.z];
   }
   clone() {
-    return new _Vec2(this.x, this.y, this.w);
+    return new _Vec3(this.x, this.y, this.z, this.w);
   }
-  equals(vec) {
-    const a = _Vec2.resolve(vec);
-    return this.x == a.x && this.y == a.y;
+  equals(...args) {
+    const a = _Vec3.resolveArgs(args);
+    return this.x == a.x && this.y == a.y && this.z == a.z;
   }
   setX(x) {
     this.x = x;
@@ -553,221 +595,686 @@ var Vec2 = class _Vec2 {
     this.y = y;
     return this;
   }
-  setW(w) {
-    this.w = w;
+  setZ(z) {
+    this.z = z;
     return this;
   }
   set(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return this.setX(vec.x).setY(vec.y);
+    const vec = _Vec3.resolveArgs(args);
+    return this.setX(vec.x).setY(vec.y).setZ(vec.z);
   }
   add(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return new _Vec2(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x + vec.x,
-      this.y + vec.y
+      this.y + vec.y,
+      this.z + vec.z
     );
   }
   offset(...args) {
-    const vec = _Vec2.resolveArgs(args);
+    const vec = _Vec3.resolveArgs(args);
     this.x += vec.x;
     this.y += vec.y;
+    this.z += vec.z;
     return this;
   }
   subtract(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return new _Vec2(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x - vec.x,
-      this.y - vec.y
+      this.y - vec.y,
+      this.z - vec.z
     );
   }
   multiply(scalar) {
-    return new _Vec2(
+    return new _Vec3(
       this.x * scalar,
-      this.y * scalar
+      this.y * scalar,
+      this.z * scalar
     );
   }
   naiveMultiply(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return new _Vec2(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x * vec.x,
-      this.y * vec.y
+      this.y * vec.y,
+      this.z * vec.z
     );
   }
   divide(...args) {
-    if (check_number_array(args, 1))
-      return new _Vec2(
+    if ((0, import_types4.isFixedTypeArray)(args, import_types4.isValidNumber, 1))
+      return new _Vec3(
         this.x / args[0],
-        this.y / args[0]
+        this.y / args[0],
+        this.z / args[0]
       );
-    const vec = _Vec2.resolveArgs(args);
-    return new _Vec2(
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
       this.x / vec.x,
-      this.y / vec.y
+      this.y / vec.y,
+      this.z / vec.z
     );
   }
   dot(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return this.x * vec.x + this.y * vec.y;
+    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
+    );
   }
   distance(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2);
+    const vec = _Vec3.resolveArgs(args);
+    return Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2) + Math.pow(vec.z - this.z, 2);
   }
   distanceSquare(...args) {
-    const vec = _Vec2.resolveArgs(args);
-    return Math.sqrt(Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2));
+    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);
-  }
-  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)
-    );
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
   }
   normalize() {
     const length = this.length();
-    if (length == 0) return new _Vec2();
-    return new _Vec2(
+    if (length == 0) return _Vec3.zero;
+    return new _Vec3(
       this.x / length,
-      this.y / length
+      this.y / length,
+      this.z / length,
+      this.w / length
     );
   }
   invert() {
     return this.multiply(-1);
   }
   round() {
-    return new _Vec2(Math.round(this.x), Math.round(this.y), Math.round(this.w));
+    return new _Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z), 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);
-  }
-  /**
-   * Create a linear function with a factor and height
-   * @param m The factor
-   * @param b The height
-   */
-  constructor(m, b) {
-    super();
-    if (!check_number(m))
-      throw new TypeError("expected number for m");
-    if (!check_number(b))
-      throw new TypeError("expected number for b");
-    this.m = m;
-    this.b = b;
+// source/algebra/quaternion.ts
+var Quaternion = class _Quaternion {
+  w;
+  x;
+  y;
+  z;
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
   }
-  get(x) {
-    if (!check_number(x))
-      throw new TypeError("expected number for x");
-    return this.m;
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Quaternion", a);
   }
-  roots() {
-    const x = -this.b / this.m;
-    if (!isNaN(x))
-      return [new Vec2(x)];
-    return [];
+  static resolveArgs(args) {
+    if ((0, import_types5.isFixedTypeArray)(args, import_types5.isValidNumber, 4))
+      return new this(args[0], args[1], args[2], args[3]);
+    return this.resolve(args[0]);
   }
-  toString() {
-    const bsign = sign_char(this.b);
-    if (bsign)
-      return `f(x) = ${this.m} * x ${bsign} ${Math.abs(this.b)}`;
-    return `f(x) = ${this.m} * x`;
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if ((0, import_types5.isFixedTypeArray)(a, import_types5.isValidNumber, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if ((0, import_types5.hasObjectProperty)(a, "toQuaternion", "function"))
+      return this.cast(a.toQuaternion());
+    if ((0, import_types5.hasObjectProperty)(a, "w", "number") && (0, import_types5.hasObjectProperty)(a, "x", "number") && (0, import_types5.hasObjectProperty)(a, "y", "number") && (0, import_types5.hasObjectProperty)(a, "z", "number"))
+      return new this(a.w, a.x, a.y, a.z);
+    if ((0, import_types5.isValidString)(a)) {
+      const parts = a.replaceAll(" ", "").split("+");
+      if ((0, import_types5.isFixedTypeArray)(parts, import_types5.isValidString, 4)) {
+        const [sw, sxi, syj, szk] = parts;
+        if (sxi.endsWith("i") && syj.endsWith("j") && szk.endsWith("k"))
+          return this.cast([
+            parseFloat(sw),
+            parseFloat(sxi.substring(0, sxi.length - 1)),
+            parseFloat(syj.substring(0, syj.length - 1)),
+            parseFloat(szk.substring(0, szk.length - 1))
+          ]);
+      }
+    }
+    return void 0;
+  }
+  static fromAxisAngle(...args) {
+    const axis = (0, import_types5.isFixedTypeArray)(args, import_types5.isValidNumber, 4) ? new Vec3(args[0], args[1], args[2]) : Vec3.resolve(args[0]);
+    const angle = (0, import_types5.isFixedTypeArray)(args, import_types5.isValidNumber, 4) ? args[3] : args[1];
+    const vec = Vec3.resolve(axis);
+    const hangle = angle * 0.5;
+    const sin2 = Math.sin(hangle);
+    const cos2 = Math.cos(hangle);
+    const length = sin2 / Math.sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
+    return new this(cos2, vec.x * length, vec.y * length, vec.z * length);
+  }
+  static fromEuler(...args) {
+    const vec = Vec3.resolveArgs(args);
+    const x2 = vec.x * 0.5, y2 = vec.y * 0.5, z2 = vec.z * 0.5;
+    const cx = Math.cos(x2), cy = Math.cos(y2), cz = Math.cos(z2);
+    const sx = Math.sin(x2), sy = Math.sin(y2), sz = Math.sin(z2);
+    return new _Quaternion(
+      cx * cy * cz - sx * sy * sz,
+      sx * cy * cz - sy * sz * cx,
+      sy * cx * cz - sx * sz * cy,
+      sx * sy * cz + sz * cx * cy
+    );
+  }
+  static get zero() {
+    return new _Quaternion(0, 0, 0, 0);
+  }
+  constructor(w, x, y, z) {
+    (0, import_types5.checkValidNumber)(w);
+    (0, import_types5.checkValidNumber)(x);
+    (0, import_types5.checkValidNumber)(y);
+    (0, import_types5.checkValidNumber)(z);
+    this.w = w;
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  toArray() {
+    return [this.w, this.x, this.y, this.z];
+  }
+  toString() {
+    return `${this.w} + ${this.x}i + ${this.y}j + ${this.z}k`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Quaternion";
+  }
+  [import_types5.NodeJSCustomInspect]() {
+    return `Quaternion <${this.toString()}>`;
+  }
+  toJSON() {
+    return {
+      w: this.w,
+      x: this.x,
+      y: this.y,
+      z: this.z
+    };
+  }
+  clone() {
+    return new _Quaternion(this.w, this.x, this.y, this.z);
+  }
+  add(...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
+    );
+  }
+  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(...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
+    );
+  }
+  negative() {
+    return new _Quaternion(-this.w, -this.x, -this.y, -this.z);
+  }
+  length(sqrt = true) {
+    const value = this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
+    return sqrt ? Math.sqrt(value) : value;
+  }
+  normalize() {
+    let length = this.length();
+    if (length < EPSILON)
+      return _Quaternion.zero;
+    length = 1 / length;
+    return new _Quaternion(this.w * length, this.x * length, this.y * length, this.z * length);
+  }
+  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,
+      this.w * quat.y + this.y * quat.w + this.z * quat.x - this.x * quat.z,
+      this.w * quat.z + this.z * quat.w + this.x * quat.y - this.y * quat.x
+    );
+  }
+  multiplyVector(...args) {
+    const vec = Vec3.resolveArgs(args);
+    const ix = this.w * vec.x + this.y * vec.y - this.z * vec.y;
+    const iy = this.w * vec.y + this.z * vec.x - this.x * vec.z;
+    const iz = this.w * vec.z + this.x * vec.y - this.y * vec.x;
+    const iw = -this.w * vec.x - this.y * vec.y - this.z * vec.z;
+    return new Vec3(
+      ix * this.w + iw * -this.x + iy * -this.z - iz * -this.y,
+      iy * this.w + iw * -this.y + iz * -this.x - ix * -this.z,
+      iz * this.w + iw * -this.z + ix * -this.y - iy * -this.x
+    );
+  }
+  scale(scalar) {
+    return new _Quaternion(this.w * scalar, this.x * scalar, this.y * scalar, this.z * scalar);
+  }
+  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 _Quaternion.zero;
+    length = 1 / length;
+    return new _Quaternion(this.w * length, -this.x * length, -this.y * length, -this.z * length);
+  }
+  divide(...args) {
+    const quat = _Quaternion.resolveArgs(args);
+    let length = quat.length(false);
+    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,
+      (this.x * quat.w - this.w * quat.x - this.y * quat.z + this.z * quat.y) * length,
+      (this.y * quat.w - this.w * quat.y - this.z * quat.x + this.x * quat.z) * length,
+      (this.z * quat.w - this.w * quat.z - this.x * quat.y + this.y * quat.x) * length
+    );
+  }
+  conjugate() {
+    return new _Quaternion(this.w, -this.x, -this.y, -this.z);
+  }
+  exp() {
+    const length = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    const exp = Math.exp(this.w);
+    const scale = exp * Math.sin(length) / length;
+    if (length == 0)
+      return new _Quaternion(exp, 0, 0, 0);
+    return new _Quaternion(
+      exp * Math.cos(length),
+      this.x * scale,
+      this.y * scale,
+      this.z * scale
+    );
+  }
+  log() {
+    if (this.x == 0 && this.z == 0)
+      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);
+  }
+  toVec3() {
+    return [this.x, this.y, this.z, this.w];
+  }
+  toAxisAngle() {
+    const sin2 = 1 - this.w * this.w;
+    if (sin2 > EPSILON)
+      return new Vec3(this.x, this.y, this.z, 0);
+    const isin = 1 / Math.sqrt(sin2);
+    const angle = 2 * Math.acos(this.w);
+    return new Vec3(this.x * isin, this.y * isin, this.z * isin, angle);
+  }
+  toEuler() {
+    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)),
+      -Math.atan2(2 * (this.x * this.y - this.w * this.z), 1 - 2 * (this.y * this.y + this.z * this.z))
+    );
+  }
+  toMat3() {
+    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),
+      2 * (this.x * this.y + this.w * this.z),
+      1 - 2 * (this.x * this.x + this.z * this.z),
+      2 * (this.y * this.z - this.w * this.x),
+      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 [
+      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),
+      0,
+      2 * (this.x * this.y + this.w * this.z),
+      1 - 2 * (this.x * this.x + this.z * this.z),
+      2 * (this.y * this.z - this.w * this.x),
+      0,
+      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),
+      0,
+      0,
+      0,
+      0,
+      1
+    ];
   }
 };
 
-// source/algebra/quad.ts
-var QuadFunction = class extends MathFunction {
-  a;
-  b;
-  c;
-  static get(a, b, c, x) {
-    return new this(a, b, c).get(x);
+// source/color/hsl.ts
+var import_types7 = require("@ntf/types");
+
+// source/color/rgb.ts
+var import_types6 = require("@ntf/types");
+
+// source/color/utils.ts
+function numberToRGB(number) {
+  const blue = number & 255;
+  const green = (number & 65280) >>> 8;
+  const red = (number & 16711680) >>> 16;
+  return [red / 255, green / 255, blue / 255];
+}
+function numberToRGBA(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];
+}
+
+// source/color/rgb.ts
+var RGBA = class _RGBA {
+  _red;
+  get red() {
+    return this._red;
   }
-  constructor(a, b, c) {
-    super();
-    if (!check_number(a))
-      throw new TypeError("expected number for a");
-    if (a == 0)
-      throw new TypeError("a cannot be 0");
-    if (!check_number(b))
-      throw new TypeError("expected number for b");
-    if (!check_number(c))
-      throw new TypeError("expected number for c");
-    this.a = a;
-    this.b = b;
-    this.c = c;
+  set red(val) {
+    this._red = clamp(val, 0, 1);
   }
-  get(x) {
-    if (!check_number(x))
-      throw new TypeError("expected number for x");
-    return this.a * x * x + this.b * x + this.c;
+  _green;
+  get green() {
+    return this._green;
   }
-  roots() {
-    const roots = new Array();
-    const discriminant = this.b * this.b - 4 * this.a * this.c;
-    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));
-    if (!isNaN(n1) && n0 != n1)
-      roots.push(new Vec2(n1));
-    return roots;
+  set green(val) {
+    this._green = clamp(val, 0, 1);
   }
-  toString(type = "standard") {
-    switch (type) {
-      default:
-      case "standard": {
-        const bsign = sign_char(this.b);
-        const csign = sign_char(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)
-          return `f(x) = ${this.a}x^2 ${bsign} ${Math.abs(this.b)}x`;
-        return `f(x) = ${this.a}x^2`;
+  _blue;
+  get blue() {
+    return this._blue;
+  }
+  set blue(val) {
+    this._blue = clamp(val, 0, 1);
+  }
+  _alpha;
+  get alpha() {
+    return this._alpha;
+  }
+  set alpha(val) {
+    this._alpha = clamp(val, 0, 1);
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("RGBAColor", a);
+  }
+  static resolveArgs(args) {
+    if ((0, import_types6.isFixedTypeArray)(args, import_types6.isValidNumber, 3) || (0, import_types6.isFixedTypeArray)(args, import_types6.isValidNumber, 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 ((0, import_types6.isFixedTypeArray)(a, import_types6.isValidNumber, 3) || (0, import_types6.isFixedTypeArray)(a, import_types6.isValidNumber, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if ((0, import_types6.hasObjectProperty)(a, "toRGB", "function"))
+      return this.cast(a.toRGB());
+    if ((0, import_types6.hasObjectProperty)(a, "toRGBA", "function"))
+      return this.cast(a.toRGBA());
+    if ((0, import_types6.hasObjectProperty)(a, "red", "number") && (0, import_types6.hasObjectProperty)(a, "green", "number") && (0, import_types6.hasObjectProperty)(a, "blue", "number"))
+      return new this(a.red, a.green, a.blue, (0, import_types6.hasObjectProperty)(a, "alpha", "number") ? a.alpha : void 0);
+    if ((0, import_types6.isValidNumber)(a)) {
+      const hex = a.toString(16);
+      const convert = hex.length <= 6 ? numberToRGB : numberToRGBA;
+      return this.cast(convert(a));
+    }
+    if ((0, import_types6.isValidString)(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 ((0, import_types6.isFixedTypeArray)(parts, import_types6.isValidString, hasAlpha ? 4 : 3))
+          return this.cast(parts.map((v) => parseInt(v) / 255));
+      }
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(red, green, blue, alpha = 1) {
+    (0, import_types6.checkValidNumber)(red);
+    (0, import_types6.checkValidNumber)(green);
+    (0, import_types6.checkValidNumber)(blue);
+    (0, import_types6.checkValidNumber)(alpha);
+    this._red = clamp(red, 0, 1);
+    this._green = clamp(green, 0, 1);
+    this._blue = clamp(blue, 0, 1);
+    this._alpha = clamp(alpha, 0, 1);
+  }
+  toArray(withAlpha = this._alpha !== 1) {
+    return withAlpha ? [this.red, this.green, this.blue, this.alpha] : [this.red, this.green, this.blue];
+  }
+  toJSON(withAlpha = this._alpha !== 1) {
+    return withAlpha ? {
+      red: this.red,
+      green: this.green,
+      blue: this.blue,
+      alpha: this.alpha
+    } : {
+      red: this.red,
+      green: this.green,
+      blue: this.blue
+    };
+  }
+  toString(withAlpha = this._alpha !== 1) {
+    return withAlpha ? `rgba(${clamp(this.red * 255 | 0, 0, 255)},${clamp(this.green * 255 | 0, 0, 255)},${clamp(this.blue * 255 | 0, 0, 255)},${this.alpha})` : `rgb(${clamp(this.red * 255 | 0, 0, 255)},${clamp(this.green * 255 | 0, 0, 255)},${clamp(this.blue * 255 | 0, 0, 255)})`;
+  }
+  get [Symbol.toStringTag]() {
+    return "RGBA";
+  }
+  [import_types6.NodeJSCustomInspect]() {
+    return `RGBA <${this.toString()}>`;
+  }
+  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 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 HSLA(((green - blue) / d + (green < blue ? 6 : 0)) / 6, saturation, luminace, withAlpha ? this.alpha : void 0);
+    if (max == green)
+      return new HSLA(((blue - red) / d + 2) / 6, saturation, luminace, withAlpha ? this.alpha : void 0);
+    if (max == blue)
+      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 = this._alpha !== 1) {
+    return new _RGBA(
+      1 - this.red,
+      1 - this.green,
+      1 - this.blue,
+      withAlpha ? 1 - this.alpha : this.alpha
+    );
+  }
+};
+
+// source/color/hsl.ts
+var HSLA = class _HSLA {
+  _hue;
+  get hue() {
+    return this._hue;
+  }
+  set hue(val) {
+    this._hue = clamp(val, 0, 1);
+  }
+  _saturation;
+  get saturation() {
+    return this._saturation;
+  }
+  set saturation(val) {
+    this._saturation = clamp(val, 0, 1);
+  }
+  _luminace;
+  get luminace() {
+    return this._luminace;
+  }
+  set luminace(val) {
+    this._luminace = clamp(val, 0, 1);
+  }
+  _alpha;
+  get alpha() {
+    return this._alpha;
+  }
+  set alpha(val) {
+    this._alpha = clamp(val, 0, 1);
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("HSLColor", a);
+  }
+  static resolveArgs(args) {
+    if ((0, import_types7.isFixedTypeArray)(args, import_types7.isValidNumber, 3) || (0, import_types7.isFixedTypeArray)(args, import_types7.isValidNumber, 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 ((0, import_types7.isFixedTypeArray)(a, import_types7.isValidNumber, 3) || (0, import_types7.isFixedTypeArray)(a, import_types7.isValidNumber, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if ((0, import_types7.hasObjectProperty)(a, "toHSL", "function"))
+      return this.cast(a.toHSL());
+    if ((0, import_types7.hasObjectProperty)(a, "toHSLA", "function"))
+      return this.cast(a.toHSLA());
+    if ((0, import_types7.hasObjectProperty)(a, "hue", "number") && (0, import_types7.hasObjectProperty)(a, "saturation", "number") && (0, import_types7.hasObjectProperty)(a, "luminace", "number"))
+      return new this(a.hue, a.saturation, a.luminace, (0, import_types7.hasObjectProperty)(a, "alpha", "number") ? a.alpha : void 0);
+    if ((0, import_types7.isValidNumber)(a)) {
+      const hex = a.toString(16);
+      const convert = hex.length <= 6 ? numberToRGB : numberToRGBA;
+      return this.cast(convert(a));
+    }
+    if ((0, import_types7.isValidString)(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 ((0, import_types7.isFixedTypeArray)(parts, import_types7.isValidString, hasAlpha ? 4 : 3))
+          return this.cast(parts.map((v) => parseInt(v) / 255));
       }
     }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(hue, saturation, luminace, alpha = 1) {
+    (0, import_types7.checkValidNumber)(hue);
+    (0, import_types7.checkValidNumber)(saturation);
+    (0, import_types7.checkValidNumber)(luminace);
+    (0, import_types7.checkValidNumber)(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 = this._alpha !== 1) {
+    return withAlpha ? [this.hue, this.saturation, this.luminace, this.alpha] : [this.hue, this.saturation, this.luminace];
+  }
+  toJSON(withAlpha = this._alpha !== 1) {
+    return withAlpha ? {
+      hue: this.hue,
+      saturation: this.saturation,
+      luminace: this.luminace,
+      alpha: this.alpha
+    } : {
+      hue: this.hue,
+      saturation: this.saturation,
+      luminace: this.luminace
+    };
+  }
+  toString(withAlpha = this._alpha !== 1) {
+    return withAlpha ? `hsla(${clamp(this.hue * 255 | 0, 0, 255)},${clamp(this.saturation * 255 | 0, 0, 255)},${clamp(this.luminace * 255 | 0, 0, 255)},${this.alpha})` : `hsl(${clamp(this.hue * 255 | 0, 0, 255)},${clamp(this.saturation * 255 | 0, 0, 255)},${clamp(this.luminace * 255 | 0, 0, 255)})`;
+  }
+  get [Symbol.toStringTag]() {
+    return "HSLA";
+  }
+  [import_types7.NodeJSCustomInspect]() {
+    return `HSLA <${this.toString()}>`;
+  }
+  toRGB(withAlpha = this._alpha !== 1) {
+    if (this.saturation == 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) {
+      let _t = t;
+      if (_t < 0)
+        _t++;
+      if (_t > 1)
+        _t--;
+      if (_t < 1 / 6)
+        return p + (q - p) * 6 * _t;
+      if (_t < 1 / 2)
+        return q;
+      if (_t < 2 / 3)
+        return p + (q - p) * (2 / 3 - _t) * 6;
+      return p;
+    }
+    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);
+  }
+  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,
+      withAlpha ? 1 - this.alpha : this.alpha
+    );
   }
 };
 
-// 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 +1284,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 +1293,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;
@@ -795,6 +1302,7 @@ function sdbm(value) {
 }
 
 // source/crypto/md2.ts
+var import_types8 = require("@ntf/types");
 var STABLE = [
   41,
   46,
@@ -1103,16 +1611,29 @@ var MD2 = class _MD2 {
     this._transform(this._checksum);
     return this._state.slice();
   }
+  toString() {
+    return "";
+  }
+  get [Symbol.toStringTag]() {
+    return "MD2";
+  }
+  [import_types8.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/bbox.ts
+var import_types10 = require("@ntf/types");
 
 // source/geometry/circle.ts
+var import_types9 = require("@ntf/types");
 var Circle = class _Circle {
   radius;
   get perimeter() {
@@ -1146,19 +1667,28 @@ var Circle = class _Circle {
       return value;
     throw new ResolveError("Circle", a);
   }
+  static resolveArgs(args) {
+    if ((0, import_types9.isFixedTypeArray)(args, import_types9.isValidNumber, 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 ((0, import_types9.isFixedTypeArray)(a, import_types9.isValidNumber, 3))
       return new this([a[0], a[1]], a[2]);
-    if (check_number_array(a, 4)) {
+    if ((0, import_types9.isFixedTypeArray)(a, import_types9.isValidNumber, 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 ((0, import_types9.hasObjectProperty)(a, "toCircle", "function"))
+      return this.cast(a.toCircle());
+    if ((0, import_types9.hasObjectProperty)(a, "x", "number") && (0, import_types9.hasObjectProperty)(a, "y", "number") && (0, import_types9.hasObjectProperty)(a, "radius", "number"))
+      return new this((0, import_types9.hasObjectProperty)(a, "w", "number") ? [a.x, a.y, a.w] : [a.x, a.y], a.radius);
+    if ((0, import_types9.isValidString)(a)) {
       const [spos, sradius] = a.split("|");
       const pos = Vec2.cast(spos);
       if (typeof pos == "undefined")
@@ -1173,9 +1703,8 @@ var Circle = class _Circle {
     return typeof this.cast(a) != "undefined";
   }
   constructor(position, radius) {
+    (0, import_types9.checkValidNumber)(radius);
     this.position = Vec2.resolve(position);
-    if (!check_number(radius))
-      throw new TypeError("expected number for radius");
     this.radius = radius;
   }
   toArray() {
@@ -1190,232 +1719,371 @@ var Circle = class _Circle {
   toString() {
     return `${this.position.toString()}|${this.radius}`;
   }
+  get [Symbol.toStringTag]() {
+    return "Circle";
+  }
+  [import_types9.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/rectangle.ts
-var Rectangle = class _Rectangle {
-  position;
-  size;
-  get area() {
-    return this.width * this.height;
+// source/geometry/bbox.ts
+var BoundingBox = class _BoundingBox {
+  left;
+  right;
+  top;
+  bottom;
+  get width() {
+    return this.right - this.left;
   }
-  get perimeter() {
-    return this.width + this.width + this.height + this.height;
+  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.position.x;
+    return this.left;
   }
-  set x(val) {
-    this.position.x = val;
+  set x(x) {
+    this.left = x;
   }
   get y() {
-    return this.position.y;
+    return this.top;
   }
-  set y(val) {
-    this.position.y = val;
+  set y(y) {
+    this.top = y;
   }
-  get w() {
-    return this.position.w;
+  w = 1;
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("BoundingBox", a);
   }
-  set w(val) {
-    this.position.w = val;
+  static resolveArgs(args) {
+    if ((0, import_types10.isFixedTypeArray)(args, import_types10.isValidNumber, 4))
+      return new this(args[0], args[1], args[2], args[3]);
+    return this.resolve(args[0]);
   }
-  get width() {
-    return this.size.width;
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if ((0, import_types10.isFixedTypeArray)(a, import_types10.isValidNumber, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if ((0, import_types10.hasObjectProperty)(a, "toBoundingBox", "function"))
+      return this.cast(a.toBoundingBox());
+    if ((0, import_types10.hasObjectProperty)(a, "left", "number") && (0, import_types10.hasObjectProperty)(a, "right", "number") && (0, import_types10.hasObjectProperty)(a, "top", "number") && (0, import_types10.hasObjectProperty)(a, "bottom", "number"))
+      return new this(a.left, a.right, a.top, a.bottom);
+    if ((0, import_types10.isValidString)(a)) {
+      const parts = a.split(",");
+      if ((0, import_types10.isFixedTypeArray)(parts, import_types10.isValidString, 4))
+        return this.cast(parts.map((v) => parseFloat(v)));
+    }
+    return void 0;
   }
-  set width(val) {
-    this.size.width = val;
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
   }
-  get height() {
-    return this.size.height;
+  constructor(left, right, top, bottom) {
+    (0, import_types10.checkValidNumber)(left);
+    (0, import_types10.checkValidNumber)(right);
+    (0, import_types10.checkValidNumber)(top);
+    (0, import_types10.checkValidNumber)(bottom);
+    this.left = left;
+    this.right = right;
+    this.top = top;
+    this.bottom = bottom;
   }
-  set height(val) {
-    this.size.height = val;
+  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";
+  }
+  [import_types10.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/rectangle.ts
+var import_types12 = require("@ntf/types");
+
+// source/geometry/size.ts
+var import_types11 = require("@ntf/types");
+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("Rectangle", a);
+    throw new ResolveError("Square", a);
+  }
+  static resolveArgs(args) {
+    if ((0, import_types11.isFixedTypeArray)(args, import_types11.isValidNumber, 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, 4))
-      return new this([a[0], a[1]], [a[2], a[3]]);
-    if (check_number_array(a, 5)) {
-      const rect = new this([a[0], a[1]], [a[3], a[4]]);
-      rect.w = a[2];
-      return rect;
-    }
-    if (check_string(a)) {
-      const [spos, ssize] = a.split("|");
-      const pos = Vec2.cast(spos);
-      const size = Size.cast(ssize);
-      if (typeof pos == "undefined" || typeof size == "undefined")
-        return void 0;
-      const rect = new this([pos.x, pos.y], [size.width, size.height]);
-      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")) {
-      const rect = new this([a.x, a.y], [a.width, a.height]);
-      if (has_property(a, "w", "number"))
-        rect.w = a.w;
-      return rect;
+    if ((0, import_types11.isFixedTypeArray)(a, import_types11.isValidNumber, 2))
+      return new this(a[0], a[1]);
+    if ((0, import_types11.hasObjectProperty)(a, "toSize", "function"))
+      return this.cast(a.toSize());
+    if ((0, import_types11.hasObjectProperty)(a, "width", "number") && (0, import_types11.hasObjectProperty)(a, "height", "number"))
+      return new this(a.width, a.height);
+    if ((0, import_types11.isValidString)(a)) {
+      const parts = a.split("x").map((v) => parseFloat(v));
+      if ((0, import_types11.isFixedTypeArray)(parts, import_types11.isValidNumber, 2))
+        return this.cast(parts);
     }
+    if ((0, import_types11.isValidNumber)(a))
+      return new this(a, a);
     return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
   }
-  constructor(pos, size) {
-    this.position = Vec2.resolve(pos);
-    this.size = Size.resolve(size);
+  constructor(width, height) {
+    (0, import_types11.checkValidNumber)(width);
+    (0, import_types11.checkValidNumber)(height);
+    this.width = width;
+    this.height = height;
   }
-  toArray(w = false) {
-    return [...this.position.toArray(w), ...this.size.toArray()];
+  toArray() {
+    return [this.width, this.height];
   }
-  toString(w = false) {
-    return `${this.position.toString(w)}|${this.size.toString()}`;
+  toString() {
+    return `${this.width}x${this.height}`;
   }
-  toJSON() {
-    return { ...this.position.toJSON(), ...this.size.toJSON() };
+  get [Symbol.toStringTag]() {
+    return "Size";
   }
-  toBoundingBox() {
-    return [this.x, this.x + this.width, this.y, this.y + this.height];
+  [import_types11.NodeJSCustomInspect]() {
+    return `Size <${this.toString()}>`;
+  }
+  toJSON() {
+    return {
+      width: this.width,
+      height: this.height
+    };
   }
   clone() {
-    return new _Rectangle(this.position.clone(), this.size.clone());
+    return new _Size(this.width, this.height);
   }
-  equals(rectangle) {
-    const rect = _Rectangle.resolve(rectangle);
-    return this.position.equals(rect.position) && this.size.equals(rect.size);
+  equals(...args) {
+    const s = _Size.resolveArgs(args);
+    return this.width == s.width && this.height == s.height;
+  }
+  toVec2() {
+    return [this.width, this.height];
   }
 };
 
-// source/geometry/bbox.ts
-var BoundingBox = class _BoundingBox {
-  left;
-  right;
-  top;
-  bottom;
+// source/geometry/rectangle.ts
+var Rectangle = class _Rectangle {
+  position;
+  size;
+  get area() {
+    return this.width * this.height;
+  }
+  get perimeter() {
+    return this.width + this.width + this.height + this.height;
+  }
+  get x() {
+    return this.position.x;
+  }
+  set x(val) {
+    this.position.x = val;
+  }
+  get y() {
+    return this.position.y;
+  }
+  set y(val) {
+    this.position.y = val;
+  }
+  get w() {
+    return this.position.w;
+  }
+  set w(val) {
+    this.position.w = val;
+  }
   get width() {
-    return this.right - this.left;
+    return this.size.width;
   }
   set width(val) {
-    this.right = this.left + val;
+    this.size.width = val;
   }
   get height() {
-    return this.bottom - this.top;
+    return this.size.height;
   }
   set height(val) {
-    this.bottom = this.top + val;
+    this.size.height = val;
   }
   static resolve(a) {
     const value = this.cast(a);
     if (typeof value != "undefined")
       return value;
-    throw new ResolveError("BoundingBox", a);
+    throw new ResolveError("Rectangle", a);
+  }
+  static resolveArgs(args) {
+    if ((0, import_types12.isFixedTypeArray)(args, import_types12.isValidNumber, 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))
-      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)));
+    if ((0, import_types12.isFixedTypeArray)(a, import_types12.isValidNumber, 4))
+      return new this([a[0], a[1]], [a[2], a[3]]);
+    if ((0, import_types12.isFixedTypeArray)(a, import_types12.isValidNumber, 5)) {
+      const rect = new this([a[0], a[1]], [a[3], a[4]]);
+      rect.w = a[2];
+      return rect;
+    }
+    if ((0, import_types12.isValidString)(a)) {
+      const [spos, ssize] = a.split("|");
+      const pos = Vec2.cast(spos);
+      const size = Size.cast(ssize);
+      if (typeof pos == "undefined" || typeof size == "undefined")
+        return void 0;
+      const rect = new this([pos.x, pos.y], [size.width, size.height]);
+      rect.w = pos.w;
+      return rect;
+    }
+    if ((0, import_types12.hasObjectProperty)(a, "toRectangle", "function"))
+      return this.cast(a.toRectangle());
+    if ((0, import_types12.hasObjectProperty)(a, "x", "number") && (0, import_types12.hasObjectProperty)(a, "y", "number") && (0, import_types12.hasObjectProperty)(a, "width", "number") && (0, import_types12.hasObjectProperty)(a, "height", "number")) {
+      const rect = new this([a.x, a.y], [a.width, a.height]);
+      if ((0, import_types12.hasObjectProperty)(a, "w", "number"))
+        rect.w = a.w;
+      return rect;
     }
     return void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
   }
-  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;
+  constructor(pos, size) {
+    this.position = Vec2.resolve(pos);
+    this.size = Size.resolve(size);
   }
-  toArray() {
-    return [this.left, this.right, this.top, this.bottom];
+  toArray(w = this.w !== 1) {
+    return [...this.position.toArray(w), ...this.size.toArray()];
   }
-  toString() {
-    return `${this.left},${this.right},${this.top},${this.bottom}`;
+  toString(w = this.w !== 1) {
+    return `${this.position.toString(w)}|${this.size.toString()}`;
   }
-  toJSON() {
-    return {
-      left: this.left,
-      top: this.top,
-      right: this.right,
-      bottom: this.bottom
-    };
+  get [Symbol.toStringTag]() {
+    return "Rectangle";
   }
-  clone() {
-    return new _BoundingBox(this.left, this.right, this.top, this.bottom);
+  [import_types12.NodeJSCustomInspect]() {
+    return `Rectangle <${this.toString()}>`;
   }
-  equals(bbox) {
-    const b = _BoundingBox.resolve(bbox);
-    return this.left == b.left && this.right == b.right && this.top == b.top && this.bottom == b.bottom;
+  toJSON() {
+    return { ...this.position.toJSON(), ...this.size.toJSON() };
   }
-  toSquare() {
-    return new Size(this.width, this.height);
+  toBoundingBox() {
+    return [this.x, this.x + this.width, this.y, this.y + this.height];
   }
-  toRectangle() {
-    return new Rectangle([this.left, this.top], [this.width, this.height]);
+  toVec2() {
+    return [this.x, this.y, this.w];
   }
-  inside(a) {
-    const bbox = _BoundingBox.resolve(a);
-    return this.right >= bbox.left && bbox.right >= this.left && this.bottom >= bbox.top && bbox.bottom >= this.top;
+  toSize() {
+    return [this.width, this.height];
   }
-  insidePoint(a) {
-    const point = Vec2.resolve(a);
-    return this.left <= point.x && this.right >= point.x && this.top <= point.y && this.bottom >= point.y;
+  clone() {
+    return new _Rectangle(this.position.clone(), this.size.clone());
   }
-  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;
+  equals(...args) {
+    const rect = _Rectangle.resolveArgs(args);
+    return this.position.equals(rect.position) && this.size.equals(rect.size);
   }
 };
 
 // source/geometry/triangle.ts
-var ATriangle = class {
+var import_types13 = require("@ntf/types");
+var Triangle = class {
   constructor(A, B, C) {
     this.A = A;
     this.B = B;
@@ -1433,349 +2101,54 @@ var ATriangle = class {
   get perimeter() {
     return this.a + this.b + this.c;
   }
-  get semiperimeter() {
-    return this.perimeter / 2;
-  }
-  get area() {
-    return Math.sqrt(this.semiperimeter * (this.semiperimeter - this.a) * (this.semiperimeter - this.b) * (this.semiperimeter - this.c));
-  }
-  get base() {
-    return 2 * (this.area / (this.a * Math.sin(this.gamma)));
-  }
-  get height() {
-    return 2 * (this.area / this.base);
-  }
-};
-var Triangle2D = class extends ATriangle {
-  get a() {
-    return Vec2.fromPoints(this.B, this.C).length();
-  }
-  get b() {
-    return Vec2.fromPoints(this.A, this.C).length();
-  }
-  get c() {
-    return Vec2.fromPoints(this.A, this.B).length();
-  }
-};
-var Triangle3D = class extends ATriangle {
-  get a() {
-    return Vec3.fromPoints(this.B, this.C).length();
-  }
-  get b() {
-    return Vec3.fromPoints(this.A, this.C).length();
-  }
-  get c() {
-    return Vec3.fromPoints(this.A, this.B).length();
-  }
-};
-
-// source/matrices/mat3.ts
-var Mat3 = class _Mat3 {
-  _raw;
-  get m00() {
-    return this._raw[0];
-  }
-  set m00(val) {
-    this._raw[0] = val;
-  }
-  get m01() {
-    return this._raw[1];
-  }
-  set m01(val) {
-    this._raw[1] = val;
-  }
-  get m02() {
-    return this._raw[2];
-  }
-  set m02(val) {
-    this._raw[2] = val;
-  }
-  get m10() {
-    return this._raw[3];
-  }
-  set m10(val) {
-    this._raw[3] = val;
-  }
-  get m11() {
-    return this._raw[4];
-  }
-  set m11(val) {
-    this._raw[4] = val;
-  }
-  get m12() {
-    return this._raw[5];
-  }
-  set m12(val) {
-    this._raw[5] = val;
-  }
-  get m20() {
-    return this._raw[6];
-  }
-  set m20(val) {
-    this._raw[6] = val;
-  }
-  get m21() {
-    return this._raw[7];
-  }
-  set m21(val) {
-    this._raw[7] = val;
-  }
-  get m22() {
-    return this._raw[8];
-  }
-  set m22(val) {
-    this._raw[8] = val;
-  }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("Mat3", a);
-  }
-  static cast(a) {
-    if (a == null || typeof a == "undefined")
-      return void 0;
-    if (check_number_array(a, 9)) {
-      return new this(a);
-    }
-    if (check_array(a, void 0, 3)) {
-      const row0 = a[0], row1 = a[1], row2 = a[2];
-      if (check_number_array(row0, 3) && check_number_array(row1, 3) && check_number_array(row2, 3))
-        return new this([
-          row0[0],
-          row0[1],
-          row0[2],
-          row1[0],
-          row1[1],
-          row1[2],
-          row2[0],
-          row2[1],
-          row2[2]
-        ]);
-    }
-    if (check_string(a)) {
-      const parts = a.split(",");
-      if (check_string_array(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"))
-      return new this([
-        a.m00,
-        a.m01,
-        a.m02,
-        a.m10,
-        a.m11,
-        a.m12,
-        a.m20,
-        a.m21,
-        a.m22
-      ]);
-    if (check_number(a)) {
-      return new this([a, a, a, a, a, a, a, a, a]);
-    }
-    return void 0;
-  }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
-  }
-  static projection(width, height) {
-    return new this([
-      2 / width,
-      0,
-      0,
-      0,
-      -2 / height,
-      0,
-      -1,
-      1,
-      1
-    ]);
-  }
-  constructor(init = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
-    if (!check_number_array(init, 9))
-      throw new TypeError("expected a number array with 9 elements");
-    this._raw = init;
-  }
-  toArray() {
-    return [
-      this.m00,
-      this.m01,
-      this.m02,
-      this.m10,
-      this.m11,
-      this.m12,
-      this.m20,
-      this.m21,
-      this.m22
-    ];
-  }
-  toNestetArray() {
-    return [
-      [this.m00, this.m01, this.m02],
-      [this.m10, this.m11, this.m12],
-      [this.m20, this.m21, this.m22]
-    ];
-  }
-  toJSON() {
-    return {
-      m00: this.m00,
-      m01: this.m01,
-      m02: this.m02,
-      m10: this.m10,
-      m11: this.m11,
-      m12: this.m12,
-      m20: this.m20,
-      m21: this.m21,
-      m22: this.m22
-    };
+  get semiperimeter() {
+    return this.perimeter / 2;
   }
-  toString() {
-    return `${this.m00},${this.m01},${this.m02},${this.m10},${this.m11},${this.m12},${this.m20},${this.m21},${this.m22}`;
+  get area() {
+    return Math.sqrt(this.semiperimeter * (this.semiperimeter - this.a) * (this.semiperimeter - this.b) * (this.semiperimeter - this.c));
   }
-  clone() {
-    return new _Mat3([
-      this.m00,
-      this.m01,
-      this.m02,
-      this.m10,
-      this.m11,
-      this.m12,
-      this.m20,
-      this.m21,
-      this.m22
-    ]);
+  get base() {
+    return 2 * (this.area / (this.a * Math.sin(this.gamma)));
   }
-  equals(mat) {
-    const m = _Mat3.resolve(mat);
-    for (let index = 0; index < this._raw.length; index++)
-      if (this._raw[index] != m._raw[index])
-        return false;
-    return true;
+  get height() {
+    return 2 * (this.area / this.base);
   }
-  add(mat) {
-    const b = _Mat3.resolve(mat);
-    const m = new _Mat3();
-    for (let index = 0; index < this._raw.length; index++)
-      m._raw[index] = this._raw[index] + b._raw[index];
-    return m;
+  toString() {
+    return `${this.A}|${this.B}|${this.C}`;
   }
-  subtract(mat) {
-    const b = _Mat3.resolve(mat);
-    const m = new _Mat3();
-    for (let index = 0; index < this._raw.length; index++)
-      m._raw[index] = this._raw[index] - b._raw[index];
-    return m;
+  get [Symbol.toStringTag]() {
+    return "Triangle";
   }
-  multiply(a) {
-    if (check_number(a))
-      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
-      ]);
-    const b = _Mat3.resolve(a);
-    return new _Mat3([
-      b.m00 * this.m00 + b.m01 * this.m10 + b.m02 * this.m20,
-      b.m00 * this.m01 + b.m01 * this.m11 + b.m02 * this.m21,
-      b.m00 * this.m02 + b.m01 * this.m12 + b.m02 * this.m22,
-      b.m10 * this.m00 + b.m11 * this.m10 + b.m12 * this.m20,
-      b.m10 * this.m01 + b.m11 * this.m11 + b.m12 * this.m21,
-      b.m10 * this.m02 + b.m11 * this.m12 + b.m12 * this.m22,
-      b.m20 * this.m00 + b.m21 * this.m10 + b.m22 * this.m20,
-      b.m20 * this.m01 + b.m21 * this.m11 + b.m22 * this.m21,
-      b.m20 * this.m02 + b.m21 * this.m12 + b.m22 * this.m22
-    ]);
+  [import_types13.NodeJSCustomInspect]() {
+    return `Triangle <${this.toString()}>`;
   }
-  translate(...args) {
-    const vec = Vec2.resolveArgs(args);
-    return this.multiply([
-      1,
-      0,
-      0,
-      0,
-      1,
-      0,
-      vec.x,
-      vec.y,
-      1
-    ]);
+};
+var Triangle2D = class extends Triangle {
+  get a() {
+    return Vec2.fromPoints(this.B, this.C).length();
   }
-  rotate(angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
-    return this.multiply([
-      c,
-      -s,
-      0,
-      s,
-      c,
-      0,
-      0,
-      0,
-      1
-    ]);
+  get b() {
+    return Vec2.fromPoints(this.A, this.C).length();
   }
-  scale(...args) {
-    const vec = Vec2.resolve(args);
-    return this.multiply([
-      vec.x,
-      0,
-      0,
-      0,
-      vec.y,
-      0,
-      0,
-      0,
-      1
-    ]);
+  get c() {
+    return Vec2.fromPoints(this.A, this.B).length();
   }
-  determinant() {
-    return this.m00 * this.m11 * this.m22 - this.m21 * this.m12 - this.m01 * this.m10 * this.m22 - this.m12 * this.m20 + this.m02 * this.m10 * this.m21 - this.m11 * this.m20;
+};
+var Triangle3D = class extends Triangle {
+  get a() {
+    return Vec3.fromPoints(this.B, this.C).length();
   }
-  inverse() {
-    const det = this.determinant();
-    return new _Mat3([
-      (this.m11 * this.m22 - this.m21 * this.m12) * det,
-      (this.m02 * this.m21 - this.m01 * this.m22) * det,
-      (this.m01 * this.m12 - this.m02 * this.m11) * det,
-      (this.m12 * this.m20 - this.m10 * this.m22) * det,
-      (this.m00 * this.m22 - this.m02 * this.m20) * det,
-      (this.m10 * this.m02 - this.m00 * this.m12) * det,
-      (this.m10 * this.m21 - this.m20 * this.m11) * det,
-      (this.m20 * this.m01 - this.m00 * this.m21) * det,
-      (this.m00 * this.m11 - this.m10 * this.m01) * det
-    ]);
+  get b() {
+    return Vec3.fromPoints(this.A, this.C).length();
   }
-  toMat4() {
-    return [
-      this.m00,
-      this.m01,
-      this.m02,
-      0,
-      this.m10,
-      this.m11,
-      this.m12,
-      0,
-      this.m20,
-      this.m20,
-      this.m22,
-      0,
-      0,
-      0,
-      0,
-      1
-    ];
+  get c() {
+    return Vec3.fromPoints(this.A, this.B).length();
   }
 };
 
-// source/matrices/mat4.ts
-var Mat4 = class _Mat4 {
+// source/matrices/mat3.ts
+var import_types14 = require("@ntf/types");
+var Mat3 = class _Mat3 {
   _raw;
   get m00() {
     return this._raw[0];
@@ -1795,220 +2168,116 @@ var Mat4 = class _Mat4 {
   set m02(val) {
     this._raw[2] = val;
   }
-  get m03() {
-    return this._raw[3];
-  }
-  set m03(val) {
-    this._raw[3] = val;
-  }
   get m10() {
-    return this._raw[4];
+    return this._raw[3];
   }
   set m10(val) {
-    this._raw[4] = val;
+    this._raw[3] = val;
   }
   get m11() {
-    return this._raw[5];
+    return this._raw[4];
   }
   set m11(val) {
-    this._raw[5] = val;
+    this._raw[4] = val;
   }
   get m12() {
-    return this._raw[6];
+    return this._raw[5];
   }
   set m12(val) {
-    this._raw[6] = val;
-  }
-  get m13() {
-    return this._raw[7];
-  }
-  set m13(val) {
-    this._raw[7] = val;
+    this._raw[5] = val;
   }
   get m20() {
-    return this._raw[8];
+    return this._raw[6];
   }
   set m20(val) {
-    this._raw[8] = val;
+    this._raw[6] = val;
   }
   get m21() {
-    return this._raw[9];
+    return this._raw[7];
   }
   set m21(val) {
-    this._raw[9] = val;
+    this._raw[7] = val;
   }
   get m22() {
-    return this._raw[10];
+    return this._raw[8];
   }
   set m22(val) {
-    this._raw[10] = val;
-  }
-  get m23() {
-    return this._raw[11];
-  }
-  set m23(val) {
-    this._raw[11] = val;
-  }
-  get m30() {
-    return this._raw[12];
-  }
-  set m30(val) {
-    this._raw[12] = val;
-  }
-  get m31() {
-    return this._raw[13];
-  }
-  set m31(val) {
-    this._raw[13] = val;
-  }
-  get m32() {
-    return this._raw[14];
-  }
-  set m32(val) {
-    this._raw[14] = val;
-  }
-  get m33() {
-    return this._raw[15];
-  }
-  set m33(val) {
-    this._raw[15] = val;
+    this._raw[8] = val;
   }
   static resolve(a) {
     const value = this.cast(a);
     if (typeof value != "undefined")
       return value;
-    throw new ResolveError("Mat4", a);
+    throw new ResolveError("Mat3", a);
+  }
+  static resolveArgs(args) {
+    if ((0, import_types14.isFixedTypeArray)(args, import_types14.isValidNumber, 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, 16)) {
+    if ((0, import_types14.isFixedTypeArray)(a, import_types14.isValidNumber, 9)) {
       return new this(a);
     }
-    if (check_array(a, void 0, 4)) {
-      const row0 = a[0], row1 = a[1], row2 = a[2], row3 = a[3];
-      if (check_number_array(row0, 4) && check_number_array(row1, 4) && check_number_array(row2, 4) && check_number_array(row3, 4))
+    if ((0, import_types14.isFixedArray)(a, 3)) {
+      const row0 = a[0], row1 = a[1], row2 = a[2];
+      if ((0, import_types14.isFixedTypeArray)(row0, import_types14.isValidNumber, 3) && (0, import_types14.isFixedTypeArray)(row1, import_types14.isValidNumber, 3) && (0, import_types14.isFixedTypeArray)(row2, import_types14.isValidNumber, 3))
         return new this([
           row0[0],
           row0[1],
           row0[2],
-          row0[3],
           row1[0],
           row1[1],
           row1[2],
-          row1[3],
           row2[0],
           row2[1],
-          row2[2],
-          row2[3],
-          row3[0],
-          row3[1],
-          row3[2],
-          row3[3]
+          row2[2]
         ]);
     }
-    if (check_string(a)) {
+    if ((0, import_types14.isValidString)(a)) {
       const parts = a.split(",");
-      if (check_string_array(parts, 16))
+      if ((0, import_types14.isFixedTypeArray)(parts, import_types14.isValidString, 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, "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 ((0, import_types14.hasObjectProperty)(a, "toMat3", "function"))
+      return this.cast(a.toMat3());
+    if ((0, import_types14.hasObjectProperty)(a, "m00", "number") && (0, import_types14.hasObjectProperty)(a, "m01", "number") && (0, import_types14.hasObjectProperty)(a, "m02", "number") && (0, import_types14.hasObjectProperty)(a, "m10", "number") && (0, import_types14.hasObjectProperty)(a, "m11", "number") && (0, import_types14.hasObjectProperty)(a, "m12", "number") && (0, import_types14.hasObjectProperty)(a, "m20", "number") && (0, import_types14.hasObjectProperty)(a, "m21", "number") && (0, import_types14.hasObjectProperty)(a, "m22", "number"))
       return new this([
         a.m00,
         a.m01,
         a.m02,
-        a.m03,
         a.m10,
-        a.m11,
-        a.m12,
-        a.m13,
-        a.m20,
-        a.m21,
-        a.m22,
-        a.m23,
-        a.m30,
-        a.m31,
-        a.m32,
-        a.m33
-      ]);
-    if (check_number(a)) {
-      return new this([a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a]);
-    }
-    return void 0;
-  }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
-  }
-  static orthographic(left, right, bottom, top, near, far) {
-    return new this([
-      2 / (right - left),
-      0,
-      0,
-      0,
-      0,
-      2 / (top - bottom),
-      0,
-      0,
-      0,
-      0,
-      2 / (near - far),
-      0,
-      (left + right) / (left - right),
-      (bottom + top) / (bottom - top),
-      (near + far) / (near - far),
-      1
-    ]);
+        a.m11,
+        a.m12,
+        a.m20,
+        a.m21,
+        a.m22
+      ]);
+    if ((0, import_types14.isValidNumber)(a)) {
+      return new this([a, a, a, a, a, a, a, a, a]);
+    }
+    return void 0;
   }
-  static perspective(fov, aspect, near, far) {
-    const f = Math.tan(Math.PI * 0.5 - 0.5 * fov);
-    const rangeInv = 1 / (near - far);
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  static projection(width, height) {
     return new this([
-      f / aspect,
-      0,
-      0,
-      0,
-      0,
-      f,
+      2 / width,
       0,
       0,
       0,
+      -2 / height,
       0,
-      (near + far) * rangeInv,
       -1,
-      0,
-      0,
-      near * far * rangeInv * 2,
-      0
-    ]);
-  }
-  static pointAt(position, target, up) {
-    const newForward = Vec3.resolve(target).subtract(position).normalize();
-    const a = newForward.multiply(Vec3.resolve(up).dot(newForward));
-    const newUp = Vec3.resolve(up).subtract(a).normalize();
-    const newRight = newUp.cross(newForward);
-    const pos = Vec3.resolve(position);
-    return new this([
-      newRight.x,
-      newRight.y,
-      newRight.z,
-      0,
-      newUp.x,
-      newUp.y,
-      newUp.z,
-      0,
-      newForward.x,
-      newForward.y,
-      newForward.z,
-      0,
-      pos.x,
-      pos.y,
-      pos.z,
+      1,
       1
     ]);
   }
-  constructor(init = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]) {
-    if (!check_number_array(init, 16))
-      throw new TypeError("expected a number array with 16 elements");
+  constructor(init = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
+    (0, import_types14.checkFixedTypeArray)(init, import_types14.isValidNumber, 9);
     this._raw = init;
   }
   toArray() {
@@ -2016,27 +2285,19 @@ var Mat4 = class _Mat4 {
       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
+      this.m22
     ];
   }
   toNestetArray() {
     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]
+      [this.m00, this.m01, this.m02],
+      [this.m10, this.m11, this.m12],
+      [this.m20, this.m21, this.m22]
     ];
   }
   toJSON() {
@@ -2044,835 +2305,900 @@ var Mat4 = class _Mat4 {
       m00: this.m00,
       m01: this.m01,
       m02: this.m02,
-      m03: this.m03,
       m10: this.m10,
       m11: this.m11,
       m12: this.m12,
-      m13: this.m13,
       m20: this.m20,
       m21: this.m21,
-      m22: this.m22,
-      m23: this.m23,
-      m30: this.m20,
-      m31: this.m21,
-      m32: this.m22,
-      m33: this.m23
+      m22: this.m22
     };
   }
   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}`;
+    return `${this.m00},${this.m01},${this.m02},${this.m10},${this.m11},${this.m12},${this.m20},${this.m21},${this.m22}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Mat3";
+  }
+  [import_types14.NodeJSCustomInspect]() {
+    return `Mat3 <${this.toString()}>`;
   }
   clone() {
-    return new _Mat4([
+    return new _Mat3([
       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
+      this.m22
     ]);
   }
-  equals(mat) {
-    const m = _Mat4.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 = _Mat4.resolve(mat);
-    const m = new _Mat4();
+  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 = _Mat4.resolve(mat);
-    const m = new _Mat4();
+  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)) {
-      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);
-      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
+  multiply(...args) {
+    if ((0, import_types14.isFixedTypeArray)(args, import_types14.isValidNumber, 1))
+      return new _Mat3([
+        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]
       ]);
-    }
-    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
-      );
-      if (vec.w != 0)
-        return vec.divide(vec.w);
-      return vec;
-    }
-    throw new ResolveError("Mat4 or Vec3 or number", 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,
+      b.m00 * this.m02 + b.m01 * this.m12 + b.m02 * this.m22,
+      b.m10 * this.m00 + b.m11 * this.m10 + b.m12 * this.m20,
+      b.m10 * this.m01 + b.m11 * this.m11 + b.m12 * this.m21,
+      b.m10 * this.m02 + b.m11 * this.m12 + b.m12 * this.m22,
+      b.m20 * this.m00 + b.m21 * this.m10 + b.m22 * this.m20,
+      b.m20 * this.m01 + b.m21 * this.m11 + b.m22 * this.m21,
+      b.m20 * this.m02 + b.m21 * this.m12 + b.m22 * this.m22
+    ]);
   }
   translate(...args) {
-    const vec = Vec3.resolveArgs(args);
+    const vec = Vec2.resolveArgs(args);
     return this.multiply([
       1,
       0,
       0,
       0,
-      0,
-      1,
-      0,
-      0,
-      0,
-      0,
       1,
       0,
       vec.x,
       vec.y,
-      vec.z,
-      1
-    ]);
-  }
-  rotateX(angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
-    return this.multiply([
-      1,
-      0,
-      0,
-      0,
-      0,
-      c,
-      s,
-      0,
-      0,
-      -s,
-      c,
-      0,
-      0,
-      0,
-      0,
       1
     ]);
   }
-  rotateY(angle) {
+  rotate(angle) {
     const c = Math.cos(angle);
     const s = Math.sin(angle);
     return this.multiply([
       c,
-      0,
       -s,
       0,
-      0,
-      1,
-      0,
-      0,
-      s,
-      0,
-      c,
-      0,
-      0,
-      0,
-      0,
-      1
-    ]);
-  }
-  rotateZ(angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
-    return this.multiply([
-      c,
       s,
-      0,
-      0,
-      -s,
       c,
       0,
       0,
       0,
-      0,
-      1,
-      0,
-      0,
-      0,
-      0,
       1
     ]);
   }
-  rotate(...args) {
-    const vec = Vec3.resolveArgs(args);
-    return this.rotateX(vec.x).rotateY(vec.y).rotateZ(vec.z);
-  }
   scale(...args) {
-    const vec = Vec3.resolveArgs(args);
+    const vec = Vec2.resolve(args);
     return this.multiply([
       vec.x,
       0,
       0,
       0,
-      0,
       vec.y,
       0,
       0,
       0,
-      0,
-      vec.z,
-      0,
-      0,
-      0,
-      0,
       1
     ]);
   }
+  determinant() {
+    return this.m00 * this.m11 * this.m22 - this.m21 * this.m12 - this.m01 * this.m10 * this.m22 - this.m12 * this.m20 + this.m02 * this.m10 * this.m21 - this.m11 * this.m20;
+  }
   inverse() {
-    return new _Mat4([
+    const det = this.determinant();
+    return new _Mat3([
+      (this.m11 * this.m22 - this.m21 * this.m12) * det,
+      (this.m02 * this.m21 - this.m01 * this.m22) * det,
+      (this.m01 * this.m12 - this.m02 * this.m11) * det,
+      (this.m12 * this.m20 - this.m10 * this.m22) * det,
+      (this.m00 * this.m22 - this.m02 * this.m20) * det,
+      (this.m10 * this.m02 - this.m00 * this.m12) * det,
+      (this.m10 * this.m21 - this.m20 * this.m11) * det,
+      (this.m20 * this.m01 - this.m00 * this.m21) * det,
+      (this.m00 * this.m11 - this.m10 * this.m01) * det
+    ]);
+  }
+  toMat4() {
+    return [
       this.m00,
-      this.m10,
-      this.m20,
-      0,
       this.m01,
-      this.m11,
-      this.m21,
-      0,
       this.m02,
+      0,
+      this.m10,
+      this.m11,
       this.m12,
+      0,
+      this.m20,
+      this.m20,
       this.m22,
       0,
-      -(this.m30 * this.m00 + this.m31 * this.m10 + this.m32 * this.m20),
-      -(this.m30 * this.m01 + this.m31 * this.m11 + this.m32 * this.m21),
-      -(this.m30 * this.m02 + this.m31 * this.m12 + this.m32 * this.m22),
+      0,
+      0,
+      0,
       1
-    ]);
+    ];
+  }
+};
+
+// source/matrices/mat4.ts
+var import_types15 = require("@ntf/types");
+var Mat4 = class _Mat4 {
+  _raw;
+  get m00() {
+    return this._raw[0];
+  }
+  set m00(val) {
+    this._raw[0] = val;
+  }
+  get m01() {
+    return this._raw[1];
+  }
+  set m01(val) {
+    this._raw[1] = val;
+  }
+  get m02() {
+    return this._raw[2];
+  }
+  set m02(val) {
+    this._raw[2] = val;
   }
-  toMat3() {
-    return [
-      this.m00,
-      this.m01,
-      this.m03,
-      this.m10,
-      this.m11,
-      this.m13,
-      this.m30,
-      this.m31,
-      this.m33
-    ];
+  get m03() {
+    return this._raw[3];
   }
-};
-
-// source/color.ts
-function _hex_to_array(hex) {
-  if (!check_hex(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];
-}
-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) {
-  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 {
-  _red;
-  get red() {
-    return this._red;
+  set m03(val) {
+    this._raw[3] = val;
   }
-  set red(val) {
-    this._red = clamp(val, 0, 1);
+  get m10() {
+    return this._raw[4];
   }
-  _green;
-  get green() {
-    return this._green;
+  set m10(val) {
+    this._raw[4] = val;
   }
-  set green(val) {
-    this._green = clamp(val, 0, 1);
+  get m11() {
+    return this._raw[5];
   }
-  _blue;
-  get blue() {
-    return this._blue;
+  set m11(val) {
+    this._raw[5] = val;
   }
-  set blue(val) {
-    this._blue = clamp(val, 0, 1);
+  get m12() {
+    return this._raw[6];
   }
-  _alpha;
-  get alpha() {
-    return this._alpha;
+  set m12(val) {
+    this._raw[6] = val;
   }
-  set alpha(val) {
-    this._alpha = clamp(val, 0, 1);
+  get m13() {
+    return this._raw[7];
   }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("RGBAColor", a);
+  set m13(val) {
+    this._raw[7] = val;
   }
-  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], 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)) {
-      const hex = a.toString(16);
-      const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
-      return this.cast(convert(a));
-    }
-    if (check_string(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))
-          return this.cast(parts.map((v) => parseInt(v) / 255));
-      }
-      return this.cast(_hex_to_array(a));
-    }
-    return void 0;
+  get m20() {
+    return this._raw[8];
   }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
+  set m20(val) {
+    this._raw[8] = val;
   }
-  constructor(red, green, blue, alpha = 1) {
-    this._red = clamp(red, 0, 1);
-    this._green = clamp(green, 0, 1);
-    this._blue = clamp(blue, 0, 1);
-    this._alpha = clamp(alpha, 0, 1);
+  get m21() {
+    return this._raw[9];
   }
-  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);
+  set m21(val) {
+    this._raw[9] = val;
   }
-  toJSON(withAlpha = false) {
-    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);
+  get m22() {
+    return this._raw[10];
   }
-  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);
+  set m22(val) {
+    this._raw[10] = val;
   }
-  toHSL(withAlpha = true) {
-    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);
-    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);
-    if (max == green)
-      return new HSLColor(((blue - red) / d + 2) / 6, saturation, luminace);
-    if (max == blue)
-      return new HSLColor(((red - green) / d + 4) / 6, saturation, luminace);
-    return new HSLColor(0, saturation, luminace, withAlpha ? this.alpha : void 0);
+  get m23() {
+    return this._raw[11];
   }
-  invert(withAlpha = false) {
-    return new _RGBAColor(
-      1 - this.red,
-      1 - this.green,
-      1 - this.blue,
-      withAlpha ? 1 - this.alpha : this.alpha
-    );
+  set m23(val) {
+    this._raw[11] = val;
   }
-};
-var HSLColor = class _HSLColor {
-  _hue;
-  get hue() {
-    return this._hue;
+  get m30() {
+    return this._raw[12];
   }
-  set hue(val) {
-    this._hue = clamp(val, 0, 1);
+  set m30(val) {
+    this._raw[12] = val;
   }
-  _saturation;
-  get saturation() {
-    return this._saturation;
+  get m31() {
+    return this._raw[13];
   }
-  set saturation(val) {
-    this._saturation = clamp(val, 0, 1);
+  set m31(val) {
+    this._raw[13] = val;
   }
-  _luminace;
-  get luminace() {
-    return this._luminace;
+  get m32() {
+    return this._raw[14];
   }
-  set luminace(val) {
-    this._luminace = clamp(val, 0, 1);
+  set m32(val) {
+    this._raw[14] = val;
   }
-  _alpha;
-  get alpha() {
-    return this._alpha;
+  get m33() {
+    return this._raw[15];
   }
-  set alpha(val) {
-    this._alpha = clamp(val, 0, 1);
+  set m33(val) {
+    this._raw[15] = val;
   }
   static resolve(a) {
     const value = this.cast(a);
     if (typeof value != "undefined")
       return value;
-    throw new ResolveError("HSLColor", a);
+    throw new ResolveError("Mat4", a);
+  }
+  static resolveArgs(args) {
+    if ((0, import_types15.isFixedTypeArray)(args, import_types15.isValidNumber, 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, 3) || check_number_array(a, 4))
-      return new this(a[0], a[1], a[2], a[3]);
-    if (has_property(a, "hue", "number") && has_property(a, "saturation", "number") && has_property(a, "luminace", "number"))
-      return new this(a.hue, a.saturation, a.luminace, has_property(a, "alpha", "number") ? a.alpha : void 0);
-    if (check_number(a)) {
-      const hex = a.toString(16);
-      const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
-      return this.cast(convert(a));
+    if ((0, import_types15.isFixedTypeArray)(a, import_types15.isValidNumber, 16)) {
+      return new this(a);
     }
-    if (check_string(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))
-          return this.cast(parts.map((v) => parseInt(v) / 255));
-      }
-      return this.cast(_hex_to_array(a));
+    if ((0, import_types15.isFixedArray)(a, 4)) {
+      const row0 = a[0], row1 = a[1], row2 = a[2], row3 = a[3];
+      if ((0, import_types15.isFixedTypeArray)(row0, import_types15.isValidNumber, 4) && (0, import_types15.isFixedTypeArray)(row1, import_types15.isValidNumber, 4) && (0, import_types15.isFixedTypeArray)(row2, import_types15.isValidNumber, 4) && (0, import_types15.isFixedTypeArray)(row3, import_types15.isValidNumber, 4))
+        return new this([
+          row0[0],
+          row0[1],
+          row0[2],
+          row0[3],
+          row1[0],
+          row1[1],
+          row1[2],
+          row1[3],
+          row2[0],
+          row2[1],
+          row2[2],
+          row2[3],
+          row3[0],
+          row3[1],
+          row3[2],
+          row3[3]
+        ]);
     }
-    return void 0;
-  }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
-  }
-  constructor(hue, saturation, luminace, alpha = 1) {
-    if (!check_number(hue))
-      throw new TypeError("expected number for hue");
-    if (!check_number(saturation))
-      throw new TypeError("expected number for saturation");
-    if (!check_number(luminace))
-      throw new TypeError("expected number for luminace");
-    if (!check_number(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);
-  }
-  toJSON(withAlpha = false) {
-    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);
-  }
-  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);
-  }
-  toRGB(withAlpha = true) {
-    if (this.saturation == 0)
-      return new RGBAColor(this.luminace * 255, this.luminace * 255, this.luminace * 255, withAlpha ? this.alpha : void 0);
-    const q = this.luminace < 0.5 ? this.luminace * (1 + this.saturation) : this.luminace + this.saturation - this.luminace * this.saturation;
-    const p = 2 * this.luminace - q;
-    function _hue_2_rgb(t) {
-      let _t = t;
-      if (_t < 0)
-        _t++;
-      if (_t > 1)
-        _t--;
-      if (_t < 1 / 6)
-        return p + (q - p) * 6 * _t;
-      if (_t < 1 / 2)
-        return q;
-      if (_t < 2 / 3)
-        return p + (q - p) * (2 / 3 - _t) * 6;
-      return p;
+    if ((0, import_types15.isValidString)(a)) {
+      const parts = a.split(",");
+      if ((0, import_types15.isFixedTypeArray)(parts, import_types15.isValidString, 16))
+        return this.cast(parts.map((i) => parseFloat(i)));
+    }
+    if ((0, import_types15.hasObjectProperty)(a, "toMat4", "function"))
+      return this.cast(a.toMat4());
+    if ((0, import_types15.hasObjectProperty)(a, "m00", "number") && (0, import_types15.hasObjectProperty)(a, "m01", "number") && (0, import_types15.hasObjectProperty)(a, "m02", "number") && (0, import_types15.hasObjectProperty)(a, "m03", "number") && (0, import_types15.hasObjectProperty)(a, "m10", "number") && (0, import_types15.hasObjectProperty)(a, "m11", "number") && (0, import_types15.hasObjectProperty)(a, "m12", "number") && (0, import_types15.hasObjectProperty)(a, "m13", "number") && (0, import_types15.hasObjectProperty)(a, "m20", "number") && (0, import_types15.hasObjectProperty)(a, "m21", "number") && (0, import_types15.hasObjectProperty)(a, "m22", "number") && (0, import_types15.hasObjectProperty)(a, "m23", "number") && (0, import_types15.hasObjectProperty)(a, "m30", "number") && (0, import_types15.hasObjectProperty)(a, "m31", "number") && (0, import_types15.hasObjectProperty)(a, "m32", "number") && (0, import_types15.hasObjectProperty)(a, "m33", "number"))
+      return new this([
+        a.m00,
+        a.m01,
+        a.m02,
+        a.m03,
+        a.m10,
+        a.m11,
+        a.m12,
+        a.m13,
+        a.m20,
+        a.m21,
+        a.m22,
+        a.m23,
+        a.m30,
+        a.m31,
+        a.m32,
+        a.m33
+      ]);
+    if ((0, import_types15.isValidNumber)(a)) {
+      return new this([a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a]);
     }
-    return new RGBAColor(_hue_2_rgb(this.hue + 1 / 3) * 255, _hue_2_rgb(this.hue) * 255, _hue_2_rgb(this.hue - 1 / 3) * 255, withAlpha ? this.alpha : void 0);
-  }
-  invert(withAlpha = false) {
-    return new _HSLColor(
-      1 - this.hue,
-      1 - this.saturation,
-      1 - this.luminace,
-      withAlpha ? 1 - this.alpha : this.alpha
-    );
+    return void 0;
   }
-};
-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;
-}
-
-// source/quaternion.ts
-var Quaternion = class _Quaternion {
-  w;
-  x;
-  y;
-  z;
   static is(a) {
     return typeof this.cast(a) != "undefined";
   }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("Quaternion", a);
-  }
-  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, "w", "number") && has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "z", "number"))
-      return new this(a.w, a.x, a.y, a.z);
-    if (check_string(a)) {
-      const parts = a.replaceAll(" ", "").split("+");
-      if (check_string_array(parts, 4)) {
-        const [sw, sxi, syj, szk] = parts;
-        if (sxi.endsWith("i") && syj.endsWith("j") && szk.endsWith("k"))
-          return this.cast([
-            parseFloat(sw),
-            parseFloat(sxi.substring(0, sxi.length - 1)),
-            parseFloat(syj.substring(0, syj.length - 1)),
-            parseFloat(szk.substring(0, szk.length - 1))
-          ]);
-      }
-    }
-    return void 0;
+  static orthographic(...args) {
+    const bbox = (0, import_types15.isFixedTypeArray)(args, import_types15.isValidNumber, 6) ? new BoundingBox(args[0], args[1], args[2], args[3]) : BoundingBox.resolve(args[0]);
+    const near = (0, import_types15.isFixedTypeArray)(args, import_types15.isValidNumber, 6) ? args[4] : args[1];
+    const far = (0, import_types15.isFixedTypeArray)(args, import_types15.isValidNumber, 6) ? args[5] : args[2];
+    return new this([
+      2 / (bbox.right - bbox.left),
+      0,
+      0,
+      0,
+      0,
+      2 / (bbox.top - bbox.bottom),
+      0,
+      0,
+      0,
+      0,
+      2 / (near - far),
+      0,
+      (bbox.left + bbox.right) / (bbox.left - bbox.right),
+      (bbox.bottom + bbox.top) / (bbox.bottom - bbox.top),
+      (near + far) / (near - far),
+      1
+    ]);
   }
-  static fromAxisAngle(axis, angle) {
-    const vec = Vec3.resolve(axis);
-    const hangle = angle * 0.5;
-    const sin2 = Math.sin(hangle);
-    const cos2 = Math.cos(hangle);
-    const length = sin2 / Math.sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
-    return new this(cos2, vec.x * length, vec.y * length, vec.z * length);
+  static perspective(fov, aspect, near, far) {
+    const f = Math.tan(Math.PI * 0.5 - 0.5 * fov);
+    const rangeInv = 1 / (near - far);
+    return new this([
+      f / aspect,
+      0,
+      0,
+      0,
+      0,
+      f,
+      0,
+      0,
+      0,
+      0,
+      (near + far) * rangeInv,
+      -1,
+      0,
+      0,
+      near * far * rangeInv * 2,
+      0
+    ]);
   }
-  static fromEuler(...args) {
-    const vec = Vec3.resolveArgs(args);
-    const x2 = vec.x * 0.5, y2 = vec.y * 0.5, z2 = vec.z * 0.5;
-    const cx = Math.cos(x2), cy = Math.cos(y2), cz = Math.cos(z2);
-    const sx = Math.sin(x2), sy = Math.sin(y2), sz = Math.sin(z2);
-    return new _Quaternion(
-      cx * cy * cz - sx * sy * sz,
-      sx * cy * cz - sy * sz * cx,
-      sy * cx * cz - sx * sz * cy,
-      sx * sy * cz + sz * cx * cy
-    );
+  static pointAt(position, target, up) {
+    const newForward = Vec3.resolve(target).subtract(position).normalize();
+    const a = newForward.multiply(Vec3.resolve(up).dot(newForward));
+    const newUp = Vec3.resolve(up).subtract(a).normalize();
+    const newRight = newUp.cross(newForward);
+    const pos = Vec3.resolve(position);
+    return new this([
+      newRight.x,
+      newRight.y,
+      newRight.z,
+      0,
+      newUp.x,
+      newUp.y,
+      newUp.z,
+      0,
+      newForward.x,
+      newForward.y,
+      newForward.z,
+      0,
+      pos.x,
+      pos.y,
+      pos.z,
+      1
+    ]);
   }
-  constructor(w = 0, x = 0, y = 0, z = 0) {
-    if (!check_number(w))
-      throw new TypeError("expected number for w");
-    if (!check_number(x))
-      throw new TypeError("expected number for x");
-    if (!check_number(y))
-      throw new TypeError("expected number for x");
-    if (!check_number(z))
-      throw new TypeError("expected number for w");
-    this.w = w;
-    this.x = x;
-    this.y = y;
-    this.z = z;
+  constructor(init = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]) {
+    (0, import_types15.checkFixedTypeArray)(init, import_types15.isValidNumber, 16);
+    this._raw = init;
   }
   toArray() {
-    return [this.w, this.x, this.y, this.z];
+    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
+    ];
   }
-  toString() {
-    return `${this.w} + ${this.x}i + ${this.y}j + ${this.z}k`;
+  toNestetArray() {
+    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]
+    ];
   }
   toJSON() {
     return {
-      w: this.w,
-      x: this.x,
-      y: this.y,
-      z: this.z
+      m00: this.m00,
+      m01: this.m01,
+      m02: this.m02,
+      m03: this.m03,
+      m10: this.m10,
+      m11: this.m11,
+      m12: this.m12,
+      m13: this.m13,
+      m20: this.m20,
+      m21: this.m21,
+      m22: this.m22,
+      m23: this.m23,
+      m30: this.m20,
+      m31: this.m21,
+      m32: this.m22,
+      m33: this.m23
     };
   }
-  clone() {
-    return new _Quaternion(this.w, this.x, this.y, this.z);
-  }
-  add(a) {
-    const quat = _Quaternion.resolve(a);
-    return new _Quaternion(
-      this.w + quat.w,
-      this.x + quat.x,
-      this.y + quat.y,
-      this.z + quat.z
-    );
-  }
-  offset(a) {
-    const quat = _Quaternion.resolve(a);
-    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);
-    return new _Quaternion(
-      this.w - quat.w,
-      this.x - quat.x,
-      this.y - quat.y,
-      this.z - quat.z
-    );
-  }
-  negative() {
-    return new _Quaternion(-this.w, -this.x, -this.y, -this.z);
-  }
-  length(sqrt = true) {
-    const value = this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
-    return sqrt ? Math.sqrt(value) : value;
-  }
-  normalize() {
-    let length = this.length();
-    if (length < EPSILON)
-      return new _Quaternion();
-    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);
-    return new _Quaternion(
-      this.w * quat.w - this.x * quat.x - this.y * quat.y - this.z * quat.z,
-      this.w * quat.x + this.x * quat.w + this.y * quat.z - this.z * quat.y,
-      this.w * quat.y + this.y * quat.w + this.z * quat.x - this.x * quat.z,
-      this.w * quat.z + this.z * quat.w + this.x * quat.y - this.y * quat.x
-    );
-  }
-  multiplyVector(...args) {
-    const vec = Vec3.resolveArgs(args);
-    const ix = this.w * vec.x + this.y * vec.y - this.z * vec.y;
-    const iy = this.w * vec.y + this.z * vec.x - this.x * vec.z;
-    const iz = this.w * vec.z + this.x * vec.y - this.y * vec.x;
-    const iw = -this.w * vec.x - this.y * vec.y - this.z * vec.z;
-    return new Vec3(
-      ix * this.w + iw * -this.x + iy * -this.z - iz * -this.y,
-      iy * this.w + iw * -this.y + iz * -this.x - ix * -this.z,
-      iz * this.w + iw * -this.z + ix * -this.y - iy * -this.x
-    );
+  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}`;
   }
-  scale(scalar) {
-    return new _Quaternion(this.w * scalar, this.x * scalar, this.y * scalar, this.z * scalar);
+  get [Symbol.toStringTag]() {
+    return "Mat4";
   }
-  dot(a) {
-    const quat = _Quaternion.resolve(a);
-    return this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z;
+  [import_types15.NodeJSCustomInspect]() {
+    return `Mat4 <${this.toString()}>`;
   }
-  inverse() {
-    let length = this.length(false);
-    if (length == 0)
-      return new _Quaternion();
-    length = 1 / length;
-    return new _Quaternion(this.w * length, -this.x * length, -this.y * length, -this.z * length);
+  clone() {
+    return new _Mat4([
+      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
+    ]);
   }
-  divide(a) {
-    const quat = _Quaternion.resolve(a);
-    let length = quat.length(false);
-    if (length == 0) return new _Quaternion();
-    length = 1 / length;
-    return new _Quaternion(
-      (this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z) * length,
-      (this.x * quat.w - this.w * quat.x - this.y * quat.z + this.z * quat.y) * length,
-      (this.y * quat.w - this.w * quat.y - this.z * quat.x + this.x * quat.z) * length,
-      (this.z * quat.w - this.w * quat.z - this.x * quat.y + this.y * quat.x) * length
-    );
+  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;
   }
-  conjugate() {
-    return new _Quaternion(this.w, -this.x, -this.y, -this.z);
+  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;
   }
-  exp() {
-    const length = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-    const exp = Math.exp(this.w);
-    const scale = exp * Math.sin(length) / length;
-    if (length == 0)
-      return new _Quaternion(exp);
-    return new _Quaternion(
-      exp * Math.cos(length),
-      this.x * scale,
-      this.y * scale,
-      this.z * scale
-    );
+  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;
   }
-  log() {
-    if (this.x == 0 && this.z == 0)
-      return new _Quaternion(log_hypot(this.w, this.x), Math.atan2(this.x, this.w));
-    const length = this.length(false);
-    const length2 = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-    const scale = Math.atan2(length2, this.w) / length;
-    return new _Quaternion(Math.log(length) * 0.5, this.x * scale, this.y * scale, this.z * scale);
+  multiply(...args) {
+    if ((0, import_types15.isFixedTypeArray)(args, import_types15.isValidNumber, 1)) {
+      const scalar = args[0];
+      return new _Mat4([
+        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
+      ]);
+    }
+    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 (result.w != 0)
+        return result.divide(result.w);
+      return result;
+    }
+    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
+    ]);
   }
-  toVector() {
-    return new Vec3(this.x, this.y, this.z, this.w);
+  translate(...args) {
+    const vec = Vec3.resolveArgs(args);
+    return this.multiply([
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      vec.x,
+      vec.y,
+      vec.z,
+      1
+    ]);
   }
-  toAxisAngle() {
-    const sin2 = 1 - this.w * this.w;
-    if (sin2 > EPSILON)
-      return new Vec3(this.x, this.y, this.z, 0);
-    const isin = 1 / Math.sqrt(sin2);
-    const angle = 2 * Math.acos(this.w);
-    return new Vec3(this.x * isin, this.y * isin, this.z * isin, angle);
+  rotateX(angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return this.multiply([
+      1,
+      0,
+      0,
+      0,
+      0,
+      c,
+      s,
+      0,
+      0,
+      -s,
+      c,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
   }
-  toEuler() {
-    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)),
-      -Math.atan2(2 * (this.x * this.y - this.w * this.z), 1 - 2 * (this.y * this.y + this.z * this.z))
-    );
+  rotateY(angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return this.multiply([
+      c,
+      0,
+      -s,
+      0,
+      0,
+      1,
+      0,
+      0,
+      s,
+      0,
+      c,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
   }
-  toMat3() {
-    return new Mat3([
-      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),
-      2 * (this.x * this.y + this.w * this.z),
-      1 - 2 * (this.x * this.x + this.z * this.z),
-      2 * (this.y * this.z - this.w * this.x),
-      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)
+  rotateZ(angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return this.multiply([
+      c,
+      s,
+      0,
+      0,
+      -s,
+      c,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1
     ]);
   }
-  toMat4() {
-    return new Mat4([
-      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),
+  rotate(...args) {
+    const vec = Vec3.resolveArgs(args);
+    return this.rotateX(vec.x).rotateY(vec.y).rotateZ(vec.z);
+  }
+  scale(...args) {
+    const vec = Vec3.resolveArgs(args);
+    return this.multiply([
+      vec.x,
       0,
-      2 * (this.x * this.y + this.w * this.z),
-      1 - 2 * (this.x * this.x + this.z * this.z),
-      2 * (this.y * this.z - this.w * this.x),
       0,
-      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),
       0,
       0,
+      vec.y,
+      0,
+      0,
+      0,
+      0,
+      vec.z,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
+  }
+  inverse() {
+    return new _Mat4([
+      this.m00,
+      this.m10,
+      this.m20,
+      0,
+      this.m01,
+      this.m11,
+      this.m21,
       0,
+      this.m02,
+      this.m12,
+      this.m22,
       0,
+      -(this.m30 * this.m00 + this.m31 * this.m10 + this.m32 * this.m20),
+      -(this.m30 * this.m01 + this.m31 * this.m11 + this.m32 * this.m21),
+      -(this.m30 * this.m02 + this.m31 * this.m12 + this.m32 * this.m22),
       1
     ]);
   }
+  toMat3() {
+    return [
+      this.m00,
+      this.m01,
+      this.m03,
+      this.m10,
+      this.m11,
+      this.m13,
+      this.m30,
+      this.m31,
+      this.m33
+    ];
+  }
 };
 
+// source/color.ts
+var import_types16 = require("@ntf/types");
+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 ((0, import_types16.isFixedTypeArray)(args, import_types16.isValidNumber, 3) || (0, import_types16.isFixedTypeArray)(args, import_types16.isValidNumber, 4))
+      return resolve(args, preferHSL);
+    return resolve(args[0], preferHSL);
+  }
+  AnyColor2.resolveArgs = resolveArgs;
+})(AnyColor || (AnyColor = {}));
+
 // source/transform.ts
-var Transform = class {
+var import_types17 = require("@ntf/types");
+var Transform2D = class {
+  constructor(position, rotation, scale, parent) {
+    this.parent = parent;
+    (0, import_types17.checkValidNumber)(rotation);
+    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";
+  }
+  [import_types17.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";
+  }
+  [import_types17.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;
   }
 };