math 0.0.3 → 0.1.0

package/dist/time/spring-core.js

@@ -0,0 +1,48 @@
+// Internal: the damped-harmonic-oscillator solver shared by every spring
+// dimension. `coefficients` recomputes the step's 2×2 linear map into `coef`
+// (module scratch, zero-allocation); each `spring*` namespace then applies those
+// four coefficients per component.
+// coefficients of the step's 2×2 map, recomputed per call into shared scratch:
+//   displacement' = coef.pp·displacement + coef.pv·velocity
+//   velocity'     = coef.vp·displacement + coef.vv·velocity
+const coef = { pp: 1, pv: 0, vp: 0, vv: 1 };
+function coefficients(smoothTime, dampingRatio, delta) {
+    const omega = 2 / Math.max(0.0001, smoothTime);
+    if (Math.abs(dampingRatio - 1) < 1e-4) {
+        // critically damped — a double root at -omega
+        const e = Math.exp(-omega * delta);
+        coef.pp = e * (1 + omega * delta);
+        coef.pv = e * delta;
+        coef.vp = -e * omega * omega * delta;
+        coef.vv = e * (1 - omega * delta);
+    }
+    else if (dampingRatio < 1) {
+        // under-damped — complex roots, oscillates and overshoots
+        const za = -omega * dampingRatio;
+        const wd = omega * Math.sqrt(1 - dampingRatio * dampingRatio);
+        const e = Math.exp(za * delta);
+        const c = Math.cos(wd * delta);
+        const s = Math.sin(wd * delta);
+        coef.pp = e * (c - (za * s) / wd);
+        coef.pv = (e * s) / wd;
+        coef.vp = (-e * omega * omega * s) / wd;
+        coef.vv = e * (c + (za * s) / wd);
+    }
+    else {
+        // over-damped — two real roots, no overshoot
+        const za = -omega * dampingRatio;
+        const zb = omega * Math.sqrt(dampingRatio * dampingRatio - 1);
+        const r1 = za - zb;
+        const r2 = za + zb;
+        const den = r1 - r2;
+        const e1 = Math.exp(r1 * delta);
+        const e2 = Math.exp(r2 * delta);
+        coef.pp = (r1 * e2 - r2 * e1) / den;
+        coef.pv = (e1 - e2) / den;
+        coef.vp = (omega * omega * (e2 - e1)) / den; // r1·r2 = omega²
+        coef.vv = (r1 * e1 - r2 * e2) / den;
+    }
+}
+
+export { coef, coefficients };
+//# sourceMappingURL=spring-core.js.map

package/dist/time/spring-core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-core.js","sources":["../../src/time/spring-core.ts"],"sourcesContent":["// Internal: the damped-harmonic-oscillator solver shared by every spring\n// dimension. `coefficients` recomputes the step's 2×2 linear map into `coef`\n// (module scratch, zero-allocation); each `spring*` namespace then applies those\n// four coefficients per component.\n\n/**\n * Spring state: a `value` and its `velocity`, of matching rank\n * (`number`, `Vec2`, `Vec3`, or `Vec4`). Allocate once, mutate each frame.\n */\nexport type Spring<T> = { value: T; velocity: T };\n\n// coefficients of the step's 2×2 map, recomputed per call into shared scratch:\n//   displacement' = coef.pp·displacement + coef.pv·velocity\n//   velocity'     = coef.vp·displacement + coef.vv·velocity\nexport const coef = { pp: 1, pv: 0, vp: 0, vv: 1 };\n\nexport function coefficients(smoothTime: number, dampingRatio: number, delta: number): void {\n    const omega = 2 / Math.max(0.0001, smoothTime);\n\n    if (Math.abs(dampingRatio - 1) < 1e-4) {\n        // critically damped — a double root at -omega\n        const e = Math.exp(-omega * delta);\n        coef.pp = e * (1 + omega * delta);\n        coef.pv = e * delta;\n        coef.vp = -e * omega * omega * delta;\n        coef.vv = e * (1 - omega * delta);\n    } else if (dampingRatio < 1) {\n        // under-damped — complex roots, oscillates and overshoots\n        const za = -omega * dampingRatio;\n        const wd = omega * Math.sqrt(1 - dampingRatio * dampingRatio);\n        const e = Math.exp(za * delta);\n        const c = Math.cos(wd * delta);\n        const s = Math.sin(wd * delta);\n        coef.pp = e * (c - (za * s) / wd);\n        coef.pv = (e * s) / wd;\n        coef.vp = (-e * omega * omega * s) / wd;\n        coef.vv = e * (c + (za * s) / wd);\n    } else {\n        // over-damped — two real roots, no overshoot\n        const za = -omega * dampingRatio;\n        const zb = omega * Math.sqrt(dampingRatio * dampingRatio - 1);\n        const r1 = za - zb;\n        const r2 = za + zb;\n        const den = r1 - r2;\n        const e1 = Math.exp(r1 * delta);\n        const e2 = Math.exp(r2 * delta);\n        coef.pp = (r1 * e2 - r2 * e1) / den;\n        coef.pv = (e1 - e2) / den;\n        coef.vp = (omega * omega * (e2 - e1)) / den; // r1·r2 = omega²\n        coef.vv = (r1 * e1 - r2 * e2) / den;\n    }\n}\n"],"names":[],"mappings":"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"}

