@aura3d/math 1.3.3 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura3d/math",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,5 +9,38 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
-  }
+  },
+  "description": "Deterministic vectors, matrices, quaternions, colors, rays, bounds, frustums, transforms, interpolation, easing, and seeded random math for Aura3D.",
+  "keywords": [
+    "aura3d",
+    "3d",
+    "browser-3d",
+    "web-3d",
+    "typescript",
+    "math",
+    "vectors",
+    "matrices",
+    "quaternion",
+    "geometry",
+    "bounds",
+    "random",
+    "deterministic"
+  ],
+  "homepage": "https://aura3d.auraone.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auraoneai/aura3d.git",
+    "directory": "packages/math"
+  },
+  "bugs": {
+    "url": "https://github.com/auraoneai/aura3d/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ]
 }

package/src/Box3.ts

@@ -1,65 +0,0 @@
-import { Matrix4 } from "./Matrix4.js";
-import { Sphere } from "./Sphere.js";
-import { Vector3 } from "./Vector3.js";
-
-export class Box3 {
-  constructor(
-    readonly min = new Vector3(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY),
-    readonly max = new Vector3(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY)
-  ) {}
-
-  static fromPoints(points: readonly Vector3[]): Box3 {
-    return points.reduce((box, point) => box.expandByPoint(point), new Box3());
-  }
-
-  isEmpty(): boolean {
-    return this.max.x < this.min.x || this.max.y < this.min.y || this.max.z < this.min.z;
-  }
-
-  expandByPoint(point: Vector3): Box3 {
-    return new Box3(this.min.min(point), this.max.max(point));
-  }
-
-  union(box: Box3): Box3 {
-    if (this.isEmpty()) return box;
-    if (box.isEmpty()) return this;
-    return new Box3(this.min.min(box.min), this.max.max(box.max));
-  }
-
-  intersectsBox(box: Box3): boolean {
-    if (this.isEmpty() || box.isEmpty()) return false;
-    return !(box.max.x < this.min.x || box.min.x > this.max.x || box.max.y < this.min.y || box.min.y > this.max.y || box.max.z < this.min.z || box.min.z > this.max.z);
-  }
-
-  containsPoint(point: Vector3): boolean {
-    return !this.isEmpty() && point.x >= this.min.x && point.x <= this.max.x && point.y >= this.min.y && point.y <= this.max.y && point.z >= this.min.z && point.z <= this.max.z;
-  }
-
-  getCenter(): Vector3 {
-    return this.isEmpty() ? Vector3.zero.clone() : this.min.add(this.max).multiplyScalar(0.5);
-  }
-
-  getSize(): Vector3 {
-    return this.isEmpty() ? Vector3.zero.clone() : this.max.subtract(this.min);
-  }
-
-  getBoundingSphere(): Sphere {
-    const center = this.getCenter();
-    return new Sphere(center, center.distanceTo(this.max));
-  }
-
-  transform(matrix: Matrix4): Box3 {
-    if (this.isEmpty()) return new Box3();
-    const corners = [
-      new Vector3(this.min.x, this.min.y, this.min.z),
-      new Vector3(this.min.x, this.min.y, this.max.z),
-      new Vector3(this.min.x, this.max.y, this.min.z),
-      new Vector3(this.min.x, this.max.y, this.max.z),
-      new Vector3(this.max.x, this.min.y, this.min.z),
-      new Vector3(this.max.x, this.min.y, this.max.z),
-      new Vector3(this.max.x, this.max.y, this.min.z),
-      new Vector3(this.max.x, this.max.y, this.max.z)
-    ];
-    return Box3.fromPoints(corners.map((corner) => matrix.transformPoint(corner)));
-  }
-}

package/src/Color.ts

