@ntf/math 1.2.0 → 1.3.1

package/dist/index.mjs

@@ -0,0 +1,2869 @@
+// source/algebra/function.ts
+var MathFunction = class {
+};
+
+// source/common/sign.ts
+function sign_char(num) {
+  if (num == 0)
+    return void 0;
+  if (num < 0)
+    return "-";
+  if (num > 0)
+    return "+";
+  return void 0;
+}
+
+// source/common/types.ts
+function check_number(obj) {
+  return obj != null && typeof obj == "number" && !isNaN(obj) && isFinite(obj);
+}
+function check_hex_digit(obj) {
+  if (!check_string(obj) || obj.length != 1)
+    return false;
+  switch (obj.toUpperCase()) {
+    default:
+      return false;
+    case "0":
+    case "1":
+    case "2":
+    case "3":
+    case "4":
+    case "5":
+    case "6":
+    case "7":
+    case "8":
+    case "9":
+    case "A":
+    case "B":
+    case "C":
+    case "D":
+    case "E":
+    case "F":
+      return true;
+  }
+}
+function get_hex_part(string) {
+  let offset = 0;
+  if (string.startsWith("#") || string.startsWith("$"))
+    offset = 1;
+  if (string.startsWith("0x"))
+    offset = 2;
+  return string.substring(offset);
+}
+function check_hex(obj) {
+  if (!check_string(obj))
+    return false;
+  const value = get_hex_part(obj).split("").map((char) => parseInt(char.toUpperCase(), 16));
+  return check_number_array(value);
+}
+function check_string(obj) {
+  return obj != null && typeof obj == "string" && obj.length > 0;
+}
+function check_array(obj, predicate, requiredLength) {
+  if (!Array.isArray(obj)) return false;
+  if (requiredLength && requiredLength != obj.length) return false;
+  for (const item of obj)
+    if (predicate && !predicate(item))
+      return false;
+  return true;
+}
+function check_number_array(obj, requiredLength) {
+  return check_array(obj, check_number, requiredLength);
+}
+function check_string_array(obj, requiredLength) {
+  return check_array(obj, check_string, requiredLength);
+}
+function has_property(obj, name, type) {
+  return obj != null && typeof obj == "object" && name in obj && typeof obj[name] == type;
+}
+
+// source/common/error.ts
+var ResolveError = class extends Error {
+  constructor(target, value) {
+    super(`can't resolve ${value} to ${target}`);
+    this.target = target;
+    this.value = value;
+  }
+};
+
+// source/geometry/size.ts
+var Size = class _Size {
+  width;
+  height;
+  get aspectRatio() {
+    return this.height / this.width;
+  }
+  get area() {
+    return this.width * this.height;
+  }
+  get perimeter() {
+    return this.width + this.width + this.height + this.height;
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Square", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 2))
+      return new this(a[0], a[1]);
+    if (has_property(a, "width", "number") && has_property(a, "height", "number"))
+      return new this(a.width, a.height);
+    if (check_string(a)) {
+      const parts = a.split("x").map((v) => parseFloat(v));
+      if (check_number_array(parts, 2))
+        return this.cast(parts);
+    }
+    if (check_number(a))
+      return new this(a, a);
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(width, height) {
+    if (!check_number(width))
+      throw new TypeError("expected number for width");
+    if (!check_number(height))
+      throw new TypeError("expected number for height");
+    this.width = width;
+    this.height = height;
+  }
+  toArray() {
+    return [this.width, this.height];
+  }
+  toString() {
+    return `${this.width}x${this.height}`;
+  }
+  toJSON() {
+    return {
+      width: this.width,
+      height: this.height
+    };
+  }
+  clone() {
+    return new _Size(this.width, this.height);
+  }
+  equals(square) {
+    const s = _Size.resolve(square);
+    return this.width == s.width && this.height == s.height;
+  }
+  toVec2() {
+    return [this.width, this.height];
+  }
+};
+
+// source/utils.ts
+function clamp(value, min, max) {
+  if (value <= min)
+    return min;
+  if (value >= max)
+    return max;
+  return value;
+}
+function log_hypot(a, b) {
+  const a_abs = Math.abs(a);
+  const b_abs = Math.abs(b);
+  if (a == 0)
+    return Math.log(b_abs);
+  if (b == 0)
+    return Math.log(a_abs);
+  if (a_abs < 3e3 && b_abs < 3e3)
+    return 0.5 * Math.log(a * a + b * b);
+  const _a = a / 2, _b = b / 2;
+  return 0.5 * Math.log(_a * _a + _b * _b) + Math.LN2;
+}
+var EPSILON = 1e-16;
+
+// source/vectors/vec3.ts
+var Vec3 = class _Vec3 {
+  x;
+  y;
+  z;
+  w;
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Vec3", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 3) || check_number_array(a, 4))
+      return new this(a[0], a[1], a[2], check_number(a[3]) ? a[3] : void 0);
+    if (has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "z", "number"))
+      return new this(a.x, a.y, a.z, has_property(a, "w", "number") ? a.w : void 0);
+    if (check_string(a)) {
+      const [sxyz, sw] = a.split(";");
+      if (check_string(sxyz)) {
+        const parts = sxyz.split(",");
+        if (check_string_array(parts, 3))
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2]), check_string(sw) ? parseFloat(sw) : void 0);
+      }
+    }
+    if (check_number(a))
+      return new this(a, a, a);
+    return void 0;
+  }
+  static resolveArgs(args) {
+    if (check_number_array(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);
+  }
+  constructor(x = 0, y = 0, z = 0, w = 1) {
+    if (!check_number(x))
+      throw new TypeError("expected number for x");
+    if (!check_number(y))
+      throw new TypeError("expected number for y");
+    if (!check_number(z))
+      throw new TypeError("expected number for z");
+    if (!check_number(w))
+      throw new TypeError("expected number for w");
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+  toArray(w = false) {
+    return w ? [this.x, this.y, this.z] : [this.x, this.y, this.z, this.w];
+  }
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+      w: this.w
+    };
+  }
+  toString(w = false) {
+    return w ? `${this.x},${this.y},${this.z}` : `${this.x},${this.y},${this.z};${this.w}`;
+  }
+  toVec2() {
+    return [this.x, this.y, this.w];
+  }
+  clone() {
+    return new _Vec3(this.x, this.y, this.z, this.w);
+  }
+  equals(vec) {
+    const a = _Vec3.resolve(vec);
+    return this.x == a.x && this.y == a.y && this.z == a.z;
+  }
+  setX(x) {
+    this.x = x;
+    return this;
+  }
+  setY(y) {
+    this.y = y;
+    return this;
+  }
+  setZ(z) {
+    this.z = z;
+    return this;
+  }
+  set(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return this.setX(vec.x).setY(vec.y).setZ(vec.z);
+  }
+  add(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x + vec.x,
+      this.y + vec.y,
+      this.z + vec.z
+    );
+  }
+  offset(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    this.x += vec.x;
+    this.y += vec.y;
+    this.z += vec.z;
+    return this;
+  }
+  subtract(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x - vec.x,
+      this.y - vec.y,
+      this.z - vec.z
+    );
+  }
+  multiply(scalar) {
+    return new _Vec3(
+      this.x * scalar,
+      this.y * scalar,
+      this.z * scalar
+    );
+  }
+  naiveMultiply(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.x * vec.x,
+      this.y * vec.y,
+      this.z * vec.z
+    );
+  }
+  divide(...args) {
+    if (check_number_array(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
+    );
+  }
+  dot(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return this.x * vec.x + this.y * vec.y + this.z * vec.z;
+  }
+  cross(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return new _Vec3(
+      this.y * vec.z - this.z * vec.y,
+      this.z * vec.x - this.x * vec.z,
+      this.x * vec.y - this.y * vec.x
+    );
+  }
+  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);
+  }
+  distanceSquare(...args) {
+    const vec = _Vec3.resolveArgs(args);
+    return Math.sqrt(Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2) + Math.pow(vec.z - this.z, 2));
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  normalize() {
+    const length = this.length();
+    if (length == 0) return new _Vec3();
+    return new _Vec3(
+      this.x / length,
+      this.y / length,
+      this.z / length
+    );
+  }
+  invert() {
+    return this.multiply(-1);
+  }
+  round() {
+    return new _Vec3(Math.round(this.x), Math.round(this.y), Math.round(this.z), Math.round(this.w));
+  }
+};
+
+// source/vectors/vec2.ts
+var Vec2 = class _Vec2 {
+  x;
+  y;
+  w;
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Vec2", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 2) || check_number_array(a, 3))
+      return new this(a[0], a[1], check_number(a[2]) ? a[2] : void 0);
+    if (has_property(a, "x", "number") && has_property(a, "y", "number"))
+      return new this(a.x, a.y, has_property(a, "w", "number") ? a.w : void 0);
+    if (check_string(a)) {
+      const [sxy, sw] = a.split(";");
+      if (check_string(sxy)) {
+        const parts = sxy.split(",");
+        if (check_string_array(parts, 2))
+          return new this(parseFloat(parts[0]), parseFloat(parts[1]), check_string(sw) ? parseFloat(sw) : void 0);
+      }
+    }
+    if (check_number(a))
+      return new this(a, a);
+    return void 0;
+  }
+  static resolveArgs(args) {
+    if (check_number_array(args, 2))
+      return new this(args[0], args[1]);
+    return this.resolve(args[0]);
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  static fromPoints(a, b) {
+    const veca = this.resolve(a);
+    const vecb = this.resolve(b);
+    return new this(vecb.x - veca.x, vecb.y - veca.y);
+  }
+  static clamp(value, min, max) {
+    const a = this.resolve(value), b = this.resolve(min), c = this.resolve(max);
+    return new this(
+      clamp(a.x, b.x, c.x),
+      clamp(a.y, b.y, c.y)
+    );
+  }
+  constructor(x = 0, y = 0, w = 1) {
+    if (!check_number(x))
+      throw new TypeError("expected number for x");
+    if (!check_number(y))
+      throw new TypeError("expected number for y");
+    if (!check_number(w))
+      throw new TypeError("expected number for w");
+    this.x = x;
+    this.y = y;
+    this.w = w;
+  }
+  toArray(w = false) {
+    return w ? [this.x, this.y] : [this.x, this.y, this.w];
+  }
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y,
+      w: this.w
+    };
+  }
+  toString(w = false) {
+    return w ? `${this.x},${this.y}` : `${this.x},${this.y};${this.w}`;
+  }
+  toSquare() {
+    return new Size(this.x, this.y);
+  }
+  toVec3(z) {
+    return new Vec3(this.x, this.y, z, this.w);
+  }
+  clone() {
+    return new _Vec2(this.x, this.y, this.w);
+  }
+  equals(vec) {
+    const a = _Vec2.resolve(vec);
+    return this.x == a.x && this.y == a.y;
+  }
+  setX(x) {
+    this.x = x;
+    return this;
+  }
+  setY(y) {
+    this.y = y;
+    return this;
+  }
+  setW(w) {
+    this.w = w;
+    return this;
+  }
+  set(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    return this.setX(vec.x).setY(vec.y);
+  }
+  add(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
+      this.x + vec.x,
+      this.y + vec.y
+    );
+  }
+  offset(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    this.x += vec.x;
+    this.y += vec.y;
+    return this;
+  }
+  subtract(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
+      this.x - vec.x,
+      this.y - vec.y
+    );
+  }
+  multiply(scalar) {
+    return new _Vec2(
+      this.x * scalar,
+      this.y * scalar
+    );
+  }
+  naiveMultiply(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
+      this.x * vec.x,
+      this.y * vec.y
+    );
+  }
+  divide(...args) {
+    if (check_number_array(args, 1))
+      return new _Vec2(
+        this.x / args[0],
+        this.y / args[0]
+      );
+    const vec = _Vec2.resolveArgs(args);
+    return new _Vec2(
+      this.x / vec.x,
+      this.y / vec.y
+    );
+  }
+  dot(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    return this.x * vec.x + this.y * vec.y;
+  }
+  distance(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    return Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2);
+  }
+  distanceSquare(...args) {
+    const vec = _Vec2.resolveArgs(args);
+    return Math.sqrt(Math.pow(vec.x - this.x, 2) + Math.pow(vec.y - this.y, 2));
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  cartesianify() {
+    return new _Vec2(
+      this.x * Math.cos(this.y),
+      this.x * Math.sin(this.y)
+    );
+  }
+  polarify() {
+    return new _Vec2(
+      Math.sqrt(this.x * this.x + this.y * this.y),
+      Math.atan(this.y / this.x)
+    );
+  }
+  normalize() {
+    const length = this.length();
+    if (length == 0) return new _Vec2();
+    return new _Vec2(
+      this.x / length,
+      this.y / length
+    );
+  }
+  invert() {
+    return this.multiply(-1);
+  }
+  round() {
+    return new _Vec2(Math.round(this.x), Math.round(this.y), Math.round(this.w));
+  }
+};
+
+// source/algebra/linear.ts
+var LinearFunction = class extends MathFunction {
+  /**
+   * The factor of the linear function
+   */
+  m;
+  /**
+   * The height of the linear function
+   */
+  b;
+  /**
+   * Create a linear function from two points
+   * @param a A point
+   * @param b A point
+   * @returns A linear function from two points
+   */
+  static fromPoints(a, b) {
+    const veca = Vec2.resolve(a);
+    const vecb = Vec2.resolve(b);
+    const m = (vecb.y - veca.y) / (vecb.x - veca.x);
+    const h = -m * veca.x + veca.y;
+    return new this(m, h);
+  }
+  /**
+   * Create a linear function with a factor and height
+   * @param m The factor
+   * @param b The height
+   */
+  constructor(m, b) {
+    super();
+    if (!check_number(m))
+      throw new TypeError("expected number for m");
+    if (!check_number(b))
+      throw new TypeError("expected number for b");
+    this.m = m;
+    this.b = b;
+  }
+  get(x) {
+    if (!check_number(x))
+      throw new TypeError("expected number for x");
+    return this.m;
+  }
+  roots() {
+    const x = -this.b / this.m;
+    if (!isNaN(x))
+      return [new Vec2(x)];
+    return [];
+  }
+  toString() {
+    const bsign = sign_char(this.b);
+    if (bsign)
+      return `f(x) = ${this.m} * x ${bsign} ${Math.abs(this.b)}`;
+    return `f(x) = ${this.m} * x`;
+  }
+};
+
+// source/algebra/quad.ts
+var QuadFunction = class extends MathFunction {
+  a;
+  b;
+  c;
+  static get(a, b, c, x) {
+    return new this(a, b, c).get(x);
+  }
+  constructor(a, b, c) {
+    super();
+    if (!check_number(a))
+      throw new TypeError("expected number for a");
+    if (a == 0)
+      throw new TypeError("a cannot be 0");
+    if (!check_number(b))
+      throw new TypeError("expected number for b");
+    if (!check_number(c))
+      throw new TypeError("expected number for c");
+    this.a = a;
+    this.b = b;
+    this.c = c;
+  }
+  get(x) {
+    if (!check_number(x))
+      throw new TypeError("expected number for x");
+    return this.a * x * x + this.b * x + this.c;
+  }
+  roots() {
+    const roots = new Array();
+    const discriminant = this.b * this.b - 4 * this.a * this.c;
+    const n0 = (-this.b + Math.sqrt(discriminant)) / (2 * this.a);
+    const n1 = (-this.b + Math.sqrt(discriminant)) / (2 * this.a);
+    if (!isNaN(n0))
+      roots.push(new Vec2(n0));
+    if (!isNaN(n1) && n0 != n1)
+      roots.push(new Vec2(n1));
+    return roots;
+  }
+  toString(type = "standard") {
+    switch (type) {
+      default:
+      case "standard": {
+        const bsign = sign_char(this.b);
+        const csign = sign_char(this.c);
+        if (bsign && csign)
+          return `f(x) = ${this.a}x^2 ${bsign} ${Math.abs(this.b)}x ${csign} ${Math.abs(this.c)}`;
+        if (bsign)
+          return `f(x) = ${this.a}x^2 ${bsign} ${Math.abs(this.b)}x`;
+        return `f(x) = ${this.a}x^2`;
+      }
+    }
+  }
+};
+
+// source/common/string.ts
+function stringify(value) {
+  return value != null && typeof value == "object" && "toString" in value && typeof value.toString == "function" ? value.toString() : String(value);
+}
+
+// source/crypto/hash.ts
+var DJB2_OFFSET = 5381n;
+function djb2(value) {
+  const string = stringify(value);
+  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 = stringify(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 = stringify(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 STABLE = [
+  41,
+  46,
+  67,
+  201,
+  162,
+  216,
+  124,
+  1,
+  61,
+  54,
+  84,
+  161,
+  236,
+  240,
+  6,
+  19,
+  98,
+  167,
+  5,
+  243,
+  192,
+  199,
+  115,
+  140,
+  152,
+  147,
+  43,
+  217,
+  188,
+  76,
+  130,
+  202,
+  30,
+  155,
+  87,
+  60,
+  253,
+  212,
+  224,
+  22,
+  103,
+  66,
+  111,
+  24,
+  138,
+  23,
+  229,
+  18,
+  190,
+  78,
+  196,
+  214,
+  218,
+  158,
+  222,
+  73,
+  160,
+  251,
+  245,
+  142,
+  187,
+  47,
+  238,
+  122,
+  169,
+  104,
+  121,
+  145,
+  21,
+  178,
+  7,
+  63,
+  148,
+  194,
+  16,
+  137,
+  11,
+  34,
+  95,
+  33,
+  128,
+  127,
+  93,
+  154,
+  90,
+  144,
+  50,
+  39,
+  53,
+  62,
+  204,
+  231,
+  191,
+  247,
+  151,
+  3,
+  255,
+  25,
+  48,
+  179,
+  72,
+  165,
+  181,
+  209,
+  215,
+  94,
+  146,
+  42,
+  172,
+  86,
+  170,
+  198,
+  79,
+  184,
+  56,
+  210,
+  150,
+  164,
+  125,
+  182,
+  118,
+  252,
+  107,
+  226,
+  156,
+  116,
+  4,
+  241,
+  69,
+  157,
+  112,
+  89,
+  100,
+  113,
+  135,
+  32,
+  134,
+  91,
+  207,
+  101,
+  230,
+  45,
+  168,
+  2,
+  27,
+  96,
+  37,
+  173,
+  174,
+  176,
+  185,
+  246,
+  28,
+  70,
+  97,
+  105,
+  52,
+  64,
+  126,
+  15,
+  85,
+  71,
+  163,
+  35,
+  221,
+  81,
+  175,
+  58,
+  195,
+  92,
+  249,
+  206,
+  186,
+  197,
+  234,
+  38,
+  44,
+  83,
+  13,
+  110,
+  133,
+  40,
+  132,
+  9,
+  211,
+  223,
+  205,
+  244,
+  65,
+  129,
+  77,
+  82,
+  106,
+  220,
+  55,
+  200,
+  108,
+  193,
+  171,
+  250,
+  36,
+  225,
+  123,
+  8,
+  12,
+  189,
+  177,
+  74,
+  120,
+  136,
+  149,
+  139,
+  227,
+  99,
+  232,
+  109,
+  233,
+  203,
+  213,
+  254,
+  59,
+  0,
+  29,
+  57,
+  242,
+  239,
+  183,
+  14,
+  102,
+  88,
+  208,
+  228,
+  166,
+  119,
+  114,
+  248,
+  235,
+  117,
+  75,
+  10,
+  49,
+  68,
+  80,
+  180,
+  143,
+  237,
+  31,
+  26,
+  219,
+  153,
+  141,
+  51,
+  159,
+  17,
+  131,
+  20
+];
+var MD2 = class _MD2 {
+  static BLOCK_SIZE = 16;
+  _data = new Uint8Array(16);
+  _state = new Uint8Array(48);
+  _checksum = new Uint8Array(16);
+  _length = 0;
+  constructor() {
+    for (let i = 0; i < this._state.length; i++)
+      this._state[i] = 0;
+    for (let i = 0; i < this._checksum.length; i++)
+      this._checksum[i] = 0;
+  }
+  update(input) {
+    for (let i = 0; i < input.length; i++) {
+      this._data[this._length] = input[i];
+      this._length++;
+      if (this._length == _MD2.BLOCK_SIZE) {
+        this._transform(input);
+        this._length = 0;
+      }
+    }
+    return this;
+  }
+  _transform(data) {
+    for (let i = 0; i < 16; ++i) {
+      this._state[i + 16] = this._data[i];
+      this._state[i + 32] = this._state[i + 16] ^ this._state[i];
+    }
+    let t = 0;
+    for (let i = 0; i < 18; ++i) {
+      for (let j = 0; j < 48; ++j) {
+        this._state[j] ^= STABLE[t];
+        t = this._state[j];
+      }
+      t = t + i & 255;
+    }
+    t = this._checksum[15];
+    for (let i = 0; i < 16; ++i) {
+      this._checksum[i] ^= STABLE[this._data[i] ^ t];
+      t = this._checksum[i];
+    }
+  }
+  digest() {
+    const toPad = _MD2.BLOCK_SIZE - this._length;
+    while (this._length < _MD2.BLOCK_SIZE)
+      this._data[this._length++] = toPad;
+    this._transform(this._data);
+    this._transform(this._checksum);
+    return this._state.slice();
+  }
+};
+
+// source/geometry/angle.ts
+var MAX_ANGLE_DEGREE = 360;
+var cap_angle_degree = (angle) => angle % MAX_ANGLE_DEGREE;
+var cap_angle_radian = (angle) => cap_angle_degree(degree_to_radian(angle));
+var radian_to_degree = (angle) => angle * (180 / Math.PI);
+var degree_to_radian = (angle) => angle * (Math.PI / 180);
+
+// source/geometry/circle.ts
+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 cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 3))
+      return new this([a[0], a[1]], a[2]);
+    if (check_number_array(a, 4)) {
+      const c = new this([a[0], a[1]], a[3]);
+      c.w = a[2];
+      return c;
+    }
+    if (has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "radius", "number"))
+      return new this(has_property(a, "w", "number") ? [a.x, a.y, a.w] : [a.x, a.y], a.radius);
+    if (check_string(a)) {
+      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) {
+    this.position = Vec2.resolve(position);
+    if (!check_number(radius))
+      throw new TypeError("expected number for radius");
+    this.radius = radius;
+  }
+  toArray() {
+    return [...this.position.toArray(), this.radius];
+  }
+  toJSON() {
+    return {
+      ...this.position.toJSON(),
+      radius: this.radius
+    };
+  }
+  toString() {
+    return `${this.position.toString()}|${this.radius}`;
+  }
+  clone() {
+    return new _Circle(this.position.clone(), this.radius);
+  }
+  equals(circle) {
+    const c = _Circle.resolve(circle);
+    return c.position.equals(c.position) && this.radius == c.radius;
+  }
+  inside(a) {
+    const circle = _Circle.resolve(a);
+    const distX = circle.x - this.x;
+    const distY = circle.y - this.y;
+    const dist = Math.sqrt(distX * distX + (distY + distY));
+    return dist <= this.radius + circle.radius;
+  }
+  insidePoint(a) {
+    return this.position.distance(a) <= this.radius;
+  }
+};
+
+// source/geometry/rectangle.ts
+var Rectangle = class _Rectangle {
+  position;
+  size;
+  get area() {
+    return this.width * this.height;
+  }
+  get perimeter() {
+    return this.width + this.width + this.height + this.height;
+  }
+  get x() {
+    return this.position.x;
+  }
+  set x(val) {
+    this.position.x = val;
+  }
+  get y() {
+    return this.position.y;
+  }
+  set y(val) {
+    this.position.y = val;
+  }
+  get w() {
+    return this.position.w;
+  }
+  set w(val) {
+    this.position.w = val;
+  }
+  get width() {
+    return this.size.width;
+  }
+  set width(val) {
+    this.size.width = val;
+  }
+  get height() {
+    return this.size.height;
+  }
+  set height(val) {
+    this.size.height = val;
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Rectangle", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if (check_number_array(a, 5)) {
+      const rect = new this(a[0], a[1], a[3], a[4]);
+      rect.w = a[2];
+      return rect;
+    }
+    if (check_string(a)) {
+      const [spos, ssize] = a.split("|");
+      const pos = Vec2.cast(spos);
+      const size = Size.cast(ssize);
+      if (typeof pos == "undefined" || typeof size == "undefined")
+        return void 0;
+      const rect = new this(pos.x, pos.y, size.width, size.height);
+      rect.w = pos.w;
+      return rect;
+    }
+    if (has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "width", "number") && has_property(a, "height", "number")) {
+      const rect = new this(a.x, a.y, a.width, a.height);
+      if (has_property(a, "w", "number"))
+        rect.w = a.w;
+      return rect;
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(a, b, c, d) {
+    const vec = Vec2.is(a) ? Vec2.resolve(a) : void 0;
+    const size = Size.is(b) ? Size.resolve(b) : void 0;
+    const x = typeof a == "number" ? a : vec?.x;
+    if (!check_number(x))
+      throw new TypeError("expected number for x position");
+    const y = typeof b == "number" ? b : vec?.y;
+    if (!check_number(y))
+      throw new TypeError("expected number for y position");
+    const width = typeof c == "number" ? c : size?.width;
+    if (!check_number(width))
+      throw new TypeError("expected number for width");
+    const height = typeof d == "number" ? d : size?.height;
+    if (!check_number(height))
+      throw new TypeError("expected number for height");
+    this.position = new Vec2(x, y);
+    this.size = new Size(width, height);
+  }
+  toArray(w = false) {
+    return [...this.position.toArray(w), ...this.size.toArray()];
+  }
+  toString(w = false) {
+    return `${this.position.toString(w)}|${this.size.toString()}`;
+  }
+  toJSON() {
+    return { ...this.position.toJSON(), ...this.size.toJSON() };
+  }
+  toBoundingBox() {
+    return [this.x, this.x + this.width, this.y, this.y + this.height];
+  }
+  clone() {
+    return new _Rectangle(this.position.clone(), this.size.clone());
+  }
+  equals(rectangle) {
+    const rect = _Rectangle.resolve(rectangle);
+    return this.position.equals(rect.position) && this.size.equals(rect.size);
+  }
+};
+
+// source/geometry/bbox.ts
+var BoundingBox = class _BoundingBox {
+  left;
+  right;
+  top;
+  bottom;
+  get width() {
+    return this.right - this.left;
+  }
+  set width(val) {
+    this.right = this.left + val;
+  }
+  get height() {
+    return this.bottom - this.top;
+  }
+  set height(val) {
+    this.bottom = this.top + val;
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("BoundingBox", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if (has_property(a, "left", "number") && has_property(a, "right", "number") && has_property(a, "top", "number") && has_property(a, "bottom", "number"))
+      return new this(a.left, a.right, a.top, a.bottom);
+    if (check_string(a)) {
+      const parts = a.split(",");
+      if (check_string_array(parts, 4))
+        return this.cast(parts.map((v) => parseFloat(v)));
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(left, right, top, bottom) {
+    if (!check_number(left))
+      throw new TypeError("expected number for left");
+    if (!check_number(right))
+      throw new TypeError("expected number for right");
+    if (!check_number(top))
+      throw new TypeError("expected number for top");
+    if (!check_number(bottom))
+      throw new TypeError("expected number for bottom");
+    this.left = left;
+    this.right = right;
+    this.top = top;
+    this.bottom = bottom;
+  }
+  toArray() {
+    return [this.left, this.right, this.top, this.bottom];
+  }
+  toString() {
+    return `${this.left},${this.right},${this.top},${this.bottom}`;
+  }
+  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(bbox) {
+    const b = _BoundingBox.resolve(bbox);
+    return this.left == b.left && this.right == b.right && this.top == b.top && this.bottom == b.bottom;
+  }
+  toSquare() {
+    return new Size(this.width, this.height);
+  }
+  toRectangle() {
+    return new Rectangle(this.left, this.top, this.width, this.height);
+  }
+  inside(a) {
+    const bbox = _BoundingBox.resolve(a);
+    return this.right >= bbox.left && bbox.right >= this.left && this.bottom >= bbox.top && bbox.bottom >= this.top;
+  }
+  insidePoint(a) {
+    const point = Vec2.resolve(a);
+    return this.left <= point.x && this.right >= point.x && this.top <= point.y && this.bottom >= point.y;
+  }
+  insideCircle(a) {
+    const circle = Circle.resolve(a);
+    const center = Vec2.resolve(circle).add(circle.radius);
+    const bboxhe = new Vec2(this.width / 2, this.height / 2);
+    const bboxcenter = new Vec2(this.left + bboxhe.x, this.top + bboxhe.y);
+    let diff = center.subtract(bboxcenter);
+    const clamped = Vec2.clamp(diff, bboxhe.invert(), bboxhe);
+    const closest = bboxcenter.add(clamped);
+    diff = closest.subtract(center);
+    return diff.length() < circle.radius;
+  }
+};
+
+// source/geometry/triangle.ts
+var ATriangle = class {
+  constructor(A, B, C) {
+    this.A = A;
+    this.B = B;
+    this.C = C;
+  }
+  get alpha() {
+    return Math.acos((this.b * this.b + this.c * this.c - this.a * this.a) / (2 * this.b * this.c));
+  }
+  get beta() {
+    return Math.acos((this.c * this.c + this.a * this.a - this.b * this.b) / (2 * this.c * this.a));
+  }
+  get gamma() {
+    return Math.acos((this.a * this.a + this.b * this.b - this.c * this.c) / (2 * this.a * this.b));
+  }
+  get perimeter() {
+    return this.a + this.b + this.c;
+  }
+  get semiperimeter() {
+    return this.perimeter / 2;
+  }
+  get area() {
+    return Math.sqrt(this.semiperimeter * (this.semiperimeter - this.a) * (this.semiperimeter - this.b) * (this.semiperimeter - this.c));
+  }
+  get base() {
+    return 2 * (this.area / (this.a * Math.sin(this.gamma)));
+  }
+  get height() {
+    return 2 * (this.area / this.base);
+  }
+};
+var Triangle2D = class extends ATriangle {
+  get a() {
+    return Vec2.fromPoints(this.B, this.C).length();
+  }
+  get b() {
+    return Vec2.fromPoints(this.A, this.C).length();
+  }
+  get c() {
+    return Vec2.fromPoints(this.A, this.B).length();
+  }
+};
+var Triangle3D = class extends ATriangle {
+  get a() {
+    return Vec3.fromPoints(this.B, this.C).length();
+  }
+  get b() {
+    return Vec3.fromPoints(this.A, this.C).length();
+  }
+  get c() {
+    return Vec3.fromPoints(this.A, this.B).length();
+  }
+};
+
+// source/matrices/mat3.ts
+var Mat3 = class _Mat3 {
+  _raw;
+  get m00() {
+    return this._raw[0];
+  }
+  set m00(val) {
+    this._raw[0] = val;
+  }
+  get m01() {
+    return this._raw[1];
+  }
+  set m01(val) {
+    this._raw[1] = val;
+  }
+  get m02() {
+    return this._raw[2];
+  }
+  set m02(val) {
+    this._raw[2] = val;
+  }
+  get m10() {
+    return this._raw[3];
+  }
+  set m10(val) {
+    this._raw[3] = val;
+  }
+  get m11() {
+    return this._raw[4];
+  }
+  set m11(val) {
+    this._raw[4] = val;
+  }
+  get m12() {
+    return this._raw[5];
+  }
+  set m12(val) {
+    this._raw[5] = val;
+  }
+  get m20() {
+    return this._raw[6];
+  }
+  set m20(val) {
+    this._raw[6] = val;
+  }
+  get m21() {
+    return this._raw[7];
+  }
+  set m21(val) {
+    this._raw[7] = val;
+  }
+  get m22() {
+    return this._raw[8];
+  }
+  set m22(val) {
+    this._raw[8] = val;
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Mat3", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 9)) {
+      return new this(a);
+    }
+    if (check_array(a, void 0, 3)) {
+      const row0 = a[0], row1 = a[1], row2 = a[2];
+      if (check_number_array(row0, 3) && check_number_array(row1, 3) && check_number_array(row2, 3))
+        return new this([
+          row0[0],
+          row0[1],
+          row0[2],
+          row1[0],
+          row1[1],
+          row1[2],
+          row2[0],
+          row2[1],
+          row2[2]
+        ]);
+    }
+    if (check_string(a)) {
+      const parts = a.split(",");
+      if (check_string_array(parts, 9))
+        return this.cast(parts.map((i) => parseFloat(i)));
+    }
+    if (has_property(a, "m00", "number") && has_property(a, "m01", "number") && has_property(a, "m02", "number") && has_property(a, "m10", "number") && has_property(a, "m11", "number") && has_property(a, "m12", "number") && has_property(a, "m20", "number") && has_property(a, "m21", "number") && has_property(a, "m22", "number"))
+      return new this([
+        a.m00,
+        a.m01,
+        a.m02,
+        a.m10,
+        a.m11,
+        a.m12,
+        a.m20,
+        a.m21,
+        a.m22
+      ]);
+    if (check_number(a)) {
+      return new this([a, a, a, a, a, a, a, a, a]);
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  static projection(width, height) {
+    return new this([
+      2 / width,
+      0,
+      0,
+      0,
+      -2 / height,
+      0,
+      -1,
+      1,
+      1
+    ]);
+  }
+  constructor(init = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
+    if (!check_number_array(init, 9))
+      throw new TypeError("expected a number array with 9 elements");
+    this._raw = init;
+  }
+  toArray() {
+    return [
+      this.m00,
+      this.m01,
+      this.m02,
+      this.m10,
+      this.m11,
+      this.m12,
+      this.m20,
+      this.m21,
+      this.m22
+    ];
+  }
+  toNestetArray() {
+    return [
+      [this.m00, this.m01, this.m02],
+      [this.m10, this.m11, this.m12],
+      [this.m20, this.m21, this.m22]
+    ];
+  }
+  toJSON() {
+    return {
+      m00: this.m00,
+      m01: this.m01,
+      m02: this.m02,
+      m10: this.m10,
+      m11: this.m11,
+      m12: this.m12,
+      m20: this.m20,
+      m21: this.m21,
+      m22: this.m22
+    };
+  }
+  toString() {
+    return `${this.m00},${this.m01},${this.m02},${this.m10},${this.m11},${this.m12},${this.m20},${this.m21},${this.m22}`;
+  }
+  clone() {
+    return new _Mat3([
+      this.m00,
+      this.m01,
+      this.m02,
+      this.m10,
+      this.m11,
+      this.m12,
+      this.m20,
+      this.m21,
+      this.m22
+    ]);
+  }
+  equals(mat) {
+    const m = _Mat3.resolve(mat);
+    for (let index = 0; index < this._raw.length; index++)
+      if (this._raw[index] != m._raw[index])
+        return false;
+    return true;
+  }
+  add(mat) {
+    const b = _Mat3.resolve(mat);
+    const m = new _Mat3();
+    for (let index = 0; index < this._raw.length; index++)
+      m._raw[index] = this._raw[index] + b._raw[index];
+    return m;
+  }
+  subtract(mat) {
+    const b = _Mat3.resolve(mat);
+    const m = new _Mat3();
+    for (let index = 0; index < this._raw.length; index++)
+      m._raw[index] = this._raw[index] - b._raw[index];
+    return m;
+  }
+  multiply(a) {
+    if (check_number(a))
+      return new _Mat3([
+        this.m00 * a,
+        this.m01 * a,
+        this.m02 * a,
+        this.m10 * a,
+        this.m11 * a,
+        this.m12 * a,
+        this.m20 * a,
+        this.m21 * a,
+        this.m22 * a
+      ]);
+    const b = _Mat3.resolve(a);
+    return new _Mat3([
+      b.m00 * this.m00 + b.m01 * this.m10 + b.m02 * this.m20,
+      b.m00 * this.m01 + b.m01 * this.m11 + b.m02 * this.m21,
+      b.m00 * this.m02 + b.m01 * this.m12 + b.m02 * this.m22,
+      b.m10 * this.m00 + b.m11 * this.m10 + b.m12 * this.m20,
+      b.m10 * this.m01 + b.m11 * this.m11 + b.m12 * this.m21,
+      b.m10 * this.m02 + b.m11 * this.m12 + b.m12 * this.m22,
+      b.m20 * this.m00 + b.m21 * this.m10 + b.m22 * this.m20,
+      b.m20 * this.m01 + b.m21 * this.m11 + b.m22 * this.m21,
+      b.m20 * this.m02 + b.m21 * this.m12 + b.m22 * this.m22
+    ]);
+  }
+  translate(...args) {
+    const vec = Vec2.resolveArgs(args);
+    return this.multiply([
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      vec.x,
+      vec.y,
+      1
+    ]);
+  }
+  rotate(angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return this.multiply([
+      c,
+      -s,
+      0,
+      s,
+      c,
+      0,
+      0,
+      0,
+      1
+    ]);
+  }
+  scale(...args) {
+    const vec = Vec2.resolve(args);
+    return this.multiply([
+      vec.x,
+      0,
+      0,
+      0,
+      vec.y,
+      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() {
+    const det = this.determinant();
+    return new _Mat3([
+      (this.m11 * this.m22 - this.m21 * this.m12) * det,
+      (this.m02 * this.m21 - this.m01 * this.m22) * det,
+      (this.m01 * this.m12 - this.m02 * this.m11) * det,
+      (this.m12 * this.m20 - this.m10 * this.m22) * det,
+      (this.m00 * this.m22 - this.m02 * this.m20) * det,
+      (this.m10 * this.m02 - this.m00 * this.m12) * det,
+      (this.m10 * this.m21 - this.m20 * this.m11) * det,
+      (this.m20 * this.m01 - this.m00 * this.m21) * det,
+      (this.m00 * this.m11 - this.m10 * this.m01) * det
+    ]);
+  }
+  toMat4() {
+    return [
+      this.m00,
+      this.m01,
+      this.m02,
+      0,
+      this.m10,
+      this.m11,
+      this.m12,
+      0,
+      this.m20,
+      this.m20,
+      this.m22,
+      0,
+      0,
+      0,
+      0,
+      1
+    ];
+  }
+};
+
+// source/matrices/mat4.ts
+var Mat4 = class _Mat4 {
+  _raw;
+  get m00() {
+    return this._raw[0];
+  }
+  set m00(val) {
+    this._raw[0] = val;
+  }
+  get m01() {
+    return this._raw[1];
+  }
+  set m01(val) {
+    this._raw[1] = val;
+  }
+  get m02() {
+    return this._raw[2];
+  }
+  set m02(val) {
+    this._raw[2] = val;
+  }
+  get m03() {
+    return this._raw[3];
+  }
+  set m03(val) {
+    this._raw[3] = val;
+  }
+  get m10() {
+    return this._raw[4];
+  }
+  set m10(val) {
+    this._raw[4] = val;
+  }
+  get m11() {
+    return this._raw[5];
+  }
+  set m11(val) {
+    this._raw[5] = val;
+  }
+  get m12() {
+    return this._raw[6];
+  }
+  set m12(val) {
+    this._raw[6] = val;
+  }
+  get m13() {
+    return this._raw[7];
+  }
+  set m13(val) {
+    this._raw[7] = val;
+  }
+  get m20() {
+    return this._raw[8];
+  }
+  set m20(val) {
+    this._raw[8] = val;
+  }
+  get m21() {
+    return this._raw[9];
+  }
+  set m21(val) {
+    this._raw[9] = 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];
+  }
+  set m33(val) {
+    this._raw[15] = val;
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Mat4", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 16)) {
+      return new this(a);
+    }
+    if (check_array(a, void 0, 4)) {
+      const row0 = a[0], row1 = a[1], row2 = a[2], row3 = a[3];
+      if (check_number_array(row0, 4) && check_number_array(row1, 4) && check_number_array(row2, 4) && check_number_array(row3, 4))
+        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 (check_string(a)) {
+      const parts = a.split(",");
+      if (check_string_array(parts, 16))
+        return this.cast(parts.map((i) => parseFloat(i)));
+    }
+    if (has_property(a, "m00", "number") && has_property(a, "m01", "number") && has_property(a, "m02", "number") && has_property(a, "m03", "number") && has_property(a, "m10", "number") && has_property(a, "m11", "number") && has_property(a, "m12", "number") && has_property(a, "m13", "number") && has_property(a, "m20", "number") && has_property(a, "m21", "number") && has_property(a, "m22", "number") && has_property(a, "m23", "number") && has_property(a, "m30", "number") && has_property(a, "m31", "number") && has_property(a, "m32", "number") && has_property(a, "m33", "number"))
+      return new this([
+        a.m00,
+        a.m01,
+        a.m02,
+        a.m03,
+        a.m10,
+        a.m11,
+        a.m12,
+        a.m13,
+        a.m20,
+        a.m21,
+        a.m22,
+        a.m23,
+        a.m30,
+        a.m31,
+        a.m32,
+        a.m33
+      ]);
+    if (check_number(a)) {
+      return new this([a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a]);
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  static orthographic(left, right, bottom, top, near, far) {
+    return new this([
+      2 / (right - left),
+      0,
+      0,
+      0,
+      0,
+      2 / (top - bottom),
+      0,
+      0,
+      0,
+      0,
+      2 / (near - far),
+      0,
+      (left + right) / (left - right),
+      (bottom + top) / (bottom - top),
+      (near + far) / (near - far),
+      1
+    ]);
+  }
+  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]) {
+    if (!check_number_array(init, 16))
+      throw new TypeError("expected a number array with 16 elements");
+    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}`;
+  }
+  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(mat) {
+    const m = _Mat4.resolve(mat);
+    for (let index = 0; index < this._raw.length; index++)
+      if (this._raw[index] != m._raw[index])
+        return false;
+    return true;
+  }
+  add(mat) {
+    const b = _Mat4.resolve(mat);
+    const m = new _Mat4();
+    for (let index = 0; index < this._raw.length; index++)
+      m._raw[index] = this._raw[index] + b._raw[index];
+    return m;
+  }
+  subtract(mat) {
+    const b = _Mat4.resolve(mat);
+    const m = new _Mat4();
+    for (let index = 0; index < this._raw.length; index++)
+      m._raw[index] = this._raw[index] - b._raw[index];
+    return m;
+  }
+  multiply(a) {
+    if (check_number(a)) {
+      return new _Mat4([
+        this.m00 * a,
+        this.m01 * a,
+        this.m02 * a,
+        this.m03 * a,
+        this.m10 * a,
+        this.m11 * a,
+        this.m12 * a,
+        this.m13 * a,
+        this.m20 * a,
+        this.m21 * a,
+        this.m22 * a,
+        this.m23 * a,
+        this.m30 * a,
+        this.m31 * a,
+        this.m32 * a,
+        this.m33 * a
+      ]);
+    }
+    if (_Mat4.is(a)) {
+      const b = _Mat4.resolve(a);
+      return new _Mat4([
+        b.m00 * this.m00 + b.m01 * this.m10 + b.m02 * this.m20 + b.m03 * this.m30,
+        b.m00 * this.m01 + b.m01 * this.m11 + b.m02 * this.m21 + b.m03 * this.m31,
+        b.m00 * this.m02 + b.m01 * this.m12 + b.m02 * this.m22 + b.m03 * this.m32,
+        b.m00 * this.m03 + b.m01 * this.m13 + b.m02 * this.m23 + b.m03 * this.m33,
+        b.m10 * this.m00 + b.m11 * this.m10 + b.m12 * this.m20 + b.m13 * this.m30,
+        b.m10 * this.m01 + b.m11 * this.m11 + b.m12 * this.m21 + b.m13 * this.m31,
+        b.m10 * this.m02 + b.m11 * this.m12 + b.m12 * this.m22 + b.m13 * this.m32,
+        b.m10 * this.m03 + b.m11 * this.m13 + b.m12 * this.m23 + b.m13 * this.m33,
+        b.m20 * this.m00 + b.m21 * this.m10 + b.m22 * this.m20 + b.m23 * this.m30,
+        b.m20 * this.m01 + b.m21 * this.m11 + b.m22 * this.m21 + b.m23 * this.m31,
+        b.m20 * this.m02 + b.m21 * this.m12 + b.m22 * this.m22 + b.m23 * this.m32,
+        b.m20 * this.m03 + b.m21 * this.m13 + b.m22 * this.m23 + b.m23 * this.m33,
+        b.m30 * this.m00 + b.m31 * this.m10 + b.m32 * this.m20 + b.m33 * this.m30,
+        b.m30 * this.m01 + b.m31 * this.m11 + b.m32 * this.m21 + b.m33 * this.m31,
+        b.m30 * this.m02 + b.m31 * this.m12 + b.m32 * this.m22 + b.m33 * this.m32,
+        b.m30 * this.m03 + b.m31 * this.m13 + b.m32 * this.m23 + b.m33 * this.m33
+      ]);
+    }
+    if (Vec3.is(a)) {
+      const b = Vec3.resolve(a);
+      const vec = new Vec3(
+        b.x * this.m00 + b.y * this.m10 + b.z * this.m20 + this.m30,
+        b.x * this.m01 + b.y * this.m11 + b.z * this.m21 + this.m31,
+        b.x * this.m02 + b.y * this.m12 + b.z * this.m22 + this.m32,
+        b.x * this.m03 + b.y * this.m13 + b.z * this.m23 + this.m33
+      );
+      if (vec.w != 0)
+        return vec.divide(vec.w);
+      return vec;
+    }
+    throw new ResolveError("Mat4 or Vec3 or number", a);
+  }
+  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
+    ]);
+  }
+  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
+    ]);
+  }
+  rotateZ(angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return this.multiply([
+      c,
+      s,
+      0,
+      0,
+      -s,
+      c,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
+  }
+  rotate(...args) {
+    const vec = Vec3.resolveArgs(args);
+    return this.rotateX(vec.x).rotateY(vec.y).rotateZ(vec.z);
+  }
+  scale(...args) {
+    const vec = Vec3.resolveArgs(args);
+    return this.multiply([
+      vec.x,
+      0,
+      0,
+      0,
+      0,
+      vec.y,
+      0,
+      0,
+      0,
+      0,
+      vec.z,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
+  }
+  inverse() {
+    return new _Mat4([
+      this.m00,
+      this.m10,
+      this.m20,
+      0,
+      this.m01,
+      this.m11,
+      this.m21,
+      0,
+      this.m02,
+      this.m12,
+      this.m22,
+      0,
+      -(this.m30 * this.m00 + this.m31 * this.m10 + this.m32 * this.m20),
+      -(this.m30 * this.m01 + this.m31 * this.m11 + this.m32 * this.m21),
+      -(this.m30 * this.m02 + this.m31 * this.m12 + this.m32 * this.m22),
+      1
+    ]);
+  }
+  toMat3() {
+    return [
+      this.m00,
+      this.m01,
+      this.m03,
+      this.m10,
+      this.m11,
+      this.m13,
+      this.m30,
+      this.m31,
+      this.m33
+    ];
+  }
+};
+
+// source/color.ts
+function _hex_to_array(hex) {
+  if (!check_hex(hex))
+    return void 0;
+  const part = get_hex_part(hex);
+  const a = parseInt(part.substring(0, 2), 16) / 255;
+  const b = parseInt(part.substring(2, 4), 16) / 255;
+  const c = parseInt(part.substring(4, 6), 16) / 255;
+  const d = part.length == 8 ? parseInt(hex.substring(6, 8), 16) / 255 : 1;
+  return [a, b, c, d];
+}
+function _number_to_rgb(number) {
+  const blue = number & 255;
+  const green = (number & 65280) >>> 8;
+  const red = (number & 16711680) >>> 16;
+  return [red / 255, green / 255, blue / 255];
+}
+function _number_to_rgba(number) {
+  const alpha = number & 255;
+  const blue = (number & 65280) >>> 8;
+  const green = (number & 16711680) >>> 16;
+  const red = (number & 4278190080) >>> 24;
+  return [red / 255, green / 255, blue / 255, alpha / 255];
+}
+function _fix_integer(number) {
+  return number * 255 | 0;
+}
+var RGBAColor = class _RGBAColor {
+  _red;
+  get red() {
+    return this._red;
+  }
+  set red(val) {
+    this._red = clamp(val, 0, 1);
+  }
+  _green;
+  get green() {
+    return this._green;
+  }
+  set green(val) {
+    this._green = clamp(val, 0, 1);
+  }
+  _blue;
+  get blue() {
+    return this._blue;
+  }
+  set blue(val) {
+    this._blue = clamp(val, 0, 1);
+  }
+  _alpha;
+  get alpha() {
+    return this._alpha;
+  }
+  set alpha(val) {
+    this._alpha = clamp(val, 0, 1);
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("RGBAColor", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 3) || check_number_array(a, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if (has_property(a, "red", "number") && has_property(a, "green", "number") && has_property(a, "blue", "number"))
+      return new this(a.red, a.green, a.blue, has_property(a, "alpha", "number") ? a.alpha : void 0);
+    if (check_number(a)) {
+      const hex = a.toString(16);
+      const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
+      return this.cast(convert(a));
+    }
+    if (check_string(a)) {
+      if (a.startsWith("rgb")) {
+        const hasAlpha = a.startsWith("rgba");
+        const offset = hasAlpha ? 5 : 4;
+        const parts = a.substring(offset, a.indexOf(")", offset)).split(",");
+        if (check_string_array(parts, hasAlpha ? 4 : 3))
+          return this.cast(parts.map((v) => parseInt(v) / 255));
+      }
+      return this.cast(_hex_to_array(a));
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  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);
+  }
+  toArray(withAlpha = false) {
+    return withAlpha ? [this.red, this.green, this.blue, this.alpha] : this.alpha == 1 ? [this.red, this.green, this.blue] : this.toArray(true);
+  }
+  toJSON(withAlpha = false) {
+    return withAlpha ? {
+      red: this.red,
+      green: this.green,
+      blue: this.blue,
+      alpha: this.alpha
+    } : this.alpha == 1 ? { red: this.red, green: this.green, blue: this.blue } : this.toJSON(true);
+  }
+  toString(withAlpha = false) {
+    return withAlpha ? `rgba(${_fix_integer(this.red)},${_fix_integer(this.green)},${_fix_integer(this.blue)},${_fix_integer(this.alpha)})` : this.alpha == 1 ? `rgb(${_fix_integer(this.red)},${_fix_integer(this.green)},${_fix_integer(this.blue)})` : this.toString(true);
+  }
+  toHSL(withAlpha = true) {
+    const red = this.red, green = this.green, blue = this.blue;
+    const min = Math.min(red, green, blue), max = Math.max(red, green, blue);
+    const luminace = (min + max) / 2;
+    if (min == max)
+      return new HSLColor(0, 0, luminace, withAlpha ? this.alpha : void 0);
+    const d = max - min;
+    const saturation = luminace > 0.5 ? d / (2 - max - min) : d / (max + min);
+    if (max == red)
+      return new HSLColor(((green - blue) / d + (green < blue ? 6 : 0)) / 6, saturation, luminace);
+    if (max == green)
+      return new HSLColor(((blue - red) / d + 2) / 6, saturation, luminace);
+    if (max == blue)
+      return new HSLColor(((red - green) / d + 4) / 6, saturation, luminace);
+    return new HSLColor(0, saturation, luminace, withAlpha ? this.alpha : void 0);
+  }
+  invert(withAlpha = false) {
+    return new _RGBAColor(
+      1 - this.red,
+      1 - this.green,
+      1 - this.blue,
+      withAlpha ? 1 - this.alpha : this.alpha
+    );
+  }
+};
+var HSLColor = class _HSLColor {
+  _hue;
+  get hue() {
+    return this._hue;
+  }
+  set hue(val) {
+    this._hue = clamp(val, 0, 1);
+  }
+  _saturation;
+  get saturation() {
+    return this._saturation;
+  }
+  set saturation(val) {
+    this._saturation = clamp(val, 0, 1);
+  }
+  _luminace;
+  get luminace() {
+    return this._luminace;
+  }
+  set luminace(val) {
+    this._luminace = clamp(val, 0, 1);
+  }
+  _alpha;
+  get alpha() {
+    return this._alpha;
+  }
+  set alpha(val) {
+    this._alpha = clamp(val, 0, 1);
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("HSLColor", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 3) || check_number_array(a, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if (has_property(a, "hue", "number") && has_property(a, "saturation", "number") && has_property(a, "luminace", "number"))
+      return new this(a.hue, a.saturation, a.luminace, has_property(a, "alpha", "number") ? a.alpha : void 0);
+    if (check_number(a)) {
+      const hex = a.toString(16);
+      const convert = hex.length <= 6 ? _number_to_rgb : _number_to_rgba;
+      return this.cast(convert(a));
+    }
+    if (check_string(a)) {
+      if (a.startsWith("hsl")) {
+        const hasAlpha = a.startsWith("hsla");
+        const offset = hasAlpha ? 5 : 4;
+        const parts = a.substring(offset, a.indexOf(")", offset)).split(",");
+        if (check_string_array(parts, hasAlpha ? 4 : 3))
+          return this.cast(parts.map((v) => parseInt(v) / 255));
+      }
+      return this.cast(_hex_to_array(a));
+    }
+    return void 0;
+  }
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  constructor(hue, saturation, luminace, alpha = 1) {
+    if (!check_number(hue))
+      throw new TypeError("expected number for hue");
+    if (!check_number(saturation))
+      throw new TypeError("expected number for saturation");
+    if (!check_number(luminace))
+      throw new TypeError("expected number for luminace");
+    if (!check_number(alpha))
+      throw new TypeError("expected number for alpha");
+    this._hue = clamp(hue, 0, 1);
+    this._saturation = clamp(saturation, 0, 1);
+    this._luminace = clamp(luminace, 0, 1);
+    this._alpha = clamp(alpha, 0, 1);
+  }
+  toArray(withAlpha = false) {
+    return withAlpha ? [this.hue, this.saturation, this.luminace, this.alpha] : this.alpha == 1 ? [this.hue, this.saturation, this.luminace] : this.toArray(true);
+  }
+  toJSON(withAlpha = false) {
+    return withAlpha ? {
+      hue: this.hue,
+      saturation: this.saturation,
+      luminace: this.luminace,
+      alpha: this.alpha
+    } : this.alpha == 1 ? { hue: this.hue, saturation: this.saturation, luminace: this.luminace } : this.toJSON(true);
+  }
+  toString(withAlpha = false) {
+    return withAlpha ? `hsla(${_fix_integer(this.hue)},${_fix_integer(this.saturation)},${_fix_integer(this.luminace)},${_fix_integer(this.alpha)})` : this.alpha == 1 ? `hsl(${_fix_integer(this.hue)},${_fix_integer(this.saturation)},${_fix_integer(this.luminace)})` : this.toString(true);
+  }
+  toRGB(withAlpha = true) {
+    if (this.saturation == 0)
+      return new RGBAColor(this.luminace * 255, this.luminace * 255, this.luminace * 255, withAlpha ? this.alpha : void 0);
+    const q = this.luminace < 0.5 ? this.luminace * (1 + this.saturation) : this.luminace + this.saturation - this.luminace * this.saturation;
+    const p = 2 * this.luminace - q;
+    function _hue_2_rgb(t) {
+      let _t = t;
+      if (_t < 0)
+        _t++;
+      if (_t > 1)
+        _t--;
+      if (_t < 1 / 6)
+        return p + (q - p) * 6 * _t;
+      if (_t < 1 / 2)
+        return q;
+      if (_t < 2 / 3)
+        return p + (q - p) * (2 / 3 - _t) * 6;
+      return p;
+    }
+    return new RGBAColor(_hue_2_rgb(this.hue + 1 / 3) * 255, _hue_2_rgb(this.hue) * 255, _hue_2_rgb(this.hue - 1 / 3) * 255, withAlpha ? this.alpha : void 0);
+  }
+  invert(withAlpha = false) {
+    return new _HSLColor(
+      1 - this.hue,
+      1 - this.saturation,
+      1 - this.luminace,
+      withAlpha ? 1 - this.alpha : this.alpha
+    );
+  }
+};
+function resolveColor(a, preferHSL = false) {
+  const value = castColor(a, preferHSL);
+  if (typeof value != "undefined")
+    return value;
+  throw new ResolveError("Color", a);
+}
+function castColor(a, preferHSL = false) {
+  const results = [];
+  try {
+    const rgba = RGBAColor.resolve(a);
+    results.push(rgba);
+  } catch (e) {
+  }
+  try {
+    const hsla = HSLColor.resolve(a);
+    results.push(hsla);
+  } catch (e) {
+  }
+  let offset = preferHSL ? 1 : 0;
+  const firstItem = results[offset];
+  if (firstItem)
+    return firstItem;
+  const secondItem = results[offset + 1];
+  if (secondItem)
+    return secondItem;
+  return void 0;
+}
+
+// source/quaternion.ts
+var Quaternion = class _Quaternion {
+  w;
+  x;
+  y;
+  z;
+  static is(a) {
+    return typeof this.cast(a) != "undefined";
+  }
+  static resolve(a) {
+    const value = this.cast(a);
+    if (typeof value != "undefined")
+      return value;
+    throw new ResolveError("Quaternion", a);
+  }
+  static cast(a) {
+    if (a == null || typeof a == "undefined")
+      return void 0;
+    if (check_number_array(a, 4))
+      return new this(a[0], a[1], a[2], a[3]);
+    if (has_property(a, "w", "number") && has_property(a, "x", "number") && has_property(a, "y", "number") && has_property(a, "z", "number"))
+      return new this(a.w, a.x, a.y, a.z);
+    if (check_string(a)) {
+      const parts = a.replaceAll(" ", "").split("+");
+      if (check_string_array(parts, 4)) {
+        const [sw, sxi, syj, szk] = parts;
+        if (sxi.endsWith("i") && syj.endsWith("j") && szk.endsWith("k"))
+          return this.cast([
+            parseFloat(sw),
+            parseFloat(sxi.substring(0, sxi.length - 1)),
+            parseFloat(syj.substring(0, syj.length - 1)),
+            parseFloat(szk.substring(0, szk.length - 1))
+          ]);
+      }
+    }
+    return void 0;
+  }
+  static fromAxisAngle(axis, angle) {
+    const vec = Vec3.resolve(axis);
+    const hangle = angle * 0.5;
+    const sin2 = Math.sin(hangle);
+    const cos2 = Math.cos(hangle);
+    const length = sin2 / Math.sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
+    return new this(cos2, vec.x * length, vec.y * length, vec.z * length);
+  }
+  static 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
+    );
+  }
+  constructor(w = 0, x = 0, y = 0, z = 0) {
+    if (!check_number(w))
+      throw new TypeError("expected number for w");
+    if (!check_number(x))
+      throw new TypeError("expected number for x");
+    if (!check_number(y))
+      throw new TypeError("expected number for x");
+    if (!check_number(z))
+      throw new TypeError("expected number for w");
+    this.w = w;
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  toArray() {
+    return [this.w, this.x, this.y, this.z];
+  }
+  toString() {
+    return `${this.w} + ${this.x}i + ${this.y}j + ${this.z}k`;
+  }
+  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(a) {
+    const quat = _Quaternion.resolve(a);
+    return new _Quaternion(
+      this.w + quat.w,
+      this.x + quat.x,
+      this.y + quat.y,
+      this.z + quat.z
+    );
+  }
+  offset(a) {
+    const quat = _Quaternion.resolve(a);
+    this.w += quat.w;
+    this.x += quat.x;
+    this.y += quat.y;
+    this.z += quat.z;
+    return this;
+  }
+  subtract(a) {
+    const quat = _Quaternion.resolve(a);
+    return new _Quaternion(
+      this.w - quat.w,
+      this.x - quat.x,
+      this.y - quat.y,
+      this.z - quat.z
+    );
+  }
+  negative() {
+    return new _Quaternion(-this.w, -this.x, -this.y, -this.z);
+  }
+  length(sqrt = true) {
+    const value = this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
+    return sqrt ? Math.sqrt(value) : value;
+  }
+  normalize() {
+    let length = this.length();
+    if (length < EPSILON)
+      return new _Quaternion();
+    length = 1 / length;
+    return new _Quaternion(this.w * length, this.x * length, this.y * length, this.z * length);
+  }
+  multiply(a) {
+    const quat = _Quaternion.resolve(a);
+    return new _Quaternion(
+      this.w * quat.w - this.x * quat.x - this.y * quat.y - this.z * quat.z,
+      this.w * quat.x + this.x * quat.w + this.y * quat.z - this.z * quat.y,
+      this.w * quat.y + this.y * quat.w + this.z * quat.x - this.x * quat.z,
+      this.w * quat.z + this.z * quat.w + this.x * quat.y - this.y * quat.x
+    );
+  }
+  multiplyVector(...args) {
+    const vec = Vec3.resolveArgs(args);
+    const ix = this.w * vec.x + this.y * vec.y - this.z * vec.y;
+    const iy = this.w * vec.y + this.z * vec.x - this.x * vec.z;
+    const iz = this.w * vec.z + this.x * vec.y - this.y * vec.x;
+    const iw = -this.w * vec.x - this.y * vec.y - this.z * vec.z;
+    return new Vec3(
+      ix * this.w + iw * -this.x + iy * -this.z - iz * -this.y,
+      iy * this.w + iw * -this.y + iz * -this.x - ix * -this.z,
+      iz * this.w + iw * -this.z + ix * -this.y - iy * -this.x
+    );
+  }
+  scale(scalar) {
+    return new _Quaternion(this.w * scalar, this.x * scalar, this.y * scalar, this.z * scalar);
+  }
+  dot(a) {
+    const quat = _Quaternion.resolve(a);
+    return this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z;
+  }
+  inverse() {
+    let length = this.length(false);
+    if (length == 0)
+      return new _Quaternion();
+    length = 1 / length;
+    return new _Quaternion(this.w * length, -this.x * length, -this.y * length, -this.z * length);
+  }
+  divide(a) {
+    const quat = _Quaternion.resolve(a);
+    let length = quat.length(false);
+    if (length == 0) return new _Quaternion();
+    length = 1 / length;
+    return new _Quaternion(
+      (this.w * quat.w + this.x * quat.x + this.y * quat.y + this.z * quat.z) * length,
+      (this.x * quat.w - this.w * quat.x - this.y * quat.z + this.z * quat.y) * length,
+      (this.y * quat.w - this.w * quat.y - this.z * quat.x + this.x * quat.z) * length,
+      (this.z * quat.w - this.w * quat.z - this.x * quat.y + this.y * quat.x) * length
+    );
+  }
+  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);
+    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(log_hypot(this.w, this.x), Math.atan2(this.x, this.w));
+    const length = this.length(false);
+    const length2 = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    const scale = Math.atan2(length2, this.w) / length;
+    return new _Quaternion(Math.log(length) * 0.5, this.x * scale, this.y * scale, this.z * scale);
+  }
+  toVector() {
+    return new Vec3(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 new Mat3([
+      1 - 2 * (this.y * this.y + this.z * this.z),
+      2 * (this.x * this.y - this.w * this.z),
+      2 * (this.x * this.z + this.w * this.y),
+      2 * (this.x * this.y + this.w * this.z),
+      1 - 2 * (this.x * this.x + this.z * this.z),
+      2 * (this.y * this.z - this.w * this.x),
+      2 * (this.x * this.z - this.w * this.y),
+      2 * (this.y * this.z + this.w * this.x),
+      1 - 2 * (this.x * this.x + this.y * this.y)
+    ]);
+  }
+  toMat4() {
+    return new Mat4([
+      1 - 2 * (this.y * this.y + this.z * this.z),
+      2 * (this.x * this.y - this.w * this.z),
+      2 * (this.x * this.z + this.w * this.y),
+      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 Transform = class {
+  /**
+   * The position of the object
+   */
+  position;
+  /**
+   * The rotation of the object
+   */
+  rotation;
+  /**
+   * The scale of the object
+   */
+  scale;
+  /**
+   * Create a new transform with `position`, `rotation` and `scale`
+   * @param position The position as a Vec3
+   * @param rotation The rotation as a Quaternion
+   * @param scale The scale as a Vec3
+   */
+  constructor(position, rotation, scale) {
+    this.position = Vec3.resolve(position);
+    this.rotation = Quaternion.resolve(rotation);
+    this.scale = Vec3.resolve(scale);
+  }
+  /**
+   * Convert the transform into a 4x3 matrix
+   * @returns A 4x4 matrix from the transform
+   */
+  toMat4() {
+    return new Mat4().translate(this.position).multiply(this.rotation.toMat4()).scale(this.scale);
+  }
+};
+export {
+  ATriangle,
+  BoundingBox,
+  Circle,
+  DJB2_OFFSET,
+  EPSILON,
+  FNV1_OFFSET,
+  FNV1_PRIME,
+  HSLColor,
+  LinearFunction,
+  MAX_ANGLE_DEGREE,
+  MD2,
+  Mat3,
+  Mat4,
+  MathFunction,
+  QuadFunction,
+  Quaternion,
+  RGBAColor,
+  Rectangle,
+  ResolveError,
+  Size,
+  Transform,
+  Triangle2D,
+  Triangle3D,
+  Vec2,
+  Vec3,
+  cap_angle_degree,
+  cap_angle_radian,
+  castColor,
+  check_array,
+  check_hex,
+  check_hex_digit,
+  check_number,
+  check_number_array,
+  check_string,
+  check_string_array,
+  clamp,
+  degree_to_radian,
+  djb2,
+  fnv1,
+  get_hex_part,
+  has_property,
+  log_hypot,
+  radian_to_degree,
+  resolveColor,
+  sdbm,
+  sign_char,
+  stringify
+};