@aura3d/math 1.0.6

package/src/Euler.ts

@@ -0,0 +1,30 @@
+import { Quaternion, type EulerOrder } from "./Quaternion.js";
+
+export class Euler {
+  constructor(
+    readonly x = 0,
+    readonly y = 0,
+    readonly z = 0,
+    readonly order: EulerOrder = "XYZ"
+  ) {
+    if (![x, y, z].every(Number.isFinite)) throw new RangeError("Euler angles must be finite.");
+    if (order !== "XYZ") throw new RangeError(`Unsupported Euler order: ${order}`);
+  }
+
+  toQuaternion(): Quaternion {
+    return Quaternion.fromEuler(this.x, this.y, this.z, this.order);
+  }
+
+  equals(euler: Euler, epsilon = 1e-10): boolean {
+    return (
+      Math.abs(this.x - euler.x) <= epsilon &&
+      Math.abs(this.y - euler.y) <= epsilon &&
+      Math.abs(this.z - euler.z) <= epsilon &&
+      this.order === euler.order
+    );
+  }
+
+  toArray(): [number, number, number] {
+    return [this.x, this.y, this.z];
+  }
+}

package/src/Frustum.ts

@@ -0,0 +1,43 @@
+import { Box3 } from "./Box3.js";
+import { Matrix4 } from "./Matrix4.js";
+import { Plane } from "./Plane.js";
+import { Sphere } from "./Sphere.js";
+import { Vector3 } from "./Vector3.js";
+
+export class Frustum {
+  constructor(readonly planes: readonly [Plane, Plane, Plane, Plane, Plane, Plane]) {}
+
+  static fromMatrix(matrix: Matrix4): Frustum {
+    const m = matrix.elements;
+    const planes: [Plane, Plane, Plane, Plane, Plane, Plane] = [
+      new Plane(new Vector3(m[3] + m[0], m[7] + m[4], m[11] + m[8]), m[15] + m[12]),
+      new Plane(new Vector3(m[3] - m[0], m[7] - m[4], m[11] - m[8]), m[15] - m[12]),
+      new Plane(new Vector3(m[3] + m[1], m[7] + m[5], m[11] + m[9]), m[15] + m[13]),
+      new Plane(new Vector3(m[3] - m[1], m[7] - m[5], m[11] - m[9]), m[15] - m[13]),
+      new Plane(new Vector3(m[3] + m[2], m[7] + m[6], m[11] + m[10]), m[15] + m[14]),
+      new Plane(new Vector3(m[3] - m[2], m[7] - m[6], m[11] - m[10]), m[15] - m[14])
+    ];
+    return new Frustum(planes);
+  }
+
+  containsPoint(point: Vector3): boolean {
+    return this.planes.every((plane) => plane.distanceToPoint(point) >= 0);
+  }
+
+  intersectsSphere(sphere: Sphere): boolean {
+    return this.planes.every((plane) => plane.distanceToPoint(sphere.center) >= -sphere.radius);
+  }
+
+  intersectsBox(box: Box3): boolean {
+    if (box.isEmpty()) return false;
+    for (const plane of this.planes) {
+      const p = new Vector3(
+        plane.normal.x >= 0 ? box.max.x : box.min.x,
+        plane.normal.y >= 0 ? box.max.y : box.min.y,
+        plane.normal.z >= 0 ? box.max.z : box.min.z
+      );
+      if (plane.distanceToPoint(p) < 0) return false;
+    }
+    return true;
+  }
+}

package/src/Interpolation.ts

@@ -0,0 +1,34 @@
+import { Vector2 } from "./Vector2.js";
+import { Vector3 } from "./Vector3.js";
+import { Vector4 } from "./Vector4.js";
+
+export function clamp(value: number, min = 0, max = 1): number {
+  if (min > max) throw new RangeError("min must be <= max");
+  return Math.min(max, Math.max(min, value));
+}
+
+export function lerp(a: number, b: number, t: number): number {
+  return a + (b - a) * t;
+}
+
+export function inverseLerp(a: number, b: number, value: number): number {
+  if (a === b) throw new RangeError("inverseLerp requires distinct endpoints");
+  return (value - a) / (b - a);
+}
+
+export function smoothstep(edge0: number, edge1: number, value: number): number {
+  const t = clamp(inverseLerp(edge0, edge1, value));
+  return t * t * (3 - 2 * t);
+}
+
+export function lerpVector2(a: Vector2, b: Vector2, t: number): Vector2 {
+  return a.lerp(b, t);
+}
+
+export function lerpVector3(a: Vector3, b: Vector3, t: number): Vector3 {
+  return a.lerp(b, t);
+}
+
+export function lerpVector4(a: Vector4, b: Vector4, t: number): Vector4 {
+  return a.lerp(b, t);
+}

