@vishinvents/aerostat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aerostat Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,260 @@
+# Aerostat
+
+**The missing physics the browser forgot to give you.**
+
+~3KB • Zero dependencies • Spring-first motion
+
+Aerostat is the animation primitive for modern frameworks. While Svelte, React, and Solid handle the DOM, Aerostat handles **time and physics** — with automatic interrupt handling, velocity catching, and a unified spring engine.
+
+---
+
+## Why Aerostat?
+
+| Feature | Aerostat | CSS/Web Animations | GSAP |
+|---------|----------|-------------------|------|
+| **Size** | ~3KB | 0KB | ~60KB |
+| **Spring Physics** | Native | Needs JS | Plugin |
+| **Interrupt Handling** | Automatic (WeakMap) | Manual | Manual |
+| **Velocity Catching** | Built-in | None | Manual |
+| **Modern Framework DX** | Svelte actions, React hooks | Generic | Generic |
+
+**Optimized for the Modern Stack** — where the framework owns the DOM and you need physics-based motion without the bloat.
+
+---
+
+## Features
+
+- 🎯 **Singleton Scheduler** - Single global rAF loop prevents layout thrashing
+- ⚡️ **Spring Physics** - Realistic damped harmonic oscillator with velocity catching
+- 🔄 **Automatic Interrupts** - WeakMap-based collision detection for smooth transitions
+- 🎨 **Framework Adapters** - Tree-shakeable actions/hooks for Svelte, React, SolidJS
+- 📦 **Tiny Bundle** - Core library under 3KB gzipped
+- 🛠️ **TypeScript** - Full type safety with strict mode
+
+---
+
+## Installation
+
+```bash
+npm install aerostat
+```
+
+---
+
+## Quick Start
+
+### Vanilla JS / TypeScript
+
+```ts
+import { aerostat } from 'aerostat';
+
+// Spring animation (default)
+aerostat({
+  from: 0,
+  to: 100,
+  onUpdate: (value) => {
+    element.style.opacity = value / 100;
+  }
+});
+
+// Duration-based with easing
+aerostat({
+  from: 0,
+  to: 100,
+  type: 'duration',
+  duration: 300,
+  easing: easeOutExpo,
+  onUpdate: (value) => {
+    element.style.transform = `translateX(${value}px)`;
+  }
+});
+```
+
+### Svelte
+
+```svelte
+<script>
+  import { squish } from 'aerostat/svelte';
+</script>
+
+<button use:squish>Click me</button>
+```
+
+### React / Next.js
+
+```tsx
+import { createUseAnimate } from 'aerostat/react';
+import * as React from 'react';
+
+const useAnimate = createUseAnimate(React);
+
+function Component() {
+  const [opacity, setOpacity] = React.useState(0);
+  
+  useAnimate({
+    from: 0,
+    to: 1,
+    duration: 300,
+    onUpdate: setOpacity
+  });
+  
+  return <div style={{ opacity }}>Fading in...</div>;
+}
+```
+
+### SolidJS
+
+```tsx
+import { createReactiveAnimation } from 'aerostat/solid';
+import { createSignal, createEffect, onCleanup } from 'solid-js';
+
+function Component() {
+  const [value, setValue] = createSignal(0);
+  
+  createEffect(() => {
+    const controller = createReactiveAnimation({
+      from: 0,
+      to: 100,
+      onUpdate: setValue
+    });
+    
+    onCleanup(() => controller.stop());
+  });
+  
+  return <div>{value()}</div>;
+}
+```
+
+---
+
+## Documentation
+
+- [Core API Reference](./docs/API.md) - Main animation functions and types
+- [Framework Adapters](./docs/FRAMEWORKS.md) - Svelte, React, and SolidJS integrations
+- [Examples & Patterns](./docs/EXAMPLES.md) - Common use cases and recipes
+
+---
+
+## Core Concepts
+
+### Spring Physics
+
+Springs create natural, momentum-based animations:
+
+```ts
+aerostat({
+  from: 0,
+  to: 100,
+  stiffness: 170,  // Higher = faster
+  damping: 12,     // Lower = more bounce
+  onUpdate: (v) => element.style.left = `${v}px`
+});
+```
+
+### Automatic Interrupts
+
+Calling a new animation on the same target automatically stops the previous one:
+
+```ts
+const controller = aerostat({
+  from: 0,
+  to: 100,
+  onUpdate: (v) => element.style.opacity = v / 100
+});
+
+// Later - this will stop the first animation
+aerostat({
+  from: controller.getValue(),
+  to: 0,
+  velocity: controller.getVelocity(), // Catch momentum!
+  onUpdate: (v) => element.style.opacity = v / 100
+});
+```
+
+### Key-Based Registry
+
+Name animations to interrupt by key:
+
+```ts
+aerostat({
+  key: 'my-animation',
+  from: 0,
+  to: 100,
+  onUpdate: (v) => element.style.left = `${v}px`
+});
+
+// Later - stops 'my-animation'
+aerostat({
+  key: 'my-animation',
+  from: 100,
+  to: 200,
+  onUpdate: (v) => element.style.left = `${v}px`
+});
+```
+
+---
+
+## Spring Presets
+
+Four built-in presets tuned for common use cases:
+
+```ts
+import { snappy, bouncy, smooth, heavy } from 'aerostat';
+
+// Use directly
+aerostat({ from: 0, to: 100, ...snappy, onUpdate });
+
+// Or set globally
+import { setDefaultPreset } from 'aerostat';
+setDefaultPreset('snappy'); // All animations now use snappy
+```
+
+| Preset | Stiffness | Damping | Feel |
+|--------|-----------|---------|------|
+| `snappy` | 400 | 30 | Quick, responsive, minimal overshoot |
+| `bouncy` | 180 | 12 | Energetic, playful overshoot |
+| `smooth` | 120 | 20 | Gentle, elegant, no overshoot |
+| `heavy` | 100 | 18 | Weighty, deliberate, slow settle |
+
+---
+
+## Bundle Size
+
+| Import | Size (gzipped) |
+|--------|---------------|
+| Core (`aerostat`) | ~2.9 KB |
+| Svelte adapter | +402 B |
+| React adapter | +459 B |
+| SolidJS adapter | +426 B |
+| Squish utility | +500 B |
+
+Tree-shakeable - only bundle what you import.
+
+---
+
+## Browser Support
+
+- Chrome/Edge 90+
+- Firefox 88+
+- Safari 14+
+- All modern mobile browsers
+
+---
+
+## Contributing
+
+PRs welcome! Please open an issue first to discuss what you'd like to change.
+
+---
+
+## License
+
+MIT © 2026
+
+---
+
+## Credits
+
+Built with ❤️ for the micro-interaction community.
+
+Inspired by the physics of real-world motion and the elegance of minimal APIs.

