math 0.0.0 → 0.1.0

package/dist/src/shapes/plane3.d.ts

@@ -0,0 +1,130 @@
+import type { Mat4 } from '../core/mat4.js';
+import type { Vec3 } from '../core/vec3.js';
+import type { Sphere } from './sphere.js';
+/**
+ * A plane in 3D space
+ * normal - a unit length vector defining the normal of the plane.
+ * constant - the signed distance from the origin to the plane.
+ */
+export type Plane3 = {
+    normal: Vec3;
+    constant: number;
+};
+/**
+ * Creates a new plane with normal (0, 1, 0) and constant 0
+ * @returns A new plane
+ */
+export declare function create(): Plane3;
+/**
+ * Creates a plane from a normal and constant
+ * @param out - The output plane
+ * @param normal - The plane normal (should be unit length)
+ * @param constant - The signed distance from origin
+ * @returns The output plane
+ */
+export declare function fromNormalAndConstant(out: Plane3, normal: Vec3, constant: number): Plane3;
+/**
+ * Creates a plane from a normal and a point on the plane
+ * @param out - The output plane
+ * @param normal - The plane normal (should be unit length)
+ * @param point - A point on the plane
+ * @returns The output plane
+ */
+export declare function fromNormalAndPoint(out: Plane3, normal: Vec3, point: Vec3): Plane3;
+/**
+ * Creates a plane from three coplanar points
+ * @param out - The output plane
+ * @param a - First point
+ * @param b - Second point
+ * @param c - Third point
+ * @returns The output plane
+ */
+export declare function fromCoplanarPoints(out: Plane3, a: Vec3, b: Vec3, c: Vec3): Plane3;
+/**
+ * Clones a plane
+ * @param plane - The plane to clone
+ * @returns A new plane
+ */
+export declare function clone(plane: Plane3): Plane3;
+/**
+ * Copies one plane to another
+ * @param out - The output plane
+ * @param plane - The source plane
+ * @returns The output plane
+ */
+export declare function copy(out: Plane3, plane: Plane3): Plane3;
+/**
+ * Normalizes a plane (ensures the normal vector is unit length)
+ * @param out - The output plane
+ * @param plane - The input plane
+ * @returns The normalized plane
+ */
+export declare function normalize(out: Plane3, plane: Plane3): Plane3;
+/**
+ * Negates a plane (flips the normal and constant)
+ * @param out - The output plane
+ * @param plane - The input plane
+ * @returns The negated plane
+ */
+export declare function negate(out: Plane3, plane: Plane3): Plane3;
+/**
+ * Offsets a plane by a distance along its normal
+ * @param out - The output plane
+ * @param plane - The input plane
+ * @param distance - The distance to offset (positive = in direction of normal)
+ * @returns The offset plane
+ */
+export declare function offset(out: Plane3, plane: Plane3, distance: number): Plane3;
+/**
+ * Calculates the signed distance from a point to the plane
+ * @param plane - The plane
+ * @param point - The point
+ * @returns The signed distance (positive = in direction of normal)
+ */
+export declare function distanceToPoint(plane: Plane3, point: Vec3): number;
+/**
+ * Projects a point onto the plane
+ * @param out - The output point
+ * @param plane - The plane
+ * @param point - The point to project
+ * @returns The projected point
+ */
+export declare function projectPoint(out: Vec3, plane: Plane3, point: Vec3): Vec3;
+/**
+ * Transforms a plane by a 4x4 matrix
+ * @param out - The output plane
+ * @param plane - The plane to transform
+ * @param matrix - The transformation matrix
+ * @returns The transformed plane
+ */
+export declare function transform(out: Plane3, plane: Plane3, matrix: Mat4): Plane3;
+/**
+ * Tests if a sphere intersects the plane
+ * @param plane - The plane
+ * @param sphere - The sphere
+ * @returns True if they intersect
+ */
+export declare function intersectsSphere(plane: Plane3, sphere: Sphere): boolean;
+/**
+ * Tests if two planes are exactly equal
+ * @param a - First plane
+ * @param b - Second plane
+ * @returns True if planes are exactly equal
+ */
+export declare function exactEquals(a: Plane3, b: Plane3): boolean;
+/**
+ * Finds the intersection point of three planes
+ * @param out - The output point where the three planes intersect
+ * @param p1 - First plane
+ * @param p2 - Second plane
+ * @param p3 - Third plane
+ * @returns True if intersection exists, false if planes are degenerate or parallel
+ */
+export declare function intersect(out: Vec3, p1: Plane3, p2: Plane3, p3: Plane3): boolean;
+/**
+ * Tests if two planes are equal
+ * @param a - First plane
+ * @param b - Second plane
+ * @returns True if planes are equal
+ */
+export declare function equals(a: Plane3, b: Plane3): boolean;

