@ansh-ui/core 0.2.0

package/dist/index.js

@@ -0,0 +1,1182 @@
+export { addScaledVec2, addVec2, addVec2Into, angleOfVec2, cloneVec2, crossVec2, distanceSqVec2, distanceVec2, dotVec2, fromAngle, lengthSqVec2, lengthVec2, lerpVec2, lerpVec2Into, limitVec2, normalizeInRect, normalizeVec2, rectContains, reflectVec2, rotateVec2, scaleVec2, scaleVec2Into, setVec2, subVec2, subVec2Into, vec2 } from './chunk-NSXKCJJ7.js';
+export { checkContrast, contrastRatio, ensureContrast, perceivedLightness, pickReadable, requiredRatio, worstContrast } from './chunk-7MYTSAPR.js';
+export { GradientCache, ParticleBuffer, SpatialGrid, ageAndCull, animatedGradient, aurora, blob, constellation, createSurface, defineEffect, drawDot, drawGlow, effects, fireflies, integrate, meshGradient, meteors, mountEffect, noiseLayer, particleField, rain, resetFilterSupport, snow, spotlight, supportsCanvasFilter, supportsOffscreenCanvas, supportsWorkerRendering, traceClosedSpline, traceOpenSpline, traceRoundRect, waves, wrapBounds } from './chunk-56NNBIAO.js';
+import { toRgbString, mixParsed } from './chunk-KTUBCQC3.js';
+export { applyGradientStops, blend, composite, createGradient, createScale, expandPalette, fadeBy, fromUint32, gamutError, gamutMapOklch, generatePalette, harmony, inSrgbGamut, invertForSurface, isGamutStable, lerpHue, maxChroma, mixColors, mixParsed, oklchToRgbMapped, palettes, resolvePalette, sortByLightness, toHex, toHslString, toOklchString, toRgbString, toUint32, withAlpha } from './chunk-KTUBCQC3.js';
+export { FRACTAL_DEFAULTS, GRAD3, GRAD4, clearNoiseTableCache, createNoise, createNoiseTables, createPerlinNoise, createSimplexNoise, createValueNoise, curl2D, curl2DAnimated, fbm2D, fbm3D, ridged2D, tileable2D, turbulence2D, warp2D } from './chunk-FAVIEION.js';
+export { createRng, deriveSeed, goldenRatioSequence, hashString, jitter, r2Sequence, weightedPick } from './chunk-YFQXRC5R.js';
+import { stagger } from './chunk-C6XPQO2O.js';
+export { behaviours, captureStyles, defineBehaviour, getSplitResult, magnetic, marquee, mountBehaviour, parallax, ripple, scrollReveal, split, splitText, stagger, staggerDuration, tilt } from './chunk-C6XPQO2O.js';
+import { now, prefersReducedMotion, getTicker, observeResize } from './chunk-BOQQHICI.js';
+export { CapabilityError, Clock, FRAME_PHASES, FrameBudget, Registry, Ticker, getReducedMotionMode, getRegistry, getTicker, now, observeIntersection, observeResize, observerPoolStats, onReducedMotionChange, prefersReducedMotion, resetObserverPools, resetReducedMotion, resetRegistry, resetTicker, resolveMotion, setReducedMotionMode, setTicker, trackPointer } from './chunk-BOQQHICI.js';
+import { parseColor, tryParseColor } from './chunk-QALZKHWH.js';
+export { ColorParseError, clearColorCache, hslToRgb, hsvToRgb, linearToOklab, linearToRgb, linearToSrgbChannel, listNamedColors, namedColorToHex, oklabToLinear, oklabToOklch, oklabToRgb, oklchToOklab, oklchToRgb, parseColor, relativeLuminance, resolveComputed, resolveCssVariable, rgbToHsl, rgbToHsv, rgbToLinear, rgbToOklab, rgbToOklch, srgbToLinearChannel, tryParseColor } from './chunk-QALZKHWH.js';
+import { resolveEasing } from './chunk-7MEIXWPH.js';
+export { anticipate, cubicBezier, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, easings, linear, listEasings, mirrorEasing, power, readEasingTable, registerEasing, resolveEasing, reverseEasing, sampleEasing, signature, steps, unregisterEasing } from './chunk-7MEIXWPH.js';
+import { clamp, lerp } from './chunk-KU2C6GEA.js';
+export { EPSILON, HALF_PI, PI, TAU, angleDelta, approximately, clamp, damp, degrees, finite, inverseLerp, lerp, lerpAngle, mean, moveTowards, percentileSorted, pingPong, radians, remap, roundTo, smootherstep, smoothstep, snap, wrap } from './chunk-KU2C6GEA.js';
+
+// src/spring/solver.ts
+var SPRING_DEFAULTS = {
+  stiffness: 170,
+  damping: 26,
+  mass: 1,
+  duration: 0.6,
+  bounce: 0,
+  restDelta: 0.01,
+  restSpeed: 0.01,
+  from: 0,
+  to: 1,
+  velocity: 0
+};
+var MAX_DURATION = 10;
+var MAX_DAMPING_RATIO = 20;
+function perceptualToPhysical(duration, bounce, mass = 1) {
+  const safeDuration = Math.max(0.01, duration);
+  const b = clamp(bounce, -1, 1);
+  const dampingRatio = b >= 0 ? 1 - b : Math.min(MAX_DAMPING_RATIO, 1 / Math.max(1 / MAX_DAMPING_RATIO, 1 + b));
+  const omega = 2 * Math.PI / safeDuration;
+  return {
+    stiffness: omega * omega * mass,
+    damping: 2 * dampingRatio * omega * mass,
+    mass
+  };
+}
+function physicalToPerceptual(stiffness, damping, mass = 1) {
+  const omega = Math.sqrt(stiffness / mass);
+  const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+  return {
+    duration: 2 * Math.PI / omega,
+    bounce: dampingRatio <= 1 ? 1 - dampingRatio : 1 / dampingRatio - 1
+  };
+}
+function createSpring(options = {}) {
+  const mass = Math.max(0.01, options.mass ?? SPRING_DEFAULTS.mass);
+  const usesPerceptual = options.duration !== void 0 || options.bounce !== void 0;
+  const { stiffness, damping } = usesPerceptual ? perceptualToPhysical(
+    options.duration ?? SPRING_DEFAULTS.duration,
+    options.bounce ?? SPRING_DEFAULTS.bounce,
+    mass
+  ) : {
+    stiffness: Math.max(0.01, options.stiffness ?? SPRING_DEFAULTS.stiffness),
+    damping: Math.max(0, options.damping ?? SPRING_DEFAULTS.damping)
+  };
+  const from = options.from ?? SPRING_DEFAULTS.from;
+  const to = options.to ?? SPRING_DEFAULTS.to;
+  const v0 = options.velocity ?? SPRING_DEFAULTS.velocity;
+  const restDelta = Math.max(1e-9, options.restDelta ?? SPRING_DEFAULTS.restDelta);
+  const restSpeed = Math.max(1e-9, options.restSpeed ?? SPRING_DEFAULTS.restSpeed);
+  const omega0 = Math.sqrt(stiffness / mass);
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  const delta = to - from;
+  let evaluate;
+  if (delta === 0 && v0 === 0) {
+    evaluate = () => ({ y: 0, dy: 0 });
+  } else if (zeta < 1 - 1e-9) {
+    const omegaD = omega0 * Math.sqrt(1 - zeta * zeta);
+    const c1 = delta;
+    const c2 = (-v0 + zeta * omega0 * delta) / omegaD;
+    evaluate = (t) => {
+      const envelope = Math.exp(-zeta * omega0 * t);
+      const cos = Math.cos(omegaD * t);
+      const sin = Math.sin(omegaD * t);
+      const y = envelope * (c1 * cos + c2 * sin);
+      const dy = envelope * (-zeta * omega0 * (c1 * cos + c2 * sin) + omegaD * (c2 * cos - c1 * sin));
+      return { y, dy };
+    };
+  } else if (zeta <= 1 + 1e-9) {
+    const c1 = delta;
+    const c2 = -v0 + omega0 * delta;
+    evaluate = (t) => {
+      const envelope = Math.exp(-omega0 * t);
+      const y = envelope * (c1 + c2 * t);
+      const dy = envelope * (c2 - omega0 * (c1 + c2 * t));
+      return { y, dy };
+    };
+  } else {
+    const s = omega0 * Math.sqrt(zeta * zeta - 1);
+    const c1 = delta;
+    const c2 = (-v0 + zeta * omega0 * delta) / s;
+    evaluate = (t) => {
+      const envelope = Math.exp(-zeta * omega0 * t);
+      const cosh = Math.cosh(s * t);
+      const sinh = Math.sinh(s * t);
+      const y = envelope * (c1 * cosh + c2 * sinh);
+      const dy = envelope * (-zeta * omega0 * (c1 * cosh + c2 * sinh) + s * (c1 * sinh + c2 * cosh));
+      return { y, dy };
+    };
+  }
+  const at = (t) => {
+    if (t <= 0) return { position: from, velocity: v0, done: false };
+    const { y, dy } = evaluate(t);
+    const position = to - y;
+    const velocity = -dy;
+    const done = Math.abs(y) <= restDelta && Math.abs(velocity) <= restSpeed;
+    return done ? { position: to, velocity: 0, done: true } : { position, velocity, done: false };
+  };
+  return {
+    at,
+    duration: estimateDuration(at),
+    dampingRatio: zeta,
+    angularFrequency: omega0
+  };
+}
+function estimateDuration(at) {
+  const STEP = 1 / 60;
+  let t = 0;
+  let previous = 0;
+  while (t < MAX_DURATION) {
+    previous = t;
+    t += STEP;
+    if (at(t).done) break;
+  }
+  if (t >= MAX_DURATION) return MAX_DURATION;
+  let low = previous;
+  let high = t;
+  for (let i = 0; i < 12; i++) {
+    const mid = (low + high) / 2;
+    if (at(mid).done) high = mid;
+    else low = mid;
+  }
+  return high;
+}
+function createDecay(options = {}) {
+  const from = options.from ?? 0;
+  const velocity = options.velocity ?? 0;
+  const power2 = options.power ?? 0.8;
+  const timeConstant = options.timeConstant ?? 0.325;
+  const restDelta = options.restDelta ?? 0.5;
+  const amplitude = power2 * velocity;
+  let target = from + amplitude;
+  if (options.min !== void 0) target = Math.max(options.min, target);
+  if (options.max !== void 0) target = Math.min(options.max, target);
+  const resolvedAmplitude = target - from;
+  const at = (t) => {
+    if (t <= 0) return { position: from, velocity, done: false };
+    const decayFactor = Math.exp(-t / timeConstant);
+    const position = target - resolvedAmplitude * decayFactor;
+    const currentVelocity = resolvedAmplitude / timeConstant * decayFactor;
+    const done = Math.abs(target - position) <= restDelta;
+    return done ? { position: target, velocity: 0, done: true } : { position, velocity: currentVelocity, done: false };
+  };
+  return { at, duration: estimateDuration(at), target };
+}
+
+// src/spring/presets.ts
+var springs = {
+  /** No overshoot, quick. The safe default for UI state changes. */
+  default: { duration: 0.5, bounce: 0 },
+  /** Fast and crisp. Menus, dropdowns, toggles. */
+  snappy: { duration: 0.35, bounce: 0.15 },
+  /** Lively overshoot. Playful confirmations, likes, badges. */
+  bouncy: { duration: 0.6, bounce: 0.4 },
+  /** Slow, deliberate, weighty. Large surfaces and sheets. */
+  heavy: { duration: 0.9, bounce: -0.2 },
+  /** Barely-there motion for micro-interactions. */
+  subtle: { duration: 0.25, bounce: 0 },
+  /** Long, luxurious settle. Hero content and page transitions. */
+  cinematic: { duration: 1.2, bounce: 0.1 },
+  /** Rubber-band feel for drag release. */
+  elastic: { duration: 0.8, bounce: 0.65 },
+  /** Molasses. Deliberately sluggish — use for depth cues, not for controls. */
+  molasses: { duration: 1.6, bounce: -0.4 }
+};
+function resolveSpringOptions(input) {
+  if (input === void 0) return springs.default;
+  if (typeof input === "string") return springs[input] ?? springs.default;
+  return input;
+}
+
+// src/kernel/lifecycle.ts
+function attachLifecycle(ticker, options = {}) {
+  if (typeof document === "undefined" || typeof window === "undefined") return () => {
+  };
+  const pauseWhenHidden = options.pauseWhenHidden ?? true;
+  const pauseWhenBlurred = options.pauseWhenBlurred ?? false;
+  const respectBattery = options.respectBattery ?? true;
+  const threshold = options.batteryThreshold ?? 0.2;
+  const saveQuality = options.batterySaveQuality ?? 0.5;
+  const cleanups = [];
+  if (pauseWhenHidden) {
+    const onVisibility = () => {
+      if (document.hidden) ticker.pause("document-hidden");
+      else ticker.resume("document-hidden");
+    };
+    document.addEventListener("visibilitychange", onVisibility);
+    cleanups.push(() => document.removeEventListener("visibilitychange", onVisibility));
+    onVisibility();
+  }
+  if (pauseWhenBlurred) {
+    const onBlur = () => ticker.pause("window-blurred");
+    const onFocus = () => ticker.resume("window-blurred");
+    window.addEventListener("blur", onBlur);
+    window.addEventListener("focus", onFocus);
+    cleanups.push(() => {
+      window.removeEventListener("blur", onBlur);
+      window.removeEventListener("focus", onFocus);
+    });
+  }
+  if (respectBattery) {
+    const getBattery = navigator.getBattery;
+    if (typeof getBattery === "function") {
+      let battery = null;
+      let disposed = false;
+      const apply = () => {
+        if (!battery) return;
+        const saving = !battery.charging && battery.level <= threshold;
+        if (saving) ticker.lockQuality(saveQuality);
+      };
+      getBattery.call(navigator).then((manager) => {
+        if (disposed) return;
+        battery = manager;
+        manager.addEventListener("levelchange", apply);
+        manager.addEventListener("chargingchange", apply);
+        cleanups.push(() => {
+          manager.removeEventListener("levelchange", apply);
+          manager.removeEventListener("chargingchange", apply);
+        });
+        apply();
+      }).catch(() => {
+      });
+      cleanups.push(() => {
+        disposed = true;
+      });
+    }
+  }
+  return () => {
+    for (const cleanup of cleanups) cleanup();
+    cleanups.length = 0;
+  };
+}
+
+// src/motion/motion-value.ts
+var VELOCITY_SAMPLE_WINDOW_MS = 100;
+var MotionValue = class {
+  current;
+  previous;
+  listeners = /* @__PURE__ */ new Set();
+  renderListeners = /* @__PURE__ */ new Set();
+  /** Timestamp and value of the last update, for velocity. */
+  lastUpdated = 0;
+  lastValue;
+  velocityValue = 0;
+  /** Set while an `animate()` drives this value, so a new animation can cancel the old one. */
+  stopAnimation = null;
+  constructor(initial) {
+    this.current = initial;
+    this.previous = initial;
+    this.lastValue = initial;
+    this.lastUpdated = now();
+  }
+  get() {
+    return this.current;
+  }
+  getPrevious() {
+    return this.previous;
+  }
+  /**
+   * Write a new value and notify subscribers.
+   *
+   * Notification is synchronous. That is a deliberate choice: this is called from inside the
+   * ticker's `write` phase, and deferring would push DOM writes into the next frame, adding a
+   * frame of latency to every animation.
+   */
+  set(value) {
+    if (value === this.current) return;
+    this.previous = this.current;
+    this.current = value;
+    this.updateVelocity(value);
+    for (const listener of this.renderListeners) listener(value);
+    for (const listener of this.listeners) listener(value, this.previous);
+  }
+  /**
+   * Write without notifying, then notify once.
+   * Used when several related values change together and should produce one visual update.
+   */
+  setSilent(value) {
+    this.previous = this.current;
+    this.current = value;
+    this.updateVelocity(value);
+  }
+  updateVelocity(value) {
+    if (typeof value !== "number" || typeof this.lastValue !== "number") return;
+    const timestamp = now();
+    const elapsed = timestamp - this.lastUpdated;
+    if (elapsed > 1) {
+      this.velocityValue = (value - this.lastValue) / elapsed * 1e3;
+      this.lastValue = value;
+      this.lastUpdated = timestamp;
+    } else if (elapsed > VELOCITY_SAMPLE_WINDOW_MS) {
+      this.velocityValue = 0;
+    }
+  }
+  /**
+   * Current velocity in units per second.
+   *
+   * Returns 0 if the value hasn't changed recently, so a spring picking up from rest doesn't
+   * inherit a phantom velocity from an interaction that ended a second ago.
+   */
+  getVelocity() {
+    if (now() - this.lastUpdated > VELOCITY_SAMPLE_WINDOW_MS) return 0;
+    return this.velocityValue;
+  }
+  /** Directly set velocity — used when handing off from a gesture to a spring. */
+  setVelocity(velocity) {
+    this.velocityValue = velocity;
+    this.lastUpdated = now();
+  }
+  /** Subscribe to changes. The listener is *not* called immediately. */
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Subscribe as a renderer — called before regular listeners.
+   *
+   * Framework bindings use this for the DOM write, so that visual output is never delayed by
+   * application-level subscribers.
+   */
+  onRender(listener) {
+    this.renderListeners.add(listener);
+    return () => this.renderListeners.delete(listener);
+  }
+  get listenerCount() {
+    return this.listeners.size + this.renderListeners.size;
+  }
+  /**
+   * Register the currently-running animation so a subsequent one can interrupt it.
+   * Called by `animate()`; not part of the public surface.
+   */
+  attachAnimation(stop) {
+    this.stopAnimation?.();
+    this.stopAnimation = stop;
+  }
+  /** Stop whatever is animating this value, leaving it wherever it is. */
+  stop() {
+    this.stopAnimation?.();
+    this.stopAnimation = null;
+  }
+  get isAnimating() {
+    return this.stopAnimation !== null;
+  }
+  /** Release listeners and stop any animation. */
+  destroy() {
+    this.stop();
+    this.listeners.clear();
+    this.renderListeners.clear();
+  }
+};
+function motionValue(initial) {
+  return new MotionValue(initial);
+}
+function derived(sources, compute) {
+  const read = () => sources.map((s) => s.get());
+  const output = new MotionValue(compute(...read()));
+  const unsubscribes = sources.map(
+    (source) => source.on(() => {
+      output.set(compute(...read()));
+    })
+  );
+  const originalDestroy = output.destroy.bind(output);
+  output.destroy = () => {
+    for (const unsubscribe of unsubscribes) unsubscribe();
+    originalDestroy();
+  };
+  return output;
+}
+function mapValue(source, transform) {
+  const output = new MotionValue(transform(source.get()));
+  const unsubscribe = source.on((value) => output.set(transform(value)));
+  const originalDestroy = output.destroy.bind(output);
+  output.destroy = () => {
+    unsubscribe();
+    originalDestroy();
+  };
+  return output;
+}
+
+// src/motion/interpolate.ts
+function interpolateNumber(from, to) {
+  const delta = to - from;
+  return (t) => from + delta * t;
+}
+function interpolateColor(from, to, space = "oklab") {
+  const a = parseColor(from);
+  const b = parseColor(to);
+  const options = { space };
+  return (t) => toRgbString(mixParsed(a, b, t, options));
+}
+var UNIT_PATTERN = /^(-?[\d.]+)([a-z%]*)$/i;
+function interpolateUnitValue(from, to) {
+  const fromMatch = UNIT_PATTERN.exec(from.trim());
+  const toMatch = UNIT_PATTERN.exec(to.trim());
+  if (!fromMatch || !toMatch) return null;
+  const fromValue = Number.parseFloat(fromMatch[1]);
+  const toValue = Number.parseFloat(toMatch[1]);
+  if (!Number.isFinite(fromValue) || !Number.isFinite(toValue)) return null;
+  const fromUnit = fromMatch[2];
+  const toUnit = toMatch[2];
+  if (fromUnit !== toUnit) {
+    if (fromValue === 0) return (t) => `${toValue * t}${toUnit}`;
+    if (toValue === 0) return (t) => `${fromValue * (1 - t)}${fromUnit}`;
+    return (t) => t < 0.5 ? from : to;
+  }
+  const delta = toValue - fromValue;
+  return (t) => `${fromValue + delta * t}${fromUnit}`;
+}
+var NUMBER_PATTERN = /-?\d*\.?\d+(?:e[+-]?\d+)?/gi;
+function interpolateNumericString(from, to) {
+  const fromNumbers = from.match(NUMBER_PATTERN);
+  const toNumbers = to.match(NUMBER_PATTERN);
+  if (!fromNumbers || !toNumbers || fromNumbers.length !== toNumbers.length) return null;
+  const template = from.split(NUMBER_PATTERN);
+  if (template.length !== fromNumbers.length + 1) return null;
+  const toTemplate = to.split(NUMBER_PATTERN);
+  for (let i = 0; i < template.length; i++) {
+    if (template[i] !== toTemplate[i]) return null;
+  }
+  const fromValues = fromNumbers.map(Number);
+  const toValues = toNumbers.map(Number);
+  if (fromValues.some(Number.isNaN) || toValues.some(Number.isNaN)) return null;
+  const count = fromValues.length;
+  return (t) => {
+    let out = "";
+    for (let i = 0; i < count; i++) {
+      out += template[i];
+      out += round(lerp(fromValues[i], toValues[i], t));
+    }
+    return out + template[count];
+  };
+}
+function round(value) {
+  return Math.round(value * 1e4) / 1e4;
+}
+function interpolateArray(from, to, options) {
+  const interpolators = from.map(
+    (value, i) => resolveInterpolator(value, to[i] ?? value, options)
+  );
+  return (t) => interpolators.map((fn) => fn(t));
+}
+function interpolateObject(from, to, options) {
+  const keys = Object.keys(from);
+  const interpolators = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const target = to[key] ?? from[key];
+    interpolators.set(key, resolveInterpolator(from[key], target, options));
+  }
+  return (t) => {
+    const out = {};
+    for (const key of keys) {
+      out[key] = interpolators.get(key)(t);
+    }
+    return out;
+  };
+}
+function resolveInterpolator(from, to, options) {
+  if (typeof from === "number" && typeof to === "number") {
+    return interpolateNumber(from, to);
+  }
+  if (typeof from === "string" && typeof to === "string") {
+    if (looksLikeColor(from) && looksLikeColor(to)) {
+      return interpolateColor(from, to, options?.colorSpace);
+    }
+    const unit = interpolateUnitValue(from, to);
+    if (unit) return unit;
+    const numeric = interpolateNumericString(from, to);
+    if (numeric) return numeric;
+    return ((t) => t < 0.5 ? from : to);
+  }
+  if (Array.isArray(from) && Array.isArray(to)) {
+    return interpolateArray(from, to, options);
+  }
+  if (isPlainObject(from) && isPlainObject(to)) {
+    return interpolateObject(from, to, options);
+  }
+  return ((t) => t < 0.5 ? from : to);
+}
+function looksLikeColor(value) {
+  const v = value.trim();
+  if (v.startsWith("#")) return true;
+  if (/^(rgb|hsl|hsv|hsb|oklch|oklab|lab|lch|color)a?\(/i.test(v)) return true;
+  if (v === "transparent" || v === "currentcolor") return true;
+  if (/^[a-z]+$/i.test(v)) return tryParseColor(v) !== null;
+  return false;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function interpolateKeyframes(values, offsets, options) {
+  if (values.length === 0) throw new RangeError("[ansh] Keyframes require at least one value.");
+  if (values.length === 1) return () => values[0];
+  const positions = offsets && offsets.length === values.length ? offsets : values.map((_, i) => i / (values.length - 1));
+  const segments = values.slice(0, -1).map((value, i) => resolveInterpolator(value, values[i + 1], options));
+  return (t) => {
+    if (t <= positions[0]) return values[0];
+    const last = values.length - 1;
+    if (t >= positions[last]) return values[last];
+    let i = 0;
+    while (i < last - 1 && positions[i + 1] < t) i++;
+    const span = positions[i + 1] - positions[i];
+    const local = span <= 0 ? 0 : (t - positions[i]) / span;
+    return segments[i](local);
+  };
+}
+
+// src/motion/sampler.ts
+var DEFAULT_TWEEN_DURATION = 0.4;
+function createSampler(from, to, options = {}) {
+  const type = options.type ?? (hasSpringOptions(options) ? "spring" : "tween");
+  const keyframes = Array.isArray(to) ? [from, ...to] : null;
+  const interpolator = keyframes ? interpolateKeyframes(keyframes, options.offsets, options) : resolveInterpolator(from, to, options);
+  if (type === "spring") {
+    const springOptions = {
+      ...resolveSpringOptions(options.spring),
+      ...defined("stiffness", options.stiffness),
+      ...defined("damping", options.damping),
+      ...defined("mass", options.mass),
+      ...defined("bounce", options.bounce),
+      ...defined("duration", options.duration),
+      velocity: options.velocity ?? 0
+    };
+    if (typeof from === "number" && typeof to === "number") {
+      const solver2 = createSpring({ ...springOptions, from, to });
+      return {
+        at: (elapsed) => solver2.at(Math.max(0, elapsed)).position,
+        duration: solver2.duration,
+        progressAt: (elapsed) => clamp(elapsed / Math.max(1e-6, solver2.duration), 0, 1)
+      };
+    }
+    const solver = createSpring({ ...springOptions, from: 0, to: 1 });
+    return {
+      at: (elapsed) => interpolator(solver.at(Math.max(0, elapsed)).position),
+      duration: solver.duration,
+      progressAt: (elapsed) => solver.at(Math.max(0, elapsed)).position
+    };
+  }
+  if (type === "decay") {
+    const decay = createDecay({
+      from: typeof from === "number" ? from : 0,
+      velocity: options.velocity ?? 0,
+      power: options.power,
+      timeConstant: options.timeConstant
+    });
+    return {
+      at: (elapsed) => decay.at(Math.max(0, elapsed)).position,
+      duration: decay.duration,
+      progressAt: (elapsed) => clamp(elapsed / Math.max(1e-6, decay.duration), 0, 1)
+    };
+  }
+  const easing = resolveEasing(options.easing);
+  const duration = Math.max(0, options.duration ?? DEFAULT_TWEEN_DURATION);
+  const progressAt = (elapsed) => duration === 0 ? 1 : easing(clamp(elapsed / duration, 0, 1));
+  return {
+    at: (elapsed) => interpolator(progressAt(elapsed)),
+    duration,
+    progressAt
+  };
+}
+function hasSpringOptions(options) {
+  return options.spring !== void 0 || options.stiffness !== void 0 || options.damping !== void 0 || options.bounce !== void 0 || options.mass !== void 0;
+}
+function defined(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/motion/animate.ts
+function animate(from, to, options = {}) {
+  const motion = from instanceof MotionValue ? from : null;
+  const startValue = motion ? motion.get() : from;
+  const delay = Math.max(0, options.delay ?? 0);
+  const repeat = options.repeat ?? 0;
+  const repeatMode = options.repeatMode ?? "loop";
+  const repeatDelay = Math.max(0, options.repeatDelay ?? 0);
+  let resolveFinished = () => {
+  };
+  const finished = new Promise((resolve) => {
+    resolveFinished = resolve;
+  });
+  const emit = (value) => {
+    motion?.set(value);
+    options.onUpdate?.(value);
+  };
+  if (prefersReducedMotion() && (options.reducedMotion ?? "jump") === "jump") {
+    const finalValue = Array.isArray(to) ? to[to.length - 1] : to;
+    options.onStart?.();
+    emit(finalValue);
+    options.onComplete?.();
+    resolveFinished();
+    return {
+      stop: noop,
+      pause: noop,
+      play: noop,
+      seek: noop,
+      finish: noop,
+      isActive: false,
+      duration: 0,
+      finished
+    };
+  }
+  const sampler = createSampler(startValue, to, {
+    ...options,
+    velocity: options.velocity ?? motion?.getVelocity() ?? 0
+  });
+  const cycleDuration = sampler.duration;
+  const cycleLength = cycleDuration + repeatDelay;
+  const activeDuration = repeat === Infinity ? Infinity : cycleDuration * (repeat + 1) + repeatDelay * repeat;
+  const totalDuration = repeat === Infinity ? Infinity : delay + activeDuration;
+  let elapsed = 0;
+  let paused = false;
+  let active = true;
+  let started = false;
+  const ticker = getTicker();
+  const applyCycle = (withinCycle, reversed) => {
+    const local = reversed ? Math.max(0, cycleDuration - withinCycle) : withinCycle;
+    emit(sampler.at(local));
+  };
+  const complete = () => {
+    if (!active) return;
+    active = false;
+    unsubscribe();
+    options.onComplete?.();
+    resolveFinished();
+  };
+  const frame = ({ delta }) => {
+    if (paused || !active) return;
+    elapsed += delta;
+    if (elapsed < delay) return;
+    if (!started) {
+      started = true;
+      options.onStart?.();
+    }
+    const sinceStart = elapsed - delay;
+    if (sinceStart >= activeDuration) {
+      applyCycle(cycleDuration, shouldReverse(repeat, repeatMode));
+      complete();
+      return;
+    }
+    const cycleIndex = cycleLength > 0 ? Math.floor(sinceStart / cycleLength) : 0;
+    const withinCycle = cycleLength > 0 ? sinceStart - cycleIndex * cycleLength : sinceStart;
+    applyCycle(Math.min(withinCycle, cycleDuration), shouldReverse(cycleIndex, repeatMode));
+  };
+  const unsubscribe = ticker.add(frame, { phase: "compute", name: "animate" });
+  const abort = () => {
+    if (!active) return;
+    active = false;
+    unsubscribe();
+    options.onStop?.();
+    resolveFinished();
+  };
+  motion?.attachAnimation(abort);
+  if (delay === 0) applyCycle(0, false);
+  return {
+    stop: abort,
+    pause() {
+      paused = true;
+    },
+    play() {
+      paused = false;
+    },
+    seek(time) {
+      elapsed = Math.max(0, time);
+      const sinceStart = Math.max(0, elapsed - delay);
+      if (sinceStart >= activeDuration) {
+        applyCycle(cycleDuration, shouldReverse(repeat, repeatMode));
+        return;
+      }
+      const cycleIndex = cycleLength > 0 ? Math.floor(sinceStart / cycleLength) : 0;
+      const withinCycle = cycleLength > 0 ? sinceStart - cycleIndex * cycleLength : sinceStart;
+      applyCycle(Math.min(withinCycle, cycleDuration), shouldReverse(cycleIndex, repeatMode));
+    },
+    finish() {
+      if (!active) return;
+      applyCycle(cycleDuration, shouldReverse(repeat === Infinity ? 0 : repeat, repeatMode));
+      complete();
+    },
+    get isActive() {
+      return active;
+    },
+    duration: totalDuration,
+    finished
+  };
+}
+function shouldReverse(index, mode) {
+  return (mode === "reverse" || mode === "mirror") && index % 2 === 1;
+}
+function noop() {
+}
+function springTo(value, getTarget, options = {}) {
+  const stiffness = options.stiffness ?? 170;
+  const damping = options.damping ?? 26;
+  const mass = Math.max(0.01, options.mass ?? 1);
+  const restDelta = options.restDelta ?? 0.01;
+  let velocity = options.velocity ?? 0;
+  const ticker = getTicker();
+  return ticker.add(
+    ({ delta }) => {
+      const target = getTarget();
+      const current = value.get();
+      if (Math.abs(current - target) < restDelta && Math.abs(velocity) < restDelta) {
+        if (current !== target) value.set(target);
+        velocity = 0;
+        return;
+      }
+      const steps2 = Math.min(4, Math.max(1, Math.ceil(delta / (1 / 60))));
+      const dt = delta / steps2;
+      let position = current;
+      for (let i = 0; i < steps2; i++) {
+        const acceleration = (-stiffness * (position - target) - damping * velocity) / mass;
+        velocity += acceleration * dt;
+        position += velocity * dt;
+      }
+      value.set(position);
+      value.setVelocity(velocity);
+    },
+    { phase: "compute", name: options.name ?? "springTo" }
+  );
+}
+
+// src/motion/timeline.ts
+function createTimeline(options = {}) {
+  const entries = [];
+  const labels = /* @__PURE__ */ new Map();
+  const repeat = options.repeat ?? 0;
+  const yoyo = options.yoyo ?? false;
+  const autoplay = options.autoplay ?? true;
+  const respectReducedMotion = options.respectReducedMotion ?? true;
+  let totalDuration = 0;
+  let previousStart = 0;
+  let previousEnd = 0;
+  let currentTime = 0;
+  let playing = false;
+  let scale = options.timeScale ?? 1;
+  let iteration = 0;
+  let killed = false;
+  let subscription = null;
+  let resolveFinished = () => {
+  };
+  const finished = new Promise((resolve) => {
+    resolveFinished = resolve;
+  });
+  const RELATIVE = /^([<>]?)(?:([+-]=)\s*([\d.]+))?$/;
+  const LABEL_RELATIVE = /^(.+?)(?:([+-]=)\s*([\d.]+))?$/;
+  function resolvePosition(position) {
+    if (position === void 0) return previousEnd;
+    if (typeof position === "number") return Math.max(0, position);
+    const trimmed = position.trim();
+    const relative = RELATIVE.exec(trimmed);
+    if (relative) {
+      const anchor = relative[1] === "<" ? previousStart : previousEnd;
+      if (!relative[2]) return anchor;
+      const amount = Number.parseFloat(relative[3]);
+      return Math.max(0, relative[2] === "+=" ? anchor + amount : anchor - amount);
+    }
+    const labelMatch = LABEL_RELATIVE.exec(trimmed);
+    if (labelMatch) {
+      const base = labels.get(labelMatch[1]);
+      if (base !== void 0) {
+        if (!labelMatch[2]) return base;
+        const amount = Number.parseFloat(labelMatch[3]);
+        return Math.max(0, labelMatch[2] === "+=" ? base + amount : base - amount);
+      }
+    }
+    console.warn(
+      `[ansh] Unknown timeline position "${position}". Placing at the end of the previous entry. Valid forms: a number, '<', '>', '+=0.2', '-=0.2', or a label name.`
+    );
+    return previousEnd;
+  }
+  function push(entry) {
+    entries.push(entry);
+    previousStart = entry.start;
+    previousEnd = entry.start + entry.duration;
+    if (previousEnd > totalDuration) totalDuration = previousEnd;
+    if (autoplay && !playing && !killed) api.play();
+  }
+  function applyAt(time, previousTime) {
+    for (const entry of entries) {
+      if (entry.isCallback) {
+        const crossedForward = previousTime < entry.start && time >= entry.start;
+        const crossedBackward = previousTime > entry.start && time <= entry.start;
+        if (crossedForward || crossedBackward) {
+          if (!entry.fired) {
+            entry.fired = true;
+            entry.apply(0);
+          }
+        } else if (Math.abs(time - entry.start) > 1e-6) {
+          entry.fired = false;
+        }
+        continue;
+      }
+      const local = clamp(time - entry.start, 0, entry.duration);
+      entry.apply(local);
+    }
+    options.onUpdate?.(time, totalDuration === 0 ? 1 : clamp(time / totalDuration, 0, 1));
+  }
+  function frame({ delta }) {
+    if (!playing || killed) return;
+    const previousTime = currentTime;
+    currentTime += delta * scale;
+    if (scale >= 0 && currentTime >= totalDuration) {
+      if (repeat === Infinity || iteration < repeat) {
+        iteration++;
+        options.onRepeat?.(iteration);
+        if (yoyo) {
+          currentTime = totalDuration;
+          scale = -Math.abs(scale);
+        } else {
+          currentTime = currentTime - totalDuration;
+          resetCallbacks();
+        }
+        applyAt(clamp(currentTime, 0, totalDuration), previousTime);
+        return;
+      }
+      currentTime = totalDuration;
+      applyAt(currentTime, previousTime);
+      finish();
+      return;
+    }
+    if (scale < 0 && currentTime <= 0) {
+      if (yoyo && (repeat === Infinity || iteration < repeat)) {
+        iteration++;
+        options.onRepeat?.(iteration);
+        currentTime = 0;
+        scale = Math.abs(scale);
+        applyAt(currentTime, previousTime);
+        return;
+      }
+      currentTime = 0;
+      applyAt(currentTime, previousTime);
+      finish();
+      return;
+    }
+    applyAt(currentTime, previousTime);
+  }
+  function resetCallbacks() {
+    for (const entry of entries) if (entry.isCallback) entry.fired = false;
+  }
+  function finish() {
+    playing = false;
+    subscription?.();
+    subscription = null;
+    options.onComplete?.();
+    resolveFinished();
+  }
+  const ticker = getTicker();
+  const api = {
+    to(value, to, sampleOptions = {}, position) {
+      const start = resolvePosition(position);
+      const sampler = createSampler(value.get(), to, sampleOptions);
+      push({
+        start,
+        duration: sampler.duration,
+        apply: (local) => value.set(sampler.at(local)),
+        isCallback: false,
+        fired: false,
+        name: "to"
+      });
+      return api;
+    },
+    from(value, from, sampleOptions = {}, position) {
+      const start = resolvePosition(position);
+      const target = value.get();
+      const sampler = createSampler(from, target, sampleOptions);
+      push({
+        start,
+        duration: sampler.duration,
+        apply: (local) => value.set(sampler.at(local)),
+        isCallback: false,
+        fired: false,
+        name: "from"
+      });
+      return api;
+    },
+    tween(from, to, tweenOptions, position) {
+      const start = resolvePosition(position);
+      const sampler = createSampler(from, to, tweenOptions);
+      const { onUpdate } = tweenOptions;
+      push({
+        start,
+        duration: sampler.duration,
+        apply: (local) => onUpdate(sampler.at(local)),
+        isCallback: false,
+        fired: false,
+        name: "tween"
+      });
+      return api;
+    },
+    stagger(values, to, staggerOptions = {}, position) {
+      const start = resolvePosition(position);
+      const delayFor = stagger(values.length, staggerOptions.stagger);
+      let groupEnd = start;
+      values.forEach((value, index) => {
+        const sampler = createSampler(value.get(), to, staggerOptions);
+        const entryStart = start + delayFor(index);
+        entries.push({
+          start: entryStart,
+          duration: sampler.duration,
+          apply: (local) => value.set(sampler.at(local)),
+          isCallback: false,
+          fired: false,
+          name: `stagger[${index}]`
+        });
+        const end = entryStart + sampler.duration;
+        if (end > groupEnd) groupEnd = end;
+      });
+      previousStart = start;
+      previousEnd = groupEnd;
+      if (groupEnd > totalDuration) totalDuration = groupEnd;
+      if (autoplay && !playing && !killed) api.play();
+      return api;
+    },
+    call(fn, position) {
+      const start = resolvePosition(position);
+      push({
+        start,
+        duration: 0,
+        apply: fn,
+        isCallback: true,
+        fired: false,
+        name: "call"
+      });
+      return api;
+    },
+    label(name, position) {
+      labels.set(name, resolvePosition(position));
+      return api;
+    },
+    add(child, position) {
+      const offset = resolvePosition(position);
+      for (const entry of child.entries) {
+        entries.push({ ...entry, start: entry.start + offset });
+      }
+      for (const [name, at] of child.labels) {
+        labels.set(name, at + offset);
+      }
+      previousStart = offset;
+      previousEnd = offset + child.duration;
+      if (previousEnd > totalDuration) totalDuration = previousEnd;
+      return api;
+    },
+    play() {
+      if (killed || playing) return api;
+      if (respectReducedMotion && prefersReducedMotion()) {
+        currentTime = totalDuration;
+        applyAt(totalDuration, 0);
+        options.onComplete?.();
+        resolveFinished();
+        return api;
+      }
+      playing = true;
+      subscription = ticker.add(frame, { phase: "compute", name: "timeline" });
+      return api;
+    },
+    pause() {
+      playing = false;
+      subscription?.();
+      subscription = null;
+      return api;
+    },
+    reverse() {
+      scale = -Math.abs(scale || 1);
+      if (!playing) api.play();
+      return api;
+    },
+    seek(time) {
+      const previousTime = currentTime;
+      currentTime = clamp(time, 0, totalDuration);
+      resetCallbacks();
+      applyAt(currentTime, previousTime);
+      return api;
+    },
+    progress(value) {
+      return api.seek(clamp(value, 0, 1) * totalDuration);
+    },
+    restart() {
+      iteration = 0;
+      scale = Math.abs(scale || 1);
+      resetCallbacks();
+      api.seek(0);
+      return api.play();
+    },
+    complete() {
+      api.seek(totalDuration);
+      finish();
+      return api;
+    },
+    kill() {
+      killed = true;
+      playing = false;
+      subscription?.();
+      subscription = null;
+      entries.length = 0;
+      labels.clear();
+      resolveFinished();
+    },
+    get duration() {
+      return totalDuration;
+    },
+    get time() {
+      return currentTime;
+    },
+    get isPlaying() {
+      return playing;
+    },
+    get timeScale() {
+      return scale;
+    },
+    set timeScale(value) {
+      scale = value;
+    },
+    finished,
+    get entries() {
+      return entries;
+    },
+    get labels() {
+      return labels;
+    }
+  };
+  return api;
+}
+
+// src/observers/scroll.ts
+var DEFAULT_OFFSET = {
+  start: ["start", "end"],
+  end: ["end", "start"]
+};
+function edgeToFraction(edge) {
+  if (typeof edge === "number") return edge;
+  switch (edge) {
+    case "start":
+      return 0;
+    case "center":
+      return 0.5;
+    case "end":
+      return 1;
+  }
+}
+function trackScroll(element, callback, options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const axis = options.axis ?? "y";
+  const offset = options.offset ?? DEFAULT_OFFSET;
+  const container = options.container ?? null;
+  const state = {
+    progress: 0,
+    velocity: 0,
+    scroll: 0,
+    direction: 0,
+    inView: false
+  };
+  let lastScroll = 0;
+  let hasLastScroll = false;
+  let needsMeasure = true;
+  let startOffset = 0;
+  let endOffset = 0;
+  const readScroll = () => {
+    if (container) return axis === "y" ? container.scrollTop : container.scrollLeft;
+    return axis === "y" ? window.scrollY : window.scrollX;
+  };
+  const viewportSize = () => {
+    if (container) return axis === "y" ? container.clientHeight : container.clientWidth;
+    return axis === "y" ? window.innerHeight : window.innerWidth;
+  };
+  const measure = () => {
+    const rect = element.getBoundingClientRect();
+    const scroll = readScroll();
+    const viewport = viewportSize();
+    const elementStart = (axis === "y" ? rect.top : rect.left) + scroll;
+    const elementSize = axis === "y" ? rect.height : rect.width;
+    const [startElementEdge, startViewportEdge] = offset.start;
+    const [endElementEdge, endViewportEdge] = offset.end;
+    startOffset = elementStart + elementSize * edgeToFraction(startElementEdge) - viewport * edgeToFraction(startViewportEdge);
+    endOffset = elementStart + elementSize * edgeToFraction(endElementEdge) - viewport * edgeToFraction(endViewportEdge);
+    needsMeasure = false;
+  };
+  const invalidate = () => {
+    needsMeasure = true;
+  };
+  window.addEventListener("resize", invalidate, { passive: true });
+  const stopResizeObserver = observeLayoutChanges(element, invalidate);
+  const ticker = getTicker();
+  const stopRead = ticker.add(
+    () => {
+      if (needsMeasure) measure();
+      state.scroll = readScroll();
+    },
+    { phase: "read", name: "scroll:measure" }
+  );
+  const stopCompute = ticker.add(
+    ({ delta }) => {
+      const span = endOffset - startOffset;
+      state.progress = span === 0 ? 0 : clamp((state.scroll - startOffset) / span, 0, 1);
+      if (hasLastScroll && delta > 0) {
+        const dv = (state.scroll - lastScroll) / delta;
+        state.velocity = dv;
+        state.direction = dv > 1 ? 1 : dv < -1 ? -1 : 0;
+      }
+      lastScroll = state.scroll;
+      hasLastScroll = true;
+      state.inView = state.progress > 0 && state.progress < 1;
+      callback(state);
+    },
+    { phase: "compute", name: "scroll:progress" }
+  );
+  return () => {
+    window.removeEventListener("resize", invalidate);
+    stopResizeObserver();
+    stopRead();
+    stopCompute();
+  };
+}
+function observeLayoutChanges(element, onChange) {
+  return observeResize(element, onChange);
+}
+function trackContainerScroll(callback, options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const axis = options.axis ?? "y";
+  const container = options.container ?? null;
+  const ticker = getTicker();
+  let scroll = 0;
+  let max = 1;
+  let lastScroll = 0;
+  let hasLast = false;
+  const stopRead = ticker.add(
+    () => {
+      if (container) {
+        scroll = axis === "y" ? container.scrollTop : container.scrollLeft;
+        max = Math.max(
+          1,
+          axis === "y" ? container.scrollHeight - container.clientHeight : container.scrollWidth - container.clientWidth
+        );
+      } else {
+        scroll = axis === "y" ? window.scrollY : window.scrollX;
+        const doc = document.documentElement;
+        max = Math.max(
+          1,
+          axis === "y" ? doc.scrollHeight - window.innerHeight : doc.scrollWidth - window.innerWidth
+        );
+      }
+    },
+    { phase: "read", name: "containerScroll:measure" }
+  );
+  const stopCompute = ticker.add(
+    ({ delta }) => {
+      const velocity = hasLast && delta > 0 ? (scroll - lastScroll) / delta : 0;
+      lastScroll = scroll;
+      hasLast = true;
+      callback({ progress: clamp(scroll / max, 0, 1), scroll, velocity, max });
+    },
+    { phase: "compute", name: "containerScroll:progress" }
+  );
+  return () => {
+    stopRead();
+    stopCompute();
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+export { DEFAULT_TWEEN_DURATION, MotionValue, SPRING_DEFAULTS, VERSION, animate, attachLifecycle, createDecay, createSampler, createSpring, createTimeline, derived, hasSpringOptions, interpolateArray, interpolateColor, interpolateKeyframes, interpolateNumber, interpolateNumericString, interpolateObject, interpolateUnitValue, mapValue, motionValue, perceptualToPhysical, physicalToPerceptual, resolveInterpolator, resolveSpringOptions, springTo, springs, trackContainerScroll, trackScroll };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map