coily 0.14.0 → 0.15.0

package/dist/{system-Ci-R4RaI.d.ts → system-Du_fXXmO.d.ts}

@@ -1,276 +1,4 @@
-//#region src/config.d.ts
-/**
- * A spring's instantaneous motion, measured relative to its target.
- * `SpringDefinition.computeTimeRemaining` takes one; build it from a live
- * spring as `{ position: spring.value - spring.target, velocity: spring.velocity }`.
- */
-interface SpringState {
-  /** Displacement from the target in value units. 0 means at the target. */
-  readonly position: number;
-  /** Rate of change of the displacement, in value units per second. */
-  readonly velocity: number;
-}
-interface BaseOptions {
-  /**
-   * Decimal places of the resting threshold. A spring rests once its
-   * remaining motion cannot reach half a unit in the last place —
-   * `0.5 * 10^-precision`, or 0.005 at the default.
-   *
-   * Values are never rounded; precision only decides rest. See
-   * https://github.com/tkofh/coily/blob/main/PRECISION.md.
-   *
-   * @default 2
-   */
-  readonly precision?: number | undefined;
-}
-interface WithMass {
-  /**
-   * Mass of the moving value. Heavier springs accelerate more slowly and
-   * carry more momentum through the target. Must be greater than 0.
-   * @default 1
-   */
-  readonly mass?: number | undefined;
-}
-interface WithoutMass {
-  /**
-   * Mass is derived from the other parameters in this input shape
-   * and cannot be provided.
-   */
-  readonly mass?: undefined;
-}
-interface WithTension {
-  /**
-   * Spring stiffness. Higher tension pulls toward the target harder,
-   * making the whole motion faster. Must be greater than 0.
-   */
-  readonly tension: number;
-}
-interface WithDamping {
-  /**
-   * Friction strength. Higher damping bleeds off velocity faster and
-   * reduces bounce; at 0 the spring oscillates forever. Must be greater
-   * than or equal to 0.
-   */
-  readonly damping: number;
-}
-interface WithDampingRatio {
-  /**
-   * Damping as a fraction of critical damping — the character of the
-   * motion, independent of its speed. Below 1 the spring overshoots and
-   * bounces. At 1 it settles as fast as possible without overshooting.
-   * Above 1 it settles slower, still without overshooting. At 0 it never
-   * settles. Must be greater than or equal to 0.
-   */
-  readonly dampingRatio: number;
-}
-interface WithBounce {
-  /**
-   * Bounciness, converted to a damping ratio as `1 - bounce`. 0 settles
-   * as fast as possible without overshooting. Positive values overshoot
-   * and bounce; 1, maximum bounce, is clamped just short of undamped so
-   * the spring still settles. Negative values settle without bounce, more
-   * slowly. Must be between -1 and 1.
-   */
-  readonly bounce: number;
-}
-interface WithDuration {
-  /**
-   * Target settle time in milliseconds. The spring is tuned so its motion
-   * decays into the resting threshold within this time, assuming it
-   * starts `displacement` away from the target. Actual rest lands at or
-   * before the requested duration. Must be greater than 0.
-   */
-  readonly duration: number;
-}
-interface WithDisplacement {
-  /**
-   * The initial displacement the duration tuning assumes. Set it to your
-   * animation's range — 300 when animating 0 to 300 — so the settle
-   * timing holds; timing skews as the real displacement diverges from
-   * this value. Must not be 0.
-   * @default 1
-   */
-  readonly displacement?: number | undefined;
-}
-interface DirectOptions extends BaseOptions, WithMass, WithTension, WithDamping {}
-interface TensionRatioOptions extends BaseOptions, WithMass, WithTension, WithDampingRatio {}
-interface TensionBounceOptions extends BaseOptions, WithMass, WithTension, WithBounce {}
-interface DampingRatioOptions extends BaseOptions, WithMass, WithDamping, WithDampingRatio {}
-interface DampingBounceOptions extends BaseOptions, WithMass, WithDamping, WithBounce {}
-interface TensionDampingRatioOptions extends BaseOptions, WithoutMass, WithTension, WithDamping, WithDampingRatio {}
-interface TensionDampingBounceOptions extends BaseOptions, WithoutMass, WithTension, WithDamping, WithBounce {}
-interface DurationOptions extends BaseOptions, WithMass, WithDampingRatio, WithDuration, WithDisplacement {}
-interface BounceDurationOptions extends BaseOptions, WithMass, WithBounce, WithDuration, WithDisplacement {}
-interface TensionDurationOptions extends BaseOptions, WithoutMass, WithTension, WithDampingRatio, WithDuration, WithDisplacement {}
-interface TensionBounceDurationOptions extends BaseOptions, WithoutMass, WithTension, WithBounce, WithDuration, WithDisplacement {}
-interface DampingDurationOptions extends BaseOptions, WithoutMass, WithDamping, WithDampingRatio, WithDuration, WithDisplacement {}
-interface DampingBounceDurationOptions extends BaseOptions, WithoutMass, WithDamping, WithBounce, WithDuration, WithDisplacement {}
-/** Every option key accepted by at least one `defineSpring` input shape. */
-type SpringOptionKeys = 'mass' | 'tension' | 'damping' | 'dampingRatio' | 'bounce' | 'duration' | 'displacement' | 'precision';
-/**
- * Marks every option key foreign to `T` as "absent or undefined", so mixing
- * properties from different input shapes fails to type-check instead of
- * silently resolving to an unintended shape at runtime.
- */
-type Exact<T> = T & { [K in Exclude<SpringOptionKeys, keyof T>]?: undefined; };
-/**
- * Every input `defineSpring` accepts: one of the documented parameter
- * combinations, exactly as written — keys from different combinations
- * don't mix.
- */
-type SpringDefinitionOptions = Exact<DirectOptions> | Exact<TensionRatioOptions> | Exact<TensionBounceOptions> | Exact<DampingRatioOptions> | Exact<DampingBounceOptions> | Exact<TensionDampingRatioOptions> | Exact<TensionDampingBounceOptions> | Exact<DurationOptions> | Exact<BounceDurationOptions> | Exact<TensionDurationOptions> | Exact<TensionBounceDurationOptions> | Exact<DampingDurationOptions> | Exact<DampingBounceDurationOptions>;
-/**
- * Immutable, resolved spring parameters. Whatever `defineSpring` input
- * shape produced it, a config carries concrete `mass`, `tension`,
- * `damping`, and `precision`, plus the quantities derived from them.
- * Instances are frozen and safe to share between springs; to change a
- * spring's behavior, assign a new config via `spring.config`.
- */
-declare class SpringDefinition {
-  /** The config for springs created without one: critically damped, settling in about 500ms. */
-  static readonly default: SpringDefinition;
-  /** Mass of the moving value, as provided or derived. */
-  readonly mass: number;
-  /** Spring stiffness, as provided or derived. */
-  readonly tension: number;
-  /** Friction strength, as provided or derived. */
-  readonly damping: number;
-  /** Decimal places of the resting threshold — see `restingMagnitude`. */
-  readonly precision: number;
-  /** Oscillation rate with no damping: `sqrt(tension / mass)`, in radians per second. */
-  readonly naturalFrequency: number;
-  /** The damping at which bounce disappears: `2 * mass * naturalFrequency`. */
-  readonly criticalDamping: number;
-  /**
-   * `damping / criticalDamping`. Below 1 the spring overshoots and
-   * bounces, at 1 it settles fastest without overshooting, above 1 it
-   * settles slower.
-   */
-  readonly dampingRatio: number;
-  /** Resting threshold in value units: half a unit in the last `precision` place. */
-  readonly restingMagnitude: number;
-  constructor(input: SpringDefinitionOptions);
-  /**
-   * Estimates how long a spring with this config takes to come to rest
-   * from `state`, in milliseconds.
-   *
-   * The estimate follows the motion's decay envelope with a 2x safety
-   * margin, so actual rest usually lands earlier. Returns 0 when `state`
-   * is already inside the resting threshold, and Infinity when the config
-   * never settles (a `dampingRatio` of 0).
-   */
-  computeTimeRemaining(state: SpringState): number;
-}
-/**
- * Creates a config from direct physical parameters: you set stiffness
- * and friction exactly.
- */
-declare function defineSpring(input: Exact<DirectOptions>): SpringDefinition;
-/**
- * Creates a config from stiffness and motion character. Damping is
- * derived as `2 * dampingRatio * sqrt(mass * tension)`.
- */
-declare function defineSpring(input: Exact<TensionRatioOptions>): SpringDefinition;
-/**
- * Creates a config from stiffness and bounciness. Damping is derived to
- * match the requested bounce, from -1 (no bounce, slow settle) to 1
- * (maximum bounce).
- */
-declare function defineSpring(input: Exact<TensionBounceOptions>): SpringDefinition;
-/**
- * Creates a config from friction and motion character. Tension is
- * derived as `damping^2 / (4 * dampingRatio^2 * mass)`; `dampingRatio`
- * must be greater than 0.
- */
-declare function defineSpring(input: Exact<DampingRatioOptions>): SpringDefinition;
-/**
- * Creates a config from friction and bounciness. Tension is derived to
- * match the requested bounce; `bounce` must be less than 1.
- */
-declare function defineSpring(input: Exact<DampingBounceOptions>): SpringDefinition;
-/**
- * Creates a config from all three physical knobs. Mass is derived as
- * `damping^2 / (4 * dampingRatio^2 * tension)` and cannot be provided;
- * `dampingRatio` must be greater than 0.
- */
-declare function defineSpring(input: Exact<TensionDampingRatioOptions>): SpringDefinition;
-/**
- * Creates a config from all three physical knobs. Mass is derived from
- * tension, damping, and the requested bounce, and cannot be provided;
- * `bounce` must be less than 1.
- */
-declare function defineSpring(input: Exact<TensionDampingBounceOptions>): SpringDefinition;
-/**
- * Tunes the spring to settle within `duration` milliseconds, with
- * `dampingRatio` setting the motion's character. Tension and damping are
- * both derived.
- *
- * The timing assumes the motion starts `displacement` (default 1) away
- * from the target — pass a `displacement` matching your animation range
- * for accurate timing.
- *
- * @example
- * ```ts
- * // Tuned for a 300px move; rests within 750ms
- * defineSpring({ duration: 750, dampingRatio: 1, displacement: 300 })
- * ```
- */
-declare function defineSpring(input: Exact<DurationOptions>): SpringDefinition;
-/**
- * Tunes the spring to settle within `duration` milliseconds, with
- * `bounce` setting how oscillatory the settling motion is. Tension and
- * damping are both derived.
- *
- * The timing assumes the motion starts `displacement` (default 1) away
- * from the target — pass a `displacement` matching your animation range
- * for accurate timing.
- */
-declare function defineSpring(input: Exact<BounceDurationOptions>): SpringDefinition;
-/**
- * Tunes a spring of the given stiffness to settle within `duration`
- * milliseconds. Mass is derived from tension and the computed natural
- * frequency, then damping from mass and `dampingRatio`; mass cannot be
- * provided.
- *
- * The timing assumes the motion starts `displacement` (default 1) away
- * from the target — pass a `displacement` matching your animation range
- * for accurate timing.
- */
-declare function defineSpring(input: Exact<TensionDurationOptions>): SpringDefinition;
-/**
- * Tunes a spring of the given stiffness to settle within `duration`
- * milliseconds, with `bounce` setting how oscillatory the settling motion
- * is. Mass is derived from tension and the computed natural frequency,
- * and cannot be provided.
- *
- * The timing assumes the motion starts `displacement` (default 1) away
- * from the target — pass a `displacement` matching your animation range
- * for accurate timing.
- */
-declare function defineSpring(input: Exact<TensionBounceDurationOptions>): SpringDefinition;
-/**
- * Tunes a spring of the given friction to settle within `duration`
- * milliseconds. Mass is derived from damping, `dampingRatio`, and the
- * computed natural frequency, then tension from mass; mass cannot be
- * provided.
- *
- * The timing assumes the motion starts `displacement` (default 1) away
- * from the target — pass a `displacement` matching your animation range
- * for accurate timing.
- */
-declare function defineSpring(input: Exact<DampingDurationOptions>): SpringDefinition;
-/**
- * Tunes a spring of the given friction to settle within `duration`
- * milliseconds, with `bounce` setting how oscillatory the settling motion
- * is. Mass is derived from damping and the computed natural frequency,
- * and cannot be provided.
- *
- * The timing assumes the motion starts `displacement` (default 1) away
- * from the target — pass a `displacement` matching your animation range
- * for accurate timing.
- */
-declare function defineSpring(input: Exact<DampingBounceDurationOptions>): SpringDefinition;
-//#endregion
+import { t as SpringDefinition } from "./config-OOMMRdK8.js";
 //#region src/flush-queue.d.ts
 /**
  * Defers callbacks while inside a batch or tick: `request` runs the
@@ -295,8 +23,41 @@ declare class FlushQueue {
  */
 declare class Motion {
   #private;
+  /** Monotone creation id: breaks ties wherever motions need a deterministic order. */
+  readonly _id: number;
   /** Tick-pass marker written by `MotionSet` so a motion re-added mid-pass isn't ticked twice. */
   _pass: number;
+  /**
+   * Frame marker written by `MotionSet`: sub-steps share one frame, and
+   * the first advance in it queues the motion for the settle sweep.
+   */
+  _frame: number;
+  /**
+   * Dependency rank written by `FollowGraph`: motions the follow graph
+   * touches count up from 0, leaders before followers; -1 marks a motion
+   * outside the graph.
+   */
+  _rank: number;
+  /**
+   * The edge this motion follows through, or null. Written by
+   * `FollowGraph` on edge add/remove so the tick's hot loop reads a
+   * field instead of a map.
+   */
+  _edge: FollowEdge | null;
+  /**
+   * A first-order-hold ramp slope in value units per second, armed by a
+   * ramped `recouple` immediately before the `_advance` that consumes
+   * it (read-and-clear; no user code runs between the two). 0 means the
+   * target holds still across the step — every path but a ramped
+   * recouple.
+   */
+  _ramp: number;
+  /**
+   * The edges reading this motion, or null when none. Written by
+   * `FollowGraph` with the rank cache, so it can lag a mid-pass edge
+   * change until the next recompute; the tick tolerates stale entries.
+   */
+  _followers: FollowEdge[] | null;
   respectsReducedMotion: boolean;
   constructor(config: SpringDefinition, position: number, velocity: number);
   get position(): number;
@@ -307,7 +68,42 @@ declare class Motion {
   get isResting(): boolean;
   configure(config: SpringDefinition): void;
   tick(dt: number, emit?: boolean): void;
+  /**
+   * Advances the simulation and emits nothing. The tick pass advances
+   * every motion through this, then delivers the frame's events with
+   * `_settleFrame`; the synchronous `tick` wraps the two.
+   *
+   * A pending `_ramp` integrates the step against a target moving at
+   * that slope instead of holding still: one affine transform around
+   * the unchanged solver. With the target at `p(t) = p0 + g*t`, the
+   * displacement u = x - p(t) obeys the homogeneous equation shifted by
+   * the constant u_ss = -(2*zeta/wn)*g = -(damping/tension)*g, so the
+   * solver ticks w = u - u_ss exactly and the results shift back.
+   * Measuring u from the moving target makes the ramp endpoint and the
+   * new target coincide — the armer assigns the target, no rebase
+   * arithmetic exists. The ramp is an argument of the step, never
+   * persistent solver state: g = 0 takes the plain step below, so a
+   * motion that never ramps steps bit-exactly like an isolated spring.
+   */
+  _advance(dt: number): void;
+  /**
+   * Emits the frame's `update`, then reconciles `stop`/`start`. The tick
+   * pass calls this in dependency order after every motion has advanced,
+   * so update callbacks read frame-final values everywhere.
+   */
+  _settleFrame(): void;
   finish(): void;
+  /**
+   * The sub-step controller's shock signal, read by a follower's `plan`
+   * with this motion as its leader: deviation from the quasi-steady
+   * tracking manifold x = -(damping/tension) * v, where damping/tension
+   * is 2*zeta/wn. Near zero while chasing any smoothly moving target at
+   * any speed; the full displacement after a target teleport;
+   * (damping/tension) * |v| after a fling.
+   */
+  _manifoldDeviation(): number;
+  /** Acceleration from current state, for `plan`'s kinematic bound on a shock frame. */
+  _acceleration(): number;
   onUpdate(callback: () => void): () => void;
   onStart(callback: () => void): () => void;
   onStop(callback: () => void): () => void;
@@ -315,6 +111,86 @@ declare class Motion {
   dispose(): void;
 }
 //#endregion
+//#region src/follow-graph.d.ts
+/**
+ * One follow relationship, as the system sees it: which motion
+ * retargets, which motions it reads, how to re-anchor it, and the
+ * sub-step controller's per-edge state. `Spring` registers an edge when
+ * a follow is wired to a source with resolvable motions, and
+ * unregisters it on unfollow and dispose.
+ */
+interface FollowEdge {
+  /** The motion that retargets when its leaders advance. */
+  readonly follower: Motion;
+  /** The distinct motions behind the followed source, per `resolveLeaderMotions`. */
+  readonly leaders: readonly Motion[];
+  /**
+   * Whether the follower shares a Tarjan SCC with any of its leaders,
+   * self-follow included. Written by `FollowGraph` on recompute. Routes
+   * `plan` to the ZOH sub-step law: FOH destabilizes cycles that are
+   * stable under ZOH, so no ramp may ever arm inside an SCC.
+   */
+  _cyclic: boolean;
+  /** The follower's target as of the last `plan` call. */
+  _prevValue: number;
+  /** The followed value's frame delta observed by the last `plan` call. */
+  _d1: number;
+  /** The frame delta one older than `_d1`; their difference estimates curvature. */
+  _d2: number;
+  /**
+   * Re-anchors the follower to the followed source's current value.
+   * `h` is the step the follower is about to advance by, in seconds
+   * (the internal tick unit). On an edge where a ramp may arm —
+   * acyclic, passthrough arrival, `h > 0`, not a reduced-motion jump —
+   * it retargets and arms the follower's `_ramp` with the delta over
+   * `h`, so the coming advance integrates against the leader's motion.
+   * Every other edge retargets with the exact semantics of the
+   * leader-update handler (finite guard, reduced-motion jump).
+   */
+  recouple(h: number): void;
+  /**
+   * Refreshes the estimator from the follower's current target and
+   * returns this edge's sub-step demand for a frame of `dt` seconds —
+   * unclamped; the caller maxes over edges and clamps. Runs no user
+   * code: history is the target trail, freshness reads leader motion
+   * state. Call at most once per edge per frame, before any motion
+   * advances.
+   */
+  plan(dt: number): number;
+}
+/**
+ * The follow graph as a walkable structure: one edge per following
+ * motion, and a cached dependency rank over every motion the edges
+ * touch. `MotionSet` owns one; springs register and unregister edges as
+ * follows are wired and torn down. What the tick reads per motion —
+ * `_edge`, `_followers`, `_rank` — lives on the motions themselves;
+ * this class is their writer.
+ */
+declare class FollowGraph {
+  #private;
+  /** Whether no edges are registered, letting the tick skip ordering work entirely. */
+  get isEmpty(): boolean;
+  /** Every registered edge, valid after `ensureOrder`; the plan pass walks this once per frame. */
+  get edges(): readonly FollowEdge[];
+  /**
+   * Registers `edge`, replacing any edge with the same follower: a
+   * spring follows at most one source at a time.
+   */
+  addEdge(edge: FollowEdge): void;
+  /** Drops the edge whose follower is `motion`, if one is registered. */
+  removeEdge(follower: Motion): void;
+  /**
+   * Recomputes ranks if an edge was added or removed since the last
+   * call; clean calls return immediately. Afterward, motions the graph
+   * touches hold ranks counting up from 0 with every leader ranked
+   * before its followers, members of a cycle rank in ascending creation
+   * id, and motions outside the graph hold -1. Ranks are canonical: a
+   * function of graph structure and creation order, never of wiring
+   * order.
+   */
+  ensureOrder(): void;
+}
+//#endregion
 //#region src/motion-set.d.ts
 /**
  * The set of motions currently moving. Motions leave the set as they
@@ -325,7 +201,16 @@ declare class MotionSet {
   #private;
   reduced: boolean;
   onWake: (() => void) | null;
+  /**
+   * The coupling error budget, in value units: the local per-frame error
+   * the sub-step controller targets on each follow edge, floored by the
+   * follower's resting magnitude. `SpringSystem` exposes it as the
+   * `couplingTolerance` option and property; validation lives there.
+   */
+  couplingTolerance: number;
   readonly flushes: FlushQueue;
+  /** Follow edges registered by following springs, with the dependency rank over their motions. */
+  readonly graph: FollowGraph;
   constructor(debug?: boolean);
   get size(): number;
   add(motion: Motion): void;
@@ -608,11 +493,16 @@ declare class Spring implements KinematicSource {
   get dampingRatio(): number;
   /** The config's resting precision. */
   get precision(): number;
+  /** The config's arrival multiplier. */
+  get arrival(): number;
   set config(value: SpringDefinition | null);
   /**
-   * Estimated milliseconds until the spring rests: 0 while resting,
-   * Infinity when undamped. The estimate carries a safety margin, so
-   * actual rest usually lands earlier.
+   * Milliseconds until the spring rests: 0 while resting, Infinity when
+   * the motion never settles. The time is solved from the motion, not
+   * estimated — the spring is resting at the first tick at or after it,
+   * and a bouncy spring can rest up to one oscillation earlier when a
+   * frame samples a low pulse. When the config's `arrival` is 0, it is
+   * capped at the exact ms of the first target crossing.
    */
   get timeRemaining(): number;
   /**
@@ -919,6 +809,17 @@ interface CompositeSpringOptions<T extends object> {
   purpose?: PurposeShape<T> | undefined;
 }
 interface SpringSystemOptions extends TickerOptions {
+  /**
+   * How far a spring may trail a source it follows within one frame, in
+   * the value's own units. A frame whose motion would exceed it is split
+   * into internal sub-steps (at most 8), so followed chains stay
+   * accurate through slow frames and sudden retargets. Smaller is
+   * tighter and costs more solver work; it never goes finer than the
+   * follower's resting precision, and listeners still fire once per
+   * frame. Springs that follow nothing are unaffected.
+   * @default 0.1
+   */
+  couplingTolerance?: number | undefined;
   /**
    * Log active motion counts to the console whenever they change.
    * @default false
@@ -996,6 +897,13 @@ interface SpringSystem {
    * created with `purpose: 'appearance'` animate regardless.
    */
   readonly reducedMotion: boolean;
+  /**
+   * How far a spring may trail a source it follows within one frame, in
+   * the value's own units — see the `couplingTolerance` option.
+   * Assignment accepts any finite number >= 0 and applies from the next
+   * frame; 0 means as fine as the follower's resting precision allows.
+   */
+  couplingTolerance: number;
   /**
    * Frame-rate cap. 0 means uncapped: one tick per displayed frame,
    * whatever rate the screen runs at. Capped ticks land on whole display
@@ -1029,4 +937,4 @@ interface SpringSystem {
  */
 declare function createSpringSystem(options?: SpringSystemOptions): SpringSystem;
 //#endregion
-export { SpringDefinitionOptions as C, SpringDefinition as S, defineSpring as T, accelerationOf as _, createSpringSystem as a, SpringSourceSymbol as b, ConfigShape as c, ReadonlyShape as d, Shape as f, KinematicSource as g, SpringTarget as h, SpringSystemOptions as i, PartialShape as l, Spring as m, SpringOptions as n, CompositeSpring as o, Purpose as p, SpringSystem as r, CompositeSpringTarget as s, CompositeSpringOptions as t, PurposeShape as u, velocityOf as v, SpringState as w, mapSpring as x, SpringSource as y };
+export { accelerationOf as _, createSpringSystem as a, SpringSourceSymbol as b, ConfigShape as c, ReadonlyShape as d, Shape as f, KinematicSource as g, SpringTarget as h, SpringSystemOptions as i, PartialShape as l, Spring as m, SpringOptions as n, CompositeSpring as o, Purpose as p, SpringSystem as r, CompositeSpringTarget as s, CompositeSpringOptions as t, PurposeShape as u, velocityOf as v, mapSpring as x, SpringSource as y };

package/dist/vue.d.ts

@@ -1,4 +1,5 @@
-import { C as SpringDefinitionOptions, S as SpringDefinition, c as ConfigShape, d as ReadonlyShape, f as Shape, i as SpringSystemOptions, l as PartialShape, m as Spring, n as SpringOptions, o as CompositeSpring, p as Purpose, r as SpringSystem, t as CompositeSpringOptions, y as SpringSource } from "./system-Ci-R4RaI.js";
+import { n as SpringDefinitionOptions, t as SpringDefinition } from "./config-OOMMRdK8.js";
+import { c as ConfigShape, d as ReadonlyShape, f as Shape, i as SpringSystemOptions, l as PartialShape, m as Spring, n as SpringOptions, o as CompositeSpring, p as Purpose, r as SpringSystem, t as CompositeSpringOptions, y as SpringSource } from "./system-Du_fXXmO.js";
 import { App, MaybeRefOrGetter, Ref, SlotsType } from "vue";
 //#region src/vue/reactive-spring.d.ts
 /**

package/dist/vue.js

@@ -1,4 +1,4 @@
-import { a as SpringDefinition, n as SpringSourceSymbol, r as isSpringSource, t as createSpringSystem } from "./system-BXxAHM2a.js";
+import { n as SpringSourceSymbol, o as SpringDefinition, r as isSpringSource, t as createSpringSystem } from "./system-Br_cPnaN.js";
 import { computed, customRef, defineComponent, getCurrentInstance, getCurrentScope, inject, onBeforeUnmount, onMounted, onScopeDispose, provide, toRefs, toValue, watchSyncEffect } from "vue";
 //#region src/vue/local.ts
 const localProvides = /* @__PURE__ */ new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coily",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Simulate values using spring physics",
   "homepage": "https://github.com/tkofh/coily#readme",
   "bugs": {
@@ -19,6 +19,7 @@
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.js",
+    "./css": "./dist/css.js",
     "./nuxt": "./dist/nuxt.js",
     "./vue": "./dist/vue.js",
     "./package.json": "./package.json"