package/dist/time/spring.js

@@ -0,0 +1,62 @@
+import { deltaAngle } from '../core/angle.js';
+import { coef, coefficients } from './spring-core.js';
+
+// A scalar spring (damped harmonic oscillator), integrated with the exact
+// analytic solution — unconditionally stable at any frame delta, and
+// behaviourally equivalent to Unity SmoothDamp / OG maath `damp` for the
+// critical case. Two dials:
+//   smoothTime    — roughly how long to reach the target; omega = 2 / smoothTime
+//   dampingRatio  — the character: 1 = critical (no overshoot), <1 bouncy, >1 sluggish
+// `damp` is `update` pinned to dampingRatio = 1.
+//
+// State lives in a `Spring<number>` the caller allocates once and passes back
+// each frame; `update`/`damp` mutate `value` and `velocity` in place.
+/** Creates a scalar spring at `value`, at rest. */
+const create = (value = 0) => ({ value, velocity: 0 });
+/**
+ * Springs `state.value` toward `target`, mutating `state` in place. Returns it.
+ *
+ * @param state spring state, mutated in place
+ * @param target goal value
+ * @param smoothTime approximate time to reach the target; smaller is faster
+ * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish
+ * @param delta frame delta, for refresh-rate independence
+ * @returns state
+ */
+function update(state, target, smoothTime, dampingRatio, delta) {
+    coefficients(smoothTime, dampingRatio, delta);
+    const d = state.value - target;
+    const v = state.velocity;
+    state.value = target + coef.pp * d + coef.pv * v;
+    state.velocity = coef.vp * d + coef.vv * v;
+    return state;
+}
+/**
+ * Critically-damped {@link update} (dampingRatio = 1): moves toward `target` as
+ * fast as possible without overshooting.
+ */
+function damp(state, target, smoothTime, delta) {
+    return update(state, target, smoothTime, 1, delta);
+}
+/**
+ * Like {@link damp}, but takes the shortest angular path to `target` (radians),
+ * wrapping across the ±π seam rather than unwinding the long way around.
+ */
+function dampAngle(state, target, smoothTime, delta) {
+    return damp(state, state.value + deltaAngle(state.value, target), smoothTime, delta);
+}
+/**
+ * Converts a SwiftUI-style `response` — the spring's natural period, in seconds
+ * — to the `smoothTime` that `update`/`damp` consume. `dampingRatio` is the
+ * orthogonal second dial and is passed to `update` unchanged.
+ *
+ * Yields the same stiffness/damping as SwiftUI's `Spring(response:dampingFraction:)`:
+ *
+ * ```ts
+ * spring3.update(state, target, spring.fromResponse(0.5), 0.3, delta); // bouncy, ~0.5s period
+ * ```
+ */
+const fromResponse = (response) => response / Math.PI;
+
+export { create, damp, dampAngle, fromResponse, update };
+//# sourceMappingURL=spring.js.map

package/dist/time/spring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring.js","sources":["../../src/time/spring.ts"],"sourcesContent":["import { deltaAngle } from '../core/angle';\nimport { coef, coefficients, type Spring } from './spring-core';\n\n// A scalar spring (damped harmonic oscillator), integrated with the exact\n// analytic solution — unconditionally stable at any frame delta, and\n// behaviourally equivalent to Unity SmoothDamp / OG maath `damp` for the\n// critical case. Two dials:\n//   smoothTime    — roughly how long to reach the target; omega = 2 / smoothTime\n//   dampingRatio  — the character: 1 = critical (no overshoot), <1 bouncy, >1 sluggish\n// `damp` is `update` pinned to dampingRatio = 1.\n//\n// State lives in a `Spring<number>` the caller allocates once and passes back\n// each frame; `update`/`damp` mutate `value` and `velocity` in place.\n\n/** Creates a scalar spring at `value`, at rest. */\nexport const create = (value = 0): Spring<number> => ({ value, velocity: 0 });\n\n/**\n * Springs `state.value` toward `target`, mutating `state` in place. Returns it.\n *\n * @param state spring state, mutated in place\n * @param target goal value\n * @param smoothTime approximate time to reach the target; smaller is faster\n * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish\n * @param delta frame delta, for refresh-rate independence\n * @returns state\n */\nexport function update(\n    state: Spring<number>,\n    target: number,\n    smoothTime: number,\n    dampingRatio: number,\n    delta: number,\n): Spring<number> {\n    coefficients(smoothTime, dampingRatio, delta);\n    const d = state.value - target;\n    const v = state.velocity;\n    state.value = target + coef.pp * d + coef.pv * v;\n    state.velocity = coef.vp * d + coef.vv * v;\n    return state;\n}\n\n/**\n * Critically-damped {@link update} (dampingRatio = 1): moves toward `target` as\n * fast as possible without overshooting.\n */\nexport function damp(state: Spring<number>, target: number, smoothTime: number, delta: number): Spring<number> {\n    return update(state, target, smoothTime, 1, delta);\n}\n\n/**\n * Like {@link damp}, but takes the shortest angular path to `target` (radians),\n * wrapping across the ±π seam rather than unwinding the long way around.\n */\nexport function dampAngle(state: Spring<number>, target: number, smoothTime: number, delta: number): Spring<number> {\n    return damp(state, state.value + deltaAngle(state.value, target), smoothTime, delta);\n}\n\n/**\n * Converts a SwiftUI-style `response` — the spring's natural period, in seconds\n * — to the `smoothTime` that `update`/`damp` consume. `dampingRatio` is the\n * orthogonal second dial and is passed to `update` unchanged.\n *\n * Yields the same stiffness/damping as SwiftUI's `Spring(response:dampingFraction:)`:\n *\n * ```ts\n * spring3.update(state, target, spring.fromResponse(0.5), 0.3, delta); // bouncy, ~0.5s period\n * ```\n */\nexport const fromResponse = (response: number): number => response / Math.PI;\n"],"names":[],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;MACa,MAAM,GAAG,CAAC,KAAK,GAAG,CAAC,MAAsB,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE;AAE5E;;;;;;;;;AASG;AACG,SAAU,MAAM,CAClB,KAAqB,EACrB,MAAc,EACd,UAAkB,EAClB,YAAoB,EACpB,KAAa,EAAA;AAEb,IAAA,YAAY,CAAC,UAAU,EAAE,YAAY,EAAE,KAAK,CAAC;AAC7C,IAAA,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,GAAG,MAAM;AAC9B,IAAA,MAAM,CAAC,GAAG,KAAK,CAAC,QAAQ;AACxB,IAAA,KAAK,CAAC,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAChD,IAAA,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAC1C,IAAA,OAAO,KAAK;AAChB;AAEA;;;AAGG;AACG,SAAU,IAAI,CAAC,KAAqB,EAAE,MAAc,EAAE,UAAkB,EAAE,KAAa,EAAA;AACzF,IAAA,OAAO,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,KAAK,CAAC;AACtD;AAEA;;;AAGG;AACG,SAAU,SAAS,CAAC,KAAqB,EAAE,MAAc,EAAE,UAAkB,EAAE,KAAa,EAAA;IAC9F,OAAO,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC;AACxF;AAEA;;;;;;;;;;AAUG;AACI,MAAM,YAAY,GAAG,CAAC,QAAgB,KAAa,QAAQ,GAAG,IAAI,CAAC;;;;"}

