coily 0.14.0 → 0.15.0

package/dist/css.js

@@ -0,0 +1,294 @@
+import { i as State, n as OverdampedSolver, o as invariant, r as UnderdampedSolver, t as CriticallyDampedSolver } from "./solver-CVXOTDkZ.js";
+//#region src/css.ts
+function pickSolver(config, state) {
+	const solver = config.dampingRatio < 1 ? new UnderdampedSolver(state) : config.dampingRatio === 1 ? new CriticallyDampedSolver(state) : new OverdampedSolver(state);
+	solver.configure(config);
+	return solver;
+}
+function walk(config, displacement, spanSec, scale, stopAtRest, velocity = 0) {
+	const state = new State(config, displacement, velocity);
+	const solver = pickSolver(config, state);
+	const period = 2 * Math.PI / config.naturalFrequency;
+	const dt = Math.max(1e-4, Math.min(period / 48, spanSec / 160));
+	const points = [{
+		x: 0,
+		y: 0
+	}];
+	let t = 0;
+	while (spanSec - t > 1e-9) {
+		const step = Math.min(dt, spanSec - t);
+		solver.tick(step);
+		t += step;
+		points.push({
+			x: t / spanSec,
+			y: (1 - state.position / displacement) * scale
+		});
+		if (stopAtRest && state.isResting) break;
+	}
+	return points;
+}
+function buildEasing(points, maxError) {
+	const simplified = simplify(points, maxError);
+	return {
+		easing: format(simplified),
+		stops: simplified.length,
+		maxError: reconstructionError(points, simplified)
+	};
+}
+function buildSettle(config, displacement, durationMs, maxError, velocity = 0) {
+	const points = walk(config, displacement, durationMs / 1e3, 1, true, velocity);
+	const last = points[points.length - 1];
+	if (1 - last.x > 1e-6) points.push({
+		x: 1,
+		y: 1
+	});
+	else {
+		last.x = 1;
+		last.y = 1;
+	}
+	return {
+		mode: "settle",
+		duration: durationMs,
+		...buildEasing(points, maxError)
+	};
+}
+function buildLoop(config, displacement, maxError) {
+	const halfSec = Math.PI / config.naturalFrequency;
+	const points = walk(config, displacement, halfSec, .5, false);
+	const last = points[points.length - 1];
+	last.x = 1;
+	last.y = 1;
+	return {
+		mode: "loop",
+		duration: halfSec * 1e3,
+		direction: "alternate",
+		iterations: "infinite",
+		...buildEasing(points, maxError)
+	};
+}
+function simplify(points, epsilon) {
+	const keep = Array.from({ length: points.length }, () => false);
+	keep[0] = true;
+	keep[points.length - 1] = true;
+	const stack = [[0, points.length - 1]];
+	while (stack.length > 0) {
+		const [lo, hi] = stack.pop();
+		const a = points[lo];
+		const b = points[hi];
+		const dx = b.x - a.x;
+		let worst = -1;
+		let worstIndex = -1;
+		for (let i = lo + 1; i < hi; i += 1) {
+			const p = points[i];
+			const f = dx === 0 ? 0 : (p.x - a.x) / dx;
+			const interpolated = a.y + f * (b.y - a.y);
+			const distance = Math.abs(p.y - interpolated);
+			if (distance > worst) {
+				worst = distance;
+				worstIndex = i;
+			}
+		}
+		if (worst > epsilon && worstIndex !== -1) {
+			keep[worstIndex] = true;
+			stack.push([lo, worstIndex], [worstIndex, hi]);
+		}
+	}
+	return points.filter((_, i) => keep[i]);
+}
+function trim(value, places) {
+	return Number(value.toFixed(places)).toString();
+}
+function format(points) {
+	return `linear(${points.map((point, i) => {
+		const output = trim(point.y, 5);
+		if (i === 0 || i === points.length - 1) return output;
+		return `${output} ${trim(point.x * 100, 2)}%`;
+	}).join(", ")})`;
+}
+function reconstructionError(dense, simplified) {
+	let worst = 0;
+	let j = 0;
+	for (const point of dense) {
+		while (j < simplified.length - 2 && simplified[j + 1].x < point.x) j += 1;
+		const a = simplified[j];
+		const b = simplified[j + 1];
+		const dx = b.x - a.x;
+		const f = dx === 0 ? 0 : (point.x - a.x) / dx;
+		worst = Math.max(worst, Math.abs(point.y - (a.y + f * (b.y - a.y))));
+	}
+	return worst;
+}
+/**
+* Turns a resolved spring config into a CSS `linear()` easing and the
+* duration in ms to pair it with. A spring that settles returns a
+* `'settle'` easing. A pure undamped config (`dampingRatio: 0` with
+* passthrough `arrival`) has no friction and never settles, so it
+* returns a `'loop'` easing for an infinite alternating animation.
+*/
+function springToLinear(config, options = {}) {
+	const displacement = options.displacement ?? 1;
+	const maxError = options.maxError ?? .0025;
+	const maxDuration = options.maxDuration ?? 1e4;
+	if (config.dampingRatio === 0 && config.arrival === 1) return buildLoop(config, displacement, maxError);
+	const settleTime = config.computeTimeRemaining({
+		position: displacement,
+		velocity: 0
+	});
+	return buildSettle(config, displacement, Math.min(settleTime, maxDuration), maxError);
+}
+/**
+* Like `springToLinear`, but from a spring caught mid-flight rather than at
+* rest: `state` carries both the displacement from the target (`position`)
+* and the current `velocity`, so the easing continues the motion smoothly
+* instead of restarting. Use it to regenerate an animation when its target
+* changes — the interruption carries momentum instead of stalling. The
+* from-rest shape trick doesn't apply here (the curve now depends on the
+* velocity), so this is computed per interruption, not cached per config.
+*
+* Always a settling easing; `position` must be nonzero.
+*/
+function springFromState(config, state, options = {}) {
+	const maxError = options.maxError ?? .0025;
+	const maxDuration = options.maxDuration ?? 1e4;
+	invariant(Math.abs(state.position) > 1e-9, "springFromState needs a nonzero position (the value and target must differ)");
+	const settleTime = config.computeTimeRemaining(state);
+	return buildSettle(config, state.position, Math.min(settleTime, maxDuration), maxError, state.velocity);
+}
+/**
+* Evolves a spring `state` forward by `elapsedMs`, returning the new
+* displacement and velocity. Pair it with a running `element.animate` — read
+* the animation's `currentTime`, evolve the state it started from, and you
+* have the exact live velocity the Web Animations API never exposes, ready
+* to hand to `springFromState` on interruption.
+*/
+function springStateAt(config, state, elapsedMs) {
+	if (elapsedMs <= 0) return {
+		position: state.position,
+		velocity: state.velocity
+	};
+	const live = new State(config, state.position, state.velocity);
+	pickSolver(config, live).tick(elapsedMs / 1e3);
+	return {
+		position: live.position,
+		velocity: live.velocity
+	};
+}
+function resolveSpecs(config, specs, options) {
+	const withVelocity = specs.some((spec) => (spec.velocity ?? 0) !== 0);
+	invariant(!withVelocity || specs.length === 1, "velocity handoff is single-property: a from-state easing depends on that property, so run one animation per property");
+	const first = specs[0];
+	const easing = withVelocity ? springFromState(config, {
+		position: first.from - first.to,
+		velocity: first.velocity
+	}, options) : springToLinear(config, {
+		...options,
+		displacement: options.displacement ?? (Math.max(...specs.map((s) => Math.abs(s.to - s.from))) || 1)
+	});
+	const from = {};
+	const to = {};
+	for (const spec of specs) {
+		const format = spec.format ?? ((value) => `${Number(value.toFixed(3))}${spec.unit ?? ""}`);
+		const far = easing.mode === "loop" ? 2 * spec.to - spec.from : spec.to;
+		const start = format(spec.from);
+		const end = format(far);
+		from[spec.property] = from[spec.property] ? `${from[spec.property]} ${start}` : start;
+		to[spec.property] = to[spec.property] ? `${to[spec.property]} ${end}` : end;
+	}
+	return {
+		easing,
+		from,
+		to
+	};
+}
+function asArray(spec) {
+	return Array.isArray(spec) ? spec : [spec];
+}
+/**
+* Builds arguments for `element.animate(keyframes, options)`: two keyframes
+* carrying the endpoint values, and options carrying the spring's `linear()`
+* easing and duration. Pass an array of specs to drive several properties
+* from one spring. A settling spring fills forwards; an undamped one repeats
+* infinitely in alternating directions.
+*
+* @example
+* ```ts
+* const { keyframes, options } = springToWaapi(config, {
+*   property: 'translate',
+*   from: 0,
+*   to: 300,
+*   unit: 'px',
+* })
+* element.animate(keyframes, options)
+* ```
+*/
+function springToWaapi(config, spec, options = {}) {
+	const { easing, from, to } = resolveSpecs(config, asArray(spec), options);
+	const keyframes = [from, to];
+	const shared = {
+		duration: easing.duration,
+		easing: easing.easing
+	};
+	return {
+		keyframes,
+		options: easing.mode === "loop" ? {
+			...shared,
+			iterations: Number.POSITIVE_INFINITY,
+			direction: "alternate"
+		} : {
+			...shared,
+			fill: "forwards"
+		}
+	};
+}
+/**
+* Builds CSS text for the animation: a `@keyframes` rule and an `animation`
+* shorthand value, driving one property or several from one spring. The
+* `name` option (default `'coily'`) names the `@keyframes` rule and is
+* referenced by the `animation` value.
+*
+* @example
+* ```ts
+* const { keyframes, animation } = springToCss(config, {
+*   property: 'translate',
+*   from: 0,
+*   to: 300,
+*   unit: 'px',
+* })
+* const style = document.createElement('style')
+* style.textContent = keyframes
+* document.head.append(style)
+* element.style.animation = animation
+* ```
+*/
+function springToCss(config, spec, options = {}) {
+	const { easing, from, to } = resolveSpecs(config, asArray(spec), options);
+	const name = options.name ?? "coily";
+	const ms = `${Number(easing.duration.toFixed(1))}ms`;
+	const declare = (values) => Object.entries(values).map(([property, value]) => `${property}: ${value};`).join(" ");
+	return {
+		keyframes: `@keyframes ${name} {\n  from { ${declare(from)} }\n  to { ${declare(to)} }\n}`,
+		animation: easing.mode === "loop" ? `${ms} ${easing.easing} infinite alternate ${name}` : `${ms} ${easing.easing} forwards ${name}`
+	};
+}
+/**
+* Builds a CSS `transition` value that springs a property change: set it on
+* the element, then change the property (on `:hover`, a toggled class, a
+* state attribute) to animate. Pass several specs for one `transition`
+* across properties.
+*
+* Only settling springs — a transition can't loop. It also can't carry
+* momentum: a change interrupted mid-flight restarts the spring from rest
+* instead of reversing through its current velocity, so it stalls at the
+* turn. For motion that's reversed often, drive a live `Spring` instead. The
+* specs' `from`/`to` only tune the duration; the actual values live in your
+* CSS rules.
+*/
+function springToTransition(config, spec, options = {}) {
+	const specs = asArray(spec);
+	const { easing } = resolveSpecs(config, specs, options);
+	invariant(easing.mode === "settle", "springToTransition requires a settling spring; an undamped (looping) config has no single end state to transition to");
+	const ms = `${Number(easing.duration.toFixed(1))}ms`;
+	return specs.map((s) => `${s.property} ${ms} ${easing.easing}`).join(", ");
+}
+//#endregion
+export { springFromState, springStateAt, springToCss, springToLinear, springToTransition, springToWaapi };

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-import { C as SpringDefinitionOptions, S as SpringDefinition, T as defineSpring, _ as accelerationOf, a as createSpringSystem, b as SpringSourceSymbol, c as ConfigShape, g as KinematicSource, h as SpringTarget, i as SpringSystemOptions, m as Spring, n as SpringOptions, o as CompositeSpring, p as Purpose, r as SpringSystem, s as CompositeSpringTarget, t as CompositeSpringOptions, u as PurposeShape, v as velocityOf, w as SpringState, x as mapSpring, y as SpringSource } from "./system-Ci-R4RaI.js";
+import { i as defineSpring, n as SpringDefinitionOptions, r as SpringState, t as SpringDefinition } from "./config-OOMMRdK8.js";
+import { _ as accelerationOf, a as createSpringSystem, b as SpringSourceSymbol, c as ConfigShape, g as KinematicSource, h as SpringTarget, i as SpringSystemOptions, m as Spring, n as SpringOptions, o as CompositeSpring, p as Purpose, r as SpringSystem, s as CompositeSpringTarget, t as CompositeSpringOptions, u as PurposeShape, v as velocityOf, x as mapSpring, y as SpringSource } from "./system-Du_fXXmO.js";
 export { type CompositeSpring, type CompositeSpringOptions, type CompositeSpringTarget, type ConfigShape, type KinematicSource, type Purpose, type PurposeShape, type Spring, type SpringDefinition, type SpringDefinitionOptions, type SpringOptions, type SpringSource, SpringSourceSymbol, type SpringState, type SpringSystem, type SpringSystemOptions, type SpringTarget, accelerationOf, createSpringSystem, defineSpring, mapSpring, velocityOf };

