tekiyo-physics 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1916 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+class Vector2 {
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+  static zero() {
+    return new Vector2(0, 0);
+  }
+  static from(x, y) {
+    return new Vector2(x, y);
+  }
+  static fromObject(obj) {
+    return new Vector2(obj.x, obj.y);
+  }
+  add(other) {
+    return new Vector2(this.x + other.x, this.y + other.y);
+  }
+  subtract(other) {
+    return new Vector2(this.x - other.x, this.y - other.y);
+  }
+  multiply(scalar) {
+    return new Vector2(this.x * scalar, this.y * scalar);
+  }
+  divide(scalar) {
+    if (scalar === 0) return Vector2.zero();
+    return new Vector2(this.x / scalar, this.y / scalar);
+  }
+  get magnitude() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  get magnitudeSquared() {
+    return this.x * this.x + this.y * this.y;
+  }
+  normalize() {
+    const mag = this.magnitude;
+    if (mag === 0) return Vector2.zero();
+    return this.divide(mag);
+  }
+  clamp(maxMagnitude) {
+    const mag = this.magnitude;
+    if (mag <= maxMagnitude) return this;
+    return this.normalize().multiply(maxMagnitude);
+  }
+  clampComponents(min, max) {
+    return new Vector2(
+      Math.max(min.x, Math.min(max.x, this.x)),
+      Math.max(min.y, Math.min(max.y, this.y))
+    );
+  }
+  lerp(target, t) {
+    return new Vector2(
+      this.x + (target.x - this.x) * t,
+      this.y + (target.y - this.y) * t
+    );
+  }
+  dot(other) {
+    return this.x * other.x + this.y * other.y;
+  }
+  distanceTo(other) {
+    return this.subtract(other).magnitude;
+  }
+  equals(other, epsilon = 1e-4) {
+    return Math.abs(this.x - other.x) < epsilon && Math.abs(this.y - other.y) < epsilon;
+  }
+  isZero(epsilon = 1e-4) {
+    return this.magnitude < epsilon;
+  }
+  negate() {
+    return new Vector2(-this.x, -this.y);
+  }
+  abs() {
+    return new Vector2(Math.abs(this.x), Math.abs(this.y));
+  }
+  toObject() {
+    return { x: this.x, y: this.y };
+  }
+}
+const DEFAULT_SPRING_CONFIG = {
+  tension: 170,
+  friction: 26,
+  mass: 1,
+  precision: 0.01
+};
+class Spring {
+  constructor(initialPosition = Vector2.zero(), config = {}) {
+    __publicField(this, "position");
+    __publicField(this, "velocity");
+    __publicField(this, "target");
+    __publicField(this, "config");
+    this.position = initialPosition;
+    this.velocity = Vector2.zero();
+    this.target = initialPosition;
+    this.config = { ...DEFAULT_SPRING_CONFIG, ...config };
+  }
+  setTarget(target) {
+    this.target = target;
+  }
+  setPosition(position) {
+    this.position = position;
+  }
+  setVelocity(velocity) {
+    this.velocity = velocity;
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Advance the spring simulation by deltaTime seconds
+   * Uses semi-implicit Euler for stability
+   */
+  step(deltaTime) {
+    const { tension, friction, mass, precision } = this.config;
+    const displacement = this.position.subtract(this.target);
+    const springForce = displacement.multiply(-tension);
+    const dampingForce = this.velocity.multiply(-friction);
+    const totalForce = springForce.add(dampingForce);
+    const acceleration = totalForce.divide(mass);
+    this.velocity = this.velocity.add(acceleration.multiply(deltaTime));
+    this.position = this.position.add(this.velocity.multiply(deltaTime));
+    const isSettled = displacement.magnitude < precision && this.velocity.magnitude < precision;
+    if (isSettled) {
+      this.position = this.target;
+      this.velocity = Vector2.zero();
+    }
+    return {
+      position: this.position,
+      velocity: this.velocity,
+      target: this.target,
+      isSettled
+    };
+  }
+  getState() {
+    const displacement = this.position.subtract(this.target);
+    return {
+      position: this.position,
+      velocity: this.velocity,
+      target: this.target,
+      isSettled: displacement.magnitude < this.config.precision && this.velocity.magnitude < this.config.precision
+    };
+  }
+  /**
+   * Immediately snap to target
+   */
+  snapToTarget() {
+    this.position = this.target;
+    this.velocity = Vector2.zero();
+  }
+}
+class Spring1D {
+  constructor(initialValue = 0, config = {}) {
+    __publicField(this, "position");
+    __publicField(this, "velocity");
+    __publicField(this, "target");
+    __publicField(this, "config");
+    this.position = initialValue;
+    this.velocity = 0;
+    this.target = initialValue;
+    this.config = { ...DEFAULT_SPRING_CONFIG, ...config };
+  }
+  setTarget(target) {
+    this.target = target;
+  }
+  setPosition(position) {
+    this.position = position;
+  }
+  setVelocity(velocity) {
+    this.velocity = velocity;
+  }
+  step(deltaTime) {
+    const { tension, friction, mass, precision } = this.config;
+    const displacement = this.position - this.target;
+    const springForce = -tension * displacement;
+    const dampingForce = -friction * this.velocity;
+    const acceleration = (springForce + dampingForce) / mass;
+    this.velocity += acceleration * deltaTime;
+    this.position += this.velocity * deltaTime;
+    const isSettled = Math.abs(displacement) < precision && Math.abs(this.velocity) < precision;
+    if (isSettled) {
+      this.position = this.target;
+      this.velocity = 0;
+    }
+    return {
+      value: this.position,
+      velocity: this.velocity,
+      isSettled
+    };
+  }
+  getValue() {
+    return this.position;
+  }
+  snapToTarget() {
+    this.position = this.target;
+    this.velocity = 0;
+  }
+}
+class VelocityTracker {
+  constructor(maxSamples = 8, maxAge = 100) {
+    __publicField(this, "samples", []);
+    __publicField(this, "maxSamples");
+    __publicField(this, "maxAge");
+    this.maxSamples = maxSamples;
+    this.maxAge = maxAge;
+  }
+  /**
+   * Record a position sample
+   */
+  addSample(position, timestamp = performance.now()) {
+    this.samples.push({ position, timestamp });
+    if (this.samples.length > this.maxSamples) {
+      this.samples.shift();
+    }
+  }
+  /**
+   * Calculate current velocity from sample history
+   * Returns smoothed velocity vector in pixels per second
+   */
+  getVelocity() {
+    const now = performance.now();
+    this.samples = this.samples.filter(
+      (sample) => now - sample.timestamp < this.maxAge
+    );
+    if (this.samples.length < 2) {
+      return Vector2.zero();
+    }
+    let totalWeight = 0;
+    let weightedVelocity = Vector2.zero();
+    for (let i = 1; i < this.samples.length; i++) {
+      const prev = this.samples[i - 1];
+      const curr = this.samples[i];
+      const dt = (curr.timestamp - prev.timestamp) / 1e3;
+      if (dt <= 0) continue;
+      const instantVelocity = curr.position.subtract(prev.position).divide(dt);
+      const age = now - curr.timestamp;
+      const weight = Math.exp(-age / this.maxAge);
+      weightedVelocity = weightedVelocity.add(instantVelocity.multiply(weight));
+      totalWeight += weight;
+    }
+    if (totalWeight === 0) {
+      return Vector2.zero();
+    }
+    return weightedVelocity.divide(totalWeight);
+  }
+  /**
+   * Get velocity magnitude in pixels per second
+   */
+  getSpeed() {
+    return this.getVelocity().magnitude;
+  }
+  /**
+   * Check if current velocity qualifies as a flick gesture
+   */
+  isFlick(threshold = 500) {
+    return this.getSpeed() > threshold;
+  }
+  /**
+   * Get dominant direction of movement
+   */
+  getDirection() {
+    const velocity = this.getVelocity();
+    const speed = velocity.magnitude;
+    if (speed < 10) return "none";
+    if (Math.abs(velocity.x) > Math.abs(velocity.y)) {
+      return velocity.x > 0 ? "right" : "left";
+    } else {
+      return velocity.y > 0 ? "down" : "up";
+    }
+  }
+  /**
+   * Clear all samples
+   */
+  reset() {
+    this.samples = [];
+  }
+  /**
+   * Get the last recorded position
+   */
+  getLastPosition() {
+    if (this.samples.length === 0) return null;
+    return this.samples[this.samples.length - 1].position;
+  }
+}
+class VelocityTracker1D {
+  constructor(maxSamples = 8, maxAge = 100) {
+    __publicField(this, "samples", []);
+    __publicField(this, "maxSamples");
+    __publicField(this, "maxAge");
+    this.maxSamples = maxSamples;
+    this.maxAge = maxAge;
+  }
+  addSample(value, timestamp = performance.now()) {
+    this.samples.push({ value, timestamp });
+    if (this.samples.length > this.maxSamples) {
+      this.samples.shift();
+    }
+  }
+  getVelocity() {
+    const now = performance.now();
+    this.samples = this.samples.filter((s) => now - s.timestamp < this.maxAge);
+    if (this.samples.length < 2) return 0;
+    let totalWeight = 0;
+    let weightedVelocity = 0;
+    for (let i = 1; i < this.samples.length; i++) {
+      const prev = this.samples[i - 1];
+      const curr = this.samples[i];
+      const dt = (curr.timestamp - prev.timestamp) / 1e3;
+      if (dt <= 0) continue;
+      const instantVelocity = (curr.value - prev.value) / dt;
+      const age = now - curr.timestamp;
+      const weight = Math.exp(-age / this.maxAge);
+      weightedVelocity += instantVelocity * weight;
+      totalWeight += weight;
+    }
+    return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
+  }
+  reset() {
+    this.samples = [];
+  }
+}
+const DEFAULT_FRICTION_CONFIG = {
+  decay: 0.95,
+  stopThreshold: 0.1,
+  maxVelocity: 2e3
+};
+class Momentum {
+  constructor(initialPosition = Vector2.zero(), config = {}) {
+    __publicField(this, "position");
+    __publicField(this, "velocity");
+    __publicField(this, "config");
+    __publicField(this, "isActive", false);
+    this.position = initialPosition;
+    this.velocity = Vector2.zero();
+    this.config = { ...DEFAULT_FRICTION_CONFIG, ...config };
+  }
+  /**
+   * Start momentum with initial velocity
+   */
+  start(position, velocity) {
+    this.position = position;
+    this.velocity = velocity.clamp(this.config.maxVelocity);
+    this.isActive = true;
+  }
+  /**
+   * Stop momentum immediately
+   */
+  stop() {
+    this.velocity = Vector2.zero();
+    this.isActive = false;
+  }
+  /**
+   * Update momentum simulation
+   * @param deltaTime Time in seconds
+   */
+  step(deltaTime) {
+    if (!this.isActive) {
+      return {
+        position: this.position,
+        velocity: Vector2.zero(),
+        isActive: false
+      };
+    }
+    this.position = this.position.add(this.velocity.multiply(deltaTime));
+    const frameDecay = Math.pow(this.config.decay, deltaTime * 60);
+    this.velocity = this.velocity.multiply(frameDecay);
+    if (this.velocity.magnitude < this.config.stopThreshold) {
+      this.velocity = Vector2.zero();
+      this.isActive = false;
+    }
+    return {
+      position: this.position,
+      velocity: this.velocity,
+      isActive: this.isActive
+    };
+  }
+  /**
+   * Apply rubber band effect at boundaries
+   */
+  applyRubberBand(bounds, rubberBandFactor = 0.55) {
+    let newX = this.position.x;
+    let newY = this.position.y;
+    if (this.position.x < bounds.min.x) {
+      const overshoot = bounds.min.x - this.position.x;
+      newX = bounds.min.x - overshoot * rubberBandFactor;
+    } else if (this.position.x > bounds.max.x) {
+      const overshoot = this.position.x - bounds.max.x;
+      newX = bounds.max.x + overshoot * rubberBandFactor;
+    }
+    if (this.position.y < bounds.min.y) {
+      const overshoot = bounds.min.y - this.position.y;
+      newY = bounds.min.y - overshoot * rubberBandFactor;
+    } else if (this.position.y > bounds.max.y) {
+      const overshoot = this.position.y - bounds.max.y;
+      newY = bounds.max.y + overshoot * rubberBandFactor;
+    }
+    this.position = new Vector2(newX, newY);
+  }
+  getPosition() {
+    return this.position;
+  }
+  getVelocity() {
+    return this.velocity;
+  }
+  getIsActive() {
+    return this.isActive;
+  }
+  setPosition(position) {
+    this.position = position;
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+}
+class Momentum1D {
+  constructor(initialPosition = 0, config = {}) {
+    __publicField(this, "position");
+    __publicField(this, "velocity");
+    __publicField(this, "config");
+    __publicField(this, "isActive", false);
+    this.position = initialPosition;
+    this.velocity = 0;
+    this.config = { ...DEFAULT_FRICTION_CONFIG, ...config };
+  }
+  start(position, velocity) {
+    this.position = position;
+    this.velocity = Math.sign(velocity) * Math.min(Math.abs(velocity), this.config.maxVelocity);
+    this.isActive = true;
+  }
+  stop() {
+    this.velocity = 0;
+    this.isActive = false;
+  }
+  step(deltaTime) {
+    if (!this.isActive) {
+      return { position: this.position, velocity: 0, isActive: false };
+    }
+    this.position += this.velocity * deltaTime;
+    const frameDecay = Math.pow(this.config.decay, deltaTime * 60);
+    this.velocity *= frameDecay;
+    if (Math.abs(this.velocity) < this.config.stopThreshold) {
+      this.velocity = 0;
+      this.isActive = false;
+    }
+    return {
+      position: this.position,
+      velocity: this.velocity,
+      isActive: this.isActive
+    };
+  }
+  getPosition() {
+    return this.position;
+  }
+  setPosition(position) {
+    this.position = position;
+  }
+}
+class PhysicsEngineCore {
+  constructor() {
+    __publicField(this, "bodies", /* @__PURE__ */ new Map());
+    __publicField(this, "rafId", null);
+    __publicField(this, "lastTime", 0);
+    __publicField(this, "isRunning", false);
+    // Cap deltaTime to prevent spiral of death (max ~30fps frame time)
+    __publicField(this, "maxDelta", 1 / 30);
+    /**
+     * Main RAF loop
+     */
+    __publicField(this, "loop", () => {
+      if (!this.isRunning) return;
+      const currentTime = performance.now();
+      let deltaTime = (currentTime - this.lastTime) / 1e3;
+      this.lastTime = currentTime;
+      deltaTime = Math.min(deltaTime, this.maxDelta);
+      const sortedBodies = Array.from(this.bodies.values()).sort(
+        (a, b) => b.priority - a.priority
+      );
+      for (const body of sortedBodies) {
+        body.update(deltaTime);
+      }
+      this.rafId = requestAnimationFrame(this.loop);
+    });
+  }
+  /**
+   * Register a physics body to receive updates
+   */
+  register(id, update, priority = 0) {
+    this.bodies.set(id, { id, update, priority });
+    this.start();
+  }
+  /**
+   * Unregister a physics body
+   */
+  unregister(id) {
+    this.bodies.delete(id);
+    if (this.bodies.size === 0) {
+      this.stop();
+    }
+  }
+  /**
+   * Check if a body is registered
+   */
+  has(id) {
+    return this.bodies.has(id);
+  }
+  /**
+   * Start the physics loop
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.lastTime = performance.now();
+    this.loop();
+  }
+  /**
+   * Stop the physics loop
+   */
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+  }
+  /**
+   * Get current number of active bodies
+   */
+  getActiveCount() {
+    return this.bodies.size;
+  }
+  /**
+   * Check if engine is running
+   */
+  getIsRunning() {
+    return this.isRunning;
+  }
+}
+const PhysicsEngine = new PhysicsEngineCore();
+let idCounter = 0;
+function generatePhysicsId(prefix = "physics") {
+  return `${prefix}_${++idCounter}_${Date.now().toString(36)}`;
+}
+const ios = {
+  name: "ios",
+  description: "iOS-like smooth, natural feel",
+  spring: {
+    tension: 170,
+    friction: 26,
+    mass: 1,
+    precision: 0.01
+  },
+  friction: {
+    decay: 0.95,
+    stopThreshold: 0.1,
+    maxVelocity: 2e3
+  },
+  stretch: {
+    intensity: 0.08,
+    maxVelocity: 1500
+  },
+  lift: {
+    scale: 1.02,
+    shadowIntensity: 0.8
+  }
+};
+const snappy = {
+  name: "snappy",
+  description: "Ultra-responsive, instant feedback",
+  spring: {
+    tension: 400,
+    friction: 30,
+    mass: 0.8,
+    precision: 0.01
+  },
+  friction: {
+    decay: 0.92,
+    stopThreshold: 0.5,
+    maxVelocity: 3e3
+  },
+  stretch: {
+    intensity: 0.06,
+    maxVelocity: 2e3
+  },
+  lift: {
+    scale: 1.015,
+    shadowIntensity: 0.6
+  }
+};
+const smooth = {
+  name: "smooth",
+  description: "Slow, luxurious, elegant motion",
+  spring: {
+    tension: 120,
+    friction: 20,
+    mass: 1.5,
+    precision: 5e-3
+  },
+  friction: {
+    decay: 0.97,
+    stopThreshold: 0.05,
+    maxVelocity: 1500
+  },
+  stretch: {
+    intensity: 0.1,
+    maxVelocity: 1200
+  },
+  lift: {
+    scale: 1.04,
+    shadowIntensity: 1.2
+  }
+};
+const stiff = {
+  name: "stiff",
+  description: "Direct, precise, no overshoot",
+  spring: {
+    tension: 300,
+    friction: 35,
+    mass: 1,
+    precision: 0.01
+  },
+  friction: {
+    decay: 0.9,
+    stopThreshold: 0.2,
+    maxVelocity: 2500
+  },
+  stretch: {
+    intensity: 0.04,
+    maxVelocity: 2500
+  },
+  lift: {
+    scale: 1.01,
+    shadowIntensity: 0.5
+  }
+};
+const gentle = {
+  name: "gentle",
+  description: "Soft, forgiving, approachable",
+  spring: {
+    tension: 150,
+    friction: 22,
+    mass: 1.2,
+    precision: 0.01
+  },
+  friction: {
+    decay: 0.96,
+    stopThreshold: 0.1,
+    maxVelocity: 1800
+  },
+  stretch: {
+    intensity: 0.12,
+    maxVelocity: 1400
+  },
+  lift: {
+    scale: 1.03,
+    shadowIntensity: 1
+  }
+};
+const presets = {
+  ios,
+  snappy,
+  smooth,
+  stiff,
+  gentle
+};
+function getPreset(name) {
+  return presets[name];
+}
+function getSpringConfig(preset) {
+  var _a;
+  if (typeof preset === "string") {
+    return ((_a = presets[preset]) == null ? void 0 : _a.spring) ?? ios.spring;
+  }
+  return preset;
+}
+function getFrictionConfig(preset) {
+  var _a;
+  if (typeof preset === "string") {
+    return ((_a = presets[preset]) == null ? void 0 : _a.friction) ?? ios.friction;
+  }
+  return preset;
+}
+const defaultContext = {
+  spring: DEFAULT_SPRING_CONFIG,
+  friction: DEFAULT_FRICTION_CONFIG,
+  stretch: {
+    intensity: 0.12,
+    maxVelocity: 2e3
+  },
+  lift: {
+    scale: 1.03,
+    shadowIntensity: 1
+  }
+};
+const PhysicsContext = react.createContext(defaultContext);
+function PhysicsProvider({
+  children,
+  preset = "ios",
+  spring,
+  friction,
+  stretch,
+  lift
+}) {
+  const value = react.useMemo(() => {
+    const basePreset = typeof preset === "string" ? presets[preset] ?? ios : preset;
+    return {
+      spring: { ...basePreset.spring, ...spring },
+      friction: { ...basePreset.friction, ...friction },
+      stretch: { ...basePreset.stretch, ...stretch },
+      lift: { ...basePreset.lift, ...lift }
+    };
+  }, [preset, spring, friction, stretch, lift]);
+  return /* @__PURE__ */ jsxRuntime.jsx(PhysicsContext.Provider, { value, children });
+}
+function usePhysicsContext() {
+  return react.useContext(PhysicsContext);
+}
+function usePhysicsConfig() {
+  const context = react.useContext(PhysicsContext);
+  return context.spring;
+}
+function useFrictionConfig() {
+  const context = react.useContext(PhysicsContext);
+  return context.friction;
+}
+function useStretchConfig() {
+  const context = react.useContext(PhysicsContext);
+  return context.stretch;
+}
+function useLiftConfig() {
+  const context = react.useContext(PhysicsContext);
+  return context.lift;
+}
+function useSpring(options) {
+  const { to, from, config, onRest, immediate = true } = options;
+  const globalConfig = usePhysicsConfig();
+  const resolvedConfig = react.useMemo(() => {
+    if (!config) return { ...DEFAULT_SPRING_CONFIG, ...globalConfig };
+    if (typeof config === "string") {
+      return { ...DEFAULT_SPRING_CONFIG, ...globalConfig };
+    }
+    return { ...DEFAULT_SPRING_CONFIG, ...globalConfig, ...config };
+  }, [config, globalConfig]);
+  const springRef = react.useRef(null);
+  const idRef = react.useRef(generatePhysicsId("spring"));
+  const onRestRef = react.useRef(onRest);
+  onRestRef.current = onRest;
+  const [state, setState] = react.useState({
+    x: (from == null ? void 0 : from.x) ?? to.x,
+    y: (from == null ? void 0 : from.y) ?? to.y,
+    isAnimating: false,
+    isSettled: true
+  });
+  react.useEffect(() => {
+    const initialPos = from ? Vector2.from(from.x, from.y) : Vector2.from(to.x, to.y);
+    springRef.current = new Spring(initialPos, resolvedConfig);
+    if (immediate) {
+      springRef.current.setTarget(Vector2.from(to.x, to.y));
+    }
+    return () => {
+      PhysicsEngine.unregister(idRef.current);
+    };
+  }, []);
+  react.useEffect(() => {
+    if (springRef.current && immediate) {
+      springRef.current.setTarget(Vector2.from(to.x, to.y));
+      if (!PhysicsEngine.has(idRef.current)) {
+        PhysicsEngine.register(idRef.current, (deltaTime) => {
+          var _a;
+          if (!springRef.current) return;
+          const result = springRef.current.step(deltaTime);
+          setState({
+            x: result.position.x,
+            y: result.position.y,
+            isAnimating: !result.isSettled,
+            isSettled: result.isSettled
+          });
+          if (result.isSettled) {
+            PhysicsEngine.unregister(idRef.current);
+            (_a = onRestRef.current) == null ? void 0 : _a.call(onRestRef);
+          }
+        });
+      }
+    }
+  }, [to.x, to.y, immediate]);
+  react.useEffect(() => {
+    var _a;
+    (_a = springRef.current) == null ? void 0 : _a.updateConfig(resolvedConfig);
+  }, [resolvedConfig]);
+  const setTarget = react.useCallback((target) => {
+    if (!springRef.current) return;
+    springRef.current.setTarget(Vector2.from(target.x, target.y));
+    if (!PhysicsEngine.has(idRef.current)) {
+      PhysicsEngine.register(idRef.current, (deltaTime) => {
+        var _a;
+        if (!springRef.current) return;
+        const result = springRef.current.step(deltaTime);
+        setState({
+          x: result.position.x,
+          y: result.position.y,
+          isAnimating: !result.isSettled,
+          isSettled: result.isSettled
+        });
+        if (result.isSettled) {
+          PhysicsEngine.unregister(idRef.current);
+          (_a = onRestRef.current) == null ? void 0 : _a.call(onRestRef);
+        }
+      });
+    }
+  }, []);
+  const snapTo = react.useCallback((position) => {
+    if (!springRef.current) return;
+    springRef.current.setPosition(Vector2.from(position.x, position.y));
+    springRef.current.setTarget(Vector2.from(position.x, position.y));
+    springRef.current.snapToTarget();
+    setState({
+      x: position.x,
+      y: position.y,
+      isAnimating: false,
+      isSettled: true
+    });
+    PhysicsEngine.unregister(idRef.current);
+  }, []);
+  const impulse = react.useCallback((velocity) => {
+    if (!springRef.current) return;
+    const currentState = springRef.current.getState();
+    springRef.current.setVelocity(
+      currentState.velocity.add(Vector2.from(velocity.x, velocity.y))
+    );
+    if (!PhysicsEngine.has(idRef.current)) {
+      PhysicsEngine.register(idRef.current, (deltaTime) => {
+        var _a;
+        if (!springRef.current) return;
+        const result = springRef.current.step(deltaTime);
+        setState({
+          x: result.position.x,
+          y: result.position.y,
+          isAnimating: !result.isSettled,
+          isSettled: result.isSettled
+        });
+        if (result.isSettled) {
+          PhysicsEngine.unregister(idRef.current);
+          (_a = onRestRef.current) == null ? void 0 : _a.call(onRestRef);
+        }
+      });
+    }
+  }, []);
+  const style = react.useMemo(
+    () => ({
+      transform: `translate3d(${state.x}px, ${state.y}px, 0)`,
+      willChange: state.isAnimating ? "transform" : "auto"
+    }),
+    [state.x, state.y, state.isAnimating]
+  );
+  return {
+    x: state.x,
+    y: state.y,
+    style,
+    isAnimating: state.isAnimating,
+    isSettled: state.isSettled,
+    setTarget,
+    snapTo,
+    impulse
+  };
+}
+function useSpring1D(options) {
+  const { to, from, config, onRest, immediate = true } = options;
+  const globalConfig = usePhysicsConfig();
+  const resolvedConfig = react.useMemo(
+    () => ({ ...DEFAULT_SPRING_CONFIG, ...globalConfig, ...config }),
+    [config, globalConfig]
+  );
+  const springRef = react.useRef(null);
+  const idRef = react.useRef(generatePhysicsId("spring1d"));
+  const onRestRef = react.useRef(onRest);
+  onRestRef.current = onRest;
+  const [state, setState] = react.useState({
+    value: from ?? to,
+    isAnimating: false,
+    isSettled: true
+  });
+  react.useEffect(() => {
+    springRef.current = new Spring1D(from ?? to, resolvedConfig);
+    if (immediate) {
+      springRef.current.setTarget(to);
+    }
+    return () => {
+      PhysicsEngine.unregister(idRef.current);
+    };
+  }, []);
+  react.useEffect(() => {
+    if (springRef.current && immediate) {
+      springRef.current.setTarget(to);
+      if (!PhysicsEngine.has(idRef.current)) {
+        PhysicsEngine.register(idRef.current, (deltaTime) => {
+          var _a;
+          if (!springRef.current) return;
+          const result = springRef.current.step(deltaTime);
+          setState({
+            value: result.value,
+            isAnimating: !result.isSettled,
+            isSettled: result.isSettled
+          });
+          if (result.isSettled) {
+            PhysicsEngine.unregister(idRef.current);
+            (_a = onRestRef.current) == null ? void 0 : _a.call(onRestRef);
+          }
+        });
+      }
+    }
+  }, [to, immediate]);
+  const setTarget = react.useCallback((target) => {
+    if (!springRef.current) return;
+    springRef.current.setTarget(target);
+    if (!PhysicsEngine.has(idRef.current)) {
+      PhysicsEngine.register(idRef.current, (deltaTime) => {
+        var _a;
+        if (!springRef.current) return;
+        const result = springRef.current.step(deltaTime);
+        setState({
+          value: result.value,
+          isAnimating: !result.isSettled,
+          isSettled: result.isSettled
+        });
+        if (result.isSettled) {
+          PhysicsEngine.unregister(idRef.current);
+          (_a = onRestRef.current) == null ? void 0 : _a.call(onRestRef);
+        }
+      });
+    }
+  }, []);
+  return {
+    value: state.value,
+    isAnimating: state.isAnimating,
+    isSettled: state.isSettled,
+    setTarget
+  };
+}
+function useGesture(options) {
+  const {
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    onFlick,
+    onHover,
+    onFocus,
+    threshold = 3,
+    flickThreshold = 500,
+    preventTouch = true
+  } = options;
+  const velocityTracker = react.useRef(new VelocityTracker());
+  const startPosition = react.useRef(Vector2.zero());
+  const lastPosition = react.useRef(Vector2.zero());
+  const isDragging = react.useRef(false);
+  const hasExceededThreshold = react.useRef(false);
+  const pointerId = react.useRef(null);
+  const elementRef = react.useRef(null);
+  const handlersRef = react.useRef({ onDragStart, onDrag, onDragEnd, onFlick });
+  handlersRef.current = { onDragStart, onDrag, onDragEnd, onFlick };
+  const createGestureState = react.useCallback(
+    (event, first, last) => {
+      const position = Vector2.from(event.clientX, event.clientY);
+      const delta = position.subtract(lastPosition.current);
+      const offset = position.subtract(startPosition.current);
+      const velocity = velocityTracker.current.getVelocity();
+      const direction = velocityTracker.current.getDirection();
+      return {
+        position,
+        delta,
+        offset,
+        velocity,
+        direction,
+        active: !last,
+        first,
+        last,
+        event
+      };
+    },
+    []
+  );
+  const handlePointerMove = react.useCallback(
+    (event) => {
+      var _a, _b, _c, _d;
+      if (!isDragging.current || pointerId.current !== event.pointerId) return;
+      const position = Vector2.from(event.clientX, event.clientY);
+      velocityTracker.current.addSample(position);
+      if (!hasExceededThreshold.current) {
+        const distance = position.distanceTo(startPosition.current);
+        if (distance < threshold) return;
+        hasExceededThreshold.current = true;
+        const state2 = createGestureState(event, true, false);
+        (_b = (_a = handlersRef.current).onDragStart) == null ? void 0 : _b.call(_a, state2);
+      }
+      const state = createGestureState(event, false, false);
+      (_d = (_c = handlersRef.current).onDrag) == null ? void 0 : _d.call(_c, state);
+      lastPosition.current = position;
+    },
+    [threshold, createGestureState]
+  );
+  const handlePointerUp = react.useCallback(
+    (event) => {
+      var _a, _b, _c, _d;
+      if (!isDragging.current || pointerId.current !== event.pointerId) return;
+      isDragging.current = false;
+      pointerId.current = null;
+      document.removeEventListener("pointermove", handlePointerMove);
+      document.removeEventListener("pointerup", handlePointerUp);
+      document.removeEventListener("pointercancel", handlePointerUp);
+      if (hasExceededThreshold.current) {
+        const state = createGestureState(event, false, true);
+        (_b = (_a = handlersRef.current).onDragEnd) == null ? void 0 : _b.call(_a, state);
+        const velocity = velocityTracker.current.getVelocity();
+        if (velocity.magnitude > flickThreshold) {
+          (_d = (_c = handlersRef.current).onFlick) == null ? void 0 : _d.call(_c, { ...state, flickVelocity: velocity });
+        }
+      }
+      velocityTracker.current.reset();
+      hasExceededThreshold.current = false;
+    },
+    [handlePointerMove, createGestureState, flickThreshold]
+  );
+  const onPointerDown = react.useCallback(
+    (e) => {
+      if (isDragging.current) return;
+      const element = e.currentTarget;
+      elementRef.current = element;
+      element.setPointerCapture(e.pointerId);
+      pointerId.current = e.pointerId;
+      isDragging.current = true;
+      hasExceededThreshold.current = false;
+      const position = Vector2.from(e.clientX, e.clientY);
+      startPosition.current = position;
+      lastPosition.current = position;
+      velocityTracker.current.reset();
+      velocityTracker.current.addSample(position);
+      document.addEventListener("pointermove", handlePointerMove);
+      document.addEventListener("pointerup", handlePointerUp);
+      document.addEventListener("pointercancel", handlePointerUp);
+    },
+    [handlePointerMove, handlePointerUp]
+  );
+  const onPointerEnter = react.useCallback(() => {
+    onHover == null ? void 0 : onHover(true);
+  }, [onHover]);
+  const onPointerLeave = react.useCallback(() => {
+    onHover == null ? void 0 : onHover(false);
+  }, [onHover]);
+  const handleFocus = react.useCallback(() => {
+    onFocus == null ? void 0 : onFocus(true);
+  }, [onFocus]);
+  const handleBlur = react.useCallback(() => {
+    onFocus == null ? void 0 : onFocus(false);
+  }, [onFocus]);
+  react.useEffect(() => {
+    return () => {
+      document.removeEventListener("pointermove", handlePointerMove);
+      document.removeEventListener("pointerup", handlePointerUp);
+      document.removeEventListener("pointercancel", handlePointerUp);
+    };
+  }, [handlePointerMove, handlePointerUp]);
+  return {
+    onPointerDown,
+    onPointerEnter,
+    onPointerLeave,
+    onFocus: handleFocus,
+    onBlur: handleBlur,
+    style: preventTouch ? { touchAction: "none" } : {}
+  };
+}
+function useDrag(options = {}) {
+  const {
+    initial = { x: 0, y: 0 },
+    bounds,
+    rubberBand = true,
+    rubberBandFactor = 0.55,
+    momentum = true,
+    snapTo,
+    snapThreshold = 50,
+    axis = "both",
+    springConfig,
+    frictionConfig,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    onRest
+  } = options;
+  const globalConfig = usePhysicsConfig();
+  const resolvedSpringConfig = react.useMemo(
+    () => ({ ...DEFAULT_SPRING_CONFIG, ...globalConfig, ...springConfig }),
+    [globalConfig, springConfig]
+  );
+  const resolvedFrictionConfig = react.useMemo(
+    () => ({ ...DEFAULT_FRICTION_CONFIG, ...frictionConfig }),
+    [frictionConfig]
+  );
+  const [state, setState] = react.useState({
+    x: initial.x,
+    y: initial.y,
+    isDragging: false,
+    isMomentum: false
+  });
+  const positionRef = react.useRef(Vector2.from(initial.x, initial.y));
+  const startPositionRef = react.useRef(Vector2.zero());
+  const dragOffsetRef = react.useRef(Vector2.zero());
+  const velocityTracker = react.useRef(new VelocityTracker());
+  const springRef = react.useRef(null);
+  const momentumRef = react.useRef(null);
+  const idRef = react.useRef(generatePhysicsId("drag"));
+  const pointerIdRef = react.useRef(null);
+  const handlersRef = react.useRef({ onDragStart, onDrag, onDragEnd, onRest });
+  handlersRef.current = { onDragStart, onDrag, onDragEnd, onRest };
+  const boundsVec = react.useMemo(() => {
+    if (!bounds) return null;
+    return {
+      min: Vector2.from(bounds.left ?? -Infinity, bounds.top ?? -Infinity),
+      max: Vector2.from(bounds.right ?? Infinity, bounds.bottom ?? Infinity)
+    };
+  }, [bounds]);
+  const applyRubberBand = react.useCallback(
+    (pos) => {
+      if (!boundsVec || !rubberBand) return pos;
+      let x = pos.x;
+      let y = pos.y;
+      if (pos.x < boundsVec.min.x) {
+        const over = boundsVec.min.x - pos.x;
+        x = boundsVec.min.x - over * rubberBandFactor;
+      } else if (pos.x > boundsVec.max.x) {
+        const over = pos.x - boundsVec.max.x;
+        x = boundsVec.max.x + over * rubberBandFactor;
+      }
+      if (pos.y < boundsVec.min.y) {
+        const over = boundsVec.min.y - pos.y;
+        y = boundsVec.min.y - over * rubberBandFactor;
+      } else if (pos.y > boundsVec.max.y) {
+        const over = pos.y - boundsVec.max.y;
+        y = boundsVec.max.y + over * rubberBandFactor;
+      }
+      return Vector2.from(x, y);
+    },
+    [boundsVec, rubberBand, rubberBandFactor]
+  );
+  const clampToBounds = react.useCallback(
+    (pos) => {
+      if (!boundsVec) return pos;
+      return pos.clampComponents(boundsVec.min, boundsVec.max);
+    },
+    [boundsVec]
+  );
+  const findSnapPoint = react.useCallback(
+    (pos, velocity) => {
+      if (!snapTo || snapTo.length === 0) return null;
+      const projectedPos = pos.add(velocity.multiply(0.1));
+      let nearestPoint = null;
+      let nearestDistance = Infinity;
+      for (const point of snapTo) {
+        const snapVec = Vector2.from(point.x, point.y);
+        const distance = projectedPos.distanceTo(snapVec);
+        if (distance < nearestDistance && distance < snapThreshold) {
+          nearestDistance = distance;
+          nearestPoint = snapVec;
+        }
+      }
+      return nearestPoint;
+    },
+    [snapTo, snapThreshold]
+  );
+  const animateToTarget = react.useCallback(
+    (target) => {
+      springRef.current = new Spring(positionRef.current, resolvedSpringConfig);
+      springRef.current.setTarget(target);
+      PhysicsEngine.register(idRef.current, (deltaTime) => {
+        var _a, _b;
+        if (!springRef.current) return;
+        const result = springRef.current.step(deltaTime);
+        positionRef.current = result.position;
+        setState((prev) => ({
+          ...prev,
+          x: result.position.x,
+          y: result.position.y,
+          isMomentum: false
+        }));
+        if (result.isSettled) {
+          PhysicsEngine.unregister(idRef.current);
+          (_b = (_a = handlersRef.current).onRest) == null ? void 0 : _b.call(_a, result.position);
+        }
+      });
+    },
+    [resolvedSpringConfig]
+  );
+  const handlePointerMove = react.useCallback(
+    (e) => {
+      var _a, _b;
+      if (pointerIdRef.current !== e.pointerId) return;
+      const currentPos = Vector2.from(e.clientX, e.clientY);
+      velocityTracker.current.addSample(currentPos);
+      let newPos = currentPos.subtract(dragOffsetRef.current);
+      if (axis === "x") {
+        newPos = Vector2.from(newPos.x, startPositionRef.current.y);
+      } else if (axis === "y") {
+        newPos = Vector2.from(startPositionRef.current.x, newPos.y);
+      }
+      newPos = applyRubberBand(newPos);
+      positionRef.current = newPos;
+      setState((prev) => ({
+        ...prev,
+        x: newPos.x,
+        y: newPos.y
+      }));
+      (_b = (_a = handlersRef.current).onDrag) == null ? void 0 : _b.call(_a, newPos);
+    },
+    [axis, applyRubberBand]
+  );
+  const handlePointerUp = react.useCallback(
+    (e) => {
+      var _a, _b, _c, _d;
+      if (pointerIdRef.current !== e.pointerId) return;
+      pointerIdRef.current = null;
+      document.removeEventListener("pointermove", handlePointerMove);
+      document.removeEventListener("pointerup", handlePointerUp);
+      document.removeEventListener("pointercancel", handlePointerUp);
+      const velocity = velocityTracker.current.getVelocity();
+      velocityTracker.current.reset();
+      setState((prev) => ({ ...prev, isDragging: false }));
+      (_b = (_a = handlersRef.current).onDragEnd) == null ? void 0 : _b.call(_a, positionRef.current, velocity);
+      const snapPoint = findSnapPoint(positionRef.current, velocity);
+      if (snapPoint) {
+        animateToTarget(snapPoint);
+        return;
+      }
+      if (boundsVec) {
+        const clamped = clampToBounds(positionRef.current);
+        if (!clamped.equals(positionRef.current)) {
+          animateToTarget(clamped);
+          return;
+        }
+      }
+      if (momentum && velocity.magnitude > 100) {
+        setState((prev) => ({ ...prev, isMomentum: true }));
+        momentumRef.current = new Momentum(positionRef.current, resolvedFrictionConfig);
+        momentumRef.current.start(positionRef.current, velocity);
+        PhysicsEngine.register(idRef.current, (deltaTime) => {
+          var _a2, _b2;
+          if (!momentumRef.current) return;
+          const result = momentumRef.current.step(deltaTime);
+          let newPos = result.position;
+          if (boundsVec) {
+            const clamped = clampToBounds(newPos);
+            if (!clamped.equals(newPos)) {
+              momentumRef.current.stop();
+              PhysicsEngine.unregister(idRef.current);
+              positionRef.current = newPos;
+              animateToTarget(clamped);
+              return;
+            }
+          }
+          positionRef.current = newPos;
+          setState((prev) => ({
+            ...prev,
+            x: newPos.x,
+            y: newPos.y,
+            isMomentum: result.isActive
+          }));
+          if (!result.isActive) {
+            PhysicsEngine.unregister(idRef.current);
+            (_b2 = (_a2 = handlersRef.current).onRest) == null ? void 0 : _b2.call(_a2, newPos);
+          }
+        });
+      } else {
+        (_d = (_c = handlersRef.current).onRest) == null ? void 0 : _d.call(_c, positionRef.current);
+      }
+    },
+    [
+      handlePointerMove,
+      momentum,
+      boundsVec,
+      clampToBounds,
+      findSnapPoint,
+      animateToTarget,
+      resolvedFrictionConfig
+    ]
+  );
+  const onPointerDown = react.useCallback(
+    (e) => {
+      var _a, _b;
+      if (pointerIdRef.current !== null) return;
+      PhysicsEngine.unregister(idRef.current);
+      pointerIdRef.current = e.pointerId;
+      const element = e.currentTarget;
+      element.setPointerCapture(e.pointerId);
+      const pointerPos = Vector2.from(e.clientX, e.clientY);
+      dragOffsetRef.current = pointerPos.subtract(positionRef.current);
+      startPositionRef.current = positionRef.current;
+      velocityTracker.current.reset();
+      velocityTracker.current.addSample(pointerPos);
+      setState((prev) => ({ ...prev, isDragging: true, isMomentum: false }));
+      (_b = (_a = handlersRef.current).onDragStart) == null ? void 0 : _b.call(_a, positionRef.current);
+      document.addEventListener("pointermove", handlePointerMove);
+      document.addEventListener("pointerup", handlePointerUp);
+      document.addEventListener("pointercancel", handlePointerUp);
+    },
+    [handlePointerMove, handlePointerUp]
+  );
+  const setPosition = react.useCallback((position) => {
+    PhysicsEngine.unregister(idRef.current);
+    positionRef.current = Vector2.from(position.x, position.y);
+    setState((prev) => ({
+      ...prev,
+      x: position.x,
+      y: position.y,
+      isDragging: false,
+      isMomentum: false
+    }));
+  }, []);
+  const snapToPosition = react.useCallback(
+    (position) => {
+      animateToTarget(Vector2.from(position.x, position.y));
+    },
+    [animateToTarget]
+  );
+  react.useEffect(() => {
+    return () => {
+      PhysicsEngine.unregister(idRef.current);
+      document.removeEventListener("pointermove", handlePointerMove);
+      document.removeEventListener("pointerup", handlePointerUp);
+      document.removeEventListener("pointercancel", handlePointerUp);
+    };
+  }, [handlePointerMove, handlePointerUp]);
+  const style = react.useMemo(
+    () => ({
+      transform: `translate3d(${state.x}px, ${state.y}px, 0)`,
+      willChange: state.isDragging || state.isMomentum ? "transform" : "auto",
+      cursor: state.isDragging ? "grabbing" : "grab"
+    }),
+    [state.x, state.y, state.isDragging, state.isMomentum]
+  );
+  return {
+    x: state.x,
+    y: state.y,
+    isDragging: state.isDragging,
+    isMomentum: state.isMomentum,
+    style,
+    bind: {
+      onPointerDown,
+      style: { touchAction: "none" }
+    },
+    setPosition,
+    snapToPosition
+  };
+}
+function useStretch(options) {
+  const {
+    velocity,
+    axis = "both",
+    intensity = 0.12,
+    maxVelocity = 2e3
+  } = options;
+  return react.useMemo(() => {
+    const vel = velocity instanceof Vector2 ? velocity : Vector2.from(velocity.x, velocity.y);
+    const normalizedX = Math.min(Math.abs(vel.x) / maxVelocity, 1);
+    const normalizedY = Math.min(Math.abs(vel.y) / maxVelocity, 1);
+    const easedX = easeOutQuad(normalizedX);
+    const easedY = easeOutQuad(normalizedY);
+    let scaleX = 1;
+    let scaleY = 1;
+    if (axis === "x" || axis === "both") {
+      const stretchX = 1 + easedX * intensity;
+      const compressY = 1 - easedX * intensity * 0.5;
+      if (axis === "x") {
+        scaleX = stretchX;
+        scaleY = compressY;
+      } else {
+        scaleX = stretchX;
+      }
+    }
+    if (axis === "y" || axis === "both") {
+      const stretchY = 1 + easedY * intensity;
+      const compressX = 1 - easedY * intensity * 0.5;
+      if (axis === "y") {
+        scaleY = stretchY;
+        scaleX = compressX;
+      } else {
+        scaleY = stretchY;
+      }
+    }
+    if (axis === "both" && normalizedX > 0 && normalizedY > 0) {
+      if (normalizedX > normalizedY) {
+        scaleX = 1 + easedX * intensity;
+        scaleY = 1 - easedX * intensity * 0.3 + easedY * intensity * 0.5;
+      } else {
+        scaleY = 1 + easedY * intensity;
+        scaleX = 1 - easedY * intensity * 0.3 + easedX * intensity * 0.5;
+      }
+    }
+    scaleX = Math.max(0.85, Math.min(1.15, scaleX));
+    scaleY = Math.max(0.85, Math.min(1.15, scaleY));
+    return {
+      scaleX,
+      scaleY,
+      style: {
+        transform: `scale3d(${scaleX}, ${scaleY}, 1)`,
+        willChange: scaleX !== 1 || scaleY !== 1 ? "transform" : "auto"
+      }
+    };
+  }, [velocity, axis, intensity, maxVelocity]);
+}
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+function combineStretchStyle(positionStyle, stretchStyle) {
+  const positionTransform = positionStyle.transform || "";
+  const stretchTransform = stretchStyle.transform || "";
+  return {
+    ...positionStyle,
+    transform: `${positionTransform} ${stretchTransform}`.trim(),
+    willChange: positionStyle.willChange === "transform" || stretchStyle.willChange === "transform" ? "transform" : "auto"
+  };
+}
+function useLift(options = {}) {
+  const {
+    trigger = "hover",
+    scale: targetScale = 1.03,
+    shadow = true,
+    shadowIntensity = 1,
+    springConfig,
+    onLift
+  } = options;
+  const [isLifted, setIsLifted] = react.useState(false);
+  const { value: scale } = useSpring1D({
+    to: isLifted ? targetScale : 1,
+    config: {
+      tension: 300,
+      friction: 20,
+      ...springConfig
+    }
+  });
+  const handleLift = react.useCallback(
+    (lifted) => {
+      setIsLifted(lifted);
+      onLift == null ? void 0 : onLift(lifted);
+    },
+    [onLift]
+  );
+  const bind = react.useMemo(() => {
+    switch (trigger) {
+      case "hover":
+        return {
+          onPointerEnter: () => handleLift(true),
+          onPointerLeave: () => handleLift(false)
+        };
+      case "drag":
+        return {
+          onPointerDown: () => handleLift(true),
+          onPointerUp: () => handleLift(false)
+        };
+      case "focus":
+        return {
+          onFocus: () => handleLift(true),
+          onBlur: () => handleLift(false)
+        };
+      case "active":
+        return {
+          onPointerDown: () => handleLift(true),
+          onPointerUp: () => handleLift(false),
+          onPointerLeave: () => handleLift(false)
+        };
+      default:
+        return {};
+    }
+  }, [trigger, handleLift]);
+  const shadowStyle = react.useMemo(() => {
+    if (!shadow) return {};
+    const liftAmount = (scale - 1) / (targetScale - 1);
+    const clampedLift = Math.max(0, Math.min(1, liftAmount));
+    const blur = 8 + clampedLift * 24 * shadowIntensity;
+    const spread = clampedLift * 4 * shadowIntensity;
+    const yOffset = 2 + clampedLift * 12 * shadowIntensity;
+    const opacity = 0.08 + clampedLift * 0.12 * shadowIntensity;
+    return {
+      boxShadow: `0 ${yOffset}px ${blur}px ${spread}px rgba(0, 0, 0, ${opacity})`
+    };
+  }, [scale, targetScale, shadow, shadowIntensity]);
+  const style = react.useMemo(
+    () => ({
+      transform: `scale3d(${scale}, ${scale}, 1)`,
+      transformOrigin: "center center",
+      willChange: scale !== 1 ? "transform, box-shadow" : "auto",
+      ...shadowStyle
+    }),
+    [scale, shadowStyle]
+  );
+  return {
+    isLifted,
+    scale,
+    style,
+    bind,
+    setLifted: handleLift
+  };
+}
+function combineLiftStyle(baseStyle, liftStyle) {
+  const baseTransform = baseStyle.transform || "";
+  const liftTransform = liftStyle.transform || "";
+  return {
+    ...baseStyle,
+    ...liftStyle,
+    transform: `${baseTransform} ${liftTransform}`.trim()
+  };
+}
+function useFlick(options = {}) {
+  const {
+    initial = { x: 0, y: 0 },
+    threshold = 500,
+    friction,
+    axis = "both",
+    onFlickStart,
+    onFlick,
+    onFlickEnd
+  } = options;
+  const resolvedFriction = react.useMemo(
+    () => ({ ...DEFAULT_FRICTION_CONFIG, ...friction }),
+    [friction]
+  );
+  const [state, setState] = react.useState({
+    x: initial.x,
+    y: initial.y,
+    isFlicking: false,
+    velocity: Vector2.zero()
+  });
+  const positionRef = react.useRef(Vector2.from(initial.x, initial.y));
+  const momentumRef = react.useRef(null);
+  const velocityTracker = react.useRef(new VelocityTracker());
+  const idRef = react.useRef(generatePhysicsId("flick"));
+  const handlersRef = react.useRef({ onFlickStart, onFlick, onFlickEnd });
+  handlersRef.current = { onFlickStart, onFlick, onFlickEnd };
+  const startMomentum = react.useCallback(
+    (velocity) => {
+      var _a, _b;
+      let constrainedVelocity = velocity;
+      if (axis === "x") {
+        constrainedVelocity = Vector2.from(velocity.x, 0);
+      } else if (axis === "y") {
+        constrainedVelocity = Vector2.from(0, velocity.y);
+      }
+      momentumRef.current = new Momentum(positionRef.current, resolvedFriction);
+      momentumRef.current.start(positionRef.current, constrainedVelocity);
+      setState((prev) => ({
+        ...prev,
+        isFlicking: true,
+        velocity: constrainedVelocity
+      }));
+      (_b = (_a = handlersRef.current).onFlickStart) == null ? void 0 : _b.call(_a, constrainedVelocity);
+      PhysicsEngine.register(idRef.current, (deltaTime) => {
+        var _a2, _b2, _c, _d;
+        if (!momentumRef.current) return;
+        const result = momentumRef.current.step(deltaTime);
+        let newPos = result.position;
+        if (axis === "x") {
+          newPos = Vector2.from(newPos.x, positionRef.current.y);
+        } else if (axis === "y") {
+          newPos = Vector2.from(positionRef.current.x, newPos.y);
+        }
+        positionRef.current = newPos;
+        setState({
+          x: newPos.x,
+          y: newPos.y,
+          isFlicking: result.isActive,
+          velocity: result.velocity
+        });
+        (_b2 = (_a2 = handlersRef.current).onFlick) == null ? void 0 : _b2.call(_a2, newPos, result.velocity);
+        if (!result.isActive) {
+          PhysicsEngine.unregister(idRef.current);
+          (_d = (_c = handlersRef.current).onFlickEnd) == null ? void 0 : _d.call(_c, newPos);
+        }
+      });
+    },
+    [axis, resolvedFriction]
+  );
+  const flick = react.useCallback(
+    (velocity) => {
+      PhysicsEngine.unregister(idRef.current);
+      velocityTracker.current.reset();
+      startMomentum(Vector2.from(velocity.x, velocity.y));
+    },
+    [startMomentum]
+  );
+  const stop = react.useCallback(() => {
+    var _a;
+    PhysicsEngine.unregister(idRef.current);
+    (_a = momentumRef.current) == null ? void 0 : _a.stop();
+    velocityTracker.current.reset();
+    setState((prev) => ({
+      ...prev,
+      isFlicking: false,
+      velocity: Vector2.zero()
+    }));
+  }, []);
+  const setPosition = react.useCallback(
+    (position) => {
+      stop();
+      positionRef.current = Vector2.from(position.x, position.y);
+      setState({
+        x: position.x,
+        y: position.y,
+        isFlicking: false,
+        velocity: Vector2.zero()
+      });
+    },
+    [stop]
+  );
+  const recordSample = react.useCallback((position) => {
+    velocityTracker.current.addSample(Vector2.from(position.x, position.y));
+    positionRef.current = Vector2.from(position.x, position.y);
+    setState((prev) => ({
+      ...prev,
+      x: position.x,
+      y: position.y
+    }));
+  }, []);
+  const getCurrentVelocity = react.useCallback(() => {
+    return velocityTracker.current.getVelocity();
+  }, []);
+  const release = react.useCallback(
+    (position) => {
+      positionRef.current = Vector2.from(position.x, position.y);
+      const velocity = velocityTracker.current.getVelocity();
+      velocityTracker.current.reset();
+      if (velocity.magnitude >= threshold) {
+        startMomentum(velocity);
+        return true;
+      }
+      setState((prev) => ({
+        ...prev,
+        x: position.x,
+        y: position.y,
+        isFlicking: false,
+        velocity: Vector2.zero()
+      }));
+      return false;
+    },
+    [threshold, startMomentum]
+  );
+  react.useEffect(() => {
+    return () => {
+      PhysicsEngine.unregister(idRef.current);
+    };
+  }, []);
+  const style = react.useMemo(
+    () => ({
+      transform: `translate3d(${state.x}px, ${state.y}px, 0)`,
+      willChange: state.isFlicking ? "transform" : "auto"
+    }),
+    [state.x, state.y, state.isFlicking]
+  );
+  return {
+    x: state.x,
+    y: state.y,
+    isFlicking: state.isFlicking,
+    velocity: state.velocity,
+    style,
+    flick,
+    stop,
+    setPosition,
+    recordSample,
+    getCurrentVelocity,
+    release
+  };
+}
+const Draggable = react.forwardRef(
+  ({
+    children,
+    initial = { x: 0, y: 0 },
+    bounds,
+    rubberBand = true,
+    momentum = true,
+    lift: enableLift = true,
+    stretch: enableStretch = true,
+    snapTo,
+    axis = "both",
+    springConfig,
+    className,
+    style: customStyle,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    onRest
+  }, ref) => {
+    const physicsContext = usePhysicsContext();
+    const {
+      isDragging,
+      isMomentum,
+      style: dragStyle,
+      bind
+    } = useDrag({
+      initial,
+      bounds,
+      rubberBand,
+      momentum,
+      snapTo,
+      axis,
+      springConfig: { ...physicsContext.spring, ...springConfig },
+      onDragStart: (pos) => onDragStart == null ? void 0 : onDragStart(pos.toObject()),
+      onDrag: (pos) => onDrag == null ? void 0 : onDrag(pos.toObject()),
+      onDragEnd: (pos, vel) => onDragEnd == null ? void 0 : onDragEnd(pos.toObject(), vel.toObject()),
+      onRest: (pos) => onRest == null ? void 0 : onRest(pos.toObject())
+    });
+    const { style: liftStyle, bind: liftBind } = useLift({
+      trigger: "drag",
+      scale: physicsContext.lift.scale,
+      shadowIntensity: physicsContext.lift.shadowIntensity
+    });
+    const velocity = react.useMemo(() => {
+      if (!isDragging && !isMomentum) return Vector2.zero();
+      return Vector2.from(0, 0);
+    }, [isDragging, isMomentum]);
+    const { style: stretchStyle } = useStretch({
+      velocity,
+      intensity: physicsContext.stretch.intensity,
+      maxVelocity: physicsContext.stretch.maxVelocity
+    });
+    const combinedStyle = react.useMemo(() => {
+      let result = { ...dragStyle };
+      if (enableLift && isDragging) {
+        result = combineLiftStyle(result, liftStyle);
+      }
+      if (enableStretch) {
+        result = combineStretchStyle(result, stretchStyle);
+      }
+      return {
+        ...result,
+        ...customStyle,
+        position: "relative",
+        userSelect: "none"
+      };
+    }, [dragStyle, liftStyle, stretchStyle, enableLift, enableStretch, isDragging, customStyle]);
+    const combinedBind = react.useMemo(() => {
+      return {
+        ...bind,
+        onPointerDown: (e) => {
+          var _a;
+          bind.onPointerDown(e);
+          if (enableLift) {
+            (_a = liftBind.onPointerDown) == null ? void 0 : _a.call(liftBind);
+          }
+        },
+        onPointerUp: () => {
+          var _a;
+          if (enableLift) {
+            (_a = liftBind.onPointerUp) == null ? void 0 : _a.call(liftBind);
+          }
+        }
+      };
+    }, [bind, liftBind, enableLift]);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref,
+        className,
+        ...combinedBind,
+        style: combinedStyle,
+        children
+      }
+    );
+  }
+);
+Draggable.displayName = "Draggable";
+const Card = react.forwardRef(
+  ({
+    children,
+    lift: enableLift = true,
+    pressable = true,
+    liftScale,
+    pressScale = 0.98,
+    glass = false,
+    glassBlur = 20,
+    springConfig,
+    className,
+    style: customStyle,
+    onClick,
+    onHover,
+    onPress
+  }, ref) => {
+    const physicsContext = usePhysicsContext();
+    const [isPressed, setIsPressed] = react.useState(false);
+    const resolvedLiftScale = liftScale ?? physicsContext.lift.scale;
+    const { style: liftStyle, bind: liftBind, isLifted } = useLift({
+      trigger: "hover",
+      scale: resolvedLiftScale,
+      shadowIntensity: physicsContext.lift.shadowIntensity,
+      springConfig: { ...physicsContext.spring, ...springConfig },
+      onLift: onHover
+    });
+    const { value: pressScaleValue } = useSpring1D({
+      to: isPressed ? pressScale : 1,
+      config: {
+        tension: 400,
+        friction: 25,
+        ...springConfig
+      }
+    });
+    const handlePointerDown = react.useCallback(() => {
+      if (pressable) {
+        setIsPressed(true);
+        onPress == null ? void 0 : onPress(true);
+      }
+    }, [pressable, onPress]);
+    const handlePointerUp = react.useCallback(() => {
+      if (pressable) {
+        setIsPressed(false);
+        onPress == null ? void 0 : onPress(false);
+      }
+    }, [pressable, onPress]);
+    const handlePointerLeave = react.useCallback(() => {
+      if (isPressed) {
+        setIsPressed(false);
+        onPress == null ? void 0 : onPress(false);
+      }
+    }, [isPressed, onPress]);
+    const glassStyles = glass ? {
+      background: "rgba(255, 255, 255, 0.1)",
+      backdropFilter: `blur(${glassBlur}px)`,
+      WebkitBackdropFilter: `blur(${glassBlur}px)`,
+      border: "1px solid rgba(255, 255, 255, 0.18)"
+    } : {};
+    const combinedStyle = react.useMemo(() => {
+      const liftTransform = enableLift ? liftStyle.transform || "" : "";
+      const pressTransform = pressable ? `scale(${pressScaleValue})` : "";
+      const transform = `${liftTransform} ${pressTransform}`.trim() || void 0;
+      return {
+        ...glassStyles,
+        ...liftStyle,
+        ...customStyle,
+        transform,
+        transformOrigin: "center center",
+        cursor: onClick ? "pointer" : "default",
+        willChange: isLifted || isPressed ? "transform, box-shadow" : "auto"
+      };
+    }, [
+      liftStyle,
+      pressScaleValue,
+      enableLift,
+      pressable,
+      glassStyles,
+      customStyle,
+      onClick,
+      isLifted,
+      isPressed
+    ]);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref,
+        className,
+        style: combinedStyle,
+        onClick,
+        onPointerEnter: liftBind.onPointerEnter,
+        onPointerLeave: () => {
+          var _a;
+          (_a = liftBind.onPointerLeave) == null ? void 0 : _a.call(liftBind);
+          handlePointerLeave();
+        },
+        onPointerDown: handlePointerDown,
+        onPointerUp: handlePointerUp,
+        children
+      }
+    );
+  }
+);
+Card.displayName = "Card";
+const cardBaseStyles = {
+  padding: "24px",
+  borderRadius: "16px",
+  background: "white",
+  boxShadow: "0 4px 12px rgba(0, 0, 0, 0.08)"
+};
+exports.Card = Card;
+exports.DEFAULT_FRICTION_CONFIG = DEFAULT_FRICTION_CONFIG;
+exports.DEFAULT_SPRING_CONFIG = DEFAULT_SPRING_CONFIG;
+exports.Draggable = Draggable;
+exports.Momentum = Momentum;
+exports.Momentum1D = Momentum1D;
+exports.PhysicsEngine = PhysicsEngine;
+exports.PhysicsProvider = PhysicsProvider;
+exports.Spring = Spring;
+exports.Spring1D = Spring1D;
+exports.Vector2 = Vector2;
+exports.VelocityTracker = VelocityTracker;
+exports.VelocityTracker1D = VelocityTracker1D;
+exports.cardBaseStyles = cardBaseStyles;
+exports.combineLiftStyle = combineLiftStyle;
+exports.combineStretchStyle = combineStretchStyle;
+exports.generatePhysicsId = generatePhysicsId;
+exports.gentle = gentle;
+exports.getFrictionConfig = getFrictionConfig;
+exports.getPreset = getPreset;
+exports.getSpringConfig = getSpringConfig;
+exports.ios = ios;
+exports.presets = presets;
+exports.smooth = smooth;
+exports.snappy = snappy;
+exports.stiff = stiff;
+exports.useDrag = useDrag;
+exports.useFlick = useFlick;
+exports.useFrictionConfig = useFrictionConfig;
+exports.useGesture = useGesture;
+exports.useLift = useLift;
+exports.useLiftConfig = useLiftConfig;
+exports.usePhysicsConfig = usePhysicsConfig;
+exports.usePhysicsContext = usePhysicsContext;
+exports.useSpring = useSpring;
+exports.useSpring1D = useSpring1D;
+exports.useStretch = useStretch;
+exports.useStretchConfig = useStretchConfig;
+//# sourceMappingURL=index.cjs.map