package/dist/time/spring2.js

@@ -0,0 +1,31 @@
+import { coefficients, coef } from './spring-core.js';
+
+// A Vec2 spring. See `spring` (scalar) for the model; the same four coefficients
+// are applied to each component. `damp` is `update` pinned to dampingRatio = 1.
+/** Creates a Vec2 spring at `value` (copied), at rest. */
+const create = (value = [0, 0]) => ({ value: [value[0], value[1]], velocity: [0, 0] });
+/**
+ * Springs `state.value` toward `target`, mutating `state` in place. Returns it.
+ * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish
+ */
+function update(state, target, smoothTime, dampingRatio, delta) {
+    coefficients(smoothTime, dampingRatio, delta);
+    const val = state.value;
+    const vel = state.velocity;
+    let d = val[0] - target[0];
+    let v = vel[0];
+    val[0] = target[0] + coef.pp * d + coef.pv * v;
+    vel[0] = coef.vp * d + coef.vv * v;
+    d = val[1] - target[1];
+    v = vel[1];
+    val[1] = target[1] + coef.pp * d + coef.pv * v;
+    vel[1] = coef.vp * d + coef.vv * v;
+    return state;
+}
+/** Critically-damped Vec2 spring (dampingRatio = 1). See {@link update}. */
+function damp(state, target, smoothTime, delta) {
+    return update(state, target, smoothTime, 1, delta);
+}
+
+export { create, damp, update };
+//# sourceMappingURL=spring2.js.map

package/dist/time/spring2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring2.js","sources":["../../src/time/spring2.ts"],"sourcesContent":["import type { Vec2 } from '../core';\nimport { coef, coefficients, type Spring } from './spring-core';\n\n// A Vec2 spring. See `spring` (scalar) for the model; the same four coefficients\n// are applied to each component. `damp` is `update` pinned to dampingRatio = 1.\n\n/** Creates a Vec2 spring at `value` (copied), at rest. */\nexport const create = (value: Vec2 = [0, 0]): Spring<Vec2> => ({ value: [value[0], value[1]], velocity: [0, 0] });\n\n/**\n * Springs `state.value` toward `target`, mutating `state` in place. Returns it.\n * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish\n */\nexport function update(state: Spring<Vec2>, target: Vec2, smoothTime: number, dampingRatio: number, delta: number): Spring<Vec2> {\n    coefficients(smoothTime, dampingRatio, delta);\n    const val = state.value;\n    const vel = state.velocity;\n    let d = val[0] - target[0];\n    let v = vel[0];\n    val[0] = target[0] + coef.pp * d + coef.pv * v;\n    vel[0] = coef.vp * d + coef.vv * v;\n    d = val[1] - target[1];\n    v = vel[1];\n    val[1] = target[1] + coef.pp * d + coef.pv * v;\n    vel[1] = coef.vp * d + coef.vv * v;\n    return state;\n}\n\n/** Critically-damped Vec2 spring (dampingRatio = 1). See {@link update}. */\nexport function damp(state: Spring<Vec2>, target: Vec2, smoothTime: number, delta: number): Spring<Vec2> {\n    return update(state, target, smoothTime, 1, delta);\n}\n"],"names":[],"mappings":";;AAGA;AACA;AAEA;AACO,MAAM,MAAM,GAAG,CAAC,QAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAoB,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;AAEhH;;;AAGG;AACG,SAAU,MAAM,CAAC,KAAmB,EAAE,MAAY,EAAE,UAAkB,EAAE,YAAoB,EAAE,KAAa,EAAA;AAC7G,IAAA,YAAY,CAAC,UAAU,EAAE,YAAY,EAAE,KAAK,CAAC;AAC7C,IAAA,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK;AACvB,IAAA,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ;IAC1B,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AAC1B,IAAA,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IACd,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAC9C,IAAA,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;IAClC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AACtB,IAAA,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IACV,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAC9C,IAAA,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAClC,IAAA,OAAO,KAAK;AAChB;AAEA;AACM,SAAU,IAAI,CAAC,KAAmB,EAAE,MAAY,EAAE,UAAkB,EAAE,KAAa,EAAA;AACrF,IAAA,OAAO,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,KAAK,CAAC;AACtD;;;;"}