package/dist/src/shapes/polygon2.d.ts

@@ -0,0 +1,155 @@
+import type { Vec2 } from '../core/vec2.js';
+import type { Box2 } from './box2.js';
+/**
+ * A 2D polygon is represented as a flat array of vertex coordinates laid out as
+ * `[x0, y0, x1, y1, ...]`, together with an explicit vertex count `n`.
+ *
+ * The count is passed separately (rather than derived from `verts.length`) so a
+ * single scratch buffer can be reused across polygons of different sizes: only
+ * the first `n` vertices are read, and any trailing slots are ignored. Vertices
+ * are assumed to be ordered (clockwise or counter-clockwise) around the polygon.
+ */
+/**
+ * Returns the signed area of the polygon using the shoelace formula.
+ * The result is positive when the vertices wind counter-clockwise and negative
+ * when they wind clockwise, so the sign can be used to determine winding order.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns the signed area
+ */
+export declare function signedArea(vertices: number[], n: number): number;
+/**
+ * Returns the (non-negative) area of the polygon.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns the absolute area
+ */
+export declare function area(vertices: number[], n: number): number;
+/**
+ * Tests whether a point lies inside the polygon. Works for both convex and
+ * concave polygons. Points exactly on an edge or vertex are considered inside.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param point the point to test
+ * @returns true if the point is inside (or on the boundary of) the polygon
+ */
+export declare function containsPoint(vertices: number[], n: number, point: Vec2): boolean;
+/**
+ * Computes the area-weighted centroid (center of mass) of the polygon.
+ * For a degenerate (zero-area) polygon this falls back to the average of the
+ * vertices.
+ *
+ * @param out the vector to store the centroid
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns out
+ */
+export declare function centroid(out: Vec2, vertices: number[], n: number): Vec2;
+/**
+ * Returns the perimeter (sum of edge lengths) of the polygon.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns the perimeter
+ */
+export declare function perimeter(vertices: number[], n: number): number;
+/**
+ * Returns the winding order of the polygon from the sign of its signed area:
+ * `1` for counter-clockwise, `-1` for clockwise, and `0` for a degenerate
+ * (zero-area) polygon.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns 1 (CCW), -1 (CW), or 0 (degenerate)
+ */
+export declare function winding(vertices: number[], n: number): number;
+/**
+ * Tests whether the polygon is convex. Works for both winding orders. Assumes a
+ * simple (non-self-intersecting) polygon; collinear vertices are allowed.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns true if the polygon is convex
+ */
+export declare function isConvex(vertices: number[], n: number): boolean;
+/**
+ * Tests whether vertex `i` is a reflex (concave) vertex of the polygon — the
+ * interior angle at that vertex exceeds 180°. Assumes the polygon is wound
+ * counter-clockwise and that `0 <= i < n`.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param i index of the vertex to test
+ * @returns true if vertex `i` is reflex
+ */
+export declare function isReflexVertex(vertices: number[], n: number, i: number): boolean;
+/**
+ * Reverses the winding order of the polygon, writing the result into `out`.
+ * `out` may be the same array as `vertices` to reverse in place.
+ *
+ * @param out the array to write the reversed polygon into
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns out
+ */
+export declare function reverse(out: number[], vertices: number[], n: number): number[];
+/**
+ * Writes the axis-aligned bounding box of the polygon into `out` as a Box2
+ * `[minX, minY, maxX, maxY]`.
+ *
+ * @param out the box to store the result
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns out
+ */
+export declare function bounds(out: Box2, vertices: number[], n: number): Box2;
+/**
+ * Finds the point on the polygon's boundary closest to `point` and writes it to
+ * `out`. `point` may lie inside, outside, or on the polygon; the result is
+ * always on an edge.
+ *
+ * @param out the vector to store the closest point
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param point the query point
+ * @returns out
+ */
+export declare function closestPoint(out: Vec2, vertices: number[], n: number, point: Vec2): Vec2;
+/**
+ * Returns the distance from `point` to the polygon's boundary, signed so that
+ * points inside the polygon get a negative distance and points outside get a
+ * positive one.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param point the query point
+ * @returns the signed distance (negative inside, positive outside)
+ */
+export declare function signedDistance(vertices: number[], n: number, point: Vec2): number;
+/**
+ * Tests whether two convex polygons overlap, using the separating axis theorem.
+ * Both polygons must be convex; results are undefined for concave input.
+ * Polygons that touch along an edge or vertex are considered overlapping.
+ *
+ * @param verticesA vertices of the first polygon `[x0, y0, x1, y1, ...]`
+ * @param numA number of vertices in the first polygon
+ * @param verticesB vertices of the second polygon `[x0, y0, x1, y1, ...]`
+ * @param numB number of vertices in the second polygon
+ * @returns true if the polygons overlap
+ */
+export declare function overlapConvex(verticesA: number[], numA: number, verticesB: number[], numB: number): boolean;
+/**
+ * Tests whether the segment `a`-`b` intersects the polygon, i.e. it has an
+ * endpoint inside the polygon or crosses one of its edges. Works for convex and
+ * concave polygons.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param a start of the segment
+ * @param b end of the segment
+ * @returns true if the segment intersects the polygon
+ */
+export declare function intersectsSegment(vertices: number[], n: number, a: Vec2, b: Vec2): boolean;