package/src/Matrix3.ts

@@ -0,0 +1,54 @@
+export class Matrix3 {
+  readonly elements: readonly [number, number, number, number, number, number, number, number, number];
+
+  constructor(elements?: readonly [number, number, number, number, number, number, number, number, number]) {
+    this.elements = elements ? [...elements] as typeof this.elements : [1, 0, 0, 0, 1, 0, 0, 0, 1];
+  }
+
+  determinant(): number {
+    const m = this.elements;
+    return m[0] * (m[4] * m[8] - m[5] * m[7]) - m[3] * (m[1] * m[8] - m[2] * m[7]) + m[6] * (m[1] * m[5] - m[2] * m[4]);
+  }
+
+  inverse(): Matrix3 {
+    const m = this.elements;
+    const det = this.determinant();
+    if (Math.abs(det) < 1e-12) throw new RangeError("Matrix3 is singular.");
+    const invDet = 1 / det;
+    return new Matrix3([
+      (m[4] * m[8] - m[5] * m[7]) * invDet,
+      (m[2] * m[7] - m[1] * m[8]) * invDet,
+      (m[1] * m[5] - m[2] * m[4]) * invDet,
+      (m[5] * m[6] - m[3] * m[8]) * invDet,
+      (m[0] * m[8] - m[2] * m[6]) * invDet,
+      (m[2] * m[3] - m[0] * m[5]) * invDet,
+      (m[3] * m[7] - m[4] * m[6]) * invDet,
+      (m[1] * m[6] - m[0] * m[7]) * invDet,
+      (m[0] * m[4] - m[1] * m[3]) * invDet
+    ]);
+  }
+
+  multiply(other: Matrix3): Matrix3 {
+    const a = this.elements;
+    const b = other.elements;
+    const out = new Array<number>(9);
+    for (let row = 0; row < 3; row++) {
+      for (let col = 0; col < 3; col++) {
+        out[col * 3 + row] =
+          a[0 * 3 + row]! * b[col * 3 + 0]! +
+          a[1 * 3 + row]! * b[col * 3 + 1]! +
+          a[2 * 3 + row]! * b[col * 3 + 2]!;
+      }
+    }
+    return new Matrix3(out as unknown as Matrix3["elements"]);
+  }
+
+  transpose(): Matrix3 {
+    const m = this.elements;
+    return new Matrix3([
+      m[0], m[3], m[6],
+      m[1], m[4], m[7],
+      m[2], m[5], m[8]
+    ]);
+  }
+}

package/src/Matrix4.ts