@@ -1,49 +0,0 @@
-import { clamp } from "./Interpolation.js";
-
-export class Color {
-  constructor(
-    readonly r = 1,
-    readonly g = 1,
-    readonly b = 1,
-    readonly a = 1
-  ) {
-    for (const channel of [r, g, b, a]) {
-      if (!Number.isFinite(channel)) throw new RangeError("Color channels must be finite.");
-    }
-  }
-
-  static fromSRGB(r: number, g: number, b: number, a = 1): Color {
-    return new Color(srgbToLinear(r), srgbToLinear(g), srgbToLinear(b), a);
-  }
-
-  toSRGB(): Color {
-    return new Color(linearToSrgb(this.r), linearToSrgb(this.g), linearToSrgb(this.b), this.a);
-  }
-
-  clamp01(): Color {
-    return new Color(clamp(this.r), clamp(this.g), clamp(this.b), clamp(this.a));
-  }
-
-  lerp(to: Color, t: number): Color {
-    return new Color(
-      this.r + (to.r - this.r) * t,
-      this.g + (to.g - this.g) * t,
-      this.b + (to.b - this.b) * t,
-      this.a + (to.a - this.a) * t
-    );
-  }
-
-  equals(color: Color, epsilon = 1e-10): boolean {
-    return Math.abs(this.r - color.r) <= epsilon && Math.abs(this.g - color.g) <= epsilon && Math.abs(this.b - color.b) <= epsilon && Math.abs(this.a - color.a) <= epsilon;
-  }
-}
-
-export function srgbToLinear(value: number): number {
-  const v = clamp(value);
-  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-}
-
-export function linearToSrgb(value: number): number {
-  const v = clamp(value);
-  return v <= 0.0031308 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
-}

package/src/Curves.ts

@@ -1,79 +0,0 @@
-import { Vector3 } from "./Vector3.js";
-
-export interface CurveSample {
-  readonly position: Vector3;
-  readonly tangent: Vector3;
-}
-
-export class CatmullRomCurve3 {
-  constructor(public readonly points: readonly Vector3[]) {
-    if (points.length < 2) throw new Error("CatmullRomCurve3 requires at least two points.");
-  }
-
-  getPoint(t: number): Vector3 {
-    const clamped = clamp01(t);
-    const scaled = clamped * (this.points.length - 1);
-    const index = Math.min(Math.floor(scaled), this.points.length - 2);
-    const localT = scaled - index;
-    const p0 = this.points[Math.max(0, index - 1)]!;
-    const p1 = this.points[index]!;
-    const p2 = this.points[index + 1]!;
-    const p3 = this.points[Math.min(this.points.length - 1, index + 2)]!;
-    return catmullRom(p0, p1, p2, p3, localT);
-  }
-
-  getTangent(t: number): Vector3 {
-    const delta = 1e-4;
-    const before = this.getPoint(Math.max(0, t - delta));
-    const after = this.getPoint(Math.min(1, t + delta));
-    return after.subtract(before).normalize();
-  }
-
-  sample(t: number): CurveSample {
-    return { position: this.getPoint(t), tangent: this.getTangent(t) };
-  }
-}
-
-export class CubicBezierCurve3 {
-  constructor(
-    public readonly p0: Vector3,
-    public readonly p1: Vector3,
-    public readonly p2: Vector3,
-    public readonly p3: Vector3
-  ) {}
-
-  getPoint(t: number): Vector3 {
-    const u = 1 - clamp01(t);
-    const tt = clamp01(t) * clamp01(t);
-    const uu = u * u;
-    const uuu = uu * u;
-    const ttt = tt * clamp01(t);
-    return this.p0.multiplyScalar(uuu)
-      .add(this.p1.multiplyScalar(3 * uu * clamp01(t)))
-      .add(this.p2.multiplyScalar(3 * u * tt))
-      .add(this.p3.multiplyScalar(ttt));
-  }
-
-  getTangent(t: number): Vector3 {
-    const u = 1 - clamp01(t);
-    return this.p1.subtract(this.p0).multiplyScalar(3 * u * u)
-      .add(this.p2.subtract(this.p1).multiplyScalar(6 * u * clamp01(t)))
-      .add(this.p3.subtract(this.p2).multiplyScalar(3 * clamp01(t) * clamp01(t)))
-      .normalize();
-  }
-}
-
-function catmullRom(p0: Vector3, p1: Vector3, p2: Vector3, p3: Vector3, t: number): Vector3 {
-  const t2 = t * t;
-  const t3 = t2 * t;
-  return p1.multiplyScalar(2)
-    .add(p2.subtract(p0).multiplyScalar(t))
-    .add(p0.multiplyScalar(2).subtract(p1.multiplyScalar(5)).add(p2.multiplyScalar(4)).subtract(p3).multiplyScalar(t2))
-    .add(p3.subtract(p0).add(p1.multiplyScalar(3).subtract(p2.multiplyScalar(3))).multiplyScalar(t3))
-    .multiplyScalar(0.5);
-}
-
-function clamp01(value: number): number {
-  if (!Number.isFinite(value)) throw new Error("Curve parameter must be finite.");
-  return Math.min(1, Math.max(0, value));
-}

package/src/Easing.ts