package/dist/time/spring3.js

@@ -0,0 +1,32 @@
+import { coefficients, coef } from './spring-core.js';
+
+// A Vec3 spring. See `spring` (scalar) for the model. `damp` is `update` pinned
+// to dampingRatio = 1.
+/** Creates a Vec3 spring at `value` (copied), at rest. */
+const create = (value = [0, 0, 0]) => ({
+    value: [value[0], value[1], value[2]],
+    velocity: [0, 0, 0],
+});
+/**
+ * Springs `state.value` toward `target`, mutating `state` in place. Returns it.
+ * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish
+ */
+function update(state, target, smoothTime, dampingRatio, delta) {
+    coefficients(smoothTime, dampingRatio, delta);
+    const val = state.value;
+    const vel = state.velocity;
+    for (let i = 0; i < 3; i++) {
+        const d = val[i] - target[i];
+        const v = vel[i];
+        val[i] = target[i] + coef.pp * d + coef.pv * v;
+        vel[i] = coef.vp * d + coef.vv * v;
+    }
+    return state;
+}
+/** Critically-damped Vec3 spring (dampingRatio = 1). See {@link update}. */
+function damp(state, target, smoothTime, delta) {
+    return update(state, target, smoothTime, 1, delta);
+}
+
+export { create, damp, update };
+//# sourceMappingURL=spring3.js.map

package/dist/time/spring3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring3.js","sources":["../../src/time/spring3.ts"],"sourcesContent":["import type { Vec3 } from '../core';\nimport { coef, coefficients, type Spring } from './spring-core';\n\n// A Vec3 spring. See `spring` (scalar) for the model. `damp` is `update` pinned\n// to dampingRatio = 1.\n\n/** Creates a Vec3 spring at `value` (copied), at rest. */\nexport const create = (value: Vec3 = [0, 0, 0]): Spring<Vec3> => ({\n    value: [value[0], value[1], value[2]],\n    velocity: [0, 0, 0],\n});\n\n/**\n * Springs `state.value` toward `target`, mutating `state` in place. Returns it.\n * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish\n */\nexport function update(state: Spring<Vec3>, target: Vec3, smoothTime: number, dampingRatio: number, delta: number): Spring<Vec3> {\n    coefficients(smoothTime, dampingRatio, delta);\n    const val = state.value;\n    const vel = state.velocity;\n    for (let i = 0; i < 3; i++) {\n        const d = val[i] - target[i];\n        const v = vel[i];\n        val[i] = target[i] + coef.pp * d + coef.pv * v;\n        vel[i] = coef.vp * d + coef.vv * v;\n    }\n    return state;\n}\n\n/** Critically-damped Vec3 spring (dampingRatio = 1). See {@link update}. */\nexport function damp(state: Spring<Vec3>, target: Vec3, smoothTime: number, delta: number): Spring<Vec3> {\n    return update(state, target, smoothTime, 1, delta);\n}\n"],"names":[],"mappings":";;AAGA;AACA;AAEA;AACO,MAAM,MAAM,GAAG,CAAC,QAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAoB;AAC9D,IAAA,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;AACrC,IAAA,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AACtB,CAAA;AAED;;;AAGG;AACG,SAAU,MAAM,CAAC,KAAmB,EAAE,MAAY,EAAE,UAAkB,EAAE,YAAoB,EAAE,KAAa,EAAA;AAC7G,IAAA,YAAY,CAAC,UAAU,EAAE,YAAY,EAAE,KAAK,CAAC;AAC7C,IAAA,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK;AACvB,IAAA,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ;AAC1B,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QACxB,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AAC5B,QAAA,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAC9C,QAAA,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;IACtC;AACA,IAAA,OAAO,KAAK;AAChB;AAEA;AACM,SAAU,IAAI,CAAC,KAAmB,EAAE,MAAY,EAAE,UAAkB,EAAE,KAAa,EAAA;AACrF,IAAA,OAAO,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,KAAK,CAAC;AACtD;;;;"}

package/dist/time/spring4.js

