@sweberdev/lagrangian 0.1.0

package/dist/index.js

@@ -0,0 +1,1112 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value2) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value2);
+var __privateSet = (obj, member, value2, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value2) : member.set(obj, value2), value2);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/spring.ts
+function springParams(options = {}) {
+  const mass = options.mass ?? 1;
+  if (options.duration !== void 0 || options.bounce !== void 0) {
+    const duration = Math.max(options.duration ?? 0.5, 0.01);
+    const bounce = Math.min(Math.max(options.bounce ?? 0, -0.99), 1);
+    const omega = 2 * Math.PI / duration;
+    const zeta = bounce >= 0 ? 1 - bounce : 1 / (1 + bounce);
+    return { stiffness: mass * omega * omega, damping: 2 * mass * zeta * omega, mass };
+  }
+  return { stiffness: options.stiffness ?? 170, damping: options.damping ?? 26, mass };
+}
+function dampingRatio(options = {}) {
+  const { stiffness, damping, mass } = springParams(options);
+  return damping / (2 * Math.sqrt(stiffness * mass));
+}
+function restThresholds(from, to, options = {}) {
+  const span = Math.max(Math.abs(to - from), Math.abs(to) * 0.01, 1e-3);
+  const restDelta = options.restDelta ?? Math.min(Math.max(span * 1e-3, 1e-4), 0.5);
+  return { restDelta, restSpeed: options.restSpeed ?? restDelta * 10 };
+}
+function spring(from, to, velocity = 0, options = {}) {
+  const { stiffness: k, damping: c, mass: m } = springParams(options);
+  const { restDelta, restSpeed } = restThresholds(from, to, options);
+  const d0 = from - to;
+  const v0 = velocity;
+  const w0 = Math.sqrt(k / m);
+  const zeta = c / (2 * Math.sqrt(k * m));
+  let displacement;
+  if (zeta < 1 - 1e-6) {
+    const a = zeta * w0;
+    const wd = w0 * Math.sqrt(1 - zeta * zeta);
+    const B = (v0 + a * d0) / wd;
+    displacement = (t) => {
+      const e = Math.exp(-a * t);
+      const cos = Math.cos(wd * t);
+      const sin = Math.sin(wd * t);
+      return [e * (d0 * cos + B * sin), e * ((B * wd - a * d0) * cos - (a * B + d0 * wd) * sin)];
+    };
+  } else if (zeta <= 1 + 1e-6) {
+    const B = v0 + w0 * d0;
+    displacement = (t) => {
+      const e = Math.exp(-w0 * t);
+      return [e * (d0 + B * t), e * (v0 - w0 * B * t)];
+    };
+  } else {
+    const s = Math.sqrt(zeta * zeta - 1);
+    const r1 = -w0 * (zeta - s);
+    const r2 = -w0 * (zeta + s);
+    const c1 = (v0 - r2 * d0) / (r1 - r2);
+    const c2 = d0 - c1;
+    displacement = (t) => {
+      const e1 = Math.exp(r1 * t);
+      const e2 = Math.exp(r2 * t);
+      return [c1 * e1 + c2 * e2, c1 * r1 * e1 + c2 * r2 * e2];
+    };
+  }
+  return (t) => {
+    const [x, v] = displacement(Math.max(t, 0));
+    if (Math.abs(x) <= restDelta && Math.abs(v) <= restSpeed) {
+      return { value: to, velocity: 0, done: true };
+    }
+    return { value: to + x, velocity: v, done: false };
+  };
+}
+function settleTime(motion, limit = 30) {
+  for (let t = 0; t <= limit; t += 1 / 1e3) {
+    if (motion(t).done) return t;
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function restValue(motion, limit = 30) {
+  for (let t = 0; t <= limit; t += 1 / 60) {
+    const state = motion(t);
+    if (state.done) return state.value;
+  }
+  return motion(limit).value;
+}
+
+// src/decay.ts
+var EDGE_SPRING = { stiffness: 400, damping: 40 };
+function timeConstant(deceleration = 0.998) {
+  const rate = Math.min(Math.max(deceleration, 0.5), 0.99999);
+  return -1 / (1e3 * Math.log(rate));
+}
+function projectRest(from, velocity, deceleration = 0.998) {
+  return from + velocity * timeConstant(deceleration);
+}
+function nearest(points, value2) {
+  let best = value2;
+  let distance = Number.POSITIVE_INFINITY;
+  for (const point of points) {
+    const d = Math.abs(point - value2);
+    if (d < distance) {
+      distance = d;
+      best = point;
+    }
+  }
+  return best;
+}
+function resolveSnap(snap, value2) {
+  return typeof snap === "function" ? snap(value2) : nearest(snap, value2);
+}
+function friction(from, v0, tau, end, restDelta) {
+  return (t) => {
+    const e = Math.exp(-Math.max(t, 0) / tau);
+    const value2 = from + v0 * tau * (1 - e);
+    const velocity = v0 * e;
+    if (Math.abs(end - value2) <= restDelta) return { value: end, velocity: 0, done: true };
+    return { value: value2, velocity, done: false };
+  };
+}
+function decay(from, options = {}) {
+  const v0 = options.velocity ?? 0;
+  const tau = timeConstant(options.deceleration);
+  const restDelta = options.restDelta ?? 0.5;
+  const min = options.min ?? Number.NEGATIVE_INFINITY;
+  const max = options.max ?? Number.POSITIVE_INFINITY;
+  const edge = { ...EDGE_SPRING, restDelta, ...options.bounce };
+  const clamp = (x) => Math.min(Math.max(x, min), max);
+  if (from < min || from > max) return spring(from, clamp(from), v0, edge);
+  const natural = from + v0 * tau;
+  if (options.snap !== void 0) {
+    const target = clamp(resolveSnap(options.snap, natural));
+    const distance = target - from;
+    const fitted = v0 !== 0 ? distance / v0 : -1;
+    if (fitted > tau / 4 && fitted < tau * 4) return friction(from, v0, fitted, target, restDelta);
+    return spring(from, target, v0, { ...edge, ...options.bounce });
+  }
+  if (natural >= min && natural <= max) return friction(from, v0, tau, natural, restDelta);
+  const bound = natural < min ? min : max;
+  const crossing = -tau * Math.log(1 - (bound - from) / (v0 * tau));
+  const glide = friction(from, v0, tau, natural, 0);
+  const vAtEdge = v0 * Math.exp(-crossing / tau);
+  const catcher = spring(bound, bound, vAtEdge, edge);
+  return (t) => t < crossing ? glide(t) : catcher(t - crossing);
+}
+function rubberband(distance, dimension, constant = 0.55) {
+  if (dimension <= 0 || constant <= 0) return 0;
+  const sign = Math.sign(distance);
+  const d = Math.abs(distance);
+  return sign * (1 - 1 / (d * constant / dimension + 1)) * dimension;
+}
+function rubberClamp(value2, min, max, dimension, constant = 0.55) {
+  if (value2 < min) return min + rubberband(value2 - min, dimension, constant);
+  if (value2 > max) return max + rubberband(value2 - max, dimension, constant);
+  return value2;
+}
+
+// src/loop.ts
+var MAX_DT = 1 / 20;
+var tasks = /* @__PURE__ */ new Set();
+var scheduled = false;
+var manual = false;
+var last = -1;
+var clock = 0;
+var hasRaf = () => typeof requestAnimationFrame === "function";
+function schedule() {
+  if (scheduled || manual || tasks.size === 0) return;
+  scheduled = true;
+  if (hasRaf()) requestAnimationFrame(frame);
+  else setTimeout(() => frame(now()), 16);
+}
+function frame(time) {
+  scheduled = false;
+  if (manual) return;
+  const dt = last < 0 ? 1 / 60 : Math.min(Math.max((time - last) / 1e3, 0), MAX_DT);
+  last = time;
+  run(dt, time);
+  if (tasks.size > 0) schedule();
+  else last = -1;
+}
+function run(dt, time) {
+  for (const task of [...tasks]) {
+    if (tasks.has(task)) task(dt, time);
+  }
+}
+function now() {
+  if (manual) return clock;
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+var loop = {
+  /** Runs `task` on every frame until the returned function is called. */
+  add(task) {
+    tasks.add(task);
+    schedule();
+    return () => {
+      tasks.delete(task);
+    };
+  },
+  /**
+   * Switches to manual stepping (for tests, server rendering or video export) or back to
+   * requestAnimationFrame.
+   */
+  manual(on = true) {
+    manual = on;
+    last = -1;
+    if (!on) schedule();
+  },
+  /** Advances the manual clock by `ms` and runs one frame. Only has an effect in manual mode. */
+  step(ms = 1e3 / 60) {
+    if (!manual) return;
+    clock += ms;
+    run(Math.min(ms / 1e3, MAX_DT), clock);
+  },
+  /** Number of running tasks. */
+  get size() {
+    return tasks.size;
+  }
+};
+
+// src/reduced-motion.ts
+var mode = "user";
+function setReducedMotion(value2) {
+  mode = value2;
+}
+function reducedMotion() {
+  if (mode !== "user") return mode === "always";
+  return typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+
+// src/velocity.ts
+var WINDOW = 100;
+var STALE = 60;
+var _samples;
+var VelocityTracker = class {
+  constructor() {
+    __privateAdd(this, _samples, []);
+  }
+  /** Adds a sample: `time` in milliseconds, `value` in any unit. */
+  add(time, value2) {
+    const samples = __privateGet(this, _samples);
+    const last2 = samples[samples.length - 1];
+    if (last2 && time <= last2.t) {
+      last2.x = value2;
+      return;
+    }
+    samples.push({ t: time, x: value2 });
+    while (samples.length > 2 && samples[0].t < time - WINDOW) samples.shift();
+  }
+  /** Velocity in units per second at `time` (ms). 0 when the pointer has been resting. */
+  velocity(time) {
+    const samples = __privateGet(this, _samples);
+    const last2 = samples[samples.length - 1];
+    if (!last2 || samples.length < 2) return 0;
+    if (time !== void 0 && time - last2.t > STALE) return 0;
+    const recent = samples.filter((s) => s.t >= last2.t - WINDOW);
+    if (recent.length < 2) return 0;
+    let mt = 0;
+    let mx = 0;
+    for (const s of recent) {
+      mt += s.t;
+      mx += s.x;
+    }
+    mt /= recent.length;
+    mx /= recent.length;
+    let num = 0;
+    let den = 0;
+    for (const s of recent) {
+      num += (s.t - mt) * (s.x - mx);
+      den += (s.t - mt) * (s.t - mt);
+    }
+    return den === 0 ? 0 : num / den * 1e3;
+  }
+  reset() {
+    __privateSet(this, _samples, []);
+  }
+};
+_samples = new WeakMap();
+
+// src/value.ts
+function settled(value2) {
+  const finished = Promise.resolve(value2);
+  return { finished, stop() {
+  } };
+}
+var _value, _velocity, _tracked, _listeners, _tracker, _cancel, _resolve, _PhysicsValue_instances, emit_fn, halt_fn;
+var PhysicsValue = class {
+  constructor(initial2 = 0) {
+    __privateAdd(this, _PhysicsValue_instances);
+    __privateAdd(this, _value);
+    __privateAdd(this, _velocity, 0);
+    __privateAdd(this, _tracked, false);
+    __privateAdd(this, _listeners, /* @__PURE__ */ new Set());
+    __privateAdd(this, _tracker, new VelocityTracker());
+    __privateAdd(this, _cancel, null);
+    __privateAdd(this, _resolve, null);
+    __privateSet(this, _value, initial2);
+  }
+  get() {
+    return __privateGet(this, _value);
+  }
+  /** Units per second, from the running motion or from recent `set` calls. */
+  get velocity() {
+    return __privateGet(this, _tracked) ? __privateGet(this, _tracker).velocity(now()) : __privateGet(this, _velocity);
+  }
+  get animating() {
+    return __privateGet(this, _cancel) !== null;
+  }
+  /** Sets the value directly (e.g. while dragging). Stops any motion and tracks the velocity. */
+  set(value2) {
+    __privateMethod(this, _PhysicsValue_instances, halt_fn).call(this, false);
+    __privateSet(this, _tracked, true);
+    __privateGet(this, _tracker).add(now(), value2);
+    __privateSet(this, _velocity, __privateGet(this, _tracker).velocity());
+    __privateMethod(this, _PhysicsValue_instances, emit_fn).call(this, value2);
+  }
+  /** Sets the value and drops all momentum. */
+  jump(value2) {
+    __privateMethod(this, _PhysicsValue_instances, halt_fn).call(this, false);
+    __privateGet(this, _tracker).reset();
+    __privateSet(this, _tracked, false);
+    __privateSet(this, _velocity, 0);
+    __privateMethod(this, _PhysicsValue_instances, emit_fn).call(this, value2);
+  }
+  /** Springs to `target`, starting from the current position and velocity. */
+  to(target, options = {}) {
+    const from = __privateGet(this, _value);
+    return this.start(spring(from, target, options.velocity ?? this.velocity, options));
+  }
+  /** Throws the value with friction, optionally into bounds or onto snap points. */
+  throw(options = {}) {
+    return this.start(
+      decay(__privateGet(this, _value), { ...options, velocity: options.velocity ?? this.velocity })
+    );
+  }
+  /** Runs any motion. Elapsed time starts at 0 on the next frame. */
+  start(motion) {
+    __privateMethod(this, _PhysicsValue_instances, halt_fn).call(this, false);
+    if (reducedMotion()) {
+      this.jump(restValue(motion));
+      return settled(true);
+    }
+    let elapsed = 0;
+    let resolve;
+    const finished = new Promise((r) => {
+      resolve = r;
+    });
+    __privateSet(this, _resolve, resolve);
+    const remove = loop.add((dt) => {
+      elapsed += dt;
+      const state = motion(elapsed);
+      __privateSet(this, _velocity, state.velocity);
+      __privateMethod(this, _PhysicsValue_instances, emit_fn).call(this, state.value);
+      if (state.done) __privateMethod(this, _PhysicsValue_instances, halt_fn).call(this, true);
+    });
+    __privateSet(this, _cancel, remove);
+    __privateSet(this, _tracked, false);
+    __privateGet(this, _tracker).reset();
+    return {
+      finished,
+      stop: () => {
+        if (__privateGet(this, _resolve) === resolve) __privateMethod(this, _PhysicsValue_instances, halt_fn).call(this, false);
+      }
+    };
+  }
+  /** Stops where it is. The velocity is kept, so a following `to` or `throw` continues it. */
+  stop() {
+    __privateMethod(this, _PhysicsValue_instances, halt_fn).call(this, false);
+  }
+  /** Calls `listener` on every change. Returns the unsubscribe function. */
+  on(listener) {
+    __privateGet(this, _listeners).add(listener);
+    return () => {
+      __privateGet(this, _listeners).delete(listener);
+    };
+  }
+};
+_value = new WeakMap();
+_velocity = new WeakMap();
+_tracked = new WeakMap();
+_listeners = new WeakMap();
+_tracker = new WeakMap();
+_cancel = new WeakMap();
+_resolve = new WeakMap();
+_PhysicsValue_instances = new WeakSet();
+emit_fn = function(value2) {
+  __privateSet(this, _value, value2);
+  for (const listener of [...__privateGet(this, _listeners)]) listener(value2, __privateGet(this, _velocity));
+};
+halt_fn = function(completed) {
+  const cancel = __privateGet(this, _cancel);
+  const resolve = __privateGet(this, _resolve);
+  __privateSet(this, _cancel, null);
+  __privateSet(this, _resolve, null);
+  if (cancel) {
+    cancel();
+    if (completed) __privateSet(this, _velocity, 0);
+  }
+  resolve?.(completed);
+};
+function value(initial2 = 0) {
+  return new PhysicsValue(initial2);
+}
+
+// src/animate.ts
+var TRANSFORMS = ["x", "y", "z", "rotate", "scale", "scaleX", "scaleY"];
+var registry = /* @__PURE__ */ new WeakMap();
+function initial(element, prop) {
+  if (prop === "scale" || prop === "scaleX" || prop === "scaleY") return 1;
+  if (prop === "opacity") {
+    const style = element.style;
+    const inline = style ? Number.parseFloat(style.opacity) : Number.NaN;
+    if (!Number.isNaN(inline)) return inline;
+    if (typeof getComputedStyle !== "function") return 1;
+    const computed = Number.parseFloat(getComputedStyle(element).opacity);
+    return Number.isNaN(computed) ? 1 : computed;
+  }
+  if (prop.startsWith("--") && typeof getComputedStyle === "function") {
+    const computed = Number.parseFloat(getComputedStyle(element).getPropertyValue(prop));
+    return Number.isNaN(computed) ? 0 : computed;
+  }
+  return 0;
+}
+function render(element, values) {
+  const style = element.style;
+  if (!style) return;
+  const get = (prop) => values.get(prop)?.get();
+  const parts = [];
+  const x = get("x");
+  const y = get("y");
+  const z = get("z");
+  if (x !== void 0 || y !== void 0 || z !== void 0) {
+    parts.push(`translate3d(${x ?? 0}px, ${y ?? 0}px, ${z ?? 0}px)`);
+  }
+  const rotate = get("rotate");
+  if (rotate !== void 0) parts.push(`rotate(${rotate}deg)`);
+  const scale = get("scale");
+  if (scale !== void 0) parts.push(`scale(${scale})`);
+  const scaleX = get("scaleX");
+  if (scaleX !== void 0) parts.push(`scaleX(${scaleX})`);
+  const scaleY = get("scaleY");
+  if (scaleY !== void 0) parts.push(`scaleY(${scaleY})`);
+  if (TRANSFORMS.some((prop) => values.has(prop))) style.transform = parts.join(" ");
+  const opacity = values.get("opacity");
+  if (opacity) style.opacity = String(Math.min(Math.max(opacity.get(), 0), 1));
+  for (const [prop, value2] of values) {
+    if (prop.startsWith("--")) style.setProperty(prop, String(value2.get()));
+  }
+}
+function getValue(element, prop) {
+  let values = registry.get(element);
+  if (!values) {
+    values = /* @__PURE__ */ new Map();
+    registry.set(element, values);
+  }
+  let v = values.get(prop);
+  if (!v) {
+    const map = values;
+    v = new PhysicsValue(initial(element, prop));
+    let queued = false;
+    v.on(() => {
+      if (queued) return;
+      queued = true;
+      queueMicrotask(() => {
+        queued = false;
+        render(element, map);
+      });
+    });
+    values.set(prop, v);
+  }
+  return v;
+}
+function elements(target) {
+  if (typeof target === "string") {
+    return typeof document === "undefined" ? [] : [...document.querySelectorAll(target)];
+  }
+  if (typeof Element !== "undefined" && target instanceof Element) return [target];
+  return Array.from(target);
+}
+function group(animations) {
+  const finished = Promise.all(animations.map((a) => a.finished)).then((all) => all.every(Boolean));
+  return {
+    finished,
+    stop: () => {
+      for (const a of animations) a.stop();
+    }
+  };
+}
+function delayed(seconds, start) {
+  if (seconds <= 0) return start();
+  let inner = null;
+  let stopped = false;
+  let resolve;
+  const finished = new Promise((r) => {
+    resolve = r;
+  });
+  const timer = setTimeout(() => {
+    if (stopped) return;
+    inner = start();
+    inner.finished.then(resolve);
+  }, seconds * 1e3);
+  return {
+    finished,
+    stop: () => {
+      stopped = true;
+      clearTimeout(timer);
+      if (inner) inner.stop();
+      else resolve(false);
+    }
+  };
+}
+function animate(target, props, options = {}) {
+  const { velocity, delay = 0, stagger = 0, ...spring2 } = options;
+  const animations = elements(target).map(
+    (element, index) => delayed(
+      delay + index * stagger,
+      () => group(
+        Object.keys(props).map(
+          (prop) => getValue(element, prop).to(props[prop], {
+            ...spring2,
+            ...velocity?.[prop] !== void 0 ? { velocity: velocity[prop] } : {}
+          })
+        )
+      )
+    )
+  );
+  return group(animations);
+}
+function set(target, props) {
+  for (const element of elements(target)) {
+    for (const prop of Object.keys(props)) {
+      getValue(element, prop).jump(props[prop]);
+    }
+  }
+}
+
+// src/drag.ts
+var FREE = [Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY];
+function ranges(element, x, y, bounds) {
+  const b = typeof bounds === "function" ? bounds() : bounds;
+  if (!b) return { x: FREE, y: FREE };
+  if (typeof Element !== "undefined" && b instanceof Element) {
+    const outer = b.getBoundingClientRect();
+    const inner = element.getBoundingClientRect();
+    const left = inner.left - x;
+    const top = inner.top - y;
+    return {
+      x: [outer.left - left, outer.right - left - inner.width],
+      y: [outer.top - top, outer.bottom - top - inner.height]
+    };
+  }
+  const box = b;
+  return {
+    x: [box.left ?? FREE[0], box.right ?? FREE[1]],
+    y: [box.top ?? FREE[0], box.bottom ?? FREE[1]]
+  };
+}
+function draggable(element, options = {}) {
+  const axis = options.axis ?? "both";
+  const x = getValue(element, "x");
+  const y = getValue(element, "y");
+  const moveX = axis !== "y";
+  const moveY = axis !== "x";
+  let pointer = null;
+  let start = { px: 0, py: 0, x: 0, y: 0 };
+  let range = { x: FREE, y: FREE };
+  const info = () => ({
+    x: x.get(),
+    y: y.get(),
+    velocityX: x.velocity,
+    velocityY: y.velocity
+  });
+  const previousTouchAction = element.style.touchAction;
+  element.style.touchAction = axis === "x" ? "pan-y" : axis === "y" ? "pan-x" : "none";
+  const place = (value2, [min, max], dimension) => {
+    if (options.rubberband === false) return Math.min(Math.max(value2, min), max);
+    return rubberClamp(value2, min, max, dimension, options.rubberband ?? 0.55);
+  };
+  const down = (event) => {
+    if (pointer !== null || event.pointerType === "mouse" && event.button !== 0) return;
+    pointer = event.pointerId;
+    element.setPointerCapture?.(event.pointerId);
+    x.stop();
+    y.stop();
+    start = { px: event.clientX, py: event.clientY, x: x.get(), y: y.get() };
+    range = ranges(element, start.x, start.y, options.bounds);
+    x.jump(start.x);
+    y.jump(start.y);
+    if (moveX) x.set(start.x);
+    if (moveY) y.set(start.y);
+    options.onStart?.(info());
+  };
+  const move = (event) => {
+    if (event.pointerId !== pointer) return;
+    const viewport = typeof window !== "undefined" ? window : { innerWidth: 1e3, innerHeight: 1e3 };
+    if (moveX) x.set(place(start.x + event.clientX - start.px, range.x, viewport.innerWidth));
+    if (moveY) y.set(place(start.y + event.clientY - start.py, range.y, viewport.innerHeight));
+    options.onMove?.(info());
+  };
+  const release = (value2, [min, max], snap) => {
+    const throwOptions = {
+      min,
+      max,
+      bounce: options.spring,
+      ...options.deceleration !== void 0 ? { deceleration: options.deceleration } : {},
+      ...snap !== void 0 ? { snap } : {}
+    };
+    if (options.inertia !== false) {
+      value2.throw(throwOptions);
+      return;
+    }
+    value2.throw({ ...throwOptions, velocity: 0 });
+  };
+  const up = (event) => {
+    if (event.pointerId !== pointer) return;
+    pointer = null;
+    element.releasePointerCapture?.(event.pointerId);
+    options.onEnd?.(info());
+    if (moveX) release(x, range.x, options.snap?.x);
+    if (moveY) release(y, range.y, options.snap?.y);
+  };
+  element.addEventListener("pointerdown", down);
+  element.addEventListener("pointermove", move);
+  element.addEventListener("pointerup", up);
+  element.addEventListener("pointercancel", up);
+  return {
+    x,
+    y,
+    get dragging() {
+      return pointer !== null;
+    },
+    destroy() {
+      element.removeEventListener("pointerdown", down);
+      element.removeEventListener("pointermove", move);
+      element.removeEventListener("pointerup", up);
+      element.removeEventListener("pointercancel", up);
+      element.style.touchAction = previousTouchAction;
+    }
+  };
+}
+
+// src/integrate.ts
+function rk4(state, t, dt, f) {
+  const n = state.length;
+  const add = (k, h) => state.map((s, i) => s + (k[i] ?? 0) * h);
+  const k1 = f(state, t);
+  const k2 = f(add(k1, dt / 2), t + dt / 2);
+  const k3 = f(add(k2, dt / 2), t + dt / 2);
+  const k4 = f(add(k3, dt), t + dt);
+  const next = new Array(n);
+  for (let i = 0; i < n; i++) {
+    next[i] = (state[i] ?? 0) + dt / 6 * ((k1[i] ?? 0) + 2 * (k2[i] ?? 0) + 2 * (k3[i] ?? 0) + (k4[i] ?? 0));
+  }
+  return next;
+}
+function system(f, initial2, step = 1 / 240) {
+  let state = [...initial2];
+  let time = 0;
+  let pending = 0;
+  return {
+    get state() {
+      return state;
+    },
+    get time() {
+      return time;
+    },
+    advance(seconds) {
+      pending += seconds;
+      while (pending >= step) {
+        state = rk4(state, time, step, f);
+        time += step;
+        pending -= step;
+      }
+      return state;
+    },
+    reset(next) {
+      state = [...next];
+      pending = 0;
+    }
+  };
+}
+
+// src/world.ts
+var SLEEP_DISTANCE = 1;
+var SLEEP_TIME = 1;
+var _rate, _options, _container, _grabs, _stopLoop, _pending, _still, _snapshot, _observer, _running, _World_instances, frame_fn, moved_fn, draw_fn, spring_fn, contact_fn, walls_fn;
+var World = class {
+  constructor(options = {}) {
+    __privateAdd(this, _World_instances);
+    this.bodies = [];
+    this.links = [];
+    this.bounds = null;
+    __privateAdd(this, _rate);
+    __privateAdd(this, _options);
+    __privateAdd(this, _container, null);
+    __privateAdd(this, _grabs, /* @__PURE__ */ new Set());
+    __privateAdd(this, _stopLoop, null);
+    __privateAdd(this, _pending, 0);
+    __privateAdd(this, _still, 0);
+    __privateAdd(this, _snapshot, []);
+    __privateAdd(this, _observer, null);
+    __privateAdd(this, _running, false);
+    __privateSet(this, _options, options);
+    this.gravity = options.gravity ?? { x: 0, y: 9.81 };
+    this.pixelsPerMeter = options.pixelsPerMeter ?? 500;
+    this.airDrag = options.airDrag ?? 0.05;
+    this.rollingResistance = options.rollingResistance ?? 0.05;
+    this.iterations = options.iterations ?? 4;
+    __privateSet(this, _rate, options.rate ?? 240);
+    this.setBounds(options.bounds ?? null);
+  }
+  /** Sets the walls. With an element, they follow its size. */
+  setBounds(bounds) {
+    __privateGet(this, _observer)?.disconnect();
+    __privateSet(this, _observer, null);
+    __privateSet(this, _container, null);
+    if (bounds && typeof HTMLElement !== "undefined" && bounds instanceof HTMLElement) {
+      __privateSet(this, _container, bounds);
+      const read = () => {
+        this.bounds = { left: 0, top: 0, right: bounds.clientWidth, bottom: bounds.clientHeight };
+        this.wake();
+      };
+      read();
+      if (typeof ResizeObserver === "function") {
+        __privateSet(this, _observer, new ResizeObserver(read));
+        __privateGet(this, _observer).observe(bounds);
+      }
+    } else {
+      this.bounds = bounds ?? null;
+      this.wake();
+    }
+  }
+  add(options) {
+    const ppm = this.pixelsPerMeter;
+    const r = options.radius;
+    const area = Math.PI * (r / ppm) ** 2;
+    const mass = options.fixed ? Number.POSITIVE_INFINITY : options.mass ?? area * (options.density ?? 1);
+    const body = {
+      x: options.x,
+      y: options.y,
+      vx: options.vx ?? 0,
+      vy: options.vy ?? 0,
+      angle: options.angle ?? 0,
+      spin: options.spin ?? 0,
+      radius: r,
+      mass,
+      restitution: options.restitution ?? 0.5,
+      friction: options.friction ?? 0.4,
+      fixed: options.fixed ?? false,
+      element: options.element ?? null,
+      invMass: options.fixed ? 0 : 1 / mass,
+      // Solid disc: I = ½·m·r², here with r in pixels so impulses stay in pixel units.
+      invInertia: options.fixed ? 0 : 2 / (mass * r * r)
+    };
+    this.bodies.push(body);
+    __privateMethod(this, _World_instances, draw_fn).call(this, body);
+    this.wake();
+    return body;
+  }
+  remove(body) {
+    const index = this.bodies.indexOf(body);
+    if (index >= 0) this.bodies.splice(index, 1);
+    for (let i = this.links.length - 1; i >= 0; i--) {
+      const link = this.links[i];
+      if (link.a === body || link.b === body) this.links.splice(i, 1);
+    }
+    for (const grab of __privateGet(this, _grabs)) if (grab.body === body) __privateGet(this, _grabs).delete(grab);
+  }
+  /** Connects two bodies with a damped spring. */
+  link(a, b, options = {}) {
+    const link = {
+      a,
+      b,
+      length: options.length ?? Math.hypot(b.x - a.x, b.y - a.y),
+      frequency: options.frequency ?? 4,
+      damping: options.damping ?? 0.3
+    };
+    this.links.push(link);
+    this.wake();
+    return link;
+  }
+  unlink(link) {
+    const index = this.links.indexOf(link);
+    if (index >= 0) this.links.splice(index, 1);
+  }
+  /** Body under a point, if any. */
+  bodyAt(x, y) {
+    for (let i = this.bodies.length - 1; i >= 0; i--) {
+      const body = this.bodies[i];
+      if ((body.x - x) ** 2 + (body.y - y) ** 2 <= body.radius ** 2) return body;
+    }
+    return null;
+  }
+  /** Pulls a body towards a moving point with a stiff spring. Released bodies keep their speed. */
+  grab(body, x, y) {
+    const grab = { body, target: { x, y } };
+    __privateGet(this, _grabs).add(grab);
+    this.wake();
+    return {
+      move: (nx, ny) => {
+        grab.target = { x: nx, y: ny };
+        this.wake();
+      },
+      release: () => {
+        __privateGet(this, _grabs).delete(grab);
+      }
+    };
+  }
+  /** Adds an impulse in kg·px/s at the centre (or `at` a point on the body for spin). */
+  push(body, impulse, at) {
+    body.vx += impulse.x * body.invMass;
+    body.vy += impulse.y * body.invMass;
+    if (at)
+      body.spin += ((at.x - body.x) * impulse.y - (at.y - body.y) * impulse.x) * body.invInertia;
+    this.wake();
+  }
+  /**
+   * Lets the pointer grab and throw bodies inside `element` (default: the bounds element).
+   * Returns a function that removes the listeners.
+   */
+  bindPointer(element = __privateGet(this, _container)) {
+    if (!element) return () => {
+    };
+    const active = /* @__PURE__ */ new Map();
+    const local = (event) => {
+      const rect = element.getBoundingClientRect();
+      return { x: event.clientX - rect.left, y: event.clientY - rect.top };
+    };
+    const down = (event) => {
+      const p = local(event);
+      const body = this.bodyAt(p.x, p.y);
+      if (!body || body.fixed) return;
+      event.preventDefault();
+      element.setPointerCapture?.(event.pointerId);
+      active.set(event.pointerId, this.grab(body, p.x, p.y));
+    };
+    const move = (event) => {
+      const grab = active.get(event.pointerId);
+      if (!grab) return;
+      const p = local(event);
+      grab.move(p.x, p.y);
+    };
+    const up = (event) => {
+      active.get(event.pointerId)?.release();
+      active.delete(event.pointerId);
+    };
+    const touchAction = element.style.touchAction;
+    element.style.touchAction = "none";
+    element.addEventListener("pointerdown", down);
+    element.addEventListener("pointermove", move);
+    element.addEventListener("pointerup", up);
+    element.addEventListener("pointercancel", up);
+    return () => {
+      for (const grab of active.values()) grab.release();
+      element.style.touchAction = touchAction;
+      element.removeEventListener("pointerdown", down);
+      element.removeEventListener("pointermove", move);
+      element.removeEventListener("pointerup", up);
+      element.removeEventListener("pointercancel", up);
+    };
+  }
+  /** Starts the simulation on the shared frame loop. */
+  start() {
+    __privateSet(this, _running, true);
+    this.wake();
+    return this;
+  }
+  /** Pauses the simulation. */
+  stop() {
+    var _a;
+    __privateSet(this, _running, false);
+    (_a = __privateGet(this, _stopLoop)) == null ? void 0 : _a.call(this);
+    __privateSet(this, _stopLoop, null);
+    return this;
+  }
+  /** True while the world runs and something moves. A resting world uses no CPU. */
+  get awake() {
+    return __privateGet(this, _stopLoop) !== null;
+  }
+  /** Resumes a resting world, e.g. after you changed bodies by hand. */
+  wake() {
+    __privateSet(this, _still, 0);
+    __privateSet(this, _snapshot, []);
+    if (!__privateGet(this, _running) || __privateGet(this, _stopLoop)) return;
+    __privateSet(this, _stopLoop, loop.add((dt) => __privateMethod(this, _World_instances, frame_fn).call(this, dt)));
+  }
+  destroy() {
+    this.stop();
+    __privateGet(this, _observer)?.disconnect();
+    this.bodies.length = 0;
+    this.links.length = 0;
+    __privateGet(this, _grabs).clear();
+  }
+  /** Advances the simulation by `dt` seconds. Called for you while the world runs. */
+  step(dt) {
+    const ppm = this.pixelsPerMeter;
+    const gx = this.gravity.x * ppm;
+    const gy = this.gravity.y * ppm;
+    const drag = Math.exp(-this.airDrag * dt);
+    for (const body of this.bodies) {
+      if (body.fixed) continue;
+      body.vx = (body.vx + gx * dt) * drag;
+      body.vy = (body.vy + gy * dt) * drag;
+      body.spin *= drag;
+    }
+    for (const link of this.links) __privateMethod(this, _World_instances, spring_fn).call(this, link, dt);
+    for (const { body, target } of __privateGet(this, _grabs)) {
+      const w = 2 * Math.PI * 8;
+      const k = w * w;
+      const c = 2 * w;
+      const den = 1 + dt * c + dt * dt * k;
+      body.vx = (body.vx + dt * k * (target.x - body.x)) / den;
+      body.vy = (body.vy + dt * k * (target.y - body.y)) / den;
+      body.spin *= 0.9;
+    }
+    for (const body of this.bodies) {
+      if (body.fixed) continue;
+      body.x += body.vx * dt;
+      body.y += body.vy * dt;
+      body.angle += body.spin * dt;
+    }
+    const bodies = [...this.bodies].sort((a, b) => a.x - a.radius - (b.x - b.radius));
+    const restingSpeed = 0.5 * ppm;
+    for (let pass = 0; pass < this.iterations; pass++) {
+      for (let i = 0; i < bodies.length; i++) {
+        const a = bodies[i];
+        for (let j = i + 1; j < bodies.length; j++) {
+          const b = bodies[j];
+          if (b.x - b.radius > a.x + a.radius) break;
+          const dx = b.x - a.x;
+          const dy = b.y - a.y;
+          const sum = a.radius + b.radius;
+          const d2 = dx * dx + dy * dy;
+          if (d2 >= sum * sum) continue;
+          const d = Math.sqrt(d2);
+          const nx = d > 1e-9 ? dx / d : 1;
+          const ny = d > 1e-9 ? dy / d : 0;
+          __privateMethod(this, _World_instances, contact_fn).call(this, a, b, nx, ny, sum - d, restingSpeed, pass === 0);
+        }
+        if (this.bounds && !a.fixed) __privateMethod(this, _World_instances, walls_fn).call(this, a, this.bounds, restingSpeed, pass === 0);
+      }
+    }
+  }
+};
+_rate = new WeakMap();
+_options = new WeakMap();
+_container = new WeakMap();
+_grabs = new WeakMap();
+_stopLoop = new WeakMap();
+_pending = new WeakMap();
+_still = new WeakMap();
+_snapshot = new WeakMap();
+_observer = new WeakMap();
+_running = new WeakMap();
+_World_instances = new WeakSet();
+frame_fn = function(dt) {
+  var _a;
+  const h = 1 / __privateGet(this, _rate);
+  __privateSet(this, _pending, Math.min(__privateGet(this, _pending) + dt, h * 32));
+  while (__privateGet(this, _pending) >= h) {
+    this.step(h);
+    __privateSet(this, _pending, __privateGet(this, _pending) - h);
+  }
+  for (const body of this.bodies) __privateMethod(this, _World_instances, draw_fn).call(this, body);
+  __privateGet(this, _options).onFrame?.(this);
+  if (__privateGet(this, _grabs).size > 0 || __privateMethod(this, _World_instances, moved_fn).call(this)) {
+    __privateSet(this, _still, 0);
+    __privateSet(this, _snapshot, this.bodies.map((b) => [b.x, b.y, b.angle * b.radius]));
+  } else {
+    __privateSet(this, _still, __privateGet(this, _still) + dt);
+  }
+  if (__privateGet(this, _still) >= SLEEP_TIME) {
+    (_a = __privateGet(this, _stopLoop)) == null ? void 0 : _a.call(this);
+    __privateSet(this, _stopLoop, null);
+  }
+};
+moved_fn = function() {
+  const snapshot = __privateGet(this, _snapshot);
+  if (snapshot.length !== this.bodies.length) return true;
+  return this.bodies.some((b, i) => {
+    const [x, y, arc] = snapshot[i];
+    return Math.abs(b.x - x) > SLEEP_DISTANCE || Math.abs(b.y - y) > SLEEP_DISTANCE || Math.abs(b.angle * b.radius - arc) > SLEEP_DISTANCE;
+  });
+};
+draw_fn = function(body) {
+  const el = body.element;
+  if (!el) return;
+  const r = body.radius;
+  el.style.transform = `translate3d(${body.x - r}px, ${body.y - r}px, 0) rotate(${body.angle}rad)`;
+};
+spring_fn = function(link, dt) {
+  const { a, b } = link;
+  const inv = a.invMass + b.invMass;
+  if (inv === 0) return;
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const d = Math.hypot(dx, dy) || 1e-9;
+  const nx = dx / d;
+  const ny = dy / d;
+  const m = 1 / inv;
+  const w = 2 * Math.PI * link.frequency;
+  const k = m * w * w;
+  const c = 2 * m * link.damping * w;
+  const vn = (b.vx - a.vx) * nx + (b.vy - a.vy) * ny;
+  const force = -k * (d - link.length) - c * vn;
+  const j = force * dt;
+  a.vx -= j * nx * a.invMass;
+  a.vy -= j * ny * a.invMass;
+  b.vx += j * nx * b.invMass;
+  b.vy += j * ny * b.invMass;
+};
+// Resolves one contact. n points from a to b; a may be a wall (null).
+contact_fn = function(a, b, nx, ny, depth, restingSpeed, report) {
+  const ima = a ? a.invMass : 0;
+  const imb = b.invMass;
+  const inv = ima + imb;
+  if (inv === 0) return;
+  const correction = Math.max(depth - 0.01, 0) / inv;
+  if (a) {
+    a.x -= nx * correction * ima;
+    a.y -= ny * correction * ima;
+  }
+  b.x += nx * correction * imb;
+  b.y += ny * correction * imb;
+  const ra = a ? a.radius : 0;
+  const rb = b.radius;
+  const iia = a ? a.invInertia : 0;
+  const iib = b.invInertia;
+  const tx = -ny;
+  const ty = nx;
+  const relative = () => {
+    const vax = a ? a.vx - a.spin * ra * ny : 0;
+    const vay = a ? a.vy + a.spin * ra * nx : 0;
+    const vbx = b.vx + b.spin * rb * ny;
+    const vby = b.vy - b.spin * rb * nx;
+    return { x: vbx - vax, y: vby - vay };
+  };
+  let rv = relative();
+  const vn = rv.x * nx + rv.y * ny;
+  if (vn >= 0) return;
+  const e = -vn < restingSpeed ? 0 : Math.min(a ? a.restitution : 1, b.restitution);
+  const jn = -(1 + e) * vn / inv;
+  if (a) {
+    a.vx -= jn * nx * ima;
+    a.vy -= jn * ny * ima;
+  }
+  b.vx += jn * nx * imb;
+  b.vy += jn * ny * imb;
+  if (report && -vn > restingSpeed) __privateGet(this, _options).onCollide?.(b, a, -vn);
+  rv = relative();
+  const vt = rv.x * tx + rv.y * ty;
+  const kt = inv + ra * ra * iia + rb * rb * iib;
+  const mu = Math.sqrt((a ? a.friction : 1) * b.friction);
+  const jt = Math.max(Math.min(-vt / kt, mu * jn), -mu * jn);
+  if (a) {
+    a.vx -= jt * tx * ima;
+    a.vy -= jt * ty * ima;
+    a.spin -= jt * ra * iia;
+  }
+  b.vx += jt * tx * imb;
+  b.vy += jt * ty * imb;
+  b.spin -= jt * rb * iib;
+  const brake = (body, r) => {
+    const limit = this.rollingResistance * jn * r * body.invInertia;
+    body.spin = Math.abs(body.spin) <= limit ? 0 : body.spin - Math.sign(body.spin) * limit;
+  };
+  if (a) brake(a, ra);
+  brake(b, rb);
+};
+walls_fn = function(body, walls, restingSpeed, report) {
+  const r = body.radius;
+  if (body.y + r > walls.bottom)
+    __privateMethod(this, _World_instances, contact_fn).call(this, null, body, 0, -1, body.y + r - walls.bottom, restingSpeed, report);
+  if (body.y - r < walls.top)
+    __privateMethod(this, _World_instances, contact_fn).call(this, null, body, 0, 1, walls.top - (body.y - r), restingSpeed, report);
+  if (body.x - r < walls.left)
+    __privateMethod(this, _World_instances, contact_fn).call(this, null, body, 1, 0, walls.left - (body.x - r), restingSpeed, report);
+  if (body.x + r > walls.right)
+    __privateMethod(this, _World_instances, contact_fn).call(this, null, body, -1, 0, body.x + r - walls.right, restingSpeed, report);
+};
+function world(options = {}) {
+  return new World(options);
+}
+export {
+  PhysicsValue,
+  VelocityTracker,
+  World,
+  animate,
+  dampingRatio,
+  decay,
+  draggable,
+  getValue,
+  loop,
+  nearest,
+  now,
+  projectRest,
+  reducedMotion,
+  restValue,
+  rk4,
+  rubberClamp,
+  rubberband,
+  set,
+  setReducedMotion,
+  settleTime,
+  spring,
+  springParams,
+  system,
+  timeConstant,
+  value,
+  world
+};
+//# sourceMappingURL=index.js.map