package/dist/index.js

@@ -1,4 +1,5 @@
-import { i as mapSpring, n as SpringSourceSymbol, o as defineSpring, r as isSpringSource, s as invariant, t as createSpringSystem } from "./system-BXxAHM2a.js";
+import { a as registerRecipe, i as mapSpring, n as SpringSourceSymbol, r as isSpringSource, s as defineSpring, t as createSpringSystem } from "./system-Br_cPnaN.js";
+import { o as invariant } from "./solver-CVXOTDkZ.js";
 //#region src/kinematic-source.ts
 function isKinematicSource(value) {
 	if (!isSpringSource(value)) return false;
@@ -32,13 +33,19 @@ const NOT_KINEMATIC = "expected a source in motion (a Spring or CompositeSpring)
 function velocityOf(source) {
 	invariant(isKinematicSource(source), NOT_KINEMATIC);
 	const api = source[SpringSourceSymbol];
-	return Object.freeze({ [SpringSourceSymbol]: Object.freeze({
+	const velocity = Object.freeze({ [SpringSourceSymbol]: Object.freeze({
 		get value() {
 			return api.velocity;
 		},
 		onUpdate: (callback) => api.onUpdate(callback),
 		onDispose: (callback) => api.onDispose(callback)
 	}) });
+	registerRecipe(velocity, {
+		sources: [source],
+		read: () => api.velocity,
+		fns: []
+	});
+	return velocity;
 }
 /**
 * Derives a source from another's acceleration — the rate its velocity
@@ -66,13 +73,19 @@ function velocityOf(source) {
 function accelerationOf(source) {
 	invariant(isKinematicSource(source), NOT_KINEMATIC);
 	const api = source[SpringSourceSymbol];
-	return Object.freeze({ [SpringSourceSymbol]: Object.freeze({
+	const acceleration = Object.freeze({ [SpringSourceSymbol]: Object.freeze({
 		get value() {
 			return api.acceleration;
 		},
 		onUpdate: (callback) => api.onUpdate(callback),
 		onDispose: (callback) => api.onDispose(callback)
 	}) });
+	registerRecipe(acceleration, {
+		sources: [source],
+		read: () => api.acceleration,
+		fns: []
+	});
+	return acceleration;
 }
 //#endregion
 export { SpringSourceSymbol, accelerationOf, createSpringSystem, defineSpring, mapSpring, velocityOf };

package/dist/nuxt.d.ts

@@ -30,6 +30,14 @@ interface CoilyModuleOptions {
    * @default 33
    */
   adjustedLag?: number;
+  /**
+   * How far a spring may trail a source it follows within one frame, in
+   * the value's own units. Frames whose motion would exceed it split
+   * into internal sub-steps; smaller is tighter and costs more solver
+   * work.
+   * @default 0.1
+   */
+  couplingTolerance?: number;
   /**
    * When springs snap to their targets instead of animating: `'user'`
    * follows the OS prefers-reduced-motion setting, including live

package/dist/nuxt.js

@@ -6,6 +6,7 @@ function getPluginTemplate(options) {
 	if (options.fps !== void 0) systemOptions.fps = options.fps;
 	if (options.lagThreshold !== void 0) systemOptions.lagThreshold = options.lagThreshold;
 	if (options.adjustedLag !== void 0) systemOptions.adjustedLag = options.adjustedLag;
+	if (options.couplingTolerance !== void 0) systemOptions.couplingTolerance = options.couplingTolerance;
 	if (options.reducedMotion) systemOptions.reducedMotion = options.reducedMotion;
 	return `import { createSpringSystem } from 'coily'
 import { provideSpringSystem } from 'coily/vue'

package/dist/solver-CVXOTDkZ.js

@@ -0,0 +1,235 @@
+//#region src/util.ts
+function invariant(condition, message) {
+	if (condition) return;
+	const resolved = typeof message === "function" ? message() : message;
+	throw new Error(resolved ?? "Invariant Failed");
+}
+/**
+* True for plain objects only. Class instances are excluded so shape
+* walks reject values like a `Spring` instead of descending into their
+* fields as if they were nested shapes.
+*/
+function isRecord(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function isRecordOrArray(value) {
+	return isRecord(value) || Array.isArray(value);
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+const RESOLVED = Promise.resolve();
+//#endregion
+//#region src/state.ts
+/**
+* The mutable position/velocity pair a motion and its solvers share, in
+* displacement space: position 0 means at the target.
+*/
+var State = class {
+	#config;
+	#position;
+	#velocity;
+	constructor(config, position, velocity) {
+		this.#config = config;
+		this.#position = position;
+		this.#velocity = velocity;
+	}
+	configure(config) {
+		this.#config = config;
+	}
+	get position() {
+		return this.#position;
+	}
+	set position(value) {
+		this.#position = value;
+	}
+	get velocity() {
+		return this.#velocity;
+	}
+	set velocity(value) {
+		this.#velocity = value;
+	}
+	/**
+	* The rest test: displacement, plus the displacement the current
+	* velocity could still convert into (|x| + |v| / wn), is inside the
+	* config's resting threshold.
+	*/
+	get isResting() {
+		return Math.abs(this.#position) + Math.abs(this.#velocity) / this.#config.naturalFrequency <= this.#config.restingMagnitude;
+	}
+};
+//#endregion
+//#region src/solver.ts
+/** dampingRatio < 1: decaying oscillation, x(t) = exp(-sigma*t) * (c1*cos(wd*t) + c2*sin(wd*t)). */
+var UnderdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#arrival = 1;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	#crossing = Infinity;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#decayRate = config.dampingRatio * config.naturalFrequency;
+			this.#dampedFrequency = config.naturalFrequency * Math.sqrt(1 - config.dampingRatio ** 2);
+			this.#arrival = config.arrival;
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = (this.#state.velocity + this.#decayRate * this.#state.position) / this.#dampedFrequency;
+		if (this.#arrival === 1) this.#crossing = Infinity;
+		else {
+			let theta = Math.atan2(-this.#c1, this.#c2) % Math.PI;
+			if (theta <= 0) theta += Math.PI;
+			this.#crossing = theta / this.#dampedFrequency;
+		}
+	}
+	tick(dt) {
+		let t = this.#t + dt;
+		while (t >= this.#crossing) {
+			t -= this.#crossing;
+			this.#arrive();
+			if (this.#state.isResting) return;
+		}
+		this.#t = t;
+		this.#evaluate();
+	}
+	#arrive() {
+		this.#t = this.#crossing;
+		this.#evaluate();
+		this.#state.position = 0;
+		this.#state.velocity *= this.#arrival;
+		this.configure();
+	}
+	#evaluate() {
+		const sin = Math.sin(this.#dampedFrequency * this.#t);
+		const cos = Math.cos(this.#dampedFrequency * this.#t);
+		const decay = Math.exp(-this.#decayRate * this.#t);
+		const decayVelocity = -this.#decayRate * decay;
+		const oscillation = this.#c1 * cos + this.#c2 * sin;
+		const oscillationVelocity = -this.#c1 * this.#dampedFrequency * sin + this.#c2 * this.#dampedFrequency * cos;
+		this.#state.position = decay * oscillation;
+		this.#state.velocity = decay * oscillationVelocity + decayVelocity * oscillation;
+	}
+};
+/** dampingRatio = 1: fastest non-oscillating decay, x(t) = (c1 + c2*t) * exp(-wn*t). */
+var CriticallyDampedSolver = class {
+	#state;
+	#naturalFrequency = 0;
+	#arrival = 1;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	#crossing = Infinity;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#naturalFrequency = config.naturalFrequency;
+			this.#arrival = config.arrival;
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = this.#state.velocity + this.#naturalFrequency * this.#state.position;
+		if (this.#arrival === 1) this.#crossing = Infinity;
+		else {
+			const t = -this.#c1 / this.#c2;
+			this.#crossing = t > 0 ? t : Infinity;
+		}
+	}
+	tick(dt) {
+		let t = this.#t + dt;
+		while (t >= this.#crossing) {
+			t -= this.#crossing;
+			this.#arrive();
+			if (this.#state.isResting) return;
+		}
+		this.#t = t;
+		this.#evaluate();
+	}
+	#arrive() {
+		this.#t = this.#crossing;
+		this.#evaluate();
+		this.#state.position = 0;
+		this.#state.velocity *= this.#arrival;
+		this.configure();
+	}
+	#evaluate() {
+		const decay = Math.exp(-this.#naturalFrequency * this.#t);
+		const decayVelocity = -this.#naturalFrequency * decay;
+		const scale = this.#c1 + this.#c2 * this.#t;
+		const scaleVelocity = this.#c2;
+		this.#state.position = scale * decay;
+		this.#state.velocity = scaleVelocity * decay + decayVelocity * scale;
+	}
+};
+/** dampingRatio > 1: slow non-oscillating decay, x(t) = exp(-sigma*t) * (c1*sinh(wd*t) + c2*cosh(wd*t)) / wd. */
+var OverdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#arrival = 1;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	#crossing = Infinity;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#decayRate = config.dampingRatio * config.naturalFrequency;
+			this.#dampedFrequency = config.naturalFrequency * Math.sqrt(config.dampingRatio ** 2 - 1);
+			this.#arrival = config.arrival;
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.velocity + this.#decayRate * this.#state.position;
+		this.#c2 = this.#state.position * this.#dampedFrequency;
+		if (this.#arrival === 1) this.#crossing = Infinity;
+		else {
+			const theta = Math.atanh(-this.#c2 / this.#c1);
+			this.#crossing = theta > 0 ? theta / this.#dampedFrequency : Infinity;
+		}
+	}
+	tick(dt) {
+		let t = this.#t + dt;
+		while (t >= this.#crossing) {
+			t -= this.#crossing;
+			this.#arrive();
+			if (this.#state.isResting) return;
+		}
+		this.#t = t;
+		this.#evaluate();
+	}
+	#arrive() {
+		this.#t = this.#crossing;
+		this.#evaluate();
+		this.#state.position = 0;
+		this.#state.velocity *= this.#arrival;
+		this.configure();
+	}
+	#evaluate() {
+		const decay = Math.exp(-this.#decayRate * this.#t);
+		const decayVelocity = -this.#decayRate * decay;
+		const clamped = Math.min(this.#dampedFrequency * this.#t, 300);
+		const sinh = Math.sinh(clamped);
+		const cosh = Math.cosh(clamped);
+		const scale = this.#c1 * sinh + this.#c2 * cosh;
+		const scaleVelocity = this.#c1 * this.#dampedFrequency * cosh + this.#c2 * this.#dampedFrequency * sinh;
+		this.#state.position = scale * decay / this.#dampedFrequency;
+		this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / this.#dampedFrequency;
+	}
+};
+//#endregion
+export { RESOLVED as a, isNumber as c, State as i, isRecord as l, OverdampedSolver as n, invariant as o, UnderdampedSolver as r, isArray as s, CriticallyDampedSolver as t, isRecordOrArray as u };