@@ -0,0 +1,32 @@
+import { coefficients, coef } from './spring-core.js';
+
+// A Vec4 spring. See `spring` (scalar) for the model. `damp` is `update` pinned
+// to dampingRatio = 1.
+/** Creates a Vec4 spring at `value` (copied), at rest. */
+const create = (value = [0, 0, 0, 0]) => ({
+    value: [value[0], value[1], value[2], value[3]],
+    velocity: [0, 0, 0, 0],
+});
+/**
+ * Springs `state.value` toward `target`, mutating `state` in place. Returns it.
+ * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish
+ */
+function update(state, target, smoothTime, dampingRatio, delta) {
+    coefficients(smoothTime, dampingRatio, delta);
+    const val = state.value;
+    const vel = state.velocity;
+    for (let i = 0; i < 4; i++) {
+        const d = val[i] - target[i];
+        const v = vel[i];
+        val[i] = target[i] + coef.pp * d + coef.pv * v;
+        vel[i] = coef.vp * d + coef.vv * v;
+    }
+    return state;
+}
+/** Critically-damped Vec4 spring (dampingRatio = 1). See {@link update}. */
+function damp(state, target, smoothTime, delta) {
+    return update(state, target, smoothTime, 1, delta);
+}
+
+export { create, damp, update };
+//# sourceMappingURL=spring4.js.map

package/dist/time/spring4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring4.js","sources":["../../src/time/spring4.ts"],"sourcesContent":["import type { Vec4 } from '../core';\nimport { coef, coefficients, type Spring } from './spring-core';\n\n// A Vec4 spring. See `spring` (scalar) for the model. `damp` is `update` pinned\n// to dampingRatio = 1.\n\n/** Creates a Vec4 spring at `value` (copied), at rest. */\nexport const create = (value: Vec4 = [0, 0, 0, 0]): Spring<Vec4> => ({\n    value: [value[0], value[1], value[2], value[3]],\n    velocity: [0, 0, 0, 0],\n});\n\n/**\n * Springs `state.value` toward `target`, mutating `state` in place. Returns it.\n * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish\n */\nexport function update(state: Spring<Vec4>, target: Vec4, smoothTime: number, dampingRatio: number, delta: number): Spring<Vec4> {\n    coefficients(smoothTime, dampingRatio, delta);\n    const val = state.value;\n    const vel = state.velocity;\n    for (let i = 0; i < 4; i++) {\n        const d = val[i] - target[i];\n        const v = vel[i];\n        val[i] = target[i] + coef.pp * d + coef.pv * v;\n        vel[i] = coef.vp * d + coef.vv * v;\n    }\n    return state;\n}\n\n/** Critically-damped Vec4 spring (dampingRatio = 1). See {@link update}. */\nexport function damp(state: Spring<Vec4>, target: Vec4, smoothTime: number, delta: number): Spring<Vec4> {\n    return update(state, target, smoothTime, 1, delta);\n}\n"],"names":[],"mappings":";;AAGA;AACA;AAEA;AACO,MAAM,MAAM,GAAG,CAAC,KAAA,GAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,MAAoB;IACjE,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAC/C,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AACzB,CAAA;AAED;;;AAGG;AACG,SAAU,MAAM,CAAC,KAAmB,EAAE,MAAY,EAAE,UAAkB,EAAE,YAAoB,EAAE,KAAa,EAAA;AAC7G,IAAA,YAAY,CAAC,UAAU,EAAE,YAAY,EAAE,KAAK,CAAC;AAC7C,IAAA,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK;AACvB,IAAA,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ;AAC1B,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QACxB,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AAC5B,QAAA,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;QAChB,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;AAC9C,QAAA,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;IACtC;AACA,IAAA,OAAO,KAAK;AAChB;AAEA;AACM,SAAU,IAAI,CAAC,KAAmB,EAAE,MAAY,EAAE,UAAkB,EAAE,KAAa,EAAA;AACrF,IAAA,OAAO,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,KAAK,CAAC;AACtD;;;;"}

package/package.json

@@ -1,20 +1,94 @@
 {
-  "author": "Kaleb Hornsby <kaleb@hornsby.ws> (kaleb.hornsby.ws)",
   "name": "math",
-  "description": "Mathematical Functions",
-  "version": "0.0.3",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/kaleb/js-math.git"
+  "version": "0.1.0",
+  "author": "Isaac Mason <isaac@isaacmason.com>",
+  "description": "a collection of math helpers for graphics and simulations",
+  "keywords": [
+    "math",
+    "vector",
+    "matrix",
+    "quaternion",
+    "euler",
+    "random",
+    "noise"
+  ],
+  "license": "MIT",
+  "repository": "github:pmndrs/math",
+  "homepage": "https://github.com/pmndrs/math",
+  "bugs": {
+    "url": "https://github.com/pmndrs/math/issues"
   },
-  "main": "math.js",
-  "engines": {
-    "node": "> 0.0.0"
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/src/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/src/index.d.ts"
+    },
+    "./shapes": {
+      "import": "./dist/shapes/index.js",
+      "types": "./dist/src/shapes/index.d.ts"
+    },
+    "./geometry": {
+      "import": "./dist/geometry/index.js",
+      "types": "./dist/src/geometry/index.d.ts"
+    },
+    "./time": {
+      "import": "./dist/time/index.js",
+      "types": "./dist/src/time/index.d.ts"
+    },
+    "./random": {
+      "import": "./dist/random/index.js",
+      "types": "./dist/src/random/index.d.ts"
+    },
+    "./noise": {
+      "import": "./dist/noise/index.js",
+      "types": "./dist/src/noise/index.d.ts"
+    },
+    "./color": {
+      "import": "./dist/color/index.js",
+      "types": "./dist/src/color/index.d.ts"
+    },
+    "./ik": {
+      "import": "./dist/ik/index.js",
+      "types": "./dist/src/ik/index.d.ts"
+    }
   },