package/dist/src/shapes/raycast3.d.ts

@@ -0,0 +1,42 @@
+import type { Vec3 } from '../core/vec3.js';
+import type { Box3 } from './box3.js';
+/**
+ * Result of a ray-triangle intersection test
+ * @see createIntersectsTriangleResult
+ * @see intersectsTriangle
+ */
+export type IntersectsTriangleResult = {
+    fraction: number;
+    hit: boolean;
+    frontFacing: boolean;
+};
+/**
+ * Creates a new IntersectsTriangleResult with default values.
+ * @returns A new IntersectsTriangleResult.
+ */
+export declare function createIntersectsTriangleResult(): IntersectsTriangleResult;
+/**
+ * Ray-triangle intersection test.
+ * Based on https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
+ *
+ * @param out output object to store result (hit boolean, fraction, frontFacing)
+ * @param origin ray origin
+ * @param direction ray direction
+ * @param length ray length
+ * @param a first vertex of triangle
+ * @param b second vertex of triangle
+ * @param c third vertex of triangle
+ * @param backfaceCulling if true, backfaces will not be considered hits
+ */
+export declare function intersectsTriangle(out: IntersectsTriangleResult, origin: Vec3, direction: Vec3, length: number, a: Vec3, b: Vec3, c: Vec3, backfaceCulling: boolean): void;
+/**
+ * Test if a ray intersects an axis-aligned bounding box.
+ * Uses slab-based algorithm that handles parallel rays correctly.
+ *
+ * @param origin ray origin
+ * @param direction ray direction
+ * @param length ray length
+ * @param aabb AABB to test against
+ * @returns true if ray intersects the AABB, false otherwise
+ */
+export declare function intersectsBox3(origin: Vec3, direction: Vec3, length: number, aabb: Box3): boolean;

package/dist/src/shapes/segment2.d.ts

