@ntf/math 1.4.0 → 1.4.1

package/dist/index.js

@@ -34,7 +34,6 @@ __export(index_exports, {
   Mat3: () => Mat3,
   Mat4: () => Mat4,
   MathFunction: () => MathFunction,
-  NodeJSCustomInspect: () => NodeJSCustomInspect,
   QuadFunction: () => QuadFunction,
   Quaternion: () => Quaternion,
   RGBA: () => RGBA,
@@ -48,22 +47,16 @@ __export(index_exports, {
   Triangle3D: () => Triangle3D,
   Vec2: () => Vec2,
   Vec3: () => Vec3,
-  checkArray: () => checkArray,
-  checkHex: () => checkHex,
-  checkNumber: () => checkNumber,
-  checkNumberArray: () => checkNumberArray,
-  checkString: () => checkString,
-  checkStringArray: () => checkStringArray,
   clamp: () => clamp,
   clampAngleDegree: () => clampAngleDegree,
   clampAngleRadian: () => clampAngleRadian,
   degreeToRadian: () => degreeToRadian,
   djb2: () => djb2,
   fnv1: () => fnv1,
-  getHexValue: () => getHexValue,
-  hasProperty: () => hasProperty,
   lerp: () => lerp,
   logHypot: () => logHypot,
+  numberToRGB: () => numberToRGB,
+  numberToRGBA: () => numberToRGBA,
   radianToDegree: () => radianToDegree,
   sdbm: () => sdbm,
   signCharacter: () => signCharacter
@@ -74,6 +67,9 @@ module.exports = __toCommonJS(index_exports);
 var MathFunction = class {
 };
 
+// source/algebra/linear.ts
+var import_types2 = require("@ntf/types");
+
 // source/common/sign.ts
 function signCharacter(num) {
   if (num == 0)
@@ -85,46 +81,6 @@ function signCharacter(num) {
   return void 0;
 }
 
-// source/common/types.ts
-function checkNumber(value) {
-  return value !== null && typeof value == "number" && !isNaN(value) && isFinite(value);
-}
-function getHexValue(string) {
-  let offset = 0;
-  if (string.startsWith("#") || string.startsWith("$"))
-    offset = 1;
-  if (string.startsWith("0x"))
-    offset = 2;
-  return string.substring(offset);
-}
-function checkHex(value) {
-  if (!checkString(value))
-    return false;
-  const hexValue = getHexValue(value).split("").map((char) => parseInt(char.toUpperCase(), 16));
-  return checkNumberArray(hexValue);
-}
-function checkString(value) {
-  return value !== null && typeof value == "string" && value.length > 0;
-}
-function checkArray(value, predicate, requiredLength) {
-  if (!Array.isArray(value)) return false;
-  if (typeof requiredLength == "number" && requiredLength !== value.length) return false;
-  for (const item of value)
-    if (typeof predicate == "function" && !predicate(item))
-      return false;
-  return true;
-}
-function checkNumberArray(value, requiredLength) {
-  return checkArray(value, checkNumber, requiredLength);
-}
-function checkStringArray(value, requiredLength) {
-  return checkArray(value, checkString, requiredLength);
-}
-function hasProperty(value, propertyName, type) {
-  return value !== null && typeof value == "object" && propertyName in value && typeof value[propertyName] == type;
-}
-var NodeJSCustomInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
-
 // source/common/error.ts
 var ResolveError = class extends Error {
   /**
@@ -139,6 +95,9 @@ var ResolveError = class extends Error {
   }
 };
 
+// source/vectors/vec2.ts
+var import_types = require("@ntf/types");
+
 // source/utils.ts
 function clamp(value, min, max) {
   if (value <= min)
@@ -176,26 +135,26 @@ var Vec2 = class _Vec2 {
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (checkNumberArray(a, 2) || checkNumberArray(a, 3))
-      return new this(a[0], a[1], checkNumber(a[2]) ? a[2] : void 0);
-    if (hasProperty(a, "toVec2", "function"))
+    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 (hasProperty(a, "x", "number") && hasProperty(a, "y", "number"))
-      return new this(a.x, a.y, hasProperty(a, "w", "number") ? a.w : void 0);
-    if (checkString(a)) {
+    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 (checkString(sxy)) {
+      if ((0, import_types.isValidString)(sxy)) {
         const parts = sxy.split(",");
-        if (checkStringArray(parts, 2))
-          return new this(parseFloat(parts[0]), parseFloat(parts[1]), checkString(sw) ? parseFloat(sw) : void 0);
+        if ((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 (checkNumber(a))
+    if ((0, import_types.isValidNumber)(a))
       return new this(a, a);
     return void 0;
   }
   static resolveArgs(args) {
-    if (checkNumberArray(args, 2))
+    if ((0, import_types.isFixedTypeArray)(args, import_types.isValidNumber, 2))
       return new this(args[0], args[1]);
     return this.resolve(args[0]);
   }
@@ -221,12 +180,9 @@ var Vec2 = class _Vec2 {
     return new this(1, 1);
   }
   constructor(x, y, w = 1) {
-    if (!checkNumber(x))
-      throw new TypeError("expected number for x");
-    if (!checkNumber(y))
-      throw new TypeError("expected number for y");
-    if (!checkNumber(w))
-      throw new TypeError("expected number for w");
+    (0, import_types.checkValidNumber)(x);
+    (0, import_types.checkValidNumber)(y);
+    (0, import_types.checkValidNumber)(w);
     this.x = x;
     this.y = y;
     this.w = w;
@@ -247,7 +203,7 @@ var Vec2 = class _Vec2 {
   get [Symbol.toStringTag]() {
     return "Vec2";
   }
-  [NodeJSCustomInspect]() {
+  [import_types.NodeJSCustomInspect]() {
     return `Vec2 <${this.toString()}>`;
   }
   toSize() {
@@ -329,7 +285,7 @@ var Vec2 = class _Vec2 {
     );
   }
   divide(...args) {
-    if (checkNumberArray(args, 1))
+    if ((0, import_types.isFixedTypeArray)(args, import_types.isValidNumber, 1))
       return new _Vec2(
         this.x / args[0],
         this.y / args[0]
@@ -414,17 +370,14 @@ var LinearFunction = class extends MathFunction {
    */
   constructor(m, b) {
     super();
-    if (!checkNumber(m))
-      throw new TypeError("expected number for m");
-    if (!checkNumber(b))
-      throw new TypeError("expected number for b");
+    (0, import_types2.checkValidNumber)(m);
+    (0, import_types2.checkValidNumber)(b);
     this.m = m;
     this.b = b;
   }
   get(x) {
-    if (!checkNumber(x))
-      throw new TypeError("expected number for x");
-    return this.m;
+    (0, import_types2.checkValidNumber)(x);
+    return this.m * x + this.b;
   }
   roots() {
     const x = -this.b / this.m;
@@ -441,12 +394,13 @@ var LinearFunction = class extends MathFunction {
   get [Symbol.toStringTag]() {
     return "LinearFunction";
   }
-  [NodeJSCustomInspect]() {
+  [import_types2.NodeJSCustomInspect]() {
     return `LinearFunction <${this.toString()}>`;
   }
 };
 
 // source/algebra/quad.ts
+var import_types3 = require("@ntf/types");
 var QuadFunction = class extends MathFunction {
   a;
   b;
@@ -456,21 +410,17 @@ var QuadFunction = class extends MathFunction {
   }
   constructor(a, b, c) {
     super();
-    if (!checkNumber(a))
-      throw new TypeError("expected number for a");
-    if (a == 0)
-      throw new TypeError("a cannot be 0");
-    if (!checkNumber(b))
-      throw new TypeError("expected number for b");
-    if (!checkNumber(c))
-      throw new TypeError("expected number for c");
+    (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) {
-    if (!checkNumber(x))
-      throw new TypeError("expected number for x");
+    (0, import_types3.checkValidNumber)(x);
     return this.a * x * x + this.b * x + this.c;
   }
   roots() {
@@ -501,1448 +451,1704 @@ var QuadFunction = class extends MathFunction {
   get [Symbol.toStringTag]() {
     return "QuadFunction";
   }
-  [NodeJSCustomInspect]() {
+  [import_types3.NodeJSCustomInspect]() {
     return `QuadFunction <${this.toString()}>`;
   }
 };
 
-// source/crypto/hash.ts
-var DJB2_OFFSET = 5381n;
-function djb2(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));
+// 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);
   }
-  return hash;
-}
-var FNV1_OFFSET = 14695981039346656037n;
-var FNV1_PRIME = 1099511628211n;
-function fnv1(value) {
-  const string = String(value);
-  let hash = FNV1_OFFSET;
-  for (let i = 0; i < string.length; i++) {
-    hash *= FNV1_PRIME;
-    hash ^= BigInt(string.charCodeAt(i));
+  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;
   }
-  return hash;
-}
-function sdbm(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;
+  static resolveArgs(args) {
+    if ((0, import_types4.isFixedTypeArray)(args, import_types4.isValidNumber, 3))
+      return new this(args[0], args[1], args[2]);
+    return this.resolve(args[0]);
   }
-  return hash;
-}
-
-// source/crypto/md2.ts
-var STABLE = [
-  41,
-  46,
-  67,
-  201,
-  162,
-  216,
-  124,
-  1,
-  61,
-  54,
-  84,
-  161,
-  236,
-  240,
-  6,
-  19,
-  98,
-  167,
-  5,
-  243,
-  192,
-  199,
-  115,
-  140,
-  152,
-  147,
-  43,
-  217,
-  188,
-  76,
-  130,
-  202,
-  30,
-  155,
-  87,
-  60,
-  253,
-  212,
-  224,
-  22,
-  103,
-  66,
-  111,
-  24,
-  138,
-  23,
-  229,
-  18,
-  190,
-  78,
-  196,
-  214,
-  218,
-  158,
-  222,
-  73,
-  160,
-  251,
-  245,
-  142,
-  187,
-  47,
-  238,
-  122,
-  169,
-  104,
-  121,
-  145,
-  21,
-  178,
-  7,
-  63,
-  148,
-  194,
-  16,
-  137,
-  11,
-  34,
-  95,
-  33,
-  128,
-  127,
-  93,
-  154,
-  90,
-  144,
-  50,
-  39,
-  53,
-  62,
-  204,
-  231,
-  191,
-  247,
-  151,
-  3,
-  255,
-  25,
-  48,
-  179,
-  72,
-  165,
-  181,
-  209,
-  215,
-  94,
-  146,
-  42,
-  172,
-  86,
-  170,
-  198,
-  79,
-  184,
-  56,
-  210,
-  150,
-  164,
-  125,
-  182,
-  118,
-  252,
-  107,
-  226,
-  156,
-  116,
-  4,
-  241,
-  69,
-  157,
-  112,
-  89,
-  100,
-  113,
-  135,
-  32,
-  134,
-  91,
-  207,
-  101,
-  230,
-  45,
-  168,
-  2,
-  27,
-  96,
-  37,
-  173,
-  174,
-  176,
-  185,
-  246,
-  28,
-  70,
-  97,
-  105,
-  52,
-  64,
-  126,
-  15,
-  85,
-  71,
-  163,
-  35,
-  221,
-  81,
-  175,
-  58,
-  195,
-  92,
-  249,
-  206,
-  186,
-  197,
-  234,
-  38,
-  44,
-  83,
-  13,
-  110,
-  133,
-  40,
-  132,
-  9,
-  211,
-  223,
-  205,
-  244,
-  65,
-  129,
-  77,
-  82,
-  106,
-  220,
-  55,
-  200,
-  108,
-  193,
-  171,
-  250,
-  36,
-  225,
-  123,
-  8,
-  12,
-  189,
-  177,
-  74,
-  120,
-  136,
-  149,
-  139,
-  227,
-  99,
-  232,
-  109,
-  233,
-  203,
-  213,
-  254,
-  59,
-  0,
-  29,
-  57,
-  242,
-  239,
-  183,
-  14,
-  102,
-  88,
-  208,
-  228,
-  166,
-  119,
-  114,
-  248,
-  235,
-  117,
-  75,
-  10,
-  49,
-  68,
-  80,
-  180,
-  143,
-  237,
-  31,
-  26,
-  219,
-  153,
-  141,
-  51,
-  159,
-  17,
-  131,
-  20
-];
-var MD2 = class _MD2 {
-  static BLOCK_SIZE = 16;
-  _data = new Uint8Array(16);
-  _state = new Uint8Array(48);
-  _checksum = new Uint8Array(16);
-  _length = 0;
-  constructor() {
-    for (let i = 0; i < this._state.length; i++)
-      this._state[i] = 0;
-    for (let i = 0; i < this._checksum.length; i++)
-      this._checksum[i] = 0;
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
   }
-  update(input) {
-    for (let i = 0; i < input.length; i++) {
-      this._data[this._length] = input[i];
-      this._length++;
-      if (this._length == _MD2.BLOCK_SIZE) {
-        this._transform(input);
-        this._length = 0;
-      }
-    }
-    return this;
+  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);
   }
-  _transform(data) {
-    for (let i = 0; i < 16; ++i) {
-      this._state[i + 16] = this._data[i];
-      this._state[i + 32] = this._state[i + 16] ^ this._state[i];
-    }
-    let t = 0;
-    for (let i = 0; i < 18; ++i) {
-      for (let j = 0; j < 48; ++j) {
-        this._state[j] ^= STABLE[t];
-        t = this._state[j];
-      }
-      t = t + i & 255;
-    }
-    t = this._checksum[15];
-    for (let i = 0; i < 16; ++i) {
-      this._checksum[i] ^= STABLE[this._data[i] ^ t];
-      t = this._checksum[i];
-    }
+  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)
+    );
   }
-  digest() {
-    const toPad = _MD2.BLOCK_SIZE - this._length;
-    while (this._length < _MD2.BLOCK_SIZE)
-      this._data[this._length++] = toPad;
-    this._transform(this._data);
-    this._transform(this._checksum);
-    return this._state.slice();
+  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);
   }
-  toString() {
-    return "";
+  static get zero() {
+    return new this(0, 0, 0);
   }
-  get [Symbol.toStringTag]() {
-    return "MD2";
+  static get one() {
+    return new this(1, 1, 1);
   }
-  [NodeJSCustomInspect]() {
-    return `MD2 <${this.toString()}>`;
+  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;
   }
-};
-
-// source/geometry/angle.ts
-var MAX_ANGLE_DEGREE = 360;
-var clampAngleDegree = (angle) => angle % MAX_ANGLE_DEGREE;
-var clampAngleRadian = (angle) => clampAngleDegree(degreeToRadian(angle));
-var radianToDegree = (angle) => angle * (180 / Math.PI);
-var degreeToRadian = (angle) => angle * (Math.PI / 180);
-
-// source/geometry/circle.ts
-var Circle = class _Circle {
-  radius;
-  get perimeter() {
-    return this.radius * Math.PI * 2;
+  toArray(w = this.w !== 1) {
+    return w ? [this.x, this.y, this.z, this.w] : [this.x, this.y, this.z];
   }
-  get area() {
-    return Math.PI * Math.pow(this.radius, 2);
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+      w: this.w
+    };
   }
-  position;
-  get x() {
-    return this.position.x;
+  toString(w = this.w !== 1) {
+    return w ? `${this.x},${this.y},${this.z};${this.w}` : `${this.x},${this.y},${this.z}`;
   }
-  set x(val) {
-    this.position.x = val;
+  get [Symbol.toStringTag]() {
+    return "Vec3";
   }
-  get y() {
-    return this.position.y;
+  [import_types4.NodeJSCustomInspect]() {
+    return `Vec3 <${this.toString()}>`;
   }
-  set y(val) {
-    this.position.y = val;
+  toVec2() {
+    return [this.x, this.y, this.w];
   }
-  get w() {
-    return this.position.w;
+  toRGB() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z];
   }
-  set w(val) {
-    this.position.w = val;
+  toRGBA() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z, vec.w];
   }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("Circle", a);
+  toHSL() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z];
   }
-  static resolveArgs(args) {
-    if (checkNumberArray(args, 3))
-      return new this([args[0], args[1]], args[2]);
-    if (args.length === 2)
-      return new this(args[0], args[1]);
-    return this.resolve(args[0]);
+  toHSLA() {
+    const vec = this.normalize();
+    return [vec.x, vec.y, vec.z, vec.w];
   }
-  static cast(a) {
-    if (a == null || typeof a == "undefined")
-      return void 0;
-    if (checkNumberArray(a, 3))
-      return new this([a[0], a[1]], a[2]);
-    if (checkNumberArray(a, 4)) {
-      const c = new this([a[0], a[1]], a[3]);
-      c.w = a[2];
-      return c;
-    }
-    if (hasProperty(a, "toCircle", "function"))
-      return this.cast(a.toCircle());
-    if (hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "radius", "number"))
-      return new this(hasProperty(a, "w", "number") ? [a.x, a.y, a.w] : [a.x, a.y], a.radius);
-    if (checkString(a)) {
-      const [spos, sradius] = a.split("|");
-      const pos = Vec2.cast(spos);
-      if (typeof pos == "undefined")
-        return void 0;
-      const radius = parseFloat(sradius);
-      if (!isNaN(radius))
-        return new this(pos, radius);
-    }
-    return void 0;
+  toQuaternion() {
+    return [this.w, this.x, this.y, this.z];
   }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
+  clone() {
+    return new _Vec3(this.x, this.y, this.z, this.w);
   }
-  constructor(position, radius) {
-    this.position = Vec2.resolve(position);
-    if (!checkNumber(radius))
-      throw new TypeError("expected number for radius");
-    this.radius = radius;
+  equals(...args) {
+    const a = _Vec3.resolveArgs(args);
+    return this.x == a.x && this.y == a.y && this.z == a.z;
   }
-  toArray() {
-    return [...this.position.toArray(), this.radius];
+  setX(x) {
+    this.x = x;
+    return this;
   }
-  toJSON() {
-    return {
-      ...this.position.toJSON(),
-      radius: this.radius
-    };
+  setY(y) {
+    this.y = y;
+    return this;
   }
-  toString() {
-    return `${this.position.toString()}|${this.radius}`;
+  setZ(z) {
+    this.z = z;
+    return this;
   }
-  get [Symbol.toStringTag]() {
-    return "Circle";
+  set(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return this.setX(vec.x).setY(vec.y).setZ(vec.z);
   }
-  [NodeJSCustomInspect]() {
-    return `Circle <${this.toString()}>`;
+  add(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x + vec.x,
+      this.y + vec.y,
+      this.z + vec.z
+    );
   }
-  clone() {
-    return new _Circle(this.position.clone(), this.radius);
+  offset(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    this.x += vec.x;
+    this.y += vec.y;
+    this.z += vec.z;
+    return this;
   }
-  toVec2() {
-    return [this.x, this.y, this.w];
+  subtract(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x - vec.x,
+      this.y - vec.y,
+      this.z - vec.z
+    );
   }
-  equals(...args) {
-    const c = _Circle.resolveArgs(args);
-    return c.position.equals(c.position) && this.radius == c.radius;
+  multiply(scalar) {
+    return new _Vec3(
+      this.x * scalar,
+      this.y * scalar,
+      this.z * scalar
+    );
   }
-  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;
+  naiveMultiply(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x * vec.x,
+      this.y * vec.y,
+      this.z * vec.z
+    );
   }
-  insidePoint(...args) {
-    return this.position.distance(Vec2.resolveArgs(args)) <= this.radius;
+  divide(...args) {
+    if ((0, import_types4.isFixedTypeArray)(args, import_types4.isValidNumber, 1))
+      return new _Vec3(
+        this.x / args[0],
+        this.y / args[0],
+        this.z / args[0]
+      );
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x / vec.x,
+      this.y / vec.y,
+      this.z / vec.z
+    );
   }
-};
-
-// source/geometry/bbox.ts
-var BoundingBox = class _BoundingBox {
-  left;
-  right;
-  top;
-  bottom;
-  get width() {
-    return this.right - this.left;
+  dot(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return this.x * vec.x + this.y * vec.y + this.z * vec.z;
   }
-  set width(val) {
-    this.right = this.left + val;
+  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
+    );
   }
-  get height() {
-    return this.bottom - this.top;
+  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);
   }
-  set height(val) {
-    this.bottom = this.top + val;
+  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));
   }
-  get x() {
-    return this.left;
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
   }
-  set x(x) {
-    this.left = x;
+  normalize() {
+    const length = this.length();
+    if (length == 0) return _Vec3.zero;
+    return new _Vec3(
+      this.x / length,
+      this.y / length,
+      this.z / length,
+      this.w / length
+    );
   }
-  get y() {
-    return this.top;
+  invert() {
+    return this.multiply(-1);
   }
-  set y(y) {
-    this.top = y;
+  round() {
+    return new _Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z), Math.round(this.w));
+  }
+};
+
+// source/algebra/quaternion.ts
+var Quaternion = class _Quaternion {
+  w;
+  x;
+  y;
+  z;
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
   }
-  w = 1;
   static resolve(a) {
     const value = this.cast(a);
     if (typeof value != "undefined")
       return value;
-    throw new ResolveError("BoundingBox", a);
+    throw new ResolveError("Quaternion", a);
   }
   static resolveArgs(args) {
-    if (checkNumberArray(args, 4))
+    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]);
   }
   static cast(a) {
     if (a == null || typeof a == "undefined")
       return void 0;
-    if (checkNumberArray(a, 4))
+    if ((0, import_types5.isFixedTypeArray)(a, import_types5.isValidNumber, 4))
       return new this(a[0], a[1], a[2], a[3]);
-    if (hasProperty(a, "toBoundingBox", "function"))
-      return this.cast(a.toBoundingBox());
-    if (hasProperty(a, "left", "number") && hasProperty(a, "right", "number") && hasProperty(a, "top", "number") && hasProperty(a, "bottom", "number"))
-      return new this(a.left, a.right, a.top, a.bottom);
-    if (checkString(a)) {
-      const parts = a.split(",");
-      if (checkStringArray(parts, 4))
-        return this.cast(parts.map((v) => parseFloat(v)));
+    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 is(a) {
-    return typeof this.cast(a) != "undefined";
+  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);
   }
-  constructor(left, right, top, bottom) {
-    if (!checkNumber(left))
-      throw new TypeError("expected number for left");
-    if (!checkNumber(right))
-      throw new TypeError("expected number for right");
-    if (!checkNumber(top))
-      throw new TypeError("expected number for top");
-    if (!checkNumber(bottom))
-      throw new TypeError("expected number for bottom");
-    this.left = left;
-    this.right = right;
-    this.top = top;
-    this.bottom = bottom;
+  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.left, this.right, this.top, this.bottom];
+    return [this.w, this.x, this.y, this.z];
   }
   toString() {
-    return `${this.left},${this.right},${this.top},${this.bottom}`;
+    return `${this.w} + ${this.x}i + ${this.y}j + ${this.z}k`;
   }
   get [Symbol.toStringTag]() {
-    return "BoundingBox";
+    return "Quaternion";
   }
-  [NodeJSCustomInspect]() {
-    return `BoundingBox <${this.toString()}>`;
+  [import_types5.NodeJSCustomInspect]() {
+    return `Quaternion <${this.toString()}>`;
   }
   toJSON() {
     return {
-      left: this.left,
-      top: this.top,
-      right: this.right,
-      bottom: this.bottom
+      w: this.w,
+      x: this.x,
+      y: this.y,
+      z: this.z
     };
   }
   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;
+    return new _Quaternion(this.w, this.x, this.y, this.z);
   }
-  toSize() {
-    return [this.width, this.height];
+  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
+    );
   }
-  toVec2() {
-    return [this.left, this.top];
+  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;
   }
-  toRectangle() {
-    return [this.left, this.top, this.width, this.height];
+  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
+    );
   }
-  inside(...args) {
-    const bbox = _BoundingBox.resolve(args);
-    return this.right >= bbox.left && bbox.right >= this.left && this.bottom >= bbox.top && bbox.bottom >= this.top;
+  negative() {
+    return new _Quaternion(-this.w, -this.x, -this.y, -this.z);
   }
-  insidePoint(...args) {
-    const point = Vec2.resolveArgs(args);
-    return this.left <= point.x && this.right >= point.x && this.top <= point.y && this.bottom >= point.y;
+  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;
   }
-  insideCircle(...args) {
-    const circle = Circle.resolveArgs(args);
-    const center = Vec2.resolve(circle).add(circle.radius);
-    const bboxhe = new Vec2(this.width / 2, this.height / 2);
-    const bboxcenter = new Vec2(this.left + bboxhe.x, this.top + bboxhe.y);
-    let diff = center.subtract(bboxcenter);
-    const clamped = Vec2.clamp(diff, bboxhe.invert(), bboxhe);
-    const closest = bboxcenter.add(clamped);
-    diff = closest.subtract(center);
-    return diff.length() < circle.radius;
-  }
-};
-
-// source/geometry/size.ts
-var Size = class _Size {
-  width;
-  height;
-  get aspectRatio() {
-    return this.height / this.width;
-  }
-  get area() {
-    return this.width * this.height;
+  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);
   }
-  get perimeter() {
-    return this.width + this.width + this.height + this.height;
+  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
+    );
   }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("Square", a);
+  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
+    );
   }
-  static resolveArgs(args) {
-    if (checkNumberArray(args, 2))
-      return new this(args[0], args[1]);
-    return this.resolve(args[0]);
+  scale(scalar) {
+    return new _Quaternion(this.w * scalar, this.x * scalar, this.y * scalar, this.z * scalar);
   }
-  static cast(a) {
-    if (a == null || typeof a == "undefined")
-      return void 0;
-    if (checkNumberArray(a, 2))
-      return new this(a[0], a[1]);
-    if (hasProperty(a, "toSize", "function"))
-      return this.cast(a.toSize());
-    if (hasProperty(a, "width", "number") && hasProperty(a, "height", "number"))
-      return new this(a.width, a.height);
-    if (checkString(a)) {
-      const parts = a.split("x").map((v) => parseFloat(v));
-      if (checkNumberArray(parts, 2))
-        return this.cast(parts);
-    }
-    if (checkNumber(a))
-      return new this(a, a);
-    return void 0;
+  dot(...args) {
+    const quat = _Quaternion.resolveArgs(args);
+    return this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z;
   }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
+  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);
   }
-  constructor(width, height) {
-    if (!checkNumber(width))
-      throw new TypeError("expected number for width");
-    if (!checkNumber(height))
-      throw new TypeError("expected number for height");
-    this.width = width;
-    this.height = height;
+  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
+    );
   }
-  toArray() {
-    return [this.width, this.height];
+  conjugate() {
+    return new _Quaternion(this.w, -this.x, -this.y, -this.z);
   }
-  toString() {
-    return `${this.width}x${this.height}`;
+  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
+    );
   }
-  get [Symbol.toStringTag]() {
-    return "Size";
+  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);
   }
-  [NodeJSCustomInspect]() {
-    return `Size <${this.toString()}>`;
+  toVec3() {
+    return [this.x, this.y, this.z, this.w];
   }
-  toJSON() {
-    return {
-      width: this.width,
-      height: this.height
-    };
+  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);
   }
-  clone() {
-    return new _Size(this.width, this.height);
+  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))
+    );
   }