@@ -0,0 +1,240 @@
+import { Quaternion } from "./Quaternion.js";
+import { Vector3 } from "./Vector3.js";
+import { Vector4 } from "./Vector4.js";
+
+export class Matrix4 {
+  readonly elements: readonly [
+    number, number, number, number,
+    number, number, number, number,
+    number, number, number, number,
+    number, number, number, number
+  ];
+
+  constructor(elements?: Matrix4["elements"]) {
+    this.elements = elements ? [...elements] as Matrix4["elements"] : [
+      1, 0, 0, 0,
+      0, 1, 0, 0,
+      0, 0, 1, 0,
+      0, 0, 0, 1
+    ];
+  }
+
+  static identity(): Matrix4 {
+    return new Matrix4();
+  }
+
+  static translation(v: Vector3): Matrix4 {
+    return new Matrix4([
+      1, 0, 0, 0,
+      0, 1, 0, 0,
+      0, 0, 1, 0,
+      v.x, v.y, v.z, 1
+    ]);
+  }
+
+  static scaling(v: Vector3): Matrix4 {
+    return new Matrix4([
+      v.x, 0, 0, 0,
+      0, v.y, 0, 0,
+      0, 0, v.z, 0,
+      0, 0, 0, 1
+    ]);
+  }
+
+  static rotation(q: Quaternion): Matrix4 {
+    const n = q.normalize();
+    const x2 = n.x + n.x;
+    const y2 = n.y + n.y;
+    const z2 = n.z + n.z;
+    const xx = n.x * x2;
+    const xy = n.x * y2;
+    const xz = n.x * z2;
+    const yy = n.y * y2;
+    const yz = n.y * z2;
+    const zz = n.z * z2;
+    const wx = n.w * x2;
+    const wy = n.w * y2;
+    const wz = n.w * z2;
+    return new Matrix4([
+      1 - (yy + zz), xy + wz, xz - wy, 0,
+      xy - wz, 1 - (xx + zz), yz + wx, 0,
+      xz + wy, yz - wx, 1 - (xx + yy), 0,
+      0, 0, 0, 1
+    ]);
+  }
+
+  static compose(position: Vector3, rotation: Quaternion, scale: Vector3): Matrix4 {
+    return Matrix4.translation(position).multiply(Matrix4.rotation(rotation)).multiply(Matrix4.scaling(scale));
+  }
+
+  static perspective(fovYRadians: number, aspect: number, near: number, far: number): Matrix4 {
+    if (![fovYRadians, aspect, near, far].every(Number.isFinite) || fovYRadians <= 0 || aspect <= 0 || near <= 0 || far <= near) {
+      throw new RangeError("Invalid perspective projection parameters.");
+    }
+    const f = 1 / Math.tan(fovYRadians / 2);
+    const nf = 1 / (near - far);
+    return new Matrix4([
+      f / aspect, 0, 0, 0,
+      0, f, 0, 0,
+      0, 0, (far + near) * nf, -1,
+      0, 0, 2 * far * near * nf, 0
+    ]);
+  }
+
+  static orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4 {
+    if (![left, right, bottom, top, near, far].every(Number.isFinite) || left === right || bottom === top || near === far) {
+      throw new RangeError("Invalid orthographic projection parameters.");
+    }
+    const lr = 1 / (left - right);
+    const bt = 1 / (bottom - top);
+    const nf = 1 / (near - far);
+    return new Matrix4([
+      -2 * lr, 0, 0, 0,
+      0, -2 * bt, 0, 0,
+      0, 0, 2 * nf, 0,
+      (left + right) * lr, (top + bottom) * bt, (far + near) * nf, 1
+    ]);
+  }
+
+  static lookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix4 {
+    const z = eye.subtract(target).normalize();
+    if (z.lengthSquared() === 0) throw new RangeError("Look-at eye and target must not be identical.");
+
+    let x = up.cross(z).normalize();
+    if (x.lengthSquared() === 0) {
+      const fallbackUp = Math.abs(up.z) === 1 ? Vector3.up : Vector3.forward;
+      x = fallbackUp.cross(z).normalize();
+    }
+    const y = z.cross(x).normalize();
+
+    return new Matrix4([
+      x.x, y.x, z.x, 0,
+      x.y, y.y, z.y, 0,
+      x.z, y.z, z.z, 0,
+      -x.dot(eye), -y.dot(eye), -z.dot(eye), 1
+    ]);
+  }
+
+  multiply(other: Matrix4): Matrix4 {
+    const a = this.elements;
+    const b = other.elements;
+    const out = new Array<number>(16);
+    for (let row = 0; row < 4; row++) {
+      for (let col = 0; col < 4; col++) {
+        out[col * 4 + row] =
+          a[0 * 4 + row]! * b[col * 4 + 0]! +
+          a[1 * 4 + row]! * b[col * 4 + 1]! +
+          a[2 * 4 + row]! * b[col * 4 + 2]! +
+          a[3 * 4 + row]! * b[col * 4 + 3]!;
+      }
+    }
+    return new Matrix4(out as unknown as Matrix4["elements"]);
+  }
+
+  transformPoint(v: Vector3): Vector3 {
+    const m = this.elements;
+    const x = v.x;
+    const y = v.y;
+    const z = v.z;
+    const w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    const iw = w === 0 ? 1 : 1 / w;
+    return new Vector3(
+      (m[0] * x + m[4] * y + m[8] * z + m[12]) * iw,
+      (m[1] * x + m[5] * y + m[9] * z + m[13]) * iw,
+      (m[2] * x + m[6] * y + m[10] * z + m[14]) * iw
+    );
+  }
+
+  transformVector4(v: Vector4): Vector4 {
+    const m = this.elements;
+    return new Vector4(
+      m[0] * v.x + m[4] * v.y + m[8] * v.z + m[12] * v.w,
+      m[1] * v.x + m[5] * v.y + m[9] * v.z + m[13] * v.w,
+      m[2] * v.x + m[6] * v.y + m[10] * v.z + m[14] * v.w,
+      m[3] * v.x + m[7] * v.y + m[11] * v.z + m[15] * v.w
+    );
+  }
+
+  transpose(): Matrix4 {
+    const m = this.elements;
+    return new Matrix4([
+      m[0], m[4], m[8], m[12],
+      m[1], m[5], m[9], m[13],
+      m[2], m[6], m[10], m[14],
+      m[3], m[7], m[11], m[15]
+    ]);
+  }
+
+  determinant(): number {
+    const m = this.elements;
+    const m00 = m[0], m01 = m[4], m02 = m[8], m03 = m[12];
+    const m10 = m[1], m11 = m[5], m12 = m[9], m13 = m[13];
+    const m20 = m[2], m21 = m[6], m22 = m[10], m23 = m[14];
+    const m30 = m[3], m31 = m[7], m32 = m[11], m33 = m[15];
+    return (
+      m03 * m12 * m21 * m30 - m02 * m13 * m21 * m30 -
+      m03 * m11 * m22 * m30 + m01 * m13 * m22 * m30 +
+      m02 * m11 * m23 * m30 - m01 * m12 * m23 * m30 -
+      m03 * m12 * m20 * m31 + m02 * m13 * m20 * m31 +
+      m03 * m10 * m22 * m31 - m00 * m13 * m22 * m31 -
+      m02 * m10 * m23 * m31 + m00 * m12 * m23 * m31 +
+      m03 * m11 * m20 * m32 - m01 * m13 * m20 * m32 -
+      m03 * m10 * m21 * m32 + m00 * m13 * m21 * m32 +
+      m01 * m10 * m23 * m32 - m00 * m11 * m23 * m32 -
+      m02 * m11 * m20 * m33 + m01 * m12 * m20 * m33 +
+      m02 * m10 * m21 * m33 - m00 * m12 * m21 * m33 -
+      m01 * m10 * m22 * m33 + m00 * m11 * m22 * m33
+    );
+  }
+
+  inverse(): Matrix4 {
+    const m = this.elements;
+    const inv = new Array<number>(16);
+
+    inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] + m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
+    inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10];
+    inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] + m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
+    inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9];
+    inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10];
+    inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] + m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
+    inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] - m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
+    inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] + m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
+    inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] + m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
+    inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] - m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
+    inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] + m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
+    inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] - m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
+    inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] - m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
+    inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] + m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
+    inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] - m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
+    inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] + m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
+
+    const det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
+    if (Math.abs(det) < 1e-12) throw new RangeError("Matrix4 is singular.");
+    return new Matrix4(inv.map((value) => value / det) as unknown as Matrix4["elements"]);
+  }
+
+  decompose(): { position: Vector3; rotation: Quaternion; scale: Vector3 } {
+    const m = this.elements;
+    const position = new Vector3(m[12], m[13], m[14]);
+    const sx = new Vector3(m[0], m[1], m[2]).length();
+    const sy = new Vector3(m[4], m[5], m[6]).length();
+    const sz = new Vector3(m[8], m[9], m[10]).length();
+    if (sx === 0 || sy === 0 || sz === 0) throw new RangeError("Cannot decompose matrix with zero scale.");
+
+    const det = this.determinant();
+    const scale = new Vector3(det < 0 ? -sx : sx, sy, sz);
+    const rotationMatrix = new Matrix4([
+      m[0] / scale.x, m[1] / scale.x, m[2] / scale.x, 0,
+      m[4] / scale.y, m[5] / scale.y, m[6] / scale.y, 0,
+      m[8] / scale.z, m[9] / scale.z, m[10] / scale.z, 0,
+      0, 0, 0, 1
+    ]);
+
+    return { position, rotation: Quaternion.fromRotationMatrix(rotationMatrix), scale };
+  }
+
+  getTranslation(): Vector3 {
+    const m = this.elements;
+    return new Vector3(m[12], m[13], m[14]);
+  }
+}

