coily 0.9.0 → 0.10.0

package/dist/api.mjs

@@ -1,82 +1,49 @@
-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;
 class Scheduler {
-  constructor() {
-    __privateAdd$5(this, _solvers, /* @__PURE__ */ new Set());
-  }
+  #solvers = /* @__PURE__ */ new Set();
   tick(delta) {
-    for (const solver of __privateGet$5(this, _solvers).values()) {
+    for (const solver of this.#solvers.values()) {
       solver.tick(delta);
       if (solver.resting) {
-        __privateGet$5(this, _solvers).delete(solver);
+        this.#solvers.delete(solver);
       }
     }
   }
   add(solver) {
-    __privateGet$5(this, _solvers).add(solver);
+    this.#solvers.add(solver);
   }
   remove(solver) {
-    __privateGet$5(this, _solvers).delete(solver);
+    this.#solvers.delete(solver);
   }
   has(solver) {
-    return __privateGet$5(this, _solvers).has(solver);
+    return this.#solvers.has(solver);
   }
 }
-_solvers = 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());
-  }
+  #handlers = /* @__PURE__ */ new Map();
   on(type, handler) {
-    const handlers = __privateGet$4(this, _handlers).get(type);
+    const handlers = this.#handlers.get(type);
     if (handlers) {
       handlers.push(handler);
     } else {
-      __privateGet$4(this, _handlers).set(type, [handler]);
+      this.#handlers.set(type, [handler]);
     }
     return () => {
       this.off(type, handler);
     };
   }
   off(type, handler) {
-    const handlers = __privateGet$4(this, _handlers).get(type);
+    const handlers = this.#handlers.get(type);
     if (handlers) {
       if (handler) {
         handlers.splice(handlers.indexOf(handler) >>> 0, 1);
       } else {
-        __privateGet$4(this, _handlers).set(type, []);
+        this.#handlers.set(type, []);
       }
     }
   }
   emit(type, evt) {
-    const handlers = __privateGet$4(this, _handlers)?.get(type);
+    const handlers = this.#handlers?.get(type);
     if (handlers) {
       handlers.slice().map((handler) => {
         handler(evt);
@@ -84,7 +51,6 @@ class Emitter {
     }
   }
 }
-_handlers = new WeakMap();
 
 function invariant(condition, message) {
   if (condition) {
@@ -97,367 +63,264 @@ function roundTo(value, 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 {
+  #precision;
+  #restingMagnitude;
+  #position;
+  #velocity;
   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)));
+    this.#precision = precision;
+    this.#restingMagnitude = 1 / 10 ** this.#precision;
+    this.#position = roundTo(position, this.#precision);
+    this.#velocity = roundTo(velocity, this.#precision);
   }
   get position() {
-    return __privateGet$3(this, _position);
+    return this.#position;
   }
   set position(value) {
-    __privateSet$3(this, _position, roundTo(value, __privateGet$3(this, _precision)));
+    this.#position = roundTo(value, this.#precision);
   }
   get velocity() {
-    return __privateGet$3(this, _velocity);
+    return this.#velocity;
   }
   set velocity(value) {
-    __privateSet$3(this, _velocity, roundTo(value, __privateGet$3(this, _precision)));
+    this.#velocity = roundTo(value, this.#precision);
   }
   get precision() {
-    return __privateGet$3(this, _precision);
+    return 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)));
+    this.#precision = value;
+    this.#restingMagnitude = 1 / 10 ** this.#precision;
+    this.#position = roundTo(this.#position, this.#precision);
+    this.#velocity = roundTo(this.#velocity, 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);
+    return Math.abs(this.#velocity) < this.#restingMagnitude && Math.abs(this.#position) < 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, _lazyPosition, _underdampedSolver, _criticallyDampedSolver, _overdampedSolver, _currentSolver, _needsUpdate, _needsReset, _emitter, _updateSolver, updateSolver_fn, _solver$1, _state2, _dampedFrequency, _t, _c1, _c2, _solver2, _state3, _t2, _c12, _c22, _solver3, _state4, _dampedFrequency2, _t3, _c13, _c23;
 class Solver {
+  #mass;
+  #tension;
+  #damping;
+  #state;
+  #underdampedSolver = null;
+  #criticallyDampedSolver = null;
+  #overdampedSolver = null;
+  #currentSolver;
+  #needsUpdate = false;
+  #needsReset = false;
+  #emitter;
   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, _lazyPosition, 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, _needsUpdate, false);
-    __privateAdd$2(this, _needsReset, 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(
+    this.#mass = options.mass;
+    this.#tension = options.tension;
+    this.#damping = options.damping;
+    this.#state = new State(
       options.position,
       options.velocity,
       options.precision
-    ));
-    __privateSet$2(this, _lazyPosition, options.position);
-    __privateSet$2(this, _emitter, new Emitter());
-    __privateMethod(this, _updateSolver, updateSolver_fn).call(this);
+    );
+    this.#emitter = new Emitter();
+    this.#updateSolver();
   }
   get mass() {
-    return __privateGet$2(this, _mass);
+    return this.#mass;
   }
   set mass(value) {
-    __privateSet$2(this, _mass, value);
-    __privateSet$2(this, _needsUpdate, true);
+    this.#mass = value;
+    this.#needsUpdate = true;
   }
   get tension() {
-    return __privateGet$2(this, _tension);
+    return this.#tension;
   }
   set tension(value) {
-    __privateSet$2(this, _tension, value);
-    __privateSet$2(this, _needsUpdate, true);
+    this.#tension = value;
+    this.#needsUpdate = true;
   }
   get damping() {
-    return __privateGet$2(this, _damping);
+    return this.#damping;
   }
   set damping(value) {
-    __privateSet$2(this, _damping, value);
-    __privateSet$2(this, _needsUpdate, true);
+    this.#damping = value;
+    this.#needsUpdate = true;
   }
   get position() {
-    return __privateGet$2(this, _state).position;
+    return this.#state.position;
   }
   set position(value) {
-    __privateGet$2(this, _state).position = value;
-    __privateSet$2(this, _needsReset, true);
-    if (!__privateGet$2(this, _state).resting) {
-      __privateGet$2(this, _emitter).emit("start");
+    this.#state.position = value;
+    this.#needsReset = true;
+    if (!this.#state.resting) {
+      this.#emitter.emit("start");
     }
   }
-  get lazyPosition() {
-    return __privateGet$2(this, _lazyPosition);
-  }
   get velocity() {
-    return __privateGet$2(this, _state).velocity;
+    return this.#state.velocity;
   }
   set velocity(value) {
-    __privateGet$2(this, _state).velocity = value;
-    __privateSet$2(this, _needsReset, true);
+    this.#state.velocity = value;
+    this.#needsReset = true;
   }
   get precision() {
-    return __privateGet$2(this, _state).precision;
+    return this.#state.precision;
   }
   set precision(value) {
-    __privateGet$2(this, _state).precision = value;
+    this.#state.precision = value;
   }
   get resting() {
-    return __privateGet$2(this, _state).resting;
+    return this.#state.resting;
   }
   get naturalFrequency() {
-    return Math.sqrt(__privateGet$2(this, _tension) / __privateGet$2(this, _mass));
+    return Math.sqrt(this.#tension / this.#mass);
   }
   get criticalDamping() {
-    return 2 * __privateGet$2(this, _mass) * this.naturalFrequency;
+    return 2 * this.#mass * this.naturalFrequency;
   }
   get dampingRatio() {
-    return __privateGet$2(this, _damping) / this.criticalDamping;
+    return this.#damping / this.criticalDamping;
   }
   tick(dt, emit = true) {
-    if (__privateGet$2(this, _needsUpdate)) {
-      __privateMethod(this, _updateSolver, updateSolver_fn).call(this);
-      __privateSet$2(this, _needsUpdate, false);
+    if (this.#needsUpdate) {
+      this.#updateSolver();
+      this.#needsUpdate = false;
     }
-    if (__privateGet$2(this, _needsReset)) {
-      __privateGet$2(this, _currentSolver).reset();
-      __privateSet$2(this, _needsReset, false);
+    if (this.#needsReset) {
+      this.#currentSolver.reset();
+      this.#needsReset = false;
     }
-    __privateGet$2(this, _currentSolver).tick(dt);
-    __privateSet$2(this, _lazyPosition, __privateGet$2(this, _state).position);
+    this.#currentSolver.tick(dt);
     if (emit) {
-      __privateGet$2(this, _emitter).emit("update");
-      if (__privateGet$2(this, _state).resting) {
-        __privateGet$2(this, _emitter).emit("stop");
+      this.#emitter.emit("update");
+      if (this.#state.resting) {
+        this.#emitter.emit("stop");
       }
     }
   }
   onUpdate(callback) {
-    return __privateGet$2(this, _emitter).on("update", callback);
+    return this.#emitter.on("update", callback);
   }
   onStart(callback) {
-    return __privateGet$2(this, _emitter).on("start", callback);
+    return this.#emitter.on("start", callback);
   }
   onStop(callback) {
-    return __privateGet$2(this, _emitter).on("stop", callback);
+    return this.#emitter.on("stop", callback);
+  }
+  #updateSolver() {
+    if (this.dampingRatio < 1) {
+      this.#underdampedSolver ||= new UnderdampedSolver(this, this.#state);
+      this.#currentSolver = this.#underdampedSolver;
+    } else if (this.dampingRatio === 1) {
+      this.#criticallyDampedSolver ||= new CriticallyDampedSolver(
+        this,
+        this.#state
+      );
+      this.#currentSolver = this.#criticallyDampedSolver;
+    } else {
+      this.#overdampedSolver ||= new OverdampedSolver(this, this.#state);
+      this.#currentSolver = this.#overdampedSolver;
+    }
   }
 }
-_mass = new WeakMap();
-_tension = new WeakMap();
-_damping = new WeakMap();
-_state = new WeakMap();
-_lazyPosition = new WeakMap();
-_underdampedSolver = new WeakMap();
-_criticallyDampedSolver = new WeakMap();
-_overdampedSolver = new WeakMap();
-_currentSolver = new WeakMap();
-_needsUpdate = new WeakMap();
-_needsReset = 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 {
+  #solver;
+  #state;
+  #dampedFrequency;
+  #t = 0;
+  #c1 = 0;
+  #c2 = 0;
   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.#solver = solver;
+    this.#state = 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.#dampedFrequency = this.#solver.naturalFrequency * Math.sqrt(1 - this.#solver.dampingRatio ** 2);
+    this.#t = 0;
+    this.#c1 = this.#state.position;
+    this.#c2 = (this.#state.velocity + this.#solver.dampingRatio * this.#solver.naturalFrequency * this.#state.position) / 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));
+    this.#t += dt;
+    const sin = Math.sin(this.#dampedFrequency * this.#t);
+    const cos = Math.cos(this.#dampedFrequency * this.#t);
     const decay = Math.exp(
-      -__privateGet$2(this, _solver$1).dampingRatio * __privateGet$2(this, _solver$1).naturalFrequency * __privateGet$2(this, _t)
+      -this.#solver.dampingRatio * this.#solver.naturalFrequency * 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;
+    const decayVelocity = -this.#solver.dampingRatio * this.#solver.naturalFrequency * 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;
   }
 }
-_solver$1 = new WeakMap();
-_state2 = new WeakMap();
-_dampedFrequency = new WeakMap();
-_t = new WeakMap();
-_c1 = new WeakMap();
-_c2 = new WeakMap();
 class CriticallyDampedSolver {
+  #solver;
+  #state;
+  #t = 0;
+  #c1 = 0;
+  #c2 = 0;
   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.#solver = solver;
+    this.#state = 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.#t = 0;
+    this.#c1 = this.#state.position;
+    this.#c2 = this.#state.velocity + this.#solver.naturalFrequency * this.#state.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;
+    this.#t += dt;
+    const decay = Math.exp(-this.#solver.naturalFrequency * this.#t);
+    const decayVelocity = -this.#solver.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;
   }
 }
-_solver2 = new WeakMap();
-_state3 = new WeakMap();
-_t2 = new WeakMap();
-_c12 = new WeakMap();
-_c22 = new WeakMap();
 class OverdampedSolver {
+  #solver;
+  #state;
+  #dampedFrequency;
+  #t = 0;
+  #c1 = 0;
+  #c2 = 0;
   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.#solver = solver;
+    this.#state = 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));
+    this.#dampedFrequency = this.#solver.naturalFrequency * Math.sqrt(this.#solver.dampingRatio ** 2 - 1);
+    this.#t = 0;
+    this.#c1 = this.#state.velocity + this.#solver.dampingRatio * this.#solver.naturalFrequency * this.#state.position;
+    this.#c2 = this.#state.position * this.#dampedFrequency;
   }
   tick(dt) {
-    __privateSet$2(this, _t3, __privateGet$2(this, _t3) + dt);
+    this.#t += dt;
     const decay = Math.exp(
-      -__privateGet$2(this, _solver3).dampingRatio * __privateGet$2(this, _solver3).naturalFrequency * __privateGet$2(this, _t3)
+      -this.#solver.dampingRatio * this.#solver.naturalFrequency * this.#t
     );
-    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 decayVelocity = -this.#solver.dampingRatio * this.#solver.naturalFrequency * decay;
+    const clamped = Math.min(this.#dampedFrequency * this.#t, 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);
+    const scale = this.#c1 * sinh + this.#c2 * cosh;
+    const scaleVelocity = -this.#c1 * this.#dampedFrequency * sinh + this.#c2 * this.#dampedFrequency * cosh;
+    this.#state.position = scale * decay / this.#dampedFrequency;
+    this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / this.#dampedFrequency;
   }
 }
-_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;
 class Spring {
-  // #newTarget: number
+  #target;
+  #solver;
+  #scheduler;
   constructor(scheduler, options) {
-    __privateAdd$1(this, _target, void 0);
-    __privateAdd$1(this, _solver, void 0);
-    __privateAdd$1(this, _scheduler$1, void 0);
     invariant(options.mass > 0, "Mass must be greater than 0");
     invariant(options.tension > 0, "Tension must be greater than 0");
     invariant(
@@ -468,161 +331,133 @@ class Spring {
       options.precision === void 0 || options.precision > 0,
       "Precision must be greater than 0"
     );
-    __privateSet$1(this, _target, options.target);
-    __privateSet$1(this, _solver, new Solver({
+    this.#target = options.target ?? 0;
+    this.#solver = new Solver({
       mass: options.mass,
       tension: options.tension,
       damping: options.damping,
-      position: options.target + (options.value ?? 0),
+      position: this.#target + (options.value ?? 0),
       velocity: 0,
       precision: options.precision ?? 2
-    }));
-    __privateSet$1(this, _scheduler$1, scheduler);
-    if (!__privateGet$1(this, _solver).resting) {
-      __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    });
+    this.#scheduler = scheduler;
+    if (!this.#solver.resting) {
+      this.#scheduler.add(this.#solver);
     }
   }
   get target() {
-    return __privateGet$1(this, _target);
+    return this.#target;
   }
   set target(value) {
-    if (value !== __privateGet$1(this, _target)) {
-      if (__privateGet$1(this, _solver).position !== __privateGet$1(this, _solver).lazyPosition) {
-        __privateGet$1(this, _solver).tick(0);
-      }
-      if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
-        __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    if (value !== this.#target) {
+      if (!this.#scheduler.has(this.#solver)) {
+        this.#scheduler.add(this.#solver);
       }
       const currentValue = this.value;
-      __privateSet$1(this, _target, value);
-      __privateGet$1(this, _solver).position = currentValue - __privateGet$1(this, _target);
+      this.#target = value;
+      this.#solver.position = currentValue - this.#target;
+      this.#solver.tick(0);
     }
   }
   get value() {
-    return __privateGet$1(this, _target) + __privateGet$1(this, _solver).position;
+    return this.#target + this.#solver.position;
   }
   set value(value) {
-    const position = value - __privateGet$1(this, _target);
-    if (position !== __privateGet$1(this, _solver).position) {
-      if (__privateGet$1(this, _solver).position !== __privateGet$1(this, _solver).lazyPosition) {
-        __privateGet$1(this, _solver).tick(0);
-      }
-      if (!__privateGet$1(this, _scheduler$1).has(__privateGet$1(this, _solver))) {
-        __privateGet$1(this, _scheduler$1).add(__privateGet$1(this, _solver));
+    const position = value - this.#target;
+    if (position !== this.#solver.position) {
+      if (!this.#scheduler.has(this.#solver)) {
+        this.#scheduler.add(this.#solver);
       }
-      __privateGet$1(this, _solver).position = position;
+      this.#solver.position = position;
+      this.#solver.tick(0);
     }
   }
   get velocity() {
-    return __privateGet$1(this, _solver).velocity;
+    return 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));
+    if (!this.#scheduler.has(this.#solver)) {
+      this.#scheduler.add(this.#solver);
     }
-    __privateGet$1(this, _solver).velocity = value;
+    this.#solver.velocity = value;
   }
   get mass() {
-    return __privateGet$1(this, _solver).mass;
+    return 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));
+    if (!this.#scheduler.has(this.#solver)) {
+      this.#scheduler.add(this.#solver);
     }
-    __privateGet$1(this, _solver).mass = value;
+    this.#solver.mass = value;
   }
   get tension() {
-    return __privateGet$1(this, _solver).tension;
+    return 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));
+    if (!this.#scheduler.has(this.#solver)) {
+      this.#scheduler.add(this.#solver);
     }
-    __privateGet$1(this, _solver).tension = value;
+    this.#solver.tension = value;
   }
   get damping() {
-    return __privateGet$1(this, _solver).damping;
+    return 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));
+    if (!this.#scheduler.has(this.#solver)) {
+      this.#scheduler.add(this.#solver);
     }
-    __privateGet$1(this, _solver).damping = value;
+    this.#solver.damping = value;
   }
   get precision() {
-    return __privateGet$1(this, _solver).precision;
+    return 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));
+    if (!this.#scheduler.has(this.#solver)) {
+      this.#scheduler.add(this.#solver);
     }
