aether-physics 0.0.0-stage → 0.1.0

package/dist/types/math/geometry/quaternion.d.ts

@@ -0,0 +1,377 @@
+import type { QuatLike, Vec3Like } from "../types.js";
+import type { Mat3x3 } from "./mat3x3.js";
+import { Vec3 } from "./vec3.js";
+/**
+ * A quaternion `[w, (x, y, z)]`, used to represent orientations and rotations.
+ *
+ * A rotation of angle `θ` about unit axis `n` is stored as `[cos(θ/2), sin(θ/2)·n]`, which
+ * has magnitude 1. `q` and `−q` represent the same rotation.
+ *
+ * Conventions:
+ *
+ * - **Component order.** The constructor takes `w` first, matching the `[w, v]` notation.
+ *   This differs from `THREE.Quaternion`, which takes `(x, y, z, w)`.
+ * - **Plain public fields.** `w`, `x`, `y` and `z` are ordinary properties, not getters, so V8
+ *   can optimize access in hot loops.
+ * - **Mutation.** Methods that modify this quaternion do it in place and return `this` for
+ *   chaining. Use `clone()` first when you need to keep the original.
+ * - **Inputs.** Arguments are any `QuatLike` or `Vec3Like`, including `THREE.Quaternion`, and
+ *   are never modified. An argument may be `this`: every method reads its inputs before
+ *   writing.
+ */
+export declare class Quaternion implements QuatLike {
+    w: number;
+    x: number;
+    y: number;
+    z: number;
+    /**
+     * Creates a quaternion from its components. Defaults to the identity `[1, 0]`.
+     *
+     * @param w Scalar part.
+     * @param x X component of the vector part.
+     * @param y Y component of the vector part.
+     * @param z Z component of the vector part.
+     */
+    constructor(w?: number, x?: number, y?: number, z?: number);
+    /**
+     * Sets this quaternion to the identity `[1, 0]`, the rotation that changes nothing.
+     *
+     * `[−1, 0]` also represents no rotation, but only `[1, 0]` leaves a quaternion
+     * unchanged when multiplied by it.
+     */
+    identity(): this;
+    /**
+     * Sets all four components.
+     *
+     * @param w Scalar part.
+     * @param x X component of the vector part.
+     * @param y Y component of the vector part.
+     * @param z Z component of the vector part.
+     */
+    set(w: number, x: number, y: number, z: number): this;
+    /**
+     * Returns true if every component is within `epsilon` of `q`'s, using `approxEqual`.
+     *
+     * Compares components, not rotations: `q` and `−q` are the same rotation but are not equal
+     * here.
+     *
+     * @param q Quaternion to compare against.
+     * @param epsilon Tolerance. Defaults to `EPSILON`.
+     */
+    equals(q: QuatLike, epsilon?: number): boolean;
+    /**
+     * Returns true if this quaternion and `q` represent the same rotation: if every component
+     * is within `epsilon` of `q`'s, or of `−q`'s.
+     *
+     * The sign compared against is chosen from the dot product, so this costs about the same
+     * as `equals`. Comparing components keeps the tolerance meaningful for small angles,
+     * where `|dot| ≈ 1` alone is insensitive (it deviates from 1 only by about `φ²/8`).
+     *
+     * @param q Quaternion to compare against.
+     * @param epsilon Tolerance. Defaults to `EPSILON`.
+     */
+    equalsRotation(q: QuatLike, epsilon?: number): boolean;
+    /**
+     * Copies the components of `q` into this quaternion.
+     *
+     * @param q Source quaternion.
+     */
+    copy(q: QuatLike): this;
+    /**
+     * Returns a new quaternion with the same components as this one.
+     */
+    clone(): Quaternion;
+    /**
+     * Returns the squared magnitude of this quaternion, `w² + x² + y² + z²`.
+     *
+     * Prefer this over `magnitude` when checking whether the quaternion is still unit length,
+     * since it avoids the square root.
+     */
+    magnitudeSquared(): number;
+    /**
+     * Returns the magnitude of this quaternion, `√(w² + x² + y² + z²)`.
+     *
+     * Rotation quaternions have magnitude 1, but floating-point error makes it drift.
+     */
+    magnitude(): number;
+    /**
+     * Scales this quaternion to unit length so it represents a pure rotation.
+     *
+     * Call it after integrating orientation, after long chains of multiplications, and
+     * after linear interpolation, since each one moves the length away from 1.
+     *
+     * A zero quaternion represents no rotation, so it becomes the identity instead of NaN.
+     */
+    normalize(): this;
+    /**
+     * Multiplies every component by the scalar `k`: `this = k · this`.
+     *
+     * Scaling by a non-zero `k` does not change the rotation once normalized, so this is
+     * mainly useful as a building block, e.g. for interpolation.
+     *
+     * @param k Scale factor.
+     */
+    scale(k: number): this;
+    /**
+     * Returns the 4D dot product `w·qw + x·qx + y·qy + z·qz`.
+     *
+     * For unit quaternions it is `cos(φ/2)`, where `φ` is the angle of the rotation between
+     * them. Its sign tells you whether `q` or `−q` is the shorter path, and `|dot| ≈ 1` means
+     * they are the same rotation.
+     *
+     * @param q The other quaternion.
+     */
+    dot(q: QuatLike): number;
+    /**
+     * Negates the vector part: `this = [w, −v]`.
+     *
+     * For a unit quaternion the conjugate is the inverse: the same rotation in the opposite
+     * direction. It is cheaper than `inverse()`, so prefer it for rotations.
+     */
+    conjugate(): this;
+    /**
+     * Sets this quaternion to its multiplicative inverse, `q⁻¹ = q* / |q|²`, so that
+     * `q · q⁻¹ = q⁻¹ · q = [1, 0]`.
+     *
+     * Works for any non-zero quaternion. For unit quaternions it equals `conjugate()`, which
+     * is cheaper.
+     *
+     * The zero quaternion has no inverse, so it stays zero instead of becoming NaN, matching
+     * how singular matrices invert to zero.
+     */
+    inverse(): this;
+    /**
+     * Sets this quaternion to its natural logarithm:
+     * `log [w, v] = [ln |q|, (v / |v|) · atan2(|v|, w)]`.
+     *
+     * For a unit quaternion `[cos(θ/2), sin(θ/2)·n]` this is `[0, (θ/2)·n]`: half the rotation
+     * vector. That makes it the way to measure or scale a rotation, e.g.
+     * `exp(t · log(q))` is `q` raised to the power `t`. The angle `θ/2` is in `[0, π]`, so `q`
+     * and `−q` give different logarithms.
+     *
+     * Edge cases:
+     *
+     * - With no vector part and `w > 0` (the identity, up to scale), the vector part is zero.
+     * - With no vector part and `w < 0` (`[−1, 0]`, up to scale), any axis is valid. `+X` is
+     *   used, giving `[ln |w|, (π, 0, 0)]`, so `exp` still recovers the original.
+     * - The zero quaternion has no logarithm: `w` becomes `−∞` and the vector part zero.
+     *
+     * Inverse of `exp`.
+     */
+    log(): this;
+    /**
+     * Sets this quaternion to its exponential:
+     * `exp [w, v] = e^w · [cos |v|, (v / |v|) · sin |v|]`.
+     *
+     * With `w = 0` the result is a unit quaternion: `exp [0, (θ/2)·n]` is the rotation of
+     * angle `θ` about unit axis `n`. So `exp` turns half a rotation vector into a rotation,
+     * e.g. integrating angular velocity exactly with `exp [0, ½·ω·dt] · q`.
+     *
+     * Inverse of `log`.
+     */
+    exp(): this;
+    /**
+     * Post-multiplies this quaternion by `q`: `this = this · q`.
+     *
+     * The result applies `q` first, then this.
+     *
+     * @param q Right-hand operand. May be `this`.
+     */
+    multiply(q: QuatLike): this;
+    /**
+     * Pre-multiplies this quaternion by `q`: `this = q · this`.
+     *
+     * The result applies this first, then `q`.
+     *
+     * @param q Left-hand operand. May be `this`.
+     */
+    premultiply(q: QuatLike): this;
+    /**
+     * Sets this quaternion to the Hamilton product `a · b`:
+     * `[a.w·b.w − a.v·b.v,  a.w·b.v + b.w·a.v + a.v × b.v]`.
+     *
+     * @param a Left-hand operand. May be `this`.
+     * @param b Right-hand operand. May be `this`.
+     */
+    multiplyQuaternions(a: QuatLike, b: QuatLike): this;
+    /**
+     * Sets this quaternion to the rotation of `angle` radians about `axis`:
+     * `[cos(angle/2), sin(angle/2)·n]`, where `n` is `axis` normalized.
+     *
+     * Positive angles rotate counter-clockwise when looking down the axis toward the origin
+     * (right-hand rule). `axis` need not be unit length and is not modified. A zero axis has
+     * no direction, so the result is the identity.
+     *
+     * @param axis Rotation axis, any non-zero length.
+     * @param angle Rotation angle in radians.
+     */
+    setFromAxisAngle(axis: Vec3Like, angle: number): this;
+    /**
+     * Sets this quaternion to the rotation that takes `q` to this one: `this = q⁻¹ · this`,
+     * so that `q · (q⁻¹ · this)` is the original `this`.
+     *
+     * The difference is applied first, then `q`, so it is expressed in `q`'s local frame:
+     * for orientations, it is the rotation from `q` to this as seen by a body oriented by `q`.
+     *
+     * `q` is not modified. Uses the full inverse, so `q` need not be unit length; a zero `q`
+     * makes the result zero, as with `inverse()`.
+     *
+     * @param q The starting orientation. May be `this`.
+     */
+    setToDifferenceQuaternion(q: QuatLike): this;
+    /**
+     * Rotates `v` by this quaternion and writes the result to `out`: the vector part of
+     * `q · [0, v] · q*`.
+     *
+     * Uses the expanded form `t = 2(u × v)`, `v' = v + w·t + u × t`, where `u` is the vector
+     * part, instead of two full products. The expansion relies on `w² + |u|² = 1`, so this
+     * quaternion must be unit length; it is not normalized here.
+     *
+     * For orientations, this takes a direction from body space to world space.
+     *
+     * @param v Vector to rotate.
+     * @param out Destination. Allocated if omitted. May be `v`.
+     */
+    rotateVec3(v: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Rotates `v` by the inverse of this quaternion and writes the result to `out`: the
+     * vector part of `q* · [0, v] · q`.
+     *
+     * Same as `rotateVec3` with the vector part negated, so this quaternion is not modified.
+     * Assumes it is unit length, where the conjugate is the inverse.
+     *
+     * For orientations, this takes a direction from world space to body space.
+     *
+     * @param v Vector to rotate.
+     * @param out Destination. Allocated if omitted. May be `v`.
+     */
+    inverseRotateVec3(v: Vec3Like, out?: Vec3): Vec3;
+    /**
+     * Spherically interpolates from this quaternion toward `q`: `this = slerp(this, q, t)`.
+     *
+     * See `slerpQuaternions` for the details and edge cases.
+     *
+     * @param q Target rotation, unit length. May be `this`.
+     * @param t Interpolation parameter. `0` gives this, `1` gives `q` (possibly as `−q`).
+     */
+    slerp(q: QuatLike, t: number): this;
+    /**
+     * Sets this quaternion to the spherical linear interpolation from `a` to `b` at `t`: the
+     * rotation a fraction `t` of the way along the shortest arc between them, turning at
+     * constant angular speed.
+     *
+     * With `θ` the 4D angle between them (half the rotation angle from `a` to `b`), the
+     * result is `a · sin((1 − t)θ) / sin θ + b · sin(tθ) / sin θ`.
+     *
+     * Edge cases:
+     *
+     * - `a` and `b` must be unit length; the result then is too.
+     * - If `a · b < 0`, `−b` is used instead. It is the same rotation, and the shorter path,
+     *   so the result at `t = 1` may be `−b`. `b` itself is not modified.
+     * - When `a` and `b` are nearly equal, `sin θ ≈ 0`, so this falls back to linear
+     *   interpolation followed by `normalize()`. The two agree closely at such small angles.
+     * - `t` outside `[0, 1]` extrapolates along the same arc.
+     *
+     * @param a Start rotation, returned at `t = 0`. May be `this`.
+     * @param b End rotation, returned at `t = 1`. May be `this`.
+     * @param t Interpolation parameter, usually in `[0, 1]`.
+     */
+    slerpQuaternions(a: QuatLike, b: QuatLike, t: number): this;
+    /**
+     * Advances this orientation by angular velocity `omega` over `dt` seconds:
+     * `q += ½·dt·[0, ω]·q`.
+     *
+     * This is a first-order step of `q̇ = ½·ω·q`, with `ω` in world space. It does not
+     * normalize, and each step moves the length slightly away from 1, so call `normalize()`
+     * afterwards (a rigid body does this when it recomputes its derived data). For an exact
+     * step, use `exp [0, ½·ω·dt] · q` instead.
+     *
+     * @param omega Angular velocity in world space, in radians per second.
+     * @param dt Time step in seconds.
+     */
+    addScaledAngularVelocity(omega: Vec3Like, dt: number): this;
+    /**
+     * Sets this quaternion from the rotation matrix `m`, so that `rotateVec3(v)` equals
+     * `m.transformVec3(v)`.
+     *
+     * Uses Shepperd's method: it branches on the largest of the trace and the diagonal
+     * elements, so the square root is always of a value of at least 1 and the division is
+     * well conditioned. The sign of the result is not canonical; `q` and `−q` are the same
+     * rotation.
+     *
+     * `m` must be a pure rotation (orthonormal, determinant 1). Scale, shear or reflection
+     * give a meaningless result.
+     *
+     * @param m Rotation matrix.
+     */
+    setFromRotationMatrix(m: Mat3x3): this;
+    /**
+     * Writes the rotation axis of this quaternion to `outAxis` and returns the rotation
+     * angle, so that `setFromAxisAngle(outAxis, angle)` gives back this rotation.
+     *
+     * The angle is in `[0, π]`: for `w < 0` the axis is flipped instead of returning an
+     * angle above π, so `q` and `−q` give the same result. The axis is unit length.
+     *
+     * Works for any non-zero quaternion, not only unit ones. With no rotation (zero vector
+     * part) any axis is valid; `+X` is written and the angle is 0.
+     *
+     * @param outAxis Destination for the unit axis. Allocated if omitted.
+     * @returns The rotation angle in radians, in `[0, π]`.
+     */
+    getAxisAngle(outAxis?: Vec3): number;
+    /**
+     * Returns the angle of the rotation between this quaternion and `q`, in `[0, π]`: the
+     * smallest rotation that takes one orientation to the other.
+     *
+     * Computed as the angle of `this* · q`, using `atan2` so it stays accurate for small
+     * angles, where `2·acos(|dot|)` loses precision. `q` and `−q` give the same result.
+     *
+     * Both quaternions must be unit length.
+     *
+     * @param q The other rotation.
+     */
+    angleTo(q: QuatLike): number;
+    /**
+     * Sets this quaternion from Euler angles in `XYZ` order: `qx · qy · qz`, where each is the
+     * rotation of the given angle about that axis.
+     *
+     * `qz` is applied first, then `qy`, then `qx`, all about the fixed world axes. Equivalently,
+     * the rotations are applied about the body's own axes in the order X, Y, Z. This matches
+     * Three.js's default `'XYZ'` order.
+     *
+     * @param x Rotation about X, in radians.
+     * @param y Rotation about Y, in radians.
+     * @param z Rotation about Z, in radians.
+     */
+    setFromEulerXYZ(x: number, y: number, z: number): this;
+    /**
+     * Writes this rotation's Euler angles in `XYZ` order to `out`, the inverse of
+     * `setFromEulerXYZ`.
+     *
+     * The angles are in `x ∈ (−π, π]`, `y ∈ [−π/2, π/2]`, `z ∈ (−π, π]`. Many angle triples
+     * describe the same rotation, so the result may differ from the angles passed to
+     * `setFromEulerXYZ` while still representing the same rotation.
+     *
+     * At `y = ±π/2` (gimbal lock), X and Z rotate about the same axis and only their
+     * combination is defined. Then `z` is set to 0 and `x` carries the whole rotation.
+     *
+     * This quaternion must be unit length.
+     *
+     * @param out Destination for the angles `(x, y, z)` in radians. Allocated if omitted.
+     */
+    getEulerXYZ(out?: Vec3): Vec3;
+    /**
+     * Sets this quaternion to the shortest rotation that takes direction `from` to direction
+     * `to`.
+     *
+     * The axis is `from × to` and the angle is the angle between them. When they are
+     * opposite, every axis perpendicular to them gives a shortest rotation (of π); one is
+     * built from the larger of `from`'s X and Z components, so it is never near zero.
+     *
+     * Both vectors must be unit length. They are not modified.
+     *
+     * @param from Unit start direction.
+     * @param to Unit end direction.
+     */
+    setFromUnitVectors(from: Vec3Like, to: Vec3Like): this;
+}

package/dist/types/math/geometry/vec3.d.ts

@@ -0,0 +1,171 @@
+import type { Vec3Like } from "../types.js";
+/**
+ * A 3D vector, used for points, directions, velocities, forces and other 3-component quantities.
+ *
+ * Conventions:
+ *
+ * - **Right-handed coordinates**, matching Three.js: `X × Y = Z`.
+ * - **Plain public fields.** `x`, `y` and `z` are ordinary properties, not getters, so V8 can
+ *   optimize access in hot loops.
+ * - **Mutation.** Methods that modify this vector do it in place and return `this` for
+ *   chaining, e.g. `v.add(w).scale(2)`. Use `clone()` first when you need to keep the original.
+ * - **Inputs.** Arguments are any `Vec3Like`, including `THREE.Vector3`, and are never
+ *   modified. An argument may be `this`: every method reads its inputs before writing.
+ */
+export declare class Vec3 implements Vec3Like {
+    x: number;
+    y: number;
+    z: number;
+    /**
+     * Creates a vector from its components. Defaults to the zero vector.
+     *
+     * @param x X component.
+     * @param y Y component.
+     * @param z Z component.
+     */
+    constructor(x?: number, y?: number, z?: number);
+    /**
+     * Sets all three components.
+     *
+     * @param x X component.
+     * @param y Y component.
+     * @param z Z component.
+     */
+    set(x: number, y: number, z: number): this;
+    /**
+     * Copies the components of `vec3Like` into this vector.
+     *
+     * @param vec3Like Source vector.
+     */
+    copy(vec3Like: Vec3Like): this;
+    /**
+     * Returns a new vector with the same components as this one.
+     */
+    clone(): Vec3;
+    /**
+     * Returns the length of this vector, `√(x² + y² + z²)`.
+     *
+     * Prefer `magnitudeSquared` when only comparing lengths, since it avoids the square root.
+     */
+    magnitude(): number;
+    /**
+     * Returns the squared length of this vector, `x² + y² + z²`.
+     */
+    magnitudeSquared(): number;
+    /**
+     * Returns the distance between this point and `v`, `|this − v|`.
+     *
+     * Prefer `distanceToSquared` when only comparing distances, since it avoids the square root.
+     *
+     * @param v The other point.
+     */
+    distanceTo(v: Vec3Like): number;
+    /**
+     * Returns the squared distance between this point and `v`, `|this − v|²`.
+     *
+     * @param v The other point.
+     */
+    distanceToSquared(v: Vec3Like): number;
+    /**
+     * Adds `v` to this vector: `this = this + v`.
+     *
+     * @param v Vector to add.
+     */
+    add(v: Vec3Like): this;
+    /**
+     * Subtracts `v` from this vector: `this = this − v`.
+     *
+     * @param v Vector to subtract.
+     */
+    subtract(v: Vec3Like): this;
+    /**
+     * Multiplies every component by the scalar `s`: `this = this · s`.
+     *
+     * @param s Scale factor.
+     */
+    scale(s: number): this;
+    /**
+     * Adds `v` scaled by `s` to this vector: `this = this + v · s`.
+     *
+     * The workhorse of integration, e.g. `position.addScaled(velocity, dt)`. Cheaper than
+     * `add(v.clone().scale(s))` and leaves `v` unchanged.
+     *
+     * @param v Vector to scale and add.
+     * @param s Scale applied to `v`.
+     */
+    addScaled(v: Vec3Like, s: number): this;
+    /**
+     * Multiplies this vector by `v` component by component (the Hadamard product):
+     * `(x·vx, y·vy, z·vz)`.
+     *
+     * Not a dot or cross product. Useful for per-axis scaling.
+     *
+     * @param v Vector of per-component factors.
+     */
+    componentWiseProduct(v: Vec3Like): this;
+    /**
+     * Reverses the direction of this vector: `this = −this`.
+     */
+    negate(): this;
+    /**
+     * Moves this vector toward `v` by fraction `t`: `this + (v − this) · t`.
+     *
+     * `t = 0` leaves it unchanged and `t = 1` sets it to `v`. Values outside [0, 1]
+     * extrapolate.
+     *
+     * @param v Target vector.
+     * @param t Interpolation fraction.
+     */
+    lerp(v: Vec3Like, t: number): this;
+    /**
+     * Returns true if every component is within `epsilon` of `v`'s, using `approxEqual`.
+     *
+     * The tolerance is absolute for components up to about 1 and relative above that.
+     *
+     * @param v Vector to compare against.
+     * @param epsilon Tolerance. Defaults to `EPSILON`.
+     */
+    equals(v: Vec3Like, epsilon?: number): boolean;
+    /**
+     * Returns the dot product `this · v = x·vx + y·vy + z·vz`.
+     *
+     * Equals `|this| |v| cos θ`: positive when the vectors point the same way, zero when they
+     * are perpendicular, negative when they point apart. With a unit `v` it is the length of
+     * this vector's projection onto `v`.
+     *
+     * @param v The other vector.
+     */
+    dot(v: Vec3Like): number;
+    /**
+     * Sets this vector to the cross product `this × v`.
+     *
+     * The result is perpendicular to both inputs, with length `|this| |v| sin θ` and direction
+     * given by the right-hand rule. It is zero for parallel vectors, and `a × b = −(b × a)`.
+     *
+     * @param v Right-hand operand. May be `this`.
+     */
+    cross(v: Vec3Like): this;
+    /**
+     * Sets this vector to the cross product `a × b` without allocating.
+     *
+     * @param a Left-hand operand. May be `this`.
+     * @param b Right-hand operand. May be `this`.
+     */
+    crossVectors(a: Vec3Like, b: Vec3Like): this;
+    /**
+     * Returns the cross product `v1 × v2` as a new vector, leaving both inputs unchanged.
+     *
+     * Allocates. On hot paths use `crossVectors` with a reused vector instead.
+     *
+     * @param v1 Left-hand operand.
+     * @param v2 Right-hand operand.
+     */
+    static cross(v1: Vec3Like, v2: Vec3Like): Vec3;
+    /**
+     * Scales this vector to unit length, keeping its direction.
+     *
+     * The zero vector has no direction, so it stays zero instead of becoming NaN. Check
+     * `magnitudeSquared()` first if a zero input needs handling.
+     */
+    normalize(): this;
+}

package/dist/types/math/index.d.ts

@@ -0,0 +1,6 @@
+export type { QuatLike, Vec3Like } from "./types.js";
+export { EPSILON, approxEqual, clamp } from "./scalar.js";
+export { Vec3 } from "./geometry/vec3.js";
+export { Mat3x3 } from "./geometry/mat3x3.js";
+export { Mat3x4 } from "./geometry/mat3x4.js";
+export { Quaternion } from "./geometry/quaternion.js";

package/dist/types/math/scalar.d.ts

@@ -0,0 +1,3 @@
+export declare const EPSILON = 0.000001;
+export declare function approxEqual(a: number, b: number, epsilon?: number): boolean;
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/types/math/types.d.ts

@@ -0,0 +1,15 @@
+/** Any object with numeric `x`, `y` and `z` components. */
+export interface Vec3Like {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Any object with numeric `x`, `y`, `z`, and `w` components.
+ */
+export interface QuatLike {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}

package/package.json

@@ -1,6 +1,48 @@
-{
-  "name": "aether-physics",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+    "name": "aether-physics",
+    "version": "0.1.0",
+    "description": "A 3D rigid-body physics engine built from scratch in TypeScript, with a Lit + Three.js playground.",
+    "license": "MIT",
+    "author": "Brandon Berisford",
+    "keywords": ["physics", "physics-engine", "rigid-body", "quaternion", "typescript"],
+    "homepage": "https://beyondbelief96.github.io/aether/",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/BeyondBelief96/aether.git"
+    },
+    "bugs": "https://github.com/BeyondBelief96/aether/issues",
+    "type": "module",
+    "sideEffects": ["./src/playground/**"],
+    "files": ["dist"],
+    "types": "./dist/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./math": {
+            "types": "./dist/types/math/index.d.ts",
+            "default": "./dist/math.js"
+        }
+    },
+    "scripts": {
+        "dev": "vite",
+        "build": "tsc && vite build",
+        "preview": "vite preview",
+        "build:lib": "vite build --config vite.lib.config.ts && tsc -p tsconfig.build.json",
+        "prepublishOnly": "npm run typecheck && npm run test:run && npm run build:lib",
+        "typecheck": "tsc",
+        "test": "vitest",
+        "test:run": "vitest run"
+    },
+    "devEngines": {},
+    "devDependencies": {
+        "@types/three": "^0.186.0",
+        "fast-check": "^4.10.2",
+        "lit": "^3.3.3",
+        "three": "^0.186.1",
+        "typescript": "^7.0.2",
+        "vite": "^8.3.4",
+        "vitest": "^5.0.3"
+    }
+}