package/src/Plane.ts

@@ -0,0 +1,34 @@
+import { Vector3 } from "./Vector3.js";
+
+export class Plane {
+  readonly normal: Vector3;
+  readonly constant: number;
+
+  constructor(normal = Vector3.up.clone(), constant = 0) {
+    const len = normal.length();
+    if (len === 0) throw new RangeError("Plane normal must be non-zero.");
+    this.normal = normal.multiplyScalar(1 / len);
+    this.constant = constant / len;
+  }
+
+  static fromPointNormal(point: Vector3, normal: Vector3): Plane {
+    const normalized = normal.normalize();
+    return new Plane(normalized, -point.dot(normalized));
+  }
+
+  distanceToPoint(point: Vector3): number {
+    return this.normal.dot(point) + this.constant;
+  }
+
+  projectPoint(point: Vector3): Vector3 {
+    return point.subtract(this.normal.multiplyScalar(this.distanceToPoint(point)));
+  }
+
+  intersectLine(start: Vector3, end: Vector3): Vector3 | undefined {
+    const direction = end.subtract(start);
+    const denominator = this.normal.dot(direction);
+    if (Math.abs(denominator) < 1e-12) return undefined;
+    const t = -(start.dot(this.normal) + this.constant) / denominator;
+    return t < 0 || t > 1 ? undefined : start.add(direction.multiplyScalar(t));
+  }
+}