package/dist/animate-B3pY7b4F.d.ts

@@ -0,0 +1,332 @@
+/** Available preset names */
+type PresetName = 'snappy' | 'bouncy' | 'smooth' | 'heavy';
+/** Preset configuration (read-only) */
+type PresetConfig = Readonly<Required<SpringConfig>>;
+/**
+ * Snappy - Quick, responsive, minimal overshoot.
+ * Best for: UI state changes, toggles, micro-interactions.
+ * Feel: "Instant but alive"
+ */
+declare const PRESET_SNAPPY: PresetConfig;
+/**
+ * Bouncy - Energetic, playful overshoot.
+ * Best for: Success states, notifications, attention-grabbers.
+ * Feel: "Pop and settle"
+ */
+declare const PRESET_BOUNCY: PresetConfig;
+/**
+ * Smooth - Gentle, elegant, no overshoot.
+ * Best for: Page transitions, modals, content reveals.
+ * Feel: "Glide into place"
+ */
+declare const PRESET_SMOOTH: PresetConfig;
+/**
+ * Heavy - Weighty, deliberate, slow settle.
+ * Best for: Large elements, dramatic reveals, emphasis.
+ * Feel: "Massive and powerful"
+ */
+declare const PRESET_HEAVY: PresetConfig;
+/**
+ * All presets as a lookup object.
+ * Use individual constants (PRESET_SNAPPY, etc.) for best tree-shaking.
+ */
+declare const presets: Readonly<Record<PresetName, PresetConfig>>;
+/** Quick, responsive, minimal overshoot */
+declare const snappy: Readonly<Required<SpringConfig>>;
+/** Energetic, playful overshoot */
+declare const bouncy: Readonly<Required<SpringConfig>>;
+/** Gentle, elegant, no overshoot */
+declare const smooth: Readonly<Required<SpringConfig>>;
+/** Weighty, deliberate, slow settle */
+declare const heavy: Readonly<Required<SpringConfig>>;
+/**
+ * Get the current default preset configuration.
+ */
+declare function getDefaultPreset(): PresetConfig;
+/**
+ * Get the current default preset name.
+ */
+declare function getDefaultPresetName(): PresetName;
+/**
+ * Set the default preset for all animations.
+ * Call this at app initialization to change the global feel.
+ *
+ * @example
+ * ```ts
+ * // At app startup
+ * import { setDefaultPreset } from 'aerostat';
+ * setDefaultPreset('snappy');
+ *
+ * // All subsequent animations will use 'snappy' by default
+ * aerostat({ from: 0, to: 100, onUpdate: ... });
+ * ```
+ */
+declare function setDefaultPreset(preset: PresetName): void;
+/**
+ * Resolve a preset name to its configuration.
+ * Returns undefined if the preset doesn't exist.
+ */
+declare function resolvePreset(name: PresetName): PresetConfig | undefined;
+
+/**
+ * Spring configuration for physics-based animations.
+ * These values create a single "universal" spring feel.
+ */
+interface SpringConfig {
+    /** Stiffness of the spring (default: 180) */
+    stiffness?: number;
+    /** Damping of the spring (default: 12) */
+    damping?: number;
+    /** Mass of the animated object (default: 1) */
+    mass?: number;
+    /** Velocity threshold to consider animation complete (default: 0.001) */
+    restVelocity?: number;
+}
+/**
+ * Duration-based animation configuration.
+ */
+interface DurationConfig {
+    /** Duration in milliseconds (default: 300) */
+    duration?: number;
+    /** Easing function name (default: 'easeOut') */
+    easing?: EasingFunction;
+}
+/**
+ * Core animation configuration - the public API input.
+ */
+interface AnimationConfig {
+    /** Starting value */
+    from: number;
+    /** Target value */
+    to: number;
+    /** Called on each frame with interpolated value */
+    onUpdate: (value: number) => void;
+    /** Called when animation completes naturally */
+    onComplete?: () => void;
+    /** Initial velocity (for spring animations) */
+    velocity?: number;
+    /** Delay before animation starts, in milliseconds */
+    delay?: number;
+    /** Unique key for interrupt handling - new animations with same key will stop previous ones */
+    key?: string | symbol;
+}
+/**
+ * Spring-based animation configuration.
+ */
+interface SpringAnimationConfig extends AnimationConfig, SpringConfig {
+    /** Animation type discriminator */
+    type?: 'spring';
+    /** Use a preset instead of raw stiffness/damping values */
+    preset?: PresetName;
+}
+/**
+ * Duration-based animation configuration.
+ */
+interface DurationAnimationConfig extends AnimationConfig, DurationConfig {
+    /** Animation type discriminator */
+    type: 'duration';
+}
+/**
+ * Combined animation config - accepts either spring or duration.
+ */
+type AerostatConfig = SpringAnimationConfig | DurationAnimationConfig;
+/**
+ * Easing function - maps progress (0-1) to eased progress (0-1).
+ */
+type EasingFunction = (t: number) => number;
+/**
+ * Named easing functions available in the library.
+ */
+type EasingName = 'linear' | 'easeOutExpo' | 'easeInOutCubic';
+/**
+ * Internal job representation for the scheduler.
+ * Uses mutable state for zero-allocation hot path.
+ */
+interface AnimationJob {
+    /** Starting value (for duration-based interpolation) */
+    fromValue: number;
+    /** Current value */
+    value: number;
+    /** Target value */
+    to: number;
+    /** Current velocity (used by spring) */
+    velocity: number;
+    /** Update callback */
+    onUpdate: (value: number) => void;
+    /** Completion callback */
+    onComplete?: () => void;
+    /** Animation configuration */
+    config: ResolvedConfig;
+    /** Whether animation is active */
+    active: boolean;
+    /** Delay remaining (ms) */
+    delayRemaining: number;
+    /** Animation status */
+    status: AnimationStatus;
+    /** Start time (timestamp when animation began) */
+    startTime: number;
+    /** Elapsed time (accumulated, for pause/resume) */
+    elapsed: number;
+    /** Pause time (timestamp when paused, for calculating elapsed) */
+    pauseTime: number;
+}
+/**
+ * Internally resolved configuration with defaults applied.
+ */
+interface ResolvedConfig {
+    /** Animation type */
+    type: 'spring' | 'duration';
+    /** Spring stiffness (if spring type) */
+    stiffness: number;
+    /** Spring damping (if spring type) */
+    damping: number;
+    /** Spring mass (if spring type) */
+    mass: number;
+    /** Rest velocity threshold (if spring type) */
+    restVelocity: number;
+    /** Duration in ms (if duration type) */
+    duration: number;
+    /** Easing function (if duration type) */
+    easing: EasingFunction;
+    /** Start time (if duration type) */
+    startTime: number;
+}
+/**
+ * Animation status.
+ */
+type AnimationStatus = 'idle' | 'running' | 'paused' | 'completed';
+/**
+ * Controller for an active animation.
+ * Provides full control over animation lifecycle.
+ */
+interface AnimationController {
+    /** Stop the animation immediately and remove from scheduler */
+    stop: () => void;
+    /** Update the target value mid-animation (for spring) */
+    setTarget: (to: number) => void;
+    /** Pause the animation (maintains current state) */
+    pause: () => void;
+    /** Resume a paused animation */
+    resume: () => void;
+    /** Get current animation status */
+    getStatus: () => AnimationStatus;
+    /** Get elapsed time in milliseconds */
+    getElapsed: () => number;
+    /** Get current value */
+    getValue: () => number;
+    /** Get current velocity */
+    getVelocity: () => number;
+    /** Whether animation is currently active */
+    readonly active: boolean;
+    /** Promise-like interface for chaining animations */
+    then: (callback: () => void) => AnimationController;
+    /** Get the underlying promise for async/await */
+    readonly finished: Promise<void>;
+}
+/**
+ * Options for the animate() function.
+ * Simplified API for object-based animations.
+ */
+interface TweenOptions {
+    /** Starting value */
+    from: number;
+    /** Target value - number or relative string like '+=100' or '-=50' */
+    to: number | string;
+    /** Duration in milliseconds (default: 300) */
+    duration?: number;
+    /** Delay before animation starts in milliseconds (default: 0) */
+    delay?: number;
+    /** Easing function (default: easeOutExpo) */
+    easing?: EasingFunction;
+    /** Called on each frame with interpolated value */
+    onUpdate: (value: number) => void;
+    /** Called when animation completes naturally */
+    onComplete?: () => void;
+}
+/**
+ * Internal task representation for WeakMap registry.
+ * Captures closure state for the animation.
+ */
+interface AnimationTask {
+    /** Start timestamp (set after delay) */
+    startTime: number;
+    /** Duration in ms */
+    duration: number;
+    /** Delay remaining in ms */
+    delayRemaining: number;
+    /** Starting value */
+    from: number;
+    /** Target value (resolved to number) */
+    to: number;
+    /** Easing function */
+    easing: EasingFunction;
+    /** Update callback */
+    onUpdate: (value: number) => void;
+    /** Completion callback */
+    onComplete?: () => void;
+    /** Whether task is active */
+    active: boolean;
+    /** Reference to the target object */
+    target: object;
+    /** Promise resolve function for .then() chaining */
+    resolve?: () => void;
+}
+
+/**
+ * Animate a target object with automatic interrupt.
+ *
+ * If the target already has an active animation,
+ * it is immediately stopped (Kill-on-Collision).
+ *
+ * @param target - The object to animate (used as WeakMap key)
+ * @param options - Animation options
+ * @returns Controller for the animation
+ *
+ * @example
+ * ```ts
+ * const element = document.querySelector('.box');
+ *
+ * // Basic animation
+ * animate(element, {
+ *   from: 0, to: 100,
+ *   duration: 300,
+ *   onUpdate: (v) => element.style.transform = `translateX(${v}px)`
+ * });
+ *
+ * // With delay (staggered menu items)
+ * animate(element, {
+ *   from: 0, to: 1,
+ *   duration: 200,
+ *   delay: 100,
+ *   onUpdate: (v) => element.style.opacity = String(v)
+ * });
+ *
+ * // Relative values
+ * animate(element, {
+ *   from: 50, to: '+=100',  // Animates to 150
+ *   onUpdate: (v) => element.style.left = `${v}px`
+ * });
+ *
+ * // Chaining with .then()
+ * animate(element, { from: 0, to: 100, onUpdate: ... })
+ *   .then(() => animate(element, { from: 100, to: 0, onUpdate: ... }));
+ *
+ * // Or with async/await
+ * await animate(element, { from: 0, to: 100, onUpdate: ... }).finished;
+ * ```
+ */
+declare function animate(target: object, options: TweenOptions): AnimationController;
+/**
+ * Check if a target has an active animation.
+ */
+declare function hasAnimation(target: object): boolean;
+/**
+ * Stop animation on a specific target.
+ */
+declare function stopAnimation(target: object): void;
+/**
+ * Get the number of active animations.
+ */
+declare function getActiveAnimationCount(): number;
+
+export { type AnimationController as A, type DurationAnimationConfig as D, type EasingFunction as E, PRESET_BOUNCY as P, type ResolvedConfig as R, type SpringAnimationConfig as S, type TweenOptions as T, animate as a, type EasingName as b, type AerostatConfig as c, type AnimationJob as d, type AnimationConfig as e, type AnimationStatus as f, type AnimationTask as g, type DurationConfig as h, PRESET_HEAVY as i, PRESET_SMOOTH as j, PRESET_SNAPPY as k, type PresetConfig as l, type PresetName as m, type SpringConfig as n, bouncy as o, getActiveAnimationCount as p, getDefaultPreset as q, getDefaultPresetName as r, hasAnimation as s, heavy as t, presets as u, resolvePreset as v, setDefaultPreset as w, smooth as x, snappy as y, stopAnimation as z };