@@ -1,24 +0,0 @@
-export const Easing = Object.freeze({
-  linear(t: number): number {
-    assertUnit(t);
-    return t;
-  },
-  easeInQuad(t: number): number {
-    assertUnit(t);
-    return t * t;
-  },
-  easeOutQuad(t: number): number {
-    assertUnit(t);
-    return t * (2 - t);
-  },
-  easeInOutCubic(t: number): number {
-    assertUnit(t);
-    return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-  }
-});
-
-function assertUnit(t: number): void {
-  if (!Number.isFinite(t) || t < 0 || t > 1) {
-    throw new RangeError("Easing input must be a finite value in [0, 1].");
-  }
-}

package/src/Euler.ts

@@ -1,30 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,240 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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;
-  }
-}

package/src/Ray.ts

@@ -1,67 +0,0 @@
-import { Box3 } from "./Box3.js";
-import { Plane } from "./Plane.js";
-import { Sphere } from "./Sphere.js";
-import { Vector3 } from "./Vector3.js";
-
-export class Ray {
-  readonly origin: Vector3;
-  readonly direction: Vector3;
-
-  constructor(origin = Vector3.zero.clone(), direction = Vector3.forward.clone()) {
-    const normalized = direction.normalize();
-    if (normalized.lengthSquared() === 0) throw new RangeError("Ray direction must be non-zero.");
-    this.origin = origin;
-    this.direction = normalized;
-  }
-
-  at(distance: number): Vector3 {
-    return this.origin.add(this.direction.multiplyScalar(distance));
-  }
-
-  intersectPlane(plane: Plane): Vector3 | undefined {
-    const denominator = plane.normal.dot(this.direction);
-    if (Math.abs(denominator) < 1e-12) return undefined;
-    const distance = -(this.origin.dot(plane.normal) + plane.constant) / denominator;
-    return distance < 0 ? undefined : this.at(distance);
-  }
-
-  intersectSphere(sphere: Sphere): Vector3 | undefined {
-    const l = sphere.center.subtract(this.origin);
-    const tca = l.dot(this.direction);
-    const d2 = l.dot(l) - tca * tca;
-    const radius2 = sphere.radius * sphere.radius;
-    if (d2 > radius2) return undefined;
-    const thc = Math.sqrt(radius2 - d2);
-    const t0 = tca - thc;
-    const t1 = tca + thc;
-    const distance = t0 >= 0 ? t0 : t1;
-    return distance < 0 ? undefined : this.at(distance);
-  }
-
-  intersectBox(box: Box3): Vector3 | undefined {
-    if (box.isEmpty()) return undefined;
-    let tmin = Number.NEGATIVE_INFINITY;
-    let tmax = Number.POSITIVE_INFINITY;
-
-    for (const axis of ["x", "y", "z"] as const) {
-      const origin = this.origin[axis];
-      const direction = this.direction[axis];
-      const min = box.min[axis];
-      const max = box.max[axis];
-      if (Math.abs(direction) < 1e-12) {
-        if (origin < min || origin > max) return undefined;
-        continue;
-      }
-      const invD = 1 / direction;
-      let t1 = (min - origin) * invD;
-      let t2 = (max - origin) * invD;
-      if (t1 > t2) [t1, t2] = [t2, t1];
-      tmin = Math.max(tmin, t1);
-      tmax = Math.min(tmax, t2);
-      if (tmin > tmax) return undefined;
-    }
-
-    const distance = tmin >= 0 ? tmin : tmax;
-    return distance < 0 ? undefined : this.at(distance);
-  }
-}

package/src/Sphere.ts

@@ -1,18 +0,0 @@
-import { Vector3 } from "./Vector3.js";
-
-export class Sphere {
-  constructor(
-    readonly center = Vector3.zero.clone(),
-    readonly radius = 0
-  ) {
-    if (!Number.isFinite(radius) || radius < 0) throw new RangeError("Sphere radius must be finite and non-negative.");
-  }
-
-  containsPoint(point: Vector3): boolean {
-    return this.center.distanceTo(point) <= this.radius;
-  }
-
-  intersectsSphere(other: Sphere): boolean {
-    return this.center.distanceTo(other.center) <= this.radius + other.radius;
-  }
-}

package/src/Transform.ts