-  equals(...args) {
-    const s = _Size.resolveArgs(args);
-    return this.width == s.width && this.height == s.height;
+  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)
+    ];
   }
-  toVec2() {
-    return [this.width, this.height];
+  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/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;
+// 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;
   }
-  set y(val) {
-    this.position.y = val;
+  set red(val) {
+    this._red = clamp(val, 0, 1);
   }
-  get w() {
-    return this.position.w;
+  _green;
+  get green() {
+    return this._green;
   }
-  set w(val) {
-    this.position.w = val;
+  set green(val) {
+    this._green = clamp(val, 0, 1);
   }
-  get width() {
-    return this.size.width;
+  _blue;
+  get blue() {
+    return this._blue;
   }
-  set width(val) {
-    this.size.width = val;
+  set blue(val) {
+    this._blue = clamp(val, 0, 1);
   }
-  get height() {
-    return this.size.height;
+  _alpha;
+  get alpha() {
+    return this._alpha;
   }
-  set height(val) {
-    this.size.height = val;
+  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("Rectangle", a);
+    throw new ResolveError("RGBAColor", a);
   }
   static resolveArgs(args) {
-    if (checkNumberArray(args, 4))
-      return new this([args[0], args[1]], [args[2], args[3]]);
+    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 (checkNumberArray(a, 4))
-      return new this([a[0], a[1]], [a[2], a[3]]);
-    if (checkNumberArray(a, 5)) {
-      const rect = new this([a[0], a[1]], [a[3], a[4]]);
-      rect.w = a[2];
-      return rect;
-    }
-    if (checkString(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_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 (hasProperty(a, "toRectangle", "function"))
-      return this.cast(a.toRectangle());
-    if (hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "width", "number") && hasProperty(a, "height", "number")) {
-      const rect = new this([a.x, a.y], [a.width, a.height]);
-      if (hasProperty(a, "w", "number"))
-        rect.w = a.w;
-      return rect;
+    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(pos, size) {
-    this.position = Vec2.resolve(pos);
-    this.size = Size.resolve(size);
-  }
-  toArray(w = this.w !== 1) {
-    return [...this.position.toArray(w), ...this.size.toArray()];
+  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);
   }
-  toString(w = this.w !== 1) {
-    return `${this.position.toString(w)}|${this.size.toString()}`;
+  toArray(withAlpha = this._alpha !== 1) {
+    return withAlpha ? [this.red, this.green, this.blue, this.alpha] : [this.red, this.green, this.blue];
   }
-  get [Symbol.toStringTag]() {
-    return "Rectangle";
+  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
+    };
   }
-  [NodeJSCustomInspect]() {
-    return `Rectangle <${this.toString()}>`;
+  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)})`;
   }
-  toJSON() {
-    return { ...this.position.toJSON(), ...this.size.toJSON() };
+  get [Symbol.toStringTag]() {
+    return "RGBA";
   }
-  toBoundingBox() {
-    return [this.x, this.x + this.width, this.y, this.y + this.height];
+  [import_types6.NodeJSCustomInspect]() {
+    return `RGBA <${this.toString()}>`;
   }
   toVec2() {
-    return [this.x, this.y, this.w];
+    return [this.red, this.green, this.blue];
   }
-  toSize() {
-    return [this.width, this.height];
+  toVec3() {
+    return [this.red, this.green, this.blue, this.alpha];
   }
-  clone() {
-    return new _Rectangle(this.position.clone(), this.size.clone());
+  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);
   }
-  equals(...args) {
-    const rect = _Rectangle.resolveArgs(args);
-    return this.position.equals(rect.position) && this.size.equals(rect.size);
+  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/common/string.ts
-function stringify(value) {
-  return value != null && typeof value == "object" && "toString" in value && typeof value.toString == "function" ? value.toString() : String(value);
-}
-
-// source/vectors/vec3.ts
-var Vec3 = class _Vec3 {
-  x;
-  y;
-  z;
-  w;
+// 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("Vec3", a);
+    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 (checkNumberArray(a, 3) || checkNumberArray(a, 4))
-      return new this(a[0], a[1], a[2], checkNumber(a[3]) ? a[3] : void 0);
-    if (hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "z", "number"))
-      return new this(a.x, a.y, a.z, hasProperty(a, "w", "number") ? a.w : void 0);
-    if (checkString(a)) {
-      const [sxyz, sw] = a.split(";");
-      if (checkString(sxyz)) {
-        const parts = sxyz.split(",");
-        if (checkStringArray(parts, 3))
-          return new this(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]), checkString(sw) ? parseFloat(sw) : void 0);
+    if ((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));
       }
     }
-    if (checkNumber(a))
-      return new this(a, a, a);
     return void 0;
   }
-  static resolveArgs(args) {
-    if (checkNumberArray(args, 3))
-      return new this(args[0], args[1], args[2]);
-    return this.resolve(args[0]);
-  }
   static is(a) {
     return typeof this.cast(a) != "undefined";
   }
-  static fromPoints(a, b) {
-    const veca = this.resolve(a);
-    const vecb = this.resolve(b);
-    return new this(vecb.x - veca.x, vecb.y - veca.y, vecb.z - veca.z);
-  }
-  static clamp(value, min, max) {
-    const a = this.resolve(value), b = this.resolve(min), c = this.resolve(max);
-    return new this(
-      clamp(a.x, b.x, c.x),
-      clamp(a.y, b.y, c.y),
-      clamp(a.z, b.z, c.z)
-    );
-  }
-  static intersectPlane(planeP, planeN, lineStart, lineEnd, t) {
-    planeN = this.resolve(planeN).normalize();
-    const plane_d = -this.resolve(planeN).dot(planeP);
-    const ad = this.resolve(lineStart).dot(planeN);
-    const bd = this.resolve(lineEnd).dot(planeN);
-    t = (-plane_d - ad) / (bd - ad);
-    const lineStartToEnd = this.resolve(lineEnd).subtract(lineStart);
-    const linetoIntersect = lineStartToEnd.multiply(t);
-    return _Vec3.resolve(lineStart).add(linetoIntersect);
-  }
-  static get zero() {
-    return new this(0, 0, 0);
-  }
-  static get one() {
-    return new this(1, 1, 1);
-  }
-  constructor(x, y, z, w = 1) {
-    if (!checkNumber(x))
-      throw new TypeError("expected number for x");
-    if (!checkNumber(y))
-      throw new TypeError("expected number for y");
-    if (!checkNumber(z))
-      throw new TypeError("expected number for z");
-    if (!checkNumber(w))
-      throw new TypeError("expected number for w");
-    this.x = x;
-    this.y = y;
-    this.z = z;
-    this.w = w;
+  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(w = this.w !== 1) {
-    return w ? [this.x, this.y, this.z, this.w] : [this.x, this.y, this.z];
+  toArray(withAlpha = this._alpha !== 1) {
+    return withAlpha ? [this.hue, this.saturation, this.luminace, this.alpha] : [this.hue, this.saturation, this.luminace];
   }
-  toJSON() {
-    return {
-      x: this.x,
-      y: this.y,
-      z: this.z,
-      w: this.w
+  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(w = this.w !== 1) {
-    return w ? `${this.x},${this.y},${this.z};${this.w}` : `${this.x},${this.y},${this.z}`;
+  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 "Vec3";
-  }
-  [NodeJSCustomInspect]() {
-    return `Vec3 <${this.toString()}>`;
+    return "HSLA";
   }
-  toVec2() {
-    return [this.x, this.y, this.w];
+  [import_types7.NodeJSCustomInspect]() {
+    return `HSLA <${this.toString()}>`;
   }
-  toRGB() {
-    const vec = this.normalize();
-    return [vec.x, vec.y, vec.z];
+  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() {
-    const vec = this.normalize();
-    return [vec.x, vec.y, vec.z, vec.w];
+    return this.toRGB(true);
   }
-  toHSL() {
-    const vec = this.normalize();
-    return [vec.x, vec.y, vec.z];
+  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/crypto/hash.ts
+var DJB2_OFFSET = 5381n;
+function djb2(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));
+  }
+  return hash;
+}
+var FNV1_OFFSET = 14695981039346656037n;
+var FNV1_PRIME = 1099511628211n;
+function fnv1(value) {
+  const string = String(value);
+  let hash = FNV1_OFFSET;
+  for (let i = 0; i < string.length; i++) {
+    hash *= FNV1_PRIME;
+    hash ^= BigInt(string.charCodeAt(i));
+  }
+  return hash;
+}
+function sdbm(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;
+  }
+  return hash;
+}
+
+// source/crypto/md2.ts
+var import_types8 = require("@ntf/types");
+var STABLE = [
+  41,
+  46,
+  67,
+  201,
+  162,
+  216,
+  124,
+  1,
+  61,
+  54,
+  84,
+  161,
+  236,
+  240,
+  6,
+  19,
+  98,
+  167,
+  5,
+  243,
+  192,
+  199,
+  115,
+  140,
+  152,
+  147,
+  43,
+  217,
+  188,
+  76,
+  130,
+  202,
+  30,
+  155,
+  87,
+  60,
+  253,
+  212,
+  224,
+  22,
+  103,
+  66,
+  111,
+  24,
+  138,
+  23,
+  229,
+  18,
+  190,
+  78,
+  196,
+  214,
+  218,
+  158,
+  222,
+  73,
+  160,
+  251,
+  245,
+  142,
+  187,
+  47,
+  238,
+  122,
+  169,
+  104,
+  121,
+  145,
+  21,
+  178,
+  7,
+  63,
+  148,
+  194,
+  16,
+  137,
+  11,
+  34,
+  95,
+  33,
+  128,
+  127,
+  93,
+  154,
+  90,
+  144,
+  50,
+  39,
+  53,
+  62,
+  204,
+  231,
+  191,
+  247,
+  151,
+  3,
+  255,
+  25,
+  48,
+  179,
+  72,
+  165,
+  181,
+  209,
+  215,
+  94,
+  146,
+  42,
+  172,
+  86,
+  170,
+  198,
+  79,
+  184,
+  56,
+  210,
+  150,
+  164,
+  125,
+  182,
+  118,
+  252,
+  107,
+  226,
+  156,
+  116,
+  4,
+  241,
+  69,
+  157,
+  112,
+  89,
+  100,
+  113,
+  135,
+  32,
+  134,
+  91,
+  207,
+  101,
+  230,
+  45,
+  168,
+  2,
+  27,
+  96,
+  37,
+  173,
+  174,
+  176,
+  185,
+  246,
+  28,
+  70,
+  97,
+  105,
+  52,
+  64,
+  126,
+  15,
+  85,
+  71,
+  163,
+  35,
+  221,
+  81,
+  175,
+  58,
+  195,
+  92,
+  249,
+  206,
+  186,
+  197,
+  234,
+  38,
+  44,
+  83,
+  13,
+  110,
+  133,
+  40,
+  132,
+  9,
+  211,
+  223,
+  205,
+  244,
+  65,
+  129,
+  77,
+  82,
+  106,
+  220,
+  55,
+  200,
+  108,
+  193,
+  171,
+  250,
+  36,
+  225,
+  123,
+  8,
+  12,
+  189,
+  177,
+  74,
+  120,
+  136,
+  149,
+  139,
+  227,
+  99,
+  232,
+  109,
+  233,
+  203,
+  213,
+  254,
+  59,
+  0,
+  29,
+  57,
+  242,
+  239,
+  183,
+  14,
+  102,
+  88,
+  208,
+  228,
+  166,
+  119,
+  114,
+  248,
+  235,
+  117,
+  75,
+  10,
+  49,
+  68,
+  80,
+  180,
+  143,
+  237,
+  31,
+  26,
+  219,
+  153,
+  141,
+  51,
+  159,
+  17,
+  131,
+  20
+];
+var MD2 = class _MD2 {
+  static BLOCK_SIZE = 16;
+  _data = new Uint8Array(16);
+  _state = new Uint8Array(48);
+  _checksum = new Uint8Array(16);
+  _length = 0;
+  constructor() {
+    for (let i = 0; i < this._state.length; i++)
+      this._state[i] = 0;
+    for (let i = 0; i < this._checksum.length; i++)
+      this._checksum[i] = 0;
+  }
+  update(input) {
+    for (let i = 0; i < input.length; i++) {
+      this._data[this._length] = input[i];
+      this._length++;
+      if (this._length == _MD2.BLOCK_SIZE) {
+        this._transform(input);
+        this._length = 0;
+      }
+    }
+    return this;
+  }
+  _transform(data) {
+    for (let i = 0; i < 16; ++i) {
+      this._state[i + 16] = this._data[i];
+      this._state[i + 32] = this._state[i + 16] ^ this._state[i];
+    }
+    let t = 0;
+    for (let i = 0; i < 18; ++i) {
+      for (let j = 0; j < 48; ++j) {
+        this._state[j] ^= STABLE[t];
+        t = this._state[j];
+      }
+      t = t + i & 255;
+    }
+    t = this._checksum[15];
+    for (let i = 0; i < 16; ++i) {
+      this._checksum[i] ^= STABLE[this._data[i] ^ t];
+      t = this._checksum[i];
+    }
+  }
+  digest() {
+    const toPad = _MD2.BLOCK_SIZE - this._length;
+    while (this._length < _MD2.BLOCK_SIZE)
+      this._data[this._length++] = toPad;
+    this._transform(this._data);
+    this._transform(this._checksum);
+    return this._state.slice();
+  }
+  toString() {
+    return "";
+  }
+  get [Symbol.toStringTag]() {
+    return "MD2";
+  }
+  [import_types8.NodeJSCustomInspect]() {
+    return `MD2 <${this.toString()}>`;
+  }
+};
+
+// source/geometry/angle.ts
+var MAX_ANGLE_DEGREE = 360;
+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() {
+    return this.radius * Math.PI * 2;
+  }
+  get area() {
+    return Math.PI * Math.pow(this.radius, 2);
+  }
+  position;
+  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;
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      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 ((0, import_types9.isFixedTypeArray)(a, import_types9.isValidNumber, 3))
+      return new this([a[0], a[1]], a[2]);
+    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 ((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")
+        return void 0;
+      const radius = parseFloat(sradius);
+      if (!isNaN(radius))
+        return new this(pos, radius);
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(position, radius) {
+    (0, import_types9.checkValidNumber)(radius);
+    this.position = Vec2.resolve(position);
+    this.radius = radius;
   }
-  toHSLA() {
-    const vec = this.normalize();
-    return [vec.x, vec.y, vec.z, vec.w];
+  toArray() {
+    return [...this.position.toArray(), this.radius];
   }
-  toQuaternion() {
-    return [this.w, this.x, this.y, this.z];
+  toJSON() {
+    return {
+      ...this.position.toJSON(),
+      radius: this.radius
+    };
+  }
+  toString() {
+    return `${this.position.toString()}|${this.radius}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Circle";
+  }
+  [import_types9.NodeJSCustomInspect]() {
+    return `Circle <${this.toString()}>`;
   }
   clone() {
-    return new _Vec3(this.x, this.y, this.z, this.w);
+    return new _Circle(this.position.clone(), this.radius);
+  }
+  toVec2() {
+    return [this.x, this.y, this.w];
   }
   equals(...args) {
-    const a = _Vec3.resolveArgs(args);
-    return this.x == a.x && this.y == a.y && this.z == a.z;
+    const c = _Circle.resolveArgs(args);
+    return c.position.equals(c.position) && this.radius == c.radius;
   }
-  setX(x) {
-    this.x = x;
-    return this;
+  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;
   }
-  setY(y) {
-    this.y = y;
-    return this;
+  insidePoint(...args) {
+    return this.position.distance(Vec2.resolveArgs(args)) <= this.radius;
   }
-  setZ(z) {
-    this.z = z;
-    return this;
+};
+
+// source/geometry/bbox.ts
+var BoundingBox = class _BoundingBox {
+  left;
+  right;
+  top;
+  bottom;
+  get width() {
+    return this.right - this.left;
   }
-  set(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return this.setX(vec.x).setY(vec.y).setZ(vec.z);
+  set width(val) {
+    this.right = this.left + val;
   }
-  add(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return new _Vec3(
-      this.x + vec.x,
-      this.y + vec.y,
-      this.z + vec.z
-    );
+  get height() {
+    return this.bottom - this.top;
   }
-  offset(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    this.x += vec.x;
-    this.y += vec.y;
-    this.z += vec.z;
-    return this;
+  set height(val) {
+    this.bottom = this.top + val;
   }
-  subtract(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return new _Vec3(
-      this.x - vec.x,
-      this.y - vec.y,
-      this.z - vec.z
-    );
+  get x() {
+    return this.left;
   }
-  multiply(scalar) {
-    return new _Vec3(
-      this.x * scalar,
-      this.y * scalar,
-      this.z * scalar
-    );
+  set x(x) {
+    this.left = x;
   }
-  naiveMultiply(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return new _Vec3(
-      this.x * vec.x,
-      this.y * vec.y,
-      this.z * vec.z
-    );
+  get y() {
+    return this.top;
   }
-  divide(...args) {
-    if (checkNumberArray(args, 1))
-      return new _Vec3(
-        this.x / args[0],
-        this.y / args[0],
-        this.z / args[0]
-      );
-    const vec = _Vec3.resolveArgs(args);
-    return new _Vec3(
-      this.x / vec.x,
-      this.y / vec.y,
-      this.z / vec.z
-    );
+  set y(y) {
+    this.top = y;
   }
-  dot(...args) {
-    const vec = _Vec3.resolveArgs(args);
-    return this.x * vec.x + this.y * vec.y + this.z * vec.z;
+  w = 1;
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("BoundingBox", a);
   }
-  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
-    );
+  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]);
   }
-  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);
+  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;
   }
-  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));
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
   }
-  length() {
-    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  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;
   }
-  normalize() {
-    const length = this.length();
-    if (length == 0) return _Vec3.zero;
-    return new _Vec3(
-      this.x / length,
-      this.y / length,
-      this.z / length,
-      this.w / length
-    );
+  toArray() {
+    return [this.left, this.right, this.top, this.bottom];
   }
-  invert() {
-    return this.multiply(-1);
+  toString() {
+    return `${this.left},${this.right},${this.top},${this.bottom}`;
   }
-  round() {
-    return new _Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z), Math.round(this.w));
+  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/triangle.ts
-var Triangle = class {
-  constructor(A, B, C) {
-    this.A = A;
-    this.B = B;
-    this.C = C;
+// 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 alpha() {
-    return Math.acos((this.b * this.b + this.c * this.c - this.a * this.a) / (2 * this.b * this.c));
+  get area() {
+    return this.width * this.height;
   }
-  get beta() {
-    return Math.acos((this.c * this.c + this.a * this.a - this.b * this.b) / (2 * this.c * this.a));
+  get perimeter() {
+    return this.width + this.width + this.height + this.height;
   }
-  get gamma() {
-    return Math.acos((this.a * this.a + this.b * this.b - this.c * this.c) / (2 * this.a * this.b));
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Square", a);
   }
-  get perimeter() {
-    return this.a + this.b + this.c;
+  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]);
   }
-  get semiperimeter() {
-    return this.perimeter / 2;
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    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;
   }
-  get area() {
-    return Math.sqrt(this.semiperimeter * (this.semiperimeter - this.a) * (this.semiperimeter - this.b) * (this.semiperimeter - this.c));
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
   }
-  get base() {
-    return 2 * (this.area / (this.a * Math.sin(this.gamma)));
+  constructor(width, height) {
+    (0, import_types11.checkValidNumber)(width);
+    (0, import_types11.checkValidNumber)(height);
+    this.width = width;
+    this.height = height;
   }
-  get height() {
-    return 2 * (this.area / this.base);
+  toArray() {
+    return [this.width, this.height];
   }
   toString() {
-    return `${stringify(this.A)}|${stringify(this.B)}|${stringify(this.C)}`;
+    return `${this.width}x${this.height}`;
   }
   get [Symbol.toStringTag]() {
-    return "Triangle";
-  }
-  [NodeJSCustomInspect]() {
-    return `Triangle <${this.toString()}>`;
-  }
-};
-var Triangle2D = class extends Triangle {
-  get a() {
-    return Vec2.fromPoints(this.B, this.C).length();
+    return "Size";
   }
-  get b() {
-    return Vec2.fromPoints(this.A, this.C).length();
+  [import_types11.NodeJSCustomInspect]() {
+    return `Size <${this.toString()}>`;
   }
-  get c() {
-    return Vec2.fromPoints(this.A, this.B).length();
+  toJSON() {
+    return {
+      width: this.width,
+      height: this.height
+    };
   }
-};
-var Triangle3D = class extends Triangle {
-  get a() {
-    return Vec3.fromPoints(this.B, this.C).length();
+  clone() {
+    return new _Size(this.width, this.height);
   }
-  get b() {
-    return Vec3.fromPoints(this.A, this.C).length();
+  equals(...args) {
+    const s = _Size.resolveArgs(args);
+    return this.width == s.width && this.height == s.height;
   }
-  get c() {
-    return Vec3.fromPoints(this.A, this.B).length();
+  toVec2() {
+    return [this.width, this.height];
   }
 };
 
-// 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];
+// source/geometry/rectangle.ts
+var Rectangle = class _Rectangle {
+  position;
+  size;
+  get area() {
+    return this.width * this.height;
   }
-  set m10(val) {
-    this._raw[3] = val;
+  get perimeter() {
+    return this.width + this.width + this.height + this.height;
   }
-  get m11() {
-    return this._raw[4];
+  get x() {
+    return this.position.x;
   }
-  set m11(val) {
-    this._raw[4] = val;
+  set x(val) {
+    this.position.x = val;
   }
-  get m12() {
-    return this._raw[5];
+  get y() {
+    return this.position.y;
   }
-  set m12(val) {
-    this._raw[5] = val;
+  set y(val) {
+    this.position.y = val;
   }
-  get m20() {
-    return this._raw[6];
+  get w() {
+    return this.position.w;
   }
-  set m20(val) {
-    this._raw[6] = val;
+  set w(val) {
+    this.position.w = val;
   }
-  get m21() {
-    return this._raw[7];
+  get width() {
+    return this.size.width;
   }
-  set m21(val) {
-    this._raw[7] = val;
+  set width(val) {
+    this.size.width = val;
   }
-  get m22() {
-    return this._raw[8];
+  get height() {
+    return this.size.height;
   }
-  set m22(val) {
-    this._raw[8] = val;
+  set height(val) {
+    this.size.height = val;
   }
   static resolve(a) {
     const value = this.cast(a);
     if (typeof value != "undefined")
       return value;
-    throw new ResolveError("Mat3", a);
+    throw new ResolveError("Rectangle", a);
   }
   static resolveArgs(args) {
-    if (checkNumberArray(args, 9))
-      return new this(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 (checkNumberArray(a, 9)) {
-      return new this(a);
-    }
-    if (checkArray(a, void 0, 3)) {
-      const row0 = a[0], row1 = a[1], row2 = a[2];
-      if (checkNumberArray(row0, 3) && checkNumberArray(row1, 3) && checkNumberArray(row2, 3))
-        return new this([
-          row0[0],
-          row0[1],
-          row0[2],
-          row1[0],
-          row1[1],
-          row1[2],
-          row2[0],
-          row2[1],
-          row2[2]
-        ]);
+    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 (checkString(a)) {
-      const parts = a.split(",");
-      if (checkStringArray(parts, 9))
-        return this.cast(parts.map((i) => parseFloat(i)));
+    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 (hasProperty(a, "toMat3", "function"))
-      return this.cast(a.toMat3());
-    if (hasProperty(a, "m00", "number") && hasProperty(a, "m01", "number") && hasProperty(a, "m02", "number") && hasProperty(a, "m10", "number") && hasProperty(a, "m11", "number") && hasProperty(a, "m12", "number") && hasProperty(a, "m20", "number") && hasProperty(a, "m21", "number") && hasProperty(a, "m22", "number"))
-      return new this([
-        a.m00,
-        a.m01,
-        a.m02,
-        a.m10,
-        a.m11,
-        a.m12,
-        a.m20,
-        a.m21,
-        a.m22
-      ]);
-    if (checkNumber(a)) {
-      return new this([a, a, a, a, a, a, a, a, a]);
+    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";
   }
-  static projection(width, height) {
-    return new this([
-      2 / width,
-      0,
-      0,
-      0,
-      -2 / height,
-      0,
-      -1,
-      1,
-      1
-    ]);
+  constructor(pos, size) {
+    this.position = Vec2.resolve(pos);
+    this.size = Size.resolve(size);
   }
-  constructor(init = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
-    if (!checkNumberArray(init, 9))
-      throw new TypeError("expected a number array with 9 elements");
-    this._raw = init;
+  toArray(w = this.w !== 1) {
+    return [...this.position.toArray(w), ...this.size.toArray()];
   }
-  toArray() {
-    return [
-      this.m00,
-      this.m01,
-      this.m02,
-      this.m10,
-      this.m11,
-      this.m12,
-      this.m20,
-      this.m21,
-      this.m22
-    ];
+  toString(w = this.w !== 1) {
+    return `${this.position.toString(w)}|${this.size.toString()}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Rectangle";
+  }
+  [import_types12.NodeJSCustomInspect]() {
+    return `Rectangle <${this.toString()}>`;
+  }
+  toJSON() {
+    return { ...this.position.toJSON(), ...this.size.toJSON() };
+  }
+  toBoundingBox() {
+    return [this.x, this.x + this.width, this.y, this.y + this.height];
+  }
+  toVec2() {
+    return [this.x, this.y, this.w];
+  }
+  toSize() {
+    return [this.width, this.height];
+  }
+  clone() {
+    return new _Rectangle(this.position.clone(), this.size.clone());
+  }
+  equals(...args) {
+    const rect = _Rectangle.resolveArgs(args);
+    return this.position.equals(rect.position) && this.size.equals(rect.size);
+  }
+};
+
+// source/geometry/triangle.ts
+var import_types13 = require("@ntf/types");
+var Triangle = class {
+  constructor(A, B, C) {
+    this.A = A;
+    this.B = B;
+    this.C = C;
   }
-  toNestetArray() {
-    return [
-      [this.m00, this.m01, this.m02],
-      [this.m10, this.m11, this.m12],
-      [this.m20, this.m21, this.m22]
-    ];
+  get alpha() {
+    return Math.acos((this.b * this.b + this.c * this.c - this.a * this.a) / (2 * this.b * this.c));
   }
-  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 beta() {
+    return Math.acos((this.c * this.c + this.a * this.a - this.b * this.b) / (2 * this.c * this.a));
   }
-  toString() {
-    return `${this.m00},${this.m01},${this.m02},${this.m10},${this.m11},${this.m12},${this.m20},${this.m21},${this.m22}`;
+  get gamma() {
+    return Math.acos((this.a * this.a + this.b * this.b - this.c * this.c) / (2 * this.a * this.b));
   }
-  get [Symbol.toStringTag]() {
-    return "Mat3";
+  get perimeter() {
+    return this.a + this.b + this.c;
   }
-  [NodeJSCustomInspect]() {
-    return `Mat3 <${this.toString()}>`;
+  get semiperimeter() {
+    return this.perimeter / 2;
   }
-  clone() {
-    return new _Mat3([
-      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));
   }
-  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;
+  get base() {
+    return 2 * (this.area / (this.a * Math.sin(this.gamma)));
   }
-  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;
+  get height() {
+    return 2 * (this.area / this.base);
   }
-  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;
+  toString() {
+    return `${this.A}|${this.B}|${this.C}`;
   }
-  multiply(...args) {
-    if (checkNumberArray(args, 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]
-      ]);
-    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
-    ]);
+  get [Symbol.toStringTag]() {
+    return "Triangle";
   }
-  translate(...args) {
-    const vec = Vec2.resolveArgs(args);
-    return this.multiply([
-      1,
-      0,
-      0,
-      0,
-      1,
-      0,
-      vec.x,
-      vec.y,
-      1
-    ]);
+  [import_types13.NodeJSCustomInspect]() {
+    return `Triangle <${this.toString()}>`;
   }
-  rotate(angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
-    return this.multiply([
-      c,
-      -s,
-      0,
-      s,
-      c,
-      0,
-      0,
-      0,
-      1
-    ]);
+};
+var Triangle2D = class extends Triangle {
+  get a() {
+    return Vec2.fromPoints(this.B, 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 b() {
+    return Vec2.fromPoints(this.A, this.C).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;
+  get c() {
+    return Vec2.fromPoints(this.A, this.B).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
-    ]);
+};
+var Triangle3D = class extends Triangle {
+  get a() {
+    return Vec3.fromPoints(this.B, 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 b() {
+    return Vec3.fromPoints(this.A, this.C).length();
+  }
+  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];
@@ -1962,230 +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];
-  }
-  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];
+    return this._raw[8];
   }
-  set m33(val) {
-    this._raw[15] = val;
+  set m22(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 (checkNumberArray(args, 16))
+    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 (checkNumberArray(a, 16)) {
+    if ((0, import_types14.isFixedTypeArray)(a, import_types14.isValidNumber, 9)) {
       return new this(a);
     }
-    if (checkArray(a, void 0, 4)) {
-      const row0 = a[0], row1 = a[1], row2 = a[2], row3 = a[3];
-      if (checkNumberArray(row0, 4) && checkNumberArray(row1, 4) && checkNumberArray(row2, 4) && checkNumberArray(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 (checkString(a)) {
+    if ((0, import_types14.isValidString)(a)) {
       const parts = a.split(",");
-      if (checkStringArray(parts, 16))
+      if ((0, import_types14.isFixedTypeArray)(parts, import_types14.isValidString, 9))
         return this.cast(parts.map((i) => parseFloat(i)));
     }
-    if (hasProperty(a, "toMat4", "function"))
-      return this.cast(a.toMat4());
-    if (hasProperty(a, "m00", "number") && hasProperty(a, "m01", "number") && hasProperty(a, "m02", "number") && hasProperty(a, "m03", "number") && hasProperty(a, "m10", "number") && hasProperty(a, "m11", "number") && hasProperty(a, "m12", "number") && hasProperty(a, "m13", "number") && hasProperty(a, "m20", "number") && hasProperty(a, "m21", "number") && hasProperty(a, "m22", "number") && hasProperty(a, "m23", "number") && hasProperty(a, "m30", "number") && hasProperty(a, "m31", "number") && hasProperty(a, "m32", "number") && hasProperty(a, "m33", "number"))
+    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
+        a.m22
       ]);
-    if (checkNumber(a)) {
-      return new this([a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a]);
+    if ((0, import_types14.isValidNumber)(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 orthographic(...args) {
-    const bbox = checkNumberArray(args, 6) ? new BoundingBox(args[0], args[1], args[2], args[3]) : BoundingBox.resolve(args[0]);
-    const near = checkNumberArray(args, 6) ? args[4] : args[1];
-    const far = checkNumberArray(args, 6) ? args[5] : args[2];
-    return new this([
-      2 / (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 perspective(fov, aspect, near, far) {
-    const f = Math.tan(Math.PI * 0.5 - 0.5 * fov);
-    const rangeInv = 1 / (near - far);
+  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 (!checkNumberArray(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() {
@@ -2193,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() {
@@ -2221,580 +2305,713 @@ 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 "Mat4";
+    return "Mat3";
   }
-  [NodeJSCustomInspect]() {
-    return `Mat4 <${this.toString()}>`;
+  [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(...args) {
-    const m = _Mat4.resolveArgs(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(...args) {
-    const b = _Mat4.resolveArgs(args);
-    const m = new _Mat4();
+    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(...args) {
-    const b = _Mat4.resolveArgs(args);
-    const m = new _Mat4();
+    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(...args) {
-    if (checkNumberArray(args, 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
+    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]
       ]);
-    }
-    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
-    ]);
-  }
-  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
-    ]);
-  }
-  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
+    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
     ]);
   }
-  rotateY(angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
+  translate(...args) {
+    const vec = Vec2.resolveArgs(args);
     return this.multiply([
-      c,
-      0,
-      -s,
-      0,
-      0,
       1,
       0,
       0,
-      s,
-      0,
-      c,
-      0,
-      0,
       0,
+      1,
       0,
+      vec.x,
+      vec.y,
       1
     ]);
   }
-  rotateZ(angle) {
+  rotate(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,
+      s,
+      c,
       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([
-      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
+    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
     ]);
   }
-  toMat3() {
+  toMat4() {
     return [
       this.m00,
       this.m01,
-      this.m03,
+      this.m02,
+      0,
       this.m10,
       this.m11,
-      this.m13,
-      this.m30,
-      this.m31,
-      this.m33
+      this.m12,
+      0,
+      this.m20,
+      this.m20,
+      this.m22,
+      0,
+      0,
+      0,
+      0,
+      1
     ];
   }
 };
 
-// source/color.ts
-function __hex_to_array__(hex) {
-  if (!checkHex(hex))
-    return void 0;
-  const part = getHexValue(hex);
-  const red = parseInt(part.substring(0, 2), 16) / 255;
-  const green = parseInt(part.substring(2, 4), 16) / 255;
-  const blue = parseInt(part.substring(4, 6), 16) / 255;
-  const alpha = part.length == 8 ? parseInt(hex.substring(6, 8), 16) / 255 : 1;
-  return [red, green, blue, alpha];
-}
-function __number_to_rgb__(number) {
-  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];
-}
-var __to_byte__ = (scale) => clamp(scale * 255 | 0, 0, 255);
-var RGBA = class _RGBA {
-  _red;
-  get red() {
-    return this._red;
+// source/matrices/mat4.ts
+var import_types15 = require("@ntf/types");
+var Mat4 = class _Mat4 {
+  _raw;
+  get m00() {
+    return this._raw[0];
   }
-  set red(val) {
-    this._red = clamp(val, 0, 1);
+  set m00(val) {
+    this._raw[0] = val;
   }
-  _green;
-  get green() {
-    return this._green;
+  get m01() {
+    return this._raw[1];
   }
-  set green(val) {
-    this._green = clamp(val, 0, 1);
+  set m01(val) {
+    this._raw[1] = val;
   }
-  _blue;
-  get blue() {
-    return this._blue;
+  get m02() {
+    return this._raw[2];
   }
-  set blue(val) {
-    this._blue = clamp(val, 0, 1);
+  set m02(val) {
+    this._raw[2] = val;
   }
-  _alpha;
-  get alpha() {
-    return this._alpha;
+  get m03() {
+    return this._raw[3];
   }
-  set alpha(val) {
-    this._alpha = clamp(val, 0, 1);
+  set m03(val) {
+    this._raw[3] = val;
   }
-  static resolve(a) {
-    const value = this.cast(a);
-    if (typeof value != "undefined")
-      return value;
-    throw new ResolveError("RGBAColor", a);
+  get m10() {
+    return this._raw[4];
   }
-  static resolveArgs(args) {
-    if (checkNumberArray(args, 3) || checkNumberArray(args, 4))
-      return new this(args[0], args[1], args[2], args[3]);
-    return this.resolve(args[0]);
+  set m10(val) {
+    this._raw[4] = val;
   }
-  static cast(a) {
-    if (a == null || typeof a == "undefined")
-      return void 0;
-    if (checkNumberArray(a, 3) || checkNumberArray(a, 4))
-      return new this(a[0], a[1], a[2], a[3]);
-    if (hasProperty(a, "toRGB", "function"))
-      return this.cast(a.toRGB());
-    if (hasProperty(a, "toRGBA", "function"))
-      return this.cast(a.toRGBA());
-    if (hasProperty(a, "red", "number") && hasProperty(a, "green", "number") && hasProperty(a, "blue", "number"))
-      return new this(a.red, a.green, a.blue, hasProperty(a, "alpha", "number") ? a.alpha : void 0);
-    if (checkNumber(a)) {
-      const hex = a.toString(16);
-      const convert = hex.length <= 6 ? __number_to_rgb__ : __number_to_rgba__;
-      return this.cast(convert(a));
-    }
-    if (checkString(a)) {
-      if (a.startsWith("rgb")) {
-        const hasAlpha = a.startsWith("rgba");
-        const offset = hasAlpha ? 5 : 4;
-        const parts = a.substring(offset, a.indexOf(")", offset)).split(",");
-        if (checkStringArray(parts, hasAlpha ? 4 : 3))
-          return this.cast(parts.map((v) => parseInt(v) / 255));
-      }
-      return this.cast(__hex_to_array__(a));
-    }
-    return void 0;
+  get m11() {
+    return this._raw[5];
   }
-  static is(a) {
-    return typeof this.cast(a) != "undefined";
+  set m11(val) {
+    this._raw[5] = 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 m12() {
+    return this._raw[6];
   }
-  toArray(withAlpha = this._alpha !== 1) {
-    return withAlpha ? [this.red, this.green, this.blue, this.alpha] : [this.red, this.green, this.blue];
+  set m12(val) {
+    this._raw[6] = val;
   }
-  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
-    };
+  get m13() {
+    return this._raw[7];
   }
-  toString(withAlpha = this._alpha !== 1) {
-    return withAlpha ? `rgba(${__to_byte__(this.red)},${__to_byte__(this.green)},${__to_byte__(this.blue)},${this.alpha})` : `rgb(${__to_byte__(this.red)},${__to_byte__(this.green)},${__to_byte__(this.blue)})`;
+  set m13(val) {
+    this._raw[7] = val;
   }
-  get [Symbol.toStringTag]() {
-    return "RGBA";
+  get m20() {
+    return this._raw[8];
   }
-  [NodeJSCustomInspect]() {
-    return `RGBA <${this.toString()}>`;
+  set m20(val) {
+    this._raw[8] = val;
   }
-  toVec2() {
-    return [this.red, this.green, this.blue];
+  get m21() {
+    return this._raw[9];
   }
-  toVec3() {
-    return [this.red, this.green, this.blue, this.alpha];
+  set m21(val) {
+    this._raw[9] = val;
   }
-  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);
+  get m22() {
+    return this._raw[10];
   }
-  toHSLA() {
-    return this.toHSL(true);
+  set m22(val) {
+    this._raw[10] = val;
   }
-  invert(withAlpha = this._alpha !== 1) {
-    return new _RGBA(
-      1 - this.red,
-      1 - this.green,
-      1 - this.blue,
-      withAlpha ? 1 - this.alpha : this.alpha
-    );
+  get m23() {
+    return this._raw[11];
   }
-};
-var HSLA = class _HSLA {
-  _hue;
-  get hue() {
-    return this._hue;
+  set m23(val) {
+    this._raw[11] = val;
   }
-  set hue(val) {
-    this._hue = clamp(val, 0, 1);
+  get m30() {
+    return this._raw[12];
   }
-  _saturation;
-  get saturation() {
-    return this._saturation;
+  set m30(val) {
+    this._raw[12] = val;
   }
-  set saturation(val) {
-    this._saturation = clamp(val, 0, 1);
+  get m31() {
+    return this._raw[13];
   }
-  _luminace;
-  get luminace() {
-    return this._luminace;
+  set m31(val) {
+    this._raw[13] = val;
   }
-  set luminace(val) {
-    this._luminace = clamp(val, 0, 1);
+  get m32() {
+    return this._raw[14];
   }
-  _alpha;
-  get alpha() {
-    return this._alpha;
+  set m32(val) {
+    this._raw[14] = val;
   }
-  set alpha(val) {
-    this._alpha = clamp(val, 0, 1);
+  get m33() {
+    return this._raw[15];
+  }
+  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 (checkNumberArray(args, 3) || checkNumberArray(args, 4))
-      return new this(args[0], args[1], args[2], args[3]);
+    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 (checkNumberArray(a, 3) || checkNumberArray(a, 4))
-      return new this(a[0], a[1], a[2], a[3]);
-    if (hasProperty(a, "toHSL", "function"))
-      return this.cast(a.toHSL());
-    if (hasProperty(a, "toHSLA", "function"))
-      return this.cast(a.toHSLA());
-    if (hasProperty(a, "hue", "number") && hasProperty(a, "saturation", "number") && hasProperty(a, "luminace", "number"))
-      return new this(a.hue, a.saturation, a.luminace, hasProperty(a, "alpha", "number") ? a.alpha : void 0);
-    if (checkNumber(a)) {
-      const hex = a.toString(16);
-      const convert = hex.length <= 6 ? __number_to_rgb__ : __number_to_rgba__;
-      return this.cast(convert(a));
+    if ((0, import_types15.isFixedTypeArray)(a, import_types15.isValidNumber, 16)) {
+      return new this(a);
     }
-    if (checkString(a)) {
-      if (a.startsWith("hsl")) {
-        const hasAlpha = a.startsWith("hsla");
-        const offset = hasAlpha ? 5 : 4;
-        const parts = a.substring(offset, a.indexOf(")", offset)).split(",");
-        if (checkStringArray(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]
+        ]);
+    }
+    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 void 0;
   }
   static is(a) {
     return typeof this.cast(a) != "undefined";
   }
-  constructor(hue, saturation, luminace, alpha = 1) {
-    if (!checkNumber(hue))
-      throw new TypeError("expected number for hue");
-    if (!checkNumber(saturation))
-      throw new TypeError("expected number for saturation");
-    if (!checkNumber(luminace))
-      throw new TypeError("expected number for luminace");
-    if (!checkNumber(alpha))
-      throw new TypeError("expected number for alpha");
-    this._hue = clamp(hue, 0, 1);
-    this._saturation = clamp(saturation, 0, 1);
-    this._luminace = clamp(luminace, 0, 1);
-    this._alpha = clamp(alpha, 0, 1);
+  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 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 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(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.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
+    ];
+  }
+  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 {
+      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
+    };
+  }
+  toString() {
+    return `${this.m00},${this.m01},${this.m02},${this.m03},${this.m10},${this.m11},${this.m12},${this.m13},${this.m20},${this.m21},${this.m22},${this.m23},${this.m30},${this.m31},${this.m32},${this.m33}`;
+  }
+  get [Symbol.toStringTag]() {
+    return "Mat4";
+  }
+  [import_types15.NodeJSCustomInspect]() {
+    return `Mat4 <${this.toString()}>`;
+  }
+  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
+    ]);
+  }
+  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;
   }
-  toArray(withAlpha = this._alpha !== 1) {
-    return withAlpha ? [this.hue, this.saturation, this.luminace, this.alpha] : [this.hue, this.saturation, this.luminace];
+  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;
   }
-  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
-    };
+  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;
   }
-  toString(withAlpha = this._alpha !== 1) {
-    return withAlpha ? `hsla(${__to_byte__(this.hue)},${__to_byte__(this.saturation)},${__to_byte__(this.luminace)},${this.alpha})` : `hsl(${__to_byte__(this.hue)},${__to_byte__(this.saturation)},${__to_byte__(this.luminace)})`;
+  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
+    ]);
   }
-  get [Symbol.toStringTag]() {
-    return "HSLA";
+  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
+    ]);
   }
-  [NodeJSCustomInspect]() {
-    return `HSLA <${this.toString()}>`;
+  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
+    ]);
   }
-  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);
+  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
+    ]);
   }
-  toRGBA() {
-    return this.toRGB(true);
+  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
+    ]);
   }
-  toVec2() {
-    return [this.hue, this.saturation, this.luminace];
+  rotate(...args) {
+    const vec = Vec3.resolveArgs(args);
+    return this.rotateX(vec.x).rotateY(vec.y).rotateZ(vec.z);
   }
-  toVec3() {
-    return [this.hue, this.saturation, this.luminace, this.alpha];
+  scale(...args) {
+    const vec = Vec3.resolveArgs(args);
+    return this.multiply([
+      vec.x,
+      0,
+      0,
+      0,
+      0,
+      vec.y,
+      0,
+      0,
+      0,
+      0,
+      vec.z,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
   }
-  invert(withAlpha = this._alpha !== 1) {
-    return new _HSLA(
-      1 - this.hue,
-      1 - this.saturation,
-      1 - this.luminace,
-      withAlpha ? 1 - this.alpha : this.alpha
-    );
+  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) {
@@ -2827,290 +3044,19 @@ var AnyColor;
   }
   AnyColor2.resolve = resolve;
   function resolveArgs(args, preferHSL = false) {
-    if (checkNumberArray(args, 3) || checkNumberArray(args, 4))
+    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/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 resolveArgs(args) {
-    if (checkNumberArray(args, 4))
-      return new this(args[0], args[1], args[2], args[3]);
-    return this.resolve(args[0]);
-  }
-  static cast(a) {
-    if (a == null || typeof a == "undefined")
-      return void 0;
-    if (checkNumberArray(a, 4))
-      return new this(a[0], a[1], a[2], a[3]);
-    if (hasProperty(a, "toQuaternion", "function"))
-      return this.cast(a.toQuaternion());
-    if (hasProperty(a, "w", "number") && hasProperty(a, "x", "number") && hasProperty(a, "y", "number") && hasProperty(a, "z", "number"))
-      return new this(a.w, a.x, a.y, a.z);
-    if (checkString(a)) {
-      const parts = a.replaceAll(" ", "").split("+");
-      if (checkStringArray(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 fromAxisAngle(...args) {
-    const axis = checkNumberArray(args, 4) ? new Vec3(args[0], args[1], args[2]) : Vec3.resolve(args[0]);
-    const angle = checkNumberArray(args, 4) ? args[3] : args[1];
-    const vec = Vec3.resolve(axis);
-    const hangle = angle * 0.5;
-    const sin2 = Math.sin(hangle);
-    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) {
-    if (!checkNumber(w))
-      throw new TypeError("expected number for w");
-    if (!checkNumber(x))
-      throw new TypeError("expected number for x");
-    if (!checkNumber(y))
-      throw new TypeError("expected number for x");
-    if (!checkNumber(z))
-      throw new TypeError("expected number for w");
-    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";
-  }
-  [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/transform.ts
+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);
@@ -3161,7 +3107,7 @@ var Transform2D = class {
   get [Symbol.toStringTag]() {
     return "Transform2D";
   }
-  [NodeJSCustomInspect]() {
+  [import_types17.NodeJSCustomInspect]() {
     return `Transform2D <${this.toString()}>`;
   }
   toMat3() {
@@ -3236,7 +3182,7 @@ var Transform3D = class {
   get [Symbol.toStringTag]() {
     return "Transform2D";
   }
-  [NodeJSCustomInspect]() {
+  [import_types17.NodeJSCustomInspect]() {
     return `Transform2D <${this.toString()}>`;
   }
   /**