@@ -0,0 +1,34 @@
+import type { Vec2 } from '../core/vec2.js';
+/**
+ * Calculates the closest point on a line segment to a given point
+ * @param out Output parameter for the closest point
+ * @param point The point
+ * @param a First endpoint of the segment
+ * @param b Second endpoint of the segment
+ */
+export declare function closestPoint(out: Vec2, point: Vec2, a: Vec2, b: Vec2): Vec2;
+/**
+ * Tests whether the two closed segments a-b and c-d intersect. Collinear
+ * (overlapping) segments are treated as non-intersecting; touching at an
+ * endpoint counts as an intersection.
+ *
+ * @param a first endpoint of the first segment
+ * @param b second endpoint of the first segment
+ * @param c first endpoint of the second segment
+ * @param d second endpoint of the second segment
+ * @returns true if the segments intersect
+ */
+export declare function intersects(a: Vec2, b: Vec2, c: Vec2, d: Vec2): boolean;
+/**
+ * Computes the intersection point of the two closed segments a-b and c-d,
+ * writing it to `out`. Returns `out` when the segments intersect, or `null`
+ * when they do not (including parallel/collinear segments).
+ *
+ * @param out output parameter for the intersection point
+ * @param a first endpoint of the first segment
+ * @param b second endpoint of the first segment
+ * @param c first endpoint of the second segment
+ * @param d second endpoint of the second segment
+ * @returns out if the segments intersect, otherwise null
+ */
+export declare function intersection(out: Vec2, a: Vec2, b: Vec2, c: Vec2, d: Vec2): Vec2 | null;

package/dist/src/shapes/sphere.d.ts

@@ -0,0 +1,19 @@
+import type { Vec3 } from '../core/vec3.js';
+/** A sphere in 3D space */
+export type Sphere = {
+    center: Vec3;
+    radius: number;
+};
+/**
+ * Creates a new sphere with a default center 0,0,0 and radius 1
+ * @returns A new sphere.
+ */
+export declare function create(): Sphere;
+/**
+ * Returns true if a point lies inside (or on the surface of) the sphere.
+ *
+ * @param sphere the sphere
+ * @param point the point to test
+ * @returns true if the point is within the sphere's radius
+ */
+export declare function containsPoint(sphere: Sphere, point: Vec3): boolean;

package/dist/src/shapes/triangle2.d.ts

@@ -0,0 +1,53 @@
+import type { Vec2 } from '../core/vec2.js';
+import type { Box2 } from './box2.js';
+/**
+ * Returns the signed area of the triangle (a, b, c). The result is positive when
+ * the vertices wind counter-clockwise, negative when they wind clockwise, and
+ * zero when the three points are collinear.
+ *
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @returns the signed area.
+ */
+export declare function signedArea(a: Vec2, b: Vec2, c: Vec2): number;
+/**
+ * Returns the (non-negative) area of the triangle (a, b, c).
+ *
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @returns the absolute area.
+ */
+export declare function area(a: Vec2, b: Vec2, c: Vec2): number;
+/**
+ * Computes the centroid of the triangle (a, b, c).
+ *
+ * @param out the output vector to store the result.
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @returns out.
+ */
+export declare function centroid(out: Vec2, a: Vec2, b: Vec2, c: Vec2): Vec2;
+/**
+ * Computes the axis-aligned bounding box of the triangle (a, b, c).
+ *
+ * @param out the output box to store the result.
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @returns out.
+ */
+export declare function bounds(out: Box2, a: Vec2, b: Vec2, c: Vec2): Box2;
+/**
+ * Tests whether a point lies inside the triangle (a, b, c). Works for either
+ * winding order; points on an edge or vertex are considered inside.
+ *
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @param point the point to test.
+ * @returns true if the point is inside (or on the boundary of) the triangle.
+ */
+export declare function containsPoint(a: Vec2, b: Vec2, c: Vec2, point: Vec2): boolean;

package/dist/src/shapes/triangle3.d.ts

