{"version":3,"file":"animate-jcotZdO1.cjs","sources":["../src/scheduler/driver.ts","../src/scheduler/scheduler.ts","../src/scheduler/shared.ts","../src/physics/easings.ts","../src/value/warn.ts","../src/physics/easing-registry.ts","../src/a11y/config.ts","../src/a11y/reduced-motion.ts","../src/physics/decay.ts","../src/physics/motion.ts","../src/physics/spring.ts","../src/physics/tween.ts","../src/value/lifecycle.ts","../src/value/thenable.ts","../src/value/animatable.ts","../src/dom/transform.ts","../src/dom/bind-style.ts","../src/value/value-type.ts","../src/dom/read-style.ts","../src/dom/bind-property.ts","../src/value/channel-group.ts","../src/value/types/color.ts","../src/value/types/complex.ts","../src/value/types/length.ts","../src/value/types/number.ts","../src/value/registry.ts","../src/compose/wait.ts","../src/dom/keyframes.ts","../src/dom/resolve-target.ts","../src/dom/resolve-value.ts","../src/dom/units.ts","../src/dom/animate.ts"],"sourcesContent":["/** Cancels a frame scheduled via FrameDriver.schedule. */\nexport type CancelFrame = () => void\n\n/**\n * Source of display frames. The production driver wraps requestAnimationFrame;\n * tests inject a manual driver to control timestamps deterministically.\n * The scheduler is the only consumer - no other module may schedule frames.\n */\nexport interface FrameDriver {\n schedule(callback: (timestampMs: number) => void): CancelFrame\n}\n\n// Browser globals are only touched when schedule() is called, never at module\n// evaluation - importing the core must stay safe under SSR.\nexport const rafDriver: FrameDriver = {\n schedule(callback) {\n const id = requestAnimationFrame(callback)\n return () => cancelAnimationFrame(id)\n },\n}\n","import type { CancelFrame, FrameDriver } from './driver'\n\nexport interface FrameInfo {\n /** Time since the previous frame, in ms. 0 on the first frame after a wake. */\n deltaMs: number\n /** Driver timestamp of this frame, in ms. */\n timestampMs: number\n}\n\nexport type FrameCallback = (frame: FrameInfo) => void\n\n/**\n * 'update' (default) runs simulations; 'render' runs DOM writes, after every\n * update of the same tick. A render subscription made during the update phase\n * still runs this tick - that is what lets bindings batch all style writes\n * produced by a frame into a single flush.\n */\nexport type FramePhase = 'update' | 'render'\n\nexport interface Scheduler {\n /** Register a per-frame callback. Starts the loop if it was sleeping. */\n subscribe(callback: FrameCallback, phase?: FramePhase): () => void\n isRunning(): boolean\n}\n\n/**\n * Upper bound on the delta fed to subscribers. After a freeze (inactive tab,\n * GC pause, breakpoint) the lost time is dropped, never replayed: physics\n * must not teleport.\n */\nexport const MAX_FRAME_DELTA_MS = 64\n\nexport function createScheduler(driver: FrameDriver): Scheduler {\n const updateSubscribers = new Set()\n const renderSubscribers = new Set()\n let cancelFrame: CancelFrame | null = null\n let lastTimestampMs: number | null = null\n let running = false\n let inTick = false\n\n const count = () => updateSubscribers.size + renderSubscribers.size\n\n const stop = () => {\n cancelFrame?.()\n cancelFrame = null\n lastTimestampMs = null\n running = false\n }\n\n // Snapshot: subscriptions made during a phase start at that phase's next\n // run. The membership check skips callbacks removed earlier in the tick.\n const runPhase = (subscribers: Set, frame: FrameInfo) => {\n for (const callback of [...subscribers]) {\n if (subscribers.has(callback)) callback(frame)\n }\n }\n\n const tick = (timestampMs: number) => {\n const deltaMs =\n lastTimestampMs === null\n ? 0\n : Math.min(timestampMs - lastTimestampMs, MAX_FRAME_DELTA_MS)\n lastTimestampMs = timestampMs\n const frame: FrameInfo = { deltaMs, timestampMs }\n\n inTick = true\n runPhase(updateSubscribers, frame)\n runPhase(renderSubscribers, frame) // snapshot after updates: same-tick flushes\n inTick = false\n\n if (count() > 0) {\n cancelFrame = driver.schedule(tick)\n } else {\n cancelFrame = null\n stop()\n }\n }\n\n return {\n subscribe(callback, phase = 'update') {\n const subscribers = phase === 'render' ? renderSubscribers : updateSubscribers\n subscribers.add(callback)\n if (!running) {\n running = true\n cancelFrame = driver.schedule(tick)\n }\n return () => {\n subscribers.delete(callback)\n // Mid-tick, the loop decides for itself at the end of the tick.\n if (count() === 0 && running && !inTick) stop()\n }\n },\n isRunning: () => running,\n }\n}\n","import { rafDriver } from './driver'\nimport { createScheduler, type Scheduler } from './scheduler'\n\n// All animatables and bindings batch into the same rAF loop. Created lazily\n// so that merely importing the core never touches browser globals (SSR-safe).\nlet shared: Scheduler | null = null\n\nexport const getSharedScheduler = (): Scheduler => (shared ??= createScheduler(rafDriver))\n","/** Easing over normalized progress [0, 1] -> [0, 1]. */\nexport type Easing = (progress: number) => number\n\nexport const linear: Easing = (p) => p\nexport const easeInCubic: Easing = (p) => p * p * p\nexport const easeOutCubic: Easing = (p) => 1 - (1 - p) ** 3\nexport const easeInOutCubic: Easing = (p) => (p < 0.5 ? 4 * p ** 3 : 1 - (-2 * p + 2) ** 3 / 2)\n","// Deduplicated, prefixed console.warn for design-boundary conditions:\n// unconvertible units, snap fallbacks, shorthand traps. One message per key\n// for the lifetime of the process - never a per-frame log. Ships always-on\n// (no __DEV__ dual build: it would complicate the exports map and the size\n// gate); the message text is centralized and budgeted instead.\nconst seen = new Set()\n\nexport function warnOnce(key: string, message: string): void {\n if (seen.has(key)) return\n seen.add(key)\n console.warn(`[underlying] ${message}`)\n}\n\n/** Test-only: clears the dedup set so a fresh key warns again. Not exported from the entry. */\nexport function __resetWarnings(): void {\n seen.clear()\n}\n","import { warnOnce } from '../value/warn'\nimport { easeInOutCubic, type Easing } from './easings'\n\n/** A passed easing: a function, or a named ease by string ('power2.out', 'elastic.out(1, 0.3)'). */\nexport type EasingInput = Easing | string\n\nexport type EasingVariant = 'in' | 'out' | 'inOut'\n\n/** Builds the actual easing for a named family, given the variant and any numeric params. */\nexport type EasingFactory = (variant: EasingVariant, params: ReadonlyArray) => Easing\n\n// Named ease families live here. Nothing is registered at module scope - a\n// top-level set() would pin this into the primitives tree-shake graph;\n// @underlying/utils registers the families on import instead.\nconst registry = new Map()\n\n/** Register a named ease family ('power2', 'elastic', 'steps', ...) so strings resolve. */\nexport function registerEasing(name: string, factory: EasingFactory): void {\n registry.set(name.toLowerCase(), factory)\n}\n\nconst SPEC = /^([a-z]+\\d*)(?:\\.(inout|in|out))?(?:\\(([^)]*)\\))?$/i\n\nconst parseSpec = (spec: string): { name: string; variant: EasingVariant; params: number[] } | null => {\n const match = SPEC.exec(spec.trim())\n if (match === null) return null\n const variantRaw = match[2]?.toLowerCase()\n const variant: EasingVariant = variantRaw === 'in' ? 'in' : variantRaw === 'inout' ? 'inOut' : 'out'\n const params =\n match[3] !== undefined && match[3].trim() !== '' ? match[3].split(',').map((part) => Number(part.trim())) : []\n return { name: match[1]!.toLowerCase(), variant, params }\n}\n\n/**\n * Resolve a function-or-name into an Easing. Functions pass through untouched;\n * an unknown name warns once and falls back to easeInOutCubic.\n */\nexport function resolveEasing(input: EasingInput): Easing {\n if (typeof input !== 'string') return input\n const parsed = parseSpec(input)\n if (parsed !== null) {\n const factory = registry.get(parsed.name)\n if (factory !== undefined) return factory(parsed.variant, parsed.params)\n }\n warnOnce(\n `easing:${input}`,\n `unknown easing \"${input}\" - import @underlying/utils to register named eases. Using easeInOutCubic.`,\n )\n return easeInOutCubic\n}\n","/**\n * What happens when the user prefers reduced motion:\n * - 'skip' (default): animations land instantly on their rest state\n * - 'fade' : movement snaps, element-level opacity still animates (animate())\n * - 'allow' : motion plays normally (only for essential, e.g. gesture-driven, motion)\n */\nexport type ReducedMotionBehavior = 'skip' | 'fade' | 'allow'\n\n/** Per-animation override on a raw value - fade only makes sense element-side. */\nexport type ReducedMotionOverride = 'skip' | 'allow'\n\nlet behavior: ReducedMotionBehavior = 'skip'\n\nexport const setReducedMotionBehavior = (next: ReducedMotionBehavior): void => {\n behavior = next\n}\n\nexport const getReducedMotionBehavior = (): ReducedMotionBehavior => behavior\n","type ReducedMotionListener = (reduced: boolean) => void\n\n// Lazy: browser globals are only touched on first use, never at import\n// (SSR-safe). The media query is watched so mid-session OS toggles are\n// reflected in every subsequent animation start. An app-level override\n// (in-app accessibility toggle, demos, tests) takes precedence over the OS.\nlet initialized = false\nlet current = false\nlet override: boolean | null = null\nconst listeners = new Set()\n\nconst effective = (): boolean => override ?? current\n\nconst notifyIfChanged = (before: boolean) => {\n const after = effective()\n if (after === before) return\n for (const listener of [...listeners]) listener(after)\n}\n\nconst init = () => {\n if (initialized) return\n initialized = true\n if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return\n const query = window.matchMedia('(prefers-reduced-motion: reduce)')\n current = query.matches\n query.addEventListener('change', (event) => {\n const before = effective()\n current = event.matches\n notifyIfChanged(before)\n })\n}\n\n/** Current effective preference (override, else OS). False when no DOM. */\nexport function prefersReducedMotion(): boolean {\n init()\n return effective()\n}\n\n/**\n * App-level override of the OS preference - in-app accessibility toggles.\n * `null` returns control to the OS media query.\n */\nexport function setReducedMotionOverride(value: boolean | null): void {\n init()\n const before = effective()\n override = value\n notifyIfChanged(before)\n}\n\n/** Notifies on effective preference changes. Returns an unsubscribe. */\nexport function onReducedMotionChange(listener: ReducedMotionListener): () => void {\n init()\n listeners.add(listener)\n return () => {\n listeners.delete(listener)\n }\n}\n\n/** Test-only: clears the cached media query state. Not part of the public API. */\nexport function __resetReducedMotion(): void {\n initialized = false\n current = false\n override = null\n listeners.clear()\n}\n","import type { ReducedMotionOverride } from '../a11y/config'\nimport type { Simulation } from './simulation'\n\nexport interface DecayOptions {\n /** Per-animation override of the reduced-motion behavior. */\n reducedMotion?: ReducedMotionOverride\n /** Initial velocity in units/s; defaults to the value's current velocity. */\n velocity?: number\n /** Exponential time constant, in ms. Higher = longer glide. Total distance ~ v0 * tau. */\n timeConstant?: number\n /** Rest when |velocity| < restSpeed (units/s). */\n restSpeed?: number\n /** Optional clamp boundary: crossing it turns the glide into a spring toward the edge. */\n min?: number\n max?: number\n bounceStiffness?: number\n bounceDamping?: number\n restDelta?: number\n}\n\nexport function decaySimulation(options: DecayOptions = {}): Simulation {\n const {\n timeConstant = 325,\n restSpeed = 0.1,\n min,\n max,\n bounceStiffness = 500,\n bounceDamping = 40,\n restDelta = 0.01,\n } = options\n const tauS = timeConstant / 1000\n\n // Latched: once a boundary is crossed the spring stays in charge, even back\n // inside the range - otherwise inward velocity would decay-glide away from\n // the edge instead of settling on it. One simulation instance per animation.\n let edge: number | null = null\n const checkEdge = (position: number): number | null => {\n if (edge === null) {\n if (min !== undefined && position < min) edge = min\n else if (max !== undefined && position > max) edge = max\n }\n return edge\n }\n\n return {\n acceleration(position, velocity) {\n const boundary = checkEdge(position)\n if (boundary !== null) return -bounceStiffness * (position - boundary) - bounceDamping * velocity\n return -velocity / tauS\n },\n rest(position, velocity) {\n const boundary = checkEdge(position)\n if (boundary !== null) {\n return Math.abs(velocity) < restSpeed && Math.abs(position - boundary) < restDelta\n ? boundary\n : null\n }\n return Math.abs(velocity) < restSpeed ? position : null\n },\n }\n}\n","import { stepSimulation, type Simulation, type SimulationState } from './simulation'\n\n/**\n * What the Animatable actually drives: anything that advances a\n * (position, velocity) state by fixed timesteps and knows when it is done.\n * Physics modes wrap a Simulation; the duration/easing escape hatch samples\n * a curve instead - same state shape, so handoff between modes is free.\n */\nexport interface Motion {\n step(state: SimulationState, timestepS: number): SimulationState\n /** Settled position when the state qualifies as rest, null while moving. */\n rest(state: SimulationState): number | null\n}\n\n/**\n * A Motion whose elapsed clock can be repositioned: the seek seam for duration\n * tweens and baked-spring tables. A live spring/decay is NOT seekable - it has\n * no fixed durationS - so simulationMotion stays a plain Motion.\n */\nexport interface SeekableMotion extends Motion {\n /** Reposition to an absolute elapsed time (seconds); returns the sample there. Next step() continues from it. */\n seek(elapsedS: number): SimulationState\n /** Total elapsed at rest (seconds). Tweens: the duration. Sampled tables: the last entry. */\n readonly durationS: number\n}\n\nexport function simulationMotion(simulation: Simulation): Motion {\n return {\n step: (state, timestepS) => stepSimulation(simulation, state, timestepS),\n rest: (state) => simulation.rest(state.position, state.velocity),\n }\n}\n","import type { ReducedMotionOverride } from '../a11y/config'\nimport type { Simulation } from './simulation'\n\nexport interface SpringOptions {\n /** Per-animation override of the reduced-motion behavior. */\n reducedMotion?: ReducedMotionOverride\n stiffness?: number\n damping?: number\n mass?: number\n /** Initial velocity in units/s - handoff from a gesture (drag -> release). */\n velocity?: number\n /** Rest requires |position - target| < restDelta... */\n restDelta?: number\n /** ...AND |velocity| < restSpeed (units/s). */\n restSpeed?: number\n}\n\n/** A spring whose target can be re-aimed in place: no Motion rebuild on a moving target (follow). */\nexport interface RetargetableSpring extends Simulation {\n retarget(target: number): void\n}\n\nexport function springSimulation(target: number, options: SpringOptions = {}): RetargetableSpring {\n const { stiffness = 100, damping = 10, mass = 1, restDelta = 0.01, restSpeed = 0.1 } = options\n let aim = target\n return {\n acceleration: (position, velocity) => (-stiffness * (position - aim) - damping * velocity) / mass,\n rest: (position, velocity) =>\n Math.abs(velocity) < restSpeed && Math.abs(position - aim) < restDelta ? aim : null,\n retarget: (next) => {\n aim = next\n },\n }\n}\n","import type { ReducedMotionOverride } from '../a11y/config'\nimport { resolveEasing, type EasingInput } from './easing-registry'\nimport { easeInOutCubic } from './easings'\nimport type { SeekableMotion } from './motion'\nimport { SIMULATION_TIMESTEP_S, type SimulationState } from './simulation'\n\nexport interface ToOptions {\n /** ms */\n duration?: number\n /** A function, or a named ease by string once @underlying/utils is imported ('power2.out'). */\n easing?: EasingInput\n /** Per-animation override of the reduced-motion behavior. */\n reducedMotion?: ReducedMotionOverride\n}\n\n/**\n * Duration/easing escape hatch. Sampled on the same fixed-step clock as the\n * physics, with a finite-difference velocity - so even a tween can hand off\n * to a spring mid-flight. Incoming velocity is ignored: a tween is positional\n * control. Seekable: it owns its elapsed clock, so the playback layer can jump\n * the playhead. One instance per animation.\n */\nexport function tweenMotion(from: number, to: number, options: ToOptions = {}): SeekableMotion {\n const durationS = (options.duration ?? 300) / 1000\n const easing = resolveEasing(options.easing ?? easeInOutCubic)\n let elapsedS = 0\n\n const positionAt = (t: number): number => {\n const progress = durationS <= 0 ? 1 : Math.min(Math.max(t, 0) / durationS, 1)\n return progress >= 1 ? to : from + (to - from) * easing(progress)\n }\n\n return {\n step(state, timestepS) {\n elapsedS += timestepS\n const position = positionAt(elapsedS)\n return { position, velocity: (position - state.position) / timestepS }\n },\n rest: () => (elapsedS >= durationS ? to : null),\n durationS,\n seek(target): SimulationState {\n elapsedS = durationS <= 0 ? durationS : Math.min(Math.max(target, 0), durationS)\n const position = positionAt(elapsedS)\n // Curve derivative via a central finite difference clamped to [0, durationS].\n const hi = Math.min(elapsedS + SIMULATION_TIMESTEP_S, durationS)\n const lo = Math.max(elapsedS - SIMULATION_TIMESTEP_S, 0)\n const span = hi - lo\n const velocity = span > 0 ? (positionAt(hi) - positionAt(lo)) / span : 0\n return { position, velocity }\n },\n }\n}\n","// The animation lifecycle surface, shared by animatable, the playback handles, and\n// animate(). Callbacks ride the existing options object; physics builders never see\n// them (their option types stay lifecycle-blind), and a small per-run registry fans\n// the events. A handle also exposes eventCallback() to attach/replace them post-hoc.\n\n/** The lifecycle moments a run can emit. `repeat`/`reverseComplete` are playback-only. */\nexport type LifecycleEvent = 'start' | 'update' | 'complete' | 'interrupt' | 'repeat' | 'reverseComplete'\n\nexport interface LifecycleCallbacks {\n /** Fired once when the run begins (after any delay). Also fires on the reduced/instant path. */\n onStart?(this: object, handle: H): void\n /** Per frame with the live value. A number on animatable/playable; the values object on animate(). */\n onUpdate?(this: object, value: number, handle: H): void\n /** Natural settle to rest. Never fires for an Infinity-repeat run. Fires on the reduced/instant path. */\n onComplete?(this: object, handle: H): void\n /** Replaced, stopped, teleported, or disposed mid-flight. Never fires on the reduced/instant path. */\n onInterrupt?(this: object, handle: H): void\n /** Playable only: an iteration boundary (the iteration index is the run's repeat count so far). */\n onRepeat?(this: object, handle: H): void\n /** Playable only: a reversed leg reached its start. */\n onReverseComplete?(this: object, handle: H): void\n /** The `this` receiver for every callback. Defaults to the handle. */\n scope?: object\n}\n\nconst EVENT_TO_KEY: Record = {\n start: 'onStart',\n update: 'onUpdate',\n complete: 'onComplete',\n interrupt: 'onInterrupt',\n repeat: 'onRepeat',\n reverseComplete: 'onReverseComplete',\n}\n\nexport interface LifecycleRegistry {\n /** Load the callbacks (and scope) from an options bag. Ignores a missing/empty bag. */\n seed(callbacks: LifecycleCallbacks | undefined): void\n /** Attach or (with null) clear one event's callback - the post-hoc eventCallback path. Last writer wins. */\n set(event: LifecycleEvent, fn: ((handle: H) => void) | null): void\n /** True if anyone is listening for this event (lets callers skip work, e.g. force the JS path for `update`). */\n has(event: LifecycleEvent): boolean\n /** Invoke the event's callback with the configured scope (`update` also passes the value). */\n fire(event: LifecycleEvent, handle: H, value?: number): void\n}\n\n// deno-lint-ignore no-explicit-any\ntype AnyFn = (...args: any[]) => void\n\nexport function lifecycleRegistry(): LifecycleRegistry {\n const fns: Partial> = {}\n let scope: object | undefined\n\n return {\n seed(callbacks) {\n if (callbacks === undefined) return\n if (callbacks.scope !== undefined) scope = callbacks.scope\n for (const event of Object.keys(EVENT_TO_KEY) as LifecycleEvent[]) {\n const fn = callbacks[EVENT_TO_KEY[event]]\n if (typeof fn === 'function') fns[event] = fn as AnyFn\n }\n },\n set(event, fn) {\n if (fn === null) delete fns[event]\n else fns[event] = fn as AnyFn\n },\n has(event) {\n return fns[event] !== undefined\n },\n fire(event, handle, value) {\n const fn = fns[event]\n if (fn === undefined) return\n const receiver = scope ?? (handle as object)\n if (event === 'update') fn.call(receiver, value, handle)\n else fn.call(receiver, handle)\n },\n }\n}\n","// Handles are PromiseLike: `await animate(...)` / `await handle` resolves\n// when the animation settles or is interrupted (never rejects, mirroring\n// `finished`). The `then` on every handle delegates to its `finished` promise.\n\n/** A PromiseLike `then` that resolves with void when the handle's `finished` does. */\nexport type ThenFn = (\n onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null,\n onrejected?: ((reason: unknown) => TResult2 | PromiseLike) | null,\n) => Promise\n\n/** Build a handle's `then` from its `finished` promise (handles never reject). */\nexport const thenFinished =\n (finished: Promise): ThenFn =>\n (onfulfilled, onrejected) =>\n finished.then(onfulfilled ?? undefined, onrejected ?? undefined)\n","import { getReducedMotionBehavior, type ReducedMotionOverride } from '../a11y/config'\nimport { prefersReducedMotion } from '../a11y/reduced-motion'\nimport { decaySimulation, type DecayOptions } from '../physics/decay'\nimport { simulationMotion, type Motion } from '../physics/motion'\nimport { SIMULATION_TIMESTEP_S, type Simulation, type SimulationState } from '../physics/simulation'\nimport { springSimulation, type SpringOptions } from '../physics/spring'\nimport { tweenMotion, type ToOptions } from '../physics/tween'\nimport type { FrameInfo, Scheduler } from '../scheduler/scheduler'\nimport { getSharedScheduler } from '../scheduler/shared'\nimport { lifecycleRegistry, type LifecycleCallbacks, type LifecycleEvent, type LifecycleRegistry } from './lifecycle'\nimport { thenFinished, type ThenFn } from './thenable'\n\nexport interface AnimationHandle {\n /** Resolves when the animation settles OR is interrupted. Never rejects. */\n readonly finished: Promise\n /**\n * Handles are awaitable: `await animate(...)` / `await handle` resolves when the\n * animation settles or is interrupted (delegates to `finished`; never rejects).\n */\n then: ThenFn\n /** Freezes the value in place - only if this animation is still the active one. */\n stop(): void\n /**\n * Attach or (with `null`) replace a lifecycle callback after creation; last writer wins per event.\n * Present on the handles that carry a lifecycle (spring/to/decay/simulate, playable, animate); use\n * `?.` on a handle whose source may not (a composed/keyframe aggregate). Callbacks passed in the\n * call always fire regardless.\n */\n eventCallback?(event: LifecycleEvent, fn: ((handle: AnimationHandle) => void) | null): AnimationHandle\n}\n\nexport interface AnimatableOptions {\n /** Injection point for tests; defaults to the shared rAF scheduler. */\n scheduler?: Scheduler\n}\n\nexport interface SetOptions {\n /** Seed a velocity (units/s) along with the value - external handoffs (WAAPI reclaim, gestures). */\n velocity?: number\n}\n\nexport interface SimulateOptions {\n /** Initial velocity (units/s); defaults to the value's current velocity. */\n velocity?: number\n /** Per-animation override of the reduced-motion behavior. */\n reducedMotion?: ReducedMotionOverride\n}\n\nexport interface Animatable {\n get(): number\n /** units/s */\n velocity(): number\n isAnimating(): boolean\n /** Teleport: cancels any animation; velocity resets to 0 unless seeded. */\n set(value: number, options?: SetOptions): void\n /**\n * Passive write of position+velocity: emits `change`, but does NOT freeze an\n * active animation, fire `rest`, or zero velocity. The playback layer drives\n * a value through this; the value stays a state holder.\n */\n drive(state: SimulationState): void\n /** Freeze in place: position AND velocity stay readable. */\n stop(): void\n /** Retargets from the current position and velocity - interruptible at any time. */\n spring(target: number, options?: SpringOptions & LifecycleCallbacks): AnimationHandle\n /** Glide on inertia from the current (or imposed) velocity; optional clamp boundaries. */\n decay(options?: DecayOptions & LifecycleCallbacks): AnimationHandle\n /** Duration/easing escape hatch - still interruptible, with a readable derived velocity. */\n to(target: number, options?: ToOptions & LifecycleCallbacks): AnimationHandle\n /**\n * Drive the value with a custom Simulation - the general physics mode that\n * spring/decay/to specialize. Runs from the current position and velocity on\n * the same fixed-timestep clock, fully interruptible. Bring your own\n * acceleration (gravity, a force field, a bounce) and rest condition.\n */\n simulate(simulation: Simulation, options?: SimulateOptions & LifecycleCallbacks): AnimationHandle\n on(event: 'change', listener: (value: number) => void): () => void\n on(event: 'rest', listener: () => void): () => void\n dispose(): void\n}\n\ninterface ActiveAnimation {\n motion: Motion\n prev: SimulationState\n curr: SimulationState\n accumulatorS: number\n registry: LifecycleRegistry\n handle: AnimationHandle\n /** True once onStart has fired - so a run replaced before it ever started emits nothing (re-entrancy safety). */\n started: boolean\n /** Resolve `finished`; on an interrupt also fire onInterrupt (onComplete is fired at the rest site). */\n finish(reason: 'complete' | 'interrupt'): void\n}\n\nconst shouldSkip = (override?: ReducedMotionOverride): boolean => {\n if (override === 'allow') return false\n if (override === undefined && getReducedMotionBehavior() === 'allow') return false\n return prefersReducedMotion()\n}\n\n// Backstop for motions that never rest (e.g. an undamped spring): give up\n// fast-forwarding and settle wherever the simulation stands.\nconst MAX_SKIP_STEPS = 100_000\n\nexport function animatable(initial: number, options: AnimatableOptions = {}): Animatable {\n const scheduler = options.scheduler ?? getSharedScheduler()\n const changeListeners = new Set<(value: number) => void>()\n const restListeners = new Set<() => void>()\n\n let position = initial\n let velocity = 0\n let active: ActiveAnimation | null = null\n let unsubscribeFrames: (() => void) | null = null\n\n const emitChange = () => {\n for (const listener of [...changeListeners]) listener(position)\n }\n\n /** Detach the active animation, resolving its `finished`. State is left as-is. */\n const freeze = (reason: 'complete' | 'interrupt') => {\n const animation = active\n if (animation === null) return\n active = null\n unsubscribeFrames?.()\n unsubscribeFrames = null\n animation.finish(reason)\n }\n\n const onFrame = ({ deltaMs }: FrameInfo) => {\n const animation = active\n if (animation === null) return\n animation.accumulatorS += deltaMs / 1000\n\n while (animation.accumulatorS >= SIMULATION_TIMESTEP_S) {\n animation.accumulatorS -= SIMULATION_TIMESTEP_S\n animation.prev = animation.curr\n animation.curr = animation.motion.step(animation.curr, SIMULATION_TIMESTEP_S)\n\n const rested = animation.motion.rest(animation.curr)\n if (rested !== null) {\n const before = position\n position = rested // exact snap on the settle position\n velocity = 0\n freeze('complete')\n emitChange()\n if (position !== before) animation.registry.fire('update', animation.handle, position) // update only on a real change\n for (const listener of [...restListeners]) listener()\n animation.registry.fire('complete', animation.handle, position)\n return\n }\n }\n\n // The exposed state is interpolated between the two latest simulated\n // steps: jitter-free rendering, and retargets inherit exactly what is\n // visible on screen.\n const alpha = animation.accumulatorS / SIMULATION_TIMESTEP_S\n const previous = position\n position = animation.prev.position + (animation.curr.position - animation.prev.position) * alpha\n velocity = animation.prev.velocity + (animation.curr.velocity - animation.prev.velocity) * alpha\n if (position !== previous) {\n emitChange()\n animation.registry.fire('update', animation.handle, position)\n }\n }\n\n // Reduced motion (default 'skip'): the animation \"runs\" instantly - the\n // simulation is fast-forwarded to its rest state in one synchronous pass,\n // so even a decay with boundaries lands exactly where the full glide would.\n const settleInstantly = (\n motion: Motion,\n state: SimulationState,\n lifecycle?: LifecycleCallbacks,\n ): AnimationHandle => {\n const registry = lifecycleRegistry()\n registry.seed(lifecycle)\n const finished = Promise.resolve()\n const handle: AnimationHandle = {\n finished,\n then: thenFinished(finished),\n stop: () => {},\n eventCallback(event, fn) {\n registry.set(event, fn)\n return handle\n },\n }\n freeze('interrupt') // any in-flight animation is replaced by this instant settle\n registry.fire('start', handle, position)\n let current = state\n let settled: number | null = null\n for (let i = 0; i < MAX_SKIP_STEPS && settled === null; i++) {\n current = motion.step(current, SIMULATION_TIMESTEP_S)\n settled = motion.rest(current)\n }\n const previous = position\n position = settled ?? current.position\n velocity = 0\n if (position !== previous) {\n emitChange()\n registry.fire('update', handle, position)\n }\n for (const listener of [...restListeners]) listener()\n registry.fire('complete', handle, position)\n return handle\n }\n\n const startAnimation = (\n motion: Motion,\n state: SimulationState,\n lifecycle?: LifecycleCallbacks,\n ): AnimationHandle => {\n const previous = active\n let resolveFinished = () => {}\n const finished = new Promise((resolve) => {\n resolveFinished = resolve\n })\n const registry = lifecycleRegistry()\n registry.seed(lifecycle)\n const animation: ActiveAnimation = {\n motion,\n prev: state,\n curr: state,\n accumulatorS: 0,\n registry,\n handle: null as unknown as AnimationHandle, // assigned just below\n started: false,\n finish(reason) {\n resolveFinished()\n // Only a run that actually started can be interrupted (skips a run replaced re-entrantly before its start).\n if (reason === 'interrupt' && this.started) registry.fire('interrupt', this.handle)\n },\n }\n const handle: AnimationHandle = {\n finished,\n then: thenFinished(finished),\n stop: () => {\n if (active === animation) freeze('interrupt')\n },\n eventCallback(event, fn) {\n registry.set(event, fn)\n return handle\n },\n }\n animation.handle = handle\n active = animation\n velocity = state.velocity\n previous?.finish('interrupt') // replaced -> resolve + fire the prior run's onInterrupt\n unsubscribeFrames ??= scheduler.subscribe(onFrame)\n // Only fire start if still active - an onInterrupt above may have re-entrantly replaced us.\n if (active === animation) {\n animation.started = true\n registry.fire('start', handle, position)\n }\n return handle\n }\n\n return {\n get: () => position,\n velocity: () => velocity,\n isAnimating: () => active !== null,\n set(value, setOptions = {}) {\n freeze('interrupt')\n velocity = setOptions.velocity ?? 0\n if (position !== value) {\n position = value\n emitChange()\n }\n },\n drive(state) {\n velocity = state.velocity\n if (position !== state.position) {\n position = state.position\n emitChange()\n }\n },\n stop: () => freeze('interrupt'),\n spring(target, springOptions = {}) {\n const motion = simulationMotion(springSimulation(target, springOptions))\n const state = { position, velocity: springOptions.velocity ?? velocity }\n if (shouldSkip(springOptions.reducedMotion)) return settleInstantly(motion, state, springOptions)\n return startAnimation(motion, state, springOptions)\n },\n decay(decayOptions = {}) {\n const motion = simulationMotion(decaySimulation(decayOptions))\n const state = { position, velocity: decayOptions.velocity ?? velocity }\n if (shouldSkip(decayOptions.reducedMotion)) return settleInstantly(motion, state, decayOptions)\n return startAnimation(motion, state, decayOptions)\n },\n to(target, toOptions = {}) {\n const motion = tweenMotion(position, target, toOptions)\n const state = { position, velocity }\n if (shouldSkip(toOptions.reducedMotion)) return settleInstantly(motion, state, toOptions)\n return startAnimation(motion, state, toOptions)\n },\n simulate(simulation, simulateOptions = {}) {\n const motion = simulationMotion(simulation)\n const state = { position, velocity: simulateOptions.velocity ?? velocity }\n if (shouldSkip(simulateOptions.reducedMotion)) return settleInstantly(motion, state, simulateOptions)\n return startAnimation(motion, state, simulateOptions)\n },\n on(event: 'change' | 'rest', listener: (value: number) => void) {\n const listeners: Set<(value: number) => void> = event === 'change' ? changeListeners : restListeners\n listeners.add(listener)\n return () => {\n listeners.delete(listener)\n }\n },\n dispose() {\n freeze('interrupt')\n changeListeners.clear()\n restListeners.clear()\n },\n }\n}\n","export type TransformChannel =\n | 'perspective'\n | 'x'\n | 'y'\n | 'rotateX'\n | 'rotateY'\n | 'rotateZ'\n | 'rotate'\n | 'skewX'\n | 'skewY'\n | 'scale'\n | 'scaleX'\n | 'scaleY'\n\nexport type TransformChannels = Partial>\n\n/** Every key that resolves into the transform string (i.e. all but opacity). */\nexport const TRANSFORM_KEYS = [\n 'perspective',\n 'x',\n 'y',\n 'rotateX',\n 'rotateY',\n 'rotateZ',\n 'rotate',\n 'skewX',\n 'skewY',\n 'scale',\n 'scaleX',\n 'scaleY',\n] as const satisfies readonly TransformChannel[]\n\n// transform-origin is a separate CSS property, not a transform function, so it\n// is its own little channel group: two percentages forming `X% Y%`.\nexport type OriginChannel = 'originX' | 'originY'\nexport type OriginChannels = Partial>\nexport const ORIGIN_KEYS = ['originX', 'originY'] as const satisfies readonly OriginChannel[]\n\n/** transform-origin from originX/originY percentages; an unset axis is center. */\nexport function formatOrigin(c: OriginChannels): string {\n return `${c.originX ?? 50}% ${c.originY ?? 50}%`\n}\n\n/**\n * Single source of the transform string format. The WAAPI delegation builds\n * its keyframes with it and the binding writes frames with it - both MUST\n * produce byte-identical strings for the same values, or handoffs would\n * visually jump.\n *\n * Canonical order: perspective first (so the 3D rotations have depth), then\n * translate, rotations, skews, scales. The functions do not all commute, so a\n * fixed order is what keeps every code path identical.\n */\nexport function formatTransform(c: TransformChannels): string {\n const parts: string[] = []\n // perspective(0) collapses the element to a point, so only emit it when positive.\n if (c.perspective !== undefined && c.perspective > 0) parts.push(`perspective(${c.perspective}px)`)\n if (c.x !== undefined || c.y !== undefined) parts.push(`translate3d(${c.x ?? 0}px, ${c.y ?? 0}px, 0)`)\n if (c.rotateX !== undefined) parts.push(`rotateX(${c.rotateX}deg)`)\n if (c.rotateY !== undefined) parts.push(`rotateY(${c.rotateY}deg)`)\n if (c.rotateZ !== undefined) parts.push(`rotateZ(${c.rotateZ}deg)`)\n if (c.rotate !== undefined) parts.push(`rotate(${c.rotate}deg)`)\n if (c.skewX !== undefined) parts.push(`skewX(${c.skewX}deg)`)\n if (c.skewY !== undefined) parts.push(`skewY(${c.skewY}deg)`)\n if (c.scale !== undefined) parts.push(`scale(${c.scale})`)\n if (c.scaleX !== undefined) parts.push(`scaleX(${c.scaleX})`)\n if (c.scaleY !== undefined) parts.push(`scaleY(${c.scaleY})`)\n return parts.join(' ')\n}\n","import { getSharedScheduler } from '../scheduler/shared'\nimport type { Scheduler } from '../scheduler/scheduler'\nimport type { Animatable } from '../value/animatable'\nimport type { AnimatableElement } from './resolve-target'\nimport {\n formatOrigin,\n formatTransform,\n ORIGIN_KEYS,\n TRANSFORM_KEYS,\n type OriginChannel,\n type OriginChannels,\n type TransformChannel,\n type TransformChannels,\n} from './transform'\n\n/** Each channel is an Animatable bound to one transform function, transform-origin axis, or opacity. */\nexport type StyleBindings = Partial> & {\n opacity?: Animatable\n}\n\nexport interface BindStyleOptions {\n /** Must be the scheduler driving the bound animatables. Defaults to the shared one. */\n scheduler?: Scheduler\n /**\n * When set, the opacity write also toggles `visibility` - `hidden` at 0, cleared\n * otherwise - so a fully transparent element stops capturing pointer events (the\n * autoAlpha behavior). No effect without an opacity binding.\n */\n autoAlpha?: boolean\n}\n\n/**\n * Writes animatable values straight to element.style from the scheduler's\n * render phase - outside any framework reactivity. All channels that moved\n * during a frame are flushed in a single write per property, per element.\n * Returns a dispose function.\n */\nexport function bindStyle(\n element: AnimatableElement,\n bindings: StyleBindings,\n options: BindStyleOptions = {},\n): () => void {\n const scheduler = options.scheduler ?? getSharedScheduler()\n const autoAlpha = options.autoAlpha === true\n const { opacity } = bindings\n const transformBindings = TRANSFORM_KEYS.map((key) => [key, bindings[key]] as const).filter(\n (entry): entry is readonly [TransformChannel, Animatable] => entry[1] !== undefined,\n )\n const originBindings = ORIGIN_KEYS.map((key) => [key, bindings[key]] as const).filter(\n (entry): entry is readonly [OriginChannel, Animatable] => entry[1] !== undefined,\n )\n\n let transformDirty = false\n let originDirty = false\n let opacityDirty = false\n let cancelFlush: (() => void) | null = null\n const unsubscribers: Array<() => void> = []\n\n const writeTransform = () => {\n const channels: TransformChannels = {}\n for (const [key, value] of transformBindings) channels[key] = value.get()\n element.style.transform = formatTransform(channels)\n }\n\n const writeOrigin = () => {\n const channels: OriginChannels = {}\n for (const [key, value] of originBindings) channels[key] = value.get()\n element.style.transformOrigin = formatOrigin(channels)\n }\n\n const writeOpacity = () => {\n if (opacity === undefined) return\n const value = opacity.get()\n element.style.opacity = String(value)\n // autoAlpha: a fully transparent element also goes visibility:hidden so it\n // drops out of hit-testing; any non-zero opacity clears it back to visible.\n if (autoAlpha) element.style.visibility = value <= 0.0001 ? 'hidden' : ''\n }\n\n const flush = () => {\n if (transformDirty) {\n transformDirty = false\n writeTransform()\n }\n if (originDirty) {\n originDirty = false\n writeOrigin()\n }\n if (opacityDirty) {\n opacityDirty = false\n writeOpacity()\n }\n }\n\n // One-shot render subscription: the flush runs after every simulation of\n // the same tick (or on the next frame for changes made outside a tick),\n // then lets the loop go back to sleep.\n const scheduleFlush = () => {\n if (cancelFlush !== null) return\n cancelFlush = scheduler.subscribe(() => {\n cancelFlush?.()\n cancelFlush = null\n flush()\n }, 'render')\n }\n\n const track = (value: Animatable | undefined, markDirty: () => void) => {\n if (value === undefined) return\n unsubscribers.push(\n value.on('change', () => {\n markDirty()\n scheduleFlush()\n }),\n )\n }\n\n const markTransformDirty = () => {\n transformDirty = true\n }\n const markOriginDirty = () => {\n originDirty = true\n }\n for (const [, value] of transformBindings) track(value, markTransformDirty)\n for (const [, value] of originBindings) track(value, markOriginDirty)\n track(opacity, () => {\n opacityDirty = true\n })\n\n // The element reflects the current values from bind time, synchronously.\n if (transformBindings.length > 0) writeTransform()\n if (originBindings.length > 0) writeOrigin()\n writeOpacity()\n\n return () => {\n for (const unsubscribe of unsubscribers) unsubscribe()\n cancelFlush?.()\n cancelFlush = null\n }\n}\n","/**\n * The value-type contract: how a CSS property name maps to the scalar channels\n * the physics drives. A `ValueType` decomposes a raw value into channels\n * (`parse`), names their magnitude/precision (`channels`), and is the SOLE\n * producer of that property's CSS strings (`format`) - the analogue of\n * `formatTransform` for the transform property. Equal shapes are\n * channel-for-channel interpolable AND share a format template.\n */\nexport interface ParsedValue {\n /** Scalar channels the physics drives, in template order. */\n channels: number[]\n /**\n * Shape identity: equal shapes are channel-for-channel interpolable AND share\n * a format template. For the complex type the shape IS the compiled template -\n * same token kinds with different literals are different shapes.\n */\n shape: string\n}\n\n/** Per-channel metadata: format precision, clamp bounds, and rest tolerances scaled to the channel's magnitude. */\nexport interface ChannelMeta {\n /** Decimals kept at format time. The simulation always runs full precision. */\n precision: number\n /** Format-time clamp - spring overshoot on bounded channels (rgb, alpha). */\n min?: number\n max?: number\n /** Rest tolerance scaled to the channel's magnitude. An explicit per-call restDelta wins. */\n restDelta?: number\n /** Rest speed scaled to the channel's magnitude (channel-units/s). Per-call restSpeed wins. */\n restSpeed?: number\n}\n\n/** px per 1 unit in this element+property context; null = not measurable. */\nexport type MeasureUnit = (unit: string) => number | null\n\nexport interface ValueType {\n /** Decompose an author/computed value. null = not animatable - the caller snaps. */\n parse(raw: string | number): ParsedValue | null\n /** Pure, deterministic, byte-identical for identical input. The ONLY producer of this property's CSS strings. */\n format(channels: readonly number[], shape: string): string\n /** Per-channel metadata for a shape; length matches parse().channels. */\n channels(shape: string): readonly ChannelMeta[]\n /** Linear multiplier mapping channel values AND velocities between shapes; null = not convertible (caller snaps). */\n convert?(fromShape: string, toShape: string, measure: MeasureUnit): number | null\n /** Re-read a raw value through a target shape: kind-stable realign, 'none' synthesis. null = incompatible. */\n reconcile?(raw: string, targetShape: string): ParsedValue | null\n /** false for non-spatial types (colors): they stay animated under reduced-motion 'fade'. Default true. */\n spatial?: boolean\n}\n\n/**\n * The one formatter primitive every value type shares: clamp to the channel's\n * bounds, round to its precision, and emit a byte-stable decimal string - no\n * scientific notation, no negative zero, no sub-precision churn. Rounding makes\n * equal floats produce byte-equal strings across runs and frame rates.\n */\nexport function formatChannelNumber(value: number, meta: ChannelMeta): string {\n let v = value\n // Never emit 'NaN'/'Infinity' into a CSS string (a non-finite source value, a\n // bad target). Fall back to the channel's floor, or 0.\n if (!Number.isFinite(v)) v = meta.min ?? 0\n if (meta.min !== undefined && v < meta.min) v = meta.min\n if (meta.max !== undefined && v > meta.max) v = meta.max\n const factor = 10 ** meta.precision\n v = Math.round(v * factor) / factor\n return v === 0 ? '0' : String(v)\n}\n","/** camelCase or custom property -> the kebab name getComputedStyle/setProperty expect. */\nexport function toKebab(property: string): string {\n if (property.startsWith('--')) return property\n return property.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)\n}\n\nexport interface StyleReader {\n /** Computed value of a property (kebab-converted), trimmed. '' when unset. */\n get(property: string): string\n}\n\n/**\n * An attribute reader with the same shape as `readStyle` - `get(name)` returns\n * the element's current attribute value (`getAttribute`), '' when unset. The seam\n * for animating SVG/element attributes (viewBox, r, points) through the same group\n * machinery as style properties.\n */\nexport function readAttribute(element: Element): StyleReader {\n return {\n get(name) {\n return (element.getAttribute(name) ?? '').trim()\n },\n }\n}\n\n/**\n * One getComputedStyle(element) per animate()/setStyle() call, evaluated lazily\n * and shared by every property read of that call - getComputedStyle forces a\n * style/layout flush, so it must happen at most once and before any write.\n * Lazy so a call that never reads (pure numeric fast path) touches no DOM.\n */\nexport function readStyle(element: Element): StyleReader {\n let computed: CSSStyleDeclaration | null = null\n return {\n get(property) {\n computed ??= getComputedStyle(element)\n return computed.getPropertyValue(toKebab(property)).trim()\n },\n }\n}\n","import { getSharedScheduler } from '../scheduler/shared'\nimport type { Scheduler } from '../scheduler/scheduler'\nimport { toKebab } from './read-style'\nimport type { AnimatableElement } from './resolve-target'\n\nexport interface BindPropertyOptions {\n scheduler?: Scheduler\n /**\n * Where the formatted value is written. 'style' (default) sets the inline style\n * property (kebab-cased); 'attr' calls setAttribute with the bare `property`\n * name - the seam for SVG/element attribute animation (viewBox, r, points).\n */\n target?: 'style' | 'attr'\n}\n\n/**\n * The structural source bindProperty writes: anything that can produce a CSS\n * string and notify when it changes. A ChannelGroup satisfies it (the animate()\n * path), and so does a composed template (bindTemplate) - one render-phase binder\n * serves both.\n */\nexport interface FormatSource {\n format(): string\n onChange(listener: () => void): () => void\n}\n\nexport interface PropertyBinding {\n dispose(): void\n /** Write the current value synchronously now, cancelling any pending flush (setStyle path). */\n flushNow(): void\n}\n\n/**\n * Writes a channel group's formatted value to one element property from the\n * scheduler's render phase - bind-style's pattern, one property at a time: a\n * group change marks dirty and arms a one-shot render subscription that flushes\n * once, then lets the loop sleep. The formatted string is deduplicated, so a\n * channel that jitters below its format precision produces no DOM write at all.\n */\nexport function bindProperty(\n element: AnimatableElement,\n property: string,\n source: FormatSource,\n options: BindPropertyOptions = {},\n): PropertyBinding {\n const scheduler = options.scheduler ?? getSharedScheduler()\n const attr = options.target === 'attr'\n // Attributes take the bare name verbatim (viewBox, stroke-width); style takes kebab.\n const name = attr ? property : toKebab(property)\n let dirty = false\n let lastWritten: string | null = null\n let cancelFlush: (() => void) | null = null\n\n const write = (): void => {\n const value = source.format()\n if (value === lastWritten) return // byte-identical: no DOM write\n lastWritten = value\n if (attr) element.setAttribute(name, value)\n else element.style.setProperty(name, value)\n }\n\n const scheduleFlush = (): void => {\n if (cancelFlush !== null) return\n cancelFlush = scheduler.subscribe(() => {\n cancelFlush?.()\n cancelFlush = null\n if (dirty) {\n dirty = false\n write()\n }\n }, 'render')\n }\n\n const unsubscribe = source.onChange(() => {\n dirty = true\n scheduleFlush()\n })\n\n // The element reflects the current value synchronously at bind time.\n write()\n\n return {\n dispose() {\n unsubscribe()\n cancelFlush?.()\n cancelFlush = null\n },\n flushNow() {\n dirty = false\n cancelFlush?.()\n cancelFlush = null\n write()\n },\n }\n}\n","import type { SpringOptions } from '../physics/spring'\nimport type { ToOptions } from '../physics/tween'\nimport type { Scheduler } from '../scheduler/scheduler'\nimport { animatable, type Animatable, type AnimationHandle } from './animatable'\nimport { thenFinished } from './thenable'\nimport type { ChannelMeta, ParsedValue, ValueType } from './value-type'\n\n/**\n * The bridge between one CSS value and the scalar physics: a value's channels\n * each become a plain Animatable, so springs, decay-grade velocity\n * conservation, interpolated exposure, exact rest snap, and reduced-motion\n * fast-forward are all INHERITED, not re-implemented. The group owns the shared\n * shape, the cached format string, and a generation counter (keyframe chains\n * read it to detect staleness). Aggregate handles fan out: `finished` resolves\n * when the last channel rests, `stop()` freezes them all.\n */\nexport interface ChannelGroup {\n readonly type: ValueType\n shape: string\n readonly channels: ReadonlyArray\n generation: number\n format(): string\n isAnimating(): boolean\n set(parsed: ParsedValue, options?: { velocity?: number }): void\n /** Same rendered pixels, new coordinate system: every channel set(pos*m, { velocity: vel*m }). */\n rebase(multiplier: number, shape: string): void\n spring(target: ParsedValue, options?: SpringOptions): AnimationHandle\n to(target: ParsedValue, options?: ToOptions): AnimationHandle\n onChange(listener: () => void): () => void\n stop(): void\n dispose(): void\n}\n\nexport interface ChannelGroupOptions {\n scheduler?: Scheduler\n}\n\n// The aggregate forwards its channels' interrupt up as ONE interrupt: a registry\n// property's channels are plain Animatables, so superseding the group (a later\n// animate() retargets a channel) interrupts them - and a lifecycle owner above\n// (animate()'s withLifecycle) hooks THIS handle to tell a supersede from a settle.\nconst aggregate = (handles: AnimationHandle[]): AnimationHandle => {\n let onInterrupt: ((h: AnimationHandle) => void) | null = null\n let fired = false\n const fireInterrupt = (): void => {\n if (fired) return\n fired = true\n onInterrupt?.(handle)\n }\n for (const child of handles) child.eventCallback?.('interrupt', fireInterrupt)\n const finished = Promise.all(handles.map((child) => child.finished)).then(() => undefined)\n const handle: AnimationHandle = {\n finished,\n then: thenFinished(finished),\n stop: () => {\n for (const child of handles) child.stop()\n },\n eventCallback(event, fn) {\n if (event === 'interrupt') onInterrupt = fn ?? null\n return handle\n },\n }\n return handle\n}\n\nexport function channelGroup(\n type: ValueType,\n parsed: ParsedValue,\n options: ChannelGroupOptions = {},\n): ChannelGroup {\n const scheduler = options.scheduler\n let shape = parsed.shape\n let metas = type.channels(shape)\n let generation = 0\n let cachedFormat: string | null = null\n const changeListeners = new Set<() => void>()\n\n const notify = (): void => {\n cachedFormat = null\n for (const listener of [...changeListeners]) listener()\n }\n\n const channels = parsed.channels.map((value) =>\n animatable(value, scheduler !== undefined ? { scheduler } : {}),\n )\n const unsubscribers = channels.map((channel) => channel.on('change', notify))\n // Reused scratch: one allocation for the channel count, refilled per format.\n const scratch: number[] = new Array(channels.length)\n\n // Per-call options win; channel meta fills only the keys the call left absent;\n // anything still absent falls through to the animatable's own defaults. Never\n // assigns undefined to an optional key (exactOptionalPropertyTypes).\n const channelOptions = (base: SpringOptions, index: number): SpringOptions => {\n const meta: ChannelMeta | undefined = metas[index]\n const opts: SpringOptions = { ...base }\n if (meta !== undefined) {\n if (opts.restDelta === undefined && meta.restDelta !== undefined) opts.restDelta = meta.restDelta\n if (opts.restSpeed === undefined && meta.restSpeed !== undefined) opts.restSpeed = meta.restSpeed\n }\n return opts\n }\n\n return {\n type,\n get shape() {\n return shape\n },\n set shape(next: string) {\n shape = next\n },\n channels,\n get generation() {\n return generation\n },\n set generation(next: number) {\n generation = next\n },\n format() {\n if (cachedFormat !== null) return cachedFormat\n for (let i = 0; i < channels.length; i++) scratch[i] = channels[i]!.get()\n cachedFormat = type.format(scratch, shape)\n return cachedFormat\n },\n isAnimating() {\n return channels.some((channel) => channel.isAnimating())\n },\n set(next, setOptions = {}) {\n generation += 1\n shape = next.shape\n metas = type.channels(shape)\n cachedFormat = null\n const velocity = setOptions.velocity\n for (let i = 0; i < channels.length; i++) {\n // Broadcast a scalar velocity to every channel: exact for single-channel\n // values (the gesture case), the documented approximation otherwise.\n channels[i]!.set(next.channels[i] ?? 0, velocity !== undefined ? { velocity } : undefined)\n }\n },\n rebase(multiplier, nextShape) {\n generation += 1\n shape = nextShape\n metas = type.channels(shape)\n cachedFormat = null\n for (const channel of channels) {\n channel.set(channel.get() * multiplier, { velocity: channel.velocity() * multiplier })\n }\n },\n spring(target, springOptions = {}) {\n generation += 1\n return aggregate(\n channels.map((channel, i) => channel.spring(target.channels[i] ?? 0, channelOptions(springOptions, i))),\n )\n },\n to(target, toOptions = {}) {\n generation += 1\n return aggregate(channels.map((channel, i) => channel.to(target.channels[i] ?? 0, toOptions)))\n },\n onChange(listener) {\n changeListeners.add(listener)\n return () => {\n changeListeners.delete(listener)\n }\n },\n stop() {\n generation += 1\n for (const channel of channels) channel.stop()\n },\n dispose() {\n for (const unsubscribe of unsubscribers) unsubscribe()\n for (const channel of channels) channel.dispose()\n changeListeners.clear()\n },\n }\n}\n","import { formatChannelNumber, type ChannelMeta, type ValueType } from '../value-type'\n\n// Colors decompose into [r^2, g^2, b^2, a]: storing the channels squared means a\n// per-channel linear spring runs in gamma-2.0 (approximate linear-light) space,\n// which IS the mix - no dark sRGB midpoint, no separate color-mixing pass.\n// `sqrt` + clamp + integer round happen only at format. Oklab/OKLCH ship later as\n// @underlying/color via registerValueType.\n//\n// Rest tolerances are scaled to the squared magnitude (0..65025): 40 / 400 is\n// roughly 0.16 sRGB steps at midrange, so the loop sleeps at visual rest rather\n// than chasing px-tuned defaults for seconds.\nconst RGB_META: ChannelMeta = { precision: 0, min: 0, max: 65025, restDelta: 40, restSpeed: 400 }\nconst ALPHA_META: ChannelMeta = { precision: 4, min: 0, max: 1, restDelta: 0.005, restSpeed: 0.05 }\nexport const COLOR_METAS: readonly ChannelMeta[] = [RGB_META, RGB_META, RGB_META, ALPHA_META]\n\n/** The single color shape: 4 channels, one canonical rgba layout. */\nexport const COLOR_SHAPE = 'rgba'\n\nconst sqrtByte = (squared: number): number => {\n const clamped = squared < 0 ? 0 : squared > 65025 ? 65025 : squared\n return Math.round(Math.sqrt(clamped))\n}\n\n/** Channels [r^2, g^2, b^2, a] -> canonical, byte-stable `rgba(R, G, B, A)`. */\nexport function formatColor(channels: readonly number[]): string {\n const r = sqrtByte(channels[0] ?? 0)\n const g = sqrtByte(channels[1] ?? 0)\n const b = sqrtByte(channels[2] ?? 0)\n const a = formatChannelNumber(channels[3] ?? 1, ALPHA_META)\n return `rgba(${r}, ${g}, ${b}, ${a})`\n}\n\nconst hexComponent = (hex: string): [number, number, number, number] | null => {\n if (!/^[0-9a-f]+$/.test(hex)) return null\n // Expand the 3/4-digit short form: 'f04' -> 'ff0044'.\n const full = hex.length === 3 || hex.length === 4 ? hex.replace(/./g, (c) => c + c) : hex\n if (full.length !== 6 && full.length !== 8) return null\n const r = parseInt(full.slice(0, 2), 16)\n const g = parseInt(full.slice(2, 4), 16)\n const b = parseInt(full.slice(4, 6), 16)\n const a = full.length === 8 ? parseInt(full.slice(6, 8), 16) / 255 : 1\n return Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(a) ? null : [r, g, b, a]\n}\n\nconst functionalArgs = (s: string): string[] | null => {\n const open = s.indexOf('(')\n const close = s.lastIndexOf(')')\n if (open < 0 || close < open) return null\n return s\n .slice(open + 1, close)\n .split(/[\\s,/]+/)\n .filter((part) => part !== '')\n}\n\nconst component = (raw: string, scale: number): number =>\n raw.endsWith('%') ? (parseFloat(raw) / 100) * scale : parseFloat(raw)\n\nconst rgbComponent = (s: string): [number, number, number, number] | null => {\n const parts = functionalArgs(s)\n if (parts === null || parts.length < 3 || parts.length > 4) return null\n const [p0, p1, p2, p3] = parts\n if (p0 === undefined || p1 === undefined || p2 === undefined) return null\n const r = component(p0, 255)\n const g = component(p1, 255)\n const b = component(p2, 255)\n const a = p3 === undefined ? 1 : component(p3, 1)\n return Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(a) ? null : [r, g, b, a]\n}\n\nconst hslToRgb = (h: number, s: number, l: number): [number, number, number] => {\n const c = (1 - Math.abs(2 * l - 1)) * s\n const hp = ((((h % 360) + 360) % 360) / 60)\n const x = c * (1 - Math.abs((hp % 2) - 1))\n const [r1, g1, b1] =\n hp < 1 ? [c, x, 0] : hp < 2 ? [x, c, 0] : hp < 3 ? [0, c, x] : hp < 4 ? [0, x, c] : hp < 5 ? [x, 0, c] : [c, 0, x]\n const m = l - c / 2\n return [(r1 + m) * 255, (g1 + m) * 255, (b1 + m) * 255]\n}\n\nconst hslComponent = (s: string): [number, number, number, number] | null => {\n const parts = functionalArgs(s)\n if (parts === null || parts.length < 3 || parts.length > 4) return null\n const [p0, p1, p2, p3] = parts\n if (p0 === undefined || p1 === undefined || p2 === undefined) return null\n const h = parseFloat(p0)\n const sat = parseFloat(p1) / 100\n const light = parseFloat(p2) / 100\n const a = p3 === undefined ? 1 : component(p3, 1)\n if (Number.isNaN(h) || Number.isNaN(sat) || Number.isNaN(light) || Number.isNaN(a)) return null\n const [r, g, b] = hslToRgb(h, sat, light)\n return [r, g, b, a]\n}\n\n// Reused, in-document probe: detached elements have no computed style, so the\n// element must live in the tree. display:none is fine - `color` is not\n// layout-dependent. Created lazily on the first named candidate (SSR-safe).\nlet probe: HTMLElement | null = null\nconst NON_COLOR_KEYWORDS = new Set([\n 'none', 'auto', 'inherit', 'initial', 'unset', 'revert', 'currentcolor', 'transparent',\n])\n\nconst namedComponent = (name: string): [number, number, number, number] | null => {\n if (NON_COLOR_KEYWORDS.has(name)) return null\n if (typeof document === 'undefined') return null\n if (probe === null) {\n probe = document.createElement('div')\n probe.style.display = 'none'\n document.documentElement.appendChild(probe)\n }\n probe.style.color = ''\n probe.style.color = name\n // An invalid keyword is rejected by the CSSOM: the assignment leaves it empty.\n if (probe.style.color === '') return null\n return rgbComponent(getComputedStyle(probe).color)\n}\n\n/** Decompose a color into squared-sRGB channels [r^2, g^2, b^2, a]. null = not a parseable color. */\nexport function parseColor(raw: string | number): [number, number, number, number] | null {\n if (typeof raw === 'number') return null\n const s = raw.trim().toLowerCase()\n if (s === '') return null\n if (s === 'transparent') return [0, 0, 0, 0]\n const rgba =\n s[0] === '#'\n ? hexComponent(s.slice(1))\n : s.startsWith('rgb')\n ? rgbComponent(s)\n : s.startsWith('hsl')\n ? hslComponent(s)\n : /^[a-z]+$/.test(s)\n ? namedComponent(s)\n : null\n if (rgba === null) return null\n const [r, g, b, a] = rgba\n return [r * r, g * g, b * b, a]\n}\n\nexport const colorValueType: ValueType = {\n spatial: false,\n parse(raw) {\n const channels = parseColor(raw)\n return channels === null ? null : { channels, shape: COLOR_SHAPE }\n },\n format(channels) {\n return formatColor(channels)\n },\n channels() {\n return COLOR_METAS\n },\n}\n\n/** Test-only: drops the cached probe element so a fresh document can be used. */\nexport function __resetColorProbe(): void {\n probe?.remove()\n probe = null\n}\n","import { formatChannelNumber, type ChannelMeta, type ValueType } from '../value-type'\nimport { COLOR_METAS, formatColor, parseColor } from './color'\n\n// The generic value type: any CSS value that is a mix of literal text, numbers\n// (with units), and embedded colors - box-shadow, filter, the fallback for\n// unknown and custom properties. One tokenizer pass turns a value into scalar\n// channels plus a SHAPE that IS the compiled template: same token kinds with\n// the same literals and units share a shape and are channel-for-channel\n// interpolable; anything else is a different shape (snap, not a silent\n// mis-mix). The hot path (format) never tokenizes - it reuses the template.\n\ntype Token = { kind: 'number'; unit: string } | { kind: 'color' }\n\ninterface Template {\n literals: string[] // length = tokens.length + 1\n tokens: Token[]\n}\n\nconst NUMBER_TOKEN_META: ChannelMeta = { precision: 4, restDelta: 0.01, restSpeed: 0.1 }\n\n// Token-slot delimiter inside a shape string. NUL never appears in a CSS value,\n// so literal chunks (which freely contain spaces, parens, commas) never collide\n// with the slot markers `c` (color) and `n:` (number).\nconst SEP = '\\u0000'\nconst colorSlot = `${SEP}c${SEP}`\nconst numberSlot = (unit: string): string => `${SEP}n:${unit}${SEP}`\nconst SINGLE_NUMBER_SHAPE = numberSlot('')\n\n// Colors are matched before numbers so the numbers inside rgb()/hsl() are not\n// mistaken for standalone tokens. The unit group (index 1) is populated only\n// for the number alternative.\nconst tokenPattern =\n /rgba?\\([^)]*\\)|hsla?\\([^)]*\\)|#[0-9a-fA-F]+|[+-]?(?:\\d+\\.?\\d*|\\.\\d+)(px|%|em|rem|vw|vh|vmin|vmax|deg|rad|turn|s|ms)?/gi\n\nconst isColorText = (text: string): boolean => text[0] === '#' || /^(?:rgb|hsl)/i.test(text)\n\ninterface Decomposed {\n channels: number[]\n shape: string\n template: Template\n}\n\n// Test seam: the hot path (format) must never reach this.\nlet tokenizeCount = 0\n\nconst decompose = (raw: string): Decomposed | null => {\n tokenizeCount += 1\n const channels: number[] = []\n const tokens: Token[] = []\n const literals: string[] = []\n let shape = ''\n let cursor = 0\n for (const match of raw.matchAll(tokenPattern)) {\n const text = match[0]\n const index = match.index\n const literal = raw.slice(cursor, index)\n literals.push(literal)\n shape += literal\n cursor = index + text.length\n if (isColorText(text)) {\n const color = parseColor(text)\n if (color === null) return null\n channels.push(color[0], color[1], color[2], color[3])\n tokens.push({ kind: 'color' })\n shape += colorSlot\n } else {\n const unit = match[1] ?? ''\n const num = parseFloat(text)\n if (Number.isNaN(num)) return null\n channels.push(num)\n tokens.push({ kind: 'number', unit })\n shape += numberSlot(unit)\n }\n }\n if (tokens.length === 0) return null\n const tail = raw.slice(cursor)\n literals.push(tail)\n shape += tail\n return { channels, shape, template: { literals, tokens } }\n}\n\n// Templates are decoded from their shape string once and cached: the shape was\n// produced by decompose, so it always round-trips. split on SEP yields\n// alternating [literal, descriptor, literal, descriptor, ..., literal].\nconst templateCache = new Map()\n\nconst compileShape = (shape: string): Template => {\n const cached = templateCache.get(shape)\n if (cached !== undefined) return cached\n const parts = shape.split(SEP)\n const literals: string[] = []\n const tokens: Token[] = []\n for (let i = 0; i < parts.length; i++) {\n const part = parts[i] ?? ''\n if (i % 2 === 0) literals.push(part)\n else if (part === 'c') tokens.push({ kind: 'color' })\n else tokens.push({ kind: 'number', unit: part.slice(2) })\n }\n const template: Template = { literals, tokens }\n templateCache.set(shape, template)\n return template\n}\n\nconst channelMetas = (shape: string): ChannelMeta[] => {\n const { tokens } = compileShape(shape)\n const metas: ChannelMeta[] = []\n for (const token of tokens) {\n if (token.kind === 'color') metas.push(...COLOR_METAS)\n else metas.push(NUMBER_TOKEN_META)\n }\n return metas\n}\n\n/** Source channels grouped by kind, preserving order - the basis for kind-stable realignment. */\nconst groupByKind = (source: Decomposed): { numbers: number[]; colors: number[][] } => {\n const numbers: number[] = []\n const colors: number[][] = []\n let offset = 0\n for (const token of source.template.tokens) {\n if (token.kind === 'color') {\n colors.push(source.channels.slice(offset, offset + 4))\n offset += 4\n } else {\n numbers.push(source.channels[offset] ?? 0)\n offset += 1\n }\n }\n return { numbers, colors }\n}\n\nexport const complexValueType: ValueType = {\n parse(raw) {\n if (typeof raw === 'number') {\n return Number.isFinite(raw) ? { channels: [raw], shape: SINGLE_NUMBER_SHAPE } : null\n }\n const decomposed = decompose(raw)\n return decomposed === null ? null : { channels: decomposed.channels, shape: decomposed.shape }\n },\n format(channels, shape) {\n const { literals, tokens } = compileShape(shape)\n let out = literals[0] ?? ''\n let offset = 0\n for (let i = 0; i < tokens.length; i++) {\n const token = tokens[i]\n if (token === undefined) break\n if (token.kind === 'color') {\n out += formatColor(channels.slice(offset, offset + 4))\n offset += 4\n } else {\n out += formatChannelNumber(channels[offset] ?? 0, NUMBER_TOKEN_META) + token.unit\n offset += 1\n }\n out += literals[i + 1] ?? ''\n }\n return out\n },\n channels(shape) {\n return channelMetas(shape)\n },\n reconcile(raw, targetShape) {\n const { tokens } = compileShape(targetShape)\n const trimmed = raw.trim().toLowerCase()\n // 'none' and an empty computed value (the unset initial: browsers serialize\n // box-shadow/filter as 'none', jsdom as '') both mean \"no value yet\".\n if (trimmed === 'none' || trimmed === '') {\n // Zero-equivalent of the target template: numbers collapse to 0, colors\n // to transparent (correct for the dominant black-shadow case).\n const channels: number[] = []\n for (const token of tokens) {\n if (token.kind === 'color') channels.push(0, 0, 0, 0)\n else channels.push(0)\n }\n return { channels, shape: targetShape }\n }\n const source = decompose(raw)\n if (source === null) return null\n const { numbers, colors } = groupByKind(source)\n let ni = 0\n let ci = 0\n const channels: number[] = []\n for (const token of tokens) {\n if (token.kind === 'color') {\n const color = colors[ci]\n if (color === undefined) return null\n channels.push(...color)\n ci += 1\n } else {\n const num = numbers[ni]\n if (num === undefined) return null\n channels.push(num)\n ni += 1\n }\n }\n // Exact count: leftover source tokens of either kind means the shapes are\n // structurally different (e.g. 1 shadow vs 2) - snap, do not pad.\n if (ni !== numbers.length || ci !== colors.length) return null\n return { channels, shape: targetShape }\n },\n}\n\n/** Test-only: number of full tokenizer passes (the hot path must add none). */\nexport function __tokenizeCount(): number {\n return tokenizeCount\n}\n\n/** Test-only: clears the template cache and the tokenizer counter. */\nexport function __resetComplexCaches(): void {\n templateCache.clear()\n tokenizeCount = 0\n}\n","import { formatChannelNumber, type ChannelMeta, type ValueType } from '../value-type'\n\n// One channel; the shape IS the unit. Cross-unit interpolation is forbidden -\n// a '50%' target and a '240px' current are different shapes, reconciled by a\n// measure-once multiplier (see convert) rather than mixed numerically.\nconst LENGTH_META: ChannelMeta = { precision: 4, restDelta: 0.01, restSpeed: 0.1 }\nconst LENGTH_METAS: readonly ChannelMeta[] = [LENGTH_META]\n\nconst LENGTH_RE = /^([+-]?(?:\\d+\\.?\\d*|\\.\\d+))(px|%|em|rem|vw|vh|vmin|vmax|deg|rad|turn)$/\n\n// Angle units convert arithmetically (no layout measurement). Reference: degrees.\nconst ANGLE_TO_DEG: Record = { deg: 1, rad: 180 / Math.PI, turn: 360 }\n\nexport const lengthValueType: ValueType = {\n parse(raw) {\n // Bare numbers default to px (the registry seeds length properties).\n if (typeof raw === 'number') {\n return Number.isFinite(raw) ? { channels: [raw], shape: 'px' } : null\n }\n const s = raw.trim()\n if (s === '') return null\n // Unitless zero is valid CSS for lengths; it carries no unit of its own.\n if (s === '0' || s === '+0' || s === '-0') return { channels: [0], shape: 'px' }\n const match = LENGTH_RE.exec(s)\n if (match === null) return null\n return { channels: [Number(match[1])], shape: match[2] as string }\n },\n format(channels, shape) {\n return formatChannelNumber(channels[0] ?? 0, LENGTH_META) + shape\n },\n channels() {\n return LENGTH_METAS\n },\n convert(fromShape, toShape, measure) {\n const fromAngle = ANGLE_TO_DEG[fromShape]\n const toAngle = ANGLE_TO_DEG[toShape]\n if (fromAngle !== undefined || toAngle !== undefined) {\n // Angle <-> angle only; a cross-kind conversion (deg <-> px) is undefined.\n if (fromAngle === undefined || toAngle === undefined) return null\n return fromAngle / toAngle\n }\n const from = measure(fromShape)\n const to = measure(toShape)\n if (from === null || to === null || to === 0) return null\n return from / to\n },\n}\n","import { formatChannelNumber, type ChannelMeta, type ValueType } from '../value-type'\n\n// Unitless scalar - flexGrow, fontWeight, custom properties registered by the\n// app. Shape is the empty string: one canonical shape, always interpolable.\nconst NUMBER_META: ChannelMeta = { precision: 4, restDelta: 0.01, restSpeed: 0.1 }\nconst NUMBER_METAS: readonly ChannelMeta[] = [NUMBER_META]\n\nexport const numberValueType: ValueType = {\n parse(raw) {\n if (typeof raw === 'string' && raw.trim() === '') return null\n const n = Number(raw)\n return Number.isFinite(n) ? { channels: [n], shape: '' } : null\n },\n format(channels) {\n return formatChannelNumber(channels[0] ?? 0, NUMBER_META)\n },\n channels() {\n return NUMBER_METAS\n },\n}\n","import { colorValueType } from './types/color'\nimport { complexValueType } from './types/complex'\nimport { lengthValueType } from './types/length'\nimport { numberValueType } from './types/number'\nimport type { ValueType } from './value-type'\nimport { warnOnce } from './warn'\n\n// Property -> value-type map. Built-in seeds are installed LAZILY on first\n// resolution, never at module scope: a top-level Map.set() would be retained by\n// flat-bundle tree-shakers (esbuild/Vite) even for a transforms-only user. The\n// CI tree-shake probe enforces that this module stays out of the primitives\n// graph entirely.\nconst registry = new Map()\nconst shorthands = new Set()\nlet seeded = false\n\n// camelCase property names, space-packed to keep the seed table small.\nconst LENGTH_PROPERTIES =\n 'width height minWidth minHeight maxWidth maxHeight top right bottom left ' +\n 'marginTop marginRight marginBottom marginLeft paddingTop paddingRight paddingBottom paddingLeft ' +\n 'fontSize letterSpacing wordSpacing textIndent gap rowGap columnGap outlineWidth outlineOffset ' +\n 'borderTopWidth borderRightWidth borderBottomWidth borderLeftWidth ' +\n 'borderTopLeftRadius borderTopRightRadius borderBottomLeftRadius borderBottomRightRadius'\n\nconst COLOR_PROPERTIES =\n 'color backgroundColor borderTopColor borderRightColor borderBottomColor borderLeftColor ' +\n 'outlineColor textDecorationColor caretColor accentColor fill stroke'\n\nconst NUMBER_PROPERTIES = 'flexGrow flexShrink fontWeight'\n\n// Shorthands expand to longhands the browser reorders and pads unpredictably:\n// resolve them to the complex fallback but warn first, pointing at the longhand.\nconst SHORTHAND_PROPERTIES = 'margin padding border background font borderRadius borderColor borderWidth'\n\nconst seed = (): void => {\n if (seeded) return\n seeded = true\n for (const property of LENGTH_PROPERTIES.split(' ')) registry.set(property, lengthValueType)\n for (const property of COLOR_PROPERTIES.split(' ')) registry.set(property, colorValueType)\n for (const property of NUMBER_PROPERTIES.split(' ')) registry.set(property, numberValueType)\n for (const property of SHORTHAND_PROPERTIES.split(' ')) shorthands.add(property)\n}\n\n/**\n * Claim properties for a descriptor - the extension point for @underlying/color,\n * @underlying/scroll, and app code. Call it from explicit user code only, never\n * from a module's import side effects (a sideEffects:false bundler would drop\n * the registration). Later registrations win for groups created afterwards;\n * a live group keeps the descriptor it was created with.\n */\nexport function registerValueType(properties: readonly string[], type: ValueType): void {\n seed()\n for (const property of properties) {\n if (registry.get(property) !== undefined) {\n warnOnce(\n `reregister:${property}`,\n `value type for \"${property}\" re-registered; existing groups keep their current descriptor`,\n )\n }\n registry.set(property, type)\n }\n}\n\n/** Resolve a property to its value type. Unknown and custom (--*) properties fall back to complex. */\nexport function resolveValueType(property: string): ValueType {\n seed()\n const existing = registry.get(property)\n if (existing !== undefined) return existing\n if (shorthands.has(property)) {\n warnOnce(\n `shorthand:${property}`,\n `\"${property}\" is a shorthand; animate its longhands (e.g. ${property}Top) for predictable results`,\n )\n return complexValueType\n }\n return complexValueType\n}\n\n/** Test-only: whether the built-in seeds have been installed yet. */\nexport function __isSeeded(): boolean {\n return seeded\n}\n\n/** Test-only: clears all registrations and the seed flag. */\nexport function __resetRegistry(): void {\n registry.clear()\n shorthands.clear()\n seeded = false\n}\n","import type { Scheduler } from '../scheduler/scheduler'\n\n/**\n * A delay on the frame clock (clamped, batched into the single loop), never on\n * setTimeout: a background tab pauses the delay like everything else. Returns an\n * unsubscribe that cancels a still-pending wait. Shared by stagger() and the\n * animate() delay wave so there is ONE frame-clock delay implementation.\n */\nexport const waitFrames = (ms: number, scheduler: Scheduler, onDone: () => void): (() => void) => {\n let elapsedMs = 0\n const unsubscribe = scheduler.subscribe(({ deltaMs }) => {\n elapsedMs += deltaMs\n if (elapsedMs >= ms) {\n unsubscribe()\n onDone()\n }\n })\n return unsubscribe\n}\n","import type { EasingInput } from '../physics/easing-registry'\nimport type { Easing } from '../physics/easings'\nimport type { AnimationHandle } from '../value/animatable'\nimport { thenFinished } from '../value/thenable'\n\n/**\n * One expressive keyframe stop: a value plus an optional position and the easing\n * of the segment REACHING it. `at` is a 0..1 fraction of the total duration\n * (tween mode); `ease` overrides the animation easing for that one segment. A\n * bare value is shorthand for `{ value }`. `null` at index 0 means \"from the\n * current value\"; a `null` later HOLDS the previous value (a dwell).\n *\n * `at` positions a waypoint in time (WAAPI-consistent): an `at` on the LAST\n * waypoint means the final value is reached at that fraction and then held to the\n * end of the duration - a settle-and-dwell, not the full-duration default.\n */\nexport interface KeyframeStop {\n value: V | null\n /** 0..1 position along the total duration where this stop is reached (tween mode). Non-decreasing. */\n at?: number\n /** Easing of the segment reaching this stop (tween mode); defaults to the animation easing. */\n ease?: EasingInput\n}\n\n/** A keyframe entry: a bare value, `null` (from-current / hold), or an expressive stop. */\nexport type KeyframeInput = V | null | KeyframeStop\n\n/**\n * Keyframe semantics, shared by numeric channels and registry property groups.\n * Without a duration the waypoints are CHAINED SPRINGS: spring to waypoint k,\n * and only once it has rested (exact snap) spring to k+1 - the honest physics\n * of \"spring through a list of targets\" (positions/per-segment easing are\n * tween-only and ignored here). With a duration they become a piecewise tween;\n * the duration is split by the stops' positions (evenly when unset) and each\n * segment eases with its own easing (the animation easing when unset). A new\n * animate() interrupts the chain (velocity conserved into the replacement);\n * stop() freezes the running segment and drops the rest. Never rejects.\n */\nexport interface ChainOps {\n /** Teleport to a value (explicit keyframe-0 start), velocity 0. */\n teleport(target: T): void\n spring(target: T): AnimationHandle\n tween(target: T, durationMs: number, easing: Easing): AnimationHandle\n /** Reduced-motion: settle directly onto the final waypoint. */\n settle(target: T): void\n}\n\nexport interface ChainConfig {\n duration?: number\n easing: Easing\n reduced: boolean\n /** Per-waypoint segment duration in ms (tween mode); overrides the even split where present. */\n segmentDurations?: number[]\n /** Per-waypoint easing (tween mode); overrides `easing` for that segment where defined. */\n segmentEasings?: ReadonlyArray\n}\n\nexport interface KeyframeChain {\n handle: AnimationHandle\n /** A new animate() took over this channel: stop advancing and resolve (do not freeze - the replacement owns it now). */\n interrupt(): void\n}\n\nexport interface NormalizedKeyframes {\n /** undefined = start from the current value+velocity; otherwise a teleport start. */\n teleport: V | undefined\n waypoints: V[]\n /** Per-waypoint 0..1 arrival position; undefined = auto (even split). Aligned to `waypoints`. */\n offsets: ReadonlyArray\n /** Per-waypoint easing input reaching it; undefined = the animation easing. Aligned to `waypoints`. */\n eases: ReadonlyArray\n}\n\nconst isStop = (entry: KeyframeInput): entry is KeyframeStop =>\n entry !== null && typeof entry === 'object' && !Array.isArray(entry)\n\n/**\n * Normalize a keyframe array. `[]` -> null (ignored). `[a]` -> from current to a.\n * `[a, b, ...]` -> teleport to a (null a = from current), then chain b, ... . A\n * `null` past index 0 HOLDS the previous value (a dwell); a leading run of nulls\n * with no prior value is dropped. Bare values and `{ value, at, ease }` stops mix\n * freely; the per-waypoint `at`/`ease` are collected into parallel arrays.\n */\nexport function normalizeKeyframes(frames: ReadonlyArray>): NormalizedKeyframes | null {\n if (frames.length === 0) return null\n\n // Flatten each entry to (value|null, at?, ease?), resolving a mid-chain null to\n // a hold of the last concrete value.\n const values: (V | null)[] = []\n const offsets: (number | undefined)[] = []\n const eases: (EasingInput | undefined)[] = []\n let lastConcrete: V | undefined\n for (const entry of frames) {\n const stop = isStop(entry) ? entry : { value: entry as V | null }\n let value = stop.value\n if (value === null && values.length > 0) {\n // A hold: repeat the previous concrete value. With nothing concrete yet, drop it.\n if (lastConcrete === undefined) continue\n value = lastConcrete\n }\n if (value !== null) lastConcrete = value\n values.push(value)\n offsets.push(stop.at)\n eases.push(stop.ease)\n }\n if (values.length === 0) return null\n\n const head = values[0] ?? null\n const tailValues: V[] = []\n const tailOffsets: (number | undefined)[] = []\n const tailEases: (EasingInput | undefined)[] = []\n for (let i = 1; i < values.length; i++) {\n const value = values[i]\n if (value === null || value === undefined) continue // an unresolved head-hold; skip\n tailValues.push(value)\n tailOffsets.push(offsets[i])\n tailEases.push(eases[i])\n }\n\n if (tailValues.length === 0) {\n // Single meaningful value: animate from the current state to it.\n if (head === null) return null\n return { teleport: undefined, waypoints: [head], offsets: [offsets[0]], eases: [eases[0]] }\n }\n return { teleport: head === null ? undefined : head, waypoints: tailValues, offsets: tailOffsets, eases: tailEases }\n}\n\nexport function runKeyframeChain(\n normalized: { teleport: T | undefined; waypoints: T[] },\n ops: ChainOps,\n config: ChainConfig,\n): KeyframeChain {\n const { waypoints } = normalized\n let cancelled = false\n let current: AnimationHandle | null = null\n let onInterrupt: ((h: AnimationHandle) => void) | null = null\n let resolveFinished = (): void => {}\n const finished = new Promise((resolve) => {\n resolveFinished = resolve\n })\n\n if (waypoints.length === 0) {\n resolveFinished()\n return { handle: { finished, then: thenFinished(finished), stop: () => {} }, interrupt: () => {} }\n }\n\n if (config.reduced) {\n // Springs converge, so fast-forwarding every segment equals settling on the\n // last target: collapse straight to the final waypoint.\n ops.settle(waypoints[waypoints.length - 1]!)\n resolveFinished()\n return { handle: { finished, then: thenFinished(finished), stop: () => {} }, interrupt: () => {} }\n }\n\n if (normalized.teleport !== undefined) ops.teleport(normalized.teleport)\n\n const evenMs = config.duration !== undefined ? config.duration / waypoints.length : 0\n\n void (async () => {\n for (let i = 0; i < waypoints.length; i++) {\n if (cancelled) return\n const waypoint = waypoints[i]!\n if (config.duration !== undefined) {\n const ms = config.segmentDurations?.[i] ?? evenMs\n const easing = config.segmentEasings?.[i] ?? config.easing\n current = ops.tween(waypoint, ms, easing)\n } else {\n current = ops.spring(waypoint)\n }\n await current.finished\n if (cancelled) return\n }\n resolveFinished()\n })()\n\n // stop() and interrupt() both end the chain mid-flight (a freeze vs. a handoff),\n // so both fire 'interrupt' - the lifecycle owner above hooks it to report\n // onInterrupt instead of onComplete. Natural completion never sets `cancelled`,\n // so it never fires interrupt.\n const handle: AnimationHandle = {\n finished,\n then: thenFinished(finished),\n stop: () => {\n if (cancelled) return\n cancelled = true\n current?.stop()\n resolveFinished()\n onInterrupt?.(handle)\n },\n eventCallback(event, fn) {\n if (event === 'interrupt') onInterrupt = fn ?? null\n return handle\n },\n }\n return {\n handle,\n interrupt: () => {\n if (cancelled) return\n cancelled = true\n resolveFinished()\n onInterrupt?.(handle)\n },\n }\n}\n\n/**\n * Fill per-waypoint arrival positions to a non-decreasing 0..1 array. Explicit\n * `at` values anchor; gaps interpolate linearly between the nearest anchors (a\n * virtual 0 before the first, 1 at the last when unset) - the times[] contract.\n */\nexport function fillOffsets(count: number, explicit: ReadonlyArray): number[] {\n const out: (number | undefined)[] = []\n for (let i = 0; i < count; i++) {\n const at = explicit[i]\n out.push(at === undefined ? undefined : Math.min(1, Math.max(0, at)))\n }\n if (out[count - 1] === undefined) out[count - 1] = 1\n\n let lastIdx = -1\n let lastVal = 0\n for (let i = 0; i < count; i++) {\n const at = out[i]\n if (at === undefined) continue\n const span = i - lastIdx\n for (let j = lastIdx + 1; j < i; j++) out[j] = lastVal + ((at - lastVal) * (j - lastIdx)) / span\n lastIdx = i\n lastVal = at\n }\n\n // Clamp to non-decreasing so a mis-ordered `at` can never make a negative segment.\n let prev = 0\n const result: number[] = []\n for (let i = 0; i < count; i++) {\n const at = Math.min(1, Math.max(prev, out[i] ?? prev))\n result.push(at)\n prev = at\n }\n return result\n}\n","import { warnOnce } from '../value/warn'\n\n/**\n * An element animate() can drive: an HTML or SVG element. Both carry `.style`,\n * `getAttribute`/`setAttribute`, and resolve under getComputedStyle, so the same\n * style + attribute machinery serves both (SVG unlocks viewBox/r/points via `attr:`).\n */\nexport type AnimatableElement = HTMLElement | SVGElement\n\n/** What animate() accepts as its target: one element, a selector, a NodeList, or any element iterable. */\nexport type AnimationTarget = AnimatableElement | string | NodeList | Iterable\n\n/**\n * SSR-safe HTMLElement check. `typeof` guard first: HTMLElement is not a global\n * server-side, where a bare `instanceof HTMLElement` would throw ReferenceError.\n * Exported so animate()'s fast-path guard reuses it instead of a bare instanceof.\n */\nexport const isHTMLElement = (value: unknown): value is HTMLElement =>\n typeof HTMLElement !== 'undefined' && value instanceof HTMLElement\n\n/** SSR-safe check for an animatable (HTML or SVG) element. */\nexport const isAnimatableElement = (value: unknown): value is AnimatableElement =>\n (typeof HTMLElement !== 'undefined' && value instanceof HTMLElement) ||\n (typeof SVGElement !== 'undefined' && value instanceof SVGElement)\n\n/**\n * Resolve an animate() target to a concrete element list. A selector is queried\n * against `root` (or the document) at call time - a static snapshot, so nodes\n * added later are not animated (re-resolve to pick them up). Non-element matches\n * (text nodes) are filtered out. SSR-safe: a selector with no document resolves to\n * [] (no throw), and an empty selector match warns once.\n */\nexport function resolveTargets(input: AnimationTarget, root?: ParentNode): AnimatableElement[] {\n if (isAnimatableElement(input)) return [input]\n if (typeof input === 'string') {\n if (typeof document === 'undefined') {\n warnOnce('targets:ssr', 'animate(selector) needs a document; no targets resolved server-side')\n return []\n }\n const found = Array.from((root ?? document).querySelectorAll(input)).filter(isAnimatableElement)\n if (found.length === 0) warnOnce(`targets:empty:${input}`, `selector \"${input}\" matched no elements`)\n return found\n }\n // NodeList or any Element iterable: keep only HTML/SVG elements.\n return Array.from(input as Iterable).filter(isAnimatableElement)\n}\n","import { warnOnce } from '../value/warn'\nimport type { AnimateKeyframes, AnimateValue } from './animate'\nimport type { AnimatableElement } from './resolve-target'\n\n/**\n * A target resolved against the current value. The numeric channels accept the\n * precise literal form (unitless); a registry property accepts the same plus a\n * unit (e.g. '+=40px'), which type-checks as a plain string and is detected at\n * runtime. '*=' scales.\n */\nexport type RelativeValue = `+=${number}` | `-=${number}` | `*=${number}`\n\n/** A per-target value: receives the item's index, its element, and the set count. */\nexport type ValueFn = (index: number, element: AnimatableElement, total: number) => V\n\n/** A single magnitude read from a registry property, plus how to re-emit it preserving the unit/template. */\nexport interface Magnitude {\n readonly value: number\n reformat(next: number): string\n}\n\nexport interface ResolveContext {\n readonly index: number\n readonly element: AnimatableElement\n readonly total: number\n /** Current value of a numeric channel (caller bakes in the INITIAL fallback); undefined if `key` is not a numeric channel. */\n readNumeric(key: string): number | undefined\n /** Current single magnitude of a registry property + a re-emitter; undefined if not resolvable or multi-channel. */\n readMagnitude(key: string): Magnitude | undefined\n}\n\n// A relative operand may carry a unit on a registry property (width:'+=40px');\n// the unit is informational - the result is re-emitted in the property's CURRENT\n// unit/template. Numeric channels are unitless.\nconst RELATIVE = /^([+\\-*])=(-?\\d*\\.?\\d+)[a-z%]*$/i\n\nconst parseRelative = (s: string): { op: '+' | '-' | '*'; operand: number } | null => {\n const match = RELATIVE.exec(s)\n if (match === null) return null\n return { op: match[1] as '+' | '-' | '*', operand: Number(match[2]) }\n}\n\nconst applyRelative = (cur: number, op: '+' | '-' | '*', operand: number): number =>\n op === '+' ? cur + operand : op === '-' ? cur - operand : cur * operand\n\n/** A keyframe stop object `{ value, at?, ease? }` - distinguished from a bare value/null. */\nconst isStop = (w: unknown): w is { value: AnimateValue | null } =>\n w !== null && typeof w === 'object' && !Array.isArray(w)\n\n/** The value a waypoint carries (a bare value, a hold null, or a stop's `.value`). */\nconst waypointValue = (w: unknown): AnimateValue | null => (isStop(w) ? w.value : (w as AnimateValue | null))\n\n/** True if a raw value needs per-element resolution (a function, or a relative string incl. inside keyframes). */\nexport const needsResolve = (raw: unknown): boolean => {\n if (typeof raw === 'function') return true\n if (typeof raw === 'string') return RELATIVE.test(raw)\n if (Array.isArray(raw)) {\n return raw.some((waypoint) => {\n const value = waypointValue(waypoint)\n return typeof value === 'string' && RELATIVE.test(value)\n })\n }\n return false\n}\n\nconst resolveScalar = (key: string, value: AnimateValue, ctx: ResolveContext): AnimateValue => {\n if (typeof value !== 'string') return value\n const rel = parseRelative(value)\n if (rel === null) return value\n const num = ctx.readNumeric(key)\n if (num !== undefined) return applyRelative(num, rel.op, rel.operand)\n const mag = ctx.readMagnitude(key)\n if (mag !== undefined) return mag.reformat(applyRelative(mag.value, rel.op, rel.operand))\n warnOnce(`relative:${key}`, `relative \"${value}\" on \"${key}\" is not decomposable; used ${rel.operand}`)\n return rel.operand\n}\n\nconst resolveKeyframes = (key: string, frames: AnimateKeyframes, ctx: ResolveContext): AnimateKeyframes => {\n // Relatives chain against the prior resolved waypoint (index 0 against the current value).\n // One running magnitude serves both numeric channels and single-magnitude registry\n // properties; the magnitude reader is fetched only when a relative is present (it reads\n // computed style). An absolute waypoint re-seeds the chain so a following relative is correct.\n const numeric = ctx.readNumeric(key)\n const mag =\n numeric === undefined &&\n frames.some((waypoint) => {\n const value = waypointValue(waypoint)\n return typeof value === 'string' && parseRelative(value) !== null\n })\n ? ctx.readMagnitude(key)\n : undefined\n let running: number | undefined = numeric ?? mag?.value\n\n // Resolve one waypoint's value against the running magnitude, advancing it.\n const resolveOne = (value: AnimateValue | null): AnimateValue | null => {\n if (value === null) return null\n if (typeof value === 'number') {\n running = value\n return value\n }\n const rel = parseRelative(value)\n if (rel === null) {\n const seed = Number.parseFloat(value)\n running = Number.isFinite(seed) ? seed : undefined\n return value\n }\n if (running === undefined) {\n warnOnce(`relative:${key}`, `relative \"${value}\" on \"${key}\" keyframe is not decomposable; used ${rel.operand}`)\n return rel.operand\n }\n running = applyRelative(running, rel.op, rel.operand)\n return mag !== undefined ? mag.reformat(running) : running\n }\n\n return frames.map((waypoint) =>\n // A stop keeps its position/easing metadata; only its value resolves.\n isStop(waypoint) ? { ...waypoint, value: resolveOne(waypoint.value) } : resolveOne(waypoint as AnimateValue | null),\n )\n}\n\n/** A value before per-target resolution: an absolute value/keyframes, a relative string, or a function returning any of those. */\nexport type ResolvableValue =\n | AnimateValue\n | AnimateKeyframes\n | RelativeValue\n | ValueFn\n\n/**\n * Resolve a possibly function/relative/keyframe value to an absolute value or\n * keyframe array for one element. A function is evaluated first (it may return a\n * relative string or a keyframe array, which re-enter resolution); relatives read\n * the LIVE cached value through `ctx`, so a re-fire retargets from the in-flight\n * position. Pure; never throws.\n */\nexport function resolveValue(key: string, raw: ResolvableValue, ctx: ResolveContext): AnimateValue | AnimateKeyframes {\n const value = typeof raw === 'function' ? raw(ctx.index, ctx.element, ctx.total) : raw\n if (Array.isArray(value)) return resolveKeyframes(key, value, ctx)\n return resolveScalar(key, value as AnimateValue, ctx)\n}\n","import type { MeasureUnit } from '../value/value-type'\nimport type { StyleReader } from './read-style'\n\n// Percentages resolve against the containing block: the block axis for these\n// properties, the inline axis (parent width) for everything else - including all\n// margins and paddings, per CSS.\nconst BLOCK_AXIS = new Set(['height', 'minHeight', 'maxHeight', 'top', 'bottom', 'rowGap'])\n\nconst positive = (value: number): number | null =>\n Number.isFinite(value) && value > 0 ? value : null\n\n/**\n * Builds the \"px per 1 unit\" function for one element+property context, used by\n * a value type's `convert` to rebase across units. Reads happen at most once per\n * unit (memoized) and only when that unit is actually requested; an unmeasurable\n * unit (no parent, zero/auto computed basis, unknown unit) returns null, which\n * makes the caller snap rather than mix incompatible units.\n */\nexport function createMeasure(\n element: Element,\n property: string,\n read: StyleReader,\n): MeasureUnit {\n const cache = new Map()\n\n const viewport = (pick: (w: number, h: number) => number): number | null => {\n const doc = element.ownerDocument.documentElement\n return positive(pick(doc.clientWidth, doc.clientHeight) / 100)\n }\n\n const compute = (unit: string): number | null => {\n switch (unit) {\n case 'px':\n return 1\n case 'em':\n return positive(parseFloat(read.get('fontSize')))\n case 'rem':\n return positive(parseFloat(getComputedStyle(element.ownerDocument.documentElement).fontSize))\n case '%': {\n const parent = element.parentElement\n if (parent === null) return null\n const parentStyle = getComputedStyle(parent)\n const basis = BLOCK_AXIS.has(property) ? parentStyle.height : parentStyle.width\n return positive(parseFloat(basis) / 100)\n }\n case 'vw':\n return viewport((w) => w)\n case 'vh':\n return viewport((_w, h) => h)\n case 'vmin':\n return viewport((w, h) => Math.min(w, h))\n case 'vmax':\n return viewport((w, h) => Math.max(w, h))\n default:\n return null\n }\n }\n\n return (unit) => {\n const cached = cache.get(unit)\n if (cached !== undefined) return cached\n const value = compute(unit)\n cache.set(unit, value)\n return value\n }\n}\n","import { getReducedMotionBehavior, type ReducedMotionBehavior } from '../a11y/config'\nimport { prefersReducedMotion } from '../a11y/reduced-motion'\nimport { resolveEasing, type EasingInput } from '../physics/easing-registry'\nimport { easeInOutCubic, type Easing } from '../physics/easings'\nimport type { SpringOptions } from '../physics/spring'\nimport type { ToOptions } from '../physics/tween'\nimport type { Scheduler } from '../scheduler/scheduler'\nimport { getSharedScheduler } from '../scheduler/shared'\nimport { channelGroup, type ChannelGroup } from '../value/channel-group'\nimport { resolveValueType } from '../value/registry'\nimport type { ParsedValue, ValueType } from '../value/value-type'\nimport { warnOnce } from '../value/warn'\nimport { animatable, type Animatable, type AnimationHandle } from '../value/animatable'\nimport { thenFinished } from '../value/thenable'\nimport { waitFrames } from '../compose/wait'\nimport type { DelayFn } from '../compose/stagger-delay'\nimport { bindProperty, type PropertyBinding } from './bind-property'\nimport { bindStyle } from './bind-style'\nimport {\n fillOffsets,\n normalizeKeyframes,\n runKeyframeChain,\n type ChainConfig,\n type ChainOps,\n type KeyframeChain,\n type KeyframeInput,\n type NormalizedKeyframes,\n} from './keyframes'\nimport { readAttribute, readStyle, toKebab, type StyleReader } from './read-style'\nimport { isHTMLElement, resolveTargets, type AnimatableElement, type AnimationTarget } from './resolve-target'\nimport {\n needsResolve,\n resolveValue,\n type Magnitude,\n type RelativeValue,\n type ResolvableValue,\n type ResolveContext,\n type ValueFn,\n} from './resolve-value'\nimport {\n formatOrigin,\n formatTransform,\n ORIGIN_KEYS,\n TRANSFORM_KEYS,\n type OriginChannel,\n type OriginChannels,\n type TransformChannel,\n type TransformChannels,\n} from './transform'\nimport { createMeasure } from './units'\n\ntype Channel = TransformChannel | OriginChannel | 'opacity'\n\n/** A CSS value the registry path animates: a number or a CSS string. */\nexport type AnimateValue = number | string\n\n/**\n * Keyframe waypoints. Each entry is a bare value, `null` (from-current at index 0,\n * a hold later), or an expressive `{ value, at, ease }` stop for per-segment\n * position and easing.\n */\nexport type AnimateKeyframes = ReadonlyArray>\nexport type NumericKeyframes = ReadonlyArray>\n\n/**\n * Any property key that is NOT one of the five numeric channels: a\n * CSSStyleDeclaration property (camelCase), a custom property, or an `attr:name`\n * key routed to setAttribute (SVG/element attributes - viewBox, r, points). A typo\n * like `{ opactiy: 1 }` does not compile. (CSSStyleDeclaration method names\n * type-check as keys - accepted noise.)\n */\nexport type AnimateProperty = Exclude, Channel> | `--${string}` | `attr:${string}`\n\n/** A numeric-channel key: a transform/origin channel, opacity, or the autoAlpha alias (opacity + visibility). */\ntype NumericKey = Channel | 'autoAlpha'\n\nexport type { AnimationTarget } from './resolve-target'\nexport type { RelativeValue, ValueFn } from './resolve-value'\n\n/** A numeric-channel target: absolute, keyframes, a relative string, or a per-target function. */\ntype ResolvableNumeric = number | NumericKeyframes | RelativeValue | ValueFn\n/** A registry-property target: absolute, keyframes, a relative string, or a per-target function. */\ntype ResolvableProperty =\n | AnimateValue\n | AnimateKeyframes\n | RelativeValue\n | ValueFn\n\n/**\n * The five channels stay numeric; everything else routes through the value-type\n * registry. Each value may also be a relative string (`'+=100'`) resolved against\n * the current value, or a per-target function `(index, element, count) => value`.\n * The keys are unchanged, so a typo like `{ opactiy: 1 }` still does not compile.\n */\nexport type AnimateTargets = Partial> &\n Partial>\n\n/** The absolute targets animateOne() consumes after the per-element pre-pass (no functions/relatives). */\ntype ResolvedTargets = Partial> &\n Partial>\n\n/** A from-state numeric value: absolute, a relative string, or a per-target function (no keyframes - a from-state is one value). */\ntype FromNumeric = number | RelativeValue | ValueFn\n/** A from-state registry value: absolute, a relative string, or a per-target function (no keyframes). */\ntype FromProperty = AnimateValue | RelativeValue | ValueFn\n\n/**\n * An entrance from-state: the same keys and value forms as a target (channels\n * plus arbitrary CSS properties; absolute, relative `'+='`, or a per-target\n * function), but a single value per key - a from-state is one point, not a\n * keyframe path. Resolved per element against the live value at the call.\n */\nexport type FromTargets = Partial> & Partial>\n\n/** The absolute from-state setStyle() teleports to, after per-element resolution. */\ntype ResolvedFrom = Partial> & Partial>\n\nexport interface AnimateOptions extends Omit {\n /** ms - providing a duration switches to the tween escape hatch. */\n duration?: number\n easing?: EasingInput\n scheduler?: Scheduler\n /**\n * Per-target start delay. A number staggers each target by index*delay; a\n * `DelayFn` from `staggerDelay()` is an expressive wave (origin, grid, axis,\n * easing). On a single element it is just a flat lead-in.\n */\n delay?: number | DelayFn\n /** Element-level reduced-motion strategy - 'fade' keeps opacity AND colors animated. */\n reducedMotion?: ReducedMotionBehavior\n /**\n * Entrance from-state. Each key is set to its from-value SYNCHRONOUSLY at the\n * call (no flash, no manual setStyle), then animated to `targets`. With a\n * stagger `delay`, every element is parked at its from-state immediately and\n * holds it through its own delay, like a real entrance. Same value forms as a\n * target (absolute, relative `'+='`, per-target function), resolved per element\n * against the live value. Under reduced motion the from-set is skipped: the\n * element ends at `targets`, never stranded at the from-state. The `from()` and\n * `fromTo()` helpers are thin sugar over this option.\n */\n from?: FromTargets\n /** Fired once when the animation begins. */\n onStart?(this: object, handle: AnimationHandle): void\n /**\n * Per frame with the live numeric channel values (`{ x, y, scale, ... }`). Requesting it\n * runs the JS path (a per-frame tick), so it skips the WAAPI compositor fast path. Unlike a\n * single value's `onUpdate`, this is NOT change-guarded - it ticks every frame of the run\n * (a multi-channel object has no single \"changed\"); guard in the callback if you need to.\n */\n onUpdate?(this: object, values: Record, handle: AnimationHandle): void\n /** Fired once when every channel settles (no channel was interrupted). */\n onComplete?(this: object, handle: AnimationHandle): void\n /** Fired once when a channel is superseded by a later animate(), or the handle is stopped. */\n onInterrupt?(this: object, handle: AnimationHandle): void\n /** The `this` receiver for the callbacks. Defaults to the handle. */\n scope?: object\n}\n\n/**\n * True if any lifecycle callback was requested - then the numeric path stays on the JS loop.\n * Even onStart/onComplete/scope opt out of WAAPI: the compositor reclaim path resolves\n * `finished` on a supersede the same as on a settle, so it cannot tell onComplete (settle)\n * from onInterrupt (supersede). The JS path can - each child handle reports its own interrupt -\n * so honoring the onComplete contract (never fires on a supersede) means owning every frame.\n */\nconst hasLifecycle = (o: AnimateOptions): boolean =>\n o.onStart !== undefined ||\n o.onUpdate !== undefined ||\n o.onComplete !== undefined ||\n o.onInterrupt !== undefined ||\n o.scope !== undefined\n\n// First touch of a channel starts from its CSS-neutral value; afterwards the\n// cached animatable carries the real state across calls - that is what makes\n// a second animate() an interruption instead of a parallel animation.\nconst INITIAL: Record = {\n perspective: 0,\n x: 0,\n y: 0,\n rotateX: 0,\n rotateY: 0,\n rotateZ: 0,\n rotate: 0,\n skewX: 0,\n skewY: 0,\n scale: 1,\n scaleX: 1,\n scaleY: 1,\n originX: 50,\n originY: 50,\n opacity: 1,\n}\n\nconst TRANSFORM_CHANNELS: ReadonlyArray = TRANSFORM_KEYS\nconst NUMERIC_CHANNELS = new Set([...TRANSFORM_KEYS, ...ORIGIN_KEYS, 'opacity'])\n\n/** The slice of a WAAPI Animation the delegation relies on (testable shape). */\nexport interface DelegatedAnimation {\n currentTime: CSSNumberish | null\n onfinish: (() => void) | null\n cancel(): void\n // Optional members the playback layer drives; the two-field call sites here are unaffected.\n playbackRate?: number\n pause?(): void\n play?(): void\n}\n\n/** Internal handle the playback layer maps controls onto. Not re-exported from the package entry. */\nexport interface DelegatedControls {\n readonly animation: DelegatedAnimation\n readonly durationMs: number\n}\n\ninterface DelegatedTween {\n animation: DelegatedAnimation\n /** Per-channel frame arrays, all of length n (the keyframe count). */\n channels: Map\n n: number\n durationMs: number\n easing: Easing\n finish: () => void\n}\n\ninterface GroupEntry {\n group: ChannelGroup\n binding: PropertyBinding\n /** 'attr' groups clean up via removeAttribute; 'style' via style.removeProperty. */\n target: PropTarget\n /** The bare DOM name written (an attribute name, or the style property). */\n name: string\n}\n\n/** Where a registry-property group writes: an inline style property or an element attribute. */\ntype PropTarget = 'style' | 'attr'\nconst ATTR_PREFIX = 'attr:'\nconst isAttrKey = (key: string): boolean => key.startsWith(ATTR_PREFIX)\n/** The bare DOM name behind a target key ('attr:r' -> 'r'; a style key is itself). */\nconst bareName = (key: string): string => (key.startsWith(ATTR_PREFIX) ? key.slice(ATTR_PREFIX.length) : key)\n\ninterface ElementEntry {\n values: Partial>\n disposeBinding: () => void\n scheduler: Scheduler\n delegated: DelegatedTween | null\n groups: Map\n /** Per-key running keyframe chains, so a new animate() on that key can interrupt them. */\n chains: Map void>\n /** Bumped on every animation intent on this element, so a pending staggered start can tell it was superseded. */\n generation: number\n /** Once autoAlpha touched this element, its opacity write also toggles visibility. */\n autoAlpha: boolean\n}\n\n/** Mark a new animation intent on the element and return the fresh generation token. */\nconst markIntent = (entry: ElementEntry): number => (entry.generation += 1)\n\nconst registry = new WeakMap()\n\nconst supportsWaapi = (element: AnimatableElement): boolean =>\n typeof element.animate === 'function' &&\n typeof CSS !== 'undefined' &&\n typeof CSS.supports === 'function' &&\n CSS.supports('animation-timing-function', 'linear(0, 1)')\n\n// Arbitrary easing functions ride to the compositor as a sampled linear().\nconst EASING_SAMPLES = 16\nconst toLinearEasing = (easing: Easing): string => {\n const stops: string[] = []\n for (let i = 0; i <= EASING_SAMPLES; i++) stops.push(String(easing(i / EASING_SAMPLES)))\n return `linear(${stops.join(', ')})`\n}\n\n/**\n * Take control back from the compositor: evaluate the curve at currentTime -\n * position AND derivative, per segment - seed the animatables with both, cancel\n * WAAPI. No DOM readback, no precision loss: the math was ours all along. With\n * n keyframes the progress maps onto an even segment grid; n = 2 degenerates to\n * a single segment (the original two-keyframe reclaim).\n */\nconst reclaim = (entry: ElementEntry): void => {\n const delegated = entry.delegated\n if (delegated === null) return\n entry.delegated = null\n\n const elapsedMs = Math.min(\n Number(delegated.animation.currentTime ?? delegated.durationMs),\n delegated.durationMs,\n )\n const progress = delegated.durationMs <= 0 ? 1 : elapsedMs / delegated.durationMs\n const segments = delegated.n - 1\n const s = progress * segments\n const index = Math.min(Math.floor(s), segments - 1)\n const t = s - index\n const window = 0.01\n const t1 = Math.min(1, t + window)\n const t0 = Math.max(0, t - window)\n const slope = (delegated.easing(t1) - delegated.easing(t0)) / (t1 - t0)\n const segmentDurationS = delegated.durationMs / 1000 / segments\n // A reversed delegated tween (playbackRate < 0) hands back a negated velocity;\n // the forward path defaults to 1, so existing reclaims are byte-identical.\n const rateSign = Math.sign(delegated.animation.playbackRate ?? 1) || 1\n\n for (const [channel, frames] of delegated.channels) {\n const value = entry.values[channel]\n if (value === undefined) continue\n const from = frames[index] ?? 0\n const to = frames[index + 1] ?? from\n const span = to - from\n value.set(from + span * delegated.easing(t), { velocity: ((span * slope) / segmentDurationS) * rateSign })\n }\n delegated.animation.cancel()\n delegated.finish()\n}\n\nconst ensureChannel = (entry: ElementEntry, channel: Channel): { value: Animatable; created: boolean } => {\n const existing = entry.values[channel]\n if (existing !== undefined) return { value: existing, created: false }\n const value = animatable(INITIAL[channel], { scheduler: entry.scheduler })\n entry.values[channel] = value\n return { value, created: true }\n}\n\nconst rebind = (entry: ElementEntry, element: AnimatableElement): void => {\n entry.disposeBinding()\n entry.disposeBinding = bindStyle(element, entry.values, { scheduler: entry.scheduler, autoAlpha: entry.autoAlpha })\n}\n\ntype NumericNorm = { teleport: number | undefined; waypoints: number[] }\n\nconst delegateMultiKeyframe = (\n entry: ElementEntry,\n element: AnimatableElement,\n scalars: Array<[Channel, number]>,\n keyframeNorms: Array<[Channel, NumericNorm]>,\n durationMs: number,\n easing: Easing,\n): AnimationHandle => {\n const channels = new Map()\n let newChannel = false\n for (const [channel, target] of scalars) {\n const { value, created } = ensureChannel(entry, channel)\n newChannel ||= created\n channels.set(channel, [value.get(), target])\n }\n for (const [channel, norm] of keyframeNorms) {\n const { value, created } = ensureChannel(entry, channel)\n newChannel ||= created\n channels.set(channel, norm.teleport !== undefined ? [norm.teleport, ...norm.waypoints] : [value.get(), ...norm.waypoints])\n }\n if (newChannel) rebind(entry, element)\n\n const n = [...channels.values()][0]?.length ?? 2\n\n // A transform / transform-origin keyframe overrides the whole property, so\n // carry the untouched channels of that group along as constants every frame.\n const animatedKeys = [...channels.keys()]\n const carry = (group: ReadonlyArray): void => {\n for (const channel of group) {\n const value = entry.values[channel]\n if (value !== undefined && !channels.has(channel)) {\n channels.set(channel, new Array(n).fill(value.get()))\n }\n }\n }\n if (animatedKeys.some((c) => c !== 'opacity' && c !== 'originX' && c !== 'originY')) carry(TRANSFORM_CHANNELS)\n if (animatedKeys.some((c) => c === 'originX' || c === 'originY')) carry(ORIGIN_KEYS)\n\n const linearEasing = toLinearEasing(easing)\n const keyframes: Record[] = []\n for (let i = 0; i < n; i++) {\n const frame: Record = {}\n const transform: TransformChannels = {}\n const origin: OriginChannels = {}\n for (const [channel, frames] of channels) {\n const value = frames[i] ?? 0\n if (channel === 'opacity') frame['opacity'] = String(value)\n else if (channel === 'originX' || channel === 'originY') origin[channel] = value\n else transform[channel] = value\n }\n if (Object.keys(transform).length > 0) frame['transform'] = formatTransform(transform)\n if (Object.keys(origin).length > 0) frame['transformOrigin'] = formatOrigin(origin)\n // Multi-keyframe: the easing rides each keyframe but the last - WAAPI applies\n // a keyframe's easing across the interval to the next one (so the JS reclaim\n // and the compositor agree on per-segment timing).\n if (n > 2 && i < n - 1) frame['easing'] = linearEasing\n keyframes.push(frame)\n }\n\n let resolveFinished = () => {}\n const finished = new Promise((resolve) => {\n resolveFinished = resolve\n })\n\n // Two keyframes: a single segment, easing at the animation level - the\n // original delegation shape.\n const options: Record = { duration: durationMs, fill: 'forwards' }\n if (n === 2) options['easing'] = linearEasing\n const animation = element.animate(keyframes, options) as unknown as DelegatedAnimation\n const tween: DelegatedTween = { animation, channels, n, durationMs, easing, finish: resolveFinished }\n entry.delegated = tween\n\n animation.onfinish = () => {\n if (entry.delegated !== tween) return\n entry.delegated = null\n for (const [channel, frames] of channels) entry.values[channel]?.set(frames[frames.length - 1] ?? 0)\n // Cancel only after the next render flush wrote the committed values -\n // cancelling first would flash the pre-animation inline style.\n const unsubscribe = entry.scheduler.subscribe(() => {\n unsubscribe()\n animation.cancel()\n }, 'render')\n resolveFinished()\n }\n\n return {\n finished,\n then: thenFinished(finished),\n stop: () => {\n if (entry.delegated === tween) reclaim(entry)\n },\n }\n}\n\nconst RESOLVED_PROMISE = Promise.resolve()\nconst RESOLVED: AnimationHandle = {\n finished: RESOLVED_PROMISE,\n then: thenFinished(RESOLVED_PROMISE),\n stop: () => {},\n}\n\n// Forwards its children's interrupt up as ONE interrupt, so an outer lifecycle\n// owner (multi-target withLifecycle, where each child IS an aggregate) can tell a\n// supersede from a settle. The single-channel case returns the bare handle, which\n// already carries eventCallback.\nconst aggregate = (handles: AnimationHandle[]): AnimationHandle => {\n if (handles.length === 0) return RESOLVED\n if (handles.length === 1) return handles[0]!\n let onInterrupt: ((h: AnimationHandle) => void) | null = null\n let fired = false\n const fireInterrupt = (): void => {\n if (fired) return\n fired = true\n onInterrupt?.(handle)\n }\n for (const child of handles) child.eventCallback?.('interrupt', fireInterrupt)\n const finished = Promise.all(handles.map((child) => child.finished)).then(() => undefined)\n const handle: AnimationHandle = {\n finished,\n then: thenFinished(finished),\n stop: () => {\n for (const child of handles) child.stop()\n },\n eventCallback(event, fn) {\n if (event === 'interrupt') onInterrupt = fn ?? null\n return handle\n },\n }\n return handle\n}\n\n/**\n * Wrap the aggregate with lifecycle callbacks. onStart fires synchronously; onUpdate\n * ticks the live numeric values each frame (not change-guarded - see AnimateOptions);\n * the FIRST child interrupted fires onInterrupt, else onComplete fires at settle. Every\n * child reports its own interrupt: a numeric channel IS an animatable, and the keyframe\n * chain and registry-property group each forward their interrupt through eventCallback,\n * so a superseded color or keyframe channel reads as onInterrupt, never a false onComplete.\n * post-hoc eventCallback handles start/complete/interrupt; onUpdate must be passed at the\n * call (it decides the JS path up front), and repeat/reverseComplete are playback-only.\n */\nconst withLifecycle = (\n base: AnimationHandle,\n children: AnimationHandle[],\n options: AnimateOptions,\n readValues: () => Record,\n scheduler: Scheduler,\n): AnimationHandle => {\n const scope = options.scope\n let onStart = options.onStart\n let onUpdate = options.onUpdate\n let onComplete = options.onComplete\n let onInterrupt = options.onInterrupt\n let ended = false\n let unsubUpdate: (() => void) | null = null\n let handle: AnimationHandle\n const finishUpdate = (): void => {\n unsubUpdate?.()\n unsubUpdate = null\n }\n const end = (cb: ((this: object, handle: AnimationHandle) => void) | undefined): void => {\n if (ended) return\n ended = true\n finishUpdate()\n cb?.call(scope ?? handle, handle)\n }\n\n for (const child of children) child.eventCallback?.('interrupt', () => end(onInterrupt))\n void base.finished.then(() => end(onComplete))\n\n handle = {\n finished: base.finished,\n then: thenFinished(base.finished),\n stop: () => base.stop(), // interrupts the children -> their interrupt fires onInterrupt above\n eventCallback(event, fn) {\n const cb = fn ?? undefined\n if (event === 'start') onStart = cb as AnimateOptions['onStart']\n else if (event === 'complete') onComplete = cb as AnimateOptions['onComplete']\n else if (event === 'interrupt') onInterrupt = cb as AnimateOptions['onInterrupt']\n return handle\n },\n }\n\n if (onUpdate !== undefined) {\n unsubUpdate = scheduler.subscribe(() => {\n if (ended) {\n finishUpdate()\n return\n }\n onUpdate?.call(scope ?? handle, readValues(), handle)\n })\n }\n onStart?.call(scope ?? handle, handle)\n return handle\n}\n\nconst springOptionsFrom = (options: AnimateOptions): SpringOptions => {\n const spring: SpringOptions = { reducedMotion: 'allow' }\n if (options.stiffness !== undefined) spring.stiffness = options.stiffness\n if (options.damping !== undefined) spring.damping = options.damping\n if (options.mass !== undefined) spring.mass = options.mass\n if (options.velocity !== undefined) spring.velocity = options.velocity\n if (options.restDelta !== undefined) spring.restDelta = options.restDelta\n if (options.restSpeed !== undefined) spring.restSpeed = options.restSpeed\n return spring\n}\n\n/** Stop a running keyframe chain on this key (a new motion is taking over). */\nconst interruptKey = (entry: ElementEntry, key: string): void => {\n const interrupt = entry.chains.get(key)\n if (interrupt !== undefined) {\n entry.chains.delete(key)\n interrupt()\n }\n}\n\n/** Register a chain so the next animate() on its key can interrupt it, and self-clean on completion. */\nconst startChain = (entry: ElementEntry, key: string, chain: KeyframeChain): AnimationHandle => {\n entry.chains.set(key, chain.interrupt)\n void chain.handle.finished.then(() => {\n if (entry.chains.get(key) === chain.interrupt) entry.chains.delete(key)\n })\n return chain.handle\n}\n\n/** The motion for one scalar numeric target - the original per-channel decision. */\nconst startNumericScalar = (\n value: Animatable,\n target: number,\n channel: Channel,\n options: AnimateOptions,\n behavior: ReducedMotionBehavior,\n reduced: boolean,\n): AnimationHandle => {\n if (reduced) {\n if (behavior === 'fade' && channel === 'opacity') {\n return value.to(target, { duration: 250, reducedMotion: 'allow' })\n }\n return value.spring(target, { reducedMotion: 'skip' })\n }\n if (options.duration !== undefined) {\n const toOptions: ToOptions =\n options.easing === undefined\n ? { duration: options.duration, reducedMotion: 'allow' }\n : { duration: options.duration, easing: options.easing, reducedMotion: 'allow' }\n return value.to(target, toOptions)\n }\n return value.spring(target, springOptionsFrom(options))\n}\n\n/** Start the right motion on a group given the element-side reduced-motion decision. */\nconst startGroupMotion = (\n group: ChannelGroup,\n target: ParsedValue,\n type: ValueType,\n options: AnimateOptions,\n behavior: ReducedMotionBehavior,\n reduced: boolean,\n): AnimationHandle => {\n if (reduced) {\n // Colors (non-spatial) keep crossfading under 'fade'; everything spatial snaps.\n if (behavior === 'fade' && type.spatial === false) {\n return group.to(target, { duration: 250, reducedMotion: 'allow' })\n }\n return group.spring(target, { reducedMotion: 'skip' })\n }\n if (options.duration !== undefined) {\n const toOptions: ToOptions =\n options.easing === undefined\n ? { duration: options.duration, reducedMotion: 'allow' }\n : { duration: options.duration, easing: options.easing, reducedMotion: 'allow' }\n return group.to(target, toOptions)\n }\n return group.spring(target, springOptionsFrom(options))\n}\n\n/** Create a cold group, start its motion BEFORE binding (so a skip settle rides the synchronous bind write), then store it. */\nconst installGroup = (\n entry: ElementEntry,\n element: AnimatableElement,\n property: string,\n type: ValueType,\n start: ParsedValue,\n startMotion: (group: ChannelGroup) => AnimationHandle,\n target: PropTarget = 'style',\n): AnimationHandle => {\n const name = target === 'attr' ? bareName(property) : property\n const group = channelGroup(type, start, { scheduler: entry.scheduler })\n const handle = startMotion(group)\n const binding = bindProperty(element, name, group, { scheduler: entry.scheduler, target })\n entry.groups.set(property, { group, binding, target, name })\n return handle\n}\n\n/** Write a literal value, dropping any group on the property. Resolves immediately, no warning. */\nconst writeLiteral = (\n entry: ElementEntry,\n element: AnimatableElement,\n property: string,\n value: AnimateValue,\n target: PropTarget = 'style',\n): AnimationHandle => {\n const existing = entry.groups.get(property)\n if (existing !== undefined) {\n existing.binding.dispose()\n existing.group.dispose()\n entry.groups.delete(property)\n }\n if (target === 'attr') element.setAttribute(bareName(property), String(value))\n else element.style.setProperty(toKebab(property), String(value))\n return RESOLVED\n}\n\n/** Drop a property's group: cannot decompose the target, write it literally and warn. */\nconst snapLiteral = (\n entry: ElementEntry,\n element: AnimatableElement,\n property: string,\n value: AnimateValue,\n target: PropTarget = 'style',\n): AnimationHandle => {\n warnOnce(`snap:${property}`, `cannot animate \"${property}\" to \"${String(value)}\"; snapped`)\n return writeLiteral(entry, element, property, value, target)\n}\n\nconst animateProperty = (\n entry: ElementEntry,\n element: AnimatableElement,\n property: string,\n value: AnimateValue,\n read: StyleReader,\n options: AnimateOptions,\n behavior: ReducedMotionBehavior,\n reduced: boolean,\n channel: PropTarget = 'style',\n): AnimationHandle => {\n const name = bareName(property)\n const type = resolveValueType(name)\n const begin = (group: ChannelGroup, target: ParsedValue): AnimationHandle =>\n startGroupMotion(group, target, type, options, behavior, reduced)\n const existing = entry.groups.get(property)\n\n if (existing !== undefined) {\n const group = existing.group\n // A keyword target (e.g. 'none') resolves against the live shape.\n const target = type.parse(value) ?? type.reconcile?.(String(value), group.shape) ?? null\n if (target === null) return snapLiteral(entry, element, property, value, channel)\n if (target.shape === group.shape) return begin(group, target)\n const multiplier = type.convert?.(group.shape, target.shape, createMeasure(element, name, read)) ?? null\n if (multiplier !== null) {\n group.rebase(multiplier, target.shape)\n return begin(group, target)\n }\n // Shape mismatch with no conversion (e.g. 1 shadow -> 2): snap, recreate at target.\n existing.binding.dispose()\n existing.group.dispose()\n entry.groups.delete(property)\n warnOnce(`snap:${property}`, `\"${name}\" changed shape (${group.shape} -> ${target.shape}); snapped`)\n return installGroup(entry, element, property, type, target, () => RESOLVED, channel)\n }\n\n // Cold start.\n const raw = read.get(name)\n const parsedTarget = type.parse(value)\n if (parsedTarget === null) {\n // Keyword target: synthesize against the current computed shape.\n const current = type.parse(raw)\n if (current !== null && type.reconcile !== undefined) {\n const recon = type.reconcile(String(value), current.shape)\n if (recon !== null)\n return installGroup(entry, element, property, type, current, (group) => begin(group, recon), channel)\n }\n return snapLiteral(entry, element, property, value, channel)\n }\n const target = parsedTarget\n\n const current = type.reconcile?.(raw, target.shape) ?? type.parse(raw)\n if (current !== null && current.shape === target.shape) {\n return installGroup(entry, element, property, type, current, (group) => begin(group, target), channel)\n }\n if (current !== null) {\n const multiplier = type.convert?.(current.shape, target.shape, createMeasure(element, name, read)) ?? null\n if (multiplier !== null) {\n return installGroup(\n entry,\n element,\n property,\n type,\n current,\n (group) => {\n group.rebase(multiplier, target.shape)\n return begin(group, target)\n },\n channel,\n )\n }\n }\n // No resolvable start value (computed 'auto', detached parent, ...): snap to target.\n warnOnce(`snap:${property}`, `cannot resolve a start for \"${name}\" (computed \"${raw}\"); snapped to target`)\n return installGroup(entry, element, property, type, target, () => RESOLVED, channel)\n}\n\n/**\n * Per-segment tween timings from a normalized keyframe result: variable segment\n * durations from explicit `at` positions and per-segment easings from explicit\n * `ease`. Both are tween-only - positions need a duration; per-segment easing is\n * carried regardless (the chain applies it only on the tween branch).\n */\nconst segmentTimings = (\n normalized: NormalizedKeyframes,\n duration: number | undefined,\n): Pick => {\n const { waypoints, offsets, eases } = normalized\n const out: Pick = {}\n if (eases.some((e) => e !== undefined)) {\n out.segmentEasings = eases.map((e) => (e !== undefined ? resolveEasing(e) : undefined))\n }\n if (duration !== undefined && offsets.some((o) => o !== undefined)) {\n const arrivals = fillOffsets(waypoints.length, offsets)\n const durations: number[] = []\n let prev = 0\n for (const arrival of arrivals) {\n durations.push(Math.max(0, arrival - prev) * duration)\n prev = arrival\n }\n out.segmentDurations = durations\n }\n return out\n}\n\n/** True if any waypoint carries an explicit position or per-segment easing (the expressive form). */\nconst hasKeyframeMeta = (normalized: NormalizedKeyframes): boolean =>\n normalized.offsets.some((o) => o !== undefined) || normalized.eases.some((e) => e !== undefined)\n\nconst animatePropertyKeyframes = (\n entry: ElementEntry,\n element: AnimatableElement,\n property: string,\n frames: AnimateKeyframes,\n read: StyleReader,\n options: AnimateOptions,\n reduced: boolean,\n channel: PropTarget = 'style',\n): AnimationHandle => {\n const name = bareName(property)\n const type = resolveValueType(name)\n const normalized = normalizeKeyframes(frames)\n if (normalized === null) return RESOLVED\n const last = normalized.waypoints[normalized.waypoints.length - 1] ?? ''\n\n // Every non-null entry - the explicit keyframe-0 lead AND every waypoint -\n // must parse to one common shape (same unit, same template).\n const rawEntries: AnimateValue[] =\n normalized.teleport !== undefined ? [normalized.teleport, ...normalized.waypoints] : [...normalized.waypoints]\n const parsedEntries: ParsedValue[] = []\n for (const raw of rawEntries) {\n const parsed = type.parse(raw)\n if (parsed === null) return snapLiteral(entry, element, property, last, channel)\n parsedEntries.push(parsed)\n }\n const first = parsedEntries[0]\n if (first === undefined) return RESOLVED\n const shape = first.shape\n if (parsedEntries.some((parsed) => parsed.shape !== shape)) {\n warnOnce(`keyframe-shape:${property}`, `\"${name}\" keyframes mix units/shapes; snapped to the last`)\n return writeLiteral(entry, element, property, last, channel)\n }\n\n const teleport = normalized.teleport !== undefined ? parsedEntries[0] : undefined\n const waypoints = normalized.teleport !== undefined ? parsedEntries.slice(1) : parsedEntries\n\n const buildChain = (group: ChannelGroup): AnimationHandle => {\n const ops: ChainOps = {\n teleport: (target) => group.set(target),\n spring: (target) => group.spring(target, springOptionsFrom(options)),\n tween: (target, ms, easing) => group.to(target, { duration: ms, easing, reducedMotion: 'allow' }),\n settle: (target) => group.spring(target, { reducedMotion: 'skip' }),\n }\n const chain = runKeyframeChain({ teleport, waypoints }, ops, {\n ...(options.duration !== undefined ? { duration: options.duration } : {}),\n easing: resolveEasing(options.easing ?? easeInOutCubic),\n reduced,\n ...segmentTimings(normalized, options.duration),\n })\n return startChain(entry, property, chain)\n }\n\n // Reuse a warm group of the matching shape; otherwise (re)create at a start.\n const existing = entry.groups.get(property)\n if (existing !== undefined && existing.group.shape === shape) {\n return buildChain(existing.group)\n }\n if (existing !== undefined) {\n existing.binding.dispose()\n existing.group.dispose()\n entry.groups.delete(property)\n }\n let start = teleport\n if (start === undefined) {\n const raw = read.get(name)\n const current = type.reconcile?.(raw, shape) ?? type.parse(raw)\n start = current !== null && current.shape === shape ? current : first\n }\n return installGroup(entry, element, property, type, start, buildChain, channel)\n}\n\n/**\n * Internal seam for @underlying/core/playback: the live WAAPI animation an\n * element's delegated tween rides, so playback can map pause/seek/timeScale/\n * reverse onto native compositor controls. Returns null on the JS path. NOT\n * exported from the package entry (index.ts).\n */\nexport function __getDelegated(element: AnimatableElement): DelegatedControls | null {\n const delegated = registry.get(element)?.delegated\n if (delegated === null || delegated === undefined) return null\n return { animation: delegated.animation, durationMs: delegated.durationMs }\n}\n\nconst ensureEntry = (element: AnimatableElement, scheduler: Scheduler | undefined): ElementEntry => {\n let entry = registry.get(element)\n if (entry === undefined) {\n entry = {\n values: {},\n disposeBinding: () => {},\n scheduler: scheduler ?? getSharedScheduler(),\n delegated: null,\n groups: new Map(),\n chains: new Map(),\n generation: 0,\n autoAlpha: false,\n }\n registry.set(element, entry)\n }\n return entry\n}\n\n/**\n * The numeric channels: delegate an eligible duration tween (scalar or uniform\n * multi-keyframe) to the compositor, else run on the rAF loop. Delegation needs\n * a duration, WAAPI with linear() support, no other numeric channel mid-physics\n * (a transform-ownership conflict), and a single frame count across channels.\n */\nconst handleNumeric = (\n entry: ElementEntry,\n element: AnimatableElement,\n scalars: Array<[Channel, number]>,\n keyframes: Array<[Channel, NumericKeyframes]>,\n options: AnimateOptions,\n behavior: ReducedMotionBehavior,\n reduced: boolean,\n): AnimationHandle[] => {\n // Any lifecycle callback opts out of WAAPI delegation onto the per-channel JS handles:\n // onUpdate ticks them each frame, onInterrupt reads a child's interrupt, and even\n // onStart/onComplete need it - the compositor reclaim cannot tell a settle from a\n // supersede, so onComplete would fire on both (see hasLifecycle).\n // autoAlpha opts out too: its visibility toggle rides the JS opacity write, which\n // the compositor path skips.\n if (!reduced && options.duration !== undefined && supportsWaapi(element) && !hasLifecycle(options) && !entry.autoAlpha) {\n const midPhysics = Object.values(entry.values).some((value) => value !== undefined && value.isAnimating())\n if (!midPhysics) {\n // Frame counts WITHOUT side effects: scalar = 2, keyframe = 1 + waypoints.\n const lengths = new Set()\n for (const _ of scalars) lengths.add(2)\n const norms: Array<[Channel, NumericNorm]> = []\n let expressive = false\n for (const [channel, frames] of keyframes) {\n const norm = normalizeKeyframes(frames)\n if (norm === null) continue\n // Per-segment positions/easings vary per channel; WAAPI shares one offset/\n // easing per keyframe row across all properties, so route the whole set to\n // the JS path (which applies them per channel) rather than delegate.\n if (hasKeyframeMeta(norm)) expressive = true\n norms.push([channel, norm])\n lengths.add(1 + norm.waypoints.length)\n }\n if (!expressive && lengths.size === 1 && scalars.length + norms.length > 0) {\n return [delegateMultiKeyframe(entry, element, scalars, norms, options.duration, resolveEasing(options.easing ?? easeInOutCubic))]\n }\n }\n }\n return animateNumericJs(entry, element, scalars, keyframes, options, behavior, reduced)\n}\n\n/**\n * The numeric path on the rAF loop: scalar channels spring or tween; keyframe\n * channels run a chained-spring / piecewise-tween sequence. Used whenever\n * delegation is ineligible (springs, reduced motion, mixed frame counts, a\n * channel mid-physics, or no WAAPI).\n */\nconst animateNumericJs = (\n entry: ElementEntry,\n element: AnimatableElement,\n scalars: Array<[Channel, number]>,\n keyframes: Array<[Channel, NumericKeyframes]>,\n options: AnimateOptions,\n behavior: ReducedMotionBehavior,\n reduced: boolean,\n): AnimationHandle[] => {\n let newChannel = false\n const prepared: Array<{ value: Animatable; channel: Channel; frames: NumericKeyframes }> = []\n const handles: AnimationHandle[] = []\n\n for (const [channel, target] of scalars) {\n const { value, created } = ensureChannel(entry, channel)\n newChannel ||= created\n handles.push(startNumericScalar(value, target, channel, options, behavior, reduced))\n }\n for (const [channel, frames] of keyframes) {\n const { value, created } = ensureChannel(entry, channel)\n newChannel ||= created\n prepared.push({ value, channel, frames })\n }\n\n // Rebind once before starting chains so a reduced-motion settle on a freshly\n // created channel rides the first flush.\n if (newChannel) rebind(entry, element)\n\n for (const { value, channel, frames } of prepared) {\n const normalized = normalizeKeyframes(frames)\n if (normalized === null) continue\n const ops: ChainOps = {\n teleport: (v) => value.set(v),\n spring: (v) => value.spring(v, springOptionsFrom(options)),\n tween: (v, ms, easing) => value.to(v, { duration: ms, easing, reducedMotion: 'allow' }),\n settle: (v) => value.spring(v, { reducedMotion: 'skip' }),\n }\n const chain = runKeyframeChain(normalized, ops, {\n ...(options.duration !== undefined ? { duration: options.duration } : {}),\n easing: resolveEasing(options.easing ?? easeInOutCubic),\n reduced,\n ...segmentTimings(normalized, options.duration),\n })\n handles.push(startChain(entry, channel, chain))\n }\n return handles\n}\n\n/**\n * Spring (default) or tween the style channels of ONE element with ALREADY\n * RESOLVED targets (no functions/relatives - the public animate() does the\n * per-element pre-pass). The five numeric channels keep their compositor fast\n * path; any other CSS property routes through the value-type registry. Repeated\n * calls retarget the same underlying values - never a jump.\n */\nfunction animateOne(element: AnimatableElement, targets: AnimateTargets, options: AnimateOptions): AnimationHandle {\n const entry = ensureEntry(element, options.scheduler)\n markIntent(entry) // a fresh intent supersedes any still-waiting staggered start on this element\n // Any new call on the element interrupts a delegated tween first.\n reclaim(entry)\n\n const behavior = options.reducedMotion ?? getReducedMotionBehavior()\n const reduced = behavior !== 'allow' && prefersReducedMotion()\n\n const numericScalars: Array<[Channel, number]> = []\n const numericKeyframes: Array<[Channel, NumericKeyframes]> = []\n const scalarProperties: Array<[string, AnimateValue]> = []\n const keyframeProperties: Array<[string, AnimateKeyframes]> = []\n const attrScalars: Array<[string, AnimateValue]> = []\n const attrKeyframes: Array<[string, AnimateKeyframes]> = []\n let autoAlpha = false\n let plainOpacity = false\n for (const key of Object.keys(targets)) {\n const value = (targets as Record)[key]\n if (value === undefined) continue\n // A new motion on a key takes over any keyframe chain still running there.\n interruptKey(entry, key)\n if (key === 'autoAlpha') {\n // An alias of the opacity channel that also toggles visibility (handled at the bind).\n autoAlpha = true\n interruptKey(entry, 'opacity')\n if (Array.isArray(value)) numericKeyframes.push(['opacity', value as NumericKeyframes])\n else numericScalars.push(['opacity', value as number])\n } else if (NUMERIC_CHANNELS.has(key)) {\n if (key === 'opacity') plainOpacity = true\n if (Array.isArray(value)) numericKeyframes.push([key as Channel, value as NumericKeyframes])\n else numericScalars.push([key as Channel, value as number])\n } else if (key === 'transform') {\n warnOnce('transform', 'animate x/y/scale/rotate instead of the transform shorthand')\n } else if (isAttrKey(key)) {\n if (Array.isArray(value)) attrKeyframes.push([key, value as AnimateKeyframes])\n else attrScalars.push([key, value as AnimateValue])\n } else if (Array.isArray(value)) {\n keyframeProperties.push([key, value as AnimateKeyframes])\n } else {\n scalarProperties.push([key, value as AnimateValue])\n }\n }\n // The visibility link follows the latest opacity intent: autoAlpha turns it on,\n // a plain opacity animation turns it off (and reveals) so it never leaks onto\n // an unrelated later opacity tween. Latched BEFORE the numeric path so the flag\n // is right when a fresh opacity channel binds (and gates WAAPI delegation).\n const opacityExisted = entry.values.opacity !== undefined\n const unlinkAutoAlpha = plainOpacity && !autoAlpha && entry.autoAlpha\n if (autoAlpha) entry.autoAlpha = true\n else if (plainOpacity) entry.autoAlpha = false\n\n const handles: AnimationHandle[] = []\n if (numericScalars.length > 0 || numericKeyframes.length > 0) {\n handles.push(...handleNumeric(entry, element, numericScalars, numericKeyframes, options, behavior, reduced))\n if (unlinkAutoAlpha) element.style.visibility = '' // drop the hidden state we may have set\n // Refresh the binding to apply/remove the visibility toggle - but only when\n // handleNumeric did not already rebind a freshly created opacity channel.\n if ((autoAlpha || unlinkAutoAlpha) && opacityExisted) rebind(entry, element)\n }\n if (scalarProperties.length > 0 || keyframeProperties.length > 0) {\n const read = readStyle(element)\n for (const [property, value] of scalarProperties) {\n handles.push(animateProperty(entry, element, property, value, read, options, behavior, reduced))\n }\n for (const [property, frames] of keyframeProperties) {\n handles.push(animatePropertyKeyframes(entry, element, property, frames, read, options, reduced))\n }\n }\n if (attrScalars.length > 0 || attrKeyframes.length > 0) {\n const read = readAttribute(element)\n for (const [property, value] of attrScalars) {\n handles.push(animateProperty(entry, element, property, value, read, options, behavior, reduced, 'attr'))\n }\n for (const [property, frames] of attrKeyframes) {\n handles.push(animatePropertyKeyframes(entry, element, property, frames, read, options, reduced, 'attr'))\n }\n }\n const base = aggregate(handles)\n if (!hasLifecycle(options)) return base\n const readValues = (): Record => {\n const out: Record = {}\n for (const [key, value] of Object.entries(entry.values)) if (value !== undefined) out[key] = value.get()\n return out\n }\n return withLifecycle(base, handles, options, readValues, entry.scheduler)\n}\n\n// A registry property's current value as ONE magnitude plus a re-emitter that\n// preserves its unit/template - only for single-channel value types (length,\n// number). Multi-channel (color, shadow) returns undefined; a relative there\n// degrades to the operand (resolveValue warns).\nconst readMagnitude = (element: AnimatableElement, entry: ElementEntry | undefined, key: string): Magnitude | undefined => {\n const warm = entry?.groups.get(key)\n if (warm !== undefined) {\n if (warm.group.channels.length !== 1) return undefined\n const channel = warm.group.channels[0]!\n const { type, shape } = warm.group\n return { value: channel.get(), reformat: (next) => type.format([next], shape) }\n }\n const name = bareName(key)\n const type = resolveValueType(name)\n // Attributes read via getAttribute; style properties via computed style.\n const raw = isAttrKey(key) ? (element.getAttribute(name) ?? '').trim() : readStyle(element).get(name)\n const parsed = type.parse(raw)\n if (parsed === null || parsed.channels.length !== 1) return undefined\n return { value: parsed.channels[0]!, reformat: (next) => type.format([next], parsed.shape) }\n}\n\n/** The per-element resolution context: live channel reads plus the single-magnitude registry reader. */\nconst resolveContextFor = (element: AnimatableElement, index: number, total: number): ResolveContext => {\n const entry = registry.get(element)\n return {\n index,\n element,\n total,\n readNumeric: (key) => {\n const channel = key === 'autoAlpha' ? 'opacity' : key\n if (!NUMERIC_CHANNELS.has(channel)) return undefined\n const value = entry?.values[channel as Channel]\n return value !== undefined ? value.get() : INITIAL[channel as Channel]\n },\n readMagnitude: (key) => readMagnitude(element, entry, key),\n }\n}\n\n/** Resolve every target value for one element (functions, relatives, keyframe chaining) to absolutes. */\nconst resolveTargetsFor = (\n element: AnimatableElement,\n targets: AnimateTargets,\n index: number,\n total: number,\n): ResolvedTargets => {\n const ctx = resolveContextFor(element, index, total)\n const out: Record = {}\n for (const key of Object.keys(targets)) {\n const raw = (targets as Record)[key]\n if (raw === undefined) continue\n out[key] = resolveValue(key, raw, ctx)\n }\n return out as ResolvedTargets\n}\n\n/** Resolve a from-state for one element to absolute teleport values (functions/relatives against the live value). */\nconst resolveFromFor = (element: AnimatableElement, from: FromTargets, index: number, total: number): ResolvedFrom =>\n // A from-state is scalar-only, so the resolved shape never carries keyframe arrays.\n resolveTargetsFor(element, from as AnimateTargets, index, total) as ResolvedFrom\n\n/**\n * Capture one element's NATURAL (current) value for each given key, synchronously\n * - the to-state `from()` animates back to. A numeric channel reads its live\n * animatable value (mid-flight if interrupted) or the CSS-neutral INITIAL when\n * untouched; any other property reads computed/inline style. Must run BEFORE the\n * from-set moves the element, so the captured value is the real resting state.\n */\nconst captureNatural = (element: AnimatableElement, keys: string[]): ResolvedTargets => {\n const entry = registry.get(element)\n const read = readStyle(element)\n const out: Record = {}\n for (const key of keys) {\n const channel = key === 'autoAlpha' ? 'opacity' : key\n if (NUMERIC_CHANNELS.has(channel)) {\n const value = entry?.values[channel as Channel]\n out[key] = value !== undefined ? value.get() : INITIAL[channel as Channel]\n } else if (isAttrKey(key)) {\n out[key] = element.getAttribute(bareName(key)) ?? ''\n } else {\n out[key] = read.get(key)\n }\n }\n return out as ResolvedTargets\n}\n\n/** True if any target value needs per-element resolution (a function, or a relative string incl. inside keyframes). */\nconst hasResolvable = (targets: AnimateTargets): boolean => {\n for (const key of Object.keys(targets)) {\n if (needsResolve((targets as Record)[key])) return true\n }\n return false\n}\n\n// Reclaim any delegated WAAPI tween FIRST (so a relative/function reads the true\n// mid-flight position, not a stale pre-tween value), then resolve this element's\n// targets and start them. Resolution happens at the element's START time.\nconst startResolved = (\n element: AnimatableElement,\n targets: AnimateTargets,\n index: number,\n total: number,\n options: AnimateOptions,\n): AnimationHandle => {\n const existing = registry.get(element)\n if (existing != null && existing.delegated !== null) reclaim(existing)\n const resolved = resolveTargetsFor(element, targets, index, total)\n return animateOne(element, resolved, options)\n}\n\n// Start one element's motion after a frame-clock delay, as ONE handle: finished\n// resolves when the post-delay inner settles or the wait is cancelled; stop cancels\n// a pending wait then freezes a started run; interrupt is forwarded so a superseded\n// or stopped deferred element reads as onInterrupt. The targets are resolved at\n// START time (after the wait), off the live value. A later animate() on this element\n// (a supersede during the wait) bumps the generation, so the stale start is dropped.\nconst deferredStart = (\n element: AnimatableElement,\n targets: AnimateTargets,\n options: AnimateOptions,\n index: number,\n total: number,\n delayMs: number,\n scheduler: Scheduler,\n): AnimationHandle => {\n const entry = ensureEntry(element, options.scheduler)\n const scheduledGen = markIntent(entry) // claim the element; a later intent bumps past this token\n let inner: AnimationHandle | null = null\n let cancelled = false\n let onInterrupt: ((h: AnimationHandle) => void) | null = null\n let resolveFinished = (): void => {}\n const finished = new Promise((resolve) => {\n resolveFinished = resolve\n })\n const cancelWait = waitFrames(delayMs, scheduler, () => {\n if (cancelled) return\n // Superseded during the wait: do NOT clobber the newer animation - report the\n // interrupt and settle, so the set reads onInterrupt instead of a false complete.\n if (entry.generation !== scheduledGen) {\n cancelled = true\n onInterrupt?.(handle)\n resolveFinished()\n return\n }\n inner = startResolved(element, targets, index, total, options)\n inner.eventCallback?.('interrupt', () => onInterrupt?.(handle))\n void inner.finished.then(resolveFinished)\n })\n const handle: AnimationHandle = {\n finished,\n then: thenFinished(finished),\n stop: () => {\n if (cancelled) return\n cancelled = true\n cancelWait()\n if (inner !== null) inner.stop()\n else onInterrupt?.(handle)\n resolveFinished()\n },\n eventCallback(event, fn) {\n if (event === 'interrupt') onInterrupt = fn ?? null\n return handle\n },\n }\n return handle\n}\n\n/** Strip the set-level options (delay, lifecycle) so each animateOne() sees only its own element's motion options. */\nconst perElementOptions = (options: AnimateOptions): AnimateOptions => {\n const out: AnimateOptions = { ...options }\n delete out.delay\n delete out.from\n delete out.onStart\n delete out.onUpdate\n delete out.onComplete\n delete out.onInterrupt\n delete out.scope\n return out\n}\n\n/**\n * Imperative escape hatch: spring (default) or tween style channels. The target\n * is one element, an array, a NodeList, or a CSS selector - one handle drives the\n * whole set. Each value may be a relative string (`'+=100'`, resolved against the\n * live value) or a per-target function `(index, element, count)`. `delay` staggers\n * the starts (a number, or a `staggerDelay()` wave). The five numeric channels\n * keep their compositor fast path; everything else routes through the value\n * registry. Repeated calls retarget the same underlying values - never a jump.\n *\n * Multi-target lifecycle is set-level: `onComplete` fires when the WHOLE set has\n * settled, `onInterrupt` when the first element is interrupted, `onUpdate` reports\n * the first element's channels.\n */\nexport function animate(target: AnimatableElement, targets: AnimateTargets, options?: AnimateOptions): AnimationHandle\nexport function animate(target: AnimationTarget, targets: AnimateTargets, options?: AnimateOptions): AnimationHandle\nexport function animate(target: AnimationTarget, targets: AnimateTargets, options: AnimateOptions = {}): AnimationHandle {\n // Fast path: one element, no delay, no function/relative - today's exact behavior\n // (lifecycle included), with no per-element pre-pass allocation. isHTMLElement is\n // SSR-safe (a bare `instanceof HTMLElement` throws server-side).\n if (isHTMLElement(target) && options.delay === undefined && options.from === undefined && !hasResolvable(targets)) {\n return animateOne(target, targets, options)\n }\n\n const elements = resolveTargets(target)\n if (elements.length === 0) return RESOLVED\n const total = elements.length\n const scheduler = options.scheduler ?? getSharedScheduler()\n const behavior = options.reducedMotion ?? getReducedMotionBehavior()\n const reduced = behavior !== 'allow' && prefersReducedMotion()\n const fromValues = options.from\n const delayOf: DelayFn | null =\n options.delay === undefined\n ? null\n : typeof options.delay === 'function'\n ? options.delay\n : (index) => (options.delay as number) * index\n const optionsForOne = perElementOptions(options)\n\n const children = elements.map((element, index) => {\n // Immediate-render the from-state synchronously, here in the call frame, for\n // EVERY element - so a staggered element is parked at its from-state and holds\n // it through its own delay before deferredStart runs. Skipped under reduced\n // motion, where the run settles straight to the to-state (no stranded from).\n if (fromValues !== undefined && !reduced) {\n // Pass the resolved scheduler so the from-set binds the element to the SAME\n // clock the animation runs on - else setStyle defaults to the shared\n // scheduler and the spring, on the injected one, never drives the channel.\n setStyle(element, resolveFromFor(element, fromValues, index, total), { scheduler })\n }\n const d = delayOf !== null ? delayOf(index, total) : 0\n if (d <= 0) return startResolved(element, targets, index, total, optionsForOne)\n return deferredStart(element, targets, optionsForOne, index, total, d, scheduler)\n })\n\n const base = aggregate(children)\n if (!hasLifecycle(options)) return base\n const first = registry.get(elements[0]!)\n const readValues = (): Record => {\n const out: Record = {}\n if (first !== undefined) {\n for (const [key, value] of Object.entries(first.values)) if (value !== undefined) out[key] = value.get()\n }\n return out\n }\n return withLifecycle(base, children, options, readValues, scheduler)\n}\n\n/**\n * Entrance: animate each target element FROM `fromValues` INTO its natural\n * (current) state, with no manual setStyle first. Each element's current value is\n * captured per key as its own to-state (so a set animates to PER-element naturals),\n * the from-state is set synchronously (no flash, held through any stagger delay),\n * then the element springs/tweens back. One aggregate handle drives the whole set.\n *\n * Same options as `animate()` - `delay`/`staggerDelay()`, lifecycle, spring config,\n * reduced motion (under which each element ends at its natural state, not the\n * from-state). If an element is mid-animation, the captured to is its live value,\n * so the hand-off has no jump. From-values take the same forms as a target\n * (absolute, relative `'+='`, per-target function), resolved against the live value.\n */\nexport function from(target: AnimationTarget, fromValues: FromTargets, options: AnimateOptions = {}): AnimationHandle {\n const elements = resolveTargets(target)\n if (elements.length === 0) return RESOLVED\n const keys = Object.keys(fromValues)\n // Capture the natural to-state NOW, per element, before animate() sets the\n // from-state. The to is handed to animate() as a per-target function that just\n // returns the pre-captured constant, so its start-time resolution is exact.\n const captured = elements.map((element) => captureNatural(element, keys))\n const to: AnimateTargets = {}\n for (const key of keys) {\n ;(to as Record>)[key] = (index) =>\n (captured[index] as Record)[key]!\n }\n // Pass the resolved element array (a stable snapshot) so animate() does not\n // re-query a selector and capture/animate a different set.\n return animate(elements, to, { ...options, from: fromValues })\n}\n\n/**\n * Animate each target element FROM an explicit `fromValues` TO an explicit\n * `toValues`. The from-state is set synchronously (no flash, held through any\n * stagger delay), then the element animates to the to-state. Thin sugar over\n * `animate(target, toValues, { ...options, from: fromValues })`: `toValues` keep\n * full target parity (keyframes, relatives, per-target functions); `fromValues`\n * are a single per-key state. Shares every `animate()` option (stagger, lifecycle,\n * spring config, reduced motion - under which it settles straight to `toValues`).\n */\nexport function fromTo(\n target: AnimationTarget,\n fromValues: FromTargets,\n toValues: AnimateTargets,\n options: AnimateOptions = {},\n): AnimationHandle {\n return animate(target, toValues, { ...options, from: fromValues })\n}\n\nexport interface SetStyleOptions {\n /**\n * Seed a velocity (channel-unit/s) along with the values - gesture handoffs.\n * Broadcast to every channel of every touched property; exact for\n * single-channel values, which is the gesture case.\n */\n velocity?: number\n scheduler?: Scheduler\n}\n\n/** Teleport a registry property, coherently with the channel state, writing synchronously. */\nconst setStyleProperty = (\n entry: ElementEntry,\n element: AnimatableElement,\n property: string,\n value: AnimateValue,\n velocity: number | undefined,\n target: PropTarget = 'style',\n): void => {\n const name = bareName(property)\n const type = resolveValueType(name)\n const existing = entry.groups.get(property)\n if (existing !== undefined) {\n // Fast path: the incoming value parses into the live shape - update channel\n // values against the compiled template, no rebuild (the pointermove case).\n const parsed = type.parse(value) ?? type.reconcile?.(String(value), existing.group.shape) ?? null\n if (parsed !== null && parsed.shape === existing.group.shape) {\n existing.group.set(parsed, velocity !== undefined ? { velocity } : {})\n existing.binding.flushNow()\n return\n }\n // Shape change: teleport by recreating at the new value.\n existing.binding.dispose()\n existing.group.dispose()\n entry.groups.delete(property)\n }\n const parsed = type.parse(value)\n if (parsed === null) {\n writeLiteral(entry, element, property, value, target)\n return\n }\n const group = channelGroup(type, parsed, { scheduler: entry.scheduler })\n if (velocity !== undefined) group.set(parsed, { velocity })\n const binding = bindProperty(element, name, group, { scheduler: entry.scheduler, target })\n entry.groups.set(property, { group, binding, target, name })\n binding.flushNow()\n}\n\n/**\n * Teleport: cancel animations on the touched properties only, write the style,\n * and keep the registry channel state coherent - unlike a raw element.style\n * write, which desyncs the cache. Seed a velocity for a following spring/decay\n * to inherit (the drag-release handoff). Registry properties write synchronously\n * (zero-latency scrubbing); numeric channels reflect on the next frame.\n */\nexport function setStyle(\n element: AnimatableElement,\n targets: Partial> & Partial>,\n options: SetStyleOptions = {},\n): void {\n const entry = ensureEntry(element, options.scheduler)\n // Reclaim only if a delegated tween owns a touched numeric channel.\n if (entry.delegated !== null) {\n const owned = Object.keys(targets).some(\n (key) => NUMERIC_CHANNELS.has(key) && entry.delegated?.channels.has(key as Channel) === true,\n )\n if (owned) reclaim(entry)\n }\n const velocity = options.velocity\n let newChannel = false\n let autoAlpha = false\n let plainOpacity = false\n for (const key of Object.keys(targets)) {\n const value = (targets as Record)[key]\n if (value === undefined) continue\n interruptKey(entry, key)\n if (key === 'autoAlpha') {\n autoAlpha = true\n interruptKey(entry, 'opacity')\n const { value: channel, created } = ensureChannel(entry, 'opacity')\n newChannel ||= created\n channel.set(value as number, velocity !== undefined ? { velocity } : undefined)\n } else if (NUMERIC_CHANNELS.has(key)) {\n if (key === 'opacity') plainOpacity = true\n const { value: channel, created } = ensureChannel(entry, key as Channel)\n newChannel ||= created\n channel.set(value as number, velocity !== undefined ? { velocity } : undefined)\n } else if (isAttrKey(key)) {\n setStyleProperty(entry, element, key, value, velocity, 'attr')\n } else if (key !== 'transform') {\n setStyleProperty(entry, element, key, value, velocity)\n }\n }\n const unlinkAutoAlpha = plainOpacity && !autoAlpha && entry.autoAlpha\n if (autoAlpha) entry.autoAlpha = true\n else if (plainOpacity) entry.autoAlpha = false\n if (unlinkAutoAlpha) element.style.visibility = ''\n if (newChannel || autoAlpha || unlinkAutoAlpha) rebind(entry, element)\n}\n\n/**\n * Forget the element: reclaim any delegated tween, dispose every channel, group,\n * and binding, remove the inline styles we wrote. The next animate() starts cold\n * (re-reads computed style). The sanctioned uncache hatch after an external\n * style write. Idempotent; an unknown element is a no-op.\n */\nexport function releaseStyle(element: AnimatableElement): void {\n const entry = registry.get(element)\n if (entry === undefined) return\n reclaim(entry)\n for (const interrupt of [...entry.chains.values()]) interrupt()\n entry.chains.clear()\n\n for (const value of Object.values(entry.values)) value?.dispose()\n entry.disposeBinding()\n if (Object.keys(entry.values).length > 0) {\n element.style.removeProperty('transform')\n element.style.removeProperty('opacity')\n if (entry.autoAlpha) element.style.removeProperty('visibility')\n }\n\n for (const { group, binding, target, name } of entry.groups.values()) {\n binding.dispose()\n group.dispose()\n if (target === 'attr') element.removeAttribute(name)\n else element.style.removeProperty(toKebab(name))\n }\n entry.groups.clear()\n registry.delete(element)\n}\n"],"names":["rafDriver","callback","id","MAX_FRAME_DELTA_MS","createScheduler","driver","updateSubscribers","renderSubscribers","cancelFrame","lastTimestampMs","running","inTick","count","stop","runPhase","subscribers","frame","tick","timestampMs","deltaMs","phase","shared","getSharedScheduler","linear","p","easeInCubic","easeOutCubic","easeInOutCubic","seen","warnOnce","key","message","registry","registerEasing","name","factory","SPEC","parseSpec","spec","match","variantRaw","_a","variant","params","part","resolveEasing","input","parsed","behavior","setReducedMotionBehavior","next","getReducedMotionBehavior","initialized","current","override","listeners","effective","notifyIfChanged","before","after","listener","init","query","event","prefersReducedMotion","setReducedMotionOverride","value","onReducedMotionChange","decaySimulation","options","timeConstant","restSpeed","min","max","bounceStiffness","bounceDamping","restDelta","tauS","edge","checkEdge","position","velocity","boundary","simulationMotion","simulation","state","timestepS","stepSimulation","springSimulation","target","stiffness","damping","mass","aim","tweenMotion","from","to","durationS","easing","elapsedS","positionAt","t","progress","hi","SIMULATION_TIMESTEP_S","lo","span","EVENT_TO_KEY","lifecycleRegistry","fns","scope","callbacks","fn","handle","receiver","thenFinished","finished","onfulfilled","onrejected","shouldSkip","MAX_SKIP_STEPS","animatable","initial","scheduler","changeListeners","restListeners","active","unsubscribeFrames","emitChange","freeze","reason","animation","onFrame","rested","alpha","previous","settleInstantly","motion","lifecycle","settled","i","startAnimation","resolveFinished","resolve","setOptions","springOptions","decayOptions","toOptions","simulateOptions","TRANSFORM_KEYS","ORIGIN_KEYS","formatOrigin","c","formatTransform","parts","bindStyle","element","bindings","autoAlpha","opacity","transformBindings","entry","originBindings","transformDirty","originDirty","opacityDirty","cancelFlush","unsubscribers","writeTransform","channels","writeOrigin","writeOpacity","flush","scheduleFlush","track","markDirty","markTransformDirty","markOriginDirty","unsubscribe","formatChannelNumber","meta","v","factor","toKebab","property","readAttribute","readStyle","computed","bindProperty","source","attr","dirty","lastWritten","write","aggregate","handles","onInterrupt","fired","fireInterrupt","child","channelGroup","type","shape","metas","generation","cachedFormat","notify","channel","scratch","channelOptions","base","index","opts","multiplier","nextShape","RGB_META","ALPHA_META","COLOR_METAS","COLOR_SHAPE","sqrtByte","squared","clamped","formatColor","r","g","b","a","hexComponent","hex","full","functionalArgs","s","open","close","component","raw","scale","rgbComponent","p0","p1","p2","p3","hslToRgb","h","l","hp","x","r1","g1","b1","m","hslComponent","sat","light","probe","NON_COLOR_KEYWORDS","namedComponent","parseColor","rgba","colorValueType","NUMBER_TOKEN_META","SEP","colorSlot","numberSlot","unit","SINGLE_NUMBER_SHAPE","tokenPattern","isColorText","text","decompose","tokens","literals","cursor","literal","color","num","tail","templateCache","compileShape","cached","template","channelMetas","token","groupByKind","numbers","colors","offset","complexValueType","decomposed","out","targetShape","trimmed","ni","ci","LENGTH_META","LENGTH_METAS","LENGTH_RE","ANGLE_TO_DEG","lengthValueType","fromShape","toShape","measure","fromAngle","toAngle","NUMBER_META","NUMBER_METAS","numberValueType","n","shorthands","seeded","LENGTH_PROPERTIES","COLOR_PROPERTIES","NUMBER_PROPERTIES","SHORTHAND_PROPERTIES","seed","registerValueType","properties","resolveValueType","existing","waitFrames","ms","onDone","elapsedMs","isStop","normalizeKeyframes","frames","values","offsets","eases","lastConcrete","head","tailValues","tailOffsets","tailEases","runKeyframeChain","normalized","ops","config","waypoints","cancelled","evenMs","waypoint","_b","fillOffsets","explicit","at","lastIdx","lastVal","j","prev","result","isHTMLElement","isAnimatableElement","resolveTargets","root","found","RELATIVE","parseRelative","applyRelative","cur","op","operand","w","waypointValue","needsResolve","resolveScalar","ctx","rel","mag","resolveKeyframes","numeric","resolveOne","resolveValue","BLOCK_AXIS","positive","createMeasure","read","cache","viewport","pick","doc","compute","parent","parentStyle","basis","_w","hasLifecycle","o","INITIAL","TRANSFORM_CHANNELS","NUMERIC_CHANNELS","ATTR_PREFIX","isAttrKey","bareName","markIntent","supportsWaapi","EASING_SAMPLES","toLinearEasing","stops","reclaim","delegated","segments","window","t1","t0","slope","segmentDurationS","rateSign","ensureChannel","rebind","delegateMultiKeyframe","scalars","keyframeNorms","durationMs","newChannel","created","norm","animatedKeys","carry","group","linearEasing","keyframes","transform","origin","tween","RESOLVED_PROMISE","RESOLVED","withLifecycle","children","readValues","onStart","onUpdate","onComplete","ended","unsubUpdate","finishUpdate","end","cb","springOptionsFrom","spring","interruptKey","interrupt","startChain","chain","startNumericScalar","reduced","startGroupMotion","installGroup","start","startMotion","binding","writeLiteral","snapLiteral","animateProperty","begin","parsedTarget","recon","_c","_d","segmentTimings","duration","e","arrivals","durations","arrival","hasKeyframeMeta","animatePropertyKeyframes","last","rawEntries","parsedEntries","first","teleport","buildChain","__getDelegated","ensureEntry","handleNumeric","lengths","_","norms","expressive","animateNumericJs","prepared","animateOne","targets","numericScalars","numericKeyframes","scalarProperties","keyframeProperties","attrScalars","attrKeyframes","plainOpacity","opacityExisted","unlinkAutoAlpha","readMagnitude","warm","resolveContextFor","total","resolveTargetsFor","resolveFromFor","captureNatural","keys","hasResolvable","startResolved","resolved","deferredStart","delayMs","scheduledGen","inner","cancelWait","perElementOptions","animate","elements","fromValues","delayOf","optionsForOne","setStyle","d","captured","fromTo","toValues","setStyleProperty","releaseStyle"],"mappings":"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"}