@redsift/charts 8.0.0 → 8.0.2

package/index.js

@@ -1,11 +1,11 @@
-import { brush, select, scaleOrdinal, zoom, interpolateRound, interpolate, scaleLinear, sum, arc, pie, min, extent, descending, scaleSqrt, max } from 'd3';
-import { RedsiftDataVizColorBlueDefault, RedsiftDataVizColorGreyDark, RedsiftDataVizColorGreenDefault, RedsiftDataVizColorPinkDefault, RedsiftDataVizColorAquaDefault, RedsiftDataVizColorBrownDefault, RedsiftDataVizColorRedDefault, RedsiftDataVizColorYellowDefault, RedsiftDataVizColorPurpleDefault, RedsiftDataVizColorOrangeDefault, RedsiftDataVizColorGreyDefault, RedsiftDataVizColorGreenDark, RedsiftDataVizColorPinkDark, RedsiftDataVizColorAquaDark, RedsiftDataVizColorBrownDark, RedsiftDataVizColorRedDark, RedsiftDataVizColorYellowDark, RedsiftDataVizColorPurpleDark, RedsiftDataVizColorOrangeDark, RedsiftDataVizColorBlueDark, RedsiftDataVizColorGreenDarker, RedsiftDataVizColorPinkDarker, RedsiftDataVizColorAquaDarker, RedsiftDataVizColorBrownDarker, RedsiftDataVizColorRedDarker, RedsiftDataVizColorYellowDarker, RedsiftDataVizColorPurpleDarker, RedsiftDataVizColorOrangeDarker, RedsiftDataVizColorBlueDarker, RedsiftDataVizColorGreyDarker, RedsiftDataVizColorGreenDarkerer, RedsiftDataVizColorPinkDarkerer, RedsiftDataVizColorAquaDarkerer, RedsiftDataVizColorBrownDarkerer, RedsiftDataVizColorRedDarkerer, RedsiftDataVizColorYellowDarkerer, RedsiftDataVizColorPurpleDarkerer, RedsiftDataVizColorOrangeDarkerer, RedsiftDataVizColorBlueDarkerer, RedsiftDataVizColorGreyDarkerer, RedsiftDataVizColorGreenLight, RedsiftDataVizColorPinkLight, RedsiftDataVizColorAquaLight, RedsiftDataVizColorBrownLight, RedsiftDataVizColorRedLight, RedsiftDataVizColorYellowLight, RedsiftDataVizColorPurpleLight, RedsiftDataVizColorOrangeLight, RedsiftDataVizColorBlueLight, RedsiftDataVizColorGreyLight, RedsiftDataVizColorGreenLighter, RedsiftDataVizColorPinkLighter, RedsiftDataVizColorAquaLighter, RedsiftDataVizColorBrownLighter, RedsiftDataVizColorRedLighter, RedsiftDataVizColorYellowLighter, RedsiftDataVizColorPurpleLighter, RedsiftDataVizColorOrangeLighter, RedsiftDataVizColorBlueLighter, RedsiftDataVizColorGreyLighter, RedsiftDataVizColorGreenLighterer, RedsiftDataVizColorPinkLighterer, RedsiftDataVizColorAquaLighterer, RedsiftDataVizColorBrownLighterer, RedsiftDataVizColorRedLighterer, RedsiftDataVizColorYellowLighterer, RedsiftDataVizColorPurpleLighterer, RedsiftDataVizColorOrangeLighterer, RedsiftDataVizColorBlueLighterer, RedsiftDataVizColorGreyLighterer, Text, Number as Number$1, baseStyling, focusRing, Flexbox, warnIfNoAccessibleLabelFound, Heading, Button } from '@redsift/design-system';
+import { brush, select, scaleOrdinal, zoom, interpolateRound, interpolate as interpolate$1, scaleLinear, sum, arc, pie, min, extent, descending, scaleSqrt, max } from 'd3';
+import { RedsiftDataVizColorBlueDefault, RedsiftDataVizColorGreyDark, RedsiftDataVizColorGreenDefault, RedsiftDataVizColorPinkDefault, RedsiftDataVizColorAquaDefault, RedsiftDataVizColorBrownDefault, RedsiftDataVizColorRedDefault, RedsiftDataVizColorYellowDefault, RedsiftDataVizColorPurpleDefault, RedsiftDataVizColorOrangeDefault, RedsiftDataVizColorGreyDefault, RedsiftDataVizColorGreenDark, RedsiftDataVizColorPinkDark, RedsiftDataVizColorAquaDark, RedsiftDataVizColorBrownDark, RedsiftDataVizColorRedDark, RedsiftDataVizColorYellowDark, RedsiftDataVizColorPurpleDark, RedsiftDataVizColorOrangeDark, RedsiftDataVizColorBlueDark, RedsiftDataVizColorGreenDarker, RedsiftDataVizColorPinkDarker, RedsiftDataVizColorAquaDarker, RedsiftDataVizColorBrownDarker, RedsiftDataVizColorRedDarker, RedsiftDataVizColorYellowDarker, RedsiftDataVizColorPurpleDarker, RedsiftDataVizColorOrangeDarker, RedsiftDataVizColorBlueDarker, RedsiftDataVizColorGreyDarker, RedsiftDataVizColorGreenDarkerer, RedsiftDataVizColorPinkDarkerer, RedsiftDataVizColorAquaDarkerer, RedsiftDataVizColorBrownDarkerer, RedsiftDataVizColorRedDarkerer, RedsiftDataVizColorYellowDarkerer, RedsiftDataVizColorPurpleDarkerer, RedsiftDataVizColorOrangeDarkerer, RedsiftDataVizColorBlueDarkerer, RedsiftDataVizColorGreyDarkerer, RedsiftDataVizColorGreenLight, RedsiftDataVizColorPinkLight, RedsiftDataVizColorAquaLight, RedsiftDataVizColorBrownLight, RedsiftDataVizColorRedLight, RedsiftDataVizColorYellowLight, RedsiftDataVizColorPurpleLight, RedsiftDataVizColorOrangeLight, RedsiftDataVizColorBlueLight, RedsiftDataVizColorGreyLight, RedsiftDataVizColorGreenLighter, RedsiftDataVizColorPinkLighter, RedsiftDataVizColorAquaLighter, RedsiftDataVizColorBrownLighter, RedsiftDataVizColorRedLighter, RedsiftDataVizColorYellowLighter, RedsiftDataVizColorPurpleLighter, RedsiftDataVizColorOrangeLighter, RedsiftDataVizColorBlueLighter, RedsiftDataVizColorGreyLighter, RedsiftDataVizColorGreenLighterer, RedsiftDataVizColorPinkLighterer, RedsiftDataVizColorAquaLighterer, RedsiftDataVizColorBrownLighterer, RedsiftDataVizColorRedLighterer, RedsiftDataVizColorYellowLighterer, RedsiftDataVizColorPurpleLighterer, RedsiftDataVizColorOrangeLighterer, RedsiftDataVizColorBlueLighterer, RedsiftDataVizColorGreyLighterer, Text, Number as Number$1, baseStyling, focusRing, Flexbox, warnIfNoAccessibleLabelFound, Heading, Button, Icon } from '@redsift/design-system';
 import * as React from 'react';
 import React__default, { useRef, useEffect, useMemo, useState, useLayoutEffect, forwardRef, useCallback, useContext, useId } from 'react';
 import classNames from 'classnames';
 import { unstable_batchedUpdates } from 'react-dom';
 import styled, { css } from 'styled-components';