@@ -0,0 +1,29 @@
+import type { Vec3 } from '../core/vec3.js';
+import type { Box3 } from './box3.js';
+/**
+ * Computes the axis-aligned bounding box of a triangle defined by three vertices.
+ * @param out the output box to store the result.
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @returns the output box containing the axis-aligned bounding box of the triangle.
+ */
+export declare function bounds(out: Box3, a: Vec3, b: Vec3, c: Vec3): Box3;
+/**
+ * Computes the normal vector of a triangle defined by three vertices.
+ * @param out the output vector to store the result.
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @returns the output vector containing the normal of the triangle.
+ */
+export declare function normal(out: Vec3, a: Vec3, b: Vec3, c: Vec3): Vec3;
+/**
+ * Computes the centroid of a triangle defined by three vertices.
+ * @param out the output vector to store the result.
+ * @param a the first vertex of the triangle.
+ * @param b the second vertex of the triangle.
+ * @param c the third vertex of the triangle.
+ * @returns the output vector containing the centroid of the triangle.
+ */
+export declare function centroid(out: Vec3, a: Vec3, b: Vec3, c: Vec3): Vec3;

package/dist/src/time/easing.d.ts

@@ -0,0 +1,21 @@
+export declare const exp: (t: number) => number;
+export declare const linear: (t: number) => number;
+export declare const sineIn: (x: number) => number;
+export declare const sineOut: (x: number) => number;
+export declare const sineInOut: (x: number) => number;
+export declare const cubicIn: (x: number) => number;
+export declare const cubicOut: (x: number) => number;
+export declare const cubicInOut: (x: number) => number;
+export declare const quintIn: (x: number) => number;
+export declare const quintOut: (x: number) => number;
+export declare const quintInOut: (x: number) => number;
+export declare const circIn: (x: number) => number;
+export declare const circOut: (x: number) => number;
+export declare const circInOut: (x: number) => number;
+export declare const quartIn: (t: number) => number;
+export declare const quartOut: (t: number) => number;
+export declare const quartInOut: (t: number) => number;
+export declare const expoIn: (x: number) => number;
+export declare const expoOut: (x: number) => number;
+export declare const expoInOut: (x: number) => number;
+export declare const rsqw: (t: number, delta?: number, a?: number, f?: number) => number;

package/dist/src/time/index.d.ts

@@ -0,0 +1,6 @@
+export * as easing from './easing.js';
+export * as spring from './spring.js';
+export * as spring2 from './spring2.js';
+export * as spring3 from './spring3.js';
+export * as spring4 from './spring4.js';
+export type { Spring } from './spring-core.js';

package/dist/src/time/spring-core.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Spring state: a `value` and its `velocity`, of matching rank
+ * (`number`, `Vec2`, `Vec3`, or `Vec4`). Allocate once, mutate each frame.
+ */
+export type Spring<T> = {
+    value: T;
+    velocity: T;
+};
+export declare const coef: {
+    pp: number;
+    pv: number;
+    vp: number;
+    vv: number;
+};
+export declare function coefficients(smoothTime: number, dampingRatio: number, delta: number): void;

package/dist/src/time/spring.d.ts

@@ -0,0 +1,36 @@
+import { type Spring } from './spring-core.js';
+/** Creates a scalar spring at `value`, at rest. */
+export declare const create: (value?: number) => Spring<number>;
+/**
+ * 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
+ */
+export declare function update(state: Spring<number>, target: number, smoothTime: number, dampingRatio: number, delta: number): Spring<number>;
+/**
+ * Critically-damped {@link update} (dampingRatio = 1): moves toward `target` as
+ * fast as possible without overshooting.
+ */
+export declare function damp(state: Spring<number>, target: number, smoothTime: number, delta: number): Spring<number>;
+/**
+ * Like {@link damp}, but takes the shortest angular path to `target` (radians),
+ * wrapping across the ±π seam rather than unwinding the long way around.
+ */
+export declare function dampAngle(state: Spring<number>, target: number, smoothTime: number, delta: number): Spring<number>;
+/**
+ * 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
+ * ```
+ */
+export declare const fromResponse: (response: number) => number;

