coily 0.12.2 → 0.14.0

package/dist/system-Bzrx4uso.js

@@ -1,976 +0,0 @@
-//#region src/motion-set.ts
-var MotionSet = class {
-	#motions = /* @__PURE__ */ new Set();
-	#debug;
-	#lastSize = 0;
-	constructor(debug = false) {
-		this.#debug = debug;
-	}
-	add(motion) {
-		this.#motions.add(motion);
-	}
-	remove(motion) {
-		this.#motions.delete(motion);
-	}
-	tick(dt) {
-		for (const motion of this.#motions) {
-			motion.tick(dt);
-			if (motion.isResting) this.#motions.delete(motion);
-		}
-		if (this.#debug && this.#motions.size !== this.#lastSize) {
-			this.#lastSize = this.#motions.size;
-			console.log(`coily: ${this.#lastSize} active motions`);
-		}
-	}
-};
-//#endregion
-//#region src/util.ts
-function invariant(condition, message) {
-	if (condition) return;
-	throw new Error(message ?? "Invariant Failed");
-}
-//#endregion
-//#region src/config.ts
-/**
-* Immutable spring configuration.
-*/
-var SpringConfig = class SpringConfig {
-	static default = new SpringConfig({
-		dampingRatio: 1,
-		duration: 500
-	});
-	/** @internal Incremented by `assign` to signal mutations. Do not read or write directly. */
-	_version = 0;
-	mass;
-	tension;
-	damping;
-	precision;
-	naturalFrequency;
-	criticalDamping;
-	dampingRatio;
-	precisionMultiplier;
-	restingMagnitude;
-	constructor(input) {
-		const raw = input;
-		const mass = raw.mass;
-		const tension = raw.tension;
-		const damping = raw.damping;
-		const bounce = raw.bounce;
-		const duration = raw.duration !== void 0 ? raw.duration / 1e3 : void 0;
-		const displacement = raw.displacement ?? 1;
-		const precision = raw.precision ?? 2;
-		if (mass !== void 0) invariant(mass > 0, "Mass must be greater than 0");
-		if (tension !== void 0) invariant(tension > 0, "Tension must be greater than 0");
-		if (damping !== void 0) invariant(damping >= 0, "Damping must be greater than or equal to 0");
-		if (bounce !== void 0) invariant(bounce >= -1 && bounce <= 1, "Bounce must be between -1 and 1");
-		const dampingRatio = raw.dampingRatio ?? (bounce !== void 0 ? Math.max(1e-4, 1 - bounce) : void 0);
-		if (dampingRatio !== void 0) invariant(dampingRatio >= 0, "Damping ratio must be greater than or equal to 0");
-		if (duration !== void 0) invariant(duration > 0, "Duration must be greater than 0");
-		invariant(displacement !== 0, "Displacement must not be 0");
-		invariant(precision >= 0, "Precision must be greater than or equal to 0");
-		this.precision = precision;
-		this.precisionMultiplier = 10 ** precision;
-		this.restingMagnitude = .5 / this.precisionMultiplier;
-		const hasM = mass !== void 0;
-		const hasK = tension !== void 0;
-		const hasC = damping !== void 0;
-		const hasZ = dampingRatio !== void 0;
-		const hasT = duration !== void 0;
-		if (hasK && hasC && !hasZ && !hasT) {
-			this.mass = mass ?? 1;
-			this.tension = tension;
-			this.damping = damping;
-		} else if (hasK && hasZ && !hasC && !hasT) {
-			this.mass = mass ?? 1;
-			this.tension = tension;
-			this.damping = 2 * dampingRatio * Math.sqrt(this.mass * tension);
-		} else if (hasC && hasZ && !hasK && !hasT) {
-			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive tension");
-			this.mass = mass ?? 1;
-			this.tension = damping ** 2 / (4 * dampingRatio ** 2 * this.mass);
-			this.damping = damping;
-		} else if (hasK && hasC && hasZ && !hasT) {
-			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive mass");
-			this.mass = damping ** 2 / (4 * dampingRatio ** 2 * tension);
-			this.tension = tension;
-			this.damping = damping;
-		} else if (hasZ && hasT) {
-			const threshold = .005;
-			const x0 = Math.abs(displacement);
-			invariant(x0 > threshold, "displacement must be greater than the precision threshold");
-			let sigmaCoeff;
-			if (dampingRatio < 1) sigmaCoeff = dampingRatio;
-			else if (dampingRatio === 1) sigmaCoeff = 1;
-			else sigmaCoeff = dampingRatio - Math.sqrt(dampingRatio ** 2 - 1);
-			invariant(sigmaCoeff > 0, "dampingRatio must be > 0 for duration-based config");
-			const wn = 2 * Math.log(x0 / threshold) / (sigmaCoeff * duration);
-			if (!hasK && !hasC) {
-				this.mass = mass ?? 1;
-				this.tension = wn ** 2 * this.mass;
-				this.damping = 2 * dampingRatio * this.mass * wn;
-			} else if (hasK && !hasM && !hasC) {
-				this.mass = tension / wn ** 2;
-				this.tension = tension;
-				this.damping = 2 * dampingRatio * this.mass * wn;
-			} else if (hasC && !hasM && !hasK) {
-				this.mass = damping / (2 * dampingRatio * wn);
-				this.tension = wn ** 2 * this.mass;
-				this.damping = damping;
-			} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
-		} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
-		this.naturalFrequency = Math.sqrt(this.tension / this.mass);
-		this.criticalDamping = 2 * this.mass * this.naturalFrequency;
-		this.dampingRatio = this.damping / this.criticalDamping;
-	}
-	/** @internal Copies physical parameters from `source` onto this config and bumps `_version`. */
-	assign(source) {
-		this._version++;
-		const t = this;
-		t.mass = source.mass;
-		t.tension = source.tension;
-		t.damping = source.damping;
-		t.precision = source.precision;
-		t.naturalFrequency = source.naturalFrequency;
-		t.criticalDamping = source.criticalDamping;
-		t.dampingRatio = source.dampingRatio;
-		t.precisionMultiplier = source.precisionMultiplier;
-		t.restingMagnitude = source.restingMagnitude;
-	}
-	/**
-	* Analytically estimates the time remaining for a spring to come to rest,
-	* given the current displacement and velocity.
-	*
-	* Uses the exponential decay envelope common to all three damping regimes.
-	* The decay rate depends on the regime:
-	* - Underdamped (ζ < 1): σ = ζωₙ
-	* - Critically damped (ζ = 1): σ = ωₙ
-	* - Overdamped (ζ > 1): σ = (ζ - √(ζ²-1))ωₙ  (the slower eigenvalue)
-	*
-	* The effective initial amplitude accounts for both displacement and velocity,
-	* since kinetic energy can convert to additional displacement:
-	*   A₀ = |x₀| + |v₀| / ωₙ
-	*
-	* Settling time: t = ln(A₀ / threshold) / σ, with a 2× safety factor
-	* to account for polynomial terms in the critically damped solution.
-	*
-	* Returns the estimated time in milliseconds.
-	*/
-	computeTimeRemaining(state) {
-		const { position, velocity } = state;
-		const a0 = Math.abs(position) + Math.abs(velocity) / this.naturalFrequency;
-		if (a0 <= this.restingMagnitude) return 0;
-		let sigma;
-		if (this.dampingRatio < 1) sigma = this.dampingRatio * this.naturalFrequency;
-		else if (this.dampingRatio === 1) sigma = this.naturalFrequency;
-		else sigma = (this.dampingRatio - Math.sqrt(this.dampingRatio * this.dampingRatio - 1)) * this.naturalFrequency;
-		if (sigma <= 0) return Infinity;
-		return 2 * Math.log(a0 / this.restingMagnitude) / sigma * 1e3;
-	}
-};
-function defineSpring(input) {
-	return new SpringConfig(input);
-}
-//#endregion
-//#region src/emitter.ts
-var Emitter = class {
-	#update = [];
-	#start = [];
-	#stop = [];
-	on(type, handler) {
-		this.#list(type).push(handler);
-		return () => {
-			this.off(type, handler);
-		};
-	}
-	off(type, handler) {
-		const list = this.#list(type);
-		if (handler) list.splice(list.indexOf(handler) >>> 0, 1);
-		else list.length = 0;
-	}
-	clear() {
-		this.#update.length = 0;
-		this.#start.length = 0;
-		this.#stop.length = 0;
-	}
-	emit(type) {
-		const list = this.#list(type);
-		if (list.length === 1) list[0]();
-		else if (list.length > 1) for (const handler of list.slice()) handler();
-	}
-	#list(type) {
-		switch (type) {
-			case "update": return this.#update;
-			case "start": return this.#start;
-			case "stop": return this.#stop;
-		}
-	}
-};
-//#endregion
-//#region src/state.ts
-var State = class {
-	#config;
-	#position;
-	#velocity;
-	constructor(config, position, velocity) {
-		this.#config = config;
-		this.#position = position;
-		this.#velocity = velocity;
-	}
-	configure(config) {
-		this.#config = config;
-	}
-	/** Returns the position rounded to the configured precision. */
-	get position() {
-		return Math.round(this.#position * this.#config.precisionMultiplier) / this.#config.precisionMultiplier;
-	}
-	set position(value) {
-		this.#position = value;
-	}
-	/** Returns the velocity rounded to the configured precision. */
-	get velocity() {
-		return Math.round(this.#velocity * this.#config.precisionMultiplier) / this.#config.precisionMultiplier;
-	}
-	set velocity(value) {
-		this.#velocity = value;
-	}
-	/** A spring is resting when its rounded position and velocity are both zero. */
-	get isResting() {
-		return this.position === 0 && this.velocity === 0;
-	}
-};
-//#endregion
-//#region src/solver.ts
-var UnderdampedSolver = class {
-	#state;
-	#dampedFrequency = 0;
-	#decayRate = 0;
-	#t = 0;
-	#c1 = 0;
-	#c2 = 0;
-	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.#t = 0;
-		this.#c1 = this.#state.position;
-		this.#c2 = (this.#state.velocity + this.#decayRate * this.#state.position) / this.#dampedFrequency;
-	}
-	tick(dt) {
-		this.#t += dt;
-		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;
-	}
-};
-var CriticallyDampedSolver = class {
-	#state;
-	#naturalFrequency = 0;
-	#t = 0;
-	#c1 = 0;
-	#c2 = 0;
-	constructor(state) {
-		this.#state = state;
-	}
-	configure(config) {
-		if (config) this.#naturalFrequency = config.naturalFrequency;
-		this.#t = 0;
-		this.#c1 = this.#state.position;
-		this.#c2 = this.#state.velocity + this.#naturalFrequency * this.#state.position;
-	}
-	tick(dt) {
-		this.#t += dt;
-		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;
-	}
-};
-var OverdampedSolver = class {
-	#state;
-	#dampedFrequency = 0;
-	#decayRate = 0;
-	#t = 0;
-	#c1 = 0;
-	#c2 = 0;
-	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.#t = 0;
-		this.#c1 = this.#state.velocity + this.#decayRate * this.#state.position;
-		this.#c2 = this.#state.position * this.#dampedFrequency;
-	}
-	tick(dt) {
-		this.#t += dt;
-		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
-//#region src/motion.ts
-var Motion = class {
-	#config;
-	#state;
-	#underdampedSolver = null;
-	#criticallyDampedSolver = null;
-	#overdampedSolver = null;
-	#currentSolver = null;
-	#needsUpdate = false;
-	#needsReset = false;
-	#configVersion = 0;
-	#timeRemaining = 0;
-	#emitter;
-	constructor(config, position, velocity) {
-		this.#config = config;
-		this.#state = new State(config, position, velocity);
-		this.#emitter = new Emitter();
-		this.#updateSolver();
-		this.#timeRemaining = this.#config.computeTimeRemaining(this.#state);
-	}
-	get position() {
-		return this.#state.position;
-	}
-	set position(value) {
-		this.#state.position = value;
-		this.#needsReset = true;
-		if (!this.#state.isResting) this.#emitter.emit("start");
-	}
-	get velocity() {
-		return this.#state.velocity;
-	}
-	set velocity(value) {
-		this.#state.velocity = value;
-		this.#needsReset = true;
-	}
-	get timeRemaining() {
-		return this.#timeRemaining;
-	}
-	get isResting() {
-		return this.#state.isResting;
-	}
-	configure(config) {
-		this.#config = config;
-		this.#state.configure(config);
-		this.#configVersion = config._version;
-		this.#needsUpdate = true;
-	}
-	tick(dt, emit = true) {
-		invariant(this.#currentSolver, "Cannot tick a disposed motion");
-		if (this.#config._version !== this.#configVersion) {
-			this.#state.configure(this.#config);
-			this.#configVersion = this.#config._version;
-			this.#needsUpdate = true;
-		}
-		const needsTimeRemaining = this.#needsUpdate || this.#needsReset;
-		if (this.#needsUpdate) {
-			this.#updateSolver();
-			this.#needsUpdate = false;
-			this.#needsReset = false;
-		} else if (this.#needsReset) {
-			this.#currentSolver.configure();
-			this.#needsReset = false;
-		}
-		if (needsTimeRemaining) this.#timeRemaining = this.#config.computeTimeRemaining(this.#state);
-		this.#currentSolver.tick(dt);
-		this.#timeRemaining = Math.max(0, this.#timeRemaining - dt * 1e3);
-		if (emit) {
-			this.#emitter.emit("update");
-			if (this.#state.isResting) {
-				this.#timeRemaining = 0;
-				this.#emitter.emit("stop");
-			}
-		}
-	}
-	onUpdate(callback) {
-		return this.#emitter.on("update", callback);
-	}
-	onStart(callback) {
-		return this.#emitter.on("start", callback);
-	}
-	onStop(callback) {
-		return this.#emitter.on("stop", callback);
-	}
-	dispose() {
-		this.#emitter.clear();
-		this.#underdampedSolver = null;
-		this.#criticallyDampedSolver = null;
-		this.#overdampedSolver = null;
-		this.#currentSolver = null;
-	}
-	#updateSolver() {
-		if (this.#config.dampingRatio < 1) {
-			this.#underdampedSolver ||= new UnderdampedSolver(this.#state);
-			this.#currentSolver = this.#underdampedSolver;
-		} else if (this.#config.dampingRatio === 1) {
-			this.#criticallyDampedSolver ||= new CriticallyDampedSolver(this.#state);
-			this.#currentSolver = this.#criticallyDampedSolver;
-		} else {
-			this.#overdampedSolver ||= new OverdampedSolver(this.#state);
-			this.#currentSolver = this.#overdampedSolver;
-		}
-		this.#currentSolver.configure(this.#config);
-	}
-};
-//#endregion
-//#region src/spring.ts
-function normalizeTarget(target) {
-	if (target instanceof Spring) return {
-		spring: target,
-		offset: 0
-	};
-	if (typeof target === "object" && target !== null && "spring" in target && target.spring instanceof Spring) return {
-		spring: target.spring,
-		offset: target.offset ?? 0
-	};
-	return null;
-}
-var Spring = class {
-	#target;
-	#config;
-	#motion;
-	#motions;
-	#leader = null;
-	#offset = 0;
-	#ownsConfig;
-	#unsubLeader = null;
-	constructor(motions, position, config) {
-		this.#motions = motions;
-		let numericTarget;
-		let value;
-		let normalized = null;
-		if (typeof position === "number") {
-			numericTarget = position;
-			value = position;
-		} else {
-			normalized = normalizeTarget(position.target);
-			if (normalized) {
-				numericTarget = normalized.spring.#target + normalized.spring.#motion.position + normalized.offset;
-				value = position.value ?? numericTarget;
-			} else {
-				numericTarget = position.target ?? position.value ?? 0;
-				value = position.value ?? numericTarget;
-			}
-		}
-		const hasOverride = config !== void 0;
-		this.#ownsConfig = hasOverride || !normalized;
-		if (normalized && !hasOverride) this.#config = normalized.spring.#config;
-		else this.#config = config ?? SpringConfig.default;
-		this.#target = numericTarget;
-		this.#motion = new Motion(this.#config, value - numericTarget, 0);
-		if (!this.#motion.isResting) this.#motions.add(this.#motion);
-		if (normalized) {
-			this.#leader = normalized.spring;
-			this.#offset = normalized.offset;
-			this.#unsubLeader = normalized.spring.onUpdate(() => {
-				this.#setTarget(this.#leader.#target + this.#leader.#motion.position + this.#offset);
-			});
-		}
-	}
-	get target() {
-		return this.#target;
-	}
-	set target(value) {
-		if (typeof value === "number") {
-			this.#unfollow();
-			this.#setTarget(value);
-		} else {
-			const normalized = normalizeTarget(value);
-			this.#follow(normalized.spring, normalized.offset);
-		}
-	}
-	get value() {
-		return this.#target + this.#motion.position;
-	}
-	set value(value) {
-		const position = value - this.#target;
-		if (position !== this.#motion.position) {
-			this.#motions.add(this.#motion);
-			this.#motion.position = position;
-			this.#motion.tick(0);
-		}
-	}
-	get velocity() {
-		return this.#motion.velocity;
-	}
-	set velocity(value) {
-		this.#motions.add(this.#motion);
-		this.#motion.velocity = value;
-	}
-	get config() {
-		return this.#config;
-	}
-	get mass() {
-		return this.#config.mass;
-	}
-	get tension() {
-		return this.#config.tension;
-	}
-	get damping() {
-		return this.#config.damping;
-	}
-	get dampingRatio() {
-		return this.#config.dampingRatio;
-	}
-	get precision() {
-		return this.#config.precision;
-	}
-	set config(value) {
-		if (value) {
-			if (this.#leader && !this.#ownsConfig) {
-				this.#ownsConfig = true;
-				this.#config = new SpringConfig({
-					tension: value.tension,
-					damping: value.damping,
-					mass: value.mass,
-					precision: value.precision
-				});
-				this.#motion.configure(this.#config);
-			} else this.#config.assign(value);
-			this.#motions.add(this.#motion);
-		} else if (this.#ownsConfig) {
-			this.#ownsConfig = false;
-			this.#config = this.#leader ? this.#leader.#config : SpringConfig.default;
-			this.#motion.configure(this.#config);
-			this.#motions.add(this.#motion);
-		}
-	}
-	get timeRemaining() {
-		return this.#motion.timeRemaining;
-	}
-	get isResting() {
-		return this.#motion.isResting;
-	}
-	jumpTo(value) {
-		this.#target = value;
-		this.#motion.position = 0;
-		this.#motion.velocity = 0;
-		this.#motion.tick(0);
-	}
-	dispose() {
-		if (this.#unsubLeader) {
-			this.#unsubLeader();
-			this.#unsubLeader = null;
-		}
-		this.#motions.remove(this.#motion);
-		this.#motion.dispose();
-	}
-	onUpdate(callback) {
-		return this.#motion.onUpdate(callback);
-	}
-	onStart(callback) {
-		return this.#motion.onStart(callback);
-	}
-	onStop(callback) {
-		return this.#motion.onStop(callback);
-	}
-	#setTarget(value) {
-		if (value !== this.#target) {
-			this.#motions.add(this.#motion);
-			const rawValue = this.#target + this.#motion.position;
-			this.#target = value;
-			this.#motion.position = rawValue - this.#target;
-			this.#motion.tick(0);
-		}
-	}
-	#follow(leader, offset) {
-		if (this.#unsubLeader) this.#unsubLeader();
-		this.#leader = leader;
-		this.#offset = offset;
-		if (!this.#ownsConfig) {
-			this.#config = leader.#config;
-			this.#motion.configure(this.#config);
-		}
-		this.#unsubLeader = leader.onUpdate(() => {
-			this.#setTarget(this.#leader.#target + this.#leader.#motion.position + this.#offset);
-		});
-		this.#setTarget(leader.#target + leader.#motion.position + offset);
-	}
-	#unfollow() {
-		if (!this.#leader) return;
-		this.#unsubLeader();
-		this.#unsubLeader = null;
-		this.#leader = null;
-		this.#offset = 0;
-		if (!this.#ownsConfig) {
-			this.#ownsConfig = true;
-			this.#config = new SpringConfig({
-				tension: this.#config.tension,
-				damping: this.#config.damping,
-				mass: this.#config.mass,
-				precision: this.#config.precision
-			});
-			this.#motion.configure(this.#config);
-		}
-	}
-};
-//#endregion
-//#region src/vector2.ts
-function isVector2(value) {
-	return typeof value === "object" && value !== null && "x" in value && typeof value.x === "number";
-}
-//#endregion
-//#region src/spring2d.ts
-function normalizeTarget2D(target) {
-	if (target instanceof Spring2D) return {
-		spring: target,
-		offset: void 0
-	};
-	if (typeof target === "object" && target !== null && "spring" in target && target.spring instanceof Spring2D) return {
-		spring: target.spring,
-		offset: target.offset
-	};
-	return null;
-}
-function toScalarTarget(spring, offset) {
-	return offset ? {
-		spring,
-		offset
-	} : spring;
-}
-function toScalarPos(target, value) {
-	if (typeof target === "number") return value !== void 0 ? {
-		target,
-		value
-	} : target;
-	return {
-		target,
-		value
-	};
-}
-var Spring2D = class Spring2D {
-	#x;
-	#y;
-	#value = {
-		x: 0,
-		y: 0
-	};
-	#velocity = {
-		x: 0,
-		y: 0
-	};
-	constructor(motions, position, config) {
-		let xPos;
-		let yPos;
-		if (isVector2(position)) {
-			xPos = position.x;
-			yPos = position.y;
-		} else {
-			const normalized = normalizeTarget2D(position.target);
-			if (normalized) {
-				const lx = normalized.spring.#x;
-				const ly = normalized.spring.#y;
-				const xTarget = toScalarTarget(lx, normalized.offset?.x);
-				const yTarget = toScalarTarget(ly, normalized.offset?.y);
-				xPos = toScalarPos(xTarget, position.value?.x);
-				yPos = toScalarPos(yTarget, position.value?.y);
-			} else if (isVector2(position.target)) {
-				const t = position.target;
-				xPos = {
-					target: t.x,
-					value: position.value?.x
-				};
-				yPos = {
-					target: t.y,
-					value: position.value?.y
-				};
-			} else {
-				xPos = {
-					target: position.target,
-					value: position.value?.x
-				};
-				yPos = {
-					target: void 0,
-					value: position.value?.y
-				};
-			}
-		}
-		this.#x = new Spring(motions, xPos, config);
-		this.#y = new Spring(motions, yPos, config);
-	}
-	get target() {
-		return {
-			x: this.#x.target,
-			y: this.#y.target
-		};
-	}
-	set target(value) {
-		if (value instanceof Spring2D) {
-			this.#x.target = value.#x;
-			this.#y.target = value.#y;
-		} else if ("spring" in value && value.spring instanceof Spring2D) {
-			const { spring, offset } = value;
-			this.#x.target = toScalarTarget(spring.#x, offset?.x);
-			this.#y.target = toScalarTarget(spring.#y, offset?.y);
-		} else {
-			const v = value;
-			this.#x.target = v.x;
-			this.#y.target = v.y;
-		}
-	}
-	get value() {
-		this.#value.x = this.#x.value;
-		this.#value.y = this.#y.value;
-		return this.#value;
-	}
-	set value(value) {
-		this.#x.value = value.x;
-		this.#y.value = value.y;
-	}
-	get velocity() {
-		this.#velocity.x = this.#x.velocity;
-		this.#velocity.y = this.#y.velocity;
-		return this.#velocity;
-	}
-	set velocity(value) {
-		this.#x.velocity = value.x;
-		this.#y.velocity = value.y;
-	}
-	get config() {
-		return this.#x.config;
-	}
-	get mass() {
-		return this.#x.mass;
-	}
-	get tension() {
-		return this.#x.tension;
-	}
-	get damping() {
-		return this.#x.damping;
-	}
-	get dampingRatio() {
-		return this.#x.dampingRatio;
-	}
-	get precision() {
-		return this.#x.precision;
-	}
-	set config(value) {
-		this.#x.config = value;
-		this.#y.config = value;
-	}
-	get timeRemaining() {
-		return Math.max(this.#x.timeRemaining, this.#y.timeRemaining);
-	}
-	get isResting() {
-		return this.#x.isResting && this.#y.isResting;
-	}
-	jumpTo(value) {
-		this.#x.jumpTo(value.x);
-		this.#y.jumpTo(value.y);
-	}
-	dispose() {
-		this.#x.dispose();
-		this.#y.dispose();
-	}
-	onUpdate(callback) {
-		const a = this.#x.onUpdate(callback);
-		const b = this.#y.onUpdate(callback);
-		return () => {
-			a();
-			b();
-		};
-	}
-	onStart(callback) {
-		const a = this.#x.onStart(callback);
-		const b = this.#y.onStart(callback);
-		return () => {
-			a();
-			b();
-		};
-	}
-	onStop(callback) {
-		const check = () => {
-			if (this.isResting) callback();
-		};
-		const a = this.#x.onStop(check);
-		const b = this.#y.onStop(check);
-		return () => {
-			a();
-			b();
-		};
-	}
-};
-//#endregion
-//#region src/ticker.ts
-const hasWindow = typeof window !== "undefined";
-const request = hasWindow ? (cb) => window.requestAnimationFrame(cb) : (cb) => setTimeout(cb, 1);
-const cancel = hasWindow ? (id) => window.cancelAnimationFrame(id) : (id) => clearTimeout(id);
-var Ticker = class {
-	#fps;
-	#gap;
-	#lagThreshold;
-	#adjustedLag;
-	#motion;
-	#frame = 0;
-	#time = 0;
-	#previousTime = 0;
-	#delta = 0;
-	#nextTime;
-	#lastWallTime = 0;
-	#id = 0;
-	#stopped = true;
-	constructor(motions, options) {
-		this.#motion = motions;
-		const fps = options?.fps ?? 60;
-		const lagThreshold = options?.lagThreshold ?? 500;
-		const adjustedLag = options?.adjustedLag ?? 33;
-		invariant(fps > 0, "FPS must be greater than 0");
-		invariant(lagThreshold >= 0, "Lag threshold must be greater than or equal to 0");
-		invariant(adjustedLag >= 0, "Adjusted lag must be greater than or equal to 0");
-		this.#fps = fps;
-		this.#gap = 1e3 / fps;
-		this.#lagThreshold = lagThreshold === 0 ? 1e8 : lagThreshold;
-		this.#adjustedLag = Math.min(adjustedLag, this.#lagThreshold);
-		this.#nextTime = this.#gap;
-	}
-	get fps() {
-		return this.#fps;
-	}
-	set fps(value) {
-		invariant(value > 0, "FPS must be greater than 0");
-		this.#fps = value;
-		this.#gap = 1e3 / value;
-		this.#nextTime = this.#previousTime + this.#gap;
-	}
-	get lagThreshold() {
-		return this.#lagThreshold;
-	}
-	set lagThreshold(value) {
-		invariant(value >= 0, "Lag threshold must be greater than or equal to 0");
-		this.#lagThreshold = value === 0 ? 1e8 : value;
-		this.#adjustedLag = Math.min(this.#adjustedLag, this.#lagThreshold);
-	}
-	get adjustedLag() {
-		return this.#adjustedLag;
-	}
-	set adjustedLag(value) {
-		invariant(value >= 0, "Adjusted lag must be greater than or equal to 0");
-		this.#adjustedLag = Math.min(value, this.#lagThreshold);
-	}
-	get time() {
-		return this.#time;
-	}
-	get frame() {
-		return this.#frame;
-	}
-	get delta() {
-		return this.#delta;
-	}
-	get deltaRatio() {
-		return this.#delta / this.#gap;
-	}
-	get stopped() {
-		return this.#stopped;
-	}
-	start() {
-		if (this.#stopped) {
-			this.#stopped = false;
-			this.#lastWallTime = performance.now();
-			this.#id = request((t) => this.#onFrame(t));
-		}
-	}
-	stop() {
-		if (!this.#stopped) {
-			cancel(this.#id);
-			this.#stopped = true;
-		}
-	}
-	/** Manually advance one frame. */
-	tick() {
-		this.#step(this.#gap);
-	}
-	#onFrame(timestamp) {
-		if (this.#stopped) return;
-		const wallElapsed = timestamp - this.#lastWallTime;
-		this.#lastWallTime = timestamp;
-		const elapsed = wallElapsed > this.#lagThreshold ? this.#adjustedLag : wallElapsed;
-		this.#time += elapsed;
-		if (this.#time - this.#nextTime >= 0) {
-			this.#frame++;
-			this.#delta = this.#time - this.#previousTime;
-			this.#previousTime = this.#time;
-			this.#nextTime += this.#gap;
-			this.#motion.tick(this.#delta / 1e3);
-		}
-		this.#id = request((t) => this.#onFrame(t));
-	}
-	#step(dt) {
-		this.#time += dt;
-		this.#frame++;
-		this.#delta = dt;
-		this.#previousTime = this.#time;
-		this.#motion.tick(dt / 1e3);
-	}
-};
-//#endregion
-//#region src/system.ts
-var SpringSystemImpl = class {
-	#motion;
-	#ticker;
-	constructor(options) {
-		this.#motion = new MotionSet(options?.debug);
-		this.#ticker = new Ticker(this.#motion, options);
-	}
-	createSpring(position, config) {
-		return new Spring(this.#motion, position, config);
-	}
-	createSpring2D(position, config) {
-		return new Spring2D(this.#motion, position, config);
-	}
-	advance(dt) {
-		this.#motion.tick(dt / 1e3);
-	}
-	start() {
-		this.#ticker.start();
-	}
-	stop() {
-		this.#ticker.stop();
-	}
-	get running() {
-		return !this.#ticker.stopped;
-	}
-	get fps() {
-		return this.#ticker.fps;
-	}
-	set fps(value) {
-		this.#ticker.fps = value;
-	}
-	get lagThreshold() {
-		return this.#ticker.lagThreshold;
-	}
-	set lagThreshold(value) {
-		this.#ticker.lagThreshold = value;
-	}
-	get adjustedLag() {
-		return this.#ticker.adjustedLag;
-	}
-	set adjustedLag(value) {
-		this.#ticker.adjustedLag = value;
-	}
-};
-function createSpringSystem(options) {
-	return new SpringSystemImpl(options);
-}
-//#endregion
-export { SpringConfig as n, defineSpring as r, createSpringSystem as t };