package/dist/chunk-GZKQYUY7.js

@@ -0,0 +1,14 @@
+import {i,d,a}from'./chunk-W7GGS6ZY.js';var C=[],O=false,E=null,h=0;function J(e){let s=h===0?0:Math.min((e-h)/1e3,.064);h=e;for(let r=C.length-1;r>=0;r--){let n=C[r];if(n.status==="paused")continue;if(n.delayRemaining>0){n.delayRemaining-=s*1e3;continue}if(n.startTime===0&&(n.startTime=e),!n.active){n.status="completed",C.splice(r,1);continue}n.elapsed=e-n.startTime;let u=false;n.config.type==="spring"?u=X(n,s):u=I(n),n.onUpdate(n.value),u||(n.active=false,n.status="completed",C.splice(r,1),n.onComplete?.());}C.length>0?E=requestAnimationFrame(J):(O=false,E=null,h=0);}function X(e,s){let{stiffness:r,damping:n,mass:u}=e.config;return d({get value(){return e.value},set value(i){e.value=i;},get velocity(){return e.velocity},set velocity(i){e.velocity=i;}},e.to,{stiffness:r,damping:n,mass:u},s)}function I(e){let{duration:s,easing:r}=e.config,n=e.elapsed,u=Math.min(n/s,1),a$1=r(u);e.value=a(e.fromValue,e.to,a$1);let i=r(Math.max(0,(n-16)/s));return e.velocity=(e.to-e.fromValue)*(a$1-i)/.016,n<s}function L(e){C.push(e),O||(O=true,h=0,E=requestAnimationFrame(J));}function U(e){let s=C.indexOf(e);s!==-1&&(C.splice(s,1),e.active=false,e.status="completed"),C.length===0&&E!==null&&(cancelAnimationFrame(E),E=null,O=false,h=0);}function M(e){e.status==="running"&&(e.status="paused",e.pauseTime=performance.now());}function N(e){if(e.status==="paused"){let s=performance.now()-e.pauseTime;e.startTime+=s,e.status="running";}}function Q(){return C.length}var w=Object.freeze({stiffness:400,damping:30,mass:1,restVelocity:.001}),$=Object.freeze({stiffness:180,damping:12,mass:1,restVelocity:.001}),H=Object.freeze({stiffness:120,damping:20,mass:1,restVelocity:.001}),q=Object.freeze({stiffness:100,damping:18,mass:2,restVelocity:.001}),z=Object.freeze({snappy:w,bouncy:$,smooth:H,heavy:q}),Z=w,j=$,ee=H,te=q,k="bouncy";function V(){return z[k]}function ne(){return k}function oe(e){k=e;}function F(e){return z[e]}var W={duration:300},b=new Map;function g(e){if(e.key!==void 0){let o=b.get(e.key);o&&o.stop();}let s=e.type??"spring",r=e.from,n=e.to,u=e.velocity??0,a=e.delay??0,i$1;if(s==="spring"){let o=e,d=(o.preset?F(o.preset):void 0)??V();i$1={type:"spring",stiffness:o.stiffness??d.stiffness,damping:o.damping??d.damping,mass:o.mass??d.mass,restVelocity:o.restVelocity??d.restVelocity,duration:0,easing:i,startTime:0};}else {let o=e;i$1={type:"duration",stiffness:0,damping:0,mass:0,restVelocity:0,duration:o.duration??W.duration,easing:o.easing??i,startTime:0};}let t={fromValue:r,value:r,to:n,velocity:u,onUpdate:e.onUpdate,...e.onComplete?{onComplete:e.onComplete}:{},config:i$1,active:true,delayRemaining:a,status:"running",startTime:0,elapsed:0,pauseTime:0};L(t);let p=true,f,l=new Promise(o=>{f=o;}),y={stop:()=>{p&&(p=false,U(t),e.key!==void 0&&b.delete(e.key),f());},setTarget:o=>{if(t.to=o,t.config.type==="duration"){let v=V();t.config.type="spring",t.config.stiffness=v.stiffness,t.config.damping=v.damping,t.config.mass=v.mass,t.config.restVelocity=v.restVelocity;}!t.active&&p&&(t.active=true,t.status="running",t.startTime=0,L(t));},pause:()=>{M(t);},resume:()=>{N(t);},getStatus:()=>t.status,getElapsed:()=>t.elapsed,getValue:()=>t.value,getVelocity:()=>t.velocity,get active(){return p&&t.active},then:o=>(l.then(o),y),get finished(){return l}};e.key!==void 0&&b.set(e.key,y);let m=t.onComplete;return t.onComplete=()=>{e.key!==void 0&&b.delete(e.key),p=false,m?.(),f();},y}function fe(e){let s=b.get(e);s&&s.stop();}function me(){for(let e of b.values())e.stop();}function de(){return b.size}var Y=e=>1-Math.pow(1-e,4);function Ce(e,s={}){let{pressScale:r=.92,pressDuration:n=80,releaseStiffness:u=500,releaseDamping:a=20}=s,i=1,t=null,p=false;function f(x){i=x,e.style.transform=`scale(${x})`;}function l(){p||(p=true,t?.stop(),t=g({from:i,to:r,type:"duration",duration:n,easing:Y,onUpdate:f}));}function y(){if(!p)return;p=false;let x=t?.getVelocity()??0;t?.stop(),t=g({from:i,to:1,type:"spring",stiffness:u,damping:a,velocity:x,onUpdate:f});}function m(x){e.setPointerCapture(x.pointerId),l();}function o(){y();}function v(){p&&y();}function d(){y();}function P(){l();}function A(){y();}function S(){l();}function c(){y();}return e.addEventListener("pointerdown",m),e.addEventListener("pointerup",o),e.addEventListener("pointerleave",v),e.addEventListener("pointercancel",d),e.addEventListener("mousedown",P),e.addEventListener("mouseup",A),e.addEventListener("touchstart",S,{passive:true}),e.addEventListener("touchend",c,{passive:true}),e.style.transformOrigin="center center",{destroy(){t?.stop(),e.removeEventListener("pointerdown",m),e.removeEventListener("pointerup",o),e.removeEventListener("pointerleave",v),e.removeEventListener("pointercancel",d),e.removeEventListener("mousedown",P),e.removeEventListener("mouseup",A),e.removeEventListener("touchstart",S),e.removeEventListener("touchend",c),e.style.transform="";}}}function he(e,s={}){let{amplitude:r=12,stiffness:n=1200,damping:u=20}=s,a=null,i=0;function t(){let f=a?.getVelocity()??0;a?.active?i:r;a?.stop();let y=a?.active?i+(i>=0?r:-r):r;a=g({from:y,to:0,velocity:f,stiffness:n,damping:u,mass:1,onUpdate:m=>{i=m,e.style.transform=`translateX(${m}px)`;},onComplete:()=>{e.style.transform="",i=0;}});}function p(){a?.stop(),e.style.transform="",i=0;}return {stop:p,shake:t,get active(){return a?.active??false}}}function Ee(e,s={}){let{amplitude:r=12,stiffness:n=1200,damping:u=20}=s;return g({from:r,to:0,stiffness:n,damping:u,mass:1,onUpdate:a=>{e.style.transform=`translateX(${a}px)`;},onComplete:()=>{e.style.transform="";}})}function Se(e,s={}){let {maxScale:r=1.05,peakOpacity:n=.6,stiffness:u=150,damping:a=25,color:i="#10b981",borderWidth:t=2}=s,p=null,f=null,l=null,m=1,o=0;function v(){if(l)return;let c=e.parentElement;if(!c)return;getComputedStyle(c).position==="static"&&(c.style.position="relative");let _=getComputedStyle(e).borderRadius||"0px";l=document.createElement("div"),l.style.cssText=`
+      position: absolute;
+      top: ${e.offsetTop-t}px;
+      left: ${e.offsetLeft-t}px;
+      width: ${e.offsetWidth+t*2}px;
+      height: ${e.offsetHeight+t*2}px;
+      border: ${t}px solid ${i};
+      border-radius: ${_};
+      pointer-events: none;
+      transform: scale(1);
+      opacity: 0;
+      box-sizing: border-box;
+    `,c.appendChild(l);}function d(){l&&(l.style.transform=`scale(${m})`,l.style.opacity=`${o}`);}function P(){v(),p?.stop(),f?.stop(),m=1,o=0,p=g({from:1,to:r,stiffness:u,damping:a,onUpdate:c=>{m=c,d();},onComplete:()=>{p=g({from:m,to:1,stiffness:u*.8,damping:a*1.2,onUpdate:c=>{m=c,d();}});}}),f=g({from:0,to:n,type:"duration",duration:100,onUpdate:c=>{o=c,d();},onComplete:()=>{f=g({from:n,to:0,type:"duration",duration:400,onUpdate:c=>{o=c,d();}});}});}function A(){p?.stop(),f?.stop(),m=1,o=0,d();}function S(){A(),l&&l.parentNode&&l.parentNode.removeChild(l),l=null;}return {pulse:P,stop:A,destroy:S,get active(){return (p?.active??false)||(f?.active??false)}}}export{L as a,U as b,M as c,N as d,Q as e,w as f,$ as g,H as h,q as i,z as j,Z as k,j as l,ee as m,te as n,V as o,ne as p,oe as q,F as r,g as s,fe as t,me as u,de as v,Ce as w,he as x,Ee as y,Se as z};//# sourceMappingURL=chunk-GZKQYUY7.js.map
+//# sourceMappingURL=chunk-GZKQYUY7.js.map