coily 0.4.0 → 0.5.0

package/dist/api.cjs

@@ -0,0 +1,606 @@
+'use strict';
+
+var __accessCheck$5 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$5 = (obj, member, getter) => {
+  __accessCheck$5(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$5 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _solvers, _callbacks;
+class Scheduler {
+  constructor() {
+    __privateAdd$5(this, _solvers, /* @__PURE__ */ new Set());
+    __privateAdd$5(this, _callbacks, /* @__PURE__ */ new Set());
+  }
+  tick(delta) {
+    for (const callback of __privateGet$5(this, _callbacks).values()) {
+      callback(delta);
+    }
+    for (const solver of __privateGet$5(this, _solvers).values()) {
+      solver.tick(delta);
+      if (solver.resting) {
+        __privateGet$5(this, _solvers).delete(solver);
+      }
+    }
+    __privateGet$5(this, _callbacks).clear();
+  }
+  add(solver) {
+    __privateGet$5(this, _solvers).add(solver);
+  }
+  remove(solver) {
+    __privateGet$5(this, _solvers).delete(solver);
+  }
+  has(solver) {
+    return __privateGet$5(this, _solvers).has(solver);
+  }
+  once(callback) {
+    __privateGet$5(this, _callbacks).add(callback);
+  }
+}
+_solvers = new WeakMap();
+_callbacks = new WeakMap();
+
+var __accessCheck$4 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$4 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _handlers;
+class Emitter {
+  constructor() {
+    __privateAdd$4(this, _handlers, /* @__PURE__ */ new Map());
+  }
+  on(type, handler) {
+    const handlers = __privateGet$4(this, _handlers).get(type);
+    if (handlers) {
+      handlers.push(handler);
+    } else {
+      __privateGet$4(this, _handlers).set(type, [handler]);
+    }
+    return () => {
+      this.off(type, handler);
+    };
+  }
+  off(type, handler) {
+    const handlers = __privateGet$4(this, _handlers).get(type);
+    if (handlers) {
+      if (handler) {
+        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+      } else {
+        __privateGet$4(this, _handlers).set(type, []);
+      }
+    }
+  }
+  emit(type, evt) {
+    const handlers = __privateGet$4(this, _handlers)?.get(type);
+    if (handlers) {
+      handlers.slice().map((handler) => {
+        handler(evt);
+      });
+    }
+  }
+}
+_handlers = new WeakMap();
+
+function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new Error(message ?? "Invariant Failed");
+}
+function roundTo(value, precision) {
+  const p = 10 ** precision;
+  return Math.round(value * p) / p;
+}
+
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _precision, _restingMagnitude, _position, _velocity;
+class State {
+  constructor(position, velocity, precision) {
+    __privateAdd$3(this, _precision, void 0);
+    __privateAdd$3(this, _restingMagnitude, void 0);
+    __privateAdd$3(this, _position, void 0);
+    __privateAdd$3(this, _velocity, void 0);
+    __privateSet$3(this, _precision, precision);
+    __privateSet$3(this, _restingMagnitude, 1 / 10 ** __privateGet$3(this, _precision));
+    __privateSet$3(this, _position, roundTo(position, __privateGet$3(this, _precision)));
+    __privateSet$3(this, _velocity, roundTo(velocity, __privateGet$3(this, _precision)));
+  }
+  get position() {
+    return __privateGet$3(this, _position);
+  }
+  set position(value) {
+    __privateSet$3(this, _position, roundTo(value, __privateGet$3(this, _precision)));
+  }
+  get velocity() {
+    return __privateGet$3(this, _velocity);
+  }
+  set velocity(value) {
+    __privateSet$3(this, _velocity, roundTo(value, __privateGet$3(this, _precision)));
+  }
+  get precision() {
+    return __privateGet$3(this, _precision);
+  }
+  set precision(value) {
+    __privateSet$3(this, _precision, value);
+    __privateSet$3(this, _restingMagnitude, 1 / 10 ** __privateGet$3(this, _precision));
+    __privateSet$3(this, _position, roundTo(__privateGet$3(this, _position), __privateGet$3(this, _precision)));
+    __privateSet$3(this, _velocity, roundTo(__privateGet$3(this, _velocity), __privateGet$3(this, _precision)));
+  }
+  get resting() {
+    return Math.abs(__privateGet$3(this, _velocity)) < __privateGet$3(this, _restingMagnitude) && Math.abs(__privateGet$3(this, _position)) < __privateGet$3(this, _restingMagnitude);
+  }
+}
+_precision = new WeakMap();
+_restingMagnitude = new WeakMap();
+_position = new WeakMap();
+_velocity = new WeakMap();
+
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck$2(obj, member, "access private method");
+  return method;
+};
+var _mass, _tension, _damping, _state, _underdampedSolver, _criticallyDampedSolver, _overdampedSolver, _currentSolver, _solverNeedsUpdate, _solverNeedsReset, _emitter, _updateSolver, updateSolver_fn, _solver$1, _state2, _dampedFrequency, _t, _c1, _c2, _solver2, _state3, _t2, _c12, _c22, _solver3, _state4, _dampedFrequency2, _t3, _c13, _c23;
+class Solver {
+  constructor(options) {
+    __privateAdd$2(this, _updateSolver);
+    __privateAdd$2(this, _mass, void 0);
+    __privateAdd$2(this, _tension, void 0);
+    __privateAdd$2(this, _damping, void 0);
+    __privateAdd$2(this, _state, void 0);
+    __privateAdd$2(this, _underdampedSolver, null);
+    __privateAdd$2(this, _criticallyDampedSolver, null);
+    __privateAdd$2(this, _overdampedSolver, null);
+    __privateAdd$2(this, _currentSolver, void 0);
+    __privateAdd$2(this, _solverNeedsUpdate, false);
+    __privateAdd$2(this, _solverNeedsReset, false);
+    __privateAdd$2(this, _emitter, void 0);
+    __privateSet$2(this, _mass, options.mass);
+    __privateSet$2(this, _tension, options.tension);
+    __privateSet$2(this, _damping, options.damping);
+    __privateSet$2(this, _state, new State(
+      options.position,
+      options.velocity,
+      options.precision
+    ));
+    __privateSet$2(this, _emitter, new Emitter());
+    __privateMethod(this, _updateSolver, updateSolver_fn).call(this);
+  }
+  get mass() {
+    return __privateGet$2(this, _mass);
+  }
+  set mass(value) {
+    __privateSet$2(this, _mass, value);
+    __privateSet$2(this, _solverNeedsUpdate, true);
+  }
+  get tension() {
+    return __privateGet$2(this, _tension);
+  }
+  set tension(value) {
+    __privateSet$2(this, _tension, value);
+    __privateSet$2(this, _solverNeedsUpdate, true);
+  }
+  get damping() {
+    return __privateGet$2(this, _damping);
+  }
+  set damping(value) {
+    __privateSet$2(this, _damping, value);
+    __privateSet$2(this, _solverNeedsUpdate, true);
+  }
+  get position() {
+    return __privateGet$2(this, _state).position;
+  }
+  set position(value) {
+    __privateGet$2(this, _state).position = value;
+    __privateSet$2(this, _solverNeedsReset, true);
+  }
+  get velocity() {
+    return __privateGet$2(this, _state).velocity;
+  }
+  set velocity(value) {
+    __privateGet$2(this, _state).velocity = value;
+    __privateSet$2(this, _solverNeedsReset, true);
+  }
+  get precision() {
+    return __privateGet$2(this, _state).precision;
+  }
+  set precision(value) {
+    __privateGet$2(this, _state).precision = value;
+  }
+  get resting() {
+    return __privateGet$2(this, _state).resting;
+  }
+  get naturalFrequency() {
+    return Math.sqrt(__privateGet$2(this, _tension) / __privateGet$2(this, _mass));
+  }
+  get criticalDamping() {
+    return 2 * __privateGet$2(this, _mass) * this.naturalFrequency;
+  }
+  get dampingRatio() {
+    return __privateGet$2(this, _damping) / this.criticalDamping;
+  }
+  tick(dt) {
+    if (__privateGet$2(this, _solverNeedsUpdate)) {
+      __privateMethod(this, _updateSolver, updateSolver_fn).call(this);
+      __privateSet$2(this, _solverNeedsUpdate, false);
+    }
+    if (__privateGet$2(this, _solverNeedsReset)) {
+      __privateGet$2(this, _currentSolver).reset();
+      __privateSet$2(this, _solverNeedsReset, false);
+    }
+    const previousPosition = __privateGet$2(this, _state).position;
+    const previousVelocity = __privateGet$2(this, _state).velocity;
+    __privateGet$2(this, _currentSolver).tick(dt);
+    if (__privateGet$2(this, _state).position !== previousPosition || __privateGet$2(this, _state).velocity !== previousVelocity) {
+      __privateGet$2(this, _emitter).emit("update");
+    }
+  }
+  onUpdate(callback) {
+    return __privateGet$2(this, _emitter).on("update", callback);
+  }
+}
+_mass = new WeakMap();
+_tension = new WeakMap();
+_damping = new WeakMap();
+_state = new WeakMap();
+_underdampedSolver = new WeakMap();
+_criticallyDampedSolver = new WeakMap();
+_overdampedSolver = new WeakMap();
+_currentSolver = new WeakMap();
+_solverNeedsUpdate = new WeakMap();
+_solverNeedsReset = new WeakMap();
+_emitter = new WeakMap();
+_updateSolver = new WeakSet();
+updateSolver_fn = function() {
+  if (this.dampingRatio < 1) {
+    __privateGet$2(this, _underdampedSolver) || __privateSet$2(this, _underdampedSolver, new UnderdampedSolver(this, __privateGet$2(this, _state)));
+    __privateSet$2(this, _currentSolver, __privateGet$2(this, _underdampedSolver));
+  } else if (this.dampingRatio === 1) {
+    __privateGet$2(this, _criticallyDampedSolver) || __privateSet$2(this, _criticallyDampedSolver, new CriticallyDampedSolver(
+      this,
+      __privateGet$2(this, _state)
+    ));
+    __privateSet$2(this, _currentSolver, __privateGet$2(this, _criticallyDampedSolver));
+  } else {
+    __privateGet$2(this, _overdampedSolver) || __privateSet$2(this, _overdampedSolver, new OverdampedSolver(this, __privateGet$2(this, _state)));
+    __privateSet$2(this, _currentSolver, __privateGet$2(this, _overdampedSolver));
+  }
+};
+class UnderdampedSolver {
+  constructor(solver, state) {
+    __privateAdd$2(this, _solver$1, void 0);
+    __privateAdd$2(this, _state2, void 0);
+    __privateAdd$2(this, _dampedFrequency, void 0);
+    __privateAdd$2(this, _t, 0);
+    __privateAdd$2(this, _c1, 0);
+    __privateAdd$2(this, _c2, 0);
+    __privateSet$2(this, _solver$1, solver);
+    __privateSet$2(this, _state2, state);
+    this.reset();
+  }
+  reset() {
+    __privateSet$2(this, _dampedFrequency, __privateGet$2(this, _solver$1).naturalFrequency * Math.sqrt(1 - __privateGet$2(this, _solver$1).dampingRatio ** 2));
+    __privateSet$2(this, _t, 0);
+    __privateSet$2(this, _c1, __privateGet$2(this, _state2).position);
+    __privateSet$2(this, _c2, (__privateGet$2(this, _state2).velocity + __privateGet$2(this, _solver$1).dampingRatio * __privateGet$2(this, _solver$1).naturalFrequency * __privateGet$2(this, _state2).position) / __privateGet$2(this, _dampedFrequency));
+    this.tick(0);
+  }
+  tick(dt) {
+    __privateSet$2(this, _t, __privateGet$2(this, _t) + dt);
+    const sin = Math.sin(__privateGet$2(this, _dampedFrequency) * __privateGet$2(this, _t));
+    const cos = Math.cos(__privateGet$2(this, _dampedFrequency) * __privateGet$2(this, _t));
+    const decay = Math.exp(
+      -__privateGet$2(this, _solver$1).dampingRatio * __privateGet$2(this, _solver$1).naturalFrequency * __privateGet$2(this, _t)
+    );
+    const decayVelocity = -__privateGet$2(this, _solver$1).dampingRatio * __privateGet$2(this, _solver$1).naturalFrequency * decay;
+    const oscillation = __privateGet$2(this, _c1) * cos + __privateGet$2(this, _c2) * sin;
+    const oscillationVelocity = -__privateGet$2(this, _c1) * __privateGet$2(this, _dampedFrequency) * sin + __privateGet$2(this, _c2) * __privateGet$2(this, _dampedFrequency) * cos;
+    __privateGet$2(this, _state2).position = decay * oscillation;
+    __privateGet$2(this, _state2).velocity = decay * oscillationVelocity + decayVelocity * oscillation;
+  }
+}
+_solver$1 = new WeakMap();
+_state2 = new WeakMap();
+_dampedFrequency = new WeakMap();
+_t = new WeakMap();
+_c1 = new WeakMap();
+_c2 = new WeakMap();
+class CriticallyDampedSolver {
+  constructor(solver, state) {
+    __privateAdd$2(this, _solver2, void 0);
+    __privateAdd$2(this, _state3, void 0);
+    __privateAdd$2(this, _t2, 0);
+    __privateAdd$2(this, _c12, 0);
+    __privateAdd$2(this, _c22, 0);
+    __privateSet$2(this, _solver2, solver);
+    __privateSet$2(this, _state3, state);
+    this.reset();
+  }
+  reset() {
+    __privateSet$2(this, _t2, 0);
+    __privateSet$2(this, _c12, __privateGet$2(this, _state3).position);
+    __privateSet$2(this, _c22, __privateGet$2(this, _state3).velocity + __privateGet$2(this, _solver2).naturalFrequency * __privateGet$2(this, _state3).position);
+    this.tick(0);
+  }
+  tick(dt) {
+    __privateSet$2(this, _t2, __privateGet$2(this, _t2) + dt);
+    const decay = Math.exp(-__privateGet$2(this, _solver2).naturalFrequency * __privateGet$2(this, _t2));
+    const decayVelocity = -__privateGet$2(this, _solver2).naturalFrequency * decay;
+    const scale = __privateGet$2(this, _c12) + __privateGet$2(this, _c22) * __privateGet$2(this, _t2);
+    const scaleVelocity = __privateGet$2(this, _c22);
+    __privateGet$2(this, _state3).position = scale * decay;
+    __privateGet$2(this, _state3).velocity = scaleVelocity * decay + decayVelocity * scale;
+  }
+}
+_solver2 = new WeakMap();
+_state3 = new WeakMap();
+_t2 = new WeakMap();
+_c12 = new WeakMap();
+_c22 = new WeakMap();
+class OverdampedSolver {
+  constructor(solver, state) {
+    __privateAdd$2(this, _solver3, void 0);
+    __privateAdd$2(this, _state4, void 0);
+    __privateAdd$2(this, _dampedFrequency2, void 0);
+    __privateAdd$2(this, _t3, 0);
+    __privateAdd$2(this, _c13, 0);
+    __privateAdd$2(this, _c23, 0);
+    __privateSet$2(this, _solver3, solver);
+    __privateSet$2(this, _state4, state);
+    this.reset();
+  }
+  reset() {
+    __privateSet$2(this, _dampedFrequency2, __privateGet$2(this, _solver3).naturalFrequency * Math.sqrt(__privateGet$2(this, _solver3).dampingRatio ** 2 - 1));
+    __privateSet$2(this, _t3, 0);
+    __privateSet$2(this, _c13, __privateGet$2(this, _state4).velocity + __privateGet$2(this, _solver3).dampingRatio * __privateGet$2(this, _solver3).naturalFrequency * __privateGet$2(this, _state4).position);
+    __privateSet$2(this, _c23, __privateGet$2(this, _state4).position * __privateGet$2(this, _dampedFrequency2));
+  }
+  tick(dt) {
+    __privateSet$2(this, _t3, __privateGet$2(this, _t3) + dt);
+    const decay = Math.exp(
+      -__privateGet$2(this, _solver3).dampingRatio * __privateGet$2(this, _solver3).naturalFrequency * __privateGet$2(this, _t3)
+    );
+    const decayVelocity = -__privateGet$2(this, _solver3).dampingRatio * __privateGet$2(this, _solver3).naturalFrequency * decay;
+    const clamped = Math.min(__privateGet$2(this, _dampedFrequency2) * __privateGet$2(this, _t3), 300);
+    const sinh = Math.sinh(clamped);
+    const cosh = Math.cosh(clamped);
+    const scale = __privateGet$2(this, _c13) * sinh + __privateGet$2(this, _c23) * cosh;
+    const scaleVelocity = -__privateGet$2(this, _c13) * __privateGet$2(this, _dampedFrequency2) * sinh + __privateGet$2(this, _c23) * __privateGet$2(this, _dampedFrequency2) * cosh;
+    __privateGet$2(this, _state4).position = scale * decay / __privateGet$2(this, _dampedFrequency2);
+    __privateGet$2(this, _state4).velocity = (scale * decayVelocity + scaleVelocity * decay) / __privateGet$2(this, _dampedFrequency2);
+  }
+}
+_solver3 = new WeakMap();
+_state4 = new WeakMap();
+_dampedFrequency2 = new WeakMap();
+_t3 = new WeakMap();
+_c13 = new WeakMap();
+_c23 = new WeakMap();
+
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _target, _solver, _scheduler$1, _optimisticTarget;
+class Spring {
+  constructor(scheduler, options) {
+    __privateAdd$1(this, _target, void 0);
+    __privateAdd$1(this, _solver, void 0);
+    __privateAdd$1(this, _scheduler$1, void 0);
+    __privateAdd$1(this, _optimisticTarget, void 0);
+    invariant(options.mass > 0, "Mass must be greater than 0");
+    invariant(options.tension > 0, "Tension must be greater than 0");
+    invariant(
+      options.damping >= 0,
+      "Damping must be greater than or equal to 0"
+    );
+    invariant(
+      options.precsiion === void 0 || options.precsiion > 0,
+      "Precision must be greater than 0"
+    );
+    __privateSet$1(this, _target, options.target);
+    __privateSet$1(this, _solver, new Solver({
+      mass: options.mass,
+      tension: options.tension,
+      damping: options.damping,
+      position: options.target + (options.value ?? 0),
+      velocity: 0,
+      precision: options.precsiion ?? 2
+    }));
+    __privateSet$1(this, _scheduler$1, scheduler);
+    __privateSet$1(this, _optimisticTarget, __privateGet$1(this, _target));
+    if (!__privateGet$1(this, _solver).resting) {
+      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    }
+  }
+  get target() {
+    return __privateGet$1(this, _optimisticTarget);
+  }
+  set target(value) {
+    if (value !== __privateGet$1(this, _optimisticTarget)) {
+      __privateSet$1(this, _optimisticTarget, value);
+      __privateGet$1(this, _scheduler$1).once(() => {
+        if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
+          __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+        }
+        const currentValue = this.value;
+        __privateSet$1(this, _target, __privateGet$1(this, _optimisticTarget));
+        __privateGet$1(this, _solver).position = currentValue - __privateGet$1(this, _target);
+      });
+    }
+  }
+  get value() {
+    return __privateGet$1(this, _target) + __privateGet$1(this, _solver).position;
+  }
+  set value(value) {
+    if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
+      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    }
+    __privateGet$1(this, _solver).position = __privateGet$1(this, _target) - value;
+  }
+  get velocity() {
+    return __privateGet$1(this, _solver).velocity;
+  }
+  set velocity(value) {
+    if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
+      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    }
+    __privateGet$1(this, _solver).velocity = value;
+  }
+  get mass() {
+    return __privateGet$1(this, _solver).mass;
+  }
+  set mass(value) {
+    invariant(value > 0, "Mass must be greater than 0");
+    if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
+      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    }
+    __privateGet$1(this, _solver).mass = value;
+  }
+  get tension() {
+    return __privateGet$1(this, _solver).tension;
+  }
+  set tension(value) {
+    invariant(value > 0, "Tension must be greater than 0");
+    if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
+      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    }
+    __privateGet$1(this, _solver).tension = value;
+  }
+  get damping() {
+    return __privateGet$1(this, _solver).damping;
+  }
+  set damping(value) {
+    invariant(value >= 0, "Damping must be greater than or equal to 0");
+    if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
+      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    }
+    __privateGet$1(this, _solver).damping = value;
+  }
+  get precision() {
+    return __privateGet$1(this, _solver).precision;
+  }
+  set precision(value) {
+    invariant(value > 0, "Precision must be greater than 0");
+    if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
+      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    }
+    __privateGet$1(this, _solver).precision = value;
+  }
+  get resting() {
+    return __privateGet$1(this, _solver).resting;
+  }
+  onUpdate(callback) {
+    return __privateGet$1(this, _solver).onUpdate(callback);
+  }
+}
+_target = new WeakMap();
+_solver = new WeakMap();
+_scheduler$1 = new WeakMap();
+_optimisticTarget = new WeakMap();
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _scheduler;
+class SpringSystem {
+  constructor() {
+    __privateAdd(this, _scheduler, void 0);
+    __privateSet(this, _scheduler, new Scheduler());
+  }
+  createSpring(options) {
+    return new Spring(__privateGet(this, _scheduler), {
+      ...options,
+      target: options.target ?? 0
+    });
+  }
+  tick(dt) {
+    __privateGet(this, _scheduler).tick(dt);
+  }
+}
+_scheduler = new WeakMap();
+
+function createSpringSystem() {
+  return new SpringSystem();
+}
+
+exports.createSpringSystem = createSpringSystem;

package/dist/api.d.cts

@@ -0,0 +1,6 @@
+import { S as SpringSystem } from './shared/coily.86bacb03.cjs';
+export { a as Spring } from './shared/coily.86bacb03.cjs';
+
+declare function createSpringSystem(): SpringSystem;
+
+export { SpringSystem, createSpringSystem };

package/dist/api.d.mts

@@ -0,0 +1,6 @@
+import { S as SpringSystem } from './shared/coily.86bacb03.mjs';
+export { a as Spring } from './shared/coily.86bacb03.mjs';
+
+declare function createSpringSystem(): SpringSystem;
+
+export { SpringSystem, createSpringSystem };

package/dist/api.d.ts

@@ -0,0 +1,6 @@
+import { S as SpringSystem } from './shared/coily.86bacb03.js';
+export { a as Spring } from './shared/coily.86bacb03.js';
+
+declare function createSpringSystem(): SpringSystem;
+
+export { SpringSystem, createSpringSystem };