-  "dependencies": {},
-  "devDependencies": {},
-  "homepage": "kaleb.hornsby.ws/js-math",
-  "contributors": [
-    "Kaleb Hornsby <kaleb@hornsby.ws> (kaleb.hornsby.ws)"
-  ]
-}
+  "files": [
+    "dist",
+    "skills",
+    "LICENSE",
+    "README.md",
+    "API.md"
+  ],
+  "scripts": {
+    "build": "rm -rf ./dist && pnpm run build:bundle && pnpm run build:dts",
+    "build:bundle": "rollup --config rollup.config.mjs",
+    "build:dts": "tsc -p tsconfig.build.json && node scripts/add-js-extensions-dts.mjs",
+    "build:examples": "pnpm --filter math-examples build",
+    "dev:examples": "pnpm --filter math-examples dev",
+    "build:website": "pnpm --filter website build",
+    "format": "biome format --write src/. tst/.",
+    "lint": "biome lint --write src/. tst/.",
+    "test": "vitest run ./tst",
+    "bench": "pnpm --filter benches exec labs",
+    "typecheck-docs": "tsc --project docs/tsconfig.json --noEmit",
+    "docs": "(cd docs && node ./build.js)",
+    "typedoc": "typedoc --tsconfig ./tsconfig.json --name \"math docs\" --out ./dist-typedoc ./src/index.ts ./src/shapes/index.ts ./src/geometry/index.ts ./src/time/index.ts ./src/random/index.ts ./src/noise/index.ts ./src/color/index.ts ./src/ik/index.ts",
+    "build:docs": "pnpm run docs && pnpm run typedoc",
+    "release": "pnpm run build && pnpm run test && pnpm run build:examples && pnpm run build:docs && pnpm run build:website"
+  },
+  "packageManager": "pnpm@11.22.0",
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.6",
+    "@rollup/plugin-node-resolve": "^16",
+    "@rollup/plugin-typescript": "^12",
+    "rollup": "^4",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.16",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}