@@ -1,33 +0,0 @@
-import { Matrix4 } from "./Matrix4.js";
-import { Quaternion } from "./Quaternion.js";
-import { Vector3 } from "./Vector3.js";
-
-export class Transform {
-  constructor(
-    readonly position = Vector3.zero.clone(),
-    readonly rotation = Quaternion.identity.clone(),
-    readonly scale = Vector3.one.clone()
-  ) {}
-
-  static identity(): Transform {
-    return new Transform();
-  }
-
-  toMatrix4(): Matrix4 {
-    return Matrix4.compose(this.position, this.rotation, this.scale);
-  }
-
-  combine(child: Transform): Transform {
-    const scaledPosition = child.position.multiply(this.scale);
-    const rotatedPosition = this.rotation.rotateVector(scaledPosition);
-    return new Transform(
-      this.position.add(rotatedPosition),
-      this.rotation.multiply(child.rotation).normalize(),
-      this.scale.multiply(child.scale)
-    );
-  }
-
-  transformPoint(point: Vector3): Vector3 {
-    return this.toMatrix4().transformPoint(point);
-  }
-}

package/src/Vector2.ts

@@ -1,66 +0,0 @@
-export class Vector2 {
-  static readonly zero = Object.freeze(new Vector2(0, 0));
-  static readonly one = Object.freeze(new Vector2(1, 1));
-
-  constructor(
-    readonly x = 0,
-    readonly y = 0
-  ) {}
-
-  clone(): Vector2 {
-    return new Vector2(this.x, this.y);
-  }
-
-  add(v: Vector2): Vector2 {
-    return new Vector2(this.x + v.x, this.y + v.y);
-  }
-
-  subtract(v: Vector2): Vector2 {
-    return new Vector2(this.x - v.x, this.y - v.y);
-  }
-
-  multiplyScalar(scalar: number): Vector2 {
-    return new Vector2(this.x * scalar, this.y * scalar);
-  }
-
-  divide(v: Vector2): Vector2 {
-    return new Vector2(this.x / v.x, this.y / v.y);
-  }
-
-  divideScalar(scalar: number): Vector2 {
-    return new Vector2(this.x / scalar, this.y / scalar);
-  }
-
-  dot(v: Vector2): number {
-    return this.x * v.x + this.y * v.y;
-  }
-
-  lengthSquared(): number {
-    return this.dot(this);
-  }
-
-  length(): number {
-    return Math.hypot(this.x, this.y);
-  }
-
-  normalize(): Vector2 {
-    const len = this.length();
-    return len === 0 ? Vector2.zero.clone() : this.multiplyScalar(1 / len);
-  }
-
-  distanceTo(v: Vector2): number {
-    return this.subtract(v).length();
-  }
-
-  lerp(v: Vector2, t: number): Vector2 {
-    return new Vector2(this.x + (v.x - this.x) * t, this.y + (v.y - this.y) * t);
-  }
-
-  equals(v: Vector2, epsilon = 1e-10): boolean {
-    return Math.abs(this.x - v.x) <= epsilon && Math.abs(this.y - v.y) <= epsilon;
-  }
-
-  toArray(): [number, number] {
-    return [this.x, this.y];
-  }
-}

package/src/Vector3.ts

@@ -1,101 +0,0 @@
-import type { Matrix4 } from "./Matrix4.js";
-import type { Quaternion } from "./Quaternion.js";
-
-export class Vector3 {
-  static readonly zero = Object.freeze(new Vector3(0, 0, 0));
-  static readonly one = Object.freeze(new Vector3(1, 1, 1));
-  static readonly up = Object.freeze(new Vector3(0, 1, 0));
-  static readonly right = Object.freeze(new Vector3(1, 0, 0));
-  static readonly forward = Object.freeze(new Vector3(0, 0, -1));
-
-  constructor(
-    readonly x = 0,
-    readonly y = 0,
-    readonly z = 0
-  ) {}
-
-  clone(): Vector3 {
-    return new Vector3(this.x, this.y, this.z);
-  }
-
-  add(v: Vector3): Vector3 {
-    return new Vector3(this.x + v.x, this.y + v.y, this.z + v.z);
-  }
-
-  subtract(v: Vector3): Vector3 {
-    return new Vector3(this.x - v.x, this.y - v.y, this.z - v.z);
-  }
-
-  multiplyScalar(scalar: number): Vector3 {
-    return new Vector3(this.x * scalar, this.y * scalar, this.z * scalar);
-  }
-
-  multiply(v: Vector3): Vector3 {
-    return new Vector3(this.x * v.x, this.y * v.y, this.z * v.z);
-  }
-
-  divide(v: Vector3): Vector3 {
-    return new Vector3(this.x / v.x, this.y / v.y, this.z / v.z);
-  }
-
-  divideScalar(scalar: number): Vector3 {
-    return new Vector3(this.x / scalar, this.y / scalar, this.z / scalar);
-  }
-
-  dot(v: Vector3): number {
-    return this.x * v.x + this.y * v.y + this.z * v.z;
-  }
-
-  cross(v: Vector3): Vector3 {
-    return new Vector3(
-      this.y * v.z - this.z * v.y,
-      this.z * v.x - this.x * v.z,
-      this.x * v.y - this.y * v.x
-    );
-  }
-
-  lengthSquared(): number {
-    return this.dot(this);
-  }
-
-  length(): number {
-    return Math.hypot(this.x, this.y, this.z);
-  }
-
-  normalize(): Vector3 {
-    const len = this.length();
-    return len === 0 ? Vector3.zero.clone() : this.multiplyScalar(1 / len);
-  }
-
-  distanceTo(v: Vector3): number {
-    return this.subtract(v).length();
-  }
-
-  lerp(v: Vector3, t: number): Vector3 {
-    return new Vector3(this.x + (v.x - this.x) * t, this.y + (v.y - this.y) * t, this.z + (v.z - this.z) * t);
-  }
-
-  transformMatrix4(matrix: Matrix4): Vector3 {
-    return matrix.transformPoint(this);
-  }
-
-  rotateByQuaternion(rotation: Quaternion): Vector3 {
-    return rotation.rotateVector(this);
-  }
-
-  min(v: Vector3): Vector3 {
-    return new Vector3(Math.min(this.x, v.x), Math.min(this.y, v.y), Math.min(this.z, v.z));
-  }
-
-  max(v: Vector3): Vector3 {
-    return new Vector3(Math.max(this.x, v.x), Math.max(this.y, v.y), Math.max(this.z, v.z));
-  }
-
-  equals(v: Vector3, epsilon = 1e-10): boolean {
-    return Math.abs(this.x - v.x) <= epsilon && Math.abs(this.y - v.y) <= epsilon && Math.abs(this.z - v.z) <= epsilon;
-  }
-
-  toArray(): [number, number, number] {
-    return [this.x, this.y, this.z];
-  }
-}