package/dist/src/time/spring2.d.ts

@@ -0,0 +1,11 @@
+import type { Vec2 } from '../core/index.js';
+import { type Spring } from './spring-core.js';
+/** Creates a Vec2 spring at `value` (copied), at rest. */
+export declare const create: (value?: Vec2) => Spring<Vec2>;
+/**
+ * Springs `state.value` toward `target`, mutating `state` in place. Returns it.
+ * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish
+ */
+export declare function update(state: Spring<Vec2>, target: Vec2, smoothTime: number, dampingRatio: number, delta: number): Spring<Vec2>;
+/** Critically-damped Vec2 spring (dampingRatio = 1). See {@link update}. */
+export declare function damp(state: Spring<Vec2>, target: Vec2, smoothTime: number, delta: number): Spring<Vec2>;

package/dist/src/time/spring3.d.ts

@@ -0,0 +1,11 @@
+import type { Vec3 } from '../core/index.js';
+import { type Spring } from './spring-core.js';
+/** Creates a Vec3 spring at `value` (copied), at rest. */
+export declare const create: (value?: Vec3) => Spring<Vec3>;
+/**
+ * Springs `state.value` toward `target`, mutating `state` in place. Returns it.
+ * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish
+ */
+export declare function update(state: Spring<Vec3>, target: Vec3, smoothTime: number, dampingRatio: number, delta: number): Spring<Vec3>;
+/** Critically-damped Vec3 spring (dampingRatio = 1). See {@link update}. */
+export declare function damp(state: Spring<Vec3>, target: Vec3, smoothTime: number, delta: number): Spring<Vec3>;

package/dist/src/time/spring4.d.ts

@@ -0,0 +1,11 @@
+import type { Vec4 } from '../core/index.js';
+import { type Spring } from './spring-core.js';
+/** Creates a Vec4 spring at `value` (copied), at rest. */
+export declare const create: (value?: Vec4) => Spring<Vec4>;
+/**
+ * Springs `state.value` toward `target`, mutating `state` in place. Returns it.
+ * @param dampingRatio 1 = critically damped (no overshoot), <1 bouncy, >1 sluggish
+ */
+export declare function update(state: Spring<Vec4>, target: Vec4, smoothTime: number, dampingRatio: number, delta: number): Spring<Vec4>;
+/** Critically-damped Vec4 spring (dampingRatio = 1). See {@link update}. */
+export declare function damp(state: Spring<Vec4>, target: Vec4, smoothTime: number, delta: number): Spring<Vec4>;

package/dist/time/easing.js

@@ -0,0 +1,24 @@
+const exp = (t) => 1 / (1 + t + 0.48 * t * t + 0.235 * t * t * t);
+const linear = (t) => t;
+const sineIn = (x) => 1 - Math.cos((x * Math.PI) / 2);
+const sineOut = (x) => Math.sin((x * Math.PI) / 2);
+const sineInOut = (x) => -(Math.cos(Math.PI * x) - 1) / 2;
+const cubicIn = (x) => x * x * x;
+const cubicOut = (x) => 1 - (1 - x) ** 3;
+const cubicInOut = (x) => (x < 0.5 ? 4 * x * x * x : 1 - (-2 * x + 2) ** 3 / 2);
+const quintIn = (x) => x ** 5;
+const quintOut = (x) => 1 - (1 - x) ** 5;
+const quintInOut = (x) => (x < 0.5 ? 16 * x ** 5 : 1 - (-2 * x + 2) ** 5 / 2);
+const circIn = (x) => 1 - Math.sqrt(1 - x * x);
+const circOut = (x) => Math.sqrt(1 - (x - 1) * (x - 1));
+const circInOut = (x) => x < 0.5 ? (1 - Math.sqrt(1 - 2 * x * (2 * x))) / 2 : (Math.sqrt(1 - (-2 * x + 2) * (-2 * x + 2)) + 1) / 2;
+const quartIn = (t) => t * t * t * t;
+const quartOut = (t) => 1 - --t * t * t * t;
+const quartInOut = (t) => (t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t);
+const expoIn = (x) => (x === 0 ? 0 : 2 ** (10 * x - 10));
+const expoOut = (x) => (x === 1 ? 1 : 1 - 2 ** (-10 * x));
+const expoInOut = (x) => x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? 2 ** (20 * x - 10) / 2 : (2 - 2 ** (-20 * x + 10)) / 2;
+const rsqw = (t, delta = 0.01, a = 1, f = 1 / (2 * Math.PI)) => (a / Math.atan(1 / delta)) * Math.atan(Math.sin(2 * Math.PI * t * f) / delta);
+
+export { circIn, circInOut, circOut, cubicIn, cubicInOut, cubicOut, exp, expoIn, expoInOut, expoOut, linear, quartIn, quartInOut, quartOut, quintIn, quintInOut, quintOut, rsqw, sineIn, sineInOut, sineOut };
+//# sourceMappingURL=easing.js.map