package/skills/math/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: math
+description: Use when writing or reviewing geometry, simulation, collision, navigation, culling, procedural generation, transforms, or other performance-sensitive algorithms with the npm `math` package, or when the user invokes /math. Not for routine arithmetic or textbook explanations.
+---
+
+# math
+
+Write data-oriented TypeScript on top of the npm `math` package: plain data, free functions, no classes, no allocation in hot paths.
+
+API docs are in `API.md` — every export with its signature, grouped by module and flat enough to grep. Find it at `node_modules/math/API.md` in a consuming project, or at the repo root when working on `math` itself.
+
+## Types
+
+Every type is a plain fixed-length tuple of numbers — no classes, no wrappers, and not a typed array:
+
+- `Vec2` `[x, y]`, `Vec3` `[x, y, z]`, `Vec4` `[x, y, z, w]`
+- `Quat` `[x, y, z, w]`, `Quat2` `[x, y, z, w, x2, y2, z2, w2]`
+- `Euler` `[x, y, z, order?]`, radians, order defaulting to `'xyz'`
+- `Mat2` (4), `Mat2d` (6), `Mat3` (9), `Mat4` (16) — contiguous and column-major, with `Mat4` translation in `m[12]`, `m[13]`, `m[14]`
+- `Polar` `[r, theta]`, `Spherical` `[r, theta, phi]`
+
+## Style
+
+- **Functions over data.** Export `function` declarations that take typed data and operate on it. Never classes for data, never closures that hold state. The one exception is a small fixed set of classes implementing a single structural type — a collector handed to a query to receive its hits, say — where the call site is polymorphic and a stable hidden class keeps it fast.
+- **`out` first, return `out`** for composite results: `fn(out: Vec3, a: Vec3, b: Vec3): Vec3`. Scalars and booleans return directly.
+- **Use result objects and `out` params over returning new objects.** When a result doesn't fit a vector, define a result type with a `createXResult()` factory beside it; report failure with a boolean or status enum rather than `out | null`.
+- **Assume the caller aliases** — the same array may arrive as both `out` and an input, as in `vec3.normalize(v, v)` or `vec3.cross(a, a, b)`. Read every input component into a local before the first write to `out`, so a write can't clobber an input still needed.
+- **Caller-owned state.** Long-lived state is plain data the caller allocates and owns. Functions receive it, mutate it in place, and return it. The library never owns the data lifecycle, so allocation happens once, ownership is explicit, and the object keeps one stable shape. Naming and file layout are up to the codebase. One common shape:
+
+```ts
+export function createWorld(capacity: number) {
+    return { capacity, count: 0, positions: new Float32Array(capacity * 3) };
+}
+export type World = ReturnType<typeof createWorld>;
+
+export function stepWorld(world: World, delta: number): World { /* mutate, return world */ }
+export function getWorldPosition(out: Vec3, world: World, i: number): Vec3 { /* write out, return it */ }
+```
+
+- **Monomorphic state.** Build the object with the same keys in the same order every time. No optional fields, no keys added later.
+- **Allocate at creation, never per call.** Preallocate flat or typed arrays to capacity. When full, return a count, sentinel, or status rather than growing inside a hot loop.
+- **Compose `math` primitives** (`vec3`, `mat4`, `quat`, and the `math/shapes`, `math/geometry`, `math/noise`, `math/random`, `math/time` subpaths).
+- **Hoist invariants out of loops**
+
+## Gotchas
+
+- Module-level scratch is named `_owner_purpose`. Grow-once buffers carry an explicit size counter rather than `push`/`pop`/`length = 0`.
+- Module-level scratch variables are not reentrant. Pass caller-owned workspace for recursive, nested, or worker code.
+- One epsilon does not fit every operation or scale. Choose each tolerance and say why.
+- Define behavior for empty input, zero-length vectors, degenerate geometry, NaN, and exact boundary contact.
+- Compare squared distances; reach for `squaredLength` / `squaredDistance` over their square-rooted pairs.
+- Integers in the range [-2^30, 2^30) are stored in the pointer itself (V8 Smi), with no heap object. Use them for indices, handles, packed IDs, bitmasks, and counts.
+- Where possible avoid plain array element kind transitions (small integers, doubles, array with holes). Especially avoid unnecessary SMI or PACKED_DOUBLE to holey transitions when holey arrays are not desired.
+- Don't assume a typed array is faster. A packed plain array is already unboxed and can still grow. Typed arrays buy footprint, a fixed layout, and zero-copy interop with workers, Wasm, and the GPU; they cost a capacity fixed up front and, for `Float32Array`, a narrowing conversion on every write. Choose one for interop or memory, not on a hunch about speed.
+- In a **library**, annotate module-level factory calls `/* @__PURE__ */` so a consumer's bundler can drop the scratch when the function is tree-shaken out. Application code does not need it.
+
+Deliver the implementation with its assumptions, complexity, edge cases, and focused tests.
+
+## Working with other libs
+
+Marshal in, compute, marshal out — and allocate on neither crossing. Keep the scratch `math` types at module scope, fill them from the other library's values, run the algorithm as plain `math` calls, then write the results back. The seam is a few lines at each end of a function; everything between them is flat data.
+
+- **A `Float32Array` is not a `Vec3`.** The tuple types don't accept one, and casting past that gets you a value the rest of the codebase can't rely on. Marshal across the boundary instead.
+- **Marshal with whatever writes into memory you already own.** For flat buffers — an instanced attribute, a packed particle array — that's `vec3.fromBuffer(out, buffer, i * 3)` and `vec3.toBuffer(buffer, v, i * 3)` (also on `vec2`, `vec4`, `quat`), or `buffer.set(m, i * 16)` for a whole matrix, since `TypedArray.set` takes any array-like.
+- **State that crosses a worker, Wasm, or GPU boundary lives in a typed array from the start.** A plain-array `Vec3` can't be transferred or shared, so back the long-lived data with `Float32Array` / `SharedArrayBuffer` at creation and marshal at the edges.
+
+### three.js
+
+`Vector3`, `Quaternion`, `Matrix4`, and `Euler` all marshal through `toArray(target)` and `fromArray(source)`, and the component order matches `math`'s in every case. Always pass your scratch to `toArray` — called bare, it allocates a fresh array.
+
+**Orbit camera.** The camera's state is a `Spherical` and a target the caller owns; three only ever sees the resulting position.
+
+```ts
+import { spherical, vec3 } from 'math';
+import type { Camera } from 'three';
+
+const MIN_RADIUS = 1;
+const MAX_RADIUS = 100;
+
+export function createOrbit() {
+    return { target: vec3.create(), orbit: spherical.fromValues(10, 0, Math.PI / 3) };
+}
+export type Orbit = ReturnType<typeof createOrbit>;
+
+const _orbit_position = vec3.create();
+
+/** Apply a drag in radians and a zoom factor, then place the camera. */
+export function updateOrbit(camera: Camera, orbit: Orbit, dragX: number, dragY: number, zoom: number): void {
+    const s = orbit.orbit;
+
+    s[0] = Math.min(MAX_RADIUS, Math.max(MIN_RADIUS, s[0] * zoom));
+    s[1] -= dragX;
+    s[2] -= dragY;
+    spherical.makeSafe(s, s); // keeps phi off the poles, where the frame degenerates
+
+    vec3.add(_orbit_position, spherical.toVec3(_orbit_position, s), orbit.target);
+
+    camera.position.fromArray(_orbit_position);
+    camera.lookAt(orbit.target[0], orbit.target[1], orbit.target[2]);
+}
+```
+
+**Camera-relative character move.** Takes the yaw straight from that orbit state, so stick-forward means away-from-camera.
+
+```ts
+import { quat, vec3, type Vec3 } from 'math';
+import type { Object3D } from 'three';
+
+const UP: Vec3 = [0, 1, 0];
+const TURN_RATE = 15;
+const DEADZONE_SQ = 0.01;
+
+const _move_yaw = quat.create();
+const _move_facing = quat.create();
+const _move_rotation = quat.create();
+const _move_position = vec3.create();
+const _move_direction = vec3.create();
+
+/** Move `character` by `inputX` / `inputZ` (a stick, in [-1, 1]) relative to a camera at `yaw`. */
+export function moveCharacter(character: Object3D, inputX: number, inputZ: number, yaw: number, speed: number, delta: number): void {
+    vec3.set(_move_direction, inputX, 0, inputZ);
+    if (vec3.squaredLength(_move_direction) < DEADZONE_SQ) return; // idle: leave the facing alone
+
+    // swing the stick into camera space, then step along it
+    quat.setAxisAngle(_move_yaw, UP, yaw);
+    vec3.transformQuat(_move_direction, _move_direction, _move_yaw);
+    vec3.normalize(_move_direction, _move_direction);
+
+    character.position.toArray(_move_position);
+    vec3.scaleAndAdd(_move_position, _move_position, _move_direction, speed * delta);
+
+    // turn toward travel, rather than snapping
+    character.quaternion.toArray(_move_rotation);
+    quat.setAxisAngle(_move_facing, UP, Math.atan2(_move_direction[0], _move_direction[2]));
+    quat.slerp(_move_rotation, _move_rotation, _move_facing, 1 - TURN_RATE ** -delta);
+
+    character.position.fromArray(_move_position);
+    character.quaternion.fromArray(_move_rotation);
+}
+```