-import { Tooltip } from '@redsift/popovers';
+import { Tooltip, Popover } from '@redsift/popovers';
 import { useLocalizedStringFormatter } from 'react-aria';
 
 const getRoundedIntermediaryPoint = (selection, scaleX, scaleY) => {
@@ -300,20 +300,3740 @@ const ColorTheme = {
   monochrome: 'monochrome'
 };
 
-var f$1=r(),n=e=>c$3(e,f$1),m$1=r();n.write=e=>c$3(e,m$1);var d$2=r();n.onStart=e=>c$3(e,d$2);var h$3=r();n.onFrame=e=>c$3(e,h$3);var p$1=r();n.onFinish=e=>c$3(e,p$1);var i=[];n.setTimeout=(e,t)=>{let a=n.now()+t,o=()=>{let F=i.findIndex(z=>z.cancel==o);~F&&i.splice(F,1),u$2-=~F?1:0;},s={time:a,handler:e,cancel:o};return i.splice(w(a),0,s),u$2+=1,v$2(),s};var w=e=>~(~i.findIndex(t=>t.time>e)||~i.length);n.cancel=e=>{d$2.delete(e),h$3.delete(e),p$1.delete(e),f$1.delete(e),m$1.delete(e);};n.sync=e=>{T=!0,n.batchedUpdates(e),T=!1;};n.throttle=e=>{let t;function a(){try{e(...t);}finally{t=null;}}function o(...s){t=s,n.onStart(a);}return o.handler=e,o.cancel=()=>{d$2.delete(a),t=null;},o};var y$3=typeof window<"u"?window.requestAnimationFrame:()=>{};n.use=e=>y$3=e;n.now=typeof performance<"u"?()=>performance.now():Date.now;n.batchedUpdates=e=>e();n.catch=console.error;n.frameLoop="always";n.advance=()=>{n.frameLoop!=="demand"?console.warn("Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"):x$2();};var l$2=-1,u$2=0,T=!1;function c$3(e,t){T?(t.delete(e),e(0)):(t.add(e),v$2());}function v$2(){l$2<0&&(l$2=0,n.frameLoop!=="demand"&&y$3(b$2));}function R(){l$2=-1;}function b$2(){~l$2&&(y$3(b$2),n.batchedUpdates(x$2));}function x$2(){let e=l$2;l$2=n.now();let t=w(l$2);if(t&&(Q$2(i.splice(0,t),a=>a.handler()),u$2-=t),!u$2){R();return}d$2.flush(),f$1.flush(e?Math.min(64,l$2-e):16.667),h$3.flush(),m$1.flush(),p$1.flush();}function r(){let e=new Set,t=e;return {add(a){u$2+=t==e&&!e.has(a)?1:0,e.add(a);},delete(a){return u$2-=t==e&&e.has(a)?1:0,e.delete(a)},flush(a){t.size&&(e=new Set,u$2-=t.size,Q$2(t,o=>o(a)&&e.add(o)),u$2+=e.size,t=e);}}}function Q$2(e,t){e.forEach(a=>{try{t(a);}catch(o){n.catch(o);}});}
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/globals.ts
+var globals_exports = {};
+__export(globals_exports, {
+  assign: () => assign,
+  colors: () => colors,
+  createStringInterpolator: () => createStringInterpolator,
+  skipAnimation: () => skipAnimation,
+  to: () => to,
+  willAdvance: () => willAdvance
+});
+
+// ../rafz/dist/react-spring_rafz.modern.mjs
+var updateQueue = makeQueue();
+var raf = (fn) => schedule(fn, updateQueue);
+var writeQueue = makeQueue();
+raf.write = (fn) => schedule(fn, writeQueue);
+var onStartQueue = makeQueue();
+raf.onStart = (fn) => schedule(fn, onStartQueue);
+var onFrameQueue = makeQueue();
+raf.onFrame = (fn) => schedule(fn, onFrameQueue);
+var onFinishQueue = makeQueue();
+raf.onFinish = (fn) => schedule(fn, onFinishQueue);
+var timeouts = [];
+raf.setTimeout = (handler, ms) => {
+  const time = raf.now() + ms;
+  const cancel = () => {
+    const i = timeouts.findIndex((t) => t.cancel == cancel);
+    if (~i)
+      timeouts.splice(i, 1);
+    pendingCount -= ~i ? 1 : 0;
+  };
+  const timeout = { time, handler, cancel };
+  timeouts.splice(findTimeout(time), 0, timeout);
+  pendingCount += 1;
+  start();
+  return timeout;
+};
+var findTimeout = (time) => ~(~timeouts.findIndex((t) => t.time > time) || ~timeouts.length);
+raf.cancel = (fn) => {
+  onStartQueue.delete(fn);
+  onFrameQueue.delete(fn);
+  onFinishQueue.delete(fn);
+  updateQueue.delete(fn);
+  writeQueue.delete(fn);
+};
+raf.sync = (fn) => {
+  sync = true;
+  raf.batchedUpdates(fn);
+  sync = false;
+};
+raf.throttle = (fn) => {
+  let lastArgs;
+  function queuedFn() {
+    try {
+      fn(...lastArgs);
+    } finally {
+      lastArgs = null;
+    }
+  }
+  function throttled(...args) {
+    lastArgs = args;
+    raf.onStart(queuedFn);
+  }
+  throttled.handler = fn;
+  throttled.cancel = () => {
+    onStartQueue.delete(queuedFn);
+    lastArgs = null;
+  };
+  return throttled;
+};
+var nativeRaf = typeof window != "undefined" ? window.requestAnimationFrame : (
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  () => {
+  }
+);
+raf.use = (impl) => nativeRaf = impl;
+raf.now = typeof performance != "undefined" ? () => performance.now() : Date.now;
+raf.batchedUpdates = (fn) => fn();
+raf.catch = console.error;
+raf.frameLoop = "always";
+raf.advance = () => {
+  if (raf.frameLoop !== "demand") {
+    console.warn(
+      "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"
+    );
+  } else {
+    update();
+  }
+};
+var ts = -1;
+var pendingCount = 0;
+var sync = false;
+function schedule(fn, queue) {
+  if (sync) {
+    queue.delete(fn);
+    fn(0);
+  } else {
+    queue.add(fn);
+    start();
+  }
+}
+function start() {
+  if (ts < 0) {
+    ts = 0;
+    if (raf.frameLoop !== "demand") {
+      nativeRaf(loop);
+    }
+  }
+}
+function stop() {
+  ts = -1;
+}
+function loop() {
+  if (~ts) {
+    nativeRaf(loop);
+    raf.batchedUpdates(update);
+  }
+}
+function update() {
+  const prevTs = ts;
+  ts = raf.now();
+  const count = findTimeout(ts);
+  if (count) {
+    eachSafely(timeouts.splice(0, count), (t) => t.handler());
+    pendingCount -= count;
+  }
+  if (!pendingCount) {
+    stop();
+    return;
+  }
+  onStartQueue.flush();
+  updateQueue.flush(prevTs ? Math.min(64, ts - prevTs) : 16.667);
+  onFrameQueue.flush();
+  writeQueue.flush();
+  onFinishQueue.flush();
+}
+function makeQueue() {
+  let next = /* @__PURE__ */ new Set();
+  let current = next;
+  return {
+    add(fn) {
+      pendingCount += current == next && !next.has(fn) ? 1 : 0;
+      next.add(fn);
+    },
+    delete(fn) {
+      pendingCount -= current == next && next.has(fn) ? 1 : 0;
+      return next.delete(fn);
+    },
+    flush(arg) {
+      if (current.size) {
+        next = /* @__PURE__ */ new Set();
+        pendingCount -= current.size;
+        eachSafely(current, (fn) => fn(arg) && next.add(fn));
+        pendingCount += next.size;
+        current = next;
+      }
+    }
+  };
+}
+function eachSafely(values, each2) {
+  values.forEach((value) => {
+    try {
+      each2(value);
+    } catch (e) {
+      raf.catch(e);
+    }
+  });
+}
+
+// src/helpers.ts
+function noop() {
+}
+var defineHidden = (obj, key, value) => Object.defineProperty(obj, key, { value, writable: true, configurable: true });
+var is = {
+  arr: Array.isArray,
+  obj: (a) => !!a && a.constructor.name === "Object",
+  fun: (a) => typeof a === "function",
+  str: (a) => typeof a === "string",
+  num: (a) => typeof a === "number",
+  und: (a) => a === void 0
+};
+function isEqual(a, b) {
+  if (is.arr(a)) {
+    if (!is.arr(b) || a.length !== b.length)
+      return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i])
+        return false;
+    }
+    return true;
+  }
+  return a === b;
+}
+var each = (obj, fn) => obj.forEach(fn);
+function eachProp(obj, fn, ctx) {
+  if (is.arr(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      fn.call(ctx, obj[i], `${i}`);
+    }
+    return;
+  }
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      fn.call(ctx, obj[key], key);
+    }
+  }
+}
+var toArray = (a) => is.und(a) ? [] : is.arr(a) ? a : [a];
+function flush(queue, iterator) {
+  if (queue.size) {
+    const items = Array.from(queue);
+    queue.clear();
+    each(items, iterator);
+  }
+}
+var flushCalls = (queue, ...args) => flush(queue, (fn) => fn(...args));
+var isSSR = () => typeof window === "undefined" || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent);
+
+// src/globals.ts
+var createStringInterpolator;
+var to;
+var colors = null;
+var skipAnimation = false;
+var willAdvance = noop;
+var assign = (globals) => {
+  if (globals.to)
+    to = globals.to;
+  if (globals.now)
+    raf.now = globals.now;
+  if (globals.colors !== void 0)
+    colors = globals.colors;
+  if (globals.skipAnimation != null)
+    skipAnimation = globals.skipAnimation;
+  if (globals.createStringInterpolator)
+    createStringInterpolator = globals.createStringInterpolator;
+  if (globals.requestAnimationFrame)
+    raf.use(globals.requestAnimationFrame);
+  if (globals.batchedUpdates)
+    raf.batchedUpdates = globals.batchedUpdates;
+  if (globals.willAdvance)
+    willAdvance = globals.willAdvance;
+  if (globals.frameLoop)
+    raf.frameLoop = globals.frameLoop;
+};
+
+// src/FrameLoop.ts
+var startQueue = /* @__PURE__ */ new Set();
+var currentFrame = [];
+var prevFrame = [];
+var priority = 0;
+var frameLoop = {
+  get idle() {
+    return !startQueue.size && !currentFrame.length;
+  },
+  /** Advance the given animation on every frame until idle. */
+  start(animation) {
+    if (priority > animation.priority) {
+      startQueue.add(animation);
+      raf.onStart(flushStartQueue);
+    } else {
+      startSafely(animation);
+      raf(advance);
+    }
+  },
+  /** Advance all animations by the given time. */
+  advance,
+  /** Call this when an animation's priority changes. */
+  sort(animation) {
+    if (priority) {
+      raf.onFrame(() => frameLoop.sort(animation));
+    } else {
+      const prevIndex = currentFrame.indexOf(animation);
+      if (~prevIndex) {
+        currentFrame.splice(prevIndex, 1);
+        startUnsafely(animation);
+      }
+    }
+  },
+  /**
+   * Clear all animations. For testing purposes.
+   *
+   * ☠️ Never call this from within the frameloop.
+   */
+  clear() {
+    currentFrame = [];
+    startQueue.clear();
+  }
+};
+function flushStartQueue() {
+  startQueue.forEach(startSafely);
+  startQueue.clear();
+  raf(advance);
+}
+function startSafely(animation) {
+  if (!currentFrame.includes(animation))
+    startUnsafely(animation);
+}
+function startUnsafely(animation) {
+  currentFrame.splice(
+    findIndex(currentFrame, (other) => other.priority > animation.priority),
+    0,
+    animation
+  );
+}
+function advance(dt) {
+  const nextFrame = prevFrame;
+  for (let i = 0; i < currentFrame.length; i++) {
+    const animation = currentFrame[i];
+    priority = animation.priority;
+    if (!animation.idle) {
+      willAdvance(animation);
+      animation.advance(dt);
+      if (!animation.idle) {
+        nextFrame.push(animation);
+      }
+    }
+  }
+  priority = 0;
+  prevFrame = currentFrame;
+  prevFrame.length = 0;
+  currentFrame = nextFrame;
+  return currentFrame.length > 0;
+}
+function findIndex(arr, test) {
+  const index = arr.findIndex(test);
+  return index < 0 ? arr.length : index;
+}
+
+// src/clamp.ts
+var clamp = (min, max, v) => Math.min(Math.max(v, min), max);
+
+// src/colors.ts
+var colors2 = {
+  transparent: 0,
+  aliceblue: 4042850303,
+  antiquewhite: 4209760255,
+  aqua: 16777215,
+  aquamarine: 2147472639,
+  azure: 4043309055,
+  beige: 4126530815,
+  bisque: 4293182719,
+  black: 255,
+  blanchedalmond: 4293643775,
+  blue: 65535,
+  blueviolet: 2318131967,
+  brown: 2771004159,
+  burlywood: 3736635391,
+  burntsienna: 3934150143,
+  cadetblue: 1604231423,
+  chartreuse: 2147418367,
+  chocolate: 3530104575,
+  coral: 4286533887,
+  cornflowerblue: 1687547391,
+  cornsilk: 4294499583,
+  crimson: 3692313855,
+  cyan: 16777215,
+  darkblue: 35839,
+  darkcyan: 9145343,
+  darkgoldenrod: 3095792639,
+  darkgray: 2846468607,
+  darkgreen: 6553855,
+  darkgrey: 2846468607,
+  darkkhaki: 3182914559,
+  darkmagenta: 2332068863,
+  darkolivegreen: 1433087999,
+  darkorange: 4287365375,
+  darkorchid: 2570243327,
+  darkred: 2332033279,
+  darksalmon: 3918953215,
+  darkseagreen: 2411499519,
+  darkslateblue: 1211993087,
+  darkslategray: 793726975,
+  darkslategrey: 793726975,
+  darkturquoise: 13554175,
+  darkviolet: 2483082239,
+  deeppink: 4279538687,
+  deepskyblue: 12582911,
+  dimgray: 1768516095,
+  dimgrey: 1768516095,
+  dodgerblue: 512819199,
+  firebrick: 2988581631,
+  floralwhite: 4294635775,
+  forestgreen: 579543807,
+  fuchsia: 4278255615,
+  gainsboro: 3705462015,
+  ghostwhite: 4177068031,
+  gold: 4292280575,
+  goldenrod: 3668254975,
+  gray: 2155905279,
+  green: 8388863,
+  greenyellow: 2919182335,
+  grey: 2155905279,
+  honeydew: 4043305215,
+  hotpink: 4285117695,
+  indianred: 3445382399,
+  indigo: 1258324735,
+  ivory: 4294963455,
+  khaki: 4041641215,
+  lavender: 3873897215,
+  lavenderblush: 4293981695,
+  lawngreen: 2096890111,
+  lemonchiffon: 4294626815,
+  lightblue: 2916673279,
+  lightcoral: 4034953471,
+  lightcyan: 3774873599,
+  lightgoldenrodyellow: 4210742015,
+  lightgray: 3553874943,
+  lightgreen: 2431553791,
+  lightgrey: 3553874943,
+  lightpink: 4290167295,
+  lightsalmon: 4288707327,
+  lightseagreen: 548580095,
+  lightskyblue: 2278488831,
+  lightslategray: 2005441023,
+  lightslategrey: 2005441023,
+  lightsteelblue: 2965692159,
+  lightyellow: 4294959359,
+  lime: 16711935,
+  limegreen: 852308735,
+  linen: 4210091775,
+  magenta: 4278255615,
+  maroon: 2147483903,
+  mediumaquamarine: 1724754687,
+  mediumblue: 52735,
+  mediumorchid: 3126187007,
+  mediumpurple: 2473647103,
+  mediumseagreen: 1018393087,
+  mediumslateblue: 2070474495,
+  mediumspringgreen: 16423679,
+  mediumturquoise: 1221709055,
+  mediumvioletred: 3340076543,
+  midnightblue: 421097727,
+  mintcream: 4127193855,
+  mistyrose: 4293190143,
+  moccasin: 4293178879,
+  navajowhite: 4292783615,
+  navy: 33023,
+  oldlace: 4260751103,
+  olive: 2155872511,
+  olivedrab: 1804477439,
+  orange: 4289003775,
+  orangered: 4282712319,
+  orchid: 3664828159,
+  palegoldenrod: 4008225535,
+  palegreen: 2566625535,
+  paleturquoise: 2951671551,
+  palevioletred: 3681588223,
+  papayawhip: 4293907967,
+  peachpuff: 4292524543,
+  peru: 3448061951,
+  pink: 4290825215,
+  plum: 3718307327,
+  powderblue: 2967529215,
+  purple: 2147516671,
+  rebeccapurple: 1714657791,
+  red: 4278190335,
+  rosybrown: 3163525119,
+  royalblue: 1097458175,
+  saddlebrown: 2336560127,
+  salmon: 4202722047,
+  sandybrown: 4104413439,
+  seagreen: 780883967,
+  seashell: 4294307583,
+  sienna: 2689740287,
+  silver: 3233857791,
+  skyblue: 2278484991,
+  slateblue: 1784335871,
+  slategray: 1887473919,
+  slategrey: 1887473919,
+  snow: 4294638335,
+  springgreen: 16744447,
+  steelblue: 1182971135,
+  tan: 3535047935,
+  teal: 8421631,
+  thistle: 3636451583,
+  tomato: 4284696575,
+  turquoise: 1088475391,
+  violet: 4001558271,
+  wheat: 4125012991,
+  white: 4294967295,
+  whitesmoke: 4126537215,
+  yellow: 4294902015,
+  yellowgreen: 2597139199
+};
+
+// src/colorMatchers.ts
+var NUMBER = "[-+]?\\d*\\.?\\d+";
+var PERCENTAGE = NUMBER + "%";
+function call(...parts) {
+  return "\\(\\s*(" + parts.join(")\\s*,\\s*(") + ")\\s*\\)";
+}
+var rgb = new RegExp("rgb" + call(NUMBER, NUMBER, NUMBER));
+var rgba = new RegExp("rgba" + call(NUMBER, NUMBER, NUMBER, NUMBER));
+var hsl = new RegExp("hsl" + call(NUMBER, PERCENTAGE, PERCENTAGE));
+var hsla = new RegExp(
+  "hsla" + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER)
+);
+var hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
+var hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
+var hex6 = /^#([0-9a-fA-F]{6})$/;
+var hex8 = /^#([0-9a-fA-F]{8})$/;
+
+// src/normalizeColor.ts
+function normalizeColor(color) {
+  let match;
+  if (typeof color === "number") {
+    return color >>> 0 === color && color >= 0 && color <= 4294967295 ? color : null;
+  }
+  if (match = hex6.exec(color))
+    return parseInt(match[1] + "ff", 16) >>> 0;
+  if (colors && colors[color] !== void 0) {
+    return colors[color];
+  }
+  if (match = rgb.exec(color)) {
+    return (parse255(match[1]) << 24 | // r
+    parse255(match[2]) << 16 | // g
+    parse255(match[3]) << 8 | // b
+    255) >>> // a
+    0;
+  }
+  if (match = rgba.exec(color)) {
+    return (parse255(match[1]) << 24 | // r
+    parse255(match[2]) << 16 | // g
+    parse255(match[3]) << 8 | // b
+    parse1(match[4])) >>> // a
+    0;
+  }
+  if (match = hex3.exec(color)) {
+    return parseInt(
+      match[1] + match[1] + // r
+      match[2] + match[2] + // g
+      match[3] + match[3] + // b
+      "ff",
+      // a
+      16
+    ) >>> 0;
+  }
+  if (match = hex8.exec(color))
+    return parseInt(match[1], 16) >>> 0;
+  if (match = hex4.exec(color)) {
+    return parseInt(
+      match[1] + match[1] + // r
+      match[2] + match[2] + // g
+      match[3] + match[3] + // b
+      match[4] + match[4],
+      // a
+      16
+    ) >>> 0;
+  }
+  if (match = hsl.exec(color)) {
+    return (hslToRgb(
+      parse360(match[1]),
+      // h
+      parsePercentage(match[2]),
+      // s
+      parsePercentage(match[3])
+      // l
+    ) | 255) >>> // a
+    0;
+  }
+  if (match = hsla.exec(color)) {
+    return (hslToRgb(
+      parse360(match[1]),
+      // h
+      parsePercentage(match[2]),
+      // s
+      parsePercentage(match[3])
+      // l
+    ) | parse1(match[4])) >>> // a
+    0;
+  }
+  return null;
+}
+function hue2rgb(p, q, t) {
+  if (t < 0)
+    t += 1;
+  if (t > 1)
+    t -= 1;
+  if (t < 1 / 6)
+    return p + (q - p) * 6 * t;
+  if (t < 1 / 2)
+    return q;
+  if (t < 2 / 3)
+    return p + (q - p) * (2 / 3 - t) * 6;
+  return p;
+}
+function hslToRgb(h, s, l) {
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const r = hue2rgb(p, q, h + 1 / 3);
+  const g = hue2rgb(p, q, h);
+  const b = hue2rgb(p, q, h - 1 / 3);
+  return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
+}
+function parse255(str) {
+  const int = parseInt(str, 10);
+  if (int < 0)
+    return 0;
+  if (int > 255)
+    return 255;
+  return int;
+}
+function parse360(str) {
+  const int = parseFloat(str);
+  return (int % 360 + 360) % 360 / 360;
+}
+function parse1(str) {
+  const num = parseFloat(str);
+  if (num < 0)
+    return 0;
+  if (num > 1)
+    return 255;
+  return Math.round(num * 255);
+}
+function parsePercentage(str) {
+  const int = parseFloat(str);
+  if (int < 0)
+    return 0;
+  if (int > 100)
+    return 1;
+  return int / 100;
+}
+
+// src/colorToRgba.ts
+function colorToRgba(input) {
+  let int32Color = normalizeColor(input);
+  if (int32Color === null)
+    return input;
+  int32Color = int32Color || 0;
+  const r = (int32Color & 4278190080) >>> 24;
+  const g = (int32Color & 16711680) >>> 16;
+  const b = (int32Color & 65280) >>> 8;
+  const a = (int32Color & 255) / 255;
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+
+// src/createInterpolator.ts
+var createInterpolator = (range, output, extrapolate) => {
+  if (is.fun(range)) {
+    return range;
+  }
+  if (is.arr(range)) {
+    return createInterpolator({
+      range,
+      output,
+      extrapolate
+    });
+  }
+  if (is.str(range.output[0])) {
+    return createStringInterpolator(range);
+  }
+  const config = range;
+  const outputRange = config.output;
+  const inputRange = config.range || [0, 1];
+  const extrapolateLeft = config.extrapolateLeft || config.extrapolate || "extend";
+  const extrapolateRight = config.extrapolateRight || config.extrapolate || "extend";
+  const easing = config.easing || ((t) => t);
+  return (input) => {
+    const range2 = findRange(input, inputRange);
+    return interpolate(
+      input,
+      inputRange[range2],
+      inputRange[range2 + 1],
+      outputRange[range2],
+      outputRange[range2 + 1],
+      easing,
+      extrapolateLeft,
+      extrapolateRight,
+      config.map
+    );
+  };
+};
+function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) {
+  let result = map ? map(input) : input;
+  if (result < inputMin) {
+    if (extrapolateLeft === "identity")
+      return result;
+    else if (extrapolateLeft === "clamp")
+      result = inputMin;
+  }
+  if (result > inputMax) {
+    if (extrapolateRight === "identity")
+      return result;
+    else if (extrapolateRight === "clamp")
+      result = inputMax;
+  }
+  if (outputMin === outputMax)
+    return outputMin;
+  if (inputMin === inputMax)
+    return input <= inputMin ? outputMin : outputMax;
+  if (inputMin === -Infinity)
+    result = -result;
+  else if (inputMax === Infinity)
+    result = result - inputMin;
+  else
+    result = (result - inputMin) / (inputMax - inputMin);
+  result = easing(result);
+  if (outputMin === -Infinity)
+    result = -result;
+  else if (outputMax === Infinity)
+    result = result + outputMin;
+  else
+    result = result * (outputMax - outputMin) + outputMin;
+  return result;
+}
+function findRange(input, inputRange) {
+  for (var i = 1; i < inputRange.length - 1; ++i)
+    if (inputRange[i] >= input)
+      break;
+  return i - 1;
+}
+
+// src/easings.ts
+var steps = (steps2, direction = "end") => (progress2) => {
+  progress2 = direction === "end" ? Math.min(progress2, 0.999) : Math.max(progress2, 1e-3);
+  const expanded = progress2 * steps2;
+  const rounded = direction === "end" ? Math.floor(expanded) : Math.ceil(expanded);
+  return clamp(0, 1, rounded / steps2);
+};
+var c1 = 1.70158;
+var c2 = c1 * 1.525;
+var c3 = c1 + 1;
+var c4 = 2 * Math.PI / 3;
+var c5 = 2 * Math.PI / 4.5;
+var bounceOut = (x) => {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (x < 1 / d1) {
+    return n1 * x * x;
+  } else if (x < 2 / d1) {
+    return n1 * (x -= 1.5 / d1) * x + 0.75;
+  } else if (x < 2.5 / d1) {
+    return n1 * (x -= 2.25 / d1) * x + 0.9375;
+  } else {
+    return n1 * (x -= 2.625 / d1) * x + 0.984375;
+  }
+};
+var easings = {
+  linear: (x) => x,
+  easeInQuad: (x) => x * x,
+  easeOutQuad: (x) => 1 - (1 - x) * (1 - x),
+  easeInOutQuad: (x) => x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2,
+  easeInCubic: (x) => x * x * x,
+  easeOutCubic: (x) => 1 - Math.pow(1 - x, 3),
+  easeInOutCubic: (x) => x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2,
+  easeInQuart: (x) => x * x * x * x,
+  easeOutQuart: (x) => 1 - Math.pow(1 - x, 4),
+  easeInOutQuart: (x) => x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2,
+  easeInQuint: (x) => x * x * x * x * x,
+  easeOutQuint: (x) => 1 - Math.pow(1 - x, 5),
+  easeInOutQuint: (x) => x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2,
+  easeInSine: (x) => 1 - Math.cos(x * Math.PI / 2),
+  easeOutSine: (x) => Math.sin(x * Math.PI / 2),
+  easeInOutSine: (x) => -(Math.cos(Math.PI * x) - 1) / 2,
+  easeInExpo: (x) => x === 0 ? 0 : Math.pow(2, 10 * x - 10),
+  easeOutExpo: (x) => x === 1 ? 1 : 1 - Math.pow(2, -10 * x),
+  easeInOutExpo: (x) => x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? Math.pow(2, 20 * x - 10) / 2 : (2 - Math.pow(2, -20 * x + 10)) / 2,
+  easeInCirc: (x) => 1 - Math.sqrt(1 - Math.pow(x, 2)),
+  easeOutCirc: (x) => Math.sqrt(1 - Math.pow(x - 1, 2)),
+  easeInOutCirc: (x) => x < 0.5 ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2,
+  easeInBack: (x) => c3 * x * x * x - c1 * x * x,
+  easeOutBack: (x) => 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2),
+  easeInOutBack: (x) => x < 0.5 ? Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2,
+  easeInElastic: (x) => x === 0 ? 0 : x === 1 ? 1 : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4),
+  easeOutElastic: (x) => x === 0 ? 0 : x === 1 ? 1 : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1,
+  easeInOutElastic: (x) => x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2 : Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5) / 2 + 1,
+  easeInBounce: (x) => 1 - bounceOut(1 - x),
+  easeOutBounce: bounceOut,
+  easeInOutBounce: (x) => x < 0.5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2,
+  steps
+};
+
+// src/fluids.ts
+var $get = Symbol.for("FluidValue.get");
+var $observers = Symbol.for("FluidValue.observers");
+var hasFluidValue = (arg) => Boolean(arg && arg[$get]);
+var getFluidValue = (arg) => arg && arg[$get] ? arg[$get]() : arg;
+var getFluidObservers = (target) => target[$observers] || null;
+function callFluidObserver(observer2, event) {
+  if (observer2.eventObserved) {
+    observer2.eventObserved(event);
+  } else {
+    observer2(event);
+  }
+}
+function callFluidObservers(target, event) {
+  const observers = target[$observers];
+  if (observers) {
+    observers.forEach((observer2) => {
+      callFluidObserver(observer2, event);
+    });
+  }
+}
+var FluidValue = class {
+  constructor(get) {
+    if (!get && !(get = this.get)) {
+      throw Error("Unknown getter");
+    }
+    setFluidGetter(this, get);
+  }
+};
+var setFluidGetter = (target, get) => setHidden(target, $get, get);
+function addFluidObserver(target, observer2) {
+  if (target[$get]) {
+    let observers = target[$observers];
+    if (!observers) {
+      setHidden(target, $observers, observers = /* @__PURE__ */ new Set());
+    }
+    if (!observers.has(observer2)) {
+      observers.add(observer2);
+      if (target.observerAdded) {
+        target.observerAdded(observers.size, observer2);
+      }
+    }
+  }
+  return observer2;
+}
+function removeFluidObserver(target, observer2) {
+  const observers = target[$observers];
+  if (observers && observers.has(observer2)) {
+    const count = observers.size - 1;
+    if (count) {
+      observers.delete(observer2);
+    } else {
+      target[$observers] = null;
+    }
+    if (target.observerRemoved) {
+      target.observerRemoved(count, observer2);
+    }
+  }
+}
+var setHidden = (target, key, value) => Object.defineProperty(target, key, {
+  value,
+  writable: true,
+  configurable: true
+});
+
+// src/regexs.ts
+var numberRegex = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
+var colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi;
+var unitRegex = new RegExp(`(${numberRegex.source})(%|[a-z]+)`, "i");
+var rgbaRegex = /rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi;
+var cssVariableRegex = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;
+
+// src/variableToRgba.ts
+var variableToRgba = (input) => {
+  const [token, fallback] = parseCSSVariable(input);
+  if (!token || isSSR()) {
+    return input;
+  }
+  const value = window.getComputedStyle(document.documentElement).getPropertyValue(token);
+  if (value) {
+    return value.trim();
+  } else if (fallback && fallback.startsWith("--")) {
+    const value2 = window.getComputedStyle(document.documentElement).getPropertyValue(fallback);
+    if (value2) {
+      return value2;
+    } else {
+      return input;
+    }
+  } else if (fallback && cssVariableRegex.test(fallback)) {
+    return variableToRgba(fallback);
+  } else if (fallback) {
+    return fallback;
+  }
+  return input;
+};
+var parseCSSVariable = (current) => {
+  const match = cssVariableRegex.exec(current);
+  if (!match)
+    return [,];
+  const [, token, fallback] = match;
+  return [token, fallback];
+};
+
+// src/stringInterpolation.ts
+var namedColorRegex;
+var rgbaRound = (_, p1, p2, p3, p4) => `rgba(${Math.round(p1)}, ${Math.round(p2)}, ${Math.round(p3)}, ${p4})`;
+var createStringInterpolator2 = (config) => {
+  if (!namedColorRegex)
+    namedColorRegex = colors ? (
+      // match color names, ignore partial matches
+      new RegExp(`(${Object.keys(colors).join("|")})(?!\\w)`, "g")
+    ) : (
+      // never match
+      /^\b$/
+    );
+  const output = config.output.map((value) => {
+    return getFluidValue(value).replace(cssVariableRegex, variableToRgba).replace(colorRegex, colorToRgba).replace(namedColorRegex, colorToRgba);
+  });
+  const keyframes = output.map((value) => value.match(numberRegex).map(Number));
+  const outputRanges = keyframes[0].map(
+    (_, i) => keyframes.map((values) => {
+      if (!(i in values)) {
+        throw Error('The arity of each "output" value must be equal');
+      }
+      return values[i];
+    })
+  );
+  const interpolators = outputRanges.map(
+    (output2) => createInterpolator({ ...config, output: output2 })
+  );
+  return (input) => {
+    const missingUnit = !unitRegex.test(output[0]) && output.find((value) => unitRegex.test(value))?.replace(numberRegex, "");
+    let i = 0;
+    return output[0].replace(
+      numberRegex,
+      () => `${interpolators[i++](input)}${missingUnit || ""}`
+    ).replace(rgbaRegex, rgbaRound);
+  };
+};
+
+// src/deprecations.ts
+var prefix = "react-spring: ";
+var once = (fn) => {
+  const func = fn;
+  let called = false;
+  if (typeof func != "function") {
+    throw new TypeError(`${prefix}once requires a function parameter`);
+  }
+  return (...args) => {
+    if (!called) {
+      func(...args);
+      called = true;
+    }
+  };
+};
+var warnInterpolate = once(console.warn);
+function deprecateInterpolate() {
+  warnInterpolate(
+    `${prefix}The "interpolate" function is deprecated in v9 (use "to" instead)`
+  );
+}
+var warnDirectCall = once(console.warn);
+function deprecateDirectCall() {
+  warnDirectCall(
+    `${prefix}Directly calling start instead of using the api object is deprecated in v9 (use ".start" instead), this will be removed in later 0.X.0 versions`
+  );
+}
+
+// src/isAnimatedString.ts
+function isAnimatedString(value) {
+  return is.str(value) && (value[0] == "#" || /\d/.test(value) || // Do not identify a CSS variable as an AnimatedString if its SSR
+  !isSSR() && cssVariableRegex.test(value) || value in (colors || {}));
+}
+var useIsomorphicLayoutEffect = isSSR() ? useEffect : useLayoutEffect;
+
+// src/hooks/useIsMounted.ts
+var useIsMounted = () => {
+  const isMounted = useRef(false);
+  useIsomorphicLayoutEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return isMounted;
+};
+
+// src/hooks/useForceUpdate.ts
+function useForceUpdate() {
+  const update2 = useState()[1];
+  const isMounted = useIsMounted();
+  return () => {
+    if (isMounted.current) {
+      update2(Math.random());
+    }
+  };
+}
+function useMemoOne(getResult, inputs) {
+  const [initial] = useState(
+    () => ({
+      inputs,
+      result: getResult()
+    })
+  );
+  const committed = useRef();
+  const prevCache = committed.current;
+  let cache = prevCache;
+  if (cache) {
+    const useCache = Boolean(
+      inputs && cache.inputs && areInputsEqual(inputs, cache.inputs)
+    );
+    if (!useCache) {
+      cache = {
+        inputs,
+        result: getResult()
+      };
+    }
+  } else {
+    cache = initial;
+  }
+  useEffect(() => {
+    committed.current = cache;
+    if (prevCache == initial) {
+      initial.inputs = initial.result = void 0;
+    }
+  }, [cache]);
+  return cache.result;
+}
+function areInputsEqual(next, prev) {
+  if (next.length !== prev.length) {
+    return false;
+  }
+  for (let i = 0; i < next.length; i++) {
+    if (next[i] !== prev[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+var useOnce = (effect) => useEffect(effect, emptyDeps);
+var emptyDeps = [];
+function usePrev(value) {
+  const prevRef = useRef();
+  useEffect(() => {
+    prevRef.current = value;
+  });
+  return prevRef.current;
+}
+
+// src/Animated.ts
+var $node = Symbol.for("Animated:node");
+var isAnimated = (value) => !!value && value[$node] === value;
+var getAnimated = (owner) => owner && owner[$node];
+var setAnimated = (owner, node) => defineHidden(owner, $node, node);
+var getPayload = (owner) => owner && owner[$node] && owner[$node].getPayload();
+var Animated = class {
+  constructor() {
+    setAnimated(this, this);
+  }
+  /** Get every `AnimatedValue` used by this node. */
+  getPayload() {
+    return this.payload || [];
+  }
+};
+var AnimatedValue = class extends Animated {
+  constructor(_value) {
+    super();
+    this._value = _value;
+    this.done = true;
+    this.durationProgress = 0;
+    if (is.num(this._value)) {
+      this.lastPosition = this._value;
+    }
+  }
+  /** @internal */
+  static create(value) {
+    return new AnimatedValue(value);
+  }
+  getPayload() {
+    return [this];
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(value, step) {
+    if (is.num(value)) {
+      this.lastPosition = value;
+      if (step) {
+        value = Math.round(value / step) * step;
+        if (this.done) {
+          this.lastPosition = value;
+        }
+      }
+    }
+    if (this._value === value) {
+      return false;
+    }
+    this._value = value;
+    return true;
+  }
+  reset() {
+    const { done } = this;
+    this.done = false;
+    if (is.num(this._value)) {
+      this.elapsedTime = 0;
+      this.durationProgress = 0;
+      this.lastPosition = this._value;
+      if (done)
+        this.lastVelocity = null;
+      this.v0 = null;
+    }
+  }
+};
+var AnimatedString = class extends AnimatedValue {
+  constructor(value) {
+    super(0);
+    this._string = null;
+    this._toString = createInterpolator({
+      output: [value, value]
+    });
+  }
+  /** @internal */
+  static create(value) {
+    return new AnimatedString(value);
+  }
+  getValue() {
+    const value = this._string;
+    return value == null ? this._string = this._toString(this._value) : value;
+  }
+  setValue(value) {
+    if (is.str(value)) {
+      if (value == this._string) {
+        return false;
+      }
+      this._string = value;
+      this._value = 1;
+    } else if (super.setValue(value)) {
+      this._string = null;
+    } else {
+      return false;
+    }
+    return true;
+  }
+  reset(goal) {
+    if (goal) {
+      this._toString = createInterpolator({
+        output: [this.getValue(), goal]
+      });
+    }
+    this._value = 0;
+    super.reset();
+  }
+};
+
+// src/context.ts
+var TreeContext = { dependencies: null };
+
+// src/AnimatedObject.ts
+var AnimatedObject = class extends Animated {
+  constructor(source) {
+    super();
+    this.source = source;
+    this.setValue(source);
+  }
+  getValue(animated) {
+    const values = {};
+    eachProp(this.source, (source, key) => {
+      if (isAnimated(source)) {
+        values[key] = source.getValue(animated);
+      } else if (hasFluidValue(source)) {
+        values[key] = getFluidValue(source);
+      } else if (!animated) {
+        values[key] = source;
+      }
+    });
+    return values;
+  }
+  /** Replace the raw object data */
+  setValue(source) {
+    this.source = source;
+    this.payload = this._makePayload(source);
+  }
+  reset() {
+    if (this.payload) {
+      each(this.payload, (node) => node.reset());
+    }
+  }
+  /** Create a payload set. */
+  _makePayload(source) {
+    if (source) {
+      const payload = /* @__PURE__ */ new Set();
+      eachProp(source, this._addToPayload, payload);
+      return Array.from(payload);
+    }
+  }
+  /** Add to a payload set. */
+  _addToPayload(source) {
+    if (TreeContext.dependencies && hasFluidValue(source)) {
+      TreeContext.dependencies.add(source);
+    }
+    const payload = getPayload(source);
+    if (payload) {
+      each(payload, (node) => this.add(node));
+    }
+  }
+};
+
+// src/AnimatedArray.ts
+var AnimatedArray = class extends AnimatedObject {
+  constructor(source) {
+    super(source);
+  }
+  /** @internal */
+  static create(source) {
+    return new AnimatedArray(source);
+  }
+  getValue() {
+    return this.source.map((node) => node.getValue());
+  }
+  setValue(source) {
+    const payload = this.getPayload();
+    if (source.length == payload.length) {
+      return payload.map((node, i) => node.setValue(source[i])).some(Boolean);
+    }
+    super.setValue(source.map(makeAnimated));
+    return true;
+  }
+};
+function makeAnimated(value) {
+  const nodeType = isAnimatedString(value) ? AnimatedString : AnimatedValue;
+  return nodeType.create(value);
+}
+function getAnimatedType(value) {
+  const parentNode = getAnimated(value);
+  return parentNode ? parentNode.constructor : is.arr(value) ? AnimatedArray : isAnimatedString(value) ? AnimatedString : AnimatedValue;
+}
+var withAnimated = (Component, host) => {
+  const hasInstance = (
+    // Function components must use "forwardRef" to avoid being
+    // re-rendered on every animation frame.
+    !is.fun(Component) || Component.prototype && Component.prototype.isReactComponent
+  );
+  return forwardRef((givenProps, givenRef) => {
+    const instanceRef = useRef(null);
+    const ref = hasInstance && // eslint-disable-next-line react-hooks/rules-of-hooks
+    useCallback(
+      (value) => {
+        instanceRef.current = updateRef(givenRef, value);
+      },
+      [givenRef]
+    );
+    const [props, deps] = getAnimatedState(givenProps, host);
+    const forceUpdate = useForceUpdate();
+    const callback = () => {
+      const instance = instanceRef.current;
+      if (hasInstance && !instance) {
+        return;
+      }
+      const didUpdate = instance ? host.applyAnimatedValues(instance, props.getValue(true)) : false;
+      if (didUpdate === false) {
+        forceUpdate();
+      }
+    };
+    const observer = new PropsObserver(callback, deps);
+    const observerRef = useRef();
+    useIsomorphicLayoutEffect(() => {
+      observerRef.current = observer;
+      each(deps, (dep) => addFluidObserver(dep, observer));
+      return () => {
+        if (observerRef.current) {
+          each(
+            observerRef.current.deps,
+            (dep) => removeFluidObserver(dep, observerRef.current)
+          );
+          raf.cancel(observerRef.current.update);
+        }
+      };
+    });
+    useEffect(callback, []);
+    useOnce(() => () => {
+      const observer2 = observerRef.current;
+      each(observer2.deps, (dep) => removeFluidObserver(dep, observer2));
+    });
+    const usedProps = host.getComponentProps(props.getValue());
+    return /* @__PURE__ */ React.createElement(Component, { ...usedProps, ref });
+  });
+};
+var PropsObserver = class {
+  constructor(update, deps) {
+    this.update = update;
+    this.deps = deps;
+  }
+  eventObserved(event) {
+    if (event.type == "change") {
+      raf.write(this.update);
+    }
+  }
+};
+function getAnimatedState(props, host) {
+  const dependencies = /* @__PURE__ */ new Set();
+  TreeContext.dependencies = dependencies;
+  if (props.style)
+    props = {
+      ...props,
+      style: host.createAnimatedStyle(props.style)
+    };
+  props = new AnimatedObject(props);
+  TreeContext.dependencies = null;
+  return [props, dependencies];
+}
+function updateRef(ref, value) {
+  if (ref) {
+    if (is.fun(ref))
+      ref(value);
+    else
+      ref.current = value;
+  }
+  return value;
+}
+
+// src/createHost.ts
+var cacheKey = Symbol.for("AnimatedComponent");
+var createHost = (components, {
+  applyAnimatedValues = () => false,
+  createAnimatedStyle = (style) => new AnimatedObject(style),
+  getComponentProps = (props) => props
+} = {}) => {
+  const hostConfig = {
+    applyAnimatedValues,
+    createAnimatedStyle,
+    getComponentProps
+  };
+  const animated = (Component) => {
+    const displayName = getDisplayName(Component) || "Anonymous";
+    if (is.str(Component)) {
+      Component = animated[Component] || (animated[Component] = withAnimated(Component, hostConfig));
+    } else {
+      Component = Component[cacheKey] || (Component[cacheKey] = withAnimated(Component, hostConfig));
+    }
+    Component.displayName = `Animated(${displayName})`;
+    return Component;
+  };
+  eachProp(components, (Component, key) => {
+    if (is.arr(components)) {
+      key = getDisplayName(Component);
+    }
+    animated[key] = animated(Component);
+  });
+  return {
+    animated
+  };
+};
+var getDisplayName = (arg) => is.str(arg) ? arg : arg && is.str(arg.displayName) ? arg.displayName : is.fun(arg) && arg.name || null;
+
+// src/hooks/useChain.ts
+function callProp(value, ...args) {
+  return is.fun(value) ? value(...args) : value;
+}
+var matchProp = (value, key) => value === true || !!(key && value && (is.fun(value) ? value(key) : toArray(value).includes(key)));
+var resolveProp = (prop, key) => is.obj(prop) ? key && prop[key] : prop;
+var getDefaultProp = (props, key) => props.default === true ? props[key] : props.default ? props.default[key] : void 0;
+var noopTransform = (value) => value;
+var getDefaultProps = (props, transform = noopTransform) => {
+  let keys = DEFAULT_PROPS$b;
+  if (props.default && props.default !== true) {
+    props = props.default;
+    keys = Object.keys(props);
+  }
+  const defaults2 = {};
+  for (const key of keys) {
+    const value = transform(props[key], key);
+    if (!is.und(value)) {
+      defaults2[key] = value;
+    }
+  }
+  return defaults2;
+};
+var DEFAULT_PROPS$b = [
+  "config",
+  "onProps",
+  "onStart",
+  "onChange",
+  "onPause",
+  "onResume",
+  "onRest"
+];
+var RESERVED_PROPS = {
+  config: 1,
+  from: 1,
+  to: 1,
+  ref: 1,
+  loop: 1,
+  reset: 1,
+  pause: 1,
+  cancel: 1,
+  reverse: 1,
+  immediate: 1,
+  default: 1,
+  delay: 1,
+  onProps: 1,
+  onStart: 1,
+  onChange: 1,
+  onPause: 1,
+  onResume: 1,
+  onRest: 1,
+  onResolve: 1,
+  // Transition props
+  items: 1,
+  trail: 1,
+  sort: 1,
+  expires: 1,
+  initial: 1,
+  enter: 1,
+  update: 1,
+  leave: 1,
+  children: 1,
+  onDestroyed: 1,
+  // Internal props
+  keys: 1,
+  callId: 1,
+  parentId: 1
+};
+function getForwardProps(props) {
+  const forward = {};
+  let count = 0;
+  eachProp(props, (value, prop) => {
+    if (!RESERVED_PROPS[prop]) {
+      forward[prop] = value;
+      count++;
+    }
+  });
+  if (count) {
+    return forward;
+  }
+}
+function inferTo(props) {
+  const to2 = getForwardProps(props);
+  if (to2) {
+    const out = { to: to2 };
+    eachProp(props, (val, key) => key in to2 || (out[key] = val));
+    return out;
+  }
+  return { ...props };
+}
+function computeGoal(value) {
+  value = getFluidValue(value);
+  return is.arr(value) ? value.map(computeGoal) : isAnimatedString(value) ? globals_exports.createStringInterpolator({
+    range: [0, 1],
+    output: [value, value]
+  })(1) : value;
+}
+function hasProps(props) {
+  for (const _ in props)
+    return true;
+  return false;
+}
+function isAsyncTo(to2) {
+  return is.fun(to2) || is.arr(to2) && is.obj(to2[0]);
+}
+function detachRefs(ctrl, ref) {
+  ctrl.ref?.delete(ctrl);
+  ref?.delete(ctrl);
+}
+function replaceRef(ctrl, ref) {
+  if (ref && ctrl.ref !== ref) {
+    ctrl.ref?.delete(ctrl);
+    ref.add(ctrl);
+    ctrl.ref = ref;
+  }
+}
+
+// src/constants.ts
+var config$1 = {
+  default: { tension: 170, friction: 26 },
+  gentle: { tension: 120, friction: 14 },
+  wobbly: { tension: 180, friction: 12 },
+  stiff: { tension: 210, friction: 20 },
+  slow: { tension: 280, friction: 60 },
+  molasses: { tension: 280, friction: 120 }
+};
+
+// src/AnimationConfig.ts
+var defaults = {
+  ...config$1.default,
+  mass: 1,
+  damping: 1,
+  easing: easings.linear,
+  clamp: false
+};
+var AnimationConfig = class {
+  constructor() {
+    /**
+     * The initial velocity of one or more values.
+     *
+     * @default 0
+     */
+    this.velocity = 0;
+    Object.assign(this, defaults);
+  }
+};
+function mergeConfig(config2, newConfig, defaultConfig) {
+  if (defaultConfig) {
+    defaultConfig = { ...defaultConfig };
+    sanitizeConfig(defaultConfig, newConfig);
+    newConfig = { ...defaultConfig, ...newConfig };
+  }
+  sanitizeConfig(config2, newConfig);
+  Object.assign(config2, newConfig);
+  for (const key in defaults) {
+    if (config2[key] == null) {
+      config2[key] = defaults[key];
+    }
+  }
+  let { frequency, damping } = config2;
+  const { mass } = config2;
+  if (!is.und(frequency)) {
+    if (frequency < 0.01)
+      frequency = 0.01;
+    if (damping < 0)
+      damping = 0;
+    config2.tension = Math.pow(2 * Math.PI / frequency, 2) * mass;
+    config2.friction = 4 * Math.PI * damping * mass / frequency;
+  }
+  return config2;
+}
+function sanitizeConfig(config2, props) {
+  if (!is.und(props.decay)) {
+    config2.duration = void 0;
+  } else {
+    const isTensionConfig = !is.und(props.tension) || !is.und(props.friction);
+    if (isTensionConfig || !is.und(props.frequency) || !is.und(props.damping) || !is.und(props.mass)) {
+      config2.duration = void 0;
+      config2.decay = void 0;
+    }
+    if (isTensionConfig) {
+      config2.frequency = void 0;
+    }
+  }
+}
+
+// src/Animation.ts
+var emptyArray = [];
+var Animation = class {
+  constructor() {
+    this.changed = false;
+    this.values = emptyArray;
+    this.toValues = null;
+    this.fromValues = emptyArray;
+    this.config = new AnimationConfig();
+    this.immediate = false;
+  }
+};
+function scheduleProps(callId, { key, props, defaultProps, state, actions }) {
+  return new Promise((resolve, reject) => {
+    let delay;
+    let timeout;
+    let cancel = matchProp(props.cancel ?? defaultProps?.cancel, key);
+    if (cancel) {
+      onStart();
+    } else {
+      if (!is.und(props.pause)) {
+        state.paused = matchProp(props.pause, key);
+      }
+      let pause = defaultProps?.pause;
+      if (pause !== true) {
+        pause = state.paused || matchProp(pause, key);
+      }
+      delay = callProp(props.delay || 0, key);
+      if (pause) {
+        state.resumeQueue.add(onResume);
+        actions.pause();
+      } else {
+        actions.resume();
+        onResume();
+      }
+    }
+    function onPause() {
+      state.resumeQueue.add(onResume);
+      state.timeouts.delete(timeout);
+      timeout.cancel();
+      delay = timeout.time - raf.now();
+    }
+    function onResume() {
+      if (delay > 0 && !globals_exports.skipAnimation) {
+        state.delayed = true;
+        timeout = raf.setTimeout(onStart, delay);
+        state.pauseQueue.add(onPause);
+        state.timeouts.add(timeout);
+      } else {
+        onStart();
+      }
+    }
+    function onStart() {
+      if (state.delayed) {
+        state.delayed = false;
+      }
+      state.pauseQueue.delete(onPause);
+      state.timeouts.delete(timeout);
+      if (callId <= (state.cancelId || 0)) {
+        cancel = true;
+      }
+      try {
+        actions.start({ ...props, callId, cancel }, resolve);
+      } catch (err) {
+        reject(err);
+      }
+    }
+  });
+}
+
+// src/AnimationResult.ts
+var getCombinedResult = (target, results) => results.length == 1 ? results[0] : results.some((result) => result.cancelled) ? getCancelledResult(target.get()) : results.every((result) => result.noop) ? getNoopResult(target.get()) : getFinishedResult(
+  target.get(),
+  results.every((result) => result.finished)
+);
+var getNoopResult = (value) => ({
+  value,
+  noop: true,
+  finished: true,
+  cancelled: false
+});
+var getFinishedResult = (value, finished, cancelled = false) => ({
+  value,
+  finished,
+  cancelled
+});
+var getCancelledResult = (value) => ({
+  value,
+  cancelled: true,
+  finished: false
+});
+
+// src/runAsync.ts
+function runAsync(to2, props, state, target) {
+  const { callId, parentId, onRest } = props;
+  const { asyncTo: prevTo, promise: prevPromise } = state;
+  if (!parentId && to2 === prevTo && !props.reset) {
+    return prevPromise;
+  }
+  return state.promise = (async () => {
+    state.asyncId = callId;
+    state.asyncTo = to2;
+    const defaultProps = getDefaultProps(
+      props,
+      (value, key) => (
+        // The `onRest` prop is only called when the `runAsync` promise is resolved.
+        key === "onRest" ? void 0 : value
+      )
+    );
+    let preventBail;
+    let bail;
+    const bailPromise = new Promise(
+      (resolve, reject) => (preventBail = resolve, bail = reject)
+    );
+    const bailIfEnded = (bailSignal) => {
+      const bailResult = (
+        // The `cancel` prop or `stop` method was used.
+        callId <= (state.cancelId || 0) && getCancelledResult(target) || // The async `to` prop was replaced.
+        callId !== state.asyncId && getFinishedResult(target, false)
+      );
+      if (bailResult) {
+        bailSignal.result = bailResult;
+        bail(bailSignal);
+        throw bailSignal;
+      }
+    };
+    const animate = (arg1, arg2) => {
+      const bailSignal = new BailSignal();
+      const skipAnimationSignal = new SkipAnimationSignal();
+      return (async () => {
+        if (globals_exports.skipAnimation) {
+          stopAsync(state);
+          skipAnimationSignal.result = getFinishedResult(target, false);
+          bail(skipAnimationSignal);
+          throw skipAnimationSignal;
+        }
+        bailIfEnded(bailSignal);
+        const props2 = is.obj(arg1) ? { ...arg1 } : { ...arg2, to: arg1 };
+        props2.parentId = callId;
+        eachProp(defaultProps, (value, key) => {
+          if (is.und(props2[key])) {
+            props2[key] = value;
+          }
+        });
+        const result2 = await target.start(props2);
+        bailIfEnded(bailSignal);
+        if (state.paused) {
+          await new Promise((resume) => {
+            state.resumeQueue.add(resume);
+          });
+        }
+        return result2;
+      })();
+    };
+    let result;
+    if (globals_exports.skipAnimation) {
+      stopAsync(state);
+      return getFinishedResult(target, false);
+    }
+    try {
+      let animating;
+      if (is.arr(to2)) {
+        animating = (async (queue) => {
+          for (const props2 of queue) {
+            await animate(props2);
+          }
+        })(to2);
+      } else {
+        animating = Promise.resolve(to2(animate, target.stop.bind(target)));
+      }
+      await Promise.all([animating.then(preventBail), bailPromise]);
+      result = getFinishedResult(target.get(), true, false);
+    } catch (err) {
+      if (err instanceof BailSignal) {
+        result = err.result;
+      } else if (err instanceof SkipAnimationSignal) {
+        result = err.result;
+      } else {
+        throw err;
+      }
+    } finally {
+      if (callId == state.asyncId) {
+        state.asyncId = parentId;
+        state.asyncTo = parentId ? prevTo : void 0;
+        state.promise = parentId ? prevPromise : void 0;
+      }
+    }
+    if (is.fun(onRest)) {
+      raf.batchedUpdates(() => {
+        onRest(result, target, target.item);
+      });
+    }
+    return result;
+  })();
+}
+function stopAsync(state, cancelId) {
+  flush(state.timeouts, (t) => t.cancel());
+  state.pauseQueue.clear();
+  state.resumeQueue.clear();
+  state.asyncId = state.asyncTo = state.promise = void 0;
+  if (cancelId)
+    state.cancelId = cancelId;
+}
+var BailSignal = class extends Error {
+  constructor() {
+    super(
+      "An async animation has been interrupted. You see this error because you forgot to use `await` or `.catch(...)` on its returned promise."
+    );
+  }
+};
+var SkipAnimationSignal = class extends Error {
+  constructor() {
+    super("SkipAnimationSignal");
+  }
+};
+var isFrameValue = (value) => value instanceof FrameValue;
+var nextId = 1;
+var FrameValue = class extends FluidValue {
+  constructor() {
+    super(...arguments);
+    this.id = nextId++;
+    this._priority = 0;
+  }
+  get priority() {
+    return this._priority;
+  }
+  set priority(priority) {
+    if (this._priority != priority) {
+      this._priority = priority;
+      this._onPriorityChange(priority);
+    }
+  }
+  /** Get the current value */
+  get() {
+    const node = getAnimated(this);
+    return node && node.getValue();
+  }
+  /** Create a spring that maps our value to another value */
+  to(...args) {
+    return globals_exports.to(this, args);
+  }
+  /** @deprecated Use the `to` method instead. */
+  interpolate(...args) {
+    deprecateInterpolate();
+    return globals_exports.to(this, args);
+  }
+  toJSON() {
+    return this.get();
+  }
+  observerAdded(count) {
+    if (count == 1)
+      this._attach();
+  }
+  observerRemoved(count) {
+    if (count == 0)
+      this._detach();
+  }
+  /** Called when the first child is added. */
+  _attach() {
+  }
+  /** Called when the last child is removed. */
+  _detach() {
+  }
+  /** Tell our children about our new value */
+  _onChange(value, idle = false) {
+    callFluidObservers(this, {
+      type: "change",
+      parent: this,
+      value,
+      idle
+    });
+  }
+  /** Tell our children about our new priority */
+  _onPriorityChange(priority) {
+    if (!this.idle) {
+      frameLoop.sort(this);
+    }
+    callFluidObservers(this, {
+      type: "priority",
+      parent: this,
+      priority
+    });
+  }
+};
+
+// src/SpringPhase.ts
+var $P = Symbol.for("SpringPhase");
+var HAS_ANIMATED = 1;
+var IS_ANIMATING = 2;
+var IS_PAUSED = 4;
+var hasAnimated = (target) => (target[$P] & HAS_ANIMATED) > 0;
+var isAnimating = (target) => (target[$P] & IS_ANIMATING) > 0;
+var isPaused = (target) => (target[$P] & IS_PAUSED) > 0;
+var setActiveBit = (target, active) => active ? target[$P] |= IS_ANIMATING | HAS_ANIMATED : target[$P] &= ~IS_ANIMATING;
+var setPausedBit = (target, paused) => paused ? target[$P] |= IS_PAUSED : target[$P] &= ~IS_PAUSED;
+
+// src/SpringValue.ts
+var SpringValue = class extends FrameValue {
+  constructor(arg1, arg2) {
+    super();
+    /** The animation state */
+    this.animation = new Animation();
+    /** Some props have customizable default values */
+    this.defaultProps = {};
+    /** The state for `runAsync` calls */
+    this._state = {
+      paused: false,
+      delayed: false,
+      pauseQueue: /* @__PURE__ */ new Set(),
+      resumeQueue: /* @__PURE__ */ new Set(),
+      timeouts: /* @__PURE__ */ new Set()
+    };
+    /** The promise resolvers of pending `start` calls */
+    this._pendingCalls = /* @__PURE__ */ new Set();
+    /** The counter for tracking `scheduleProps` calls */
+    this._lastCallId = 0;
+    /** The last `scheduleProps` call that changed the `to` prop */
+    this._lastToId = 0;
+    this._memoizedDuration = 0;
+    if (!is.und(arg1) || !is.und(arg2)) {
+      const props = is.obj(arg1) ? { ...arg1 } : { ...arg2, from: arg1 };
+      if (is.und(props.default)) {
+        props.default = true;
+      }
+      this.start(props);
+    }
+  }
+  /** Equals true when not advancing on each frame. */
+  get idle() {
+    return !(isAnimating(this) || this._state.asyncTo) || isPaused(this);
+  }
+  get goal() {
+    return getFluidValue(this.animation.to);
+  }
+  get velocity() {
+    const node = getAnimated(this);
+    return node instanceof AnimatedValue ? node.lastVelocity || 0 : node.getPayload().map((node2) => node2.lastVelocity || 0);
+  }
+  /**
+   * When true, this value has been animated at least once.
+   */
+  get hasAnimated() {
+    return hasAnimated(this);
+  }
+  /**
+   * When true, this value has an unfinished animation,
+   * which is either active or paused.
+   */
+  get isAnimating() {
+    return isAnimating(this);
+  }
+  /**
+   * When true, all current and future animations are paused.
+   */
+  get isPaused() {
+    return isPaused(this);
+  }
+  /**
+   *
+   *
+   */
+  get isDelayed() {
+    return this._state.delayed;
+  }
+  /** Advance the current animation by a number of milliseconds */
+  advance(dt) {
+    let idle = true;
+    let changed = false;
+    const anim = this.animation;
+    let { toValues } = anim;
+    const { config: config2 } = anim;
+    const payload = getPayload(anim.to);
+    if (!payload && hasFluidValue(anim.to)) {
+      toValues = toArray(getFluidValue(anim.to));
+    }
+    anim.values.forEach((node2, i) => {
+      if (node2.done)
+        return;
+      const to2 = (
+        // Animated strings always go from 0 to 1.
+        node2.constructor == AnimatedString ? 1 : payload ? payload[i].lastPosition : toValues[i]
+      );
+      let finished = anim.immediate;
+      let position = to2;
+      if (!finished) {
+        position = node2.lastPosition;
+        if (config2.tension <= 0) {
+          node2.done = true;
+          return;
+        }
+        let elapsed = node2.elapsedTime += dt;
+        const from = anim.fromValues[i];
+        const v0 = node2.v0 != null ? node2.v0 : node2.v0 = is.arr(config2.velocity) ? config2.velocity[i] : config2.velocity;
+        let velocity;
+        const precision = config2.precision || (from == to2 ? 5e-3 : Math.min(1, Math.abs(to2 - from) * 1e-3));
+        if (!is.und(config2.duration)) {
+          let p = 1;
+          if (config2.duration > 0) {
+            if (this._memoizedDuration !== config2.duration) {
+              this._memoizedDuration = config2.duration;
+              if (node2.durationProgress > 0) {
+                node2.elapsedTime = config2.duration * node2.durationProgress;
+                elapsed = node2.elapsedTime += dt;
+              }
+            }
+            p = (config2.progress || 0) + elapsed / this._memoizedDuration;
+            p = p > 1 ? 1 : p < 0 ? 0 : p;
+            node2.durationProgress = p;
+          }
+          position = from + config2.easing(p) * (to2 - from);
+          velocity = (position - node2.lastPosition) / dt;
+          finished = p == 1;
+        } else if (config2.decay) {
+          const decay = config2.decay === true ? 0.998 : config2.decay;
+          const e = Math.exp(-(1 - decay) * elapsed);
+          position = from + v0 / (1 - decay) * (1 - e);
+          finished = Math.abs(node2.lastPosition - position) <= precision;
+          velocity = v0 * e;
+        } else {
+          velocity = node2.lastVelocity == null ? v0 : node2.lastVelocity;
+          const restVelocity = config2.restVelocity || precision / 10;
+          const bounceFactor = config2.clamp ? 0 : config2.bounce;
+          const canBounce = !is.und(bounceFactor);
+          const isGrowing = from == to2 ? node2.v0 > 0 : from < to2;
+          let isMoving;
+          let isBouncing = false;
+          const step = 1;
+          const numSteps = Math.ceil(dt / step);
+          for (let n = 0; n < numSteps; ++n) {
+            isMoving = Math.abs(velocity) > restVelocity;
+            if (!isMoving) {
+              finished = Math.abs(to2 - position) <= precision;
+              if (finished) {
+                break;
+              }
+            }
+            if (canBounce) {
+              isBouncing = position == to2 || position > to2 == isGrowing;
+              if (isBouncing) {
+                velocity = -velocity * bounceFactor;
+                position = to2;
+              }
+            }
+            const springForce = -config2.tension * 1e-6 * (position - to2);
+            const dampingForce = -config2.friction * 1e-3 * velocity;
+            const acceleration = (springForce + dampingForce) / config2.mass;
+            velocity = velocity + acceleration * step;
+            position = position + velocity * step;
+          }
+        }
+        node2.lastVelocity = velocity;
+        if (Number.isNaN(position)) {
+          console.warn(`Got NaN while animating:`, this);
+          finished = true;
+        }
+      }
+      if (payload && !payload[i].done) {
+        finished = false;
+      }
+      if (finished) {
+        node2.done = true;
+      } else {
+        idle = false;
+      }
+      if (node2.setValue(position, config2.round)) {
+        changed = true;
+      }
+    });
+    const node = getAnimated(this);
+    const currVal = node.getValue();
+    if (idle) {
+      const finalVal = getFluidValue(anim.to);
+      if ((currVal !== finalVal || changed) && !config2.decay) {
+        node.setValue(finalVal);
+        this._onChange(finalVal);
+      } else if (changed && config2.decay) {
+        this._onChange(currVal);
+      }
+      this._stop();
+    } else if (changed) {
+      this._onChange(currVal);
+    }
+  }
+  /** Set the current value, while stopping the current animation */
+  set(value) {
+    raf.batchedUpdates(() => {
+      this._stop();
+      this._focus(value);
+      this._set(value);
+    });
+    return this;
+  }
+  /**
+   * Freeze the active animation in time, as well as any updates merged
+   * before `resume` is called.
+   */
+  pause() {
+    this._update({ pause: true });
+  }
+  /** Resume the animation if paused. */
+  resume() {
+    this._update({ pause: false });
+  }
+  /** Skip to the end of the current animation. */
+  finish() {
+    if (isAnimating(this)) {
+      const { to: to2, config: config2 } = this.animation;
+      raf.batchedUpdates(() => {
+        this._onStart();
+        if (!config2.decay) {
+          this._set(to2, false);
+        }
+        this._stop();
+      });
+    }
+    return this;
+  }
+  /** Push props into the pending queue. */
+  update(props) {
+    const queue = this.queue || (this.queue = []);
+    queue.push(props);
+    return this;
+  }
+  start(to2, arg2) {
+    let queue;
+    if (!is.und(to2)) {
+      queue = [is.obj(to2) ? to2 : { ...arg2, to: to2 }];
+    } else {
+      queue = this.queue || [];
+      this.queue = [];
+    }
+    return Promise.all(
+      queue.map((props) => {
+        const up = this._update(props);
+        return up;
+      })
+    ).then((results) => getCombinedResult(this, results));
+  }
+  /**
+   * Stop the current animation, and cancel any delayed updates.
+   *
+   * Pass `true` to call `onRest` with `cancelled: true`.
+   */
+  stop(cancel) {
+    const { to: to2 } = this.animation;
+    this._focus(this.get());
+    stopAsync(this._state, cancel && this._lastCallId);
+    raf.batchedUpdates(() => this._stop(to2, cancel));
+    return this;
+  }
+  /** Restart the animation. */
+  reset() {
+    this._update({ reset: true });
+  }
+  /** @internal */
+  eventObserved(event) {
+    if (event.type == "change") {
+      this._start();
+    } else if (event.type == "priority") {
+      this.priority = event.priority + 1;
+    }
+  }
+  /**
+   * Parse the `to` and `from` range from the given `props` object.
+   *
+   * This also ensures the initial value is available to animated components
+   * during the render phase.
+   */
+  _prepareNode(props) {
+    const key = this.key || "";
+    let { to: to2, from } = props;
+    to2 = is.obj(to2) ? to2[key] : to2;
+    if (to2 == null || isAsyncTo(to2)) {
+      to2 = void 0;
+    }
+    from = is.obj(from) ? from[key] : from;
+    if (from == null) {
+      from = void 0;
+    }
+    const range = { to: to2, from };
+    if (!hasAnimated(this)) {
+      if (props.reverse)
+        [to2, from] = [from, to2];
+      from = getFluidValue(from);
+      if (!is.und(from)) {
+        this._set(from);
+      } else if (!getAnimated(this)) {
+        this._set(to2);
+      }
+    }
+    return range;
+  }
+  /** Every update is processed by this method before merging. */
+  _update({ ...props }, isLoop) {
+    const { key, defaultProps } = this;
+    if (props.default)
+      Object.assign(
+        defaultProps,
+        getDefaultProps(
+          props,
+          (value, prop) => /^on/.test(prop) ? resolveProp(value, key) : value
+        )
+      );
+    mergeActiveFn(this, props, "onProps");
+    sendEvent(this, "onProps", props, this);
+    const range = this._prepareNode(props);
+    if (Object.isFrozen(this)) {
+      throw Error(
+        "Cannot animate a `SpringValue` object that is frozen. Did you forget to pass your component to `animated(...)` before animating its props?"
+      );
+    }
+    const state = this._state;
+    return scheduleProps(++this._lastCallId, {
+      key,
+      props,
+      defaultProps,
+      state,
+      actions: {
+        pause: () => {
+          if (!isPaused(this)) {
+            setPausedBit(this, true);
+            flushCalls(state.pauseQueue);
+            sendEvent(
+              this,
+              "onPause",
+              getFinishedResult(this, checkFinished(this, this.animation.to)),
+              this
+            );
+          }
+        },
+        resume: () => {
+          if (isPaused(this)) {
+            setPausedBit(this, false);
+            if (isAnimating(this)) {
+              this._resume();
+            }
+            flushCalls(state.resumeQueue);
+            sendEvent(
+              this,
+              "onResume",
+              getFinishedResult(this, checkFinished(this, this.animation.to)),
+              this
+            );
+          }
+        },
+        start: this._merge.bind(this, range)
+      }
+    }).then((result) => {
+      if (props.loop && result.finished && !(isLoop && result.noop)) {
+        const nextProps = createLoopUpdate(props);
+        if (nextProps) {
+          return this._update(nextProps, true);
+        }
+      }
+      return result;
+    });
+  }
+  /** Merge props into the current animation */
+  _merge(range, props, resolve) {
+    if (props.cancel) {
+      this.stop(true);
+      return resolve(getCancelledResult(this));
+    }
+    const hasToProp = !is.und(range.to);
+    const hasFromProp = !is.und(range.from);
+    if (hasToProp || hasFromProp) {
+      if (props.callId > this._lastToId) {
+        this._lastToId = props.callId;
+      } else {
+        return resolve(getCancelledResult(this));
+      }
+    }
+    const { key, defaultProps, animation: anim } = this;
+    const { to: prevTo, from: prevFrom } = anim;
+    let { to: to2 = prevTo, from = prevFrom } = range;
+    if (hasFromProp && !hasToProp && (!props.default || is.und(to2))) {
+      to2 = from;
+    }
+    if (props.reverse)
+      [to2, from] = [from, to2];
+    const hasFromChanged = !isEqual(from, prevFrom);
+    if (hasFromChanged) {
+      anim.from = from;
+    }
+    from = getFluidValue(from);
+    const hasToChanged = !isEqual(to2, prevTo);
+    if (hasToChanged) {
+      this._focus(to2);
+    }
+    const hasAsyncTo = isAsyncTo(props.to);
+    const { config: config2 } = anim;
+    const { decay, velocity } = config2;
+    if (hasToProp || hasFromProp) {
+      config2.velocity = 0;
+    }
+    if (props.config && !hasAsyncTo) {
+      mergeConfig(
+        config2,
+        callProp(props.config, key),
+        // Avoid calling the same "config" prop twice.
+        props.config !== defaultProps.config ? callProp(defaultProps.config, key) : void 0
+      );
+    }
+    let node = getAnimated(this);
+    if (!node || is.und(to2)) {
+      return resolve(getFinishedResult(this, true));
+    }
+    const reset = (
+      // When `reset` is undefined, the `from` prop implies `reset: true`,
+      // except for declarative updates. When `reset` is defined, there
+      // must exist a value to animate from.
+      is.und(props.reset) ? hasFromProp && !props.default : !is.und(from) && matchProp(props.reset, key)
+    );
+    const value = reset ? from : this.get();
+    const goal = computeGoal(to2);
+    const isAnimatable = is.num(goal) || is.arr(goal) || isAnimatedString(goal);
+    const immediate = !hasAsyncTo && (!isAnimatable || matchProp(defaultProps.immediate || props.immediate, key));
+    if (hasToChanged) {
+      const nodeType = getAnimatedType(to2);
+      if (nodeType !== node.constructor) {
+        if (immediate) {
+          node = this._set(goal);
+        } else
+          throw Error(
+            `Cannot animate between ${node.constructor.name} and ${nodeType.name}, as the "to" prop suggests`
+          );
+      }
+    }
+    const goalType = node.constructor;
+    let started = hasFluidValue(to2);
+    let finished = false;
+    if (!started) {
+      const hasValueChanged = reset || !hasAnimated(this) && hasFromChanged;
+      if (hasToChanged || hasValueChanged) {
+        finished = isEqual(computeGoal(value), goal);
+        started = !finished;
+      }
+      if (!isEqual(anim.immediate, immediate) && !immediate || !isEqual(config2.decay, decay) || !isEqual(config2.velocity, velocity)) {
+        started = true;
+      }
+    }
+    if (finished && isAnimating(this)) {
+      if (anim.changed && !reset) {
+        started = true;
+      } else if (!started) {
+        this._stop(prevTo);
+      }
+    }
+    if (!hasAsyncTo) {
+      if (started || hasFluidValue(prevTo)) {
+        anim.values = node.getPayload();
+        anim.toValues = hasFluidValue(to2) ? null : goalType == AnimatedString ? [1] : toArray(goal);
+      }
+      if (anim.immediate != immediate) {
+        anim.immediate = immediate;
+        if (!immediate && !reset) {
+          this._set(prevTo);
+        }
+      }
+      if (started) {
+        const { onRest } = anim;
+        each(ACTIVE_EVENTS, (type) => mergeActiveFn(this, props, type));
+        const result = getFinishedResult(this, checkFinished(this, prevTo));
+        flushCalls(this._pendingCalls, result);
+        this._pendingCalls.add(resolve);
+        if (anim.changed)
+          raf.batchedUpdates(() => {
+            anim.changed = !reset;
+            onRest?.(result, this);
+            if (reset) {
+              callProp(defaultProps.onRest, result);
+            } else {
+              anim.onStart?.(result, this);
+            }
+          });
+      }
+    }
+    if (reset) {
+      this._set(value);
+    }
+    if (hasAsyncTo) {
+      resolve(runAsync(props.to, props, this._state, this));
+    } else if (started) {
+      this._start();
+    } else if (isAnimating(this) && !hasToChanged) {
+      this._pendingCalls.add(resolve);
+    } else {
+      resolve(getNoopResult(value));
+    }
+  }
+  /** Update the `animation.to` value, which might be a `FluidValue` */
+  _focus(value) {
+    const anim = this.animation;
+    if (value !== anim.to) {
+      if (getFluidObservers(this)) {
+        this._detach();
+      }
+      anim.to = value;
+      if (getFluidObservers(this)) {
+        this._attach();
+      }
+    }
+  }
+  _attach() {
+    let priority = 0;
+    const { to: to2 } = this.animation;
+    if (hasFluidValue(to2)) {
+      addFluidObserver(to2, this);
+      if (isFrameValue(to2)) {
+        priority = to2.priority + 1;
+      }
+    }
+    this.priority = priority;
+  }
+  _detach() {
+    const { to: to2 } = this.animation;
+    if (hasFluidValue(to2)) {
+      removeFluidObserver(to2, this);
+    }
+  }
+  /**
+   * Update the current value from outside the frameloop,
+   * and return the `Animated` node.
+   */
+  _set(arg, idle = true) {
+    const value = getFluidValue(arg);
+    if (!is.und(value)) {
+      const oldNode = getAnimated(this);
+      if (!oldNode || !isEqual(value, oldNode.getValue())) {
+        const nodeType = getAnimatedType(value);
+        if (!oldNode || oldNode.constructor != nodeType) {
+          setAnimated(this, nodeType.create(value));
+        } else {
+          oldNode.setValue(value);
+        }
+        if (oldNode) {
+          raf.batchedUpdates(() => {
+            this._onChange(value, idle);
+          });
+        }
+      }
+    }
+    return getAnimated(this);
+  }
+  _onStart() {
+    const anim = this.animation;
+    if (!anim.changed) {
+      anim.changed = true;
+      sendEvent(
+        this,
+        "onStart",
+        getFinishedResult(this, checkFinished(this, anim.to)),
+        this
+      );
+    }
+  }
+  _onChange(value, idle) {
+    if (!idle) {
+      this._onStart();
+      callProp(this.animation.onChange, value, this);
+    }
+    callProp(this.defaultProps.onChange, value, this);
+    super._onChange(value, idle);
+  }
+  // This method resets the animation state (even if already animating) to
+  // ensure the latest from/to range is used, and it also ensures this spring
+  // is added to the frameloop.
+  _start() {
+    const anim = this.animation;
+    getAnimated(this).reset(getFluidValue(anim.to));
+    if (!anim.immediate) {
+      anim.fromValues = anim.values.map((node) => node.lastPosition);
+    }
+    if (!isAnimating(this)) {
+      setActiveBit(this, true);
+      if (!isPaused(this)) {
+        this._resume();
+      }
+    }
+  }
+  _resume() {
+    if (globals_exports.skipAnimation) {
+      this.finish();
+    } else {
+      frameLoop.start(this);
+    }
+  }
+  /**
+   * Exit the frameloop and notify `onRest` listeners.
+   *
+   * Always wrap `_stop` calls with `batchedUpdates`.
+   */
+  _stop(goal, cancel) {
+    if (isAnimating(this)) {
+      setActiveBit(this, false);
+      const anim = this.animation;
+      each(anim.values, (node) => {
+        node.done = true;
+      });
+      if (anim.toValues) {
+        anim.onChange = anim.onPause = anim.onResume = void 0;
+      }
+      callFluidObservers(this, {
+        type: "idle",
+        parent: this
+      });
+      const result = cancel ? getCancelledResult(this.get()) : getFinishedResult(this.get(), checkFinished(this, goal ?? anim.to));
+      flushCalls(this._pendingCalls, result);
+      if (anim.changed) {
+        anim.changed = false;
+        sendEvent(this, "onRest", result, this);
+      }
+    }
+  }
+};
+function checkFinished(target, to2) {
+  const goal = computeGoal(to2);
+  const value = computeGoal(target.get());
+  return isEqual(value, goal);
+}
+function createLoopUpdate(props, loop = props.loop, to2 = props.to) {
+  const loopRet = callProp(loop);
+  if (loopRet) {
+    const overrides = loopRet !== true && inferTo(loopRet);
+    const reverse = (overrides || props).reverse;
+    const reset = !overrides || overrides.reset;
+    return createUpdate({
+      ...props,
+      loop,
+      // Avoid updating default props when looping.
+      default: false,
+      // Never loop the `pause` prop.
+      pause: void 0,
+      // For the "reverse" prop to loop as expected, the "to" prop
+      // must be undefined. The "reverse" prop is ignored when the
+      // "to" prop is an array or function.
+      to: !reverse || isAsyncTo(to2) ? to2 : void 0,
+      // Ignore the "from" prop except on reset.
+      from: reset ? props.from : void 0,
+      reset,
+      // The "loop" prop can return a "useSpring" props object to
+      // override any of the original props.
+      ...overrides
+    });
+  }
+}
+function createUpdate(props) {
+  const { to: to2, from } = props = inferTo(props);
+  const keys = /* @__PURE__ */ new Set();
+  if (is.obj(to2))
+    findDefined(to2, keys);
+  if (is.obj(from))
+    findDefined(from, keys);
+  props.keys = keys.size ? Array.from(keys) : null;
+  return props;
+}
+function declareUpdate(props) {
+  const update2 = createUpdate(props);
+  if (is.und(update2.default)) {
+    update2.default = getDefaultProps(update2);
+  }
+  return update2;
+}
+function findDefined(values, keys) {
+  eachProp(values, (value, key) => value != null && keys.add(key));
+}
+var ACTIVE_EVENTS = [
+  "onStart",
+  "onRest",
+  "onChange",
+  "onPause",
+  "onResume"
+];
+function mergeActiveFn(target, props, type) {
+  target.animation[type] = props[type] !== getDefaultProp(props, type) ? resolveProp(props[type], target.key) : void 0;
+}
+function sendEvent(target, type, ...args) {
+  target.animation[type]?.(...args);
+  target.defaultProps[type]?.(...args);
+}
+var BATCHED_EVENTS = ["onStart", "onChange", "onRest"];
+var nextId2 = 1;
+var Controller = class {
+  constructor(props, flush3) {
+    this.id = nextId2++;
+    /** The animated values */
+    this.springs = {};
+    /** The queue of props passed to the `update` method. */
+    this.queue = [];
+    /** The counter for tracking `scheduleProps` calls */
+    this._lastAsyncId = 0;
+    /** The values currently being animated */
+    this._active = /* @__PURE__ */ new Set();
+    /** The values that changed recently */
+    this._changed = /* @__PURE__ */ new Set();
+    /** Equals false when `onStart` listeners can be called */
+    this._started = false;
+    /** State used by the `runAsync` function */
+    this._state = {
+      paused: false,
+      pauseQueue: /* @__PURE__ */ new Set(),
+      resumeQueue: /* @__PURE__ */ new Set(),
+      timeouts: /* @__PURE__ */ new Set()
+    };
+    /** The event queues that are flushed once per frame maximum */
+    this._events = {
+      onStart: /* @__PURE__ */ new Map(),
+      onChange: /* @__PURE__ */ new Map(),
+      onRest: /* @__PURE__ */ new Map()
+    };
+    this._onFrame = this._onFrame.bind(this);
+    if (flush3) {
+      this._flush = flush3;
+    }
+    if (props) {
+      this.start({ default: true, ...props });
+    }
+  }
+  /**
+   * Equals `true` when no spring values are in the frameloop, and
+   * no async animation is currently active.
+   */
+  get idle() {
+    return !this._state.asyncTo && Object.values(this.springs).every((spring) => {
+      return spring.idle && !spring.isDelayed && !spring.isPaused;
+    });
+  }
+  get item() {
+    return this._item;
+  }
+  set item(item) {
+    this._item = item;
+  }
+  /** Get the current values of our springs */
+  get() {
+    const values = {};
+    this.each((spring, key) => values[key] = spring.get());
+    return values;
+  }
+  /** Set the current values without animating. */
+  set(values) {
+    for (const key in values) {
+      const value = values[key];
+      if (!is.und(value)) {
+        this.springs[key].set(value);
+      }
+    }
+  }
+  /** Push an update onto the queue of each value. */
+  update(props) {
+    if (props) {
+      this.queue.push(createUpdate(props));
+    }
+    return this;
+  }
+  /**
+   * Start the queued animations for every spring, and resolve the returned
+   * promise once all queued animations have finished or been cancelled.
+   *
+   * When you pass a queue (instead of nothing), that queue is used instead of
+   * the queued animations added with the `update` method, which are left alone.
+   */
+  start(props) {
+    let { queue } = this;
+    if (props) {
+      queue = toArray(props).map(createUpdate);
+    } else {
+      this.queue = [];
+    }
+    if (this._flush) {
+      return this._flush(this, queue);
+    }
+    prepareKeys(this, queue);
+    return flushUpdateQueue(this, queue);
+  }
+  /** @internal */
+  stop(arg, keys) {
+    if (arg !== !!arg) {
+      keys = arg;
+    }
+    if (keys) {
+      const springs = this.springs;
+      each(toArray(keys), (key) => springs[key].stop(!!arg));
+    } else {
+      stopAsync(this._state, this._lastAsyncId);
+      this.each((spring) => spring.stop(!!arg));
+    }
+    return this;
+  }
+  /** Freeze the active animation in time */
+  pause(keys) {
+    if (is.und(keys)) {
+      this.start({ pause: true });
+    } else {
+      const springs = this.springs;
+      each(toArray(keys), (key) => springs[key].pause());
+    }
+    return this;
+  }
+  /** Resume the animation if paused. */
+  resume(keys) {
+    if (is.und(keys)) {
+      this.start({ pause: false });
+    } else {
+      const springs = this.springs;
+      each(toArray(keys), (key) => springs[key].resume());
+    }
+    return this;
+  }
+  /** Call a function once per spring value */
+  each(iterator) {
+    eachProp(this.springs, iterator);
+  }
+  /** @internal Called at the end of every animation frame */
+  _onFrame() {
+    const { onStart, onChange, onRest } = this._events;
+    const active = this._active.size > 0;
+    const changed = this._changed.size > 0;
+    if (active && !this._started || changed && !this._started) {
+      this._started = true;
+      flush(onStart, ([onStart2, result]) => {
+        result.value = this.get();
+        onStart2(result, this, this._item);
+      });
+    }
+    const idle = !active && this._started;
+    const values = changed || idle && onRest.size ? this.get() : null;
+    if (changed && onChange.size) {
+      flush(onChange, ([onChange2, result]) => {
+        result.value = values;
+        onChange2(result, this, this._item);
+      });
+    }
+    if (idle) {
+      this._started = false;
+      flush(onRest, ([onRest2, result]) => {
+        result.value = values;
+        onRest2(result, this, this._item);
+      });
+    }
+  }
+  /** @internal */
+  eventObserved(event) {
+    if (event.type == "change") {
+      this._changed.add(event.parent);
+      if (!event.idle) {
+        this._active.add(event.parent);
+      }
+    } else if (event.type == "idle") {
+      this._active.delete(event.parent);
+    } else
+      return;
+    raf.onFrame(this._onFrame);
+  }
+};
+function flushUpdateQueue(ctrl, queue) {
+  return Promise.all(queue.map((props) => flushUpdate(ctrl, props))).then(
+    (results) => getCombinedResult(ctrl, results)
+  );
+}
+async function flushUpdate(ctrl, props, isLoop) {
+  const { keys, to: to2, from, loop, onRest, onResolve } = props;
+  const defaults2 = is.obj(props.default) && props.default;
+  if (loop) {
+    props.loop = false;
+  }
+  if (to2 === false)
+    props.to = null;
+  if (from === false)
+    props.from = null;
+  const asyncTo = is.arr(to2) || is.fun(to2) ? to2 : void 0;
+  if (asyncTo) {
+    props.to = void 0;
+    props.onRest = void 0;
+    if (defaults2) {
+      defaults2.onRest = void 0;
+    }
+  } else {
+    each(BATCHED_EVENTS, (key) => {
+      const handler = props[key];
+      if (is.fun(handler)) {
+        const queue = ctrl["_events"][key];
+        props[key] = ({ finished, cancelled }) => {
+          const result2 = queue.get(handler);
+          if (result2) {
+            if (!finished)
+              result2.finished = false;
+            if (cancelled)
+              result2.cancelled = true;
+          } else {
+            queue.set(handler, {
+              value: null,
+              finished: finished || false,
+              cancelled: cancelled || false
+            });
+          }
+        };
+        if (defaults2) {
+          defaults2[key] = props[key];
+        }
+      }
+    });
+  }
+  const state = ctrl["_state"];
+  if (props.pause === !state.paused) {
+    state.paused = props.pause;
+    flushCalls(props.pause ? state.pauseQueue : state.resumeQueue);
+  } else if (state.paused) {
+    props.pause = true;
+  }
+  const promises = (keys || Object.keys(ctrl.springs)).map(
+    (key) => ctrl.springs[key].start(props)
+  );
+  const cancel = props.cancel === true || getDefaultProp(props, "cancel") === true;
+  if (asyncTo || cancel && state.asyncId) {
+    promises.push(
+      scheduleProps(++ctrl["_lastAsyncId"], {
+        props,
+        state,
+        actions: {
+          pause: noop,
+          resume: noop,
+          start(props2, resolve) {
+            if (cancel) {
+              stopAsync(state, ctrl["_lastAsyncId"]);
+              resolve(getCancelledResult(ctrl));
+            } else {
+              props2.onRest = onRest;
+              resolve(
+                runAsync(
+                  asyncTo,
+                  props2,
+                  state,
+                  ctrl
+                )
+              );
+            }
+          }
+        }
+      })
+    );
+  }
+  if (state.paused) {
+    await new Promise((resume) => {
+      state.resumeQueue.add(resume);
+    });
+  }
+  const result = getCombinedResult(ctrl, await Promise.all(promises));
+  if (loop && result.finished && !(isLoop && result.noop)) {
+    const nextProps = createLoopUpdate(props, loop, to2);
+    if (nextProps) {
+      prepareKeys(ctrl, [nextProps]);
+      return flushUpdate(ctrl, nextProps, true);
+    }
+  }
+  if (onResolve) {
+    raf.batchedUpdates(() => onResolve(result, ctrl, ctrl.item));
+  }
+  return result;
+}
+function getSprings(ctrl, props) {
+  const springs = { ...ctrl.springs };
+  if (props) {
+    each(toArray(props), (props2) => {
+      if (is.und(props2.keys)) {
+        props2 = createUpdate(props2);
+      }
+      if (!is.obj(props2.to)) {
+        props2 = { ...props2, to: void 0 };
+      }
+      prepareSprings(springs, props2, (key) => {
+        return createSpring(key);
+      });
+    });
+  }
+  setSprings(ctrl, springs);
+  return springs;
+}
+function setSprings(ctrl, springs) {
+  eachProp(springs, (spring, key) => {
+    if (!ctrl.springs[key]) {
+      ctrl.springs[key] = spring;
+      addFluidObserver(spring, ctrl);
+    }
+  });
+}
+function createSpring(key, observer) {
+  const spring = new SpringValue();
+  spring.key = key;
+  if (observer) {
+    addFluidObserver(spring, observer);
+  }
+  return spring;
+}
+function prepareSprings(springs, props, create) {
+  if (props.keys) {
+    each(props.keys, (key) => {
+      const spring = springs[key] || (springs[key] = create(key));
+      spring["_prepareNode"](props);
+    });
+  }
+}
+function prepareKeys(ctrl, queue) {
+  each(queue, (props) => {
+    prepareSprings(ctrl.springs, props, (key) => {
+      return createSpring(key, ctrl);
+    });
+  });
+}
+var SpringContext = ({
+  children,
+  ...props
+}) => {
+  const inherited = useContext(ctx);
+  const pause = props.pause || !!inherited.pause, immediate = props.immediate || !!inherited.immediate;
+  props = useMemoOne(() => ({ pause, immediate }), [pause, immediate]);
+  const { Provider } = ctx;
+  return /* @__PURE__ */ React.createElement(Provider, { value: props }, children);
+};
+var ctx = makeContext(SpringContext, {});
+SpringContext.Provider = ctx.Provider;
+SpringContext.Consumer = ctx.Consumer;
+function makeContext(target, init) {
+  Object.assign(target, React.createContext(init));
+  target.Provider._context = target;
+  target.Consumer._context = target;
+  return target;
+}
+var SpringRef = () => {
+  const current = [];
+  const SpringRef2 = function(props) {
+    deprecateDirectCall();
+    const results = [];
+    each(current, (ctrl, i) => {
+      if (is.und(props)) {
+        results.push(ctrl.start());
+      } else {
+        const update2 = _getProps(props, ctrl, i);
+        if (update2) {
+          results.push(ctrl.start(update2));
+        }
+      }
+    });
+    return results;
+  };
+  SpringRef2.current = current;
+  SpringRef2.add = function(ctrl) {
+    if (!current.includes(ctrl)) {
+      current.push(ctrl);
+    }
+  };
+  SpringRef2.delete = function(ctrl) {
+    const i = current.indexOf(ctrl);
+    if (~i)
+      current.splice(i, 1);
+  };
+  SpringRef2.pause = function() {
+    each(current, (ctrl) => ctrl.pause(...arguments));
+    return this;
+  };
+  SpringRef2.resume = function() {
+    each(current, (ctrl) => ctrl.resume(...arguments));
+    return this;
+  };
+  SpringRef2.set = function(values) {
+    each(current, (ctrl, i) => {
+      const update2 = is.fun(values) ? values(i, ctrl) : values;
+      if (update2) {
+        ctrl.set(update2);
+      }
+    });
+  };
+  SpringRef2.start = function(props) {
+    const results = [];
+    each(current, (ctrl, i) => {
+      if (is.und(props)) {
+        results.push(ctrl.start());
+      } else {
+        const update2 = this._getProps(props, ctrl, i);
+        if (update2) {
+          results.push(ctrl.start(update2));
+        }
+      }
+    });
+    return results;
+  };
+  SpringRef2.stop = function() {
+    each(current, (ctrl) => ctrl.stop(...arguments));
+    return this;
+  };
+  SpringRef2.update = function(props) {
+    each(current, (ctrl, i) => ctrl.update(this._getProps(props, ctrl, i)));
+    return this;
+  };
+  const _getProps = function(arg, ctrl, index) {
+    return is.fun(arg) ? arg(index, ctrl) : arg;
+  };
+  SpringRef2._getProps = _getProps;
+  return SpringRef2;
+};
+
+// src/hooks/useSprings.ts
+function useSprings(length, props, deps) {
+  const propsFn = is.fun(props) && props;
+  if (propsFn && !deps)
+    deps = [];
+  const ref = useMemo(
+    () => propsFn || arguments.length == 3 ? SpringRef() : void 0,
+    []
+  );
+  const layoutId = useRef(0);
+  const forceUpdate = useForceUpdate();
+  const state = useMemo(
+    () => ({
+      ctrls: [],
+      queue: [],
+      flush(ctrl, updates2) {
+        const springs2 = getSprings(ctrl, updates2);
+        const canFlushSync = layoutId.current > 0 && !state.queue.length && !Object.keys(springs2).some((key) => !ctrl.springs[key]);
+        return canFlushSync ? flushUpdateQueue(ctrl, updates2) : new Promise((resolve) => {
+          setSprings(ctrl, springs2);
+          state.queue.push(() => {
+            resolve(flushUpdateQueue(ctrl, updates2));
+          });
+          forceUpdate();
+        });
+      }
+    }),
+    []
+  );
+  const ctrls = useRef([...state.ctrls]);
+  const updates = [];
+  const prevLength = usePrev(length) || 0;
+  useMemo(() => {
+    each(ctrls.current.slice(length, prevLength), (ctrl) => {
+      detachRefs(ctrl, ref);
+      ctrl.stop(true);
+    });
+    ctrls.current.length = length;
+    declareUpdates(prevLength, length);
+  }, [length]);
+  useMemo(() => {
+    declareUpdates(0, Math.min(prevLength, length));
+  }, deps);
+  function declareUpdates(startIndex, endIndex) {
+    for (let i = startIndex; i < endIndex; i++) {
+      const ctrl = ctrls.current[i] || (ctrls.current[i] = new Controller(null, state.flush));
+      const update2 = propsFn ? propsFn(i, ctrl) : props[i];
+      if (update2) {
+        updates[i] = declareUpdate(update2);
+      }
+    }
+  }
+  const springs = ctrls.current.map((ctrl, i) => getSprings(ctrl, updates[i]));
+  const context = useContext(SpringContext);
+  const prevContext = usePrev(context);
+  const hasContext = context !== prevContext && hasProps(context);
+  useIsomorphicLayoutEffect(() => {
+    layoutId.current++;
+    state.ctrls = ctrls.current;
+    const { queue } = state;
+    if (queue.length) {
+      state.queue = [];
+      each(queue, (cb) => cb());
+    }
+    each(ctrls.current, (ctrl, i) => {
+      ref?.add(ctrl);
+      if (hasContext) {
+        ctrl.start({ default: context });
+      }
+      const update2 = updates[i];
+      if (update2) {
+        replaceRef(ctrl, update2.ref);
+        if (ctrl.ref) {
+          ctrl.queue.push(update2);
+        } else {
+          ctrl.start(update2);
+        }
+      }
+    });
+  });
+  useOnce(() => () => {
+    each(state.ctrls, (ctrl) => ctrl.stop(true));
+  });
+  const values = springs.map((x) => ({ ...x }));
+  return ref ? [values, ref] : values;
+}
 
-var ze$1=Object.defineProperty;var Le$2=(e,t)=>{for(var r in t)ze$1(e,r,{get:t[r],enumerable:!0});};var p={};Le$2(p,{assign:()=>U,colors:()=>c$2,createStringInterpolator:()=>k$2,skipAnimation:()=>ee,to:()=>J$1,willAdvance:()=>S});function Y(){}var mt$1=(e,t,r)=>Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0}),l$1={arr:Array.isArray,obj:e=>!!e&&e.constructor.name==="Object",fun:e=>typeof e=="function",str:e=>typeof e=="string",num:e=>typeof e=="number",und:e=>e===void 0};function bt$1(e,t){if(l$1.arr(e)){if(!l$1.arr(t)||e.length!==t.length)return !1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return !1;return !0}return e===t}var Ve=(e,t)=>e.forEach(t);function xt(e,t,r){if(l$1.arr(e)){for(let n=0;n<e.length;n++)t.call(r,e[n],`${n}`);return}for(let n in e)e.hasOwnProperty(n)&&t.call(r,e[n],n);}var ht$1=e=>l$1.und(e)?[]:l$1.arr(e)?e:[e];function Pe$1(e,t){if(e.size){let r=Array.from(e);e.clear(),Ve(r,t);}}var yt$1=(e,...t)=>Pe$1(e,r=>r(...t)),h$2=()=>typeof window>"u"||!window.navigator||/ServerSideRendering|^Deno\//.test(window.navigator.userAgent);var k$2,J$1,c$2=null,ee=!1,S=Y,U=e=>{e.to&&(J$1=e.to),e.now&&(n.now=e.now),e.colors!==void 0&&(c$2=e.colors),e.skipAnimation!=null&&(ee=e.skipAnimation),e.createStringInterpolator&&(k$2=e.createStringInterpolator),e.requestAnimationFrame&&n.use(e.requestAnimationFrame),e.batchedUpdates&&(n.batchedUpdates=e.batchedUpdates),e.willAdvance&&(S=e.willAdvance),e.frameLoop&&(n.frameLoop=e.frameLoop);};var E$1=new Set,u$1=[],H$1=[],A=0,qe$1={get idle(){return !E$1.size&&!u$1.length},start(e){A>e.priority?(E$1.add(e),n.onStart($e)):(te$1(e),n(B));},advance:B,sort(e){if(A)n.onFrame(()=>qe$1.sort(e));else {let t=u$1.indexOf(e);~t&&(u$1.splice(t,1),re(e));}},clear(){u$1=[],E$1.clear();}};function $e(){E$1.forEach(te$1),E$1.clear(),n(B);}function te$1(e){u$1.includes(e)||re(e);}function re(e){u$1.splice(Ge$1(u$1,t=>t.priority>e.priority),0,e);}function B(e){let t=H$1;for(let r=0;r<u$1.length;r++){let n=u$1[r];A=n.priority,n.idle||(S(n),n.advance(e),n.idle||t.push(n));}return A=0,H$1=u$1,H$1.length=0,u$1=t,u$1.length>0}function Ge$1(e,t){let r=e.findIndex(t);return r<0?e.length:r}var ne$2=(e,t,r)=>Math.min(Math.max(r,e),t);var It={transparent:0,aliceblue:4042850303,antiquewhite:4209760255,aqua:16777215,aquamarine:2147472639,azure:4043309055,beige:4126530815,bisque:4293182719,black:255,blanchedalmond:4293643775,blue:65535,blueviolet:2318131967,brown:2771004159,burlywood:3736635391,burntsienna:3934150143,cadetblue:1604231423,chartreuse:2147418367,chocolate:3530104575,coral:4286533887,cornflowerblue:1687547391,cornsilk:4294499583,crimson:3692313855,cyan:16777215,darkblue:35839,darkcyan:9145343,darkgoldenrod:3095792639,darkgray:2846468607,darkgreen:6553855,darkgrey:2846468607,darkkhaki:3182914559,darkmagenta:2332068863,darkolivegreen:1433087999,darkorange:4287365375,darkorchid:2570243327,darkred:2332033279,darksalmon:3918953215,darkseagreen:2411499519,darkslateblue:1211993087,darkslategray:793726975,darkslategrey:793726975,darkturquoise:13554175,darkviolet:2483082239,deeppink:4279538687,deepskyblue:12582911,dimgray:1768516095,dimgrey:1768516095,dodgerblue:512819199,firebrick:2988581631,floralwhite:4294635775,forestgreen:579543807,fuchsia:4278255615,gainsboro:3705462015,ghostwhite:4177068031,gold:4292280575,goldenrod:3668254975,gray:2155905279,green:8388863,greenyellow:2919182335,grey:2155905279,honeydew:4043305215,hotpink:4285117695,indianred:3445382399,indigo:1258324735,ivory:4294963455,khaki:4041641215,lavender:3873897215,lavenderblush:4293981695,lawngreen:2096890111,lemonchiffon:4294626815,lightblue:2916673279,lightcoral:4034953471,lightcyan:3774873599,lightgoldenrodyellow:4210742015,lightgray:3553874943,lightgreen:2431553791,lightgrey:3553874943,lightpink:4290167295,lightsalmon:4288707327,lightseagreen:548580095,lightskyblue:2278488831,lightslategray:2005441023,lightslategrey:2005441023,lightsteelblue:2965692159,lightyellow:4294959359,lime:16711935,limegreen:852308735,linen:4210091775,magenta:4278255615,maroon:2147483903,mediumaquamarine:1724754687,mediumblue:52735,mediumorchid:3126187007,mediumpurple:2473647103,mediumseagreen:1018393087,mediumslateblue:2070474495,mediumspringgreen:16423679,mediumturquoise:1221709055,mediumvioletred:3340076543,midnightblue:421097727,mintcream:4127193855,mistyrose:4293190143,moccasin:4293178879,navajowhite:4292783615,navy:33023,oldlace:4260751103,olive:2155872511,olivedrab:1804477439,orange:4289003775,orangered:4282712319,orchid:3664828159,palegoldenrod:4008225535,palegreen:2566625535,paleturquoise:2951671551,palevioletred:3681588223,papayawhip:4293907967,peachpuff:4292524543,peru:3448061951,pink:4290825215,plum:3718307327,powderblue:2967529215,purple:2147516671,rebeccapurple:1714657791,red:4278190335,rosybrown:3163525119,royalblue:1097458175,saddlebrown:2336560127,salmon:4202722047,sandybrown:4104413439,seagreen:780883967,seashell:4294307583,sienna:2689740287,silver:3233857791,skyblue:2278484991,slateblue:1784335871,slategray:1887473919,slategrey:1887473919,snow:4294638335,springgreen:16744447,steelblue:1182971135,tan:3535047935,teal:8421631,thistle:3636451583,tomato:4284696575,turquoise:1088475391,violet:4001558271,wheat:4125012991,white:4294967295,whitesmoke:4126537215,yellow:4294902015,yellowgreen:2597139199};var d$1="[-+]?\\d*\\.?\\d+",M=d$1+"%";function C$1(...e){return "\\(\\s*("+e.join(")\\s*,\\s*(")+")\\s*\\)"}var oe$1=new RegExp("rgb"+C$1(d$1,d$1,d$1)),fe$1=new RegExp("rgba"+C$1(d$1,d$1,d$1,d$1)),ae$1=new RegExp("hsl"+C$1(d$1,M,M)),ie=new RegExp("hsla"+C$1(d$1,M,M,d$1)),se$1=/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,ue$1=/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,le$1=/^#([0-9a-fA-F]{6})$/,ce=/^#([0-9a-fA-F]{8})$/;function be$1(e){let t;return typeof e=="number"?e>>>0===e&&e>=0&&e<=4294967295?e:null:(t=le$1.exec(e))?parseInt(t[1]+"ff",16)>>>0:c$2&&c$2[e]!==void 0?c$2[e]:(t=oe$1.exec(e))?(y$2(t[1])<<24|y$2(t[2])<<16|y$2(t[3])<<8|255)>>>0:(t=fe$1.exec(e))?(y$2(t[1])<<24|y$2(t[2])<<16|y$2(t[3])<<8|me$1(t[4]))>>>0:(t=se$1.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+"ff",16)>>>0:(t=ce.exec(e))?parseInt(t[1],16)>>>0:(t=ue$1.exec(e))?parseInt(t[1]+t[1]+t[2]+t[2]+t[3]+t[3]+t[4]+t[4],16)>>>0:(t=ae$1.exec(e))?(de$1(pe(t[1]),z$1(t[2]),z$1(t[3]))|255)>>>0:(t=ie.exec(e))?(de$1(pe(t[1]),z$1(t[2]),z$1(t[3]))|me$1(t[4]))>>>0:null}function j$1(e,t,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*(2/3-r)*6:e}function de$1(e,t,r){let n=r<.5?r*(1+t):r+t-r*t,f=2*r-n,o=j$1(f,n,e+1/3),i=j$1(f,n,e),s=j$1(f,n,e-1/3);return Math.round(o*255)<<24|Math.round(i*255)<<16|Math.round(s*255)<<8}function y$2(e){let t=parseInt(e,10);return t<0?0:t>255?255:t}function pe(e){return (parseFloat(e)%360+360)%360/360}function me$1(e){let t=parseFloat(e);return t<0?0:t>1?255:Math.round(t*255)}function z$1(e){let t=parseFloat(e);return t<0?0:t>100?1:t/100}function D$1(e){let t=be$1(e);if(t===null)return e;t=t||0;let r=(t&4278190080)>>>24,n=(t&16711680)>>>16,f=(t&65280)>>>8,o=(t&255)/255;return `rgba(${r}, ${n}, ${f}, ${o})`}var W$1=(e,t,r)=>{if(l$1.fun(e))return e;if(l$1.arr(e))return W$1({range:e,output:t,extrapolate:r});if(l$1.str(e.output[0]))return k$2(e);let n=e,f=n.output,o=n.range||[0,1],i=n.extrapolateLeft||n.extrapolate||"extend",s=n.extrapolateRight||n.extrapolate||"extend",x=n.easing||(a=>a);return a=>{let F=He$1(a,o);return Ue$1(a,o[F],o[F+1],f[F],f[F+1],x,i,s,n.map)}};function Ue$1(e,t,r,n,f,o,i,s,x){let a=x?x(e):e;if(a<t){if(i==="identity")return a;i==="clamp"&&(a=t);}if(a>r){if(s==="identity")return a;s==="clamp"&&(a=r);}return n===f?n:t===r?e<=t?n:f:(t===-1/0?a=-a:r===1/0?a=a-t:a=(a-t)/(r-t),a=o(a),n===-1/0?a=-a:f===1/0?a=a+n:a=a*(f-n)+n,a)}function He$1(e,t){for(var r=1;r<t.length-1&&!(t[r]>=e);++r);return r-1}var Be=(e,t="end")=>r=>{r=t==="end"?Math.min(r,.999):Math.max(r,.001);let n=r*e,f=t==="end"?Math.floor(n):Math.ceil(n);return ne$2(0,1,f/e)},P=1.70158,L$1=P*1.525,xe$1=P+1,he$1=2*Math.PI/3,ye$1=2*Math.PI/4.5,V$1=e=>e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375,Lt$1={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>1-(1-e)*(1-e),easeInOutQuad:e=>e<.5?2*e*e:1-Math.pow(-2*e+2,2)/2,easeInCubic:e=>e*e*e,easeOutCubic:e=>1-Math.pow(1-e,3),easeInOutCubic:e=>e<.5?4*e*e*e:1-Math.pow(-2*e+2,3)/2,easeInQuart:e=>e*e*e*e,easeOutQuart:e=>1-Math.pow(1-e,4),easeInOutQuart:e=>e<.5?8*e*e*e*e:1-Math.pow(-2*e+2,4)/2,easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>1-Math.pow(1-e,5),easeInOutQuint:e=>e<.5?16*e*e*e*e*e:1-Math.pow(-2*e+2,5)/2,easeInSine:e=>1-Math.cos(e*Math.PI/2),easeOutSine:e=>Math.sin(e*Math.PI/2),easeInOutSine:e=>-(Math.cos(Math.PI*e)-1)/2,easeInExpo:e=>e===0?0:Math.pow(2,10*e-10),easeOutExpo:e=>e===1?1:1-Math.pow(2,-10*e),easeInOutExpo:e=>e===0?0:e===1?1:e<.5?Math.pow(2,20*e-10)/2:(2-Math.pow(2,-20*e+10))/2,easeInCirc:e=>1-Math.sqrt(1-Math.pow(e,2)),easeOutCirc:e=>Math.sqrt(1-Math.pow(e-1,2)),easeInOutCirc:e=>e<.5?(1-Math.sqrt(1-Math.pow(2*e,2)))/2:(Math.sqrt(1-Math.pow(-2*e+2,2))+1)/2,easeInBack:e=>xe$1*e*e*e-P*e*e,easeOutBack:e=>1+xe$1*Math.pow(e-1,3)+P*Math.pow(e-1,2),easeInOutBack:e=>e<.5?Math.pow(2*e,2)*((L$1+1)*2*e-L$1)/2:(Math.pow(2*e-2,2)*((L$1+1)*(e*2-2)+L$1)+2)/2,easeInElastic:e=>e===0?0:e===1?1:-Math.pow(2,10*e-10)*Math.sin((e*10-10.75)*he$1),easeOutElastic:e=>e===0?0:e===1?1:Math.pow(2,-10*e)*Math.sin((e*10-.75)*he$1)+1,easeInOutElastic:e=>e===0?0:e===1?1:e<.5?-(Math.pow(2,20*e-10)*Math.sin((20*e-11.125)*ye$1))/2:Math.pow(2,-20*e+10)*Math.sin((20*e-11.125)*ye$1)/2+1,easeInBounce:e=>1-V$1(1-e),easeOutBounce:V$1,easeInOutBounce:e=>e<.5?(1-V$1(1-2*e))/2:(1+V$1(2*e-1))/2,steps:Be};var g$1=Symbol.for("FluidValue.get"),m=Symbol.for("FluidValue.observers");var Pt=e=>!!(e&&e[g$1]),ve=e=>e&&e[g$1]?e[g$1]():e,qt=e=>e[m]||null;function je(e,t){e.eventObserved?e.eventObserved(t):e(t);}function $t(e,t){let r=e[m];r&&r.forEach(n=>{je(n,t);});}var ge=class{[g$1];[m];constructor(t){if(!t&&!(t=this.get))throw Error("Unknown getter");De$1(this,t);}},De$1=(e,t)=>Ee$1(e,g$1,t);function Gt$1(e,t){if(e[g$1]){let r=e[m];r||Ee$1(e,m,r=new Set),r.has(t)||(r.add(t),e.observerAdded&&e.observerAdded(r.size,t));}return t}function Qt(e,t){let r=e[m];if(r&&r.has(t)){let n=r.size-1;n?r.delete(t):e[m]=null,e.observerRemoved&&e.observerRemoved(n,t);}}var Ee$1=(e,t,r)=>Object.defineProperty(e,t,{value:r,writable:!0,configurable:!0});var O=/[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,Oe=/(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi,K=new RegExp(`(${O.source})(%|[a-z]+)`,"i"),we$1=/rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi,b$1=/var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;var N=e=>{let[t,r]=We(e);if(!t||h$2())return e;let n=window.getComputedStyle(document.documentElement).getPropertyValue(t);if(n)return n.trim();if(r&&r.startsWith("--")){let f=window.getComputedStyle(document.documentElement).getPropertyValue(r);return f||e}else {if(r&&b$1.test(r))return N(r);if(r)return r}return e},We=e=>{let t=b$1.exec(e);if(!t)return [,];let[,r,n]=t;return [r,n]};var _$1,Ke$1=(e,t,r,n,f)=>`rgba(${Math.round(t)}, ${Math.round(r)}, ${Math.round(n)}, ${f})`,Xt=e=>{_$1||(_$1=c$2?new RegExp(`(${Object.keys(c$2).join("|")})(?!\\w)`,"g"):/^\b$/);let t=e.output.map(o=>ve(o).replace(b$1,N).replace(Oe,D$1).replace(_$1,D$1)),r=t.map(o=>o.match(O).map(Number)),f=r[0].map((o,i)=>r.map(s=>{if(!(i in s))throw Error('The arity of each "output" value must be equal');return s[i]})).map(o=>W$1({...e,output:o}));return o=>{let i=!K.test(t[0])&&t.find(x=>K.test(x))?.replace(O,""),s=0;return t[0].replace(O,()=>`${f[s++](o)}${i||""}`).replace(we$1,Ke$1)}};var Z="react-spring: ",Te=e=>{let t=e,r=!1;if(typeof t!="function")throw new TypeError(`${Z}once requires a function parameter`);return (...n)=>{r||(t(...n),r=!0);}},Ne$1=Te(console.warn);function Jt(){Ne$1(`${Z}The "interpolate" function is deprecated in v9 (use "to" instead)`);}var _e$1=Te(console.warn);function er$1(){_e$1(`${Z}Directly calling start instead of using the api object is deprecated in v9 (use ".start" instead), this will be removed in later 0.X.0 versions`);}function or(e){return l$1.str(e)&&(e[0]=="#"||/\d/.test(e)||!h$2()&&b$1.test(e)||e in(c$2||{}))}var Q$1=h$2()?useEffect:useLayoutEffect;var Ce$1=()=>{let e=useRef(!1);return Q$1(()=>(e.current=!0,()=>{e.current=!1;}),[]),e};function Mr(){let e=useState()[1],t=Ce$1();return ()=>{t.current&&e(Math.random());}}function Lr(e,t){let[r]=useState(()=>({inputs:t,result:e()})),n=useRef(),f=n.current,o=f;return o?t&&o.inputs&&it$2(t,o.inputs)||(o={inputs:t,result:e()}):o=r,useEffect(()=>{n.current=o,f==r&&(r.inputs=r.result=void 0);},[o]),o.result}function it$2(e,t){if(e.length!==t.length)return !1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return !1;return !0}var $r=e=>useEffect(e,ut),ut=[];function Ur(e){let t=useRef();return useEffect(()=>{t.current=e;}),t.current}
+// src/hooks/useSpring.ts
+function useSpring(props, deps) {
+  const isFn = is.fun(props);
+  const [[values], ref] = useSprings(
+    1,
+    isFn ? props : [props],
+    isFn ? deps || [] : deps
+  );
+  return isFn || arguments.length == 2 ? [values, ref] : values;
+}
+function useTransition(data, props, deps) {
+  const propsFn = is.fun(props) && props;
+  const {
+    reset,
+    sort,
+    trail = 0,
+    expires = true,
+    exitBeforeEnter = false,
+    onDestroyed,
+    ref: propsRef,
+    config: propsConfig
+  } = propsFn ? propsFn() : props;
+  const ref = useMemo(
+    () => propsFn || arguments.length == 3 ? SpringRef() : void 0,
+    []
+  );
+  const items = toArray(data);
+  const transitions = [];
+  const usedTransitions = useRef(null);
+  const prevTransitions = reset ? null : usedTransitions.current;
+  useIsomorphicLayoutEffect(() => {
+    usedTransitions.current = transitions;
+  });
+  useOnce(() => {
+    each(transitions, (t) => {
+      ref?.add(t.ctrl);
+      t.ctrl.ref = ref;
+    });
+    return () => {
+      each(usedTransitions.current, (t) => {
+        if (t.expired) {
+          clearTimeout(t.expirationId);
+        }
+        detachRefs(t.ctrl, ref);
+        t.ctrl.stop(true);
+      });
+    };
+  });
+  const keys = getKeys(items, propsFn ? propsFn() : props, prevTransitions);
+  const expired = reset && usedTransitions.current || [];
+  useIsomorphicLayoutEffect(
+    () => each(expired, ({ ctrl, item, key }) => {
+      detachRefs(ctrl, ref);
+      callProp(onDestroyed, item, key);
+    })
+  );
+  const reused = [];
+  if (prevTransitions)
+    each(prevTransitions, (t, i) => {
+      if (t.expired) {
+        clearTimeout(t.expirationId);
+        expired.push(t);
+      } else {
+        i = reused[i] = keys.indexOf(t.key);
+        if (~i)
+          transitions[i] = t;
+      }
+    });
+  each(items, (item, i) => {
+    if (!transitions[i]) {
+      transitions[i] = {
+        key: keys[i],
+        item,
+        phase: "mount" /* MOUNT */,
+        ctrl: new Controller()
+      };
+      transitions[i].ctrl.item = item;
+    }
+  });
+  if (reused.length) {
+    let i = -1;
+    const { leave } = propsFn ? propsFn() : props;
+    each(reused, (keyIndex, prevIndex) => {
+      const t = prevTransitions[prevIndex];
+      if (~keyIndex) {
+        i = transitions.indexOf(t);
+        transitions[i] = { ...t, item: items[keyIndex] };
+      } else if (leave) {
+        transitions.splice(++i, 0, t);
+      }
+    });
+  }
+  if (is.fun(sort)) {
+    transitions.sort((a, b) => sort(a.item, b.item));
+  }
+  let delay = -trail;
+  const forceUpdate = useForceUpdate();
+  const defaultProps = getDefaultProps(props);
+  const changes = /* @__PURE__ */ new Map();
+  const exitingTransitions = useRef(/* @__PURE__ */ new Map());
+  const forceChange = useRef(false);
+  each(transitions, (t, i) => {
+    const key = t.key;
+    const prevPhase = t.phase;
+    const p = propsFn ? propsFn() : props;
+    let to2;
+    let phase;
+    const propsDelay = callProp(p.delay || 0, key);
+    if (prevPhase == "mount" /* MOUNT */) {
+      to2 = p.enter;
+      phase = "enter" /* ENTER */;
+    } else {
+      const isLeave = keys.indexOf(key) < 0;
+      if (prevPhase != "leave" /* LEAVE */) {
+        if (isLeave) {
+          to2 = p.leave;
+          phase = "leave" /* LEAVE */;
+        } else if (to2 = p.update) {
+          phase = "update" /* UPDATE */;
+        } else
+          return;
+      } else if (!isLeave) {
+        to2 = p.enter;
+        phase = "enter" /* ENTER */;
+      } else
+        return;
+    }
+    to2 = callProp(to2, t.item, i);
+    to2 = is.obj(to2) ? inferTo(to2) : { to: to2 };
+    if (!to2.config) {
+      const config2 = propsConfig || defaultProps.config;
+      to2.config = callProp(config2, t.item, i, phase);
+    }
+    delay += trail;
+    const payload = {
+      ...defaultProps,
+      // we need to add our props.delay value you here.
+      delay: propsDelay + delay,
+      ref: propsRef,
+      immediate: p.immediate,
+      // This prevents implied resets.
+      reset: false,
+      // Merge any phase-specific props.
+      ...to2
+    };
+    if (phase == "enter" /* ENTER */ && is.und(payload.from)) {
+      const p2 = propsFn ? propsFn() : props;
+      const from = is.und(p2.initial) || prevTransitions ? p2.from : p2.initial;
+      payload.from = callProp(from, t.item, i);
+    }
+    const { onResolve } = payload;
+    payload.onResolve = (result) => {
+      callProp(onResolve, result);
+      const transitions2 = usedTransitions.current;
+      const t2 = transitions2.find((t3) => t3.key === key);
+      if (!t2)
+        return;
+      if (result.cancelled && t2.phase != "update" /* UPDATE */) {
+        return;
+      }
+      if (t2.ctrl.idle) {
+        const idle = transitions2.every((t3) => t3.ctrl.idle);
+        if (t2.phase == "leave" /* LEAVE */) {
+          const expiry = callProp(expires, t2.item);
+          if (expiry !== false) {
+            const expiryMs = expiry === true ? 0 : expiry;
+            t2.expired = true;
+            if (!idle && expiryMs > 0) {
+              if (expiryMs <= 2147483647)
+                t2.expirationId = setTimeout(forceUpdate, expiryMs);
+              return;
+            }
+          }
+        }
+        if (idle && transitions2.some((t3) => t3.expired)) {
+          exitingTransitions.current.delete(t2);
+          if (exitBeforeEnter) {
+            forceChange.current = true;
+          }
+          forceUpdate();
+        }
+      }
+    };
+    const springs = getSprings(t.ctrl, payload);
+    if (phase === "leave" /* LEAVE */ && exitBeforeEnter) {
+      exitingTransitions.current.set(t, { phase, springs, payload });
+    } else {
+      changes.set(t, { phase, springs, payload });
+    }
+  });
+  const context = useContext(SpringContext);
+  const prevContext = usePrev(context);
+  const hasContext = context !== prevContext && hasProps(context);
+  useIsomorphicLayoutEffect(() => {
+    if (hasContext) {
+      each(transitions, (t) => {
+        t.ctrl.start({ default: context });
+      });
+    }
+  }, [context]);
+  each(changes, (_, t) => {
+    if (exitingTransitions.current.size) {
+      const ind = transitions.findIndex((state) => state.key === t.key);
+      transitions.splice(ind, 1);
+    }
+  });
+  useIsomorphicLayoutEffect(
+    () => {
+      each(
+        exitingTransitions.current.size ? exitingTransitions.current : changes,
+        ({ phase, payload }, t) => {
+          const { ctrl } = t;
+          t.phase = phase;
+          ref?.add(ctrl);
+          if (hasContext && phase == "enter" /* ENTER */) {
+            ctrl.start({ default: context });
+          }
+          if (payload) {
+            replaceRef(ctrl, payload.ref);
+            if ((ctrl.ref || ref) && !forceChange.current) {
+              ctrl.update(payload);
+            } else {
+              ctrl.start(payload);
+              if (forceChange.current) {
+                forceChange.current = false;
+              }
+            }
+          }
+        }
+      );
+    },
+    reset ? void 0 : deps
+  );
+  const renderTransitions = (render) => /* @__PURE__ */ React.createElement(React.Fragment, null, transitions.map((t, i) => {
+    const { springs } = changes.get(t) || t.ctrl;
+    const elem = render({ ...springs }, t.item, t, i);
+    return elem && elem.type ? /* @__PURE__ */ React.createElement(
+      elem.type,
+      {
+        ...elem.props,
+        key: is.str(t.key) || is.num(t.key) ? t.key : t.ctrl.id,
+        ref: elem.ref
+      }
+    ) : elem;
+  }));
+  return ref ? [renderTransitions, ref] : renderTransitions;
+}
+var nextKey = 1;
+function getKeys(items, { key, keys = key }, prevTransitions) {
+  if (keys === null) {
+    const reused = /* @__PURE__ */ new Set();
+    return items.map((item) => {
+      const t = prevTransitions && prevTransitions.find(
+        (t2) => t2.item === item && t2.phase !== "leave" /* LEAVE */ && !reused.has(t2)
+      );
+      if (t) {
+        reused.add(t);
+        return t.key;
+      }
+      return nextKey++;
+    });
+  }
+  return is.und(keys) ? items : is.fun(keys) ? items.map(keys) : toArray(keys);
+}
+var Interpolation = class extends FrameValue {
+  constructor(source, args) {
+    super();
+    this.source = source;
+    /** Equals false when in the frameloop */
+    this.idle = true;
+    /** The inputs which are currently animating */
+    this._active = /* @__PURE__ */ new Set();
+    this.calc = createInterpolator(...args);
+    const value = this._get();
+    const nodeType = getAnimatedType(value);
+    setAnimated(this, nodeType.create(value));
+  }
+  advance(_dt) {
+    const value = this._get();
+    const oldValue = this.get();
+    if (!isEqual(value, oldValue)) {
+      getAnimated(this).setValue(value);
+      this._onChange(value, this.idle);
+    }
+    if (!this.idle && checkIdle(this._active)) {
+      becomeIdle(this);
+    }
+  }
+  _get() {
+    const inputs = is.arr(this.source) ? this.source.map(getFluidValue) : toArray(getFluidValue(this.source));
+    return this.calc(...inputs);
+  }
+  _start() {
+    if (this.idle && !checkIdle(this._active)) {
+      this.idle = false;
+      each(getPayload(this), (node) => {
+        node.done = false;
+      });
+      if (globals_exports.skipAnimation) {
+        raf.batchedUpdates(() => this.advance());
+        becomeIdle(this);
+      } else {
+        frameLoop.start(this);
+      }
+    }
+  }
+  // Observe our sources only when we're observed.
+  _attach() {
+    let priority = 1;
+    each(toArray(this.source), (source) => {
+      if (hasFluidValue(source)) {
+        addFluidObserver(source, this);
+      }
+      if (isFrameValue(source)) {
+        if (!source.idle) {
+          this._active.add(source);
+        }
+        priority = Math.max(priority, source.priority + 1);
+      }
+    });
+    this.priority = priority;
+    this._start();
+  }
+  // Stop observing our sources once we have no observers.
+  _detach() {
+    each(toArray(this.source), (source) => {
+      if (hasFluidValue(source)) {
+        removeFluidObserver(source, this);
+      }
+    });
+    this._active.clear();
+    becomeIdle(this);
+  }
+  /** @internal */
+  eventObserved(event) {
+    if (event.type == "change") {
+      if (event.idle) {
+        this.advance();
+      } else {
+        this._active.add(event.parent);
+        this._start();
+      }
+    } else if (event.type == "idle") {
+      this._active.delete(event.parent);
+    } else if (event.type == "priority") {
+      this.priority = toArray(this.source).reduce(
+        (highest, parent) => Math.max(highest, (isFrameValue(parent) ? parent.priority : 0) + 1),
+        0
+      );
+    }
+  }
+};
+function isIdle(source) {
+  return source.idle !== false;
+}
+function checkIdle(active) {
+  return !active.size || Array.from(active).every(isIdle);
+}
+function becomeIdle(self) {
+  if (!self.idle) {
+    self.idle = true;
+    each(getPayload(self), (node) => {
+      node.done = true;
+    });
+    callFluidObservers(self, {
+      type: "idle",
+      parent: self
+    });
+  }
+}
+globals_exports.assign({
+  createStringInterpolator: createStringInterpolator2,
+  to: (source, args) => new Interpolation(source, args)
+});
 
-var h$1=Symbol.for("Animated:node"),v$1=e=>!!e&&e[h$1]===e,k$1=e=>e&&e[h$1],D=(e,t)=>mt$1(e,h$1,t),F$1=e=>e&&e[h$1]&&e[h$1].getPayload(),c$1=class{payload;constructor(){D(this,this);}getPayload(){return this.payload||[]}};var l=class extends c$1{constructor(r){super();this._value=r;l$1.num(this._value)&&(this.lastPosition=this._value);}done=!0;elapsedTime;lastPosition;lastVelocity;v0;durationProgress=0;static create(r){return new l(r)}getPayload(){return [this]}getValue(){return this._value}setValue(r,n){return l$1.num(r)&&(this.lastPosition=r,n&&(r=Math.round(r/n)*n,this.done&&(this.lastPosition=r))),this._value===r?!1:(this._value=r,!0)}reset(){let{done:r}=this;this.done=!1,l$1.num(this._value)&&(this.elapsedTime=0,this.durationProgress=0,this.lastPosition=this._value,r&&(this.lastVelocity=null),this.v0=null);}};var d=class extends l{_string=null;_toString;constructor(t){super(0),this._toString=W$1({output:[t,t]});}static create(t){return new d(t)}getValue(){let t=this._string;return t??(this._string=this._toString(this._value))}setValue(t){if(l$1.str(t)){if(t==this._string)return !1;this._string=t,this._value=1;}else if(super.setValue(t))this._string=null;else return !1;return !0}reset(t){t&&(this._toString=W$1({output:[this.getValue(),t]})),this._value=0,super.reset();}};var f={dependencies:null};var u=class extends c$1{constructor(r){super();this.source=r;this.setValue(r);}getValue(r){let n={};return xt(this.source,(a,i)=>{v$1(a)?n[i]=a.getValue(r):Pt(a)?n[i]=ve(a):r||(n[i]=a);}),n}setValue(r){this.source=r,this.payload=this._makePayload(r);}reset(){this.payload&&Ve(this.payload,r=>r.reset());}_makePayload(r){if(r){let n=new Set;return xt(r,this._addToPayload,n),Array.from(n)}}_addToPayload(r){f.dependencies&&Pt(r)&&f.dependencies.add(r);let n=F$1(r);n&&Ve(n,a=>this.add(a));}};var y$1=class extends u{constructor(t){super(t);}static create(t){return new y$1(t)}getValue(){return this.source.map(t=>t.getValue())}setValue(t){let r=this.getPayload();return t.length==r.length?r.map((n,a)=>n.setValue(t[a])).some(Boolean):(super.setValue(t.map(z)),!0)}};function z(e){return (or(e)?d:l).create(e)}function Le$1(e){let t=k$1(e);return t?t.constructor:l$1.arr(e)?y$1:or(e)?d:l}var x$1=(e,t)=>{let r=!l$1.fun(e)||e.prototype&&e.prototype.isReactComponent;return forwardRef((n$1,a)=>{let i=useRef(null),o=r&&useCallback(s=>{i.current=ae(a,s);},[a]),[m,T]=ne$1(n$1,t),W=Mr(),P=()=>{let s=i.current;if(r&&!s)return;(s?t.applyAnimatedValues(s,m.getValue(!0)):!1)===!1&&W();},_=new b(P,T),p=useRef();Q$1(()=>(p.current=_,Ve(T,s=>Gt$1(s,_)),()=>{p.current&&(Ve(p.current.deps,s=>Qt(s,p.current)),n.cancel(p.current.update));})),useEffect(P,[]),$r(()=>()=>{let s=p.current;Ve(s.deps,S=>Qt(S,s));});let $=t.getComponentProps(m.getValue());return React.createElement(e,{...$,ref:o})})},b=class{constructor(t,r){this.update=t;this.deps=r;}eventObserved(t){t.type=="change"&&n.write(this.update);}};function ne$1(e,t){let r=new Set;return f.dependencies=r,e.style&&(e={...e,style:t.createAnimatedStyle(e.style)}),e=new u(e),f.dependencies=null,[e,r]}function ae(e,t){return e&&(l$1.fun(e)?e(t):e.current=t),t}var j=Symbol.for("AnimatedComponent"),Ke=(e,{applyAnimatedValues:t=()=>!1,createAnimatedStyle:r=a=>new u(a),getComponentProps:n=a=>a}={})=>{let a={applyAnimatedValues:t,createAnimatedStyle:r,getComponentProps:n},i=o=>{let m=I$2(o)||"Anonymous";return l$1.str(o)?o=i[o]||(i[o]=x$1(o,a)):o=o[j]||(o[j]=x$1(o,a)),o.displayName=`Animated(${m})`,o};return xt(e,(o,m)=>{l$1.arr(e)&&(m=I$2(o)),i[m]=i(o);}),{animated:i}},I$2=e=>l$1.str(e)?e:e&&l$1.str(e.displayName)?e.displayName:l$1.fun(e)&&e.name||null;
+// src/index.ts
 
-function I$1(t,...e){return l$1.fun(t)?t(...e):t}var te=(t,e)=>t===!0||!!(e&&t&&(l$1.fun(t)?t(e):ht$1(t).includes(e))),et=(t,e)=>l$1.obj(t)?e&&t[e]:t;var ke=(t,e)=>t.default===!0?t[e]:t.default?t.default[e]:void 0,nn=t=>t,ne=(t,e=nn)=>{let n=rn;t.default&&t.default!==!0&&(t=t.default,n=Object.keys(t));let r={};for(let o of n){let s=e(t[o],o);l$1.und(s)||(r[o]=s);}return r},rn=["config","onProps","onStart","onChange","onPause","onResume","onRest"],on={config:1,from:1,to:1,ref:1,loop:1,reset:1,pause:1,cancel:1,reverse:1,immediate:1,default:1,delay:1,onProps:1,onStart:1,onChange:1,onPause:1,onResume:1,onRest:1,onResolve:1,items:1,trail:1,sort:1,expires:1,initial:1,enter:1,update:1,leave:1,children:1,onDestroyed:1,keys:1,callId:1,parentId:1};function sn(t){let e={},n=0;if(xt(t,(r,o)=>{on[o]||(e[o]=r,n++);}),n)return e}function de(t){let e=sn(t);if(e){let n={to:e};return xt(t,(r,o)=>o in e||(n[o]=r)),n}return {...t}}function me(t){return t=ve(t),l$1.arr(t)?t.map(me):or(t)?p.createStringInterpolator({range:[0,1],output:[t,t]})(1):t}function Ue(t){for(let e in t)return !0;return !1}function Ee(t){return l$1.fun(t)||l$1.arr(t)&&l$1.obj(t[0])}function xe(t,e){t.ref?.delete(t),e?.delete(t);}function he(t,e){e&&t.ref!==e&&(t.ref?.delete(t),e.add(t),t.ref=e);}var mt={default:{tension:170,friction:26},gentle:{tension:120,friction:14},wobbly:{tension:180,friction:12},stiff:{tension:210,friction:20},slow:{tension:280,friction:60},molasses:{tension:280,friction:120}};var tt={...mt.default,mass:1,damping:1,easing:Lt$1.linear,clamp:!1},we=class{tension;friction;frequency;damping;mass;velocity=0;restVelocity;precision;progress;duration;easing;clamp;bounce;decay;round;constructor(){Object.assign(this,tt);}};function gt(t,e,n){n&&(n={...n},ht(n,e),e={...n,...e}),ht(t,e),Object.assign(t,e);for(let i in tt)t[i]==null&&(t[i]=tt[i]);let{frequency:r,damping:o}=t,{mass:s}=t;return l$1.und(r)||(r<.01&&(r=.01),o<0&&(o=0),t.tension=Math.pow(2*Math.PI/r,2)*s,t.friction=4*Math.PI*o*s/r),t}function ht(t,e){if(!l$1.und(e.decay))t.duration=void 0;else {let n=!l$1.und(e.tension)||!l$1.und(e.friction);(n||!l$1.und(e.frequency)||!l$1.und(e.damping)||!l$1.und(e.mass))&&(t.duration=void 0,t.decay=void 0),n&&(t.frequency=void 0);}}var yt=[],Le=class{changed=!1;values=yt;toValues=null;fromValues=yt;to;from;config=new we;immediate=!1};function Me(t,{key:e,props:n$1,defaultProps:r,state:o,actions:s}){return new Promise((i,a)=>{let u,p$1,f=te(n$1.cancel??r?.cancel,e);if(f)b();else {l$1.und(n$1.pause)||(o.paused=te(n$1.pause,e));let c=r?.pause;c!==!0&&(c=o.paused||te(c,e)),u=I$1(n$1.delay||0,e),c?(o.resumeQueue.add(m),s.pause()):(s.resume(),m());}function d(){o.resumeQueue.add(m),o.timeouts.delete(p$1),p$1.cancel(),u=p$1.time-n.now();}function m(){u>0&&!p.skipAnimation?(o.delayed=!0,p$1=n.setTimeout(b,u),o.pauseQueue.add(d),o.timeouts.add(p$1)):b();}function b(){o.delayed&&(o.delayed=!1),o.pauseQueue.delete(d),o.timeouts.delete(p$1),t<=(o.cancelId||0)&&(f=!0);try{s.start({...n$1,callId:t,cancel:f},i);}catch(c){a(c);}}})}var be=(t,e)=>e.length==1?e[0]:e.some(n=>n.cancelled)?q$1(t.get()):e.every(n=>n.noop)?nt(t.get()):E(t.get(),e.every(n=>n.finished)),nt=t=>({value:t,noop:!0,finished:!0,cancelled:!1}),E=(t,e,n=!1)=>({value:t,finished:e,cancelled:n}),q$1=t=>({value:t,cancelled:!0,finished:!1});function De(t,e,n$1,r){let{callId:o,parentId:s,onRest:i}=e,{asyncTo:a,promise:u}=n$1;return !s&&t===a&&!e.reset?u:n$1.promise=(async()=>{n$1.asyncId=o,n$1.asyncTo=t;let p$1=ne(e,(l,h)=>h==="onRest"?void 0:l),f,d,m=new Promise((l,h)=>(f=l,d=h)),b=l=>{let h=o<=(n$1.cancelId||0)&&q$1(r)||o!==n$1.asyncId&&E(r,!1);if(h)throw l.result=h,d(l),l},c=(l,h)=>{let g=new Ae,x=new Ne;return (async()=>{if(p.skipAnimation)throw oe(n$1),x.result=E(r,!1),d(x),x;b(g);let S=l$1.obj(l)?{...l}:{...h,to:l};S.parentId=o,xt(p$1,(V,_)=>{l$1.und(S[_])&&(S[_]=V);});let A=await r.start(S);return b(g),n$1.paused&&await new Promise(V=>{n$1.resumeQueue.add(V);}),A})()},P;if(p.skipAnimation)return oe(n$1),E(r,!1);try{let l;l$1.arr(t)?l=(async h=>{for(let g of h)await c(g);})(t):l=Promise.resolve(t(c,r.stop.bind(r))),await Promise.all([l.then(f),m]),P=E(r.get(),!0,!1);}catch(l){if(l instanceof Ae)P=l.result;else if(l instanceof Ne)P=l.result;else throw l}finally{o==n$1.asyncId&&(n$1.asyncId=s,n$1.asyncTo=s?a:void 0,n$1.promise=s?u:void 0);}return l$1.fun(i)&&n.batchedUpdates(()=>{i(P,r,r.item);}),P})()}function oe(t,e){Pe$1(t.timeouts,n=>n.cancel()),t.pauseQueue.clear(),t.resumeQueue.clear(),t.asyncId=t.asyncTo=t.promise=void 0,e&&(t.cancelId=e);}var Ae=class extends Error{result;constructor(){super("An async animation has been interrupted. You see this error because you forgot to use `await` or `.catch(...)` on its returned promise.");}},Ne=class extends Error{result;constructor(){super("SkipAnimationSignal");}};var Re=t=>t instanceof X,Sn=1,X=class extends ge{id=Sn++;_priority=0;get priority(){return this._priority}set priority(e){this._priority!=e&&(this._priority=e,this._onPriorityChange(e));}get(){let e=k$1(this);return e&&e.getValue()}to(...e){return p.to(this,e)}interpolate(...e){return Jt(),p.to(this,e)}toJSON(){return this.get()}observerAdded(e){e==1&&this._attach();}observerRemoved(e){e==0&&this._detach();}_attach(){}_detach(){}_onChange(e,n=!1){$t(this,{type:"change",parent:this,value:e,idle:n});}_onPriorityChange(e){this.idle||qe$1.sort(this),$t(this,{type:"priority",parent:this,priority:e});}};var se=Symbol.for("SpringPhase"),bt=1,rt=2,ot=4,qe=t=>(t[se]&bt)>0,Q=t=>(t[se]&rt)>0,ye=t=>(t[se]&ot)>0,st=(t,e)=>e?t[se]|=rt|bt:t[se]&=~rt,it$1=(t,e)=>e?t[se]|=ot:t[se]&=~ot;var ue=class extends X{key;animation=new Le;queue;defaultProps={};_state={paused:!1,delayed:!1,pauseQueue:new Set,resumeQueue:new Set,timeouts:new Set};_pendingCalls=new Set;_lastCallId=0;_lastToId=0;_memoizedDuration=0;constructor(e,n){if(super(),!l$1.und(e)||!l$1.und(n)){let r=l$1.obj(e)?{...e}:{...n,from:e};l$1.und(r.default)&&(r.default=!0),this.start(r);}}get idle(){return !(Q(this)||this._state.asyncTo)||ye(this)}get goal(){return ve(this.animation.to)}get velocity(){let e=k$1(this);return e instanceof l?e.lastVelocity||0:e.getPayload().map(n=>n.lastVelocity||0)}get hasAnimated(){return qe(this)}get isAnimating(){return Q(this)}get isPaused(){return ye(this)}get isDelayed(){return this._state.delayed}advance(e){let n=!0,r=!1,o=this.animation,{toValues:s}=o,{config:i}=o,a=F$1(o.to);!a&&Pt(o.to)&&(s=ht$1(ve(o.to))),o.values.forEach((f,d$1)=>{if(f.done)return;let m=f.constructor==d?1:a?a[d$1].lastPosition:s[d$1],b=o.immediate,c=m;if(!b){if(c=f.lastPosition,i.tension<=0){f.done=!0;return}let P=f.elapsedTime+=e,l=o.fromValues[d$1],h=f.v0!=null?f.v0:f.v0=l$1.arr(i.velocity)?i.velocity[d$1]:i.velocity,g,x=i.precision||(l==m?.005:Math.min(1,Math.abs(m-l)*.001));if(l$1.und(i.duration))if(i.decay){let S=i.decay===!0?.998:i.decay,A=Math.exp(-(1-S)*P);c=l+h/(1-S)*(1-A),b=Math.abs(f.lastPosition-c)<=x,g=h*A;}else {g=f.lastVelocity==null?h:f.lastVelocity;let S=i.restVelocity||x/10,A=i.clamp?0:i.bounce,V=!l$1.und(A),_=l==m?f.v0>0:l<m,v,w=!1,C=1,$=Math.ceil(e/C);for(let L=0;L<$&&(v=Math.abs(g)>S,!(!v&&(b=Math.abs(m-c)<=x,b)));++L){V&&(w=c==m||c>m==_,w&&(g=-g*A,c=m));let N=-i.tension*1e-6*(c-m),y=-i.friction*.001*g,T=(N+y)/i.mass;g=g+T*C,c=c+g*C;}}else {let S=1;i.duration>0&&(this._memoizedDuration!==i.duration&&(this._memoizedDuration=i.duration,f.durationProgress>0&&(f.elapsedTime=i.duration*f.durationProgress,P=f.elapsedTime+=e)),S=(i.progress||0)+P/this._memoizedDuration,S=S>1?1:S<0?0:S,f.durationProgress=S),c=l+i.easing(S)*(m-l),g=(c-f.lastPosition)/e,b=S==1;}f.lastVelocity=g,Number.isNaN(c)&&(console.warn("Got NaN while animating:",this),b=!0);}a&&!a[d$1].done&&(b=!1),b?f.done=!0:n=!1,f.setValue(c,i.round)&&(r=!0);});let u=k$1(this),p=u.getValue();if(n){let f=ve(o.to);(p!==f||r)&&!i.decay?(u.setValue(f),this._onChange(f)):r&&i.decay&&this._onChange(p),this._stop();}else r&&this._onChange(p);}set(e){return n.batchedUpdates(()=>{this._stop(),this._focus(e),this._set(e);}),this}pause(){this._update({pause:!0});}resume(){this._update({pause:!1});}finish(){if(Q(this)){let{to:e,config:n$1}=this.animation;n.batchedUpdates(()=>{this._onStart(),n$1.decay||this._set(e,!1),this._stop();});}return this}update(e){return (this.queue||(this.queue=[])).push(e),this}start(e,n){let r;return l$1.und(e)?(r=this.queue||[],this.queue=[]):r=[l$1.obj(e)?e:{...n,to:e}],Promise.all(r.map(o=>this._update(o))).then(o=>be(this,o))}stop(e){let{to:n$1}=this.animation;return this._focus(this.get()),oe(this._state,e&&this._lastCallId),n.batchedUpdates(()=>this._stop(n$1,e)),this}reset(){this._update({reset:!0});}eventObserved(e){e.type=="change"?this._start():e.type=="priority"&&(this.priority=e.priority+1);}_prepareNode(e){let n=this.key||"",{to:r,from:o}=e;r=l$1.obj(r)?r[n]:r,(r==null||Ee(r))&&(r=void 0),o=l$1.obj(o)?o[n]:o,o==null&&(o=void 0);let s={to:r,from:o};return qe(this)||(e.reverse&&([r,o]=[o,r]),o=ve(o),l$1.und(o)?k$1(this)||this._set(r):this._set(o)),s}_update({...e},n){let{key:r,defaultProps:o}=this;e.default&&Object.assign(o,ne(e,(a,u)=>/^on/.test(u)?et(a,r):a)),_t(this,e,"onProps"),Ie(this,"onProps",e,this);let s=this._prepareNode(e);if(Object.isFrozen(this))throw Error("Cannot animate a `SpringValue` object that is frozen. Did you forget to pass your component to `animated(...)` before animating its props?");let i=this._state;return Me(++this._lastCallId,{key:r,props:e,defaultProps:o,state:i,actions:{pause:()=>{ye(this)||(it$1(this,!0),yt$1(i.pauseQueue),Ie(this,"onPause",E(this,Ce(this,this.animation.to)),this));},resume:()=>{ye(this)&&(it$1(this,!1),Q(this)&&this._resume(),yt$1(i.resumeQueue),Ie(this,"onResume",E(this,Ce(this,this.animation.to)),this));},start:this._merge.bind(this,s)}}).then(a=>{if(e.loop&&a.finished&&!(n&&a.noop)){let u=at(e);if(u)return this._update(u,!0)}return a})}_merge(e,n$1,r){if(n$1.cancel)return this.stop(!0),r(q$1(this));let o=!l$1.und(e.to),s=!l$1.und(e.from);if(o||s)if(n$1.callId>this._lastToId)this._lastToId=n$1.callId;else return r(q$1(this));let{key:i,defaultProps:a,animation:u}=this,{to:p,from:f}=u,{to:d$1=p,from:m=f}=e;s&&!o&&(!n$1.default||l$1.und(d$1))&&(d$1=m),n$1.reverse&&([d$1,m]=[m,d$1]);let b=!bt$1(m,f);b&&(u.from=m),m=ve(m);let c=!bt$1(d$1,p);c&&this._focus(d$1);let P=Ee(n$1.to),{config:l}=u,{decay:h,velocity:g}=l;(o||s)&&(l.velocity=0),n$1.config&&!P&&gt(l,I$1(n$1.config,i),n$1.config!==a.config?I$1(a.config,i):void 0);let x=k$1(this);if(!x||l$1.und(d$1))return r(E(this,!0));let S=l$1.und(n$1.reset)?s&&!n$1.default:!l$1.und(m)&&te(n$1.reset,i),A=S?m:this.get(),V=me(d$1),_=l$1.num(V)||l$1.arr(V)||or(V),v=!P&&(!_||te(a.immediate||n$1.immediate,i));if(c){let L=Le$1(d$1);if(L!==x.constructor)if(v)x=this._set(V);else throw Error(`Cannot animate between ${x.constructor.name} and ${L.name}, as the "to" prop suggests`)}let w=x.constructor,C=Pt(d$1),$=!1;if(!C){let L=S||!qe(this)&&b;(c||L)&&($=bt$1(me(A),V),C=!$),(!bt$1(u.immediate,v)&&!v||!bt$1(l.decay,h)||!bt$1(l.velocity,g))&&(C=!0);}if($&&Q(this)&&(u.changed&&!S?C=!0:C||this._stop(p)),!P&&((C||Pt(p))&&(u.values=x.getPayload(),u.toValues=Pt(d$1)?null:w==d?[1]:ht$1(V)),u.immediate!=v&&(u.immediate=v,!v&&!S&&this._set(p)),C)){let{onRest:L}=u;Ve(_n,y=>_t(this,n$1,y));let N=E(this,Ce(this,p));yt$1(this._pendingCalls,N),this._pendingCalls.add(r),u.changed&&n.batchedUpdates(()=>{u.changed=!S,L?.(N,this),S?I$1(a.onRest,N):u.onStart?.(N,this);});}S&&this._set(A),P?r(De(n$1.to,n$1,this._state,this)):C?this._start():Q(this)&&!c?this._pendingCalls.add(r):r(nt(A));}_focus(e){let n=this.animation;e!==n.to&&(qt(this)&&this._detach(),n.to=e,qt(this)&&this._attach());}_attach(){let e=0,{to:n}=this.animation;Pt(n)&&(Gt$1(n,this),Re(n)&&(e=n.priority+1)),this.priority=e;}_detach(){let{to:e}=this.animation;Pt(e)&&Qt(e,this);}_set(e,n$1=!0){let r=ve(e);if(!l$1.und(r)){let o=k$1(this);if(!o||!bt$1(r,o.getValue())){let s=Le$1(r);!o||o.constructor!=s?D(this,s.create(r)):o.setValue(r),o&&n.batchedUpdates(()=>{this._onChange(r,n$1);});}}return k$1(this)}_onStart(){let e=this.animation;e.changed||(e.changed=!0,Ie(this,"onStart",E(this,Ce(this,e.to)),this));}_onChange(e,n){n||(this._onStart(),I$1(this.animation.onChange,e,this)),I$1(this.defaultProps.onChange,e,this),super._onChange(e,n);}_start(){let e=this.animation;k$1(this).reset(ve(e.to)),e.immediate||(e.fromValues=e.values.map(n=>n.lastPosition)),Q(this)||(st(this,!0),ye(this)||this._resume());}_resume(){p.skipAnimation?this.finish():qe$1.start(this);}_stop(e,n){if(Q(this)){st(this,!1);let r=this.animation;Ve(r.values,s=>{s.done=!0;}),r.toValues&&(r.onChange=r.onPause=r.onResume=void 0),$t(this,{type:"idle",parent:this});let o=n?q$1(this.get()):E(this.get(),Ce(this,e??r.to));yt$1(this._pendingCalls,o),r.changed&&(r.changed=!1,Ie(this,"onRest",o,this));}}};function Ce(t,e){let n=me(e),r=me(t.get());return bt$1(r,n)}function at(t,e=t.loop,n=t.to){let r=I$1(e);if(r){let o=r!==!0&&de(r),s=(o||t).reverse,i=!o||o.reset;return Pe({...t,loop:e,default:!1,pause:void 0,to:!s||Ee(n)?n:void 0,from:i?t.from:void 0,reset:i,...o})}}function Pe(t){let{to:e,from:n}=t=de(t),r=new Set;return l$1.obj(e)&&Vt(e,r),l$1.obj(n)&&Vt(n,r),t.keys=r.size?Array.from(r):null,t}function Ot(t){let e=Pe(t);return l$1.und(e.default)&&(e.default=ne(e)),e}function Vt(t,e){xt(t,(n,r)=>n!=null&&e.add(r));}var _n=["onStart","onRest","onChange","onPause","onResume"];function _t(t,e,n){t.animation[n]=e[n]!==ke(e,n)?et(e[n],t.key):void 0;}function Ie(t,e,...n){t.animation[e]?.(...n),t.defaultProps[e]?.(...n);}var Fn=["onStart","onChange","onRest"],kn=1,le=class{id=kn++;springs={};queue=[];ref;_flush;_initialProps;_lastAsyncId=0;_active=new Set;_changed=new Set;_started=!1;_item;_state={paused:!1,pauseQueue:new Set,resumeQueue:new Set,timeouts:new Set};_events={onStart:new Map,onChange:new Map,onRest:new Map};constructor(e,n){this._onFrame=this._onFrame.bind(this),n&&(this._flush=n),e&&this.start({default:!0,...e});}get idle(){return !this._state.asyncTo&&Object.values(this.springs).every(e=>e.idle&&!e.isDelayed&&!e.isPaused)}get item(){return this._item}set item(e){this._item=e;}get(){let e={};return this.each((n,r)=>e[r]=n.get()),e}set(e){for(let n in e){let r=e[n];l$1.und(r)||this.springs[n].set(r);}}update(e){return e&&this.queue.push(Pe(e)),this}start(e){let{queue:n}=this;return e?n=ht$1(e).map(Pe):this.queue=[],this._flush?this._flush(this,n):(jt(this,n),ze(this,n))}stop(e,n){if(e!==!!e&&(n=e),n){let r=this.springs;Ve(ht$1(n),o=>r[o].stop(!!e));}else oe(this._state,this._lastAsyncId),this.each(r=>r.stop(!!e));return this}pause(e){if(l$1.und(e))this.start({pause:!0});else {let n=this.springs;Ve(ht$1(e),r=>n[r].pause());}return this}resume(e){if(l$1.und(e))this.start({pause:!1});else {let n=this.springs;Ve(ht$1(e),r=>n[r].resume());}return this}each(e){xt(this.springs,e);}_onFrame(){let{onStart:e,onChange:n,onRest:r}=this._events,o=this._active.size>0,s=this._changed.size>0;(o&&!this._started||s&&!this._started)&&(this._started=!0,Pe$1(e,([u,p])=>{p.value=this.get(),u(p,this,this._item);}));let i=!o&&this._started,a=s||i&&r.size?this.get():null;s&&n.size&&Pe$1(n,([u,p])=>{p.value=a,u(p,this,this._item);}),i&&(this._started=!1,Pe$1(r,([u,p])=>{p.value=a,u(p,this,this._item);}));}eventObserved(e){if(e.type=="change")this._changed.add(e.parent),e.idle||this._active.add(e.parent);else if(e.type=="idle")this._active.delete(e.parent);else return;n.onFrame(this._onFrame);}};function ze(t,e){return Promise.all(e.map(n=>wt(t,n))).then(n=>be(t,n))}async function wt(t,e,n$1){let{keys:r,to:o,from:s,loop:i,onRest:a,onResolve:u}=e,p=l$1.obj(e.default)&&e.default;i&&(e.loop=!1),o===!1&&(e.to=null),s===!1&&(e.from=null);let f=l$1.arr(o)||l$1.fun(o)?o:void 0;f?(e.to=void 0,e.onRest=void 0,p&&(p.onRest=void 0)):Ve(Fn,P=>{let l=e[P];if(l$1.fun(l)){let h=t._events[P];e[P]=({finished:g,cancelled:x})=>{let S=h.get(l);S?(g||(S.finished=!1),x&&(S.cancelled=!0)):h.set(l,{value:null,finished:g||!1,cancelled:x||!1});},p&&(p[P]=e[P]);}});let d=t._state;e.pause===!d.paused?(d.paused=e.pause,yt$1(e.pause?d.pauseQueue:d.resumeQueue)):d.paused&&(e.pause=!0);let m=(r||Object.keys(t.springs)).map(P=>t.springs[P].start(e)),b=e.cancel===!0||ke(e,"cancel")===!0;(f||b&&d.asyncId)&&m.push(Me(++t._lastAsyncId,{props:e,state:d,actions:{pause:Y,resume:Y,start(P,l){b?(oe(d,t._lastAsyncId),l(q$1(t))):(P.onRest=a,l(De(f,P,d,t)));}}})),d.paused&&await new Promise(P=>{d.resumeQueue.add(P);});let c=be(t,await Promise.all(m));if(i&&c.finished&&!(n$1&&c.noop)){let P=at(e,i,o);if(P)return jt(t,[P]),wt(t,P,!0)}return u&&n.batchedUpdates(()=>u(c,t,t.item)),c}function _e(t,e){let n={...t.springs};return e&&Ve(ht$1(e),r=>{l$1.und(r.keys)&&(r=Pe(r)),l$1.obj(r.to)||(r={...r,to:void 0}),Mt(n,r,o=>Lt(o));}),pt(t,n),n}function pt(t,e){xt(e,(n,r)=>{t.springs[r]||(t.springs[r]=n,Gt$1(n,t));});}function Lt(t,e){let n=new ue;return n.key=t,e&&Gt$1(n,e),n}function Mt(t,e,n){e.keys&&Ve(e.keys,r=>{(t[r]||(t[r]=n(r)))._prepareNode(e);});}function jt(t,e){Ve(e,n=>{Mt(t.springs,n,r=>Lt(r,t));});}var H=({children:t,...e})=>{let n=useContext(Ge),r=e.pause||!!n.pause,o=e.immediate||!!n.immediate;e=Lr(()=>({pause:r,immediate:o}),[r,o]);let{Provider:s}=Ge;return React.createElement(s,{value:e},t)},Ge=wn(H,{});H.Provider=Ge.Provider;H.Consumer=Ge.Consumer;function wn(t,e){return Object.assign(t,React.createContext(e)),t.Provider._context=t,t.Consumer._context=t,t}var fe=()=>{let t=[],e=function(r){er$1();let o=[];return Ve(t,(s,i)=>{if(l$1.und(r))o.push(s.start());else {let a=n(r,s,i);a&&o.push(s.start(a));}}),o};e.current=t,e.add=function(r){t.includes(r)||t.push(r);},e.delete=function(r){let o=t.indexOf(r);~o&&t.splice(o,1);},e.pause=function(){return Ve(t,r=>r.pause(...arguments)),this},e.resume=function(){return Ve(t,r=>r.resume(...arguments)),this},e.set=function(r){Ve(t,(o,s)=>{let i=l$1.fun(r)?r(s,o):r;i&&o.set(i);});},e.start=function(r){let o=[];return Ve(t,(s,i)=>{if(l$1.und(r))o.push(s.start());else {let a=this._getProps(r,s,i);a&&o.push(s.start(a));}}),o},e.stop=function(){return Ve(t,r=>r.stop(...arguments)),this},e.update=function(r){return Ve(t,(o,s)=>o.update(this._getProps(r,o,s))),this};let n=function(r,o,s){return l$1.fun(r)?r(s,o):r};return e._getProps=n,e};function He(t,e,n){let r=l$1.fun(e)&&e;r&&!n&&(n=[]);let o=useMemo(()=>r||arguments.length==3?fe():void 0,[]),s=useRef(0),i=Mr(),a=useMemo(()=>({ctrls:[],queue:[],flush(h,g){let x=_e(h,g);return s.current>0&&!a.queue.length&&!Object.keys(x).some(A=>!h.springs[A])?ze(h,g):new Promise(A=>{pt(h,x),a.queue.push(()=>{A(ze(h,g));}),i();})}}),[]),u=useRef([...a.ctrls]),p=[],f=Ur(t)||0;useMemo(()=>{Ve(u.current.slice(t,f),h=>{xe(h,o),h.stop(!0);}),u.current.length=t,d(f,t);},[t]),useMemo(()=>{d(0,Math.min(f,t));},n);function d(h,g){for(let x=h;x<g;x++){let S=u.current[x]||(u.current[x]=new le(null,a.flush)),A=r?r(x,S):e[x];A&&(p[x]=Ot(A));}}let m=u.current.map((h,g)=>_e(h,p[g])),b=useContext(H),c=Ur(b),P=b!==c&&Ue(b);Q$1(()=>{s.current++,a.ctrls=u.current;let{queue:h}=a;h.length&&(a.queue=[],Ve(h,g=>g())),Ve(u.current,(g,x)=>{o?.add(g),P&&g.start({default:b});let S=p[x];S&&(he(g,S.ref),g.ref?g.queue.push(S):g.start(S));});}),$r(()=>()=>{Ve(a.ctrls,h=>h.stop(!0));});let l=m.map(h=>({...h}));return o?[l,o]:l}function J(t,e){let n=l$1.fun(t),[[r],o]=He(1,n?t:[t],n?e||[]:e);return n||arguments.length==2?[r,o]:r}function Gt(t,e,n){let r=l$1.fun(e)&&e,{reset:o,sort:s,trail:i=0,expires:a=!0,exitBeforeEnter:u=!1,onDestroyed:p,ref:f,config:d}=r?r():e,m=useMemo(()=>r||arguments.length==3?fe():void 0,[]),b=ht$1(t),c=[],P=useRef(null),l=o?null:P.current;Q$1(()=>{P.current=c;}),$r(()=>(Ve(c,y=>{m?.add(y.ctrl),y.ctrl.ref=m;}),()=>{Ve(P.current,y=>{y.expired&&clearTimeout(y.expirationId),xe(y.ctrl,m),y.ctrl.stop(!0);});}));let h=tr(b,r?r():e,l),g=o&&P.current||[];Q$1(()=>Ve(g,({ctrl:y,item:T,key:F})=>{xe(y,m),I$1(p,T,F);}));let x=[];if(l&&Ve(l,(y,T)=>{y.expired?(clearTimeout(y.expirationId),g.push(y)):(T=x[T]=h.indexOf(y.key),~T&&(c[T]=y));}),Ve(b,(y,T)=>{c[T]||(c[T]={key:h[T],item:y,phase:"mount",ctrl:new le},c[T].ctrl.item=y);}),x.length){let y=-1,{leave:T}=r?r():e;Ve(x,(F,k)=>{let O=l[k];~F?(y=c.indexOf(O),c[y]={...O,item:b[F]}):T&&c.splice(++y,0,O);});}l$1.fun(s)&&c.sort((y,T)=>s(y.item,T.item));let S=-i,A=Mr(),V=ne(e),_=new Map,v=useRef(new Map),w=useRef(!1);Ve(c,(y,T)=>{let F=y.key,k=y.phase,O=r?r():e,U,D,Jt=I$1(O.delay||0,F);if(k=="mount")U=O.enter,D="enter";else {let M=h.indexOf(F)<0;if(k!="leave")if(M)U=O.leave,D="leave";else if(U=O.update)D="update";else return;else if(!M)U=O.enter,D="enter";else return}if(U=I$1(U,y.item,T),U=l$1.obj(U)?de(U):{to:U},!U.config){let M=d||V.config;U.config=I$1(M,y.item,T,D);}S+=i;let Z={...V,delay:Jt+S,ref:f,immediate:O.immediate,reset:!1,...U};if(D=="enter"&&l$1.und(Z.from)){let M=r?r():e,Te=l$1.und(M.initial)||l?M.from:M.initial;Z.from=I$1(Te,y.item,T);}let{onResolve:Wt}=Z;Z.onResolve=M=>{I$1(Wt,M);let Te=P.current,B=Te.find(Fe=>Fe.key===F);if(B&&!(M.cancelled&&B.phase!="update")&&B.ctrl.idle){let Fe=Te.every(ee=>ee.ctrl.idle);if(B.phase=="leave"){let ee=I$1(a,B.item);if(ee!==!1){let Ze=ee===!0?0:ee;if(B.expired=!0,!Fe&&Ze>0){Ze<=2147483647&&(B.expirationId=setTimeout(A,Ze));return}}}Fe&&Te.some(ee=>ee.expired)&&(v.current.delete(B),u&&(w.current=!0),A());}};let ft=_e(y.ctrl,Z);D==="leave"&&u?v.current.set(y,{phase:D,springs:ft,payload:Z}):_.set(y,{phase:D,springs:ft,payload:Z});});let C=useContext(H),$=Ur(C),L=C!==$&&Ue(C);Q$1(()=>{L&&Ve(c,y=>{y.ctrl.start({default:C});});},[C]),Ve(_,(y,T)=>{if(v.current.size){let F=c.findIndex(k=>k.key===T.key);c.splice(F,1);}}),Q$1(()=>{Ve(v.current.size?v.current:_,({phase:y,payload:T},F)=>{let{ctrl:k}=F;F.phase=y,m?.add(k),L&&y=="enter"&&k.start({default:C}),T&&(he(k,T.ref),(k.ref||m)&&!w.current?k.update(T):(k.start(T),w.current&&(w.current=!1)));});},o?void 0:n);let N=y=>React.createElement(React.Fragment,null,c.map((T,F)=>{let{springs:k}=_.get(T)||T.ctrl,O=y({...k},T.item,T,F);return O&&O.type?React.createElement(O.type,{...O.props,key:l$1.str(T.key)||l$1.num(T.key)?T.key:T.ctrl.id,ref:O.ref}):O}));return m?[N,m]:N}var er=1;function tr(t,{key:e,keys:n=e},r){if(n===null){let o=new Set;return t.map(s=>{let i=r&&r.find(a=>a.item===s&&a.phase!=="leave"&&!o.has(a));return i?(o.add(i),i.key):er++})}return l$1.und(n)?t:l$1.fun(n)?t.map(n):ht$1(n)}var W=class extends X{constructor(n,r){super();this.source=n;this.calc=W$1(...r);let o=this._get(),s=Le$1(o);D(this,s.create(o));}key;idle=!0;calc;_active=new Set;advance(n){let r=this._get(),o=this.get();bt$1(r,o)||(k$1(this).setValue(r),this._onChange(r,this.idle)),!this.idle&&Yt(this._active)&&ct(this);}_get(){let n=l$1.arr(this.source)?this.source.map(ve):ht$1(ve(this.source));return this.calc(...n)}_start(){this.idle&&!Yt(this._active)&&(this.idle=!1,Ve(F$1(this),n=>{n.done=!1;}),p.skipAnimation?(n.batchedUpdates(()=>this.advance()),ct(this)):qe$1.start(this));}_attach(){let n=1;Ve(ht$1(this.source),r=>{Pt(r)&&Gt$1(r,this),Re(r)&&(r.idle||this._active.add(r),n=Math.max(n,r.priority+1));}),this.priority=n,this._start();}_detach(){Ve(ht$1(this.source),n=>{Pt(n)&&Qt(n,this);}),this._active.clear(),ct(this);}eventObserved(n){n.type=="change"?n.idle?this.advance():(this._active.add(n.parent),this._start()):n.type=="idle"?this._active.delete(n.parent):n.type=="priority"&&(this.priority=ht$1(this.source).reduce((r,o)=>Math.max(r,(Re(o)?o.priority:0)+1),0));}};function vr(t){return t.idle!==!1}function Yt(t){return !t.size||Array.from(t).every(vr)}function ct(t){t.idle||(t.idle=!0,Ve(F$1(t),e=>{e.done=!0;}),$t(t,{type:"idle",parent:t}));}p.assign({createStringInterpolator:Xt,to:(t,e)=>new W(t,e)});
+// src/applyAnimatedValues.ts
+var isCustomPropRE = /^--/;
+function dangerousStyleValue(name, value) {
+  if (value == null || typeof value === "boolean" || value === "")
+    return "";
+  if (typeof value === "number" && value !== 0 && !isCustomPropRE.test(name) && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]))
+    return value + "px";
+  return ("" + value).trim();
+}
+var attributeCache = {};
+function applyAnimatedValues(instance, props) {
+  if (!instance.nodeType || !instance.setAttribute) {
+    return false;
+  }
+  const isFilterElement = instance.nodeName === "filter" || instance.parentNode && instance.parentNode.nodeName === "filter";
+  const { style, children, scrollTop, scrollLeft, viewBox, ...attributes } = props;
+  const values = Object.values(attributes);
+  const names = Object.keys(attributes).map(
+    (name) => isFilterElement || instance.hasAttribute(name) ? name : attributeCache[name] || (attributeCache[name] = name.replace(
+      /([A-Z])/g,
+      // Attributes are written in dash case
+      (n) => "-" + n.toLowerCase()
+    ))
+  );
+  if (children !== void 0) {
+    instance.textContent = children;
+  }
+  for (const name in style) {
+    if (style.hasOwnProperty(name)) {
+      const value = dangerousStyleValue(name, style[name]);
+      if (isCustomPropRE.test(name)) {
+        instance.style.setProperty(name, value);
+      } else {
+        instance.style[name] = value;
+      }
+    }
+  }
+  names.forEach((name, i) => {
+    instance.setAttribute(name, values[i]);
+  });
+  if (scrollTop !== void 0) {
+    instance.scrollTop = scrollTop;
+  }
+  if (scrollLeft !== void 0) {
+    instance.scrollLeft = scrollLeft;
+  }
+  if (viewBox !== void 0) {
+    instance.setAttribute("viewBox", viewBox);
+  }
+}
+var isUnitlessNumber = {
+  animationIterationCount: true,
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  boxFlex: true,
+  boxFlexGroup: true,
+  boxOrdinalGroup: true,
+  columnCount: true,
+  columns: true,
+  flex: true,
+  flexGrow: true,
+  flexPositive: true,
+  flexShrink: true,
+  flexNegative: true,
+  flexOrder: true,
+  gridRow: true,
+  gridRowEnd: true,
+  gridRowSpan: true,
+  gridRowStart: true,
+  gridColumn: true,
+  gridColumnEnd: true,
+  gridColumnSpan: true,
+  gridColumnStart: true,
+  fontWeight: true,
+  lineClamp: true,
+  lineHeight: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related properties
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true
+};
+var prefixKey = (prefix, key) => prefix + key.charAt(0).toUpperCase() + key.substring(1);
+var prefixes = ["Webkit", "Ms", "Moz", "O"];
+isUnitlessNumber = Object.keys(isUnitlessNumber).reduce((acc, prop) => {
+  prefixes.forEach((prefix) => acc[prefixKey(prefix, prop)] = acc[prop]);
+  return acc;
+}, isUnitlessNumber);
+var domTransforms = /^(matrix|translate|scale|rotate|skew)/;
+var pxTransforms = /^(translate)/;
+var degTransforms = /^(rotate|skew)/;
+var addUnit = (value, unit) => is.num(value) && value !== 0 ? value + unit : value;
+var isValueIdentity = (value, id) => is.arr(value) ? value.every((v) => isValueIdentity(v, id)) : is.num(value) ? value === id : parseFloat(value) === id;
+var AnimatedStyle = class extends AnimatedObject {
+  constructor({ x, y, z, ...style }) {
+    const inputs = [];
+    const transforms = [];
+    if (x || y || z) {
+      inputs.push([x || 0, y || 0, z || 0]);
+      transforms.push((xyz) => [
+        `translate3d(${xyz.map((v) => addUnit(v, "px")).join(",")})`,
+        // prettier-ignore
+        isValueIdentity(xyz, 0)
+      ]);
+    }
+    eachProp(style, (value, key) => {
+      if (key === "transform") {
+        inputs.push([value || ""]);
+        transforms.push((transform) => [transform, transform === ""]);
+      } else if (domTransforms.test(key)) {
+        delete style[key];
+        if (is.und(value))
+          return;
+        const unit = pxTransforms.test(key) ? "px" : degTransforms.test(key) ? "deg" : "";
+        inputs.push(toArray(value));
+        transforms.push(
+          key === "rotate3d" ? ([x2, y2, z2, deg]) => [
+            `rotate3d(${x2},${y2},${z2},${addUnit(deg, unit)})`,
+            isValueIdentity(deg, 0)
+          ] : (input) => [
+            `${key}(${input.map((v) => addUnit(v, unit)).join(",")})`,
+            isValueIdentity(input, key.startsWith("scale") ? 1 : 0)
+          ]
+        );
+      }
+    });
+    if (inputs.length) {
+      style.transform = new FluidTransform(inputs, transforms);
+    }
+    super(style);
+  }
+};
+var FluidTransform = class extends FluidValue {
+  constructor(inputs, transforms) {
+    super();
+    this.inputs = inputs;
+    this.transforms = transforms;
+    this._value = null;
+  }
+  get() {
+    return this._value || (this._value = this._get());
+  }
+  _get() {
+    let transform = "";
+    let identity = true;
+    each(this.inputs, (input, i) => {
+      const arg1 = getFluidValue(input[0]);
+      const [t, id] = this.transforms[i](
+        is.arr(arg1) ? arg1 : input.map(getFluidValue)
+      );
+      transform += " " + t;
+      identity = identity && id;
+    });
+    return identity ? "none" : transform;
+  }
+  // Start observing our inputs once we have an observer.
+  observerAdded(count) {
+    if (count == 1)
+      each(
+        this.inputs,
+        (input) => each(
+          input,
+          (value) => hasFluidValue(value) && addFluidObserver(value, this)
+        )
+      );
+  }
+  // Stop observing our inputs once we have no observers.
+  observerRemoved(count) {
+    if (count == 0)
+      each(
+        this.inputs,
+        (input) => each(
+          input,
+          (value) => hasFluidValue(value) && removeFluidObserver(value, this)
+        )
+      );
+  }
+  eventObserved(event) {
+    if (event.type == "change") {
+      this._value = null;
+    }
+    callFluidObservers(this, event);
+  }
+};
 
-var k=/^--/;function I(t,e){return e==null||typeof e=="boolean"||e===""?"":typeof e=="number"&&e!==0&&!k.test(t)&&!(c.hasOwnProperty(t)&&c[t])?e+"px":(""+e).trim()}var v={};function V(t,e){if(!t.nodeType||!t.setAttribute)return !1;let r=t.nodeName==="filter"||t.parentNode&&t.parentNode.nodeName==="filter",{style:i,children:s,scrollTop:u,scrollLeft:l,viewBox:a,...n}=e,d=Object.values(n),m=Object.keys(n).map(o=>r||t.hasAttribute(o)?o:v[o]||(v[o]=o.replace(/([A-Z])/g,p=>"-"+p.toLowerCase())));s!==void 0&&(t.textContent=s);for(let o in i)if(i.hasOwnProperty(o)){let p=I(o,i[o]);k.test(o)?t.style.setProperty(o,p):t.style[o]=p;}m.forEach((o,p)=>{t.setAttribute(o,d[p]);}),u!==void 0&&(t.scrollTop=u),l!==void 0&&(t.scrollLeft=l),a!==void 0&&t.setAttribute("viewBox",a);}var c={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},F=(t,e)=>t+e.charAt(0).toUpperCase()+e.substring(1),L=["Webkit","Ms","Moz","O"];c=Object.keys(c).reduce((t,e)=>(L.forEach(r=>t[F(r,e)]=t[e]),t),c);var _=/^(matrix|translate|scale|rotate|skew)/,$=/^(translate)/,G=/^(rotate|skew)/,y=(t,e)=>l$1.num(t)&&t!==0?t+e:t,h=(t,e)=>l$1.arr(t)?t.every(r=>h(r,e)):l$1.num(t)?t===e:parseFloat(t)===e,g=class extends u{constructor({x:e,y:r,z:i,...s}){let u=[],l=[];(e||r||i)&&(u.push([e||0,r||0,i||0]),l.push(a=>[`translate3d(${a.map(n=>y(n,"px")).join(",")})`,h(a,0)])),xt(s,(a,n)=>{if(n==="transform")u.push([a||""]),l.push(d=>[d,d===""]);else if(_.test(n)){if(delete s[n],l$1.und(a))return;let d=$.test(n)?"px":G.test(n)?"deg":"";u.push(ht$1(a)),l.push(n==="rotate3d"?([m,o,p,O])=>[`rotate3d(${m},${o},${p},${y(O,d)})`,h(O,0)]:m=>[`${n}(${m.map(o=>y(o,d)).join(",")})`,h(m,n.startsWith("scale")?1:0)]);}}),u.length&&(s.transform=new x(u,l)),super(s);}},x=class extends ge{constructor(r,i){super();this.inputs=r;this.transforms=i;}_value=null;get(){return this._value||(this._value=this._get())}_get(){let r="",i=!0;return Ve(this.inputs,(s,u)=>{let l=ve(s[0]),[a,n]=this.transforms[u](l$1.arr(l)?l:s.map(ve));r+=" "+a,i=i&&n;}),i?"none":r}observerAdded(r){r==1&&Ve(this.inputs,i=>Ve(i,s=>Pt(s)&&Gt$1(s,this)));}observerRemoved(r){r==0&&Ve(this.inputs,i=>Ve(i,s=>Pt(s)&&Qt(s,this)));}eventObserved(r){r.type=="change"&&(this._value=null),$t(this,r);}};var C=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","big","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","keygen","label","legend","li","link","main","map","mark","menu","menuitem","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","param","picture","pre","progress","q","rp","rt","ruby","s","samp","script","section","select","small","source","span","strong","style","sub","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr","circle","clipPath","defs","ellipse","foreignObject","g","image","line","linearGradient","mask","path","pattern","polygon","polyline","radialGradient","rect","stop","svg","text","tspan"];p.assign({batchedUpdates:unstable_batchedUpdates,createStringInterpolator:Xt,colors:It});var q=Ke(C,{applyAnimatedValues:V,createAnimatedStyle:t=>new g(t),getComponentProps:({scrollTop:t,scrollLeft:e,...r})=>r}),it=q.animated;
+// src/primitives.ts
+var primitives = [
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "big",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "keygen",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "menuitem",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr",
+  // SVG
+  "circle",
+  "clipPath",
+  "defs",
+  "ellipse",
+  "foreignObject",
+  "g",
+  "image",
+  "line",
+  "linearGradient",
+  "mask",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "stop",
+  "svg",
+  "text",
+  "tspan"
+];
+globals_exports.assign({
+  batchedUpdates: unstable_batchedUpdates,
+  createStringInterpolator: createStringInterpolator2,
+  colors: colors2
+});
+var host = createHost(primitives, {
+  applyAnimatedValues,
+  createAnimatedStyle: (style) => new AnimatedStyle(style),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getComponentProps: ({ scrollTop, scrollLeft, ...props }) => props
+});
+var animated = host.animated;
 
 /**
  * Component style.
  */
-const StyledDataPoint = styled(it.g)``;
+const StyledDataPoint = styled(animated.g)``;
 
 const _excluded$k = ["children", "className", "data", "id", "index", "isSelected", "labelDecorator", "onClick", "role", "tooltipVariant"];
 const DataPoint = /*#__PURE__*/forwardRef((props, ref) => {
@@ -428,7 +4148,7 @@ const StyledArc = styled(DataPoint)`
 const config = (() => ({
   config: {
     duration: 700,
-    easing: Lt$1.easeInOutQuad
+    easing: easings.easeInOutQuad
   },
   reset: true,
   immediate: false
@@ -467,10 +4187,10 @@ const Arc = /*#__PURE__*/forwardRef((props, ref) => {
       previousData
     } = props,
     forwardedProps = _objectWithoutProperties(props, _excluded$j);
-  const interpolator = interpolate(previousData, data);
+  const interpolator = interpolate$1(previousData, data);
   const isSelectable = role === 'option';
   const isDeselected = isSelectable && propsIsSelected === false;
-  const animatedProps = J(_objectSpread2(_objectSpread2({}, config), {}, {
+  const animatedProps = useSpring(_objectSpread2(_objectSpread2({}, config), {}, {
     to: async next => {
       await next({
         t: 1
@@ -485,7 +4205,7 @@ const Arc = /*#__PURE__*/forwardRef((props, ref) => {
     className: classNames(Arc.className, className),
     $clickable: Boolean(onClick),
     $hasStroke: Boolean(hasStroke)
-  }), /*#__PURE__*/React__default.createElement(it.path, {
+  }), /*#__PURE__*/React__default.createElement(animated.path, {
     d: config.immediate ? createArc(data) : animatedProps.t.to(t => createArc(interpolator(t))),
     fill: isDeselected ? 'var(--redsift-color-neutral-lightgrey)' : color
   }));
@@ -519,7 +4239,7 @@ const Arcs = /*#__PURE__*/forwardRef((props, ref) => {
     } = props,
     forwardedProps = _objectWithoutProperties(props, _excluded$i);
   const id = propsId !== null && propsId !== void 0 ? propsId : useId();
-  const animatedProps = J(_objectSpread2(_objectSpread2({}, config), {}, {
+  const animatedProps = useSpring(_objectSpread2(_objectSpread2({}, config), {}, {
     to: async next => {
       await next({
         t: 1
@@ -561,8 +4281,8 @@ const Arcs = /*#__PURE__*/forwardRef((props, ref) => {
     const arcIndex = (_arc$index2 = arc.index) !== null && _arc$index2 !== void 0 ? _arc$index2 : index;
     const arcId = (_arc$id2 = arc.id) !== null && _arc$id2 !== void 0 ? _arc$id2 : `id${id}__arc-${arcIndex}`;
     const arcLabelDecorator = (_arc$labelDecorator = arc.labelDecorator) !== null && _arc$labelDecorator !== void 0 ? _arc$labelDecorator : labelDecorator;
-    const interpolator = interpolate(arc.from, arc.data);
-    return /*#__PURE__*/React__default.createElement(it.text, {
+    const interpolator = interpolate$1(arc.from, arc.data);
+    return /*#__PURE__*/React__default.createElement(animated.text, {
       alignmentBaseline: "middle",
       className: `arc-label _${index}`,
       key: `${arcId}-label`,
@@ -600,7 +4320,7 @@ const AxisPosition = {
 /**
  * Component style.
  */
-const StyledAxis = styled(it.g)`
+const StyledAxis = styled(animated.g)`
   .redsift-axis__line,
   .redsift-axis-tick__line {
     fill: none;
@@ -759,7 +4479,7 @@ const Axis = /*#__PURE__*/forwardRef((props, ref) => {
     forwardedProps = _objectWithoutProperties(props, _excluded$h);
   const axis = getAxisType(position);
   const axisRef = ref || useRef();
-  const animatedProps = J(_objectSpread2(_objectSpread2({}, config), {}, {
+  const animatedProps = useSpring(_objectSpread2(_objectSpread2({}, config), {}, {
     to: async next => {
       await next({
         lineX2: axis === 'x' ? length : 0,
@@ -823,7 +4543,7 @@ const Axis = /*#__PURE__*/forwardRef((props, ref) => {
     tickPadding: tickPadding,
     tickRotation: tickRotation
   });
-  const transition = Gt(ticks, _objectSpread2(_objectSpread2({}, config), {}, {
+  const transition = useTransition(ticks, _objectSpread2(_objectSpread2({}, config), {}, {
     keys: tick => tick.key,
     initial: tick => ({
       opacity: 1,
@@ -855,7 +4575,7 @@ const Axis = /*#__PURE__*/forwardRef((props, ref) => {
     transform: `translate(${x},${y})`,
     ref: axisRef
   }), variant === AxisVariant.default || variant === AxisVariant.tick || variant === AxisVariant.lineTick || variant === AxisVariant.tickValue ? transition((transitionProps, tick, _state, tickIndex) => {
-    return /*#__PURE__*/React__default.createElement(it.g, {
+    return /*#__PURE__*/React__default.createElement(animated.g, {
       className: `${Axis.className}__tick`,
       key: tickIndex,
       transform: transitionProps.transform,
@@ -868,12 +4588,12 @@ const Axis = /*#__PURE__*/forwardRef((props, ref) => {
       x2: tick.lineX,
       y1: 0,
       y2: tick.lineY
-    }), variant === AxisVariant.default || variant === AxisVariant.tickValue ? /*#__PURE__*/React__default.createElement(it.text, {
+    }), variant === AxisVariant.default || variant === AxisVariant.tickValue ? /*#__PURE__*/React__default.createElement(animated.text, {
       dominantBaseline: textBaseline,
       textAnchor: textAlign,
       transform: transitionProps.textTransform
     }, `${tick.value}`) : null);
-  }) : null, variant === AxisVariant.default || variant === AxisVariant.line || variant === AxisVariant.lineTick ? /*#__PURE__*/React__default.createElement(it.line, {
+  }) : null, variant === AxisVariant.default || variant === AxisVariant.line || variant === AxisVariant.lineTick ? /*#__PURE__*/React__default.createElement(animated.line, {
     className: `${Axis.className}__line`,
     x1: 0,
     x2: config.immediate ? axis === 'x' ? length : 0 : animatedProps.lineX2,
@@ -988,11 +4708,11 @@ const Bar = /*#__PURE__*/forwardRef((props, ref) => {
       width
     } = props,
     forwardedProps = _objectWithoutProperties(props, _excluded$g);
-  const interpolator = interpolate(((_data = previousData.data) === null || _data === void 0 ? void 0 : _data.value) || 0, data.data.value);
+  const interpolator = interpolate$1(((_data = previousData.data) === null || _data === void 0 ? void 0 : _data.value) || 0, data.data.value);
   const text = labelDecorator ? labelDecorator(data) : data.data.key;
   const isSelectable = role === 'option';
   const isDeselected = isSelectable && propsIsSelected === false;
-  const animatedProps = J(_objectSpread2(_objectSpread2({}, config), {}, {
+  const animatedProps = useSpring(_objectSpread2(_objectSpread2({}, config), {}, {
     to: async next => {
       await next({
         t: 1
@@ -1007,11 +4727,11 @@ const Bar = /*#__PURE__*/forwardRef((props, ref) => {
     className: classNames(Bar.className, className),
     transform: orientation === BarOrientation.horizontal ? `translate(0, ${gap * (index + 1) + height * index})` : `translate(${gap * (index + 1) + width * index}, 0)`,
     $clickable: Boolean(onClick)
-  }), orientation === BarOrientation.horizontal ? /*#__PURE__*/React__default.createElement(it.rect, {
+  }), orientation === BarOrientation.horizontal ? /*#__PURE__*/React__default.createElement(animated.rect, {
     height: height,
     fill: isDeselected ? 'var(--redsift-color-neutral-lightgrey)' : color,
     width: config.immediate ? scale(data.data.value) : animatedProps.t.to(t => scale(interpolator(t)))
-  }) : /*#__PURE__*/React__default.createElement(it.rect, {
+  }) : /*#__PURE__*/React__default.createElement(animated.rect, {
     height: config.immediate ? scale(data.data.value) : animatedProps.t.to(t => scale(interpolator(t))),
     fill: isDeselected ? 'var(--redsift-color-neutral-lightgrey)' : color,
     width: width
@@ -1074,9 +4794,10 @@ const StyledChartContainerCaption = styled.p`
   font-size: var(--redsift-typography-caption-font-size);
   font-weight: var(--redsift-typography-caption-font-weight);
   line-height: var(--redsift-typography-caption-line-height);
+  margin: 8px;
 `;
 
-const _excluded$f = ["aria-label", "aria-labelledby", "caption", "chartProps", "chartRef", "children", "className", "id", "title", "onReset"];
+const _excluded$f = ["aria-label", "aria-labelledby", "description", "chartProps", "chartRef", "children", "className", "id", "title", "onReset"];
 const COMPONENT_NAME$6 = 'ChartContainer';
 const CLASSNAME$6 = 'redsift-chart-container';
 const DEFAULT_PROPS$6 = {};
@@ -1084,7 +4805,7 @@ const ChartContainer = /*#__PURE__*/forwardRef((props, ref) => {
   const {
       'aria-label': propsAriaLabel,
       'aria-labelledby': propsAriaLabelledby,
-      caption,
+      description,
       chartProps,
       chartRef,
       children,
@@ -1115,14 +4836,16 @@ const ChartContainer = /*#__PURE__*/forwardRef((props, ref) => {
     color: "question",
     variant: "unstyled",
     onClick: onReset
-  }, stringFormatter.format('reset')) : null) : null, children ? /*#__PURE__*/React__default.createElement("div", _extends({}, chartProps, {
+  }, stringFormatter.format('reset')) : null) : null, /*#__PURE__*/React__default.createElement(Flexbox, {
+    flexDirection: "column"
+  }, children ? /*#__PURE__*/React__default.createElement("div", _extends({}, chartProps, {
     ref: chartRef,
     className: `${ChartContainer.className}__content`,
     "aria-label": ariaLabel,
     "aria-labelledby": ariaLabelledby
-  }), children) : null, caption ? /*#__PURE__*/React__default.createElement(StyledChartContainerCaption, {
-    className: `${ChartContainer.className}__caption`
-  }, caption) : null);
+  }), children) : null, description ? /*#__PURE__*/React__default.createElement(StyledChartContainerCaption, {
+    className: `${ChartContainer.className}__description`
+  }, description) : null));
 });
 ChartContainer.className = CLASSNAME$6;
 ChartContainer.defaultProps = DEFAULT_PROPS$6;
@@ -2348,13 +6071,20 @@ const EmptyScatterPlot = /*#__PURE__*/forwardRef((props, ref) => {
   })))));
 });
 
-const _excluded$1 = ["isBrushable", "className", "data", "dotRole", "id", "isDotSelected", "labelDecorator", "labelVariant", "legendProps", "onBrush", "onBrushEnd", "onDotClick", "size", "theme", "tooltipVariant", "variant", "xAxisVariant", "yAxisVariant"];
+// Material Design Icons v7.2.96
+var mdiChevronDown = "M7.41,8.58L12,13.17L16.59,8.58L18,10L12,16L6,10L7.41,8.58Z";
+var mdiChevronRight = "M8.59,16.58L13.17,12L8.59,7.41L10,6L16,12L10,18L8.59,16.58Z";
+var mdiMouse = "M11,1.07C7.05,1.56 4,4.92 4,9H11M4,15A8,8 0 0,0 12,23A8,8 0 0,0 20,15V11H4M13,1.07V9H20C20,4.92 16.94,1.56 13,1.07Z";
+
+const _excluded$1 = ["isBrushable", "caption", "className", "data", "dotRole", "hideControlKeyPanel", "id", "isDotSelected", "labelDecorator", "labelVariant", "legendProps", "onBrush", "onBrushEnd", "onDotClick", "size", "theme", "tooltipVariant", "variant", "xAxisVariant", "xAxisPlacement", "yAxisVariant", "yAxisPlacement"];
 const RenderedScatterPlot = /*#__PURE__*/forwardRef((props, ref) => {
   const {
       isBrushable,
+      caption,
       className,
       data: propsData,
       dotRole,
+      hideControlKeyPanel,
       id,
       isDotSelected,
       labelDecorator,
@@ -2368,7 +6098,9 @@ const RenderedScatterPlot = /*#__PURE__*/forwardRef((props, ref) => {
       tooltipVariant,
       variant,
       xAxisVariant,
-      yAxisVariant
+      xAxisPlacement,
+      yAxisVariant,
+      yAxisPlacement
     } = props,
     forwardedProps = _objectWithoutProperties(props, _excluded$1);
   const cache = useRef();
@@ -2380,10 +6112,10 @@ const RenderedScatterPlot = /*#__PURE__*/forwardRef((props, ref) => {
   const width = chartDimensions.width;
   const height = chartDimensions.height;
   const margins = {
-    top: 16,
-    left: 48,
-    right: 16,
-    bottom: 48
+    top: xAxisVariant === AxisVariant.default || xAxisVariant === AxisVariant.tickValue ? 24 : 8,
+    left: yAxisVariant === AxisVariant.default || yAxisVariant === AxisVariant.tickValue ? 48 : 8,
+    right: yAxisVariant === AxisVariant.default || yAxisVariant === AxisVariant.tickValue ? 48 : 8,
+    bottom: xAxisVariant === AxisVariant.default || xAxisVariant === AxisVariant.tickValue ? 24 : 8
   };
   const chartHeight = height - margins.top - margins.bottom;
   const chartWidth = width - margins.left - margins.right;
@@ -2454,11 +6186,50 @@ const RenderedScatterPlot = /*#__PURE__*/forwardRef((props, ref) => {
   if (countsByCategory && !legendWidth.current) {
     legendWidth.current = `${Math.max(...countsByCategory.map(d => d.key.length + String(d.value).length)) * 8 + 32}px`;
   }
+  const [isKeyPanelOpen, setIsKeyPanelOpen] = useState(false);
   return /*#__PURE__*/React__default.createElement(StyledScatterPlot, _extends({}, forwardedProps, {
     id: id,
     className: className,
     ref: ref
-  }), /*#__PURE__*/React__default.createElement("svg", {
+  }), /*#__PURE__*/React__default.createElement(Flexbox, {
+    flexDirection: "column",
+    alignItems: "center",
+    gap: "8"
+  }, !hideControlKeyPanel ? /*#__PURE__*/React__default.createElement(Flexbox, {
+    width: width,
+    position: "absolute"
+  }, /*#__PURE__*/React__default.createElement(Flexbox, {
+    flexDirection: "column",
+    alignItems: "flex-end",
+    position: "absolute",
+    top: `${margins.top + 16}px`,
+    right: `${margins.right + 16}px`
+  }, /*#__PURE__*/React__default.createElement(Popover, {
+    placement: "bottom-end",
+    isOpen: isKeyPanelOpen,
+    onOpen: setIsKeyPanelOpen
+  }, /*#__PURE__*/React__default.createElement(Popover.Trigger, null, /*#__PURE__*/React__default.createElement(Button, {
+    variant: "secondary",
+    rightIcon: isKeyPanelOpen ? mdiChevronDown : mdiChevronRight,
+    color: "question",
+    style: {
+      border: '1px solid var(--redsift-color-neutral-midgrey)'
+    }
+  }, /*#__PURE__*/React__default.createElement(Icon, {
+    icon: mdiMouse
+  }))), /*#__PURE__*/React__default.createElement(Popover.Content, {
+    flexDirection: "column",
+    alignItems: "flex-start"
+  }, /*#__PURE__*/React__default.createElement(Text, {
+    margin: "8px 16px 0",
+    fontSize: "13px"
+  }, "Zoom - Mouse wheel"), /*#__PURE__*/React__default.createElement(Text, {
+    margin: "0 16px",
+    fontSize: "13px"
+  }, "Pan - Left click and drag"), /*#__PURE__*/React__default.createElement(Text, {
+    margin: "0 16px 8px",
+    fontSize: "13px"
+  }, "Select - Hold shift, left click and drag"))))) : null, /*#__PURE__*/React__default.createElement("svg", {
     ref: svgRef,
     width: width,
     height: height
@@ -2499,23 +6270,41 @@ const RenderedScatterPlot = /*#__PURE__*/forwardRef((props, ref) => {
     });
   }))), /*#__PURE__*/React__default.createElement("g", {
     transform: `translate(${margins.left},${margins.top})`
-  }, /*#__PURE__*/React__default.createElement(Axis, {
-    position: "left",
-    length: chartHeight,
-    scale: scaleY,
+  }, ['bottom', 'both'].includes(xAxisPlacement) ? /*#__PURE__*/React__default.createElement(Axis, {
+    position: "bottom",
+    length: chartWidth,
+    scale: scaleX,
     x: 0,
-    y: 0,
+    y: chartHeight,
     tickValues: 8,
     variant: xAxisVariant
-  }), /*#__PURE__*/React__default.createElement(Axis, {
-    position: "bottom",
+  }) : null, ['top', 'both'].includes(xAxisPlacement) ? /*#__PURE__*/React__default.createElement(Axis, {
+    position: "top",
     length: chartWidth,
     scale: scaleX,
     x: 0,
-    y: chartHeight,
+    y: 0,
+    tickValues: 8,
+    variant: xAxisVariant
+  }) : null, ['left', 'both'].includes(yAxisPlacement) ? /*#__PURE__*/React__default.createElement(Axis, {
+    position: "left",
+    length: chartHeight,
+    scale: scaleY,
+    x: 0,
+    y: 0,
+    tickValues: 8,
+    variant: yAxisVariant
+  }) : null, ['right', 'both'].includes(yAxisPlacement) ? /*#__PURE__*/React__default.createElement(Axis, {
+    position: "right",
+    length: chartHeight,
+    scale: scaleY,
+    x: chartWidth,
+    y: 0,
     tickValues: 8,
     variant: yAxisVariant
-  }))), hasCategory && labelVariant !== ScatterPlotLabelVariant.none ? /*#__PURE__*/React__default.createElement(Legend, _extends({
+  }) : null)), /*#__PURE__*/React__default.createElement(StyledChartContainerCaption, {
+    width: chartWidth - 48
+  }, caption)), hasCategory && labelVariant !== ScatterPlotLabelVariant.none ? /*#__PURE__*/React__default.createElement(Legend, _extends({
     data: countsByCategory.map(d => _objectSpread2(_objectSpread2({}, d), {}, {
       color: colorScale === null || colorScale === void 0 ? void 0 : colorScale(d.key)
     })),
@@ -2528,6 +6317,7 @@ const _excluded = ["className", "data", "dotRole", "emptyComponent", "id", "isDo
 const COMPONENT_NAME = 'ScatterPlot';
 const CLASSNAME = 'redsift-scatterplot';
 const DEFAULT_PROPS = {
+  hideControlKeyPanel: false,
   labelVariant: ScatterPlotLabelVariant.externalLabel,
   localeText: {
     emptyChartText: 'No Data'
@@ -2537,7 +6327,9 @@ const DEFAULT_PROPS = {
   tooltipVariant: TooltipVariant.none,
   variant: ScatterPlotVariant.default,
   xAxisVariant: AxisVariant.default,
-  yAxisVariant: AxisVariant.default
+  xAxisPlacement: 'bottom',
+  yAxisVariant: AxisVariant.default,
+  yAxisPlacement: 'left'
 };
 const ScatterPlot = /*#__PURE__*/forwardRef((props, ref) => {
   const {