package/src/Vector4.ts

@@ -1,55 +0,0 @@
-import type { Matrix4 } from "./Matrix4.js";
-
-export class Vector4 {
-  constructor(
-    readonly x = 0,
-    readonly y = 0,
-    readonly z = 0,
-    readonly w = 0
-  ) {}
-
-  add(v: Vector4): Vector4 {
-    return new Vector4(this.x + v.x, this.y + v.y, this.z + v.z, this.w + v.w);
-  }
-
-  subtract(v: Vector4): Vector4 {
-    return new Vector4(this.x - v.x, this.y - v.y, this.z - v.z, this.w - v.w);
-  }
-
-  multiplyScalar(scalar: number): Vector4 {
-    return new Vector4(this.x * scalar, this.y * scalar, this.z * scalar, this.w * scalar);
-  }
-
-  divide(v: Vector4): Vector4 {
-    return new Vector4(this.x / v.x, this.y / v.y, this.z / v.z, this.w / v.w);
-  }
-
-  divideScalar(scalar: number): Vector4 {
-    return new Vector4(this.x / scalar, this.y / scalar, this.z / scalar, this.w / scalar);
-  }
-
-  dot(v: Vector4): number {
-    return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
-  }
-
-  lerp(v: Vector4, t: number): Vector4 {
-    return new Vector4(
-      this.x + (v.x - this.x) * t,
-      this.y + (v.y - this.y) * t,
-      this.z + (v.z - this.z) * t,
-      this.w + (v.w - this.w) * t
-    );
-  }
-
-  transformMatrix4(matrix: Matrix4): Vector4 {
-    return matrix.transformVector4(this);
-  }
-
-  equals(v: Vector4, epsilon = 1e-10): boolean {
-    return Math.abs(this.x - v.x) <= epsilon && Math.abs(this.y - v.y) <= epsilon && Math.abs(this.z - v.z) <= epsilon && Math.abs(this.w - v.w) <= epsilon;
-  }
-
-  toArray(): [number, number, number, number] {
-    return [this.x, this.y, this.z, this.w];
-  }
-}

package/src/index.ts

@@ -1,18 +0,0 @@
-export * from "./Vector2.js";
-export * from "./Vector3.js";
-export * from "./Vector4.js";
-export * from "./Matrix3.js";
-export * from "./Matrix4.js";
-export * from "./Quaternion.js";
-export * from "./Euler.js";
-export * from "./Color.js";
-export * from "./Ray.js";
-export * from "./Plane.js";
-export * from "./Box3.js";
-export * from "./Sphere.js";
-export * from "./Frustum.js";
-export * from "./Transform.js";
-export * from "./Interpolation.js";
-export * from "./Easing.js";
-export * from "./Random.js";
-export * from "./Curves.js";