package/AUTHORS

@@ -1 +0,0 @@
-Kaleb Hornsby <kaleb@hornsby.ws> (kaleb.hornsby.ws)

package/Cakefile

@@ -1,28 +0,0 @@
-{exec, spawn} = require 'child_process'
-path = require 'path'
-
-repo = 'git' # or 'hg
-
-getVersion = -> spawn 'npm', ['--version'], (err, stdout, stderr) ->
-    [err, stdout, stderr]
-
-task 'edit', 'Edit the Cakefile', (options) ->
-    console.log 'Not implemented', options
-
-task 'version', 'Display the package version.', (options) ->
-    exec 'npm --version', (error, stdout, stderr) ->
-        version = stdout.split('.')
-        console.log version[2]
-
-task 'ci', 'commit', (options) ->
-    console.dir(options)
-    exec "#{repo} commit", (error, stdout, stderr) ->
-        console.log stdout
-
-task 'co', 
-
-task 'push'
-
-task 'pull'
-
-option '-m', '--message', 'Message'

package/math.coffee

@@ -1,112 +0,0 @@
-module?.exports &&= Math
-
-###*
- * @return wheter a Number x, has the same sign as another Number, y.
- * @example
- * Math.samesign(1,2)
- * //-> true
- * Math.samesign(-3, 4)
- * //-> false
- * @test
- * Math.samesign(5, 6)
- * //-> false
- * Math.samesign(-7, -8)
- * //-> true
- ###
-Math.samesign = (x, y) -> (x >= 0) != (y < 0)
-
-###*
- * @return {Number} a copy of Number x with the same sign of Number y.
- * @example
- * Math.copysign(1, -2)
- * //-> -1
- * @test
- * Math.copysign(-3, 4)
- * //-> 3
- * Math.copysign(5, 6)
- * //-> 5
- * Math.copysign(-7, -8)
- * //-> -7
- ###
-Math.copysign = (x, y) -> if Math.samesign x, y then x else -x
-
-###*
- * @return {Number} sum of two Numbers.
- * @example
- * Math.add(1, 2)
- * //-> 3
- * @test
- * Math.add('three', 4)
- * //-> NaN
- ###
-Math.add = (a, b) -> (+a) + (+b)
-
-###*
- * @return {Number} sum of an Array of Numbers.
- * @example
- * Math.sum([1, 2, 3])
- * //-> 6
- ###
-Math.sum = (nums) -> nums.reduce Math.add
-
-###*
- * @return {Number} product of two Numbers.
- * @example
- * Math.(2, 3)
- * //-> 6
- ###
-Math.mul = (a, b) -> a * b
-
-###*
- * @return {Number} product of an Array of Numbers.
- * @example
- * Math.prod(2, 3, 4)
- * //-> 24
- ###
-Math.prod = (nums) -> nums.reduce Math.mul
-
-###*
- * @return {Number} factorial of a Number.
- * @example
- * Math.factorial(4)
- * //-> 24
- * @test
- * Math.factorial(3)
- * //-> 6
- * Math.factorial(2)
- * //-> 2
- * Math.factorial(1)
- * //-> 1
- * Math.factorial(0)
- * //-> 1
- * Math.factorial(-1)
- * //-> Infinity
- ###
-Math.factorial = (n) ->
-    if n < 0 then Infinity
-    else if n == 0 then 1
-    else Math.prod.apply null, [1..n]
-
-###*
- * Greatest Common Multipler
- * @return {Number} greatest common multipler of two Numbers.
- * @example
- * Math.gcd(493, 289)
- * //-> 17
- * @test
- * Math.gcd(493, -289)
- * //-> 17
- ###
-Math.gcd = (a, b) -> [a, b] = [b, a % b] while b; a
-
-###*
- * Least Common Multiplier
- * @return {Number} least common multiplier of two numbers.
- * @example
- * Math.lcm(4, 12)
- * //-> 12
- * @test
- * Math.lcm(6, 7)
- * //-> 42
- ###
-Math.lcm = (a, b) -> a / Math.gcd(a, b) * b