{"version":3,"file":"index.cjs","sources":["../../src/physics/sampled.ts","../../src/playback/time-scope.ts","../../src/playback/playable.ts","../../src/playback/waapi.ts","../../src/playback/animate.ts","../../src/playback/follow.ts","../../src/playback/sequence.ts"],"sourcesContent":["import type { Motion, SeekableMotion } from './motion'\nimport { SIMULATION_TIMESTEP_S, type SimulationState } from './simulation'\n\n/**\n * Upper bound on how many fixed steps a single cold seek re-walks before it\n * yields a sample, and the cap on the checkpoint stride. Bounds the synchronous\n * cost of reconstructing a state far from a checkpoint. Only the record/bake\n * paths consult it; the onFrame accumulator hot path is untouched.\n */\nexport const MAX_STEPS_PER_FRAME = 240\n\n// Backstop for a motion that never rests (an undamped spring): give up\n// discovering a duration rather than spin forever.\nconst MAX_RECORD_STEPS = 100_000\n\nconst H = SIMULATION_TIMESTEP_S\n\nexport interface Trajectory {\n /** Total elapsed at rest (seconds): the step where the simulation first rested, times H. */\n readonly durationS: number\n /**\n * Exposed (position, velocity) at absolute elapsed time (seconds), clamped to\n * [0, durationS]. Reproduces the live animatable's one-step-trailing\n * interpolation, so a baked clip scrubs to the exact pixels a live run showed.\n */\n sample(elapsedS: number): SimulationState\n}\n\nexport interface RecordOptions {\n /** Checkpoint stride in steps. Default 64, clamped to MAX_STEPS_PER_FRAME. Bounds cold-seek re-walk for stateless motions. */\n checkpointStride?: number\n /**\n * The motion carries latched state (a decay edge, a tween clock) that a\n * mid-trajectory state cannot resume from: rebuild makeMotion() and re-walk\n * from the start on every cold seek so that state re-forms identically.\n */\n stateful?: boolean\n /** Steps before record gives up (the motion never rests). Default 100_000. */\n maxSteps?: number\n}\n\n/**\n * Run the 1/120 s simulation once to discover its duration and a sparse\n * checkpoint table. Pure: no scheduler, no time source. Returns null when the\n * motion never rests within maxSteps (the bake-failure path).\n */\nexport function record(\n makeMotion: () => Motion,\n initial: SimulationState,\n options: RecordOptions = {},\n): Trajectory | null {\n const stride = Math.max(1, Math.min(options.checkpointStride ?? 64, MAX_STEPS_PER_FRAME))\n const stateful = options.stateful ?? false\n const maxSteps = options.maxSteps ?? MAX_RECORD_STEPS\n\n // A single reusable motion for the forward walk and (when stateless) for\n // checkpoint-seeded reconstruction. Stateful motions get a fresh one per seek.\n const probe = makeMotion()\n const checkpoints: SimulationState[] = [initial] // checkpoints[i] = state after i*stride steps\n let state = initial\n let restStep = -1\n let restedPosition = initial.position\n\n for (let step = 1; step <= maxSteps; step++) {\n state = probe.step(state, H)\n if (step % stride === 0) checkpoints.push(state)\n const rested = probe.rest(state)\n if (rested !== null) {\n restStep = step\n restedPosition = rested\n break\n }\n }\n if (restStep === -1) return null\n\n const durationS = restStep * H\n const restState: SimulationState = { position: restedPosition, velocity: 0 }\n\n // Exact (position, velocity) after `targetStep` fixed steps. Stateless motions\n // resume from the nearest checkpoint; stateful ones rebuild and re-walk from\n // the start so the latched edge re-latches at the same step.\n const stateAfter = (targetStep: number): SimulationState => {\n if (targetStep <= 0) return initial\n if (targetStep >= restStep) return restState\n if (stateful) {\n const motion = makeMotion()\n let s = initial\n for (let i = 0; i < targetStep; i++) s = motion.step(s, H)\n return s\n }\n const base = Math.min(Math.floor(targetStep / stride), checkpoints.length - 1)\n let s = checkpoints[base] ?? initial\n for (let i = base * stride; i < targetStep; i++) s = probe.step(s, H)\n return s\n }\n\n return {\n durationS,\n sample(elapsedS) {\n if (elapsedS <= 0) return initial\n if (elapsedS >= durationS) return restState\n const q = elapsedS / H\n const n = Math.floor(q)\n const alpha = q - n\n // The exposed value trails one step (the animatable interpolates between\n // the two latest simulated steps), so the window is [S_{n-1}, S_n].\n const lo = stateAfter(n - 1)\n const hi = stateAfter(n)\n return {\n position: lo.position + (hi.position - lo.position) * alpha,\n velocity: lo.velocity + (hi.velocity - lo.velocity) * alpha,\n }\n },\n }\n}\n\n/**\n * A SeekableMotion backed by a recorded trajectory. Owns its elapsed clock so\n * the playback layer can jump the playhead; step() advances it, rest() reports\n * the settle once the duration is reached.\n */\nexport function sampledMotion(trajectory: Trajectory): SeekableMotion {\n let elapsedS = 0\n return {\n step(_state, timestepS) {\n elapsedS += timestepS\n return trajectory.sample(elapsedS)\n },\n rest: () => (elapsedS >= trajectory.durationS ? trajectory.sample(trajectory.durationS).position : null),\n durationS: trajectory.durationS,\n seek(target): SimulationState {\n elapsedS = Math.min(Math.max(target, 0), trajectory.durationS)\n return trajectory.sample(elapsedS)\n },\n }\n}\n","import {\n MAX_FRAME_DELTA_MS,\n type FrameCallback,\n type FrameInfo,\n type FramePhase,\n type Scheduler,\n} from '../scheduler/scheduler'\nimport { getSharedScheduler } from '../scheduler/shared'\n\n/**\n * A Scheduler that wraps a parent and scales the time its members see. This is\n * the pause / timeScale mechanism: the integrator behind every member still\n * only ever steps by SIMULATION_TIMESTEP_S, so timeScale changes how many\n * steps a wall-frame consumes, never the step size. The 60/120/144 Hz\n * convergence the physics asserts is therefore structurally untouched.\n *\n * The scope subscribes the parent once per phase and fans a single shared\n * FrameInfo to its members (no per-member parent subscription). On pause() it\n * drops the parent subscription so the rAF loop sleeps.\n */\nexport interface TimeScope extends Scheduler {\n /** Freeze: drop the parent subscription so the loop can sleep. Resumable. */\n pause(): void\n /** Resume real time, re-subscribing the parent. No-op if not paused. */\n resume(): void\n isPaused(): boolean\n /** Time dilation. 0 stops integration but stays subscribed (unlike pause). */\n setTimeScale(rate: number): void\n getTimeScale(): number\n /** Drop the parent subscription and forget all members. */\n dispose(): void\n}\n\nexport interface TimeScopeOptions {\n /** Parent scheduler; defaults to the shared rAF loop. */\n scheduler?: Scheduler\n /** Initial time scale. Default 1. */\n timeScale?: number\n /** Start paused (no parent subscription). Default false. */\n paused?: boolean\n}\n\nexport function timeScope(options: TimeScopeOptions = {}): TimeScope {\n const parent = options.scheduler ?? getSharedScheduler()\n let timeScale = options.timeScale ?? 1\n let paused = options.paused ?? false\n\n const members: Record> = { update: new Set(), render: new Set() }\n const detach: Record void) | null> = { update: null, render: null }\n\n // Scale the delta, then re-clamp: the real scheduler clamps BEFORE us, so a\n // scale-up could otherwise push past the freeze guard and teleport.\n const fan = (phase: FramePhase) => (frame: FrameInfo) => {\n const scaled = Math.min(frame.deltaMs * timeScale, MAX_FRAME_DELTA_MS)\n const shared: FrameInfo = { deltaMs: scaled, timestampMs: frame.timestampMs }\n const set = members[phase]\n for (const callback of [...set]) if (set.has(callback)) callback(shared)\n }\n\n const attach = (phase: FramePhase) => {\n if (!paused && detach[phase] === null && members[phase].size > 0) {\n detach[phase] = parent.subscribe(fan(phase), phase)\n }\n }\n const detachPhase = (phase: FramePhase) => {\n detach[phase]?.()\n detach[phase] = null\n }\n const detachAll = () => {\n detachPhase('update')\n detachPhase('render')\n }\n const attachAll = () => {\n attach('update')\n attach('render')\n }\n\n return {\n subscribe(callback, phase = 'update') {\n members[phase].add(callback)\n attach(phase)\n return () => {\n members[phase].delete(callback)\n if (members[phase].size === 0) detachPhase(phase)\n }\n },\n isRunning: () => detach.update !== null || detach.render !== null,\n pause() {\n if (paused) return\n paused = true\n detachAll()\n },\n resume() {\n if (!paused) return\n paused = false\n attachAll()\n },\n isPaused: () => paused,\n setTimeScale(rate) {\n timeScale = rate\n },\n getTimeScale: () => timeScale,\n dispose() {\n detachAll()\n members.update.clear()\n members.render.clear()\n },\n }\n}\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, type SeekableMotion } from '../physics/motion'\nimport { record, sampledMotion } from '../physics/sampled'\nimport { SIMULATION_TIMESTEP_S, type SimulationState } from '../physics/simulation'\nimport { springSimulation, type SpringOptions } from '../physics/spring'\nimport { tweenMotion, type ToOptions } from '../physics/tween'\nimport type { Scheduler } from '../scheduler/scheduler'\nimport { getSharedScheduler } from '../scheduler/shared'\nimport type { Animatable } from '../value/animatable'\nimport { lifecycleRegistry, type LifecycleEvent, type LifecycleRegistry } from '../value/lifecycle'\nimport { thenFinished } from '../value/thenable'\nimport { warnOnce } from '../value/warn'\nimport type { MotionKind, PlaybackHandle, PlaybackOptions } from './handle'\nimport { timeScope } from './time-scope'\n\n/** Emit a lifecycle event for the run (the handle is resolved lazily, after buildHandle). */\ntype Fire = (event: LifecycleEvent, value?: number) => void\nconst NO_FIRE: Fire = () => {}\n\nexport interface PlayableOptions {\n /** The scheduler the value runs on; pass the same one the value was created with. Defaults to the shared loop. */\n scheduler?: Scheduler\n}\n\nexport interface PlaybackValue {\n /** Live spring chase (physics, not seekable until bake()). */\n spring(target: number, options?: SpringOptions & PlaybackOptions): PlaybackHandle\n /** Duration tween (timeline, seekable from birth). */\n to(target: number, options?: ToOptions & PlaybackOptions): PlaybackHandle\n /** Inertial glide (physics, not seekable until bake()). */\n decay(options?: DecayOptions & PlaybackOptions): PlaybackHandle\n}\n\nconst H = SIMULATION_TIMESTEP_S\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\nconst clamp = (x: number, lo: number, hi: number): number => Math.min(Math.max(x, lo), hi)\n\n/** Conditionally-spread the repeat/delay options (exactOptionalPropertyTypes: never assign undefined). */\nfunction repeatConfig(o: PlaybackOptions): Pick {\n const c: Pick = {}\n if (o.delay !== undefined) c.delay = o.delay\n if (o.repeat !== undefined) c.repeat = o.repeat\n if (o.repeatDelay !== undefined) c.repeatDelay = o.repeatDelay\n if (o.yoyo !== undefined) c.yoyo = o.yoyo\n return c\n}\n\n/** Under reduced motion the loop collapses; the final waypoint depends on yoyo parity. */\nfunction reducedFinal(from: number, to: number, o: PlaybackOptions): number {\n const repeat = o.repeat ?? 0\n if (o.yoyo !== true || !Number.isFinite(repeat)) return to\n return (1 + repeat) % 2 === 1 ? to : from\n}\n\n// Backstop for a live spring that never rests when reduced motion fast-forwards it.\nconst MAX_SKIP_STEPS = 100_000\n\n/** Run a motion to rest synchronously; returns the settled state. */\nfunction settleInstantly(motion: Motion, from: SimulationState): SimulationState {\n let current = from\n let settled: number | null = null\n for (let i = 0; i < MAX_SKIP_STEPS && settled === null; i++) {\n current = motion.step(current, H)\n settled = motion.rest(current)\n }\n return { position: settled ?? current.position, velocity: 0 }\n}\n\n/** Controls shared by every PlaybackHandle, before the public router wraps them. */\ninterface RunControls {\n readonly kind: MotionKind\n isSeekable(): boolean\n finished: Promise\n pause(): void\n resume(): void\n isPaused(): boolean\n setTimeScale(rate: number): void\n getTimeScale(): number\n stop(): void\n reverse(): void\n // seekable only:\n seekMs(ms: number): void\n progressGet(): number\n timeMs(): number\n totalMs(): number\n durationMs(): number | undefined\n // playhead queries (both kinds):\n isActive(): boolean\n iteration(): number\n totalProgress(): number\n restart(): void\n startTimeMs(): number\n endTimeMs(): number | undefined\n // live only:\n setTarget(value: number, velocity?: number): void\n bake(maxDurationMs?: number): boolean\n}\n\ninterface StartConfig {\n value: Animatable\n scheduler: Scheduler\n kind: MotionKind\n state: SimulationState\n paused: boolean\n timeScale: number\n /** Build the live motion for the current target (springs/decay). Absent for a seekable tween. */\n makeLive?: () => Motion\n /** Update the live target (springs) so a rebuild/reverse/bake re-aims correctly. */\n retargetLive?: (target: number) => void\n /** The launch position (springs), for reverse and progress(). */\n launchPos?: number\n /** The initial target (springs), so live progress() spans launch -> target. */\n initialTarget?: number\n /** Whether makeLive() carries latched state (decay): bake must re-walk from the start. */\n stateful?: boolean\n /** The seekable motion (tween/baked). Present iff seekable from birth. */\n seekMotion?: SeekableMotion\n /** ms before the first iteration starts. */\n delay?: number\n /** Iterations beyond the first; Infinity loops forever. */\n repeat?: number\n /** ms of dead time between iterations. */\n repeatDelay?: number\n /** Ping-pong the iterations. */\n yoyo?: boolean\n /** Emit lifecycle events (start/update/repeat/complete/interrupt/reverseComplete). */\n fire?: Fire\n}\n\nfunction startRun(config: StartConfig): RunControls {\n const { value, kind } = config\n const scope = timeScope({ scheduler: config.scheduler, timeScale: config.timeScale, paused: config.paused })\n\n // Mode: a live spring/decay drains fixed steps; a seekable tween/table walks a playhead.\n let seekMotion: SeekableMotion | null = config.seekMotion ?? null\n let liveMotion: Motion | null = config.makeLive ? config.makeLive() : null\n\n // Live accumulator state.\n let prev = config.state\n let curr = config.state\n let accumulatorS = 0\n let liveElapsedS = 0\n const launchPos = config.launchPos ?? config.state.position\n const originalTarget = config.initialTarget ?? launchPos\n let currentTarget = originalTarget\n\n // Seekable playhead state.\n let elapsedS = 0\n let direction: 1 | -1 = 1\n let durationS = seekMotion?.durationS ?? 0\n\n // Repeat / delay / yoyo state. Decay has no symmetric start, so it never repeats.\n const canRepeat = seekMotion !== null || config.initialTarget !== undefined\n let iterationsLeft = canRepeat ? (config.repeat ?? 0) : 0\n const repeatDelayS = (config.repeatDelay ?? 0) / 1000\n const yoyo = config.yoyo ?? false\n let holdS = (config.delay ?? 0) / 1000 // initial delay, then reused between iterations\n let forwardLeg = true // live yoyo parity: launch -> target (true) vs target -> launch\n let totalElapsedS = 0\n let iterationIndex = 0 // 0-based, advances at each iteration boundary (handles infinite repeat)\n\n // Total run duration (initial delay + every iteration + repeat delays), for\n // totalProgress()/endTime(). undefined while an un-baked spring has no duration.\n const delayS0 = (config.delay ?? 0) / 1000\n const repeatCount = (): number => (canRepeat ? (config.repeat ?? 0) : 0)\n const activeDurationS = (): number | undefined => {\n if (seekMotion === null) return undefined\n const r = repeatCount()\n return Number.isFinite(r) ? (1 + r) * durationS + r * repeatDelayS : Infinity\n }\n\n let settled = false\n let resolveFinished = () => {}\n const finished = new Promise((resolve) => {\n resolveFinished = resolve\n })\n\n let unsubscribe: (() => void) | null = null\n const fire = config.fire ?? NO_FIRE\n let started = false\n let reversing = false // a live spring sent back to its launch by reverse()\n let seekReversed = false // a user reverse() on a seekable run - distinct from a yoyo backward leg\n let lastUpdateValue = value.get() // the launch value, so the first no-op frame is not a spurious update\n // Fire 'update' only on an actual value change, matching value.drive()/on('change').\n const fireUpdate = (): void => {\n const v = value.get()\n if (v !== lastUpdateValue) {\n lastUpdateValue = v\n fire('update', v)\n }\n }\n\n const finish = (reason: 'complete' | 'interrupt' | 'reverseComplete') => {\n if (settled) return\n settled = true\n unsubscribe?.()\n unsubscribe = null\n scope.dispose()\n resolveFinished()\n fire(reason)\n }\n\n // End of one iteration. Either finish, or roll into the next one after an\n // optional repeatDelay. Springs reset to rest at a boundary (a stable\n // discontinuous loop); tweens replay the curve (mirrored for yoyo).\n const onIterationEnd = (boundaryPos: number) => {\n value.drive({ position: boundaryPos, velocity: 0 })\n fireUpdate() // report the exact boundary/settle value before the terminal event\n if (iterationsLeft <= 0) {\n // reverseComplete only when the USER reversed - never on a natural yoyo backward leg.\n const reversed = seekMotion !== null ? seekReversed : reversing\n finish(reversed ? 'reverseComplete' : 'complete')\n return\n }\n iterationsLeft -= 1\n iterationIndex += 1\n fire('repeat', boundaryPos)\n holdS = repeatDelayS\n if (seekMotion !== null) {\n if (yoyo) {\n direction = direction === 1 ? -1 : 1 // play back from this boundary\n } else {\n elapsedS = 0\n direction = 1 // replay from the start\n }\n return\n }\n forwardLeg = yoyo ? !forwardLeg : true\n const start = forwardLeg ? launchPos : originalTarget\n const aim = forwardLeg ? originalTarget : launchPos\n config.retargetLive?.(aim)\n currentTarget = aim\n const seed: SimulationState = { position: start, velocity: 0 }\n prev = seed\n curr = seed\n accumulatorS = 0\n liveElapsedS = 0\n liveMotion = config.makeLive ? config.makeLive() : liveMotion\n value.drive(seed)\n }\n\n const driveLive = (deltaS: number) => {\n if (liveMotion === null) return\n accumulatorS += deltaS\n while (accumulatorS >= H) {\n accumulatorS -= H\n prev = curr\n curr = liveMotion.step(curr, H)\n liveElapsedS += H\n const rested = liveMotion.rest(curr)\n if (rested !== null) {\n onIterationEnd(rested)\n return\n }\n }\n const alpha = accumulatorS / H\n value.drive({\n position: prev.position + (curr.position - prev.position) * alpha,\n velocity: prev.velocity + (curr.velocity - prev.velocity) * alpha,\n })\n fireUpdate()\n }\n\n const driveSeek = (deltaS: number) => {\n if (seekMotion === null) return\n elapsedS += deltaS * direction\n if (direction < 0 && elapsedS <= 0) {\n elapsedS = 0\n onIterationEnd(seekMotion.seek(0).position)\n return\n }\n if (direction > 0 && elapsedS >= durationS) {\n elapsedS = durationS\n onIterationEnd(seekMotion.seek(durationS).position)\n return\n }\n const s = seekMotion.seek(elapsedS)\n value.drive(direction < 0 ? { position: s.position, velocity: -s.velocity } : s)\n fireUpdate()\n }\n\n // A live handle may switch to seekable on bake(), so the branch is chosen per\n // frame rather than captured once. A delay / repeatDelay holds the clock first.\n const frame = ({ deltaMs }: { deltaMs: number }) => {\n const deltaS = deltaMs / 1000\n totalElapsedS += deltaS\n if (holdS > 0) {\n holdS -= deltaS\n return\n }\n if (!started) {\n started = true\n fire('start', value.get())\n }\n if (seekMotion !== null) driveSeek(deltaS)\n else driveLive(deltaS)\n }\n\n const ensureSubscribed = () => {\n if (unsubscribe === null && !settled) unsubscribe = scope.subscribe(frame)\n }\n ensureSubscribed()\n\n const liveProgress = (): number => {\n const span = Math.abs(currentTarget - launchPos)\n if (span === 0) return settled ? 1 : 0\n return clamp(Math.abs(value.get() - launchPos) / span, 0, 1)\n }\n\n // Re-aim a live spring. isReverse marks a reverse() so the eventual settle reports\n // onReverseComplete; a forward setTarget() clears it.\n const retargetLiveTo = (target: number, velocity: number | undefined, isReverse: boolean): void => {\n if (seekMotion !== null) return\n reversing = isReverse\n currentTarget = target\n config.retargetLive?.(target)\n liveMotion = config.makeLive ? config.makeLive() : liveMotion\n const seed: SimulationState = { position: value.get(), velocity: velocity ?? value.velocity() }\n prev = seed\n curr = seed\n accumulatorS = 0\n value.drive(seed)\n ensureSubscribed()\n }\n\n return {\n kind,\n isSeekable: () => seekMotion !== null,\n finished,\n pause: () => scope.pause(),\n resume: () => scope.resume(),\n isPaused: () => scope.isPaused(),\n setTimeScale: (rate) => scope.setTimeScale(rate),\n getTimeScale: () => scope.getTimeScale(),\n stop: () => finish('interrupt'),\n reverse() {\n if (seekMotion !== null) {\n direction = direction === 1 ? -1 : 1\n seekReversed = direction < 0 // a deliberate reverse; terminating now is onReverseComplete\n ensureSubscribed()\n return\n }\n // Live spring: retarget to the launch position, conserving current velocity.\n retargetLiveTo(launchPos, value.velocity(), true)\n },\n seekMs(ms) {\n if (seekMotion === null) return\n elapsedS = clamp(ms / 1000, 0, durationS)\n const s = seekMotion.seek(elapsedS)\n value.drive(direction < 0 ? { position: s.position, velocity: -s.velocity } : s)\n },\n progressGet() {\n if (settled) return 1\n if (seekMotion !== null) return durationS <= 0 ? 1 : clamp(elapsedS / durationS, 0, 1)\n return liveProgress()\n },\n timeMs: () => (seekMotion !== null ? elapsedS : liveElapsedS) * 1000,\n totalMs: () => totalElapsedS * 1000,\n durationMs: () => (seekMotion !== null ? durationS * 1000 : undefined),\n isActive: () => !settled && !scope.isPaused(),\n iteration: () => iterationIndex,\n totalProgress() {\n if (settled) return 1\n const active = activeDurationS()\n const total = active === undefined ? undefined : delayS0 + active\n // Unknown (un-baked spring) or infinite total: fall back to this iteration's progress.\n if (total === undefined || !Number.isFinite(total) || total <= 0) {\n if (seekMotion !== null) return durationS <= 0 ? 1 : clamp(elapsedS / durationS, 0, 1)\n return liveProgress()\n }\n return clamp(totalElapsedS / total, 0, 1)\n },\n startTimeMs: () => delayS0 * 1000,\n endTimeMs() {\n const active = activeDurationS()\n return active === undefined || !Number.isFinite(active) ? undefined : (delayS0 + active) * 1000\n },\n restart() {\n if (settled) {\n warnOnce('playback:restart-settled', 'restart() needs an active handle; a finished run cannot replay - start a new one')\n return\n }\n iterationsLeft = repeatCount()\n iterationIndex = 0\n // Seed the elapsed clock with the skipped initial delay so totalProgress()'s\n // (delayS0 + active) denominator still reaches 1 - restart skips the delay.\n totalElapsedS = delayS0\n holdS = 0 // replay immediately, skipping the initial delay\n seekReversed = false\n reversing = false\n started = false // re-arm so the replay fires 'start' again\n if (seekMotion !== null) {\n elapsedS = 0\n direction = 1\n value.drive(seekMotion.seek(0))\n ensureSubscribed()\n } else {\n forwardLeg = true\n value.drive({ position: launchPos, velocity: 0 })\n retargetLiveTo(originalTarget, 0, false) // re-aims + re-subscribes\n }\n lastUpdateValue = value.get() // seed after driving so the first frame isn't a spurious update\n scope.resume()\n },\n setTarget(target, velocity) {\n retargetLiveTo(target, velocity, false)\n },\n bake(maxDurationMs) {\n if (seekMotion !== null) return true // a tween or already-baked handle: idempotent\n if (config.makeLive === undefined) return false\n const make = config.makeLive\n const maxSteps = maxDurationMs === undefined ? undefined : Math.ceil(maxDurationMs / 1000 / H)\n const seed: SimulationState = { position: value.get(), velocity: value.velocity() }\n const recordOptions: { stateful?: boolean; maxSteps?: number } = {}\n if (config.stateful !== undefined) recordOptions.stateful = config.stateful\n if (maxSteps !== undefined) recordOptions.maxSteps = maxSteps\n const trajectory = record(make, seed, recordOptions)\n if (trajectory === null) {\n warnOnce('playback:bake-failed', 'bake() found no rest within the limit; the handle stays live')\n return false\n }\n seekMotion = sampledMotion(trajectory)\n durationS = trajectory.durationS\n elapsedS = 0\n direction = 1\n liveMotion = null\n ensureSubscribed()\n return true\n },\n }\n}\n\n/** A settled, inert handle returned under reduced motion (the motion fast-forwarded). */\nfunction inertControls(value: Animatable, kind: MotionKind, settleTo: number): RunControls {\n value.drive({ position: settleTo, velocity: 0 })\n return {\n kind,\n isSeekable: () => true,\n finished: Promise.resolve(),\n pause: () => {},\n resume: () => {},\n isPaused: () => false,\n setTimeScale: () => {},\n getTimeScale: () => 1,\n stop: () => {},\n reverse: () => {},\n seekMs: () => {},\n progressGet: () => 1,\n timeMs: () => 0,\n totalMs: () => 0,\n durationMs: () => 0,\n isActive: () => false,\n iteration: () => 0,\n totalProgress: () => 1,\n restart: () => {},\n startTimeMs: () => 0,\n endTimeMs: () => 0,\n setTarget: (target) => value.drive({ position: target, velocity: 0 }),\n bake: () => true,\n }\n}\n\n/** Wrap RunControls in the public PlaybackHandle, applying the kind-invalid warn-and-no-op policy. */\nfunction buildHandle(controls: RunControls, registry: LifecycleRegistry): PlaybackHandle {\n const handle: PlaybackHandle = {\n kind: controls.kind,\n eventCallback(event, fn) {\n registry.set(event, fn)\n return handle\n },\n get seekable() {\n return controls.isSeekable()\n },\n finished: controls.finished,\n then: thenFinished(controls.finished),\n stop: () => controls.stop(),\n pause() {\n controls.pause()\n return this\n },\n play() {\n controls.resume()\n return this\n },\n resume() {\n controls.resume()\n return this\n },\n isPaused: () => controls.isPaused(),\n timeScale(rate?: number): number | PlaybackHandle {\n if (rate === undefined) return controls.getTimeScale()\n controls.setTimeScale(rate)\n return handle\n },\n reverse() {\n controls.reverse()\n return this\n },\n seek(timeMs: number) {\n if (!controls.isSeekable()) {\n warnOnce('playback:seek-live', 'seek()/progress() need a seekable handle; bake() a spring first')\n return this\n }\n controls.seekMs(timeMs)\n return this\n },\n progress(p?: number): number | PlaybackHandle {\n if (p === undefined) return controls.progressGet()\n if (!controls.isSeekable()) {\n warnOnce('playback:seek-live', 'seek()/progress() need a seekable handle; bake() a spring first')\n return handle\n }\n const duration = controls.durationMs() ?? 0\n controls.seekMs(clamp(p, 0, 1) * duration)\n return handle\n },\n time: () => controls.timeMs(),\n totalTime: () => controls.totalMs(),\n duration: () => controls.durationMs(),\n isActive: () => controls.isActive(),\n iteration: () => controls.iteration(),\n totalProgress: () => controls.totalProgress(),\n startTime: () => controls.startTimeMs(),\n endTime: () => controls.endTimeMs(),\n restart() {\n controls.restart()\n return this\n },\n bake: (options) => controls.bake(options?.maxDurationMs),\n setTarget(value: number, options?: { velocity?: number }) {\n if (controls.isSeekable()) {\n warnOnce('playback:settarget-seekable', 'setTarget() re-aims a live spring; a seekable handle uses seek()')\n return this\n }\n controls.setTarget(value, options?.velocity)\n return this\n },\n } as PlaybackHandle\n return handle\n}\n\nexport function playable(value: Animatable, options: PlayableOptions = {}): PlaybackValue {\n const scheduler = options.scheduler ?? getSharedScheduler()\n\n return {\n spring(target, springOptions = {}) {\n const registry = lifecycleRegistry()\n registry.seed(springOptions)\n let handle: PlaybackHandle\n const fire: Fire = (event, value) => registry.fire(event, handle, value)\n const state: SimulationState = {\n position: value.get(),\n velocity: springOptions.velocity ?? value.velocity(),\n }\n if (shouldSkip(springOptions.reducedMotion)) {\n handle = buildHandle(\n inertControls(value, 'physics', reducedFinal(state.position, target, springOptions)),\n registry,\n )\n fire('start', value.get())\n fire('complete', value.get())\n return handle\n }\n let aim = target\n handle = buildHandle(\n startRun({\n value,\n scheduler,\n kind: 'physics',\n state,\n paused: springOptions.paused ?? false,\n timeScale: springOptions.timeScale ?? 1,\n makeLive: () => simulationMotion(springSimulation(aim, springOptions)),\n retargetLive: (next) => {\n aim = next\n },\n launchPos: state.position,\n initialTarget: target,\n stateful: false,\n fire,\n ...repeatConfig(springOptions),\n }),\n registry,\n )\n return handle\n },\n decay(decayOptions = {}) {\n const registry = lifecycleRegistry()\n registry.seed(decayOptions)\n let handle: PlaybackHandle\n const fire: Fire = (event, value) => registry.fire(event, handle, value)\n const state: SimulationState = {\n position: value.get(),\n velocity: decayOptions.velocity ?? value.velocity(),\n }\n if (shouldSkip(decayOptions.reducedMotion)) {\n const final = settleInstantly(simulationMotion(decaySimulation(decayOptions)), state)\n handle = buildHandle(inertControls(value, 'physics', final.position), registry)\n fire('start', value.get())\n fire('complete', value.get())\n return handle\n }\n handle = buildHandle(\n startRun({\n value,\n scheduler,\n kind: 'physics',\n state,\n paused: decayOptions.paused ?? false,\n timeScale: decayOptions.timeScale ?? 1,\n makeLive: () => simulationMotion(decaySimulation(decayOptions)),\n launchPos: state.position,\n stateful: true,\n fire,\n }),\n registry,\n )\n return handle\n },\n to(target, toOptions = {}) {\n const registry = lifecycleRegistry()\n registry.seed(toOptions)\n let handle: PlaybackHandle\n const fire: Fire = (event, value) => registry.fire(event, handle, value)\n const from = value.get()\n const motion = tweenMotion(from, target, toOptions)\n if (shouldSkip(toOptions.reducedMotion)) {\n handle = buildHandle(inertControls(value, 'timeline', reducedFinal(from, target, toOptions)), registry)\n fire('start', value.get())\n fire('complete', value.get())\n return handle\n }\n handle = buildHandle(\n startRun({\n value,\n scheduler,\n kind: 'timeline',\n state: { position: from, velocity: 0 },\n paused: toOptions.paused ?? false,\n timeScale: toOptions.timeScale ?? 1,\n seekMotion: motion,\n fire,\n ...repeatConfig(toOptions),\n }),\n registry,\n )\n return handle\n },\n }\n}\n","import type { DelegatedControls } from '../dom/animate'\nimport type { AnimationHandle } from '../value/animatable'\nimport { thenFinished } from '../value/thenable'\nimport { warnOnce } from '../value/warn'\nimport type { MotionKind, PlaybackHandle } from './handle'\n\nconst clamp = (x: number, lo: number, hi: number): number => Math.min(Math.max(x, lo), hi)\n\n/**\n * Map a PlaybackHandle onto a WAAPI-delegated tween. The scheduler wrapper cannot\n * pause the compositor, so these controls drive the native animation directly:\n * pause/play, currentTime for seek, playbackRate for timeScale and reverse. The\n * reclaim sign fix keeps an interrupted reversed tween's handoff velocity correct.\n */\nexport function waapiHandle(delegated: DelegatedControls, base: AnimationHandle, kind: MotionKind): PlaybackHandle {\n const animation = delegated.animation\n const durationMs = delegated.durationMs\n let paused = false\n let done = false\n void base.finished.then(() => {\n done = true\n })\n const progressNow = (): number => (durationMs <= 0 ? 1 : clamp(Number(animation.currentTime ?? 0) / durationMs, 0, 1))\n\n const handle: PlaybackHandle = {\n kind,\n seekable: true,\n finished: base.finished,\n then: thenFinished(base.finished),\n stop: () => base.stop(),\n pause() {\n animation.pause?.()\n paused = true\n return this\n },\n play() {\n animation.play?.()\n paused = false\n return this\n },\n resume() {\n return this.play()\n },\n isPaused: () => paused,\n timeScale(rate?: number): number | PlaybackHandle {\n if (rate === undefined) return animation.playbackRate ?? 1\n animation.playbackRate = rate\n return handle\n },\n reverse() {\n animation.playbackRate = -(animation.playbackRate ?? 1)\n return this\n },\n seek(timeMs: number) {\n animation.currentTime = clamp(timeMs, 0, durationMs)\n return this\n },\n progress(p?: number): number | PlaybackHandle {\n if (p === undefined) return progressNow()\n animation.currentTime = clamp(p, 0, 1) * durationMs\n return handle\n },\n time: () => Number(animation.currentTime ?? 0),\n totalTime: () => Number(animation.currentTime ?? 0),\n duration: () => durationMs,\n isActive: () => !done && !paused,\n iteration: () => 0, // a delegated tween runs a single iteration\n totalProgress: () => progressNow(),\n startTime: () => 0,\n endTime: () => durationMs,\n restart() {\n animation.currentTime = 0\n animation.play?.()\n paused = false\n return this\n },\n bake: () => true, // a delegated tween is already seekable\n setTarget() {\n warnOnce('playback:settarget-seekable', 'setTarget() re-aims a live spring; a tween uses seek()')\n return this\n },\n } as PlaybackHandle\n return handle\n}\n","import { __getDelegated, animate, type AnimateOptions, type AnimateTargets } from '../dom/animate'\nimport type { AnimationHandle } from '../value/animatable'\nimport { thenFinished } from '../value/thenable'\nimport { warnOnce } from '../value/warn'\nimport type { MotionKind, PlaybackHandle, PlaybackOptions } from './handle'\nimport { timeScope, type TimeScope } from './time-scope'\nimport { waapiHandle } from './waapi'\n\n/**\n * The JS path (springs, or a tween with no WAAPI): pause / timeScale ride the\n * private timeScope. There is no external playhead, so seek / progress / reverse\n * warn once and no-op. For a seekable DOM tween, delegate to WAAPI (see above).\n */\nfunction scopeHandle(scope: TimeScope, base: AnimationHandle, kind: MotionKind): PlaybackHandle {\n let done = false\n void base.finished.then(() => {\n done = true\n })\n const handle: PlaybackHandle = {\n kind,\n seekable: false,\n finished: base.finished,\n then: thenFinished(base.finished),\n stop: () => base.stop(),\n pause() {\n scope.pause()\n return this\n },\n play() {\n scope.resume()\n return this\n },\n resume() {\n scope.resume()\n return this\n },\n isPaused: () => scope.isPaused(),\n timeScale(rate?: number): number | PlaybackHandle {\n if (rate === undefined) return scope.getTimeScale()\n scope.setTimeScale(rate)\n return handle\n },\n reverse() {\n warnOnce('playback:reverse-js', 'reverse() needs a WAAPI-delegated tween; bake a spring for a seekable clip')\n return this\n },\n seek() {\n warnOnce('playback:seek-live', 'seek()/progress() need a seekable (WAAPI-delegated) handle')\n return this\n },\n progress(p?: number): number | PlaybackHandle {\n if (p === undefined) return 0\n warnOnce('playback:seek-live', 'seek()/progress() need a seekable (WAAPI-delegated) handle')\n return handle\n },\n time: () => 0,\n totalTime: () => 0,\n duration: () => undefined,\n isActive: () => !done && !scope.isPaused(),\n iteration: () => 0, // repeat/yoyo are not modelled on this path (playable() has them)\n totalProgress: () => (done ? 1 : 0), // no playhead on a live spring; coarse but honest\n startTime: () => 0,\n endTime: () => undefined,\n restart() {\n warnOnce('playback:restart-dom', 'restart() needs a seekable handle or playable(); re-call animate() to replay')\n return this\n },\n bake: () => false,\n setTarget() {\n warnOnce('playback:settarget-dom', 'setTarget() is for an imperative value; use playable() for live re-aim')\n return this\n },\n } as PlaybackHandle\n return handle\n}\n\n/**\n * animate() that returns a PlaybackHandle. A delegated tween (duration + WAAPI)\n * is controlled natively (pause/seek/timeScale/reverse, lossless and\n * off-main-thread); everything else runs on a private timeScope that pause and\n * timeScale drive. repeat / delay / yoyo are not modelled here - reach for\n * playable() on an imperative value when you need them.\n */\nexport function animatePlayback(\n element: HTMLElement,\n targets: AnimateTargets,\n options: AnimateOptions & PlaybackOptions = {},\n): PlaybackHandle {\n if (options.repeat !== undefined || options.delay !== undefined || options.yoyo === true) {\n warnOnce('playback:dom-repeat', 'repeat/delay/yoyo are not supported on animatePlayback; use playable()')\n }\n\n const scopeOptions = options.scheduler !== undefined ? { scheduler: options.scheduler } : {}\n const scope = timeScope(scopeOptions)\n const base = animate(element, targets, { ...options, scheduler: scope })\n\n const kind: MotionKind = options.duration !== undefined ? 'timeline' : 'physics'\n const delegated = __getDelegated(element)\n\n if (delegated !== null) {\n if (options.timeScale !== undefined) delegated.animation.playbackRate = options.timeScale\n if (options.paused === true) {\n delegated.animation.pause?.()\n }\n return waapiHandle(delegated, base, kind)\n }\n\n if (options.timeScale !== undefined) scope.setTimeScale(options.timeScale)\n if (options.paused === true) scope.pause()\n return scopeHandle(scope, base, kind)\n}\n","import { simulationMotion } from '../physics/motion'\nimport { SIMULATION_TIMESTEP_S, type SimulationState } from '../physics/simulation'\nimport { springSimulation, type SpringOptions } from '../physics/spring'\nimport type { Scheduler } from '../scheduler/scheduler'\nimport { getSharedScheduler } from '../scheduler/shared'\nimport { animatable, type Animatable } from '../value/animatable'\n\nexport interface FollowOptions extends SpringOptions {\n /** The scheduler to run on; defaults to the shared rAF loop. */\n scheduler?: Scheduler\n}\n\nexport interface Follow {\n /** The tracking value: read get()/velocity(), subscribe on('change'). */\n readonly value: Animatable\n /** Re-aim the spring at a moving target. Velocity is conserved; NO Motion rebuild. */\n target(next: number): void\n /** Freeze the spring in place. */\n stop(): void\n /** Stop and release the value and the frame subscription. */\n dispose(): void\n}\n\nconst H = SIMULATION_TIMESTEP_S\n\n/**\n * A value that springs toward a moving target: the momentum-scrub seam for\n * scroll. The default config is critically damped, so a scrub never overshoots.\n * target() mutates the spring's aim in place rather than rebuilding the Motion,\n * so a per-frame scroll handler allocates nothing after construction.\n */\nexport function follow(initial: number, options: FollowOptions = {}): Follow {\n const scheduler = options.scheduler ?? getSharedScheduler()\n const value = animatable(initial, { scheduler })\n\n const stiffness = options.stiffness ?? 100\n const mass = options.mass ?? 1\n // Critically damped unless the caller overrides: monotonic, no overshoot.\n const damping = options.damping ?? 2 * Math.sqrt(stiffness * mass)\n const sim = springSimulation(initial, { ...options, stiffness, damping, mass })\n const motion = simulationMotion(sim)\n\n let lastTarget = initial\n let prev: SimulationState = { position: initial, velocity: 0 }\n let curr: SimulationState = prev\n let accumulatorS = 0\n let unsubscribe: (() => void) | null = null\n let disposed = false\n\n const onFrame = ({ deltaMs }: { deltaMs: number }) => {\n accumulatorS += deltaMs / 1000\n while (accumulatorS >= H) {\n accumulatorS -= H\n prev = curr\n curr = motion.step(curr, H)\n const rested = motion.rest(curr)\n if (rested !== null) {\n value.drive({ position: rested, velocity: 0 })\n unsubscribe?.()\n unsubscribe = null\n return\n }\n }\n const alpha = accumulatorS / H\n value.drive({\n position: prev.position + (curr.position - prev.position) * alpha,\n velocity: prev.velocity + (curr.velocity - prev.velocity) * alpha,\n })\n }\n\n const ensureRunning = () => {\n if (unsubscribe === null && !disposed) unsubscribe = scheduler.subscribe(onFrame)\n }\n\n return {\n value,\n target(next) {\n if (next === lastTarget) return\n lastTarget = next\n sim.retarget(next) // in place: no springSimulation/simulationMotion allocation\n // Re-seed from the value's live state so velocity is conserved across the re-aim.\n curr = { position: value.get(), velocity: value.velocity() }\n prev = curr\n accumulatorS = 0\n ensureRunning()\n },\n stop() {\n unsubscribe?.()\n unsubscribe = null\n },\n dispose() {\n disposed = true\n unsubscribe?.()\n unsubscribe = null\n value.dispose()\n },\n }\n}\n","import type { ThenFn } from '../value/thenable'\nimport type { DecayOptions } from '../physics/decay'\nimport type { SpringOptions } from '../physics/spring'\nimport type { ToOptions } from '../physics/tween'\nimport type { FrameInfo, Scheduler } from '../scheduler/scheduler'\nimport type { Animatable, AnimationHandle } from '../value/animatable'\nimport type { PlaybackOptions } from './handle'\nimport { playable } from './playable'\nimport { timeScope, type TimeScope } from './time-scope'\n\nexport interface SequenceOptions extends Pick {\n /** Frame loop. Tests inject createScheduler(createManualDriver()). Default the shared rAF loop. */\n scheduler?: Scheduler\n /** Spring/tween knobs merged into every leg (a leg's own options win). */\n defaults?: SpringOptions & ToOptions\n}\n\n/** Where a leg starts relative to the previous one - the only positioning a live sequence has. */\nexport interface LegOptions {\n /**\n * Start this leg `overlap` ms after the PREVIOUS leg STARTED - the cascade\n * feel, springs handing off mid-flight. Omitted: start when the previous leg\n * comes to rest (strict order).\n */\n overlap?: number\n}\nexport type SpringLegOptions = LegOptions & SpringOptions\nexport type ToLegOptions = LegOptions & ToOptions\nexport type DecayLegOptions = LegOptions & DecayOptions\nexport interface StaggerLegOptions extends LegOptions {\n /** Per-item spacing in ms. */\n each: number\n}\n\n/**\n * The live twin of a timeline. Legs run in authored order on completion events\n * (no master clock): each starts when the previous rests, or `overlap` ms after\n * it starts. Every leg is a live spring/decay/tween, so a value stays\n * interruptible - retarget it mid-flight and the motion hands off with its\n * velocity conserved, never a restart. It is deliberately NOT seekable: no\n * seek(), progress() or duration() - that is what `timeline()` is for. Author\n * with from()/fromTo() to make a run replayable (they reset the start each play).\n */\nexport interface Sequence {\n readonly kind: 'sequence'\n readonly seekable: false\n /** Resolves when the last leg rests (or on stop()). Never rejects. */\n readonly finished: Promise\n /** Awaitable: `await sequence` resolves when the current run finishes (delegates to `finished`). */\n then: ThenFn\n\n spring(value: Animatable, target: number, options?: SpringLegOptions): this\n to(value: Animatable, target: number, options?: ToLegOptions): this\n from(value: Animatable, start: number, options?: ToLegOptions): this\n fromTo(value: Animatable, start: number, target: number, options?: ToLegOptions): this\n decay(value: Animatable, options?: DecayLegOptions): this\n /** Run an arbitrary handle as a leg. It keeps its own clock - pause/timeScale do not reach it. */\n add(step: () => AnimationHandle, options?: LegOptions): this\n /** Fire a callback at this point in the chain. */\n call(fn: () => void, options?: LegOptions): this\n /** Fan a builder across items `each` ms apart, run as one leg. */\n stagger(items: readonly T[], build: (item: T, index: number) => AnimationHandle, options: StaggerLegOptions): this\n\n /** Start (or restart from the top), or resume after pause(). */\n play(): this\n pause(): this\n resume(): this\n /** Freeze running legs, cancel pending ones, resolve finished. */\n stop(): void\n isPaused(): boolean\n timeScale(rate: number): this\n timeScale(): number\n}\n\ntype LegHandle = { finished: Promise; stop: () => void }\ninterface Leg {\n /** ms after the previous leg's START, or null to wait for the previous leg's REST. */\n overlap: number | null\n /** The driven value, for same-value hand-off; null for call()/add()/stagger(). */\n value: Animatable | null\n start: () => LegHandle\n}\n\n// A frame-clock delay (clamped, batched into the loop) - never setTimeout, so a\n// background tab pauses overlaps like everything else. Runs on the sequence scope.\nconst wait = (ms: number, scheduler: Scheduler, onDone: () => void): (() => void) => {\n let elapsedMs = 0\n const unsubscribe = scheduler.subscribe(({ deltaMs }: FrameInfo) => {\n elapsedMs += deltaMs\n if (elapsedMs >= ms) {\n unsubscribe()\n onDone()\n }\n })\n return unsubscribe\n}\n\nexport function createSequence(options: SequenceOptions = {}): Sequence {\n const legs: Leg[] = []\n const defaults = options.defaults ?? {}\n\n let scope: TimeScope | null = null\n let phase: 'idle' | 'running' | 'paused' | 'done' = 'idle'\n let startedCount = 0\n let doneCount = 0\n const active = new Set()\n const activeByValue = new Map()\n const cancels = new Set<() => void>()\n\n let resolveFinished: () => void = () => {}\n let finishedPromise = new Promise((resolve) => {\n resolveFinished = resolve\n })\n\n const ensureScope = (): TimeScope => {\n if (scope === null) {\n const opts: { scheduler?: Scheduler; timeScale: number; paused: boolean } = {\n timeScale: options.timeScale ?? 1,\n paused: true,\n }\n if (options.scheduler !== undefined) opts.scheduler = options.scheduler\n scope = timeScope(opts)\n }\n return scope\n }\n\n // Merge defaults under a leg's own options, and drop the overlap field before\n // the options reach playable (which has no concept of it).\n const legOptions = (o: LegOptions & T): T => {\n const merged = { ...defaults, ...o } as Record\n if ('overlap' in merged) delete merged.overlap\n return merged as T\n }\n const overlapOf = (o: LegOptions): number | null => (o.overlap === undefined ? null : o.overlap)\n\n const tryFinish = (): void => {\n if (phase !== 'running') return\n if (startedCount >= legs.length && doneCount >= legs.length) {\n phase = 'done'\n scope?.pause()\n resolveFinished()\n }\n }\n\n const startLeg = (i: number): void => {\n if (phase !== 'running' || i !== startedCount) return // serialize starts\n const leg = legs[i]\n if (leg === undefined) return\n startedCount = i + 1\n\n // Same-value hand-off: a new leg takes a value over from the prior leg's\n // live position AND velocity (playable re-seeds from value.velocity()).\n if (leg.value !== null) {\n const prior = activeByValue.get(leg.value)\n if (prior !== undefined) {\n prior.stop() // does not write the value, so the new leg inherits its live state\n active.delete(prior)\n activeByValue.delete(leg.value)\n }\n }\n\n const handle = leg.start()\n active.add(handle)\n if (leg.value !== null) activeByValue.set(leg.value, handle)\n\n let counted = false\n void handle.finished.then(() => {\n if (counted) return\n counted = true\n active.delete(handle)\n if (leg.value !== null && activeByValue.get(leg.value) === handle) activeByValue.delete(leg.value)\n doneCount += 1\n tryFinish()\n })\n\n const next = legs[i + 1]\n if (next === undefined) {\n tryFinish()\n return\n }\n if (next.overlap !== null) cancels.add(wait(next.overlap, ensureScope(), () => startLeg(i + 1)))\n else void handle.finished.then(() => startLeg(i + 1))\n }\n\n const beginRun = (): void => {\n startedCount = 0\n doneCount = 0\n active.clear()\n activeByValue.clear()\n for (const cancel of cancels) cancel()\n cancels.clear()\n if (legs.length === 0) {\n phase = 'done'\n resolveFinished()\n return\n }\n phase = 'running'\n ensureScope().resume()\n startLeg(0)\n }\n\n const seq = {\n kind: 'sequence' as const,\n seekable: false as const,\n get finished() {\n return finishedPromise\n },\n then(\n onfulfilled?: ((value: void) => unknown) | null,\n onrejected?: ((reason: unknown) => unknown) | null,\n ): Promise {\n return finishedPromise.then(onfulfilled ?? undefined, onrejected ?? undefined)\n },\n\n spring(value: Animatable, target: number, o: SpringLegOptions = {}) {\n legs.push({\n overlap: overlapOf(o),\n value,\n start: () => playable(value, { scheduler: ensureScope() }).spring(target, legOptions(o)),\n })\n return seq\n },\n to(value: Animatable, target: number, o: ToLegOptions = {}) {\n legs.push({\n overlap: overlapOf(o),\n value,\n start: () => playable(value, { scheduler: ensureScope() }).to(target, legOptions(o)),\n })\n return seq\n },\n from(value: Animatable, start: number, o: ToLegOptions = {}) {\n legs.push({\n overlap: overlapOf(o),\n value,\n start: () => {\n const dest = value.get()\n value.set(start)\n return playable(value, { scheduler: ensureScope() }).to(dest, legOptions(o))\n },\n })\n return seq\n },\n fromTo(value: Animatable, start: number, target: number, o: ToLegOptions = {}) {\n legs.push({\n overlap: overlapOf(o),\n value,\n start: () => {\n value.set(start)\n return playable(value, { scheduler: ensureScope() }).to(target, legOptions(o))\n },\n })\n return seq\n },\n decay(value: Animatable, o: DecayLegOptions = {}) {\n legs.push({\n overlap: overlapOf(o),\n value,\n start: () => playable(value, { scheduler: ensureScope() }).decay(legOptions(o)),\n })\n return seq\n },\n add(step: () => AnimationHandle, o: LegOptions = {}) {\n legs.push({\n overlap: overlapOf(o),\n value: null,\n start: () => {\n const handle = step()\n return { finished: handle.finished, stop: () => handle.stop() }\n },\n })\n return seq\n },\n call(fn: () => void, o: LegOptions = {}) {\n legs.push({\n overlap: overlapOf(o),\n value: null,\n start: () => {\n fn()\n return { finished: Promise.resolve(), stop: () => {} }\n },\n })\n return seq\n },\n stagger(items: readonly unknown[], build: (item: unknown, index: number) => AnimationHandle, o: StaggerLegOptions) {\n legs.push({\n overlap: overlapOf(o),\n value: null,\n start: () => {\n const made: AnimationHandle[] = []\n const itemCancels: Array<() => void> = []\n let remaining = items.length\n let resolveAll: () => void = () => {}\n const finished = items.length === 0 ? Promise.resolve() : new Promise((r) => {\n resolveAll = r\n })\n const startItem = (item: unknown, index: number): void => {\n const handle = build(item, index)\n made.push(handle)\n void handle.finished.then(() => {\n remaining -= 1\n if (remaining === 0) resolveAll()\n })\n }\n items.forEach((item, index) => {\n const delay = o.each * index\n if (delay <= 0) startItem(item, index)\n else itemCancels.push(wait(delay, ensureScope(), () => startItem(item, index)))\n })\n return {\n finished,\n stop: () => {\n for (const cancel of itemCancels) cancel()\n for (const handle of made) handle.stop()\n },\n }\n },\n })\n return seq\n },\n\n play() {\n if (phase === 'running') return seq\n if (phase === 'paused') {\n phase = 'running'\n scope?.resume()\n return seq\n }\n // idle or done: a fresh run from the top, with a fresh finished promise\n finishedPromise = new Promise((resolve) => {\n resolveFinished = resolve\n })\n beginRun()\n return seq\n },\n pause() {\n if (phase === 'running') {\n phase = 'paused'\n scope?.pause()\n }\n return seq\n },\n resume() {\n return seq.play()\n },\n isPaused() {\n return scope?.isPaused() ?? true\n },\n stop() {\n for (const cancel of cancels) cancel()\n cancels.clear()\n for (const handle of active) handle.stop()\n active.clear()\n activeByValue.clear()\n phase = 'done'\n scope?.pause()\n resolveFinished()\n },\n timeScale(rate?: number) {\n const sc = ensureScope()\n if (rate === undefined) return sc.getTimeScale()\n sc.setTimeScale(rate)\n return seq\n },\n }\n\n return seq as unknown as Sequence\n}\n"],"names":["MAX_STEPS_PER_FRAME","MAX_RECORD_STEPS","H","SIMULATION_TIMESTEP_S","record","makeMotion","initial","options","stride","stateful","maxSteps","probe","checkpoints","state","restStep","restedPosition","step","rested","durationS","restState","stateAfter","targetStep","motion","s","base","i","elapsedS","q","n","alpha","lo","hi","sampledMotion","trajectory","_state","timestepS","target","timeScope","parent","getSharedScheduler","timeScale","paused","members","detach","fan","phase","frame","shared","MAX_FRAME_DELTA_MS","set","callback","attach","detachPhase","_a","detachAll","attachAll","rate","NO_FIRE","shouldSkip","override","getReducedMotionBehavior","prefersReducedMotion","clamp","x","repeatConfig","o","c","reducedFinal","from","to","repeat","MAX_SKIP_STEPS","settleInstantly","current","settled","startRun","config","value","kind","scope","seekMotion","liveMotion","prev","curr","accumulatorS","liveElapsedS","launchPos","originalTarget","currentTarget","direction","canRepeat","iterationsLeft","repeatDelayS","yoyo","holdS","forwardLeg","totalElapsedS","iterationIndex","delayS0","repeatCount","activeDurationS","r","resolveFinished","finished","resolve","unsubscribe","fire","started","reversing","seekReversed","lastUpdateValue","fireUpdate","v","finish","reason","onIterationEnd","boundaryPos","start","aim","seed","driveLive","deltaS","driveSeek","deltaMs","ensureSubscribed","liveProgress","span","retargetLiveTo","velocity","isReverse","ms","active","total","warnOnce","maxDurationMs","make","recordOptions","inertControls","settleTo","buildHandle","controls","registry","handle","event","fn","thenFinished","timeMs","p","duration","playable","scheduler","springOptions","lifecycleRegistry","simulationMotion","springSimulation","next","decayOptions","final","decaySimulation","toOptions","tweenMotion","waapiHandle","delegated","animation","durationMs","done","progressNow","scopeHandle","animatePlayback","element","targets","scopeOptions","animate","__getDelegated","_b","follow","animatable","stiffness","mass","damping","sim","lastTarget","disposed","onFrame","ensureRunning","wait","onDone","elapsedMs","createSequence","legs","defaults","startedCount","doneCount","activeByValue","cancels","finishedPromise","ensureScope","opts","legOptions","merged","overlapOf","tryFinish","startLeg","leg","prior","counted","beginRun","cancel","seq","onfulfilled","onrejected","dest","items","build","made","itemCancels","remaining","resolveAll","startItem","item","index","delay","sc"],"mappings":"8JASaA,GAAsB,IAI7BC,GAAmB,IAEnBC,EAAIC,GAAAA,sBA+BH,SAASC,GACdC,EACAC,EACAC,EAAyB,CAAA,EACN,CACnB,MAAMC,EAAS,KAAK,IAAI,EAAG,KAAK,IAAID,EAAQ,kBAAoB,GAAIP,EAAmB,CAAC,EAClFS,EAAWF,EAAQ,UAAY,GAC/BG,EAAWH,EAAQ,UAAYN,GAI/BU,EAAQN,EAAA,EACRO,EAAiC,CAACN,CAAO,EAC/C,IAAIO,EAAQP,EACRQ,EAAW,GACXC,EAAiBT,EAAQ,SAE7B,QAASU,EAAO,EAAGA,GAAQN,EAAUM,IAAQ,CAC3CH,EAAQF,EAAM,KAAKE,EAAOX,CAAC,EACvBc,EAAOR,IAAW,GAAGI,EAAY,KAAKC,CAAK,EAC/C,MAAMI,EAASN,EAAM,KAAKE,CAAK,EAC/B,GAAII,IAAW,KAAM,CACnBH,EAAWE,EACXD,EAAiBE,EACjB,KACF,CACF,CACA,GAAIH,IAAa,GAAI,OAAO,KAE5B,MAAMI,EAAYJ,EAAWZ,EACvBiB,EAA6B,CAAE,SAAUJ,EAAgB,SAAU,CAAA,EAKnEK,EAAcC,GAAwC,CAC1D,GAAIA,GAAc,EAAG,OAAOf,EAC5B,GAAIe,GAAcP,EAAU,OAAOK,EACnC,GAAIV,EAAU,CACZ,MAAMa,EAASjB,EAAA,EACf,IAAIkB,EAAIjB,EACR,QAAS,EAAI,EAAG,EAAIe,EAAY,IAAKE,EAAID,EAAO,KAAKC,EAAGrB,CAAC,EACzD,OAAOqB,CACT,CACA,MAAMC,EAAO,KAAK,IAAI,KAAK,MAAMH,EAAab,CAAM,EAAGI,EAAY,OAAS,CAAC,EAC7E,IAAIW,EAAIX,EAAYY,CAAI,GAAKlB,EAC7B,QAASmB,EAAID,EAAOhB,EAAQiB,EAAIJ,EAAYI,IAAKF,EAAIZ,EAAM,KAAKY,EAAGrB,CAAC,EACpE,OAAOqB,CACT,EAEA,MAAO,CACL,UAAAL,EACA,OAAOQ,EAAU,CACf,GAAIA,GAAY,EAAG,OAAOpB,EAC1B,GAAIoB,GAAYR,EAAW,OAAOC,EAClC,MAAMQ,EAAID,EAAWxB,EACf0B,EAAI,KAAK,MAAMD,CAAC,EAChBE,EAAQF,EAAIC,EAGZE,EAAKV,EAAWQ,EAAI,CAAC,EACrBG,EAAKX,EAAWQ,CAAC,EACvB,MAAO,CACL,SAAUE,EAAG,UAAYC,EAAG,SAAWD,EAAG,UAAYD,EACtD,SAAUC,EAAG,UAAYC,EAAG,SAAWD,EAAG,UAAYD,CAAA,CAE1D,CAAA,CAEJ,CAOO,SAASG,GAAcC,EAAwC,CACpE,IAAIP,EAAW,EACf,MAAO,CACL,KAAKQ,EAAQC,EAAW,CACtB,OAAAT,GAAYS,EACLF,EAAW,OAAOP,CAAQ,CACnC,EACA,KAAM,IAAOA,GAAYO,EAAW,UAAYA,EAAW,OAAOA,EAAW,SAAS,EAAE,SAAW,KACnG,UAAWA,EAAW,UACtB,KAAKG,EAAyB,CAC5B,OAAAV,EAAW,KAAK,IAAI,KAAK,IAAIU,EAAQ,CAAC,EAAGH,EAAW,SAAS,EACtDA,EAAW,OAAOP,CAAQ,CACnC,CAAA,CAEJ,CC7FO,SAASW,EAAU9B,EAA4B,GAAe,CACnE,MAAM+B,EAAS/B,EAAQ,WAAagC,qBAAA,EACpC,IAAIC,EAAYjC,EAAQ,WAAa,EACjCkC,EAASlC,EAAQ,QAAU,GAE/B,MAAMmC,EAAkD,CAAE,OAAQ,IAAI,IAAO,OAAQ,IAAI,GAAI,EACvFC,EAAkD,CAAE,OAAQ,KAAM,OAAQ,IAAA,EAI1EC,EAAOC,GAAuBC,GAAqB,CAEvD,MAAMC,EAAoB,CAAE,QADb,KAAK,IAAID,EAAM,QAAUN,EAAWQ,oBAAkB,EACxB,YAAaF,EAAM,WAAA,EAC1DG,EAAMP,EAAQG,CAAK,EACzB,UAAWK,IAAY,CAAC,GAAGD,CAAG,EAAOA,EAAI,IAAIC,CAAQ,GAAGA,EAASH,CAAM,CACzE,EAEMI,EAAUN,GAAsB,CAChC,CAACJ,GAAUE,EAAOE,CAAK,IAAM,MAAQH,EAAQG,CAAK,EAAE,KAAO,IAC7DF,EAAOE,CAAK,EAAIP,EAAO,UAAUM,EAAIC,CAAK,EAAGA,CAAK,EAEtD,EACMO,EAAeP,GAAsB,QACzCQ,EAAAV,EAAOE,KAAP,MAAAQ,EAAA,KAAAV,GACAA,EAAOE,CAAK,EAAI,IAClB,EACMS,EAAY,IAAM,CACtBF,EAAY,QAAQ,EACpBA,EAAY,QAAQ,CACtB,EACMG,EAAY,IAAM,CACtBJ,EAAO,QAAQ,EACfA,EAAO,QAAQ,CACjB,EAEA,MAAO,CACL,UAAUD,EAAUL,EAAQ,SAAU,CACpC,OAAAH,EAAQG,CAAK,EAAE,IAAIK,CAAQ,EAC3BC,EAAON,CAAK,EACL,IAAM,CACXH,EAAQG,CAAK,EAAE,OAAOK,CAAQ,EAC1BR,EAAQG,CAAK,EAAE,OAAS,KAAeA,CAAK,CAClD,CACF,EACA,UAAW,IAAMF,EAAO,SAAW,MAAQA,EAAO,SAAW,KAC7D,OAAQ,CACFF,IACJA,EAAS,GACTa,EAAA,EACF,EACA,QAAS,CACFb,IACLA,EAAS,GACTc,EAAA,EACF,EACA,SAAU,IAAMd,EAChB,aAAae,EAAM,CACjBhB,EAAYgB,CACd,EACA,aAAc,IAAMhB,EACpB,SAAU,CACRc,EAAA,EACAZ,EAAQ,OAAO,MAAA,EACfA,EAAQ,OAAO,MAAA,CACjB,CAAA,CAEJ,CCzFA,MAAMe,GAAgB,IAAM,CAAC,EAgBvBvD,EAAIC,GAAAA,sBAEJuD,GAAcC,GACdA,IAAa,SACbA,IAAa,QAAaC,EAAAA,yBAAA,IAA+B,QAAgB,GACtEC,uBAAA,EAGHC,EAAQ,CAACC,EAAWjC,EAAYC,IAAuB,KAAK,IAAI,KAAK,IAAIgC,EAAGjC,CAAE,EAAGC,CAAE,EAGzF,SAASiC,GAAaC,EAAoF,CACxG,MAAMC,EAAoE,CAAA,EAC1E,OAAID,EAAE,QAAU,SAAWC,EAAE,MAAQD,EAAE,OACnCA,EAAE,SAAW,SAAWC,EAAE,OAASD,EAAE,QACrCA,EAAE,cAAgB,SAAWC,EAAE,YAAcD,EAAE,aAC/CA,EAAE,OAAS,SAAWC,EAAE,KAAOD,EAAE,MAC9BC,CACT,CAGA,SAASC,GAAaC,EAAcC,EAAYJ,EAA4B,CAC1E,MAAMK,EAASL,EAAE,QAAU,EAC3B,OAAIA,EAAE,OAAS,IAAQ,CAAC,OAAO,SAASK,CAAM,IACtC,EAAIA,GAAU,IAAM,EAD4BD,EACnBD,CACvC,CAGA,MAAMG,GAAiB,IAGvB,SAASC,GAAgBlD,EAAgB8C,EAAwC,CAC/E,IAAIK,EAAUL,EACVM,EAAyB,KAC7B,QAASjD,EAAI,EAAGA,EAAI8C,IAAkBG,IAAY,KAAMjD,IACtDgD,EAAUnD,EAAO,KAAKmD,EAASvE,CAAC,EAChCwE,EAAUpD,EAAO,KAAKmD,CAAO,EAE/B,MAAO,CAAE,SAAUC,GAAWD,EAAQ,SAAU,SAAU,CAAA,CAC5D,CA+DA,SAASE,GAASC,EAAkC,CAClD,KAAM,CAAE,MAAAC,EAAO,KAAAC,CAAA,EAASF,EAClBG,EAAQ1C,EAAU,CAAE,UAAWuC,EAAO,UAAW,UAAWA,EAAO,UAAW,OAAQA,EAAO,MAAA,CAAQ,EAG3G,IAAII,EAAoCJ,EAAO,YAAc,KACzDK,EAA4BL,EAAO,SAAWA,EAAO,WAAa,KAGlEM,EAAON,EAAO,MACdO,EAAOP,EAAO,MACdQ,EAAe,EACfC,EAAe,EACnB,MAAMC,EAAYV,EAAO,WAAaA,EAAO,MAAM,SAC7CW,EAAiBX,EAAO,eAAiBU,EAC/C,IAAIE,EAAgBD,EAGhB7D,EAAW,EACX+D,EAAoB,EACpBvE,GAAY8D,GAAA,YAAAA,EAAY,YAAa,EAGzC,MAAMU,EAAYV,IAAe,MAAQJ,EAAO,gBAAkB,OAClE,IAAIe,EAAiBD,EAAad,EAAO,QAAU,EAAK,EACxD,MAAMgB,GAAgBhB,EAAO,aAAe,GAAK,IAC3CiB,EAAOjB,EAAO,MAAQ,GAC5B,IAAIkB,GAASlB,EAAO,OAAS,GAAK,IAC9BmB,EAAa,GACbC,EAAgB,EAChBC,EAAiB,EAIrB,MAAMC,GAAWtB,EAAO,OAAS,GAAK,IAChCuB,EAAc,IAAeT,EAAad,EAAO,QAAU,EAAK,EAChEwB,EAAkB,IAA0B,CAChD,GAAIpB,IAAe,KAAM,OACzB,MAAMqB,EAAIF,EAAA,EACV,OAAO,OAAO,SAASE,CAAC,GAAK,EAAIA,GAAKnF,EAAYmF,EAAIT,EAAe,GACvE,EAEA,IAAIlB,EAAU,GACV4B,EAAkB,IAAM,CAAC,EAC7B,MAAMC,EAAW,IAAI,QAAeC,GAAY,CAC9CF,EAAkBE,CACpB,CAAC,EAED,IAAIC,EAAmC,KACvC,MAAMC,EAAO9B,EAAO,MAAQnB,GAC5B,IAAIkD,EAAU,GACVC,EAAY,GACZC,EAAe,GACfC,EAAkBjC,EAAM,IAAA,EAE5B,MAAMkC,EAAa,IAAY,CAC7B,MAAMC,EAAInC,EAAM,IAAA,EACZmC,IAAMF,IACRA,EAAkBE,EAClBN,EAAK,SAAUM,CAAC,EAEpB,EAEMC,GAAUC,GAAyD,CACnExC,IACJA,EAAU,GACV+B,GAAA,MAAAA,IACAA,EAAc,KACd1B,EAAM,QAAA,EACNuB,EAAA,EACAI,EAAKQ,CAAM,EACb,EAKMC,EAAkBC,GAAwB,OAG9C,GAFAvC,EAAM,MAAM,CAAE,SAAUuC,EAAa,SAAU,EAAG,EAClDL,EAAA,EACIpB,GAAkB,EAAG,CAGvBsB,IADiBjC,IAAe,KAAO6B,EAAeD,GACpC,kBAAoB,UAAU,EAChD,MACF,CAKA,GAJAjB,GAAkB,EAClBM,GAAkB,EAClBS,EAAK,SAAUU,CAAW,EAC1BtB,EAAQF,EACJZ,IAAe,KAAM,CACnBa,EACFJ,EAAYA,IAAc,EAAI,GAAK,GAEnC/D,EAAW,EACX+D,EAAY,GAEd,MACF,CACAM,EAAaF,EAAO,CAACE,EAAa,GAClC,MAAMsB,EAAQtB,EAAaT,EAAYC,EACjC+B,EAAMvB,EAAaR,EAAiBD,GAC1CjC,EAAAuB,EAAO,eAAP,MAAAvB,EAAA,KAAAuB,EAAsB0C,GACtB9B,EAAgB8B,EAChB,MAAMC,EAAwB,CAAE,SAAUF,EAAO,SAAU,CAAA,EAC3DnC,EAAOqC,EACPpC,EAAOoC,EACPnC,EAAe,EACfC,EAAe,EACfJ,EAAaL,EAAO,SAAWA,EAAO,SAAA,EAAaK,EACnDJ,EAAM,MAAM0C,CAAI,CAClB,EAEMC,GAAaC,GAAmB,CACpC,GAAIxC,IAAe,KAAM,OAEzB,IADAG,GAAgBqC,EACTrC,GAAgBlF,GAAG,CACxBkF,GAAgBlF,EAChBgF,EAAOC,EACPA,EAAOF,EAAW,KAAKE,EAAMjF,CAAC,EAC9BmF,GAAgBnF,EAChB,MAAMe,EAASgE,EAAW,KAAKE,CAAI,EACnC,GAAIlE,IAAW,KAAM,CACnBkG,EAAelG,CAAM,EACrB,MACF,CACF,CACA,MAAMY,EAAQuD,EAAelF,EAC7B2E,EAAM,MAAM,CACV,SAAUK,EAAK,UAAYC,EAAK,SAAWD,EAAK,UAAYrD,EAC5D,SAAUqD,EAAK,UAAYC,EAAK,SAAWD,EAAK,UAAYrD,CAAA,CAC7D,EACDkF,EAAA,CACF,EAEMW,GAAaD,GAAmB,CACpC,GAAIzC,IAAe,KAAM,OAEzB,GADAtD,GAAY+F,EAAShC,EACjBA,EAAY,GAAK/D,GAAY,EAAG,CAClCA,EAAW,EACXyF,EAAenC,EAAW,KAAK,CAAC,EAAE,QAAQ,EAC1C,MACF,CACA,GAAIS,EAAY,GAAK/D,GAAYR,EAAW,CAC1CQ,EAAWR,EACXiG,EAAenC,EAAW,KAAK9D,CAAS,EAAE,QAAQ,EAClD,MACF,CACA,MAAMK,EAAIyD,EAAW,KAAKtD,CAAQ,EAClCmD,EAAM,MAAMY,EAAY,EAAI,CAAE,SAAUlE,EAAE,SAAU,SAAU,CAACA,EAAE,QAAA,EAAaA,CAAC,EAC/EwF,EAAA,CACF,EAIMjE,GAAQ,CAAC,CAAE,QAAA6E,KAAmC,CAClD,MAAMF,EAASE,EAAU,IAEzB,GADA3B,GAAiByB,EACb3B,EAAQ,EAAG,CACbA,GAAS2B,EACT,MACF,CACKd,IACHA,EAAU,GACVD,EAAK,QAAS7B,EAAM,KAAK,GAEvBG,IAAe,KAAM0C,GAAUD,CAAM,KAC1BA,CAAM,CACvB,EAEMG,EAAmB,IAAM,CACzBnB,IAAgB,MAAQ,CAAC/B,IAAS+B,EAAc1B,EAAM,UAAUjC,EAAK,EAC3E,EACA8E,EAAA,EAEA,MAAMC,GAAe,IAAc,CACjC,MAAMC,EAAO,KAAK,IAAItC,EAAgBF,CAAS,EAC/C,OAAIwC,IAAS,EAAUpD,EAAU,EAAI,EAC9BZ,EAAM,KAAK,IAAIe,EAAM,MAAQS,CAAS,EAAIwC,EAAM,EAAG,CAAC,CAC7D,EAIMC,EAAiB,CAAC3F,EAAgB4F,EAA8BC,IAA6B,OACjG,GAAIjD,IAAe,KAAM,OACzB4B,EAAYqB,EACZzC,EAAgBpD,GAChBiB,EAAAuB,EAAO,eAAP,MAAAvB,EAAA,KAAAuB,EAAsBxC,GACtB6C,EAAaL,EAAO,SAAWA,EAAO,SAAA,EAAaK,EACnD,MAAMsC,EAAwB,CAAE,SAAU1C,EAAM,MAAO,SAAUmD,GAAYnD,EAAM,UAAS,EAC5FK,EAAOqC,EACPpC,EAAOoC,EACPnC,EAAe,EACfP,EAAM,MAAM0C,CAAI,EAChBK,EAAA,CACF,EAEA,MAAO,CACL,KAAA9C,EACA,WAAY,IAAME,IAAe,KACjC,SAAAuB,EACA,MAAO,IAAMxB,EAAM,MAAA,EACnB,OAAQ,IAAMA,EAAM,OAAA,EACpB,SAAU,IAAMA,EAAM,SAAA,EACtB,aAAevB,GAASuB,EAAM,aAAavB,CAAI,EAC/C,aAAc,IAAMuB,EAAM,aAAA,EAC1B,KAAM,IAAMkC,GAAO,WAAW,EAC9B,SAAU,CACR,GAAIjC,IAAe,KAAM,CACvBS,EAAYA,IAAc,EAAI,GAAK,EACnCoB,EAAepB,EAAY,EAC3BmC,EAAA,EACA,MACF,CAEAG,EAAezC,EAAWT,EAAM,SAAA,EAAY,EAAI,CAClD,EACA,OAAOqD,EAAI,CACT,GAAIlD,IAAe,KAAM,OACzBtD,EAAWoC,EAAMoE,EAAK,IAAM,EAAGhH,CAAS,EACxC,MAAMK,EAAIyD,EAAW,KAAKtD,CAAQ,EAClCmD,EAAM,MAAMY,EAAY,EAAI,CAAE,SAAUlE,EAAE,SAAU,SAAU,CAACA,EAAE,QAAA,EAAaA,CAAC,CACjF,EACA,aAAc,CACZ,OAAImD,EAAgB,EAChBM,IAAe,KAAa9D,GAAa,EAAI,EAAI4C,EAAMpC,EAAWR,EAAW,EAAG,CAAC,EAC9E2G,GAAA,CACT,EACA,OAAQ,KAAO7C,IAAe,KAAOtD,EAAW2D,GAAgB,IAChE,QAAS,IAAMW,EAAgB,IAC/B,WAAY,IAAOhB,IAAe,KAAO9D,EAAY,IAAO,OAC5D,SAAU,IAAM,CAACwD,GAAW,CAACK,EAAM,SAAA,EACnC,UAAW,IAAMkB,EACjB,eAAgB,CACd,GAAIvB,EAAS,MAAO,GACpB,MAAMyD,EAAS/B,EAAA,EACTgC,EAAQD,IAAW,OAAY,OAAYjC,EAAUiC,EAE3D,OAAIC,IAAU,QAAa,CAAC,OAAO,SAASA,CAAK,GAAKA,GAAS,EACzDpD,IAAe,KAAa9D,GAAa,EAAI,EAAI4C,EAAMpC,EAAWR,EAAW,EAAG,CAAC,EAC9E2G,GAAA,EAEF/D,EAAMkC,EAAgBoC,EAAO,EAAG,CAAC,CAC1C,EACA,YAAa,IAAMlC,EAAU,IAC7B,WAAY,CACV,MAAMiC,EAAS/B,EAAA,EACf,OAAO+B,IAAW,QAAa,CAAC,OAAO,SAASA,CAAM,EAAI,QAAajC,EAAUiC,GAAU,GAC7F,EACA,SAAU,CACR,GAAIzD,EAAS,CACX2D,EAAAA,SAAS,2BAA4B,kFAAkF,EACvH,MACF,CACA1C,EAAiBQ,EAAA,EACjBF,EAAiB,EAGjBD,EAAgBE,EAChBJ,EAAQ,EACRe,EAAe,GACfD,EAAY,GACZD,EAAU,GACN3B,IAAe,MACjBtD,EAAW,EACX+D,EAAY,EACZZ,EAAM,MAAMG,EAAW,KAAK,CAAC,CAAC,EAC9B4C,EAAA,IAEA7B,EAAa,GACblB,EAAM,MAAM,CAAE,SAAUS,EAAW,SAAU,EAAG,EAChDyC,EAAexC,EAAgB,EAAG,EAAK,GAEzCuB,EAAkBjC,EAAM,IAAA,EACxBE,EAAM,OAAA,CACR,EACA,UAAU3C,EAAQ4F,EAAU,CAC1BD,EAAe3F,EAAQ4F,EAAU,EAAK,CACxC,EACA,KAAKM,EAAe,CAClB,GAAItD,IAAe,KAAM,MAAO,GAChC,GAAIJ,EAAO,WAAa,OAAW,MAAO,GAC1C,MAAM2D,EAAO3D,EAAO,SACdlE,EAAW4H,IAAkB,OAAY,OAAY,KAAK,KAAKA,EAAgB,IAAOpI,CAAC,EACvFqH,EAAwB,CAAE,SAAU1C,EAAM,MAAO,SAAUA,EAAM,UAAS,EAC1E2D,EAA2D,CAAA,EAC7D5D,EAAO,WAAa,SAAW4D,EAAc,SAAW5D,EAAO,UAC/DlE,IAAa,SAAW8H,EAAc,SAAW9H,GACrD,MAAMuB,EAAa7B,GAAOmI,EAAMhB,EAAMiB,CAAa,EACnD,OAAIvG,IAAe,MACjBoG,EAAAA,SAAS,uBAAwB,8DAA8D,EACxF,KAETrD,EAAahD,GAAcC,CAAU,EACrCf,EAAYe,EAAW,UACvBP,EAAW,EACX+D,EAAY,EACZR,EAAa,KACb2C,EAAA,EACO,GACT,CAAA,CAEJ,CAGA,SAASa,GAAc5D,EAAmBC,EAAkB4D,EAA+B,CACzF,OAAA7D,EAAM,MAAM,CAAE,SAAU6D,EAAU,SAAU,EAAG,EACxC,CACL,KAAA5D,EACA,WAAY,IAAM,GAClB,SAAU,QAAQ,QAAA,EAClB,MAAO,IAAM,CAAC,EACd,OAAQ,IAAM,CAAC,EACf,SAAU,IAAM,GAChB,aAAc,IAAM,CAAC,EACrB,aAAc,IAAM,EACpB,KAAM,IAAM,CAAC,EACb,QAAS,IAAM,CAAC,EAChB,OAAQ,IAAM,CAAC,EACf,YAAa,IAAM,EACnB,OAAQ,IAAM,EACd,QAAS,IAAM,EACf,WAAY,IAAM,EAClB,SAAU,IAAM,GAChB,UAAW,IAAM,EACjB,cAAe,IAAM,EACrB,QAAS,IAAM,CAAC,EAChB,YAAa,IAAM,EACnB,UAAW,IAAM,EACjB,UAAY1C,GAAWyC,EAAM,MAAM,CAAE,SAAUzC,EAAQ,SAAU,EAAG,EACpE,KAAM,IAAM,EAAA,CAEhB,CAGA,SAASuG,EAAYC,EAAuBC,EAA6D,CACvG,MAAMC,EAAyB,CAC7B,KAAMF,EAAS,KACf,cAAcG,EAAOC,EAAI,CACvB,OAAAH,EAAS,IAAIE,EAAOC,CAAE,EACfF,CACT,EACA,IAAI,UAAW,CACb,OAAOF,EAAS,WAAA,CAClB,EACA,SAAUA,EAAS,SACnB,KAAMK,EAAAA,aAAaL,EAAS,QAAQ,EACpC,KAAM,IAAMA,EAAS,KAAA,EACrB,OAAQ,CACN,OAAAA,EAAS,MAAA,EACF,IACT,EACA,MAAO,CACL,OAAAA,EAAS,OAAA,EACF,IACT,EACA,QAAS,CACP,OAAAA,EAAS,OAAA,EACF,IACT,EACA,SAAU,IAAMA,EAAS,SAAA,EACzB,UAAUpF,EAAwC,CAChD,OAAIA,IAAS,OAAkBoF,EAAS,aAAA,GACxCA,EAAS,aAAapF,CAAI,EACnBsF,EACT,EACA,SAAU,CACR,OAAAF,EAAS,QAAA,EACF,IACT,EACA,KAAKM,EAAgB,CACnB,OAAKN,EAAS,cAIdA,EAAS,OAAOM,CAAM,EACf,OAJLb,EAAAA,SAAS,qBAAsB,iEAAiE,EACzF,KAIX,EACA,SAASc,EAAqC,CAC5C,GAAIA,IAAM,OAAW,OAAOP,EAAS,YAAA,EACrC,GAAI,CAACA,EAAS,aACZP,OAAAA,EAAAA,SAAS,qBAAsB,iEAAiE,EACzFS,EAET,MAAMM,EAAWR,EAAS,WAAA,GAAgB,EAC1C,OAAAA,EAAS,OAAO9E,EAAMqF,EAAG,EAAG,CAAC,EAAIC,CAAQ,EAClCN,CACT,EACA,KAAM,IAAMF,EAAS,OAAA,EACrB,UAAW,IAAMA,EAAS,QAAA,EAC1B,SAAU,IAAMA,EAAS,WAAA,EACzB,SAAU,IAAMA,EAAS,SAAA,EACzB,UAAW,IAAMA,EAAS,UAAA,EAC1B,cAAe,IAAMA,EAAS,cAAA,EAC9B,UAAW,IAAMA,EAAS,YAAA,EAC1B,QAAS,IAAMA,EAAS,UAAA,EACxB,SAAU,CACR,OAAAA,EAAS,QAAA,EACF,IACT,EACA,KAAOrI,GAAYqI,EAAS,KAAKrI,GAAA,YAAAA,EAAS,aAAa,EACvD,UAAUsE,EAAetE,EAAiC,CACxD,OAAIqI,EAAS,cACXP,EAAAA,SAAS,8BAA+B,kEAAkE,EACnG,OAETO,EAAS,UAAU/D,EAAOtE,GAAA,YAAAA,EAAS,QAAQ,EACpC,KACT,CAAA,EAEF,OAAOuI,CACT,CAEO,SAASO,EAASxE,EAAmBtE,EAA2B,GAAmB,CACxF,MAAM+I,EAAY/I,EAAQ,WAAagC,qBAAA,EAEvC,MAAO,CACL,OAAOH,EAAQmH,EAAgB,GAAI,CACjC,MAAMV,EAAWW,EAAAA,kBAAA,EACjBX,EAAS,KAAKU,CAAa,EAC3B,IAAIT,EACJ,MAAMpC,EAAa,CAACqC,EAAOlE,IAAUgE,EAAS,KAAKE,EAAOD,EAAQjE,CAAK,EACjEhE,EAAyB,CAC7B,SAAUgE,EAAM,IAAA,EAChB,SAAU0E,EAAc,UAAY1E,EAAM,SAAA,CAAS,EAErD,GAAInB,GAAW6F,EAAc,aAAa,EACxC,OAAAT,EAASH,EACPF,GAAc5D,EAAO,UAAWV,GAAatD,EAAM,SAAUuB,EAAQmH,CAAa,CAAC,EACnFV,CAAA,EAEFnC,EAAK,QAAS7B,EAAM,KAAK,EACzB6B,EAAK,WAAY7B,EAAM,KAAK,EACrBiE,EAET,IAAIxB,EAAMlF,EACV,OAAA0G,EAASH,EACPhE,GAAS,CACP,MAAAE,EACA,UAAAyE,EACA,KAAM,UACN,MAAAzI,EACA,OAAQ0I,EAAc,QAAU,GAChC,UAAWA,EAAc,WAAa,EACtC,SAAU,IAAME,EAAAA,iBAAiBC,EAAAA,iBAAiBpC,EAAKiC,CAAa,CAAC,EACrE,aAAeI,GAAS,CACtBrC,EAAMqC,CACR,EACA,UAAW9I,EAAM,SACjB,cAAeuB,EACf,SAAU,GACV,KAAAsE,EACA,GAAG1C,GAAauF,CAAa,CAAA,CAC9B,EACDV,CAAA,EAEKC,CACT,EACA,MAAMc,EAAe,GAAI,CACvB,MAAMf,EAAWW,EAAAA,kBAAA,EACjBX,EAAS,KAAKe,CAAY,EAC1B,IAAId,EACJ,MAAMpC,EAAa,CAACqC,EAAOlE,IAAUgE,EAAS,KAAKE,EAAOD,EAAQjE,CAAK,EACjEhE,EAAyB,CAC7B,SAAUgE,EAAM,IAAA,EAChB,SAAU+E,EAAa,UAAY/E,EAAM,SAAA,CAAS,EAEpD,GAAInB,GAAWkG,EAAa,aAAa,EAAG,CAC1C,MAAMC,EAAQrF,GAAgBiF,EAAAA,iBAAiBK,EAAAA,gBAAgBF,CAAY,CAAC,EAAG/I,CAAK,EACpF,OAAAiI,EAASH,EAAYF,GAAc5D,EAAO,UAAWgF,EAAM,QAAQ,EAAGhB,CAAQ,EAC9EnC,EAAK,QAAS7B,EAAM,KAAK,EACzB6B,EAAK,WAAY7B,EAAM,KAAK,EACrBiE,CACT,CACA,OAAAA,EAASH,EACPhE,GAAS,CACP,MAAAE,EACA,UAAAyE,EACA,KAAM,UACN,MAAAzI,EACA,OAAQ+I,EAAa,QAAU,GAC/B,UAAWA,EAAa,WAAa,EACrC,SAAU,IAAMH,EAAAA,iBAAiBK,EAAAA,gBAAgBF,CAAY,CAAC,EAC9D,UAAW/I,EAAM,SACjB,SAAU,GACV,KAAA6F,CAAA,CACD,EACDmC,CAAA,EAEKC,CACT,EACA,GAAG1G,EAAQ2H,EAAY,GAAI,CACzB,MAAMlB,EAAWW,EAAAA,kBAAA,EACjBX,EAAS,KAAKkB,CAAS,EACvB,IAAIjB,EACJ,MAAMpC,EAAa,CAACqC,EAAOlE,IAAUgE,EAAS,KAAKE,EAAOD,EAAQjE,CAAK,EACjET,EAAOS,EAAM,IAAA,EACbvD,EAAS0I,EAAAA,YAAY5F,EAAMhC,EAAQ2H,CAAS,EAClD,OAAIrG,GAAWqG,EAAU,aAAa,GACpCjB,EAASH,EAAYF,GAAc5D,EAAO,WAAYV,GAAaC,EAAMhC,EAAQ2H,CAAS,CAAC,EAAGlB,CAAQ,EACtGnC,EAAK,QAAS7B,EAAM,KAAK,EACzB6B,EAAK,WAAY7B,EAAM,KAAK,EACrBiE,IAETA,EAASH,EACPhE,GAAS,CACP,MAAAE,EACA,UAAAyE,EACA,KAAM,WACN,MAAO,CAAE,SAAUlF,EAAM,SAAU,CAAA,EACnC,OAAQ2F,EAAU,QAAU,GAC5B,UAAWA,EAAU,WAAa,EAClC,WAAYzI,EACZ,KAAAoF,EACA,GAAG1C,GAAa+F,CAAS,CAAA,CAC1B,EACDlB,CAAA,EAEKC,EACT,CAAA,CAEJ,CC3oBA,MAAMhF,GAAQ,CAACC,EAAWjC,EAAYC,IAAuB,KAAK,IAAI,KAAK,IAAIgC,EAAGjC,CAAE,EAAGC,CAAE,EAQlF,SAASkI,GAAYC,EAA8B1I,EAAuBsD,EAAkC,CACjH,MAAMqF,EAAYD,EAAU,UACtBE,EAAaF,EAAU,WAC7B,IAAIzH,EAAS,GACT4H,EAAO,GACN7I,EAAK,SAAS,KAAK,IAAM,CAC5B6I,EAAO,EACT,CAAC,EACD,MAAMC,EAAc,IAAeF,GAAc,EAAI,EAAItG,GAAM,OAAOqG,EAAU,aAAe,CAAC,EAAIC,EAAY,EAAG,CAAC,EAE9GtB,EAAyB,CAC7B,KAAAhE,EACA,SAAU,GACV,SAAUtD,EAAK,SACf,KAAMyH,EAAAA,aAAazH,EAAK,QAAQ,EAChC,KAAM,IAAMA,EAAK,KAAA,EACjB,OAAQ,OACN,OAAA6B,EAAA8G,EAAU,QAAV,MAAA9G,EAAA,KAAA8G,GACA1H,EAAS,GACF,IACT,EACA,MAAO,OACL,OAAAY,EAAA8G,EAAU,OAAV,MAAA9G,EAAA,KAAA8G,GACA1H,EAAS,GACF,IACT,EACA,QAAS,CACP,OAAO,KAAK,KAAA,CACd,EACA,SAAU,IAAMA,EAChB,UAAUe,EAAwC,CAChD,OAAIA,IAAS,OAAkB2G,EAAU,cAAgB,GACzDA,EAAU,aAAe3G,EAClBsF,EACT,EACA,SAAU,CACR,OAAAqB,EAAU,aAAe,EAAEA,EAAU,cAAgB,GAC9C,IACT,EACA,KAAKjB,EAAgB,CACnB,OAAAiB,EAAU,YAAcrG,GAAMoF,EAAQ,EAAGkB,CAAU,EAC5C,IACT,EACA,SAASjB,EAAqC,CAC5C,OAAIA,IAAM,OAAkBmB,EAAA,GAC5BH,EAAU,YAAcrG,GAAMqF,EAAG,EAAG,CAAC,EAAIiB,EAClCtB,EACT,EACA,KAAM,IAAM,OAAOqB,EAAU,aAAe,CAAC,EAC7C,UAAW,IAAM,OAAOA,EAAU,aAAe,CAAC,EAClD,SAAU,IAAMC,EAChB,SAAU,IAAM,CAACC,GAAQ,CAAC5H,EAC1B,UAAW,IAAM,EACjB,cAAe,IAAM6H,EAAA,EACrB,UAAW,IAAM,EACjB,QAAS,IAAMF,EACf,SAAU,OACR,OAAAD,EAAU,YAAc,GACxB9G,EAAA8G,EAAU,OAAV,MAAA9G,EAAA,KAAA8G,GACA1H,EAAS,GACF,IACT,EACA,KAAM,IAAM,GACZ,WAAY,CACV4F,OAAAA,EAAAA,SAAS,8BAA+B,wDAAwD,EACzF,IACT,CAAA,EAEF,OAAOS,CACT,CCtEA,SAASyB,GAAYxF,EAAkBvD,EAAuBsD,EAAkC,CAC9F,IAAIuF,EAAO,GACN7I,EAAK,SAAS,KAAK,IAAM,CAC5B6I,EAAO,EACT,CAAC,EACD,MAAMvB,EAAyB,CAC7B,KAAAhE,EACA,SAAU,GACV,SAAUtD,EAAK,SACf,KAAMyH,EAAAA,aAAazH,EAAK,QAAQ,EAChC,KAAM,IAAMA,EAAK,KAAA,EACjB,OAAQ,CACN,OAAAuD,EAAM,MAAA,EACC,IACT,EACA,MAAO,CACL,OAAAA,EAAM,OAAA,EACC,IACT,EACA,QAAS,CACP,OAAAA,EAAM,OAAA,EACC,IACT,EACA,SAAU,IAAMA,EAAM,SAAA,EACtB,UAAUvB,EAAwC,CAChD,OAAIA,IAAS,OAAkBuB,EAAM,aAAA,GACrCA,EAAM,aAAavB,CAAI,EAChBsF,EACT,EACA,SAAU,CACRT,OAAAA,EAAAA,SAAS,sBAAuB,4EAA4E,EACrG,IACT,EACA,MAAO,CACLA,OAAAA,EAAAA,SAAS,qBAAsB,4DAA4D,EACpF,IACT,EACA,SAASc,EAAqC,CAC5C,OAAIA,IAAM,OAAkB,GAC5Bd,EAAAA,SAAS,qBAAsB,4DAA4D,EACpFS,EACT,EACA,KAAM,IAAM,EACZ,UAAW,IAAM,EACjB,SAAU,IAAA,GACV,SAAU,IAAM,CAACuB,GAAQ,CAACtF,EAAM,SAAA,EAChC,UAAW,IAAM,EACjB,cAAe,IAAOsF,EAAO,EAAI,EACjC,UAAW,IAAM,EACjB,QAAS,IAAA,GACT,SAAU,CACRhC,OAAAA,EAAAA,SAAS,uBAAwB,8EAA8E,EACxG,IACT,EACA,KAAM,IAAM,GACZ,WAAY,CACVA,OAAAA,EAAAA,SAAS,yBAA0B,wEAAwE,EACpG,IACT,CAAA,EAEF,OAAOS,CACT,CASO,SAAS0B,GACdC,EACAC,EACAnK,EAA4C,CAAA,EAC5B,UACZA,EAAQ,SAAW,QAAaA,EAAQ,QAAU,QAAaA,EAAQ,OAAS,KAClF8H,EAAAA,SAAS,sBAAuB,wEAAwE,EAG1G,MAAMsC,EAAepK,EAAQ,YAAc,OAAY,CAAE,UAAWA,EAAQ,SAAA,EAAc,CAAA,EACpFwE,EAAQ1C,EAAUsI,CAAY,EAC9BnJ,EAAOoJ,EAAAA,QAAQH,EAASC,EAAS,CAAE,GAAGnK,EAAS,UAAWwE,EAAO,EAEjED,EAAmBvE,EAAQ,WAAa,OAAY,WAAa,UACjE2J,EAAYW,EAAAA,eAAeJ,CAAO,EAExC,OAAIP,IAAc,MACZ3J,EAAQ,YAAc,SAAW2J,EAAU,UAAU,aAAe3J,EAAQ,WAC5EA,EAAQ,SAAW,MACrBuK,GAAAzH,EAAA6G,EAAU,WAAU,QAApB,MAAAY,EAAA,KAAAzH,IAEK4G,GAAYC,EAAW1I,EAAMsD,CAAI,IAGtCvE,EAAQ,YAAc,QAAWwE,EAAM,aAAaxE,EAAQ,SAAS,EACrEA,EAAQ,SAAW,IAAMwE,EAAM,MAAA,EAC5BwF,GAAYxF,EAAOvD,EAAMsD,CAAI,EACtC,CCvFA,MAAM5E,EAAIC,GAAAA,sBAQH,SAAS4K,GAAOzK,EAAiBC,EAAyB,GAAY,CAC3E,MAAM+I,EAAY/I,EAAQ,WAAagC,qBAAA,EACjCsC,EAAQmG,EAAAA,WAAW1K,EAAS,CAAE,UAAAgJ,EAAW,EAEzC2B,EAAY1K,EAAQ,WAAa,IACjC2K,EAAO3K,EAAQ,MAAQ,EAEvB4K,EAAU5K,EAAQ,SAAW,EAAI,KAAK,KAAK0K,EAAYC,CAAI,EAC3DE,EAAM1B,EAAAA,iBAAiBpJ,EAAS,CAAE,GAAGC,EAAS,UAAA0K,EAAW,QAAAE,EAAS,KAAAD,EAAM,EACxE5J,EAASmI,EAAAA,iBAAiB2B,CAAG,EAEnC,IAAIC,EAAa/K,EACb4E,EAAwB,CAAE,SAAU5E,EAAS,SAAU,CAAA,EACvD6E,EAAwBD,EACxBE,EAAe,EACfqB,EAAmC,KACnC6E,EAAW,GAEf,MAAMC,EAAU,CAAC,CAAE,QAAA5D,KAAmC,CAEpD,IADAvC,GAAgBuC,EAAU,IACnBvC,GAAgBlF,GAAG,CACxBkF,GAAgBlF,EAChBgF,EAAOC,EACPA,EAAO7D,EAAO,KAAK6D,EAAMjF,CAAC,EAC1B,MAAMe,EAASK,EAAO,KAAK6D,CAAI,EAC/B,GAAIlE,IAAW,KAAM,CACnB4D,EAAM,MAAM,CAAE,SAAU5D,EAAQ,SAAU,EAAG,EAC7CwF,GAAA,MAAAA,IACAA,EAAc,KACd,MACF,CACF,CACA,MAAM5E,EAAQuD,EAAelF,EAC7B2E,EAAM,MAAM,CACV,SAAUK,EAAK,UAAYC,EAAK,SAAWD,EAAK,UAAYrD,EAC5D,SAAUqD,EAAK,UAAYC,EAAK,SAAWD,EAAK,UAAYrD,CAAA,CAC7D,CACH,EAEM2J,EAAgB,IAAM,CACtB/E,IAAgB,MAAQ,CAAC6E,IAAU7E,EAAc6C,EAAU,UAAUiC,CAAO,EAClF,EAEA,MAAO,CACL,MAAA1G,EACA,OAAO8E,EAAM,CACPA,IAAS0B,IACbA,EAAa1B,EACbyB,EAAI,SAASzB,CAAI,EAEjBxE,EAAO,CAAE,SAAUN,EAAM,IAAA,EAAO,SAAUA,EAAM,UAAS,EACzDK,EAAOC,EACPC,EAAe,EACfoG,EAAA,EACF,EACA,MAAO,CACL/E,GAAA,MAAAA,IACAA,EAAc,IAChB,EACA,SAAU,CACR6E,EAAW,GACX7E,GAAA,MAAAA,IACAA,EAAc,KACd5B,EAAM,QAAA,CACR,CAAA,CAEJ,CCZA,MAAM4G,GAAO,CAACvD,EAAYoB,EAAsBoC,IAAqC,CACnF,IAAIC,EAAY,EAChB,MAAMlF,EAAc6C,EAAU,UAAU,CAAC,CAAE,QAAA3B,KAAyB,CAClEgE,GAAahE,EACTgE,GAAazD,IACfzB,EAAA,EACAiF,EAAA,EAEJ,CAAC,EACD,OAAOjF,CACT,EAEO,SAASmF,GAAerL,EAA2B,GAAc,CACtE,MAAMsL,EAAc,CAAA,EACdC,EAAWvL,EAAQ,UAAY,CAAA,EAErC,IAAIwE,EAA0B,KAC1BlC,EAAgD,OAChDkJ,EAAe,EACfC,EAAY,EAChB,MAAM7D,MAAa,IACb8D,MAAoB,IACpBC,MAAc,IAEpB,IAAI5F,EAA8B,IAAM,CAAC,EACrC6F,EAAkB,IAAI,QAAe3F,GAAY,CACnDF,EAAkBE,CACpB,CAAC,EAED,MAAM4F,EAAc,IAAiB,CACnC,GAAIrH,IAAU,KAAM,CAClB,MAAMsH,EAAsE,CAC1E,UAAW9L,EAAQ,WAAa,EAChC,OAAQ,EAAA,EAENA,EAAQ,YAAc,SAAW8L,EAAK,UAAY9L,EAAQ,WAC9DwE,EAAQ1C,EAAUgK,CAAI,CACxB,CACA,OAAOtH,CACT,EAIMuH,EAAiBrI,GAAyB,CAC9C,MAAMsI,EAAS,CAAE,GAAGT,EAAU,GAAG7H,CAAA,EACjC,MAAI,YAAasI,GAAQ,OAAOA,EAAO,QAChCA,CACT,EACMC,EAAavI,GAAkCA,EAAE,UAAY,OAAY,KAAOA,EAAE,QAElFwI,EAAY,IAAY,CACxB5J,IAAU,WACVkJ,GAAgBF,EAAK,QAAUG,GAAaH,EAAK,SACnDhJ,EAAQ,OACRkC,GAAA,MAAAA,EAAO,QACPuB,EAAA,EAEJ,EAEMoG,EAAY,GAAoB,CACpC,GAAI7J,IAAU,WAAa,IAAMkJ,EAAc,OAC/C,MAAMY,EAAMd,EAAK,CAAC,EAClB,GAAIc,IAAQ,OAAW,OAKvB,GAJAZ,EAAe,EAAI,EAIfY,EAAI,QAAU,KAAM,CACtB,MAAMC,EAAQX,EAAc,IAAIU,EAAI,KAAK,EACrCC,IAAU,SACZA,EAAM,KAAA,EACNzE,EAAO,OAAOyE,CAAK,EACnBX,EAAc,OAAOU,EAAI,KAAK,EAElC,CAEA,MAAM7D,EAAS6D,EAAI,MAAA,EACnBxE,EAAO,IAAIW,CAAM,EACb6D,EAAI,QAAU,QAAoB,IAAIA,EAAI,MAAO7D,CAAM,EAE3D,IAAI+D,EAAU,GACT/D,EAAO,SAAS,KAAK,IAAM,CAC1B+D,IACJA,EAAU,GACV1E,EAAO,OAAOW,CAAM,EAChB6D,EAAI,QAAU,MAAQV,EAAc,IAAIU,EAAI,KAAK,IAAM7D,GAAQmD,EAAc,OAAOU,EAAI,KAAK,EACjGX,GAAa,EACbS,EAAA,EACF,CAAC,EAED,MAAM9C,EAAOkC,EAAK,EAAI,CAAC,EACvB,GAAIlC,IAAS,OAAW,CACtB8C,EAAA,EACA,MACF,CACI9C,EAAK,UAAY,KAAMuC,EAAQ,IAAIT,GAAK9B,EAAK,QAASyC,EAAA,EAAe,IAAMM,EAAS,EAAI,CAAC,CAAC,CAAC,EACrF5D,EAAO,SAAS,KAAK,IAAM4D,EAAS,EAAI,CAAC,CAAC,CACtD,EAEMI,EAAW,IAAY,CAC3Bf,EAAe,EACfC,EAAY,EACZ7D,EAAO,MAAA,EACP8D,EAAc,MAAA,EACd,UAAWc,KAAUb,EAASa,EAAA,EAE9B,GADAb,EAAQ,MAAA,EACJL,EAAK,SAAW,EAAG,CACrBhJ,EAAQ,OACRyD,EAAA,EACA,MACF,CACAzD,EAAQ,UACRuJ,EAAA,EAAc,OAAA,EACdM,EAAS,CAAC,CACZ,EAEMM,EAAM,CACV,KAAM,WACN,SAAU,GACV,IAAI,UAAW,CACb,OAAOb,CACT,EACA,KACEc,EACAC,EACkB,CAClB,OAAOf,EAAgB,KAAKc,GAAe,OAAWC,GAAc,MAAS,CAC/E,EAEA,OAAOrI,EAAmBzC,EAAgB6B,EAAsB,CAAA,EAAI,CAClE,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAAY,EACA,MAAO,IAAMwE,EAASxE,EAAO,CAAE,UAAWuH,GAAY,CAAG,EAAE,OAAOhK,EAAQkK,EAAWrI,CAAC,CAAC,CAAA,CACxF,EACM+I,CACT,EACA,GAAGnI,EAAmBzC,EAAgB6B,EAAkB,CAAA,EAAI,CAC1D,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAAY,EACA,MAAO,IAAMwE,EAASxE,EAAO,CAAE,UAAWuH,GAAY,CAAG,EAAE,GAAGhK,EAAQkK,EAAWrI,CAAC,CAAC,CAAA,CACpF,EACM+I,CACT,EACA,KAAKnI,EAAmBwC,EAAepD,EAAkB,CAAA,EAAI,CAC3D,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAAY,EACA,MAAO,IAAM,CACX,MAAMsI,EAAOtI,EAAM,IAAA,EACnB,OAAAA,EAAM,IAAIwC,CAAK,EACRgC,EAASxE,EAAO,CAAE,UAAWuH,EAAA,EAAe,EAAE,GAAGe,EAAMb,EAAWrI,CAAC,CAAC,CAC7E,CAAA,CACD,EACM+I,CACT,EACA,OAAOnI,EAAmBwC,EAAejF,EAAgB6B,EAAkB,CAAA,EAAI,CAC7E,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAAY,EACA,MAAO,KACLA,EAAM,IAAIwC,CAAK,EACRgC,EAASxE,EAAO,CAAE,UAAWuH,EAAA,EAAe,EAAE,GAAGhK,EAAQkK,EAAWrI,CAAC,CAAC,EAC/E,CACD,EACM+I,CACT,EACA,MAAMnI,EAAmBZ,EAAqB,GAAI,CAChD,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAAY,EACA,MAAO,IAAMwE,EAASxE,EAAO,CAAE,UAAWuH,EAAA,CAAY,CAAG,EAAE,MAAME,EAAWrI,CAAC,CAAC,CAAA,CAC/E,EACM+I,CACT,EACA,IAAIhM,EAA6BiD,EAAgB,GAAI,CACnD,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAO,KACP,MAAO,IAAM,CACX,MAAM6E,EAAS9H,EAAA,EACf,MAAO,CAAE,SAAU8H,EAAO,SAAU,KAAM,IAAMA,EAAO,MAAK,CAC9D,CAAA,CACD,EACMkE,CACT,EACA,KAAKhE,EAAgB/E,EAAgB,GAAI,CACvC,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAO,KACP,MAAO,KACL+E,EAAA,EACO,CAAE,SAAU,QAAQ,QAAA,EAAW,KAAM,IAAM,CAAC,CAAA,EACrD,CACD,EACMgE,CACT,EACA,QAAQI,EAA2BC,EAA0DpJ,EAAsB,CACjH,OAAA4H,EAAK,KAAK,CACR,QAASW,EAAUvI,CAAC,EACpB,MAAO,KACP,MAAO,IAAM,CACX,MAAMqJ,EAA0B,CAAA,EAC1BC,EAAiC,CAAA,EACvC,IAAIC,EAAYJ,EAAM,OAClBK,EAAyB,IAAM,CAAC,EACpC,MAAMlH,EAAW6G,EAAM,SAAW,EAAI,QAAQ,UAAY,IAAI,QAAe/G,GAAM,CACjFoH,EAAapH,CACf,CAAC,EACKqH,EAAY,CAACC,EAAeC,IAAwB,CACxD,MAAM9E,EAASuE,EAAMM,EAAMC,CAAK,EAChCN,EAAK,KAAKxE,CAAM,EACXA,EAAO,SAAS,KAAK,IAAM,CAC9B0E,GAAa,EACTA,IAAc,GAAGC,EAAA,CACvB,CAAC,CACH,EACA,OAAAL,EAAM,QAAQ,CAACO,EAAMC,IAAU,CAC7B,MAAMC,EAAQ5J,EAAE,KAAO2J,EACnBC,GAAS,EAAGH,EAAUC,EAAMC,CAAK,EAChCL,EAAY,KAAK9B,GAAKoC,EAAOzB,IAAe,IAAMsB,EAAUC,EAAMC,CAAK,CAAC,CAAC,CAChF,CAAC,EACM,CACL,SAAArH,EACA,KAAM,IAAM,CACV,UAAWwG,KAAUQ,EAAaR,EAAA,EAClC,UAAWjE,KAAUwE,EAAMxE,EAAO,KAAA,CACpC,CAAA,CAEJ,CAAA,CACD,EACMkE,CACT,EAEA,MAAO,CACL,OAAInK,IAAU,UAAkBmK,EAC5BnK,IAAU,UACZA,EAAQ,UACRkC,GAAA,MAAAA,EAAO,SACAiI,IAGTb,EAAkB,IAAI,QAAe3F,GAAY,CAC/CF,EAAkBE,CACpB,CAAC,EACDsG,EAAA,EACOE,EACT,EACA,OAAQ,CACN,OAAInK,IAAU,YACZA,EAAQ,SACRkC,GAAA,MAAAA,EAAO,SAEFiI,CACT,EACA,QAAS,CACP,OAAOA,EAAI,KAAA,CACb,EACA,UAAW,CACT,OAAOjI,GAAA,YAAAA,EAAO,aAAc,EAC9B,EACA,MAAO,CACL,UAAWgI,KAAUb,EAASa,EAAA,EAC9Bb,EAAQ,MAAA,EACR,UAAWpD,KAAUX,EAAQW,EAAO,KAAA,EACpCX,EAAO,MAAA,EACP8D,EAAc,MAAA,EACdpJ,EAAQ,OACRkC,GAAA,MAAAA,EAAO,QACPuB,EAAA,CACF,EACA,UAAU9C,EAAe,CACvB,MAAMsK,EAAK1B,EAAA,EACX,OAAI5I,IAAS,OAAkBsK,EAAG,aAAA,GAClCA,EAAG,aAAatK,CAAI,EACbwJ,EACT,CAAA,EAGF,OAAOA,CACT"}