react-spring-carousel 3.0.0-beta005 → 3.0.0-beta006

package/dist/cjs/index.js

@@ -1,3732 +1,19 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var React = require('react');
-var reactDom = require('react-dom');
-var react = require('@use-gesture/react');
+var web = require('@react-spring/web');
+var react = require('react');
+var react$1 = require('@use-gesture/react');
 var screenfull = require('screenfull');
 
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
-
-let updateQueue = makeQueue();
-const raf = fn => schedule(fn, updateQueue);
-let writeQueue = makeQueue();
-
-raf.write = fn => schedule(fn, writeQueue);
-
-let onStartQueue = makeQueue();
-
-raf.onStart = fn => schedule(fn, onStartQueue);
-
-let onFrameQueue = makeQueue();
-
-raf.onFrame = fn => schedule(fn, onFrameQueue);
-
-let onFinishQueue = makeQueue();
-
-raf.onFinish = fn => schedule(fn, onFinishQueue);
-
-let timeouts = [];
-
-raf.setTimeout = (handler, ms) => {
-  let time = raf.now() + ms;
-
-  let cancel = () => {
-    let i = timeouts.findIndex(t => t.cancel == cancel);
-    if (~i) timeouts.splice(i, 1);
-    pendingCount -= ~i ? 1 : 0;
-  };
-
-  let timeout = {
-    time,
-    handler,
-    cancel
-  };
-  timeouts.splice(findTimeout(time), 0, timeout);
-  pendingCount += 1;
-  start();
-  return timeout;
-};
-
-let 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;
-};
-
-let nativeRaf = typeof window != 'undefined' ? window.requestAnimationFrame : () => {};
-
-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();
-  }
-};
-
-let ts = -1;
-let pendingCount = 0;
-let 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() {
-  let prevTs = ts;
-  ts = raf.now();
-  let 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 = 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 = new Set();
-        pendingCount -= current.size;
-        eachSafely(current, fn => fn(arg) && next.add(fn));
-        pendingCount += next.size;
-        current = next;
-      }
-    }
-
-  };
-}
-
-function eachSafely(values, each) {
-  values.forEach(value => {
-    try {
-      each(value);
-    } catch (e) {
-      raf.catch(e);
-    }
-  });
-}
-
-function noop() {}
-const defineHidden = (obj, key, value) => Object.defineProperty(obj, key, {
-  value,
-  writable: true,
-  configurable: true
-});
-const 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 === undefined
-};
-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;
-}
-const 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);
-    }
-  }
-}
-const 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);
-  }
-}
-const flushCalls = (queue, ...args) => flush(queue, fn => fn(...args));
-const isSSR = () => typeof window === 'undefined' || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent);
-
-let createStringInterpolator$1;
-let to;
-let colors$1 = null;
-let skipAnimation = false;
-let willAdvance = noop;
-const assign = globals => {
-  if (globals.to) to = globals.to;
-  if (globals.now) raf.now = globals.now;
-  if (globals.colors !== undefined) colors$1 = globals.colors;
-  if (globals.skipAnimation != null) skipAnimation = globals.skipAnimation;
-  if (globals.createStringInterpolator) createStringInterpolator$1 = 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;
-};
-
-var globals = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  get createStringInterpolator () { return createStringInterpolator$1; },
-  get to () { return to; },
-  get colors () { return colors$1; },
-  get skipAnimation () { return skipAnimation; },
-  get willAdvance () { return willAdvance; },
-  assign: assign
-});
-
-const startQueue = new Set();
-let currentFrame = [];
-let prevFrame = [];
-let priority = 0;
-const frameLoop = {
-  get idle() {
-    return !startQueue.size && !currentFrame.length;
-  },
-
-  start(animation) {
-    if (priority > animation.priority) {
-      startQueue.add(animation);
-      raf.onStart(flushStartQueue);
-    } else {
-      startSafely(animation);
-      raf(advance);
-    }
-  },
-
-  advance,
-
-  sort(animation) {
-    if (priority) {
-      raf.onFrame(() => frameLoop.sort(animation));
-    } else {
-      const prevIndex = currentFrame.indexOf(animation);
-
-      if (~prevIndex) {
-        currentFrame.splice(prevIndex, 1);
-        startUnsafely(animation);
-      }
-    }
-  },
-
-  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;
-}
-
-const colors = {
-  transparent: 0x00000000,
-  aliceblue: 0xf0f8ffff,
-  antiquewhite: 0xfaebd7ff,
-  aqua: 0x00ffffff,
-  aquamarine: 0x7fffd4ff,
-  azure: 0xf0ffffff,
-  beige: 0xf5f5dcff,
-  bisque: 0xffe4c4ff,
-  black: 0x000000ff,
-  blanchedalmond: 0xffebcdff,
-  blue: 0x0000ffff,
-  blueviolet: 0x8a2be2ff,
-  brown: 0xa52a2aff,
-  burlywood: 0xdeb887ff,
-  burntsienna: 0xea7e5dff,
-  cadetblue: 0x5f9ea0ff,
-  chartreuse: 0x7fff00ff,
-  chocolate: 0xd2691eff,
-  coral: 0xff7f50ff,
-  cornflowerblue: 0x6495edff,
-  cornsilk: 0xfff8dcff,
-  crimson: 0xdc143cff,
-  cyan: 0x00ffffff,
-  darkblue: 0x00008bff,
-  darkcyan: 0x008b8bff,
-  darkgoldenrod: 0xb8860bff,
-  darkgray: 0xa9a9a9ff,
-  darkgreen: 0x006400ff,
-  darkgrey: 0xa9a9a9ff,
-  darkkhaki: 0xbdb76bff,
-  darkmagenta: 0x8b008bff,
-  darkolivegreen: 0x556b2fff,
-  darkorange: 0xff8c00ff,
-  darkorchid: 0x9932ccff,
-  darkred: 0x8b0000ff,
-  darksalmon: 0xe9967aff,
-  darkseagreen: 0x8fbc8fff,
-  darkslateblue: 0x483d8bff,
-  darkslategray: 0x2f4f4fff,
-  darkslategrey: 0x2f4f4fff,
-  darkturquoise: 0x00ced1ff,
-  darkviolet: 0x9400d3ff,
-  deeppink: 0xff1493ff,
-  deepskyblue: 0x00bfffff,
-  dimgray: 0x696969ff,
-  dimgrey: 0x696969ff,
-  dodgerblue: 0x1e90ffff,
-  firebrick: 0xb22222ff,
-  floralwhite: 0xfffaf0ff,
-  forestgreen: 0x228b22ff,
-  fuchsia: 0xff00ffff,
-  gainsboro: 0xdcdcdcff,
-  ghostwhite: 0xf8f8ffff,
-  gold: 0xffd700ff,
-  goldenrod: 0xdaa520ff,
-  gray: 0x808080ff,
-  green: 0x008000ff,
-  greenyellow: 0xadff2fff,
-  grey: 0x808080ff,
-  honeydew: 0xf0fff0ff,
-  hotpink: 0xff69b4ff,
-  indianred: 0xcd5c5cff,
-  indigo: 0x4b0082ff,
-  ivory: 0xfffff0ff,
-  khaki: 0xf0e68cff,
-  lavender: 0xe6e6faff,
-  lavenderblush: 0xfff0f5ff,
-  lawngreen: 0x7cfc00ff,
-  lemonchiffon: 0xfffacdff,
-  lightblue: 0xadd8e6ff,
-  lightcoral: 0xf08080ff,
-  lightcyan: 0xe0ffffff,
-  lightgoldenrodyellow: 0xfafad2ff,
-  lightgray: 0xd3d3d3ff,
-  lightgreen: 0x90ee90ff,
-  lightgrey: 0xd3d3d3ff,
-  lightpink: 0xffb6c1ff,
-  lightsalmon: 0xffa07aff,
-  lightseagreen: 0x20b2aaff,
-  lightskyblue: 0x87cefaff,
-  lightslategray: 0x778899ff,
-  lightslategrey: 0x778899ff,
-  lightsteelblue: 0xb0c4deff,
-  lightyellow: 0xffffe0ff,
-  lime: 0x00ff00ff,
-  limegreen: 0x32cd32ff,
-  linen: 0xfaf0e6ff,
-  magenta: 0xff00ffff,
-  maroon: 0x800000ff,
-  mediumaquamarine: 0x66cdaaff,
-  mediumblue: 0x0000cdff,
-  mediumorchid: 0xba55d3ff,
-  mediumpurple: 0x9370dbff,
-  mediumseagreen: 0x3cb371ff,
-  mediumslateblue: 0x7b68eeff,
-  mediumspringgreen: 0x00fa9aff,
-  mediumturquoise: 0x48d1ccff,
-  mediumvioletred: 0xc71585ff,
-  midnightblue: 0x191970ff,
-  mintcream: 0xf5fffaff,
-  mistyrose: 0xffe4e1ff,
-  moccasin: 0xffe4b5ff,
-  navajowhite: 0xffdeadff,
-  navy: 0x000080ff,
-  oldlace: 0xfdf5e6ff,
-  olive: 0x808000ff,
-  olivedrab: 0x6b8e23ff,
-  orange: 0xffa500ff,
-  orangered: 0xff4500ff,
-  orchid: 0xda70d6ff,
-  palegoldenrod: 0xeee8aaff,
-  palegreen: 0x98fb98ff,
-  paleturquoise: 0xafeeeeff,
-  palevioletred: 0xdb7093ff,
-  papayawhip: 0xffefd5ff,
-  peachpuff: 0xffdab9ff,
-  peru: 0xcd853fff,
-  pink: 0xffc0cbff,
-  plum: 0xdda0ddff,
-  powderblue: 0xb0e0e6ff,
-  purple: 0x800080ff,
-  rebeccapurple: 0x663399ff,
-  red: 0xff0000ff,
-  rosybrown: 0xbc8f8fff,
-  royalblue: 0x4169e1ff,
-  saddlebrown: 0x8b4513ff,
-  salmon: 0xfa8072ff,
-  sandybrown: 0xf4a460ff,
-  seagreen: 0x2e8b57ff,
-  seashell: 0xfff5eeff,
-  sienna: 0xa0522dff,
-  silver: 0xc0c0c0ff,
-  skyblue: 0x87ceebff,
-  slateblue: 0x6a5acdff,
-  slategray: 0x708090ff,
-  slategrey: 0x708090ff,
-  snow: 0xfffafaff,
-  springgreen: 0x00ff7fff,
-  steelblue: 0x4682b4ff,
-  tan: 0xd2b48cff,
-  teal: 0x008080ff,
-  thistle: 0xd8bfd8ff,
-  tomato: 0xff6347ff,
-  turquoise: 0x40e0d0ff,
-  violet: 0xee82eeff,
-  wheat: 0xf5deb3ff,
-  white: 0xffffffff,
-  whitesmoke: 0xf5f5f5ff,
-  yellow: 0xffff00ff,
-  yellowgreen: 0x9acd32ff
-};
-
-const NUMBER = '[-+]?\\d*\\.?\\d+';
-const PERCENTAGE = NUMBER + '%';
-
-function call(...parts) {
-  return '\\(\\s*(' + parts.join(')\\s*,\\s*(') + ')\\s*\\)';
-}
-
-const rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));
-const rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));
-const hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));
-const hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));
-const hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
-const hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
-const hex6 = /^#([0-9a-fA-F]{6})$/;
-const hex8 = /^#([0-9a-fA-F]{8})$/;
-
-function normalizeColor(color) {
-  let match;
-
-  if (typeof color === 'number') {
-    return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null;
-  }
-
-  if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0;
-
-  if (colors$1 && colors$1[color] !== undefined) {
-    return colors$1[color];
-  }
-
-  if (match = rgb.exec(color)) {
-    return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | 0x000000ff) >>> 0;
-  }
-
-  if (match = rgba.exec(color)) {
-    return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | parse1(match[4])) >>> 0;
-  }
-
-  if (match = hex3.exec(color)) {
-    return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + 'ff', 16) >>> 0;
-  }
-
-  if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0;
-
-  if (match = hex4.exec(color)) {
-    return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + match[4] + match[4], 16) >>> 0;
-  }
-
-  if (match = hsl.exec(color)) {
-    return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | 0x000000ff) >>> 0;
-  }
-
-  if (match = hsla.exec(color)) {
-    return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | parse1(match[4])) >>> 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;
-}
-
-function colorToRgba(input) {
-  let int32Color = normalizeColor(input);
-  if (int32Color === null) return input;
-  int32Color = int32Color || 0;
-  let r = (int32Color & 0xff000000) >>> 24;
-  let g = (int32Color & 0x00ff0000) >>> 16;
-  let b = (int32Color & 0x0000ff00) >>> 8;
-  let a = (int32Color & 0x000000ff) / 255;
-  return `rgba(${r}, ${g}, ${b}, ${a})`;
-}
-
-const createInterpolator = (range, output, extrapolate) => {
-  if (is.fun(range)) {
-    return range;
-  }
-
-  if (is.arr(range)) {
-    return createInterpolator({
-      range,
-      output: output,
-      extrapolate
-    });
-  }
-
-  if (is.str(range.output[0])) {
-    return createStringInterpolator$1(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 range = findRange(input, inputRange);
-    return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 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;
-}
-
-function _extends$2() {
-  _extends$2 = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-  return _extends$2.apply(this, arguments);
-}
-
-const $get = Symbol.for('FluidValue.get');
-const $observers = Symbol.for('FluidValue.observers');
-
-const hasFluidValue = arg => Boolean(arg && arg[$get]);
-
-const getFluidValue = arg => arg && arg[$get] ? arg[$get]() : arg;
-
-const getFluidObservers = target => target[$observers] || null;
-
-function callFluidObserver(observer, event) {
-  if (observer.eventObserved) {
-    observer.eventObserved(event);
-  } else {
-    observer(event);
-  }
-}
-
-function callFluidObservers(target, event) {
-  let observers = target[$observers];
-
-  if (observers) {
-    observers.forEach(observer => {
-      callFluidObserver(observer, event);
-    });
-  }
-}
-
-class FluidValue {
-  constructor(get) {
-    this[$get] = void 0;
-    this[$observers] = void 0;
-
-    if (!get && !(get = this.get)) {
-      throw Error('Unknown getter');
-    }
-
-    setFluidGetter(this, get);
-  }
-
-}
-
-const setFluidGetter = (target, get) => setHidden(target, $get, get);
-
-function addFluidObserver(target, observer) {
-  if (target[$get]) {
-    let observers = target[$observers];
-
-    if (!observers) {
-      setHidden(target, $observers, observers = new Set());
-    }
-
-    if (!observers.has(observer)) {
-      observers.add(observer);
-
-      if (target.observerAdded) {
-        target.observerAdded(observers.size, observer);
-      }
-    }
-  }
-
-  return observer;
-}
-
-function removeFluidObserver(target, observer) {
-  let observers = target[$observers];
-
-  if (observers && observers.has(observer)) {
-    const count = observers.size - 1;
-
-    if (count) {
-      observers.delete(observer);
-    } else {
-      target[$observers] = null;
-    }
-
-    if (target.observerRemoved) {
-      target.observerRemoved(count, observer);
-    }
-  }
-}
-
-const setHidden = (target, key, value) => Object.defineProperty(target, key, {
-  value,
-  writable: true,
-  configurable: true
-});
-
-const numberRegex = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
-const colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi;
-const unitRegex = new RegExp(`(${numberRegex.source})(%|[a-z]+)`, 'i');
-const rgbaRegex = /rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi;
-const cssVariableRegex = /var\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\)/;
-
-const 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 _value = window.getComputedStyle(document.documentElement).getPropertyValue(fallback);
-
-    if (_value) {
-      return _value;
-    } else {
-      return input;
-    }
-  } else if (fallback && cssVariableRegex.test(fallback)) {
-    return variableToRgba(fallback);
-  } else if (fallback) {
-    return fallback;
-  }
-
-  return input;
-};
-
-const parseCSSVariable = current => {
-  const match = cssVariableRegex.exec(current);
-  if (!match) return [,];
-  const [, token, fallback] = match;
-  return [token, fallback];
-};
-
-let namedColorRegex;
-
-const rgbaRound = (_, p1, p2, p3, p4) => `rgba(${Math.round(p1)}, ${Math.round(p2)}, ${Math.round(p3)}, ${p4})`;
-
-const createStringInterpolator = config => {
-  if (!namedColorRegex) namedColorRegex = colors$1 ? new RegExp(`(${Object.keys(colors$1).join('|')})(?!\\w)`, 'g') : /^\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(output => createInterpolator(_extends$2({}, config, {
-    output
-  })));
-  return input => {
-    var _output$find;
-
-    const missingUnit = !unitRegex.test(output[0]) && ((_output$find = output.find(value => unitRegex.test(value))) == null ? void 0 : _output$find.replace(numberRegex, ''));
-    let i = 0;
-    return output[0].replace(numberRegex, () => `${interpolators[i++](input)}${missingUnit || ''}`).replace(rgbaRegex, rgbaRound);
-  };
-};
-
-const prefix = 'react-spring: ';
-
-const 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;
-    }
-  };
-};
-
-const warnInterpolate = once(console.warn);
-function deprecateInterpolate() {
-  warnInterpolate(`${prefix}The "interpolate" function is deprecated in v9 (use "to" instead)`);
-}
-const 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`);
-}
-
-function isAnimatedString(value) {
-  return is.str(value) && (value[0] == '#' || /\d/.test(value) || !isSSR() && cssVariableRegex.test(value) || value in (colors$1 || {}));
-}
-
-const useIsomorphicLayoutEffect = isSSR() ? React.useEffect : React.useLayoutEffect;
-
-const useIsMounted = () => {
-  const isMounted = React.useRef(false);
-  useIsomorphicLayoutEffect(() => {
-    isMounted.current = true;
-    return () => {
-      isMounted.current = false;
-    };
-  }, []);
-  return isMounted;
-};
-
-function useForceUpdate() {
-  const update = React.useState()[1];
-  const isMounted = useIsMounted();
-  return () => {
-    if (isMounted.current) {
-      update(Math.random());
-    }
-  };
-}
-
-function useMemoOne(getResult, inputs) {
-  const [initial] = React.useState(() => ({
-    inputs,
-    result: getResult()
-  }));
-  const committed = React.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;
-  }
-
-  React.useEffect(() => {
-    committed.current = cache;
-
-    if (prevCache == initial) {
-      initial.inputs = initial.result = undefined;
-    }
-  }, [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;
-}
-
-const useOnce = effect => React.useEffect(effect, emptyDeps);
-const emptyDeps = [];
-
-function usePrev(value) {
-  const prevRef = React.useRef();
-  React.useEffect(() => {
-    prevRef.current = value;
-  });
-  return prevRef.current;
-}
-
-const $node = Symbol.for('Animated:node');
-const isAnimated = value => !!value && value[$node] === value;
-const getAnimated = owner => owner && owner[$node];
-const setAnimated = (owner, node) => defineHidden(owner, $node, node);
-const getPayload = owner => owner && owner[$node] && owner[$node].getPayload();
-class Animated {
-  constructor() {
-    this.payload = void 0;
-    setAnimated(this, this);
-  }
-
-  getPayload() {
-    return this.payload || [];
-  }
-
-}
-
-class AnimatedValue extends Animated {
-  constructor(_value) {
-    super();
-    this.done = true;
-    this.elapsedTime = void 0;
-    this.lastPosition = void 0;
-    this.lastVelocity = void 0;
-    this.v0 = void 0;
-    this.durationProgress = 0;
-    this._value = _value;
-
-    if (is.num(this._value)) {
-      this.lastPosition = this._value;
-    }
-  }
-
-  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;
-    }
-  }
-
-}
-
-class AnimatedString extends AnimatedValue {
-  constructor(value) {
-    super(0);
-    this._string = null;
-    this._toString = void 0;
-    this._toString = createInterpolator({
-      output: [value, value]
-    });
-  }
-
-  static create(value) {
-    return new AnimatedString(value);
-  }
-
-  getValue() {
-    let 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();
-  }
-
-}
-
-const TreeContext = {
-  dependencies: null
-};
-
-class AnimatedObject 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;
-  }
-
-  setValue(source) {
-    this.source = source;
-    this.payload = this._makePayload(source);
-  }
-
-  reset() {
-    if (this.payload) {
-      each(this.payload, node => node.reset());
-    }
-  }
-
-  _makePayload(source) {
-    if (source) {
-      const payload = new Set();
-      eachProp(source, this._addToPayload, payload);
-      return Array.from(payload);
-    }
-  }
-
-  _addToPayload(source) {
-    if (TreeContext.dependencies && hasFluidValue(source)) {
-      TreeContext.dependencies.add(source);
-    }
-
-    const payload = getPayload(source);
-
-    if (payload) {
-      each(payload, node => this.add(node));
-    }
-  }
-
-}
-
-class AnimatedArray extends AnimatedObject {
-  constructor(source) {
-    super(source);
-  }
-
-  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;
-}
-
-function _extends$1() {
-  _extends$1 = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-  return _extends$1.apply(this, arguments);
-}
-
-const withAnimated = (Component, host) => {
-  const hasInstance = !is.fun(Component) || Component.prototype && Component.prototype.isReactComponent;
-  return React.forwardRef((givenProps, givenRef) => {
-    const instanceRef = React.useRef(null);
-    const ref = hasInstance && React.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 = React.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);
-        }
-      };
-    });
-    React.useEffect(callback, []);
-    useOnce(() => () => {
-      const observer = observerRef.current;
-      each(observer.deps, dep => removeFluidObserver(dep, observer));
-    });
-    const usedProps = host.getComponentProps(props.getValue());
-    return React__namespace.createElement(Component, _extends$1({}, usedProps, {
-      ref: ref
-    }));
-  });
-};
-
-class PropsObserver {
-  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 = new Set();
-  TreeContext.dependencies = dependencies;
-  if (props.style) props = _extends$1({}, 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;
-}
-
-const cacheKey = Symbol.for('AnimatedComponent');
-const createHost = (components, {
-  applyAnimatedValues: _applyAnimatedValues = () => false,
-  createAnimatedStyle: _createAnimatedStyle = style => new AnimatedObject(style),
-  getComponentProps: _getComponentProps = props => props
-} = {}) => {
-  const hostConfig = {
-    applyAnimatedValues: _applyAnimatedValues,
-    createAnimatedStyle: _createAnimatedStyle,
-    getComponentProps: _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
-  };
-};
-
-const getDisplayName = arg => is.str(arg) ? arg : arg && is.str(arg.displayName) ? arg.displayName : is.fun(arg) && arg.name || null;
-
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-
-function callProp(value, ...args) {
-  return is.fun(value) ? value(...args) : value;
-}
-const matchProp = (value, key) => value === true || !!(key && value && (is.fun(value) ? value(key) : toArray(value).includes(key)));
-const resolveProp = (prop, key) => is.obj(prop) ? key && prop[key] : prop;
-const getDefaultProp = (props, key) => props.default === true ? props[key] : props.default ? props.default[key] : undefined;
-
-const noopTransform = value => value;
-
-const getDefaultProps = (props, transform = noopTransform) => {
-  let keys = DEFAULT_PROPS;
-
-  if (props.default && props.default !== true) {
-    props = props.default;
-    keys = Object.keys(props);
-  }
-
-  const defaults = {};
-
-  for (const key of keys) {
-    const value = transform(props[key], key);
-
-    if (!is.und(value)) {
-      defaults[key] = value;
-    }
-  }
-
-  return defaults;
-};
-const DEFAULT_PROPS = ['config', 'onProps', 'onStart', 'onChange', 'onPause', 'onResume', 'onRest'];
-const 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,
-  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 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 to = getForwardProps(props);
-
-  if (to) {
-    const out = {
-      to
-    };
-    eachProp(props, (val, key) => key in to || (out[key] = val));
-    return out;
-  }
-
-  return _extends({}, props);
-}
-function computeGoal(value) {
-  value = getFluidValue(value);
-  return is.arr(value) ? value.map(computeGoal) : isAnimatedString(value) ? globals.createStringInterpolator({
-    range: [0, 1],
-    output: [value, value]
-  })(1) : value;
-}
-function hasProps(props) {
-  for (const _ in props) return true;
-
-  return false;
-}
-function isAsyncTo(to) {
-  return is.fun(to) || is.arr(to) && is.obj(to[0]);
-}
-function detachRefs(ctrl, ref) {
-  var _ctrl$ref;
-
-  (_ctrl$ref = ctrl.ref) == null ? void 0 : _ctrl$ref.delete(ctrl);
-  ref == null ? void 0 : ref.delete(ctrl);
-}
-function replaceRef(ctrl, ref) {
-  if (ref && ctrl.ref !== ref) {
-    var _ctrl$ref2;
-
-    (_ctrl$ref2 = ctrl.ref) == null ? void 0 : _ctrl$ref2.delete(ctrl);
-    ref.add(ctrl);
-    ctrl.ref = ref;
-  }
-}
-
-const config = {
-  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
-  }
-};
-const c1 = 1.70158;
-const c2 = c1 * 1.525;
-const c3 = c1 + 1;
-const c4 = 2 * Math.PI / 3;
-const c5 = 2 * Math.PI / 4.5;
-
-const 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;
-  }
-};
-
-const 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
-};
-
-const defaults = _extends({}, config.default, {
-  mass: 1,
-  damping: 1,
-  easing: easings.linear,
-  clamp: false
-});
-
-class AnimationConfig {
-  constructor() {
-    this.tension = void 0;
-    this.friction = void 0;
-    this.frequency = void 0;
-    this.damping = void 0;
-    this.mass = void 0;
-    this.velocity = 0;
-    this.restVelocity = void 0;
-    this.precision = void 0;
-    this.progress = void 0;
-    this.duration = void 0;
-    this.easing = void 0;
-    this.clamp = void 0;
-    this.bounce = void 0;
-    this.decay = void 0;
-    this.round = void 0;
-    Object.assign(this, defaults);
-  }
-
-}
-function mergeConfig(config, newConfig, defaultConfig) {
-  if (defaultConfig) {
-    defaultConfig = _extends({}, defaultConfig);
-    sanitizeConfig(defaultConfig, newConfig);
-    newConfig = _extends({}, defaultConfig, newConfig);
-  }
-
-  sanitizeConfig(config, newConfig);
-  Object.assign(config, newConfig);
-
-  for (const key in defaults) {
-    if (config[key] == null) {
-      config[key] = defaults[key];
-    }
-  }
-
-  let {
-    mass,
-    frequency,
-    damping
-  } = config;
-
-  if (!is.und(frequency)) {
-    if (frequency < 0.01) frequency = 0.01;
-    if (damping < 0) damping = 0;
-    config.tension = Math.pow(2 * Math.PI / frequency, 2) * mass;
-    config.friction = 4 * Math.PI * damping * mass / frequency;
-  }
-
-  return config;
-}
-
-function sanitizeConfig(config, props) {
-  if (!is.und(props.decay)) {
-    config.duration = undefined;
-  } 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)) {
-      config.duration = undefined;
-      config.decay = undefined;
-    }
-
-    if (isTensionConfig) {
-      config.frequency = undefined;
-    }
-  }
-}
-
-const emptyArray = [];
-class Animation {
-  constructor() {
-    this.changed = false;
-    this.values = emptyArray;
-    this.toValues = null;
-    this.fromValues = emptyArray;
-    this.to = void 0;
-    this.from = void 0;
-    this.config = new AnimationConfig();
-    this.immediate = false;
-  }
-
-}
-
-function scheduleProps(callId, {
-  key,
-  props,
-  defaultProps,
-  state,
-  actions
-}) {
-  return new Promise((resolve, reject) => {
-    var _props$cancel;
-
-    let delay;
-    let timeout;
-    let cancel = matchProp((_props$cancel = props.cancel) != null ? _props$cancel : defaultProps == null ? void 0 : defaultProps.cancel, key);
-
-    if (cancel) {
-      onStart();
-    } else {
-      if (!is.und(props.pause)) {
-        state.paused = matchProp(props.pause, key);
-      }
-
-      let pause = defaultProps == null ? void 0 : 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.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(_extends({}, props, {
-          callId,
-          cancel
-        }), resolve);
-      } catch (err) {
-        reject(err);
-      }
-    }
-  });
-}
-
-const 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));
-const getNoopResult = value => ({
-  value,
-  noop: true,
-  finished: true,
-  cancelled: false
-});
-const getFinishedResult = (value, finished, cancelled = false) => ({
-  value,
-  finished,
-  cancelled
-});
-const getCancelledResult = value => ({
-  value,
-  cancelled: true,
-  finished: false
-});
-
-function runAsync(to, props, state, target) {
-  const {
-    callId,
-    parentId,
-    onRest
-  } = props;
-  const {
-    asyncTo: prevTo,
-    promise: prevPromise
-  } = state;
-
-  if (!parentId && to === prevTo && !props.reset) {
-    return prevPromise;
-  }
-
-  return state.promise = (async () => {
-    state.asyncId = callId;
-    state.asyncTo = to;
-    const defaultProps = getDefaultProps(props, (value, key) => key === 'onRest' ? undefined : value);
-    let preventBail;
-    let bail;
-    const bailPromise = new Promise((resolve, reject) => (preventBail = resolve, bail = reject));
-
-    const bailIfEnded = bailSignal => {
-      const bailResult = callId <= (state.cancelId || 0) && getCancelledResult(target) || 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 SkipAniamtionSignal();
-      return (async () => {
-        if (globals.skipAnimation) {
-          stopAsync(state);
-          skipAnimationSignal.result = getFinishedResult(target, false);
-          bail(skipAnimationSignal);
-          throw skipAnimationSignal;
-        }
-
-        bailIfEnded(bailSignal);
-        const props = is.obj(arg1) ? _extends({}, arg1) : _extends({}, arg2, {
-          to: arg1
-        });
-        props.parentId = callId;
-        eachProp(defaultProps, (value, key) => {
-          if (is.und(props[key])) {
-            props[key] = value;
-          }
-        });
-        const result = await target.start(props);
-        bailIfEnded(bailSignal);
-
-        if (state.paused) {
-          await new Promise(resume => {
-            state.resumeQueue.add(resume);
-          });
-        }
-
-        return result;
-      })();
-    };
-
-    let result;
-
-    if (globals.skipAnimation) {
-      stopAsync(state);
-      return getFinishedResult(target, false);
-    }
-
-    try {
-      let animating;
-
-      if (is.arr(to)) {
-        animating = (async queue => {
-          for (const props of queue) {
-            await animate(props);
-          }
-        })(to);
-      } else {
-        animating = Promise.resolve(to(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 SkipAniamtionSignal) {
-        result = err.result;
-      } else {
-        throw err;
-      }
-    } finally {
-      if (callId == state.asyncId) {
-        state.asyncId = parentId;
-        state.asyncTo = parentId ? prevTo : undefined;
-        state.promise = parentId ? prevPromise : undefined;
-      }
-    }
-
-    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 = undefined;
-  if (cancelId) state.cancelId = cancelId;
-}
-class BailSignal 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.');
-    this.result = void 0;
-  }
-
-}
-class SkipAniamtionSignal extends Error {
-  constructor() {
-    super('SkipAnimationSignal');
-    this.result = void 0;
-  }
-
-}
-
-const isFrameValue = value => value instanceof FrameValue;
-let nextId$1 = 1;
-class FrameValue extends FluidValue {
-  constructor(...args) {
-    super(...args);
-    this.id = nextId$1++;
-    this.key = void 0;
-    this._priority = 0;
-  }
-
-  get priority() {
-    return this._priority;
-  }
-
-  set priority(priority) {
-    if (this._priority != priority) {
-      this._priority = priority;
-
-      this._onPriorityChange(priority);
-    }
-  }
-
-  get() {
-    const node = getAnimated(this);
-    return node && node.getValue();
-  }
-
-  to(...args) {
-    return globals.to(this, args);
-  }
-
-  interpolate(...args) {
-    deprecateInterpolate();
-    return globals.to(this, args);
-  }
-
-  toJSON() {
-    return this.get();
-  }
-
-  observerAdded(count) {
-    if (count == 1) this._attach();
-  }
-
-  observerRemoved(count) {
-    if (count == 0) this._detach();
-  }
-
-  _attach() {}
-
-  _detach() {}
-
-  _onChange(value, idle = false) {
-    callFluidObservers(this, {
-      type: 'change',
-      parent: this,
-      value,
-      idle
-    });
-  }
-
-  _onPriorityChange(priority) {
-    if (!this.idle) {
-      frameLoop.sort(this);
-    }
-
-    callFluidObservers(this, {
-      type: 'priority',
-      parent: this,
-      priority
-    });
-  }
-
-}
-
-const $P = Symbol.for('SpringPhase');
-const HAS_ANIMATED = 1;
-const IS_ANIMATING = 2;
-const IS_PAUSED = 4;
-const hasAnimated = target => (target[$P] & HAS_ANIMATED) > 0;
-const isAnimating = target => (target[$P] & IS_ANIMATING) > 0;
-const isPaused = target => (target[$P] & IS_PAUSED) > 0;
-const setActiveBit = (target, active) => active ? target[$P] |= IS_ANIMATING | HAS_ANIMATED : target[$P] &= ~IS_ANIMATING;
-const setPausedBit = (target, paused) => paused ? target[$P] |= IS_PAUSED : target[$P] &= ~IS_PAUSED;
-
-class SpringValue extends FrameValue {
-  constructor(arg1, arg2) {
-    super();
-    this.key = void 0;
-    this.animation = new Animation();
-    this.queue = void 0;
-    this.defaultProps = {};
-    this._state = {
-      paused: false,
-      delayed: false,
-      pauseQueue: new Set(),
-      resumeQueue: new Set(),
-      timeouts: new Set()
-    };
-    this._pendingCalls = new Set();
-    this._lastCallId = 0;
-    this._lastToId = 0;
-    this._memoizedDuration = 0;
-
-    if (!is.und(arg1) || !is.und(arg2)) {
-      const props = is.obj(arg1) ? _extends({}, arg1) : _extends({}, arg2, {
-        from: arg1
-      });
-
-      if (is.und(props.default)) {
-        props.default = true;
-      }
-
-      this.start(props);
-    }
-  }
-
-  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(node => node.lastVelocity || 0);
-  }
-
-  get hasAnimated() {
-    return hasAnimated(this);
-  }
-
-  get isAnimating() {
-    return isAnimating(this);
-  }
-
-  get isPaused() {
-    return isPaused(this);
-  }
-
-  get isDelayed() {
-    return this._state.delayed;
-  }
-
-  advance(dt) {
-    let idle = true;
-    let changed = false;
-    const anim = this.animation;
-    let {
-      config,
-      toValues
-    } = anim;
-    const payload = getPayload(anim.to);
-
-    if (!payload && hasFluidValue(anim.to)) {
-      toValues = toArray(getFluidValue(anim.to));
-    }
-
-    anim.values.forEach((node, i) => {
-      if (node.done) return;
-      const to = node.constructor == AnimatedString ? 1 : payload ? payload[i].lastPosition : toValues[i];
-      let finished = anim.immediate;
-      let position = to;
-
-      if (!finished) {
-        position = node.lastPosition;
-
-        if (config.tension <= 0) {
-          node.done = true;
-          return;
-        }
-
-        let elapsed = node.elapsedTime += dt;
-        const from = anim.fromValues[i];
-        const v0 = node.v0 != null ? node.v0 : node.v0 = is.arr(config.velocity) ? config.velocity[i] : config.velocity;
-        let velocity;
-        const precision = config.precision || (from == to ? 0.005 : Math.min(1, Math.abs(to - from) * 0.001));
-
-        if (!is.und(config.duration)) {
-          let p = 1;
-
-          if (config.duration > 0) {
-            if (this._memoizedDuration !== config.duration) {
-              this._memoizedDuration = config.duration;
-
-              if (node.durationProgress > 0) {
-                node.elapsedTime = config.duration * node.durationProgress;
-                elapsed = node.elapsedTime += dt;
-              }
-            }
-
-            p = (config.progress || 0) + elapsed / this._memoizedDuration;
-            p = p > 1 ? 1 : p < 0 ? 0 : p;
-            node.durationProgress = p;
-          }
-
-          position = from + config.easing(p) * (to - from);
-          velocity = (position - node.lastPosition) / dt;
-          finished = p == 1;
-        } else if (config.decay) {
-          const decay = config.decay === true ? 0.998 : config.decay;
-          const e = Math.exp(-(1 - decay) * elapsed);
-          position = from + v0 / (1 - decay) * (1 - e);
-          finished = Math.abs(node.lastPosition - position) <= precision;
-          velocity = v0 * e;
-        } else {
-          velocity = node.lastVelocity == null ? v0 : node.lastVelocity;
-          const restVelocity = config.restVelocity || precision / 10;
-          const bounceFactor = config.clamp ? 0 : config.bounce;
-          const canBounce = !is.und(bounceFactor);
-          const isGrowing = from == to ? node.v0 > 0 : from < to;
-          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(to - position) <= precision;
-
-              if (finished) {
-                break;
-              }
-            }
-
-            if (canBounce) {
-              isBouncing = position == to || position > to == isGrowing;
-
-              if (isBouncing) {
-                velocity = -velocity * bounceFactor;
-                position = to;
-              }
-            }
-
-            const springForce = -config.tension * 0.000001 * (position - to);
-            const dampingForce = -config.friction * 0.001 * velocity;
-            const acceleration = (springForce + dampingForce) / config.mass;
-            velocity = velocity + acceleration * step;
-            position = position + velocity * step;
-          }
-        }
-
-        node.lastVelocity = velocity;
-
-        if (Number.isNaN(position)) {
-          console.warn(`Got NaN while animating:`, this);
-          finished = true;
-        }
-      }
-
-      if (payload && !payload[i].done) {
-        finished = false;
-      }
-
-      if (finished) {
-        node.done = true;
-      } else {
-        idle = false;
-      }
-
-      if (node.setValue(position, config.round)) {
-        changed = true;
-      }
-    });
-    const node = getAnimated(this);
-    const currVal = node.getValue();
-
-    if (idle) {
-      const finalVal = getFluidValue(anim.to);
-
-      if ((currVal !== finalVal || changed) && !config.decay) {
-        node.setValue(finalVal);
-
-        this._onChange(finalVal);
-      } else if (changed && config.decay) {
-        this._onChange(currVal);
-      }
-
-      this._stop();
-    } else if (changed) {
-      this._onChange(currVal);
-    }
-  }
-
-  set(value) {
-    raf.batchedUpdates(() => {
-      this._stop();
-
-      this._focus(value);
-
-      this._set(value);
-    });
-    return this;
-  }
-
-  pause() {
-    this._update({
-      pause: true
-    });
-  }
-
-  resume() {
-    this._update({
-      pause: false
-    });
-  }
-
-  finish() {
-    if (isAnimating(this)) {
-      const {
-        to,
-        config
-      } = this.animation;
-      raf.batchedUpdates(() => {
-        this._onStart();
-
-        if (!config.decay) {
-          this._set(to, false);
-        }
-
-        this._stop();
-      });
-    }
-
-    return this;
-  }
-
-  update(props) {
-    const queue = this.queue || (this.queue = []);
-    queue.push(props);
-    return this;
-  }
-
-  start(to, arg2) {
-    let queue;
-
-    if (!is.und(to)) {
-      queue = [is.obj(to) ? to : _extends({}, arg2, {
-        to
-      })];
-    } 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(cancel) {
-    const {
-      to
-    } = this.animation;
-
-    this._focus(this.get());
-
-    stopAsync(this._state, cancel && this._lastCallId);
-    raf.batchedUpdates(() => this._stop(to, cancel));
-    return this;
-  }
-
-  reset() {
-    this._update({
-      reset: true
-    });
-  }
-
-  eventObserved(event) {
-    if (event.type == 'change') {
-      this._start();
-    } else if (event.type == 'priority') {
-      this.priority = event.priority + 1;
-    }
-  }
-
-  _prepareNode(props) {
-    const key = this.key || '';
-    let {
-      to,
-      from
-    } = props;
-    to = is.obj(to) ? to[key] : to;
-
-    if (to == null || isAsyncTo(to)) {
-      to = undefined;
-    }
-
-    from = is.obj(from) ? from[key] : from;
-
-    if (from == null) {
-      from = undefined;
-    }
-
-    const range = {
-      to,
-      from
-    };
-
-    if (!hasAnimated(this)) {
-      if (props.reverse) [to, from] = [from, to];
-      from = getFluidValue(from);
-
-      if (!is.und(from)) {
-        this._set(from);
-      } else if (!getAnimated(this)) {
-        this._set(to);
-      }
-    }
-
-    return range;
-  }
-
-  _update(_ref, isLoop) {
-    let props = _extends({}, _ref);
-
-    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(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 = prevTo,
-      from = prevFrom
-    } = range;
-
-    if (hasFromProp && !hasToProp && (!props.default || is.und(to))) {
-      to = from;
-    }
-
-    if (props.reverse) [to, from] = [from, to];
-    const hasFromChanged = !isEqual(from, prevFrom);
-
-    if (hasFromChanged) {
-      anim.from = from;
-    }
-
-    from = getFluidValue(from);
-    const hasToChanged = !isEqual(to, prevTo);
-
-    if (hasToChanged) {
-      this._focus(to);
-    }
-
-    const hasAsyncTo = isAsyncTo(props.to);
-    const {
-      config
-    } = anim;
-    const {
-      decay,
-      velocity
-    } = config;
-
-    if (hasToProp || hasFromProp) {
-      config.velocity = 0;
-    }
-
-    if (props.config && !hasAsyncTo) {
-      mergeConfig(config, callProp(props.config, key), props.config !== defaultProps.config ? callProp(defaultProps.config, key) : void 0);
-    }
-
-    let node = getAnimated(this);
-
-    if (!node || is.und(to)) {
-      return resolve(getFinishedResult(this, true));
-    }
-
-    const reset = is.und(props.reset) ? hasFromProp && !props.default : !is.und(from) && matchProp(props.reset, key);
-    const value = reset ? from : this.get();
-    const goal = computeGoal(to);
-    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(to);
-
-      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(to);
-    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(config.decay, decay) || !isEqual(config.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(to) ? 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 == null ? void 0 : onRest(result, this);
-
-          if (reset) {
-            callProp(defaultProps.onRest, result);
-          } else {
-            anim.onStart == null ? void 0 : 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));
-    }
-  }
-
-  _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
-    } = this.animation;
-
-    if (hasFluidValue(to)) {
-      addFluidObserver(to, this);
-
-      if (isFrameValue(to)) {
-        priority = to.priority + 1;
-      }
-    }
-
-    this.priority = priority;
-  }
-
-  _detach() {
-    const {
-      to
-    } = this.animation;
-
-    if (hasFluidValue(to)) {
-      removeFluidObserver(to, this);
-    }
-  }
-
-  _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);
-  }
-
-  _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.skipAnimation) {
-      this.finish();
-    } else {
-      frameLoop.start(this);
-    }
-  }
-
-  _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 = undefined;
-      }
-
-      callFluidObservers(this, {
-        type: 'idle',
-        parent: this
-      });
-      const result = cancel ? getCancelledResult(this.get()) : getFinishedResult(this.get(), checkFinished(this, goal != null ? goal : anim.to));
-      flushCalls(this._pendingCalls, result);
-
-      if (anim.changed) {
-        anim.changed = false;
-        sendEvent(this, 'onRest', result, this);
-      }
-    }
-  }
-
-}
-
-function checkFinished(target, to) {
-  const goal = computeGoal(to);
-  const value = computeGoal(target.get());
-  return isEqual(value, goal);
-}
-
-function createLoopUpdate(props, loop = props.loop, to = props.to) {
-  let loopRet = callProp(loop);
-
-  if (loopRet) {
-    const overrides = loopRet !== true && inferTo(loopRet);
-    const reverse = (overrides || props).reverse;
-    const reset = !overrides || overrides.reset;
-    return createUpdate(_extends({}, props, {
-      loop,
-      default: false,
-      pause: undefined,
-      to: !reverse || isAsyncTo(to) ? to : undefined,
-      from: reset ? props.from : undefined,
-      reset
-    }, overrides));
-  }
-}
-function createUpdate(props) {
-  const {
-    to,
-    from
-  } = props = inferTo(props);
-  const keys = new Set();
-  if (is.obj(to)) findDefined(to, keys);
-  if (is.obj(from)) findDefined(from, keys);
-  props.keys = keys.size ? Array.from(keys) : null;
-  return props;
-}
-function declareUpdate(props) {
-  const update = createUpdate(props);
-
-  if (is.und(update.default)) {
-    update.default = getDefaultProps(update);
-  }
-
-  return update;
-}
-
-function findDefined(values, keys) {
-  eachProp(values, (value, key) => value != null && keys.add(key));
-}
-
-const 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) : undefined;
-}
-
-function sendEvent(target, type, ...args) {
-  var _target$animation$typ, _target$animation, _target$defaultProps$, _target$defaultProps;
-
-  (_target$animation$typ = (_target$animation = target.animation)[type]) == null ? void 0 : _target$animation$typ.call(_target$animation, ...args);
-  (_target$defaultProps$ = (_target$defaultProps = target.defaultProps)[type]) == null ? void 0 : _target$defaultProps$.call(_target$defaultProps, ...args);
-}
-
-const BATCHED_EVENTS = ['onStart', 'onChange', 'onRest'];
-let nextId = 1;
-class Controller {
-  constructor(props, flush) {
-    this.id = nextId++;
-    this.springs = {};
-    this.queue = [];
-    this.ref = void 0;
-    this._flush = void 0;
-    this._initialProps = void 0;
-    this._lastAsyncId = 0;
-    this._active = new Set();
-    this._changed = new Set();
-    this._started = false;
-    this._item = void 0;
-    this._state = {
-      paused: false,
-      pauseQueue: new Set(),
-      resumeQueue: new Set(),
-      timeouts: new Set()
-    };
-    this._events = {
-      onStart: new Map(),
-      onChange: new Map(),
-      onRest: new Map()
-    };
-    this._onFrame = this._onFrame.bind(this);
-
-    if (flush) {
-      this._flush = flush;
-    }
-
-    if (props) {
-      this.start(_extends({
-        default: true
-      }, props));
-    }
-  }
-
-  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() {
-    const values = {};
-    this.each((spring, key) => values[key] = spring.get());
-    return values;
-  }
-
-  set(values) {
-    for (const key in values) {
-      const value = values[key];
-
-      if (!is.und(value)) {
-        this.springs[key].set(value);
-      }
-    }
-  }
-
-  update(props) {
-    if (props) {
-      this.queue.push(createUpdate(props));
-    }
-
-    return this;
-  }
-
-  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);
-  }
-
-  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;
-  }
-
-  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(keys) {
-    if (is.und(keys)) {
-      this.start({
-        pause: false
-      });
-    } else {
-      const springs = this.springs;
-      each(toArray(keys), key => springs[key].resume());
-    }
-
-    return this;
-  }
-
-  each(iterator) {
-    eachProp(this.springs, iterator);
-  }
-
-  _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, ([onStart, result]) => {
-        result.value = this.get();
-        onStart(result, this, this._item);
-      });
-    }
-
-    const idle = !active && this._started;
-    const values = changed || idle && onRest.size ? this.get() : null;
-
-    if (changed && onChange.size) {
-      flush(onChange, ([onChange, result]) => {
-        result.value = values;
-        onChange(result, this, this._item);
-      });
-    }
-
-    if (idle) {
-      this._started = false;
-      flush(onRest, ([onRest, result]) => {
-        result.value = values;
-        onRest(result, this, this._item);
-      });
-    }
-  }
-
-  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,
-    from,
-    loop,
-    onRest,
-    onResolve
-  } = props;
-  const defaults = is.obj(props.default) && props.default;
-
-  if (loop) {
-    props.loop = false;
-  }
-
-  if (to === false) props.to = null;
-  if (from === false) props.from = null;
-  const asyncTo = is.arr(to) || is.fun(to) ? to : undefined;
-
-  if (asyncTo) {
-    props.to = undefined;
-    props.onRest = undefined;
-
-    if (defaults) {
-      defaults.onRest = undefined;
-    }
-  } else {
-    each(BATCHED_EVENTS, key => {
-      const handler = props[key];
-
-      if (is.fun(handler)) {
-        const queue = ctrl['_events'][key];
-
-        props[key] = ({
-          finished,
-          cancelled
-        }) => {
-          const result = queue.get(handler);
-
-          if (result) {
-            if (!finished) result.finished = false;
-            if (cancelled) result.cancelled = true;
-          } else {
-            queue.set(handler, {
-              value: null,
-              finished: finished || false,
-              cancelled: cancelled || false
-            });
-          }
-        };
-
-        if (defaults) {
-          defaults[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(props, resolve) {
-          if (cancel) {
-            stopAsync(state, ctrl['_lastAsyncId']);
-            resolve(getCancelledResult(ctrl));
-          } else {
-            props.onRest = onRest;
-            resolve(runAsync(asyncTo, props, 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, to);
-
-    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 = _extends({}, ctrl.springs);
-
-  if (props) {
-    each(toArray(props), props => {
-      if (is.und(props.keys)) {
-        props = createUpdate(props);
-      }
-
-      if (!is.obj(props.to)) {
-        props = _extends({}, props, {
-          to: undefined
-        });
-      }
-
-      prepareSprings(springs, props, 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);
-    });
-  });
-}
-
-function _objectWithoutPropertiesLoose$1(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-const _excluded$3 = ["children"];
-const SpringContext = _ref => {
-  let {
-    children
-  } = _ref,
-      props = _objectWithoutPropertiesLoose$1(_ref, _excluded$3);
-
-  const inherited = React.useContext(ctx);
-  const pause = props.pause || !!inherited.pause,
-        immediate = props.immediate || !!inherited.immediate;
-  props = useMemoOne(() => ({
-    pause,
-    immediate
-  }), [pause, immediate]);
-  const {
-    Provider
-  } = ctx;
-  return React__namespace.createElement(Provider, {
-    value: props
-  }, children);
-};
-const ctx = makeContext(SpringContext, {});
-SpringContext.Provider = ctx.Provider;
-SpringContext.Consumer = ctx.Consumer;
-
-function makeContext(target, init) {
-  Object.assign(target, React__namespace.createContext(init));
-  target.Provider._context = target;
-  target.Consumer._context = target;
-  return target;
-}
-
-const SpringRef = () => {
-  const current = [];
-
-  const SpringRef = function SpringRef(props) {
-    deprecateDirectCall();
-    const results = [];
-    each(current, (ctrl, i) => {
-      if (is.und(props)) {
-        results.push(ctrl.start());
-      } else {
-        const update = _getProps(props, ctrl, i);
-
-        if (update) {
-          results.push(ctrl.start(update));
-        }
-      }
-    });
-    return results;
-  };
-
-  SpringRef.current = current;
-
-  SpringRef.add = function (ctrl) {
-    if (!current.includes(ctrl)) {
-      current.push(ctrl);
-    }
-  };
-
-  SpringRef.delete = function (ctrl) {
-    const i = current.indexOf(ctrl);
-    if (~i) current.splice(i, 1);
-  };
-
-  SpringRef.pause = function () {
-    each(current, ctrl => ctrl.pause(...arguments));
-    return this;
-  };
-
-  SpringRef.resume = function () {
-    each(current, ctrl => ctrl.resume(...arguments));
-    return this;
-  };
-
-  SpringRef.set = function (values) {
-    each(current, ctrl => ctrl.set(values));
-  };
-
-  SpringRef.start = function (props) {
-    const results = [];
-    each(current, (ctrl, i) => {
-      if (is.und(props)) {
-        results.push(ctrl.start());
-      } else {
-        const update = this._getProps(props, ctrl, i);
-
-        if (update) {
-          results.push(ctrl.start(update));
-        }
-      }
-    });
-    return results;
-  };
-
-  SpringRef.stop = function () {
-    each(current, ctrl => ctrl.stop(...arguments));
-    return this;
-  };
-
-  SpringRef.update = function (props) {
-    each(current, (ctrl, i) => ctrl.update(this._getProps(props, ctrl, i)));
-    return this;
-  };
-
-  const _getProps = function _getProps(arg, ctrl, index) {
-    return is.fun(arg) ? arg(index, ctrl) : arg;
-  };
-
-  SpringRef._getProps = _getProps;
-  return SpringRef;
-};
-
-function useSprings(length, props, deps) {
-  const propsFn = is.fun(props) && props;
-  if (propsFn && !deps) deps = [];
-  const ref = React.useMemo(() => propsFn || arguments.length == 3 ? SpringRef() : void 0, []);
-  const layoutId = React.useRef(0);
-  const forceUpdate = useForceUpdate();
-  const state = React.useMemo(() => ({
-    ctrls: [],
-    queue: [],
-
-    flush(ctrl, updates) {
-      const springs = getSprings(ctrl, updates);
-      const canFlushSync = layoutId.current > 0 && !state.queue.length && !Object.keys(springs).some(key => !ctrl.springs[key]);
-      return canFlushSync ? flushUpdateQueue(ctrl, updates) : new Promise(resolve => {
-        setSprings(ctrl, springs);
-        state.queue.push(() => {
-          resolve(flushUpdateQueue(ctrl, updates));
-        });
-        forceUpdate();
-      });
-    }
-
-  }), []);
-  const ctrls = React.useRef([...state.ctrls]);
-  const updates = [];
-  const prevLength = usePrev(length) || 0;
-  React.useMemo(() => {
-    each(ctrls.current.slice(length, prevLength), ctrl => {
-      detachRefs(ctrl, ref);
-      ctrl.stop(true);
-    });
-    ctrls.current.length = length;
-    declareUpdates(prevLength, length);
-  }, [length]);
-  React.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 update = propsFn ? propsFn(i, ctrl) : props[i];
-
-      if (update) {
-        updates[i] = declareUpdate(update);
-      }
-    }
-  }
-
-  const springs = ctrls.current.map((ctrl, i) => getSprings(ctrl, updates[i]));
-  const context = React.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 == null ? void 0 : ref.add(ctrl);
-
-      if (hasContext) {
-        ctrl.start({
-          default: context
-        });
-      }
-
-      const update = updates[i];
-
-      if (update) {
-        replaceRef(ctrl, update.ref);
-
-        if (ctrl.ref) {
-          ctrl.queue.push(update);
-        } else {
-          ctrl.start(update);
-        }
-      }
-    });
-  });
-  useOnce(() => () => {
-    each(state.ctrls, ctrl => ctrl.stop(true));
-  });
-  const values = springs.map(x => _extends({}, x));
-  return ref ? [values, ref] : values;
-}
-
-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;
-}
-
-let TransitionPhase;
-
-(function (TransitionPhase) {
-  TransitionPhase["MOUNT"] = "mount";
-  TransitionPhase["ENTER"] = "enter";
-  TransitionPhase["UPDATE"] = "update";
-  TransitionPhase["LEAVE"] = "leave";
-})(TransitionPhase || (TransitionPhase = {}));
-
-class Interpolation extends FrameValue {
-  constructor(source, args) {
-    super();
-    this.key = void 0;
-    this.idle = true;
-    this.calc = void 0;
-    this._active = new Set();
-    this.source = source;
-    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.skipAnimation) {
-        raf.batchedUpdates(() => this.advance());
-        becomeIdle(this);
-      } else {
-        frameLoop.start(this);
-      }
-    }
-  }
-
-  _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();
-  }
-
-  _detach() {
-    each(toArray(this.source), source => {
-      if (hasFluidValue(source)) {
-        removeFluidObserver(source, this);
-      }
-    });
-
-    this._active.clear();
-
-    becomeIdle(this);
-  }
-
-  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.assign({
-  createStringInterpolator,
-  to: (source, args) => new Interpolation(source, args)
-});
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-const _excluded$2 = ["style", "children", "scrollTop", "scrollLeft"];
-const 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();
-}
-
-const attributeCache = {};
-function applyAnimatedValues(instance, props) {
-  if (!instance.nodeType || !instance.setAttribute) {
-    return false;
-  }
-
-  const isFilterElement = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter';
-
-  const _ref = props,
-        {
-    style,
-    children,
-    scrollTop,
-    scrollLeft
-  } = _ref,
-        attributes = _objectWithoutPropertiesLoose(_ref, _excluded$2);
-
-  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, n => '-' + n.toLowerCase())));
-
-  if (children !== void 0) {
-    instance.textContent = children;
-  }
-
-  for (let 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;
-  }
-}
-let 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,
-  fillOpacity: true,
-  floodOpacity: true,
-  stopOpacity: true,
-  strokeDasharray: true,
-  strokeDashoffset: true,
-  strokeMiterlimit: true,
-  strokeOpacity: true,
-  strokeWidth: true
-};
-
-const prefixKey = (prefix, key) => prefix + key.charAt(0).toUpperCase() + key.substring(1);
-
-const prefixes = ['Webkit', 'Ms', 'Moz', 'O'];
-isUnitlessNumber = Object.keys(isUnitlessNumber).reduce((acc, prop) => {
-  prefixes.forEach(prefix => acc[prefixKey(prefix, prop)] = acc[prop]);
-  return acc;
-}, isUnitlessNumber);
-
-const _excluded$1 = ["x", "y", "z"];
-const domTransforms = /^(matrix|translate|scale|rotate|skew)/;
-const pxTransforms = /^(translate)/;
-const degTransforms = /^(rotate|skew)/;
-
-const addUnit = (value, unit) => is.num(value) && value !== 0 ? value + unit : value;
-
-const isValueIdentity = (value, id) => is.arr(value) ? value.every(v => isValueIdentity(v, id)) : is.num(value) ? value === id : parseFloat(value) === id;
-
-class AnimatedStyle extends AnimatedObject {
-  constructor(_ref) {
-    let {
-      x,
-      y,
-      z
-    } = _ref,
-        style = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-
-    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(',')})`, 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' ? ([x, y, z, deg]) => [`rotate3d(${x},${y},${z},${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);
-  }
-
-}
-
-class FluidTransform extends FluidValue {
-  constructor(inputs, transforms) {
-    super();
-    this._value = null;
-    this.inputs = inputs;
-    this.transforms = transforms;
-  }
-
-  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;
-  }
-
-  observerAdded(count) {
-    if (count == 1) each(this.inputs, input => each(input, value => hasFluidValue(value) && addFluidObserver(value, this)));
-  }
-
-  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);
-  }
-
-}
-
-const 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', 'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];
-
-const _excluded = ["scrollTop", "scrollLeft"];
-globals.assign({
-  batchedUpdates: reactDom.unstable_batchedUpdates,
-  createStringInterpolator,
-  colors
-});
-createHost(primitives, {
-  applyAnimatedValues,
-  createAnimatedStyle: style => new AnimatedStyle(style),
-  getComponentProps: _ref => {
-    let props = _objectWithoutPropertiesLoose(_ref, _excluded);
-
-    return props;
-  }
-});
-
 const eventLabel = 'RSC::Event';
 function useEventsModule() {
-    const targetEvent = React.useRef(null);
-    React.useEffect(() => {
+    const targetEvent = react.useRef(null);
+    react.useEffect(() => {
         targetEvent.current = document.createElement('div');
     }, []);
     function useListenToCustomEvent(eventHandler) {
-        React.useEffect(() => {
+        react.useEffect(() => {
             function handleEvent(event) {
                 eventHandler(event.detail);
             }
@@ -3756,8 +43,8 @@ function useEventsModule() {
 }
 
 function useFullscreenModule({ mainCarouselWrapperRef, emitEvent, handleResize, }) {
-    const isFullscreen = React.useRef(false);
-    React.useEffect(() => {
+    const isFullscreen = react.useRef(false);
+    react.useEffect(() => {
         function handleFullscreenChange() {
             if (document.fullscreenElement) {
                 setIsFullscreen(true);
@@ -3814,8 +101,8 @@ function isInViewport(el) {
         rect.right <= (window.innerWidth || document.documentElement.clientWidth));
 }
 function useThumbsModule({ thumbsSlideAxis = 'x', withThumbs = false, prepareThumbsData, items, }) {
-    const wrapperRef = React.useRef(null);
-    const [spring, setSpring] = useSpring(() => ({
+    const wrapperRef = react.useRef(null);
+    const [spring, setSpring] = web.useSpring(() => ({
         val: 0,
     }));
     function getTotalScrollValue() {
@@ -3881,12 +168,12 @@ function useThumbsModule({ thumbsSlideAxis = 'x', withThumbs = false, prepareThu
 }
 
 function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = 'x', itemsPerSlide = 1, slideType = 'fixed', gutter = 0, withLoop = false, startEndGutter = 0, carouselSlideAxis = 'x', disableGestures = false, draggingSlideTreshold: _draggingSlideTreshold, slideWhenThresholdIsReached = false, freeScroll, enableFreeScrollDrag, initialStartingPosition, prepareThumbsData, initialActiveItem = 0, }) {
-    const prevWindowWidth = React.useRef(0);
-    const draggingSlideTreshold = React.useRef(_draggingSlideTreshold !== null && _draggingSlideTreshold !== void 0 ? _draggingSlideTreshold : 0);
-    const slideActionType = React.useRef('initial');
-    const slideModeType = React.useRef('initial');
-    const prevSlidedValue = React.useRef(0);
-    const [spring, setSpring] = useSpring(() => ({
+    const prevWindowWidth = react.useRef(0);
+    const draggingSlideTreshold = react.useRef(_draggingSlideTreshold !== null && _draggingSlideTreshold !== void 0 ? _draggingSlideTreshold : 0);
+    const slideActionType = react.useRef('initial');
+    const slideModeType = react.useRef('initial');
+    const prevSlidedValue = react.useRef(0);
+    const [spring, setSpring] = web.useSpring(() => ({
         val: 0,
         pause: !init,
         onChange({ value }) {
@@ -3909,12 +196,12 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
             }
         },
     }));
-    const activeItem = React.useRef(initialActiveItem);
-    const firstItemReached = React.useRef(initialActiveItem === 0);
-    const lastItemReached = React.useRef(false);
-    const mainCarouselWrapperRef = React.useRef(null);
-    const carouselTrackWrapperRef = React.useRef(null);
-    const getItems = React.useCallback(() => {
+    const activeItem = react.useRef(initialActiveItem);
+    const firstItemReached = react.useRef(initialActiveItem === 0);
+    const lastItemReached = react.useRef(false);
+    const mainCarouselWrapperRef = react.useRef(null);
+    const carouselTrackWrapperRef = react.useRef(null);
+    const getItems = react.useCallback(() => {
         if (withLoop) {
             return [
                 ...items.map(i => (Object.assign(Object.assign({}, i), { id: `prev-repeated-item-${i.id}` }))),
@@ -3981,7 +268,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
             to: {
                 val: to,
             },
-            config: Object.assign(Object.assign({}, config.default), { velocity: spring.val.velocity }),
+            config: Object.assign(Object.assign({}, web.config.default), { velocity: spring.val.velocity }),
             onRest(value) {
                 if (!immediate && value.finished) {
                     emitEvent({
@@ -4199,10 +486,10 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
             nextActiveItem: nextItem,
         });
     }
-    React.useEffect(() => {
+    react.useEffect(() => {
         prevWindowWidth.current = window.innerWidth;
     }, []);
-    React.useEffect(() => {
+    react.useEffect(() => {
         adjustCarouselWrapperPosition();
     }, [
         initialStartingPosition,
@@ -4214,7 +501,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
         slideType,
         init,
     ]);
-    React.useLayoutEffect(() => {
+    react.useLayoutEffect(() => {
         /**
          * Set initial track position
          */
@@ -4222,7 +509,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
             adjustCarouselWrapperPosition();
         }
     }, []);
-    React.useEffect(() => {
+    react.useEffect(() => {
         if (_draggingSlideTreshold) {
             draggingSlideTreshold.current = _draggingSlideTreshold;
         }
@@ -4230,7 +517,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
             draggingSlideTreshold.current = Math.floor(getSlideValue() / 2 / 2);
         }
     }, [_draggingSlideTreshold]);
-    React.useEffect(() => {
+    react.useEffect(() => {
         function handleResize() {
             if (window.innerWidth === prevWindowWidth.current)
                 return;
@@ -4242,7 +529,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
             window.removeEventListener('resize', handleResize);
         };
     }, []);
-    const bindDrag = react.useDrag(state => {
+    const bindDrag = react$1.useDrag(state => {
         const isDragging = state.dragging;
         const movement = state.offset[carouselSlideAxis === 'x' ? 0 : 1];
         const currentMovement = state.movement[carouselSlideAxis === 'x' ? 0 : 1];
@@ -4321,7 +608,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
                 if (!withLoop && lastItemReached.current) {
                     setSpring.start({
                         val: -getTotalScrollValue(),
-                        config: Object.assign(Object.assign({}, config.default), { velocity: state.velocity }),
+                        config: Object.assign(Object.assign({}, web.config.default), { velocity: state.velocity }),
                     });
                 }
                 else {
@@ -4332,7 +619,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
                 if (!withLoop && firstItemReached.current) {
                     setSpring.start({
                         val: 0,
-                        config: Object.assign(Object.assign({}, config.default), { velocity: state.velocity }),
+                        config: Object.assign(Object.assign({}, web.config.default), { velocity: state.velocity }),
                     });
                 }
                 else {
@@ -4342,7 +629,7 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
             else {
                 setSpring.start({
                     val: prevSlidedValue.current,
-                    config: Object.assign(Object.assign({}, config.default), { velocity: state.velocity }),
+                    config: Object.assign(Object.assign({}, web.config.default), { velocity: state.velocity }),
                 });
             }
         }
@@ -4477,9 +764,9 @@ function useSpringCarousel({ items, init = true, withThumbs, thumbsSlideAxis = '
         },
     };
 }
-const Context = React.createContext(undefined);
+const Context = react.createContext(undefined);
 function useSpringCarouselContext() {
-    const context = React.useContext(Context);
+    const context = react.useContext(Context);
     if (!context) {
         throw new Error('useSpringCarouselContext must be used within the carousel.');
     }