package/src/Quaternion.ts

@@ -0,0 +1,178 @@
+import { Vector3 } from "./Vector3.js";
+import type { Matrix4 } from "./Matrix4.js";
+
+export type EulerOrder = "XYZ";
+
+export class Quaternion {
+  static readonly identity = Object.freeze(new Quaternion(0, 0, 0, 1));
+
+  constructor(
+    readonly x = 0,
+    readonly y = 0,
+    readonly z = 0,
+    readonly w = 1
+  ) {}
+
+  static fromAxisAngle(axis: Vector3, radians: number): Quaternion {
+    const normalized = axis.normalize();
+    if (normalized.lengthSquared() === 0) throw new RangeError("Axis must be non-zero.");
+    const half = radians / 2;
+    const s = Math.sin(half);
+    return new Quaternion(normalized.x * s, normalized.y * s, normalized.z * s, Math.cos(half)).normalize();
+  }
+
+  static fromUnitVectors(from: Vector3, to: Vector3): Quaternion {
+    const vFrom = from.normalize();
+    const vTo = to.normalize();
+    const dot = vFrom.dot(vTo);
+
+    if (dot < -0.999999) {
+      const axis = Math.abs(vFrom.x) > 0.1 ? Vector3.up.cross(vFrom).normalize() : Vector3.right.cross(vFrom).normalize();
+      return Quaternion.fromAxisAngle(axis, Math.PI);
+    }
+    if (dot > 0.999999) return Quaternion.identity.clone();
+
+    const cross = vFrom.cross(vTo);
+    return new Quaternion(cross.x, cross.y, cross.z, 1 + dot).normalize();
+  }
+
+  static fromEuler(x: number, y: number, z: number, order: EulerOrder = "XYZ"): Quaternion {
+    if (order !== "XYZ") throw new RangeError(`Unsupported Euler order: ${order}`);
+    if (![x, y, z].every(Number.isFinite)) throw new RangeError("Euler angles must be finite.");
+    const c1 = Math.cos(x / 2);
+    const c2 = Math.cos(y / 2);
+    const c3 = Math.cos(z / 2);
+    const s1 = Math.sin(x / 2);
+    const s2 = Math.sin(y / 2);
+    const s3 = Math.sin(z / 2);
+    return new Quaternion(
+      s1 * c2 * c3 + c1 * s2 * s3,
+      c1 * s2 * c3 - s1 * c2 * s3,
+      c1 * c2 * s3 + s1 * s2 * c3,
+      c1 * c2 * c3 - s1 * s2 * s3
+    ).normalize();
+  }
+
+  static fromRotationMatrix(matrix: Matrix4): Quaternion {
+    const m = matrix.elements;
+    const m11 = m[0]!, m12 = m[4]!, m13 = m[8]!;
+    const m21 = m[1]!, m22 = m[5]!, m23 = m[9]!;
+    const m31 = m[2]!, m32 = m[6]!, m33 = m[10]!;
+    const trace = m11 + m22 + m33;
+
+    if (trace > 0) {
+      const s = 0.5 / Math.sqrt(trace + 1);
+      return new Quaternion(
+        (m32 - m23) * s,
+        (m13 - m31) * s,
+        (m21 - m12) * s,
+        0.25 / s
+      ).normalize();
+    }
+    if (m11 > m22 && m11 > m33) {
+      const s = 2 * Math.sqrt(1 + m11 - m22 - m33);
+      return new Quaternion(
+        0.25 * s,
+        (m12 + m21) / s,
+        (m13 + m31) / s,
+        (m32 - m23) / s
+      ).normalize();
+    }
+    if (m22 > m33) {
+      const s = 2 * Math.sqrt(1 + m22 - m11 - m33);
+      return new Quaternion(
+        (m12 + m21) / s,
+        0.25 * s,
+        (m23 + m32) / s,
+        (m13 - m31) / s
+      ).normalize();
+    }
+    const s = 2 * Math.sqrt(1 + m33 - m11 - m22);
+    return new Quaternion(
+      (m13 + m31) / s,
+      (m23 + m32) / s,
+      0.25 * s,
+      (m21 - m12) / s
+    ).normalize();
+  }
+
+  clone(): Quaternion {
+    return new Quaternion(this.x, this.y, this.z, this.w);
+  }
+
+  length(): number {
+    return Math.hypot(this.x, this.y, this.z, this.w);
+  }
+
+  normalize(): Quaternion {
+    const len = this.length();
+    if (len === 0) return Quaternion.identity.clone();
+    return new Quaternion(this.x / len, this.y / len, this.z / len, this.w / len);
+  }
+
+  conjugate(): Quaternion {
+    return new Quaternion(-this.x, -this.y, -this.z, this.w);
+  }
+
+  inverse(): Quaternion {
+    const lengthSquared = this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+    if (lengthSquared === 0) return Quaternion.identity.clone();
+    const conjugate = this.conjugate();
+    return new Quaternion(
+      conjugate.x / lengthSquared,
+      conjugate.y / lengthSquared,
+      conjugate.z / lengthSquared,
+      conjugate.w / lengthSquared
+    );
+  }
+
+  multiply(q: Quaternion): Quaternion {
+    return new Quaternion(
+      this.w * q.x + this.x * q.w + this.y * q.z - this.z * q.y,
+      this.w * q.y - this.x * q.z + this.y * q.w + this.z * q.x,
+      this.w * q.z + this.x * q.y - this.y * q.x + this.z * q.w,
+      this.w * q.w - this.x * q.x - this.y * q.y - this.z * q.z
+    );
+  }
+
+  rotateVector(v: Vector3): Vector3 {
+    const qv = new Quaternion(v.x, v.y, v.z, 0);
+    const result = this.multiply(qv).multiply(this.conjugate());
+    return new Vector3(result.x, result.y, result.z);
+  }
+
+  slerp(to: Quaternion, t: number): Quaternion {
+    let target = to;
+    let cosHalfTheta = this.x * to.x + this.y * to.y + this.z * to.z + this.w * to.w;
+
+    if (cosHalfTheta < 0) {
+      target = new Quaternion(-to.x, -to.y, -to.z, -to.w);
+      cosHalfTheta = -cosHalfTheta;
+    }
+
+    if (cosHalfTheta >= 1.0) return this.clone();
+    if (cosHalfTheta > 0.9995) {
+      return new Quaternion(
+        this.x + t * (target.x - this.x),
+        this.y + t * (target.y - this.y),
+        this.z + t * (target.z - this.z),
+        this.w + t * (target.w - this.w)
+      ).normalize();
+    }
+
+    const halfTheta = Math.acos(cosHalfTheta);
+    const sinHalfTheta = Math.sqrt(1 - cosHalfTheta * cosHalfTheta);
+    const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;
+    const ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+    return new Quaternion(
+      this.x * ratioA + target.x * ratioB,
+      this.y * ratioA + target.y * ratioB,
+      this.z * ratioA + target.z * ratioB,
+      this.w * ratioA + target.w * ratioB
+    ).normalize();
+  }
+
+  equals(q: Quaternion, epsilon = 1e-10): boolean {
+    return Math.abs(this.x - q.x) <= epsilon && Math.abs(this.y - q.y) <= epsilon && Math.abs(this.z - q.z) <= epsilon && Math.abs(this.w - q.w) <= epsilon;
+  }
+}

package/src/Random.ts

@@ -0,0 +1,32 @@
+export class SeededRandom {
+  private state: number;
+
+  constructor(seed: number) {
+    if (!Number.isInteger(seed)) throw new RangeError("Seed must be an integer.");
+    this.state = seed >>> 0;
+  }
+
+  nextUint32(): number {
+    let x = this.state;
+    x ^= x << 13;
+    x ^= x >>> 17;
+    x ^= x << 5;
+    this.state = x >>> 0;
+    return this.state;
+  }
+
+  nextFloat(): number {
+    return this.nextUint32() / 0x1_0000_0000;
+  }
+
+  range(min: number, max: number): number {
+    if (min > max) throw new RangeError("min must be <= max");
+    return min + (max - min) * this.nextFloat();
+  }
+
+  clone(): SeededRandom {
+    const random = new SeededRandom(0);
+    random.state = this.state;
+    return random;
+  }
+}