-    __privateGet$1(this, _solver).precision = value;
+    this.#solver.precision = value;
   }
   get resting() {
-    return __privateGet$1(this, _solver).resting;
+    return this.#solver.resting;
   }
   onUpdate(callback) {
-    return __privateGet$1(this, _solver).onUpdate(callback);
+    return this.#solver.onUpdate(callback);
   }
   onStart(callback) {
-    return __privateGet$1(this, _solver).onStart(callback);
+    return this.#solver.onStart(callback);
   }
   onStop(callback) {
-    return __privateGet$1(this, _solver).onStop(callback);
+    return this.#solver.onStop(callback);
   }
   jumpTo(value) {
-    __privateSet$1(this, _target, value);
-    __privateGet$1(this, _solver).position = 0;
-    __privateGet$1(this, _solver).velocity = 0;
-    __privateGet$1(this, _solver).tick(0);
+    this.#target = value;
+    this.#solver.position = 0;
+    this.#solver.velocity = 0;
+    this.#solver.tick(0);
   }
 }
-_target = new WeakMap();
-_solver = new WeakMap();
-_scheduler$1 = 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 {
+class SpringSystemImpl {
+  #scheduler;
   constructor() {
-    __privateAdd(this, _scheduler, void 0);
-    __privateSet(this, _scheduler, new Scheduler());
+    this.#scheduler = new Scheduler();
   }
   createSpring(options) {
-    return new Spring(__privateGet(this, _scheduler), {
+    return new Spring(this.#scheduler, {
       ...options,
       target: options.target ?? 0
     });
   }
   tick(dt) {
-    __privateGet(this, _scheduler).tick(dt);
+    this.#scheduler.tick(dt);
   }
 }
-_scheduler = new WeakMap();
-
 function createSpringSystem() {
-  return new SpringSystem();
+  return new SpringSystemImpl();
 }
 
 export { createSpringSystem };