package/dist/time/easing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"easing.js","sources":["../../src/time/easing.ts"],"sourcesContent":["export const exp = (t: number) => 1 / (1 + t + 0.48 * t * t + 0.235 * t * t * t);\n\nexport const linear = (t: number) => t;\n\nexport const sineIn = (x: number) => 1 - Math.cos((x * Math.PI) / 2);\nexport const sineOut = (x: number) => Math.sin((x * Math.PI) / 2);\nexport const sineInOut = (x: number) => -(Math.cos(Math.PI * x) - 1) / 2;\n\nexport const cubicIn = (x: number) => x * x * x;\nexport const cubicOut = (x: number) => 1 - (1 - x) ** 3;\nexport const cubicInOut = (x: number) => (x < 0.5 ? 4 * x * x * x : 1 - (-2 * x + 2) ** 3 / 2);\n\nexport const quintIn = (x: number) => x ** 5;\nexport const quintOut = (x: number) => 1 - (1 - x) ** 5;\nexport const quintInOut = (x: number) => (x < 0.5 ? 16 * x ** 5 : 1 - (-2 * x + 2) ** 5 / 2);\n\nexport const circIn = (x: number) => 1 - Math.sqrt(1 - x * x);\nexport const circOut = (x: number) => Math.sqrt(1 - (x - 1) * (x - 1));\nexport const circInOut = (x: number) =>\n    x < 0.5 ? (1 - Math.sqrt(1 - 2 * x * (2 * x))) / 2 : (Math.sqrt(1 - (-2 * x + 2) * (-2 * x + 2)) + 1) / 2;\n\nexport const quartIn = (t: number) => t * t * t * t;\nexport const quartOut = (t: number) => 1 - --t * t * t * t;\nexport const quartInOut = (t: number) => (t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t);\n\nexport const expoIn = (x: number) => (x === 0 ? 0 : 2 ** (10 * x - 10));\nexport const expoOut = (x: number) => (x === 1 ? 1 : 1 - 2 ** (-10 * x));\nexport const expoInOut = (x: number) =>\n    x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? 2 ** (20 * x - 10) / 2 : (2 - 2 ** (-20 * x + 10)) / 2;\n\nexport const rsqw = (t: number, delta = 0.01, a = 1, f = 1 / (2 * Math.PI)) =>\n    (a / Math.atan(1 / delta)) * Math.atan(Math.sin(2 * Math.PI * t * f) / delta);\n"],"names":[],"mappings":"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"}

package/dist/time/index.js

@@ -0,0 +1,11 @@
+import * as easing from './easing.js';
+export { easing };
+import * as spring from './spring.js';
+export { spring };
+import * as spring2 from './spring2.js';
+export { spring2 };
+import * as spring3 from './spring3.js';
+export { spring3 };
+import * as spring4 from './spring4.js';
+export { spring4 };
+//# sourceMappingURL=index.js.map

package/dist/time/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}