{"version":3,"file":"05d954cf-d605a1a15ccb4d436312.js","mappings":"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","sources":["webpack://mi-frontend/./node_modules/framer-motion/dist/framer-motion.es.js"],"sourcesContent":["import { __assign, __spreadArrays, __rest, __extends } from 'tslib';\nimport { useRef, memo, useEffect, createContext, useMemo, useContext, forwardRef, createElement, Fragment, useCallback, useState, Component, cloneElement, Children, isValidElement } from 'react';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { velocityPerSecond, distance, mix, interpolate, wrap } from '@popmotion/popcorn';\nimport styler, { createStylerFactory, buildStyleProperty, isTransformProp, transformProps, buildSVGAttrs } from 'stylefire';\nimport { invariant, warning } from 'hey-listen';\nimport { color, complex, number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { action, delay, tween, spring, keyframes as keyframes$1, inertia } from 'popmotion';\nimport * as easingLookup from '@popmotion/easing';\nimport { cubicBezier, linear } from '@popmotion/easing';\n\nvar isFloat = function isFloat(value) {\n  return !isNaN(parseFloat(value));\n};\n/**\r\n * `MotionValue` is used to track the state and velocity of motion values.\r\n *\r\n * @public\r\n */\n\n\nvar MotionValue = function () {\n  /**\r\n   * @param init - The initiating value\r\n   * @param config - Optional configuration options\r\n   *\r\n   * -  `transformer`: A function to transform incoming values with.\r\n   *\r\n   * @internal\r\n   */\n  function MotionValue(init, _a) {\n    var _this = this;\n\n    var _b = _a === void 0 ? {} : _a,\n        transformer = _b.transformer,\n        parent = _b.parent;\n    /**\r\n     * Duration, in milliseconds, since last updating frame.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.timeDelta = 0;\n    /**\r\n     * Timestamp of the last time this `MotionValue` was updated.\r\n     *\r\n     * @internal\r\n     */\n\n    this.lastUpdated = 0;\n    /**\r\n     * Tracks whether this value can output a velocity. Currently this is only true\r\n     * if the value is numerical, but we might be able to widen the scope here and support\r\n     * other value types.\r\n     *\r\n     * @internal\r\n     */\n\n    this.canTrackVelocity = false;\n\n    this.updateAndNotify = function (v, render) {\n      if (render === void 0) {\n        render = true;\n      }\n\n      _this.prev = _this.current;\n      _this.current = _this.transformer ? _this.transformer(v) : v;\n\n      if (_this.updateSubscribers && _this.prev !== _this.current) {\n        _this.updateSubscribers.forEach(_this.notifySubscriber);\n      }\n\n      if (_this.children) {\n        _this.children.forEach(_this.setChild);\n      }\n\n      if (render && _this.renderSubscribers) {\n        _this.renderSubscribers.forEach(_this.notifySubscriber);\n      } // Update timestamp\n\n\n      var _a = getFrameData(),\n          delta = _a.delta,\n          timestamp = _a.timestamp;\n\n      if (_this.lastUpdated !== timestamp) {\n        _this.timeDelta = delta;\n        _this.lastUpdated = timestamp;\n        sync.postRender(_this.scheduleVelocityCheck);\n      }\n    };\n    /**\r\n     * Notify a subscriber with the latest value.\r\n     *\r\n     * This is an instanced and bound function to prevent generating a new\r\n     * function once per frame.\r\n     *\r\n     * @param subscriber - The subscriber to notify.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.notifySubscriber = function (subscriber) {\n      subscriber(_this.current);\n    };\n    /**\r\n     * Schedule a velocity check for the next frame.\r\n     *\r\n     * This is an instanced and bound function to prevent generating a new\r\n     * function once per frame.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.scheduleVelocityCheck = function () {\n      return sync.postRender(_this.velocityCheck);\n    };\n    /**\r\n     * Updates `prev` with `current` if the value hasn't been updated this frame.\r\n     * This ensures velocity calculations return `0`.\r\n     *\r\n     * This is an instanced and bound function to prevent generating a new\r\n     * function once per frame.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.velocityCheck = function (_a) {\n      var timestamp = _a.timestamp;\n\n      if (timestamp !== _this.lastUpdated) {\n        _this.prev = _this.current;\n      }\n    };\n    /**\r\n     * Updates child `MotionValue`.\r\n     *\r\n     * @param child - Child `MotionValue`.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.setChild = function (child) {\n      return child.set(_this.current);\n    };\n\n    this.parent = parent;\n    this.transformer = transformer;\n    this.set(init, false);\n    this.canTrackVelocity = isFloat(this.current);\n  }\n  /**\r\n   * Creates a new `MotionValue` that's subscribed to the output of this one.\r\n   *\r\n   * @param config - Optional configuration options\r\n   *\r\n   * -  `transformer`: A function to transform incoming values with.\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.addChild = function (config) {\n    if (config === void 0) {\n      config = {};\n    }\n\n    var child = new MotionValue(this.current, __assign({\n      parent: this\n    }, config));\n    if (!this.children) this.children = new Set();\n    this.children.add(child);\n    return child;\n  };\n  /**\r\n   * Stops a `MotionValue` from being subscribed to this one.\r\n   *\r\n   * @param child - The subscribed `MotionValue`\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.removeChild = function (child) {\n    if (!this.children) {\n      return;\n    }\n\n    this.children.delete(child);\n  };\n  /**\r\n   * Subscribes a subscriber function to a subscription list.\r\n   *\r\n   * @param subscriptions - A `Set` of subscribers.\r\n   * @param subscription - A subscriber function.\r\n   */\n\n\n  MotionValue.prototype.subscribeTo = function (subscriptions, subscription) {\n    var _this = this;\n\n    var updateSubscriber = function updateSubscriber() {\n      return subscription(_this.current);\n    };\n\n    subscriptions.add(updateSubscriber);\n    return function () {\n      return subscriptions.delete(updateSubscriber);\n    };\n  };\n  /**\r\n   * Adds a function that will be notified when the `MotionValue` is updated.\r\n   *\r\n   * It returns a function that, when called, will cancel the subscription.\r\n   *\r\n   * When calling `onChange` inside a React component, it should be wrapped with the\r\n   * `useEffect` hook. As it returns an unsubscribe function, this should be returned\r\n   * from the `useEffect` function to ensure you don't add duplicate subscribers..\r\n   *\r\n   * @library\r\n   *\r\n   * ```jsx\r\n   * function MyComponent() {\r\n   *   const x = useMotionValue(0)\r\n   *   const y = useMotionValue(0)\r\n   *   const opacity = useMotionValue(1)\r\n   *\r\n   *   useEffect(() => {\r\n   *     function updateOpacity() {\r\n   *       const maxXY = Math.max(x.get(), y.get())\r\n   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\r\n   *       opacity.set(newOpacity)\r\n   *     }\r\n   *\r\n   *     const unsubscribeX = x.onChange(updateOpacity)\r\n   *     const unsubscribeY = y.onChange(updateOpacity)\r\n   *\r\n   *     return () => {\r\n   *       unsubscribeX()\r\n   *       unsubscribeY()\r\n   *     }\r\n   *   }, [])\r\n   *\r\n   *   return <Frame x={x} />\r\n   * }\r\n   * ```\r\n   *\r\n   * @motion\r\n   *\r\n   * ```jsx\r\n   * export const MyComponent = () => {\r\n   *   const x = useMotionValue(0)\r\n   *   const y = useMotionValue(0)\r\n   *   const opacity = useMotionValue(1)\r\n   *\r\n   *   useEffect(() => {\r\n   *     function updateOpacity() {\r\n   *       const maxXY = Math.max(x.get(), y.get())\r\n   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\r\n   *       opacity.set(newOpacity)\r\n   *     }\r\n   *\r\n   *     const unsubscribeX = x.onChange(updateOpacity)\r\n   *     const unsubscribeY = y.onChange(updateOpacity)\r\n   *\r\n   *     return () => {\r\n   *       unsubscribeX()\r\n   *       unsubscribeY()\r\n   *     }\r\n   *   }, [])\r\n   *\r\n   *   return <motion.div style={{ x }} />\r\n   * }\r\n   * ```\r\n   *\r\n   * @internalremarks\r\n   *\r\n   * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\r\n   *\r\n   * ```jsx\r\n   * useOnChange(x, () => {})\r\n   * ```\r\n   *\r\n   * @param subscriber - A function that receives the latest value.\r\n   * @returns A function that, when called, will cancel this subscription.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.onChange = function (subscription) {\n    if (!this.updateSubscribers) this.updateSubscribers = new Set();\n    return this.subscribeTo(this.updateSubscribers, subscription);\n  };\n  /**\r\n   * Adds a function that will be notified when the `MotionValue` requests a render.\r\n   *\r\n   * @param subscriber - A function that's provided the latest value.\r\n   * @returns A function that, when called, will cancel this subscription.\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.onRenderRequest = function (subscription) {\n    if (!this.renderSubscribers) this.renderSubscribers = new Set(); // Render immediately\n\n    this.notifySubscriber(subscription);\n    return this.subscribeTo(this.renderSubscribers, subscription);\n  };\n  /**\r\n   * Attaches a passive effect to the `MotionValue`.\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.attach = function (passiveEffect) {\n    this.passiveEffect = passiveEffect;\n  };\n  /**\r\n   * Sets the state of the `MotionValue`.\r\n   *\r\n   * @remarks\r\n   *\r\n   * ```jsx\r\n   * const x = useMotionValue(0)\r\n   * x.set(10)\r\n   * ```\r\n   *\r\n   * @param latest - Latest value to set.\r\n   * @param render - Whether to notify render subscribers. Defaults to `true`\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.set = function (v, render) {\n    if (render === void 0) {\n      render = true;\n    }\n\n    if (!render || !this.passiveEffect) {\n      this.updateAndNotify(v, render);\n    } else {\n      this.passiveEffect(v, this.updateAndNotify);\n    }\n  };\n  /**\r\n   * Returns the latest state of `MotionValue`\r\n   *\r\n   * @returns - The latest state of `MotionValue`\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.get = function () {\n    return this.current;\n  };\n  /**\r\n   * Returns the latest velocity of `MotionValue`\r\n   *\r\n   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.getVelocity = function () {\n    // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n    return this.canTrackVelocity ? // These casts could be avoided if parseFloat would be typed better\n    velocityPerSecond(parseFloat(this.current) - parseFloat(this.prev), this.timeDelta) : 0;\n  };\n  /**\r\n   * Registers a new animation to control this `MotionValue`. Only one\r\n   * animation can drive a `MotionValue` at one time.\r\n   *\r\n   * ```jsx\r\n   * value.start()\r\n   * ```\r\n   *\r\n   * @param animation - A function that starts the provided animation\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.start = function (animation) {\n    var _this = this;\n\n    this.stop();\n    return new Promise(function (resolve) {\n      _this.stopAnimation = animation(resolve);\n    }).then(function () {\n      return _this.clearAnimation();\n    });\n  };\n  /**\r\n   * Stop the currently active animation.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.stop = function () {\n    if (this.stopAnimation) this.stopAnimation();\n    this.clearAnimation();\n  };\n  /**\r\n   * Returns `true` if this value is currently animating.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.isAnimating = function () {\n    return !!this.stopAnimation;\n  };\n\n  MotionValue.prototype.clearAnimation = function () {\n    this.stopAnimation = null;\n  };\n  /**\r\n   * Destroy and clean up subscribers to this `MotionValue`.\r\n   *\r\n   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\r\n   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\r\n   * created a `MotionValue` via the `motionValue` function.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.destroy = function () {\n    this.updateSubscribers && this.updateSubscribers.clear();\n    this.renderSubscribers && this.renderSubscribers.clear();\n    this.parent && this.parent.removeChild(this);\n    this.stop();\n  };\n\n  return MotionValue;\n}();\n/**\r\n * @internal\r\n */\n\n\nfunction motionValue(init, opts) {\n  return new MotionValue(init, opts);\n}\n/**\r\n * Creates a constant value over the lifecycle of a component.\r\n *\r\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\r\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\r\n * you can ensure that initialisers don't execute twice or more.\r\n */\n\n\nfunction useConstant(init) {\n  var ref = useRef(null);\n\n  if (ref.current === null) {\n    ref.current = init();\n  }\n\n  return ref.current;\n}\n\nvar isMotionValue = function isMotionValue(value) {\n  return value instanceof MotionValue;\n}; // Creating a styler factory for the `onUpdate` prop allows all values\n// to fire and the `onUpdate` prop will only fire once per frame\n\n\nvar updateStyler = createStylerFactory({\n  onRead: function onRead() {\n    return null;\n  },\n  onRender: function onRender(state, _a) {\n    var onUpdate = _a.onUpdate;\n    return onUpdate(state);\n  }\n});\n\nvar MotionValuesMap = function () {\n  function MotionValuesMap() {\n    this.hasMounted = false;\n    this.values = new Map();\n    this.unsubscribers = new Map();\n  }\n\n  MotionValuesMap.prototype.has = function (key) {\n    return this.values.has(key);\n  };\n\n  MotionValuesMap.prototype.set = function (key, value) {\n    this.values.set(key, value);\n\n    if (this.hasMounted) {\n      this.bindValueToOutput(key, value);\n    }\n  };\n\n  MotionValuesMap.prototype.get = function (key, defaultValue) {\n    var value = this.values.get(key);\n\n    if (value === undefined && defaultValue !== undefined) {\n      value = new MotionValue(defaultValue);\n      this.set(key, value);\n    }\n\n    return value;\n  };\n\n  MotionValuesMap.prototype.forEach = function (callback) {\n    return this.values.forEach(callback);\n  };\n\n  MotionValuesMap.prototype.bindValueToOutput = function (key, value) {\n    var _this = this;\n\n    var onRender = function onRender(v) {\n      return _this.output && _this.output(key, v);\n    };\n\n    var unsubscribeOnRender = value.onRenderRequest(onRender);\n\n    var onChange = function onChange(v) {\n      _this.onUpdate && _this.onUpdate.set(key, v);\n    };\n\n    var unsubscribeOnChange = value.onChange(onChange);\n\n    if (this.unsubscribers.has(key)) {\n      this.unsubscribers.get(key)();\n    }\n\n    this.unsubscribers.set(key, function () {\n      unsubscribeOnRender();\n      unsubscribeOnChange();\n    });\n  };\n\n  MotionValuesMap.prototype.setOnUpdate = function (onUpdate) {\n    this.onUpdate = undefined;\n\n    if (onUpdate) {\n      this.onUpdate = updateStyler({\n        onUpdate: onUpdate\n      });\n    }\n  };\n\n  MotionValuesMap.prototype.setTransformTemplate = function (transformTemplate) {\n    if (this.transformTemplate !== transformTemplate) {\n      this.transformTemplate = transformTemplate;\n      this.updateTransformTemplate();\n    }\n  };\n\n  MotionValuesMap.prototype.getTransformTemplate = function () {\n    return this.transformTemplate;\n  };\n\n  MotionValuesMap.prototype.updateTransformTemplate = function () {\n    if (this.output) {\n      this.output(\"transform\", this.transformTemplate);\n    }\n  };\n\n  MotionValuesMap.prototype.mount = function (output) {\n    var _this = this;\n\n    this.hasMounted = true;\n    if (output) this.output = output;\n    this.values.forEach(function (value, key) {\n      return _this.bindValueToOutput(key, value);\n    });\n    this.updateTransformTemplate();\n  };\n\n  MotionValuesMap.prototype.unmount = function () {\n    var _this = this;\n\n    this.values.forEach(function (_value, key) {\n      var unsubscribe = _this.unsubscribers.get(key);\n\n      unsubscribe && unsubscribe();\n    });\n  };\n\n  return MotionValuesMap;\n}();\n\nvar specialMotionValueProps = new Set([\"dragOriginX\", \"dragOriginY\"]);\n\nvar useMotionValues = function useMotionValues(props) {\n  var motionValues = useConstant(function () {\n    var map = new MotionValuesMap();\n    /**\r\n     * Loop through every prop and add any detected `MotionValue`s. This is SVG-specific\r\n     * code that should be extracted, perhaps considered hollistically with `useMotionStyles`.\r\n     *\r\n     * <motion.circle cx={motionValue(0)} />\r\n     */\n\n    for (var key in props) {\n      if (isMotionValue(props[key]) && !specialMotionValueProps.has(key)) {\n        map.set(key, props[key]);\n      }\n    }\n\n    return map;\n  });\n  motionValues.setOnUpdate(props.onUpdate);\n  motionValues.setTransformTemplate(props.transformTemplate);\n  return motionValues;\n};\n\nvar session = null;\nvar syncRenderSession = {\n  isOpen: function isOpen() {\n    return session !== null;\n  },\n  open: function open() {\n    invariant(!session, \"Sync render session already open\");\n    session = [];\n  },\n  flush: function flush() {\n    invariant(session !== null, \"No sync render session found\");\n    session && session.forEach(function (styler) {\n      return styler.render();\n    });\n    session = null;\n  },\n  push: function push(styler) {\n    invariant(session !== null, \"No sync render session found\");\n    session && session.push(styler);\n  }\n};\n/**\r\n * `useEffect` gets resolved bottom-up. We defer some optional functionality to child\r\n * components, so to ensure everything runs correctly we export the ref-binding logic\r\n * to a new component rather than in `useMotionValues`.\r\n */\n\nvar MountComponent = function MountComponent(_a) {\n  var ref = _a.innerRef,\n      values = _a.values,\n      isStatic = _a.isStatic;\n  useEffect(function () {\n    invariant(ref.current instanceof Element, \"No `ref` found. Ensure components created with `motion.custom` forward refs using `React.forwardRef`\");\n    var domStyler = styler(ref.current, {\n      preparseOutput: false,\n      enableHardwareAcceleration: !isStatic\n    });\n    values.mount(function (key, value) {\n      domStyler.set(key, value);\n\n      if (syncRenderSession.isOpen()) {\n        syncRenderSession.push(domStyler);\n      }\n    });\n    return function () {\n      return values.unmount();\n    };\n  }, []);\n  return null;\n};\n\nvar Mount = memo(MountComponent);\n\nvar createValueResolver = function createValueResolver(resolver) {\n  return function (values) {\n    var resolvedValues = {};\n    values.forEach(function (value, key) {\n      return resolvedValues[key] = resolver(value);\n    });\n    return resolvedValues;\n  };\n};\n\nvar resolveCurrent = createValueResolver(function (value) {\n  return value.get();\n});\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\n\nvar isTransformOriginProp = function isTransformOriginProp(key) {\n  return transformOriginProps.has(key);\n};\n\nvar buildStyleAttr = function buildStyleAttr(values, styleProp, isStatic) {\n  var motionValueStyles = resolveCurrent(values);\n  var transformTemplate = values.getTransformTemplate();\n\n  if (transformTemplate) {\n    // If `transform` has been manually set as a string, pass that through the template\n    // otherwise pass it forward to Stylefire's style property builder\n    motionValueStyles.transform = styleProp.transform ? transformTemplate({}, styleProp.transform) : transformTemplate;\n  }\n\n  return buildStyleProperty(__assign(__assign({}, styleProp), motionValueStyles), !isStatic);\n};\n\nvar useMotionStyles = function useMotionStyles(values, styleProp, isStatic, transformValues) {\n  if (styleProp === void 0) {\n    styleProp = {};\n  }\n\n  var style = {};\n  var prevMotionStyles = useRef({}).current;\n\n  for (var key in styleProp) {\n    var thisStyle = styleProp[key];\n\n    if (isMotionValue(thisStyle)) {\n      // If this is a motion value, add it to our MotionValuesMap\n      values.set(key, thisStyle);\n    } else if (!isStatic && (isTransformProp(key) || isTransformOriginProp(key))) {\n      // Or if it's a transform prop, create a motion value (or update an existing one)\n      // to ensure Stylefire can reconcile all the transform values together.\n      // A further iteration on this would be to create a single styler per component that gets\n      // used in the DOM renderer's buildStyleAttr *and* animations, then we would only\n      // have to convert animating values to `MotionValues` (we could probably remove this entire function).\n      // The only architectural consideration is to allow Stylefire to have elements mounted after\n      // a styler is created.\n      if (!values.has(key)) {\n        // If it doesn't exist as a motion value, create it\n        values.set(key, motionValue(thisStyle));\n      } else {\n        // Otherwise only update it if it's changed from a previous render\n        if (thisStyle !== prevMotionStyles[key]) {\n          var value = values.get(key);\n          value.set(thisStyle);\n        }\n      }\n\n      prevMotionStyles[key] = thisStyle;\n    } else {\n      style[key] = thisStyle;\n    }\n  }\n\n  return transformValues ? transformValues(style) : style;\n};\n\nvar isKeyframesTarget = function isKeyframesTarget(v) {\n  return Array.isArray(v);\n};\n\nvar isCustomValue = function isCustomValue(v) {\n  return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\n\nvar resolveFinalValueInKeyframes = function resolveFinalValueInKeyframes(v) {\n  // TODO maybe throw if v.length - 1 is placeholder token?\n  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nvar auto = {\n  test: function test(v) {\n    return v === \"auto\";\n  },\n  parse: function parse(v) {\n    return v;\n  }\n};\nvar dimensionTypes = [number, px, percent, degrees, vw, vh, auto];\n\nvar valueTypes = __spreadArrays(dimensionTypes, [color, complex]);\n\nvar testValueType = function testValueType(v) {\n  return function (type) {\n    return type.test(v);\n  };\n};\n\nvar getDimensionValueType = function getDimensionValueType(v) {\n  return dimensionTypes.find(testValueType(v));\n};\n\nvar getValueType = function getValueType(v) {\n  return valueTypes.find(testValueType(v));\n};\n\nvar underDampedSpring = function underDampedSpring() {\n  return {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restDelta: 0.5,\n    restSpeed: 10\n  };\n};\n\nvar overDampedSpring = function overDampedSpring(to) {\n  return {\n    type: \"spring\",\n    stiffness: 700,\n    damping: to === 0 ? 100 : 35\n  };\n};\n\nvar linearTween = function linearTween() {\n  return {\n    ease: \"linear\",\n    duration: 0.3\n  };\n};\n\nvar keyframes = function keyframes(values) {\n  return {\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values\n  };\n};\n\nvar defaultTransitions = {\n  x: underDampedSpring,\n  y: underDampedSpring,\n  z: underDampedSpring,\n  rotate: underDampedSpring,\n  rotateX: underDampedSpring,\n  rotateY: underDampedSpring,\n  rotateZ: underDampedSpring,\n  scaleX: overDampedSpring,\n  scaleY: overDampedSpring,\n  scale: overDampedSpring,\n  opacity: linearTween,\n  backgroundColor: linearTween,\n  color: linearTween,\n  default: overDampedSpring\n};\n\nvar getDefaultTransition = function getDefaultTransition(valueKey, to) {\n  var transitionFactory;\n\n  if (isKeyframesTarget(to)) {\n    transitionFactory = keyframes;\n  } else {\n    transitionFactory = defaultTransitions[valueKey] || defaultTransitions.default;\n  }\n\n  return __assign({\n    to: to\n  }, transitionFactory(to));\n};\n/**\r\n * A Popmotion action that accepts a single `to` prop. When it starts, it immediately\r\n * updates with `to` and then completes. By using this we can compose instant transitions\r\n * in with the same logic that applies `delay` or returns a `Promise` etc.\r\n *\r\n * Accepting `duration` is a little bit of a hack that simply defers the completetion of\r\n * the animation until after the duration finishes. This is for situations when you're **only**\r\n * animating non-animatable values and then setting something on `transitionEnd`. Really\r\n * you want this to fire after the \"animation\" finishes, rather than instantly.\r\n *\r\n * ```\r\n * animate={{\r\n *   display: 'block',\r\n *   transitionEnd: { display: 'none' }\r\n * }}\r\n * ```\r\n */\n\n\nvar just = function just(_a) {\n  var to = _a.to,\n      duration = _a.duration;\n  return action(function (_a) {\n    var update = _a.update,\n        complete = _a.complete;\n    update(to);\n    duration ? delay(duration).start({\n      complete: complete\n    }) : complete();\n  });\n};\n\nvar easingDefinitionToFunction = function easingDefinitionToFunction(definition) {\n  if (Array.isArray(definition)) {\n    // If cubic bezier definition, create bezier curve\n    invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n    var x1 = definition[0],\n        y1 = definition[1],\n        x2 = definition[2],\n        y2 = definition[3];\n    return cubicBezier(x1, y1, x2, y2);\n  } else if (typeof definition === \"string\") {\n    // Else lookup from table\n    invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\" + definition + \"'\");\n    return easingLookup[definition];\n  }\n\n  return definition;\n};\n\nvar isEasingArray = function isEasingArray(ease) {\n  return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nvar isDurationAnimation = function isDurationAnimation(v) {\n  return v.hasOwnProperty(\"duration\") || v.hasOwnProperty(\"repeatDelay\");\n};\n/**\r\n * Check if a value is animatable. Examples:\r\n *\r\n * ✅: 100, \"100px\", \"#fff\"\r\n * ❌: \"block\", \"url(2.jpg)\"\r\n * @param value\r\n *\r\n * @internal\r\n */\n\n\nvar isAnimatable = function isAnimatable(key, value) {\n  // If the list of keys tat might be non-animatable grows, replace with Set\n  if (key === \"zIndex\") return false; // If it's a number or a keyframes array, we can animate it. We might at some point\n  // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n  // but for now lets leave it like this for performance reasons\n\n  if (typeof value === \"number\" || Array.isArray(value)) return true;\n\n  if (typeof value === \"string\" && // It's animatable if we have a string\n  complex.test(value) && // And it contains numbers and/or colors\n  !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n  ) {\n    return true;\n  }\n\n  return false;\n};\n/**\r\n * Converts seconds to milliseconds\r\n *\r\n * @param seconds - Time in seconds.\r\n * @return milliseconds - Converted time in milliseconds.\r\n */\n\n\nvar secondsToMilliseconds = function secondsToMilliseconds(seconds) {\n  return seconds * 1000;\n};\n\nvar transitions = {\n  tween: tween,\n  spring: spring,\n  keyframes: keyframes$1,\n  inertia: inertia,\n  just: just\n};\nvar transitionOptionParser = {\n  tween: function tween(opts) {\n    if (opts.ease) {\n      var ease = isEasingArray(opts.ease) ? opts.ease[0] : opts.ease;\n      opts.ease = easingDefinitionToFunction(ease);\n    }\n\n    return opts;\n  },\n  keyframes: function keyframes(_a) {\n    var from = _a.from,\n        to = _a.to,\n        velocity = _a.velocity,\n        opts = __rest(_a, [\"from\", \"to\", \"velocity\"]);\n\n    if (opts.values && opts.values[0] === null) {\n      var values = __spreadArrays(opts.values);\n\n      values[0] = from;\n      opts.values = values;\n    }\n\n    if (opts.ease) {\n      opts.easings = isEasingArray(opts.ease) ? opts.ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(opts.ease);\n    }\n\n    opts.ease = linear;\n    return opts;\n  }\n};\n\nvar isTransitionDefined = function isTransitionDefined(_a) {\n  var when = _a.when,\n      delay = _a.delay,\n      delayChildren = _a.delayChildren,\n      staggerChildren = _a.staggerChildren,\n      staggerDirection = _a.staggerDirection,\n      transition = __rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\"]);\n\n  return Object.keys(transition).length;\n};\n\nvar getTransitionDefinition = function getTransitionDefinition(key, to, transitionDefinition) {\n  var delay = transitionDefinition ? transitionDefinition.delay : 0; // If no object, return default transition\n  // A better way to handle this would be to deconstruct out all the shared Orchestration props\n  // and see if there's any props remaining\n\n  if (transitionDefinition === undefined || !isTransitionDefined(transitionDefinition)) {\n    return __assign({\n      delay: delay\n    }, getDefaultTransition(key, to));\n  }\n\n  var valueTransitionDefinition = transitionDefinition[key] || transitionDefinition.default || transitionDefinition;\n\n  if (valueTransitionDefinition.type === false) {\n    return {\n      delay: valueTransitionDefinition.hasOwnProperty(\"delay\") ? valueTransitionDefinition.delay : delay,\n      to: isKeyframesTarget(to) ? to[to.length - 1] : to,\n      type: \"just\"\n    };\n  } else if (isKeyframesTarget(to)) {\n    return __assign(__assign({\n      values: to,\n      duration: 0.8,\n      delay: delay,\n      ease: \"linear\"\n    }, valueTransitionDefinition), {\n      // This animation must be keyframes if we're animating through an array\n      type: \"keyframes\"\n    });\n  } else {\n    return __assign({\n      type: \"tween\",\n      to: to,\n      delay: delay\n    }, valueTransitionDefinition);\n  }\n};\n\nvar preprocessOptions = function preprocessOptions(type, opts) {\n  return transitionOptionParser[type] ? transitionOptionParser[type](opts) : opts;\n};\n\nvar getAnimation = function getAnimation(key, value, target, transition) {\n  var origin = value.get();\n  var isOriginAnimatable = isAnimatable(key, origin);\n  var isTargetAnimatable = isAnimatable(key, target); // TODO we could probably improve this check to ensure both values are of the same type -\n  // for instance 100 to #fff. This might live better in Popmotion.\n\n  warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \" + key + \" from \\\"\" + origin + \"\\\" to \" + target + \". \\\"\" + origin + \"\\\" is not an animatable value - to enable this animation set \" + origin + \" to a value animatable to \" + target + \" via the `style` property.\"); // Parse the `transition` prop and return options for the Popmotion animation\n\n  var _a = getTransitionDefinition(key, target, transition),\n      _b = _a.type,\n      type = _b === void 0 ? \"tween\" : _b,\n      transitionDefinition = __rest(_a, [\"type\"]); // If this is an animatable pair of values, return an animation, otherwise use `just`\n\n\n  var actionFactory = isOriginAnimatable && isTargetAnimatable ? transitions[type] : just;\n  var opts = preprocessOptions(type, __assign({\n    from: origin,\n    velocity: value.getVelocity()\n  }, transitionDefinition)); // Convert duration from Framer Motion's seconds into Popmotion's milliseconds\n\n  if (isDurationAnimation(opts)) {\n    if (opts.duration) {\n      opts.duration = secondsToMilliseconds(opts.duration);\n    }\n\n    if (opts.repeatDelay) {\n      opts.repeatDelay = secondsToMilliseconds(opts.repeatDelay);\n    }\n  }\n\n  return [actionFactory, opts];\n};\n/**\r\n * Start animation on a value. This function completely encapsulates Popmotion-specific logic.\r\n *\r\n * @internal\r\n */\n\n\nfunction startAnimation(key, value, target, _a) {\n  var _b = _a.delay,\n      delay$1 = _b === void 0 ? 0 : _b,\n      transition = __rest(_a, [\"delay\"]);\n\n  return value.start(function (complete) {\n    var activeAnimation;\n\n    var _a = getAnimation(key, value, target, transition),\n        animationFactory = _a[0],\n        _b = _a[1],\n        valueDelay = _b.delay,\n        options = __rest(_b, [\"delay\"]);\n\n    if (valueDelay !== undefined) {\n      delay$1 = valueDelay;\n    }\n\n    var animate = function animate() {\n      var animation = animationFactory(options); // Bind animation opts to animation\n\n      activeAnimation = animation.start({\n        update: function update(v) {\n          return value.set(v);\n        },\n        complete: complete\n      });\n    }; // If we're delaying this animation, only resolve it **after** the delay to\n    // ensure the value's resolve velocity is up-to-date.\n\n\n    if (delay$1) {\n      activeAnimation = delay(secondsToMilliseconds(delay$1)).start({\n        complete: animate\n      });\n    } else {\n      animate();\n    }\n\n    return function () {\n      if (activeAnimation) activeAnimation.stop();\n    };\n  });\n}\n/**\r\n * Get the current value of every `MotionValue`\r\n * @param values -\r\n */\n\n\nvar getCurrent = function getCurrent(values) {\n  var current = {};\n  values.forEach(function (value, key) {\n    return current[key] = value.get();\n  });\n  return current;\n};\n/**\r\n * Get the current velocity of every `MotionValue`\r\n * @param values -\r\n */\n\n\nvar getVelocity = function getVelocity(values) {\n  var velocity = {};\n  values.forEach(function (value, key) {\n    return velocity[key] = value.getVelocity();\n  });\n  return velocity;\n};\n/**\r\n * Check if value is a function that returns a `Target`. A generic typeof === 'function'\r\n * check, just helps with typing.\r\n * @param p -\r\n */\n\n\nvar isTargetResolver = function isTargetResolver(p) {\n  return typeof p === \"function\";\n};\n/**\r\n * Check if value is a list of variant labels\r\n * @param v -\r\n */\n\n\nvar isVariantLabels = function isVariantLabels(v) {\n  return Array.isArray(v);\n};\n/**\r\n * Check if value is a numerical string, ie \"100\" or \"100px\"\r\n */\n\n\nvar isNumericalString = function isNumericalString(v) {\n  return /^\\d*\\.?\\d+$/.test(v);\n};\n/**\r\n * Control animations for a single component\r\n *\r\n * @internal\r\n */\n\n\nvar ValueAnimationControls = function () {\n  function ValueAnimationControls(_a) {\n    var _this = this;\n\n    var values = _a.values,\n        readValueFromSource = _a.readValueFromSource,\n        makeTargetAnimatable = _a.makeTargetAnimatable;\n    /**\r\n     * A reference to the component's latest props. We could probably ditch this in\r\n     * favour to a reference to the `custom` prop now we don't send all props through\r\n     * to target resolvers.\r\n     */\n\n    this.props = {};\n    /**\r\n     * The component's variants, as provided by `variants`\r\n     */\n\n    this.variants = {};\n    /**\r\n     * A set of values that we animate back to when a value is cleared of all overrides.\r\n     */\n\n    this.baseTarget = {};\n    /**\r\n     * A series of target overrides that we can animate to/from when overrides are set/cleared.\r\n     */\n\n    this.overrides = [];\n    /**\r\n     * A series of target overrides as they were originally resolved.\r\n     */\n\n    this.resolvedOverrides = [];\n    /**\r\n     * A Set of currently active override indexes\r\n     */\n\n    this.activeOverrides = new Set();\n    /**\r\n     * A Set of value keys that are currently animating.\r\n     */\n\n    this.isAnimating = new Set();\n    /**\r\n     * Check if the associated `MotionValueMap` has a key with the provided string.\r\n     * Pre-bound to the class so we can provide directly to the `filter` in `checkForNewValues`.\r\n     */\n\n    this.hasValue = function (key) {\n      return !_this.values.has(key);\n    };\n\n    this.values = values;\n    this.readValueFromSource = readValueFromSource;\n    this.makeTargetAnimatable = makeTargetAnimatable;\n    this.values.forEach(function (value, key) {\n      return _this.baseTarget[key] = value.get();\n    });\n  }\n  /**\r\n   * Set the reference to the component's props.\r\n   * @param props -\r\n   */\n\n\n  ValueAnimationControls.prototype.setProps = function (props) {\n    this.props = props;\n  };\n  /**\r\n   * Set the reference to the component's variants\r\n   * @param variants -\r\n   */\n\n\n  ValueAnimationControls.prototype.setVariants = function (variants) {\n    if (variants) this.variants = variants;\n  };\n  /**\r\n   * Set the component's default transition\r\n   * @param transition -\r\n   */\n\n\n  ValueAnimationControls.prototype.setDefaultTransition = function (transition) {\n    if (transition) this.defaultTransition = transition;\n  };\n  /**\r\n   * Set motion values without animation.\r\n   *\r\n   * @param definition -\r\n   * @param isActive -\r\n   */\n\n\n  ValueAnimationControls.prototype.setValues = function (definition, _a) {\n    var _this = this;\n\n    var _b = _a === void 0 ? {} : _a,\n        _c = _b.isActive,\n        isActive = _c === void 0 ? new Set() : _c,\n        priority = _b.priority;\n\n    var _d = this.resolveVariant(definition),\n        target = _d.target,\n        transitionEnd = _d.transitionEnd;\n\n    target = this.transformValues(__assign(__assign({}, target), transitionEnd));\n    return Object.keys(target).forEach(function (key) {\n      if (isActive.has(key)) return;\n      isActive.add(key);\n\n      if (target) {\n        var targetValue = resolveFinalValueInKeyframes(target[key]);\n\n        if (_this.values.has(key)) {\n          var value = _this.values.get(key);\n\n          value && value.set(targetValue);\n        } else {\n          _this.values.set(key, motionValue(targetValue));\n        }\n\n        if (!priority) _this.baseTarget[key] = targetValue;\n      }\n    });\n  };\n  /**\r\n   * Allows `transformValues` to be set by a component that allows us to\r\n   * transform the values in a given `Target`. This allows Framer Library\r\n   * to extend Framer Motion to animate `Color` variables etc. Currently we have\r\n   * to manually support these extended types here in Framer Motion.\r\n   *\r\n   * @param values -\r\n   */\n\n\n  ValueAnimationControls.prototype.transformValues = function (values) {\n    var transformValues = this.props.transformValues;\n    return transformValues ? transformValues(values) : values;\n  };\n  /**\r\n   * Check a `Target` for new values we haven't animated yet, and add them\r\n   * to the `MotionValueMap`.\r\n   *\r\n   * Currently there's functionality here that is DOM-specific, we should allow\r\n   * this functionality to be injected by the factory that creates DOM-specific\r\n   * components.\r\n   *\r\n   * @param target -\r\n   */\n\n\n  ValueAnimationControls.prototype.checkForNewValues = function (target) {\n    var newValueKeys = Object.keys(target).filter(this.hasValue);\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues) return;\n\n    for (var i = 0; i < numNewValues; i++) {\n      var key = newValueKeys[i];\n      var targetValue = target[key];\n      var value = null; // If this is a keyframes value, we can attempt to use the first value in the\n      // array as that's going to be the first value of the animation anyway\n\n      if (Array.isArray(targetValue)) {\n        value = targetValue[0];\n      } // If it isn't a keyframes or the first keyframes value was set as `null`, read the\n      // value from the DOM. It might be worth investigating whether to check props (for SVG)\n      // or props.style (for HTML) if the value exists there before attempting to read.\n\n\n      if (value === null) {\n        value = this.readValueFromSource(key);\n        invariant(value !== null, \"No initial value for \\\"\" + key + \"\\\" can be inferred. Ensure an initial value for \\\"\" + key + \"\\\" is defined on the component.\");\n      }\n\n      if (typeof value === \"string\" && isNumericalString(value)) {\n        // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n        value = parseFloat(value);\n      } else if (!getValueType(value) && complex.test(targetValue)) {\n        // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n        value = complex.getAnimatableNone(targetValue);\n      }\n\n      this.values.set(key, motionValue(value));\n      this.baseTarget[key] = value;\n    }\n  };\n  /**\r\n   * Resolve a variant from its label or resolver into an actual `Target` we can animate to.\r\n   * @param variant -\r\n   */\n\n\n  ValueAnimationControls.prototype.resolveVariant = function (variant) {\n    if (!variant) {\n      return {\n        target: undefined,\n        transition: undefined,\n        transitionEnd: undefined\n      };\n    }\n\n    if (isTargetResolver(variant)) {\n      // resolve current and velocity\n      variant = variant(this.props.custom, getCurrent(this.values), getVelocity(this.values));\n    }\n\n    var _a = variant.transition,\n        transition = _a === void 0 ? this.defaultTransition : _a,\n        transitionEnd = variant.transitionEnd,\n        target = __rest(variant, [\"transition\", \"transitionEnd\"]);\n\n    return {\n      transition: transition,\n      transitionEnd: transitionEnd,\n      target: target\n    };\n  };\n  /**\r\n   * Get the highest active override priority index\r\n   */\n\n\n  ValueAnimationControls.prototype.getHighestPriority = function () {\n    if (!this.activeOverrides.size) return 0;\n    return Math.max.apply(Math, Array.from(this.activeOverrides));\n  };\n  /**\r\n   * Set an override. We add this layer of indirection so if, for instance, a tap gesture\r\n   * starts and overrides a hover gesture, when we clear the tap gesture and fallback to the\r\n   * hover gesture, if that hover gesture has changed in the meantime we can go to that rather\r\n   * than the one that was resolved when the hover gesture animation started.\r\n   *\r\n   * @param definition -\r\n   * @param overrideIndex -\r\n   */\n\n\n  ValueAnimationControls.prototype.setOverride = function (definition, overrideIndex) {\n    this.overrides[overrideIndex] = definition;\n\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.setOverride(definition, overrideIndex);\n      });\n    }\n  };\n  /**\r\n   * Start an override animation.\r\n   * @param overrideIndex -\r\n   */\n\n\n  ValueAnimationControls.prototype.startOverride = function (overrideIndex) {\n    var override = this.overrides[overrideIndex];\n\n    if (override) {\n      return this.start(override, {\n        priority: overrideIndex\n      });\n    }\n  };\n  /**\r\n   * Clear an override. We check every value we animated to in this override to see if\r\n   * its present on any lower-priority overrides. If not, we animate it back to its base target.\r\n   * @param overrideIndex -\r\n   */\n\n\n  ValueAnimationControls.prototype.clearOverride = function (overrideIndex) {\n    var _this = this;\n\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.clearOverride(overrideIndex);\n      });\n    }\n\n    var override = this.overrides[overrideIndex];\n    if (!override) return;\n    this.activeOverrides.delete(overrideIndex);\n    var highest = this.getHighestPriority();\n    this.resetIsAnimating();\n\n    if (highest) {\n      var highestOverride = this.overrides[highest];\n      highestOverride && this.startOverride(highest);\n    } // Figure out which remaining values were affected by the override and animate those\n\n\n    var overrideTarget = this.resolvedOverrides[overrideIndex];\n    if (!overrideTarget) return;\n    var remainingValues = {};\n\n    for (var key in this.baseTarget) {\n      if (overrideTarget[key] !== undefined) {\n        remainingValues[key] = this.baseTarget[key];\n      }\n    }\n\n    this.onStart();\n    this.animate(remainingValues).then(function () {\n      return _this.onComplete();\n    });\n  };\n  /**\r\n   * Apply a target/variant without any animation\r\n   */\n\n\n  ValueAnimationControls.prototype.apply = function (definition) {\n    if (Array.isArray(definition)) {\n      return this.applyVariantLabels(definition);\n    } else if (typeof definition === \"string\") {\n      return this.applyVariantLabels([definition]);\n    } else {\n      this.setValues(definition);\n    }\n  };\n  /**\r\n   * Apply variant labels without animation\r\n   */\n\n\n  ValueAnimationControls.prototype.applyVariantLabels = function (variantLabelList) {\n    var _this = this;\n\n    var isActive = new Set();\n\n    var reversedList = __spreadArrays(variantLabelList).reverse();\n\n    reversedList.forEach(function (key) {\n      var _a = _this.resolveVariant(_this.variants[key]),\n          target = _a.target,\n          transitionEnd = _a.transitionEnd;\n\n      if (transitionEnd) {\n        _this.setValues(transitionEnd, {\n          isActive: isActive\n        });\n      }\n\n      if (target) {\n        _this.setValues(target, {\n          isActive: isActive\n        });\n      }\n\n      if (_this.children && _this.children.size) {\n        _this.children.forEach(function (child) {\n          return child.applyVariantLabels(variantLabelList);\n        });\n      }\n    });\n  };\n\n  ValueAnimationControls.prototype.start = function (definition, opts) {\n    var _this = this;\n\n    if (opts === void 0) {\n      opts = {};\n    }\n\n    if (opts.priority) {\n      this.activeOverrides.add(opts.priority);\n    }\n\n    this.resetIsAnimating(opts.priority);\n    var animation;\n\n    if (isVariantLabels(definition)) {\n      animation = this.animateVariantLabels(definition, opts);\n    } else if (typeof definition === \"string\") {\n      animation = this.animateVariant(definition, opts);\n    } else {\n      animation = this.animate(definition, opts);\n    }\n\n    this.onStart();\n    return animation.then(function () {\n      return _this.onComplete();\n    });\n  };\n\n  ValueAnimationControls.prototype.animate = function (animationDefinition, _a) {\n    var _this = this;\n\n    var _b = _a === void 0 ? {} : _a,\n        _c = _b.delay,\n        delay = _c === void 0 ? 0 : _c,\n        _d = _b.priority,\n        priority = _d === void 0 ? 0 : _d,\n        transitionOverride = _b.transitionOverride;\n\n    var _e = this.resolveVariant(animationDefinition),\n        target = _e.target,\n        transition = _e.transition,\n        transitionEnd = _e.transitionEnd;\n\n    if (transitionOverride) {\n      transition = transitionOverride;\n    }\n\n    if (!target) return Promise.resolve();\n    target = this.transformValues(target);\n\n    if (transitionEnd) {\n      transitionEnd = this.transformValues(transitionEnd);\n    }\n\n    this.checkForNewValues(target);\n\n    if (this.makeTargetAnimatable) {\n      var animatable = this.makeTargetAnimatable(target, transitionEnd);\n      target = animatable.target;\n      transitionEnd = animatable.transitionEnd;\n    }\n\n    if (priority) {\n      this.resolvedOverrides[priority] = target;\n    }\n\n    this.checkForNewValues(target);\n    var animations = [];\n\n    for (var key in target) {\n      var value = this.values.get(key);\n      if (!value || !target || target[key] === undefined) continue;\n      var valueTarget = target[key];\n\n      if (!priority) {\n        this.baseTarget[key] = resolveFinalValueInKeyframes(valueTarget);\n      }\n\n      if (this.isAnimating.has(key)) continue;\n      this.isAnimating.add(key);\n      animations.push(startAnimation(key, value, valueTarget, __assign({\n        delay: delay\n      }, transition)));\n    }\n\n    var allAnimations = Promise.all(animations);\n    return transitionEnd ? allAnimations.then(function () {\n      _this.setValues(transitionEnd, {\n        priority: priority\n      });\n    }) : allAnimations;\n  };\n\n  ValueAnimationControls.prototype.animateVariantLabels = function (variantLabels, opts) {\n    var _this = this;\n\n    var animations = __spreadArrays(variantLabels).reverse().map(function (label) {\n      return _this.animateVariant(label, opts);\n    });\n\n    return Promise.all(animations);\n  };\n\n  ValueAnimationControls.prototype.animateVariant = function (variantLabel, opts) {\n    var _this = this;\n\n    var when = false;\n    var delayChildren = 0;\n    var staggerChildren = 0;\n    var staggerDirection = 1;\n    var priority = opts && opts.priority || 0;\n    var variant = this.variants[variantLabel];\n    var getAnimations = variant ? function () {\n      return _this.animate(variant, opts);\n    } : function () {\n      return Promise.resolve();\n    };\n    var getChildrenAnimations = this.children ? function () {\n      return _this.animateChildren(variantLabel, delayChildren, staggerChildren, staggerDirection, priority);\n    } : function () {\n      return Promise.resolve();\n    };\n\n    if (variant && this.children) {\n      var transition = this.resolveVariant(variant).transition;\n\n      if (transition) {\n        when = transition.when || when;\n        delayChildren = transition.delayChildren || delayChildren;\n        staggerChildren = transition.staggerChildren || staggerChildren;\n        staggerDirection = transition.staggerDirection || staggerDirection;\n      }\n    }\n\n    if (when) {\n      var _a = when === \"beforeChildren\" ? [getAnimations, getChildrenAnimations] : [getChildrenAnimations, getAnimations],\n          first = _a[0],\n          last = _a[1];\n\n      return first().then(last);\n    } else {\n      return Promise.all([getAnimations(), getChildrenAnimations()]);\n    }\n  };\n\n  ValueAnimationControls.prototype.animateChildren = function (variantLabel, delayChildren, staggerChildren, staggerDirection, priority) {\n    if (delayChildren === void 0) {\n      delayChildren = 0;\n    }\n\n    if (staggerChildren === void 0) {\n      staggerChildren = 0;\n    }\n\n    if (staggerDirection === void 0) {\n      staggerDirection = 1;\n    }\n\n    if (priority === void 0) {\n      priority = 0;\n    }\n\n    if (!this.children) {\n      return Promise.resolve();\n    }\n\n    var animations = [];\n    var maxStaggerDuration = (this.children.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1 ? function (i) {\n      return i * staggerChildren;\n    } : function (i) {\n      return maxStaggerDuration - i * staggerChildren;\n    };\n    Array.from(this.children).forEach(function (childControls, i) {\n      var animation = childControls.animateVariant(variantLabel, {\n        priority: priority,\n        delay: delayChildren + generateStaggerDuration(i)\n      });\n      animations.push(animation);\n    });\n    return Promise.all(animations);\n  };\n\n  ValueAnimationControls.prototype.onStart = function () {\n    var onAnimationStart = this.props.onAnimationStart;\n    onAnimationStart && onAnimationStart();\n  };\n\n  ValueAnimationControls.prototype.onComplete = function () {\n    var onAnimationComplete = this.props.onAnimationComplete;\n    onAnimationComplete && onAnimationComplete();\n  };\n\n  ValueAnimationControls.prototype.checkOverrideIsAnimating = function (priority) {\n    var numOverrides = this.overrides.length;\n\n    for (var i = priority + 1; i < numOverrides; i++) {\n      var resolvedOverride = this.resolvedOverrides[i];\n\n      if (resolvedOverride) {\n        for (var key in resolvedOverride) {\n          this.isAnimating.add(key);\n        }\n      }\n    }\n  };\n\n  ValueAnimationControls.prototype.resetIsAnimating = function (priority) {\n    if (priority === void 0) {\n      priority = 0;\n    }\n\n    this.isAnimating.clear(); // If this isn't the highest priority gesture, block the animation\n    // of anything that's currently being animated\n\n    if (priority < this.getHighestPriority()) {\n      this.checkOverrideIsAnimating(priority);\n    }\n\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.resetIsAnimating(priority);\n      });\n    }\n  };\n\n  ValueAnimationControls.prototype.stop = function () {\n    this.values.forEach(function (value) {\n      return value.stop();\n    });\n  };\n  /**\r\n   * Add the controls of a child component.\r\n   * @param controls -\r\n   */\n\n\n  ValueAnimationControls.prototype.addChild = function (controls) {\n    if (!this.children) {\n      this.children = new Set();\n    }\n\n    this.children.add(controls); // We set child overrides when `setOverride` is called, but also have to do it here\n    // as the first time `setOverride` is called all the children might not have been added yet.\n\n    this.overrides.forEach(function (override, i) {\n      override && controls.setOverride(override, i);\n    });\n  };\n\n  ValueAnimationControls.prototype.removeChild = function (controls) {\n    if (!this.children) {\n      return;\n    }\n\n    this.children.delete(controls);\n  };\n\n  ValueAnimationControls.prototype.resetChildren = function () {\n    if (this.children) this.children.clear();\n  };\n\n  return ValueAnimationControls;\n}();\n/**\r\n * Use callback either only on the initial render or on all renders. In concurrent mode\r\n * the \"initial\" render might run multiple times\r\n *\r\n * @param callback - Callback to run\r\n * @param isInitialOnly - Set to `true` to only run on initial render, or `false` for all renders. Defaults to `false`.\r\n *\r\n * @public\r\n */\n\n\nfunction useInitialOrEveryRender(callback, isInitialOnly) {\n  if (isInitialOnly === void 0) {\n    isInitialOnly = false;\n  }\n\n  var isInitialRender = useRef(true);\n\n  if (!isInitialOnly || isInitialOnly && isInitialRender.current) {\n    callback();\n  }\n\n  isInitialRender.current = false;\n}\n/**\r\n * Control animations on one or more components.\r\n *\r\n * @public\r\n */\n\n\nvar AnimationControls = function () {\n  function AnimationControls() {\n    /**\r\n     * Track whether the host component has mounted.\r\n     *\r\n     * @internal\r\n     */\n    this.hasMounted = false;\n    /**\r\n     * Pending animations that are started before a component is mounted.\r\n     *\r\n     * @internal\r\n     */\n\n    this.pendingAnimations = [];\n    /**\r\n     * A collection of linked component animation controls.\r\n     *\r\n     * @internal\r\n     */\n\n    this.componentControls = new Set();\n  }\n  /**\r\n   * Set variants on this and all child components.\r\n   *\r\n   * @param variants - The variants to set\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.setVariants = function (variants) {\n    this.variants = variants;\n    this.componentControls.forEach(function (controls) {\n      return controls.setVariants(variants);\n    });\n  };\n  /**\r\n   * Set a default transition on this and all child components\r\n   *\r\n   * @param transition - The default transition to set\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.setDefaultTransition = function (transition) {\n    this.defaultTransition = transition;\n    this.componentControls.forEach(function (controls) {\n      return controls.setDefaultTransition(transition);\n    });\n  };\n  /**\r\n   * Subscribes a component's animation controls to this.\r\n   *\r\n   * @param controls - The controls to subscribe\r\n   * @returns An unsubscribe function.\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.subscribe = function (controls) {\n    var _this = this;\n\n    this.componentControls.add(controls);\n    if (this.variants) controls.setVariants(this.variants);\n    if (this.defaultTransition) controls.setDefaultTransition(this.defaultTransition);\n    return function () {\n      return _this.componentControls.delete(controls);\n    };\n  };\n  /**\r\n   * Starts an animation on all linked components.\r\n   *\r\n   * @remarks\r\n   *\r\n   * ```jsx\r\n   * controls.start(\"variantLabel\")\r\n   * controls.start({\r\n   *   x: 0,\r\n   *   transition: { duration: 1 }\r\n   * })\r\n   * ```\r\n   *\r\n   * @param definition - Properties or variant label to animate to\r\n   * @param transition - Optional `transtion` to apply to a variant\r\n   * @returns - A `Promise` that resolves when all animations have completed.\r\n   *\r\n   * @public\r\n   */\n\n\n  AnimationControls.prototype.start = function (definition, transitionOverride) {\n    var _this = this;\n\n    if (this.hasMounted) {\n      var animations_1 = [];\n      this.componentControls.forEach(function (controls) {\n        var animation = controls.start(definition, {\n          transitionOverride: transitionOverride\n        });\n        animations_1.push(animation);\n      });\n      return Promise.all(animations_1);\n    } else {\n      return new Promise(function (resolve) {\n        _this.pendingAnimations.push({\n          animation: [definition, transitionOverride],\n          resolve: resolve\n        });\n      });\n    }\n  };\n  /**\r\n   * Instantly set to a set of properties or a variant.\r\n   *\r\n   * ```jsx\r\n   * // With properties\r\n   * controls.set({ opacity: 0 })\r\n   *\r\n   * // With variants\r\n   * controls.set(\"hidden\")\r\n   * ```\r\n   *\r\n   * @internalremarks\r\n   * We could perform a similar trick to `.start` where this can be called before mount\r\n   * and we maintain a list of of pending actions that get applied on mount. But the\r\n   * expectation of `set` is that it happens synchronously and this would be difficult\r\n   * to do before any children have even attached themselves. It's also poor practise\r\n   * and we should discourage render-synchronous `.start` calls rather than lean into this.\r\n   *\r\n   * @public\r\n   */\n\n\n  AnimationControls.prototype.set = function (definition) {\n    invariant(this.hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n    return this.componentControls.forEach(function (controls) {\n      return controls.apply(definition);\n    });\n  };\n  /**\r\n   * Stops animations on all linked components.\r\n   *\r\n   * ```jsx\r\n   * controls.stop()\r\n   * ```\r\n   *\r\n   * @public\r\n   */\n\n\n  AnimationControls.prototype.stop = function () {\n    this.componentControls.forEach(function (controls) {\n      return controls.stop();\n    });\n  };\n  /**\r\n   * Initialises the animation controls.\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.mount = function () {\n    var _this = this;\n\n    this.hasMounted = true;\n    this.pendingAnimations.forEach(function (_a) {\n      var animation = _a.animation,\n          resolve = _a.resolve;\n      return _this.start.apply(_this, animation).then(resolve);\n    });\n  };\n  /**\r\n   * Stops all child animations when the host component unmounts.\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.unmount = function () {\n    this.hasMounted = false;\n    this.stop();\n  };\n\n  return AnimationControls;\n}();\n/**\r\n * @internal\r\n */\n\n\nvar animationControls = function animationControls() {\n  return new AnimationControls();\n};\n/**\r\n * @internal\r\n */\n\n\nvar MotionContext = createContext({\n  static: false\n});\n\nvar isVariantLabel = function isVariantLabel(v) {\n  return typeof v === \"string\" || Array.isArray(v);\n};\n\nvar isAnimationControls = function isAnimationControls(v) {\n  return v instanceof AnimationControls;\n};\n/**\r\n * Set up the context for children motion components.\r\n *\r\n * We also use this opportunity to apply `initial` values\r\n */\n\n\nvar useMotionContext = function useMotionContext(parentContext, controls, values, isStatic, _a) {\n  if (isStatic === void 0) {\n    isStatic = false;\n  }\n\n  var initial = _a.initial,\n      animate = _a.animate,\n      variants = _a.variants,\n      whileTap = _a.whileTap,\n      whileHover = _a.whileHover; // Override initial with that from a parent context, if defined\n\n  if (parentContext.exitProps && parentContext.exitProps.initial !== undefined) {\n    initial = parentContext.exitProps.initial;\n  }\n\n  var initialState;\n\n  if (initial === false && !isAnimationControls(animate)) {\n    initialState = animate;\n  } else if (typeof initial !== \"boolean\") {\n    initialState = initial;\n  } // Track mounted status so children can detect whether they were present during their\n  // parent's first render\n\n\n  var hasMounted = useRef(false); // We propagate this component's ValueAnimationControls *if* we're being provided variants,\n  // if we're being used to control variants, or if we're being passed animation controls.\n  // Otherwise this component should be \"invisible\" to variant propagation. This is a slight concession\n  // to Framer X where every `Frame` is a `motion` component and it might be if we change that in the future\n  // that this restriction is removed.\n\n  var shouldPropagateControls = variants || isVariantLabel(animate) || isVariantLabel(whileTap) || isVariantLabel(whileHover) || isAnimationControls(animate); // If this component's `initial` prop is a variant label, propagate it. Otherwise pass the parent's.\n\n  var targetInitial = isVariantLabel(initialState) ? initialState : parentContext.initial; // If this is a variant tree we need to propagate the `animate` prop in case new children are added after\n  // the tree initially animates.\n\n  var targetAnimate = isVariantLabel(animate) ? animate : parentContext.animate; // Only allow `initial` to trigger context re-renders if this is a `static` component (ie we're on the Framer canvas)\n  // or in another non-animation/interaction environment.\n\n  var initialDependency = isStatic ? targetInitial : null; // Only allow `animate` to trigger context re-renders if it's a variant label. If this is an array of\n  // variant labels there's probably an optimisation to deep-compare but it might be an over-optimisation.\n  // We want to do this as we rely on React's component rendering order each render cycle to determine\n  // the new order of any child components for the `staggerChildren` functionality.\n\n  var animateDependency = shouldPropagateControls && isVariantLabel(targetAnimate) ? targetAnimate : null; // The context to provide to the child. We `useMemo` because although `controls` and `initial` are\n  // unlikely to change, by making the context an object it'll be considered a new value every render.\n  // So all child motion components will re-render as a result.\n\n  var context = useMemo(function () {\n    return {\n      controls: shouldPropagateControls ? controls : parentContext.controls,\n      initial: targetInitial,\n      animate: targetAnimate,\n      values: values,\n      hasMounted: hasMounted,\n      isReducedMotion: parentContext.isReducedMotion\n    };\n  }, [initialDependency, animateDependency, parentContext.isReducedMotion]); // Update the `static` property every render. This is unlikely to change but also essentially free.\n\n  context.static = isStatic; // Set initial state. If this is a static component (ie in Framer canvas), respond to updates\n  // in `initial`.\n\n  useInitialOrEveryRender(function () {\n    var initialToApply = initialState || parentContext.initial;\n    initialToApply && controls.apply(initialToApply);\n  }, !isStatic);\n  useEffect(function () {\n    hasMounted.current = true;\n  }, []);\n  return context;\n};\n/**\r\n * Creates an imperative set of controls to trigger animations.\r\n *\r\n * This allows a consolidated, uniform API for animations, to be triggered by other APIs like the `animate` prop, or the gesture handlers.\r\n *\r\n * @param values\r\n * @param props\r\n * @param ref\r\n * @param subscribeToParentControls\r\n *\r\n * @internal\r\n */\n\n\nfunction useValueAnimationControls(config, props, subscribeToParentControls, parentContext) {\n  var variants = props.variants,\n      transition = props.transition;\n  var parentControls = useContext(MotionContext).controls;\n  var controls = useConstant(function () {\n    return new ValueAnimationControls(config);\n  }); // Reset and resubscribe children every render to ensure stagger order is correct\n\n  if (!parentContext || !parentContext.exitProps || !parentContext.exitProps.isExiting) {\n    controls.resetChildren();\n    controls.setProps(props);\n    controls.setVariants(variants);\n    controls.setDefaultTransition(transition);\n  } // We have to subscribe to the parent controls within a useEffect rather than during render,\n  // as\n\n\n  useEffect(function () {\n    if (subscribeToParentControls && parentControls) {\n      parentControls.addChild(controls);\n    }\n  });\n  useEffect(function () {\n    return function () {\n      // Remove reference to onAnimationComplete from controls. All the MotionValues\n      // are unsubscribed from this component separately. We let animations run out\n      // as they might be animating other components.\n      var onAnimationComplete = props.onAnimationComplete,\n          unmountProps = __rest(props, [\"onAnimationComplete\"]);\n\n      controls.setProps(unmountProps);\n      parentControls && parentControls.removeChild(controls);\n    };\n  }, []);\n  return controls;\n}\n\nvar checkShouldInheritVariant = function checkShouldInheritVariant(_a) {\n  var animate = _a.animate,\n      variants = _a.variants,\n      _b = _a.inherit,\n      inherit = _b === void 0 ? true : _b;\n  return inherit && !!variants && (!animate || animate instanceof AnimationControls);\n};\n/**\r\n * Uses the ref that is passed in, or creates a new one\r\n * @param external - External ref\r\n * @internal\r\n */\n\n\nfunction useExternalRef(externalRef) {\n  // We're conditionally calling `useRef` here which is sort of naughty as hooks\n  // shouldn't be called conditionally. However, Framer Motion will break if this\n  // condition changes anyway. It might be possible to use an invariant here to\n  // make it explicit, but I expect changing `ref` is not normal behaviour.\n  var ref = !externalRef || typeof externalRef === \"function\" ? useRef(null) : externalRef; // Handle `ref` functions. Again, calling the hook conditionally is kind of naughty\n  // but `ref` types changing between renders would break Motion anyway. If we receive\n  // bug reports about this, we should track the provided ref and throw an invariant\n  // rather than move the conditional to inside the useEffect as this will be fired\n  // for every Frame component within Framer.\n\n  if (externalRef && typeof externalRef === \"function\") {\n    useEffect(function () {\n      externalRef(ref.current);\n      return function () {\n        return externalRef(null);\n      };\n    }, []);\n  }\n\n  return ref;\n}\n/**\r\n * @internal\r\n */\n\n\nvar createMotionComponent = function createMotionComponent(_a) {\n  var getValueControlsConfig = _a.getValueControlsConfig,\n      loadFunctionalityComponents = _a.loadFunctionalityComponents,\n      renderComponent = _a.renderComponent;\n\n  function MotionComponent(props, externalRef) {\n    var ref = useExternalRef(externalRef);\n    var parentContext = useContext(MotionContext);\n    var isStatic = parentContext.static || props.static || false;\n    var values = useMotionValues(props);\n    var style = useMotionStyles(values, props.style, isStatic, props.transformValues);\n    var shouldInheritVariant = checkShouldInheritVariant(props);\n    var controlsConfig = useConstant(function () {\n      return getValueControlsConfig(ref, values);\n    });\n    var controls = useValueAnimationControls(controlsConfig, props, shouldInheritVariant, parentContext);\n    var context = useMotionContext(parentContext, controls, values, isStatic, props);\n    var functionality = isStatic ? null : loadFunctionalityComponents(ref, values, props, parentContext, controls, shouldInheritVariant);\n    var renderedComponent = renderComponent(ref, style, values, props, isStatic);\n    return createElement(Fragment, null, createElement(MotionContext.Provider, {\n      value: context\n    }, renderedComponent), createElement(Fragment, null, createElement(Mount, {\n      innerRef: ref,\n      values: values,\n      isStatic: isStatic\n    }), functionality));\n  }\n\n  return forwardRef(MotionComponent);\n};\n/**\r\n * @internal\r\n */\n\n\nvar htmlElements = [\"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\", \"webview\"];\n/**\r\n * @internal\r\n */\n\nvar svgElements = [\"animate\", \"circle\", \"clipPath\", \"defs\", \"desc\", \"ellipse\", \"feBlend\", \"feColorMatrix\", \"feComponentTransfer\", \"feComposite\", \"feConvolveMatrix\", \"feDiffuseLighting\", \"feDisplacementMap\", \"feDistantLight\", \"feDropShadow\", \"feFlood\", \"feFuncA\", \"feFuncB\", \"feFuncG\", \"feFuncR\", \"feGaussianBlur\", \"feImage\", \"feMerge\", \"feMergeNode\", \"feMorphology\", \"feOffset\", \"fePointLight\", \"feSpecularLighting\", \"feSpotLight\", \"feTile\", \"feTurbulence\", \"filter\", \"foreignObject\", \"g\", \"image\", \"line\", \"linearGradient\", \"marker\", \"mask\", \"metadata\", \"path\", \"pattern\", \"polygon\", \"polyline\", \"radialGradient\", \"rect\", \"stop\", \"svg\", \"switch\", \"symbol\", \"text\", \"textPath\", \"tspan\", \"use\", \"view\"];\n/**\r\n * @internal\r\n */\n\nvar MotionPluginContext = createContext({\n  transformPagePoint: function transformPagePoint(p) {\n    return p;\n  }\n});\n/**\r\n * @remarks For now I think this should remain a private API for our own use\r\n * until we can figure out a nicer way of allowing people to add these\r\n *\r\n * @internal\r\n */\n\nfunction MotionPlugins(_a) {\n  var children = _a.children,\n      props = __rest(_a, [\"children\"]);\n\n  var pluginContext = useContext(MotionPluginContext);\n  var value = useRef(__assign({}, pluginContext)).current; // Mutative to prevent triggering rerenders in all listening\n  // components every time this component renders\n\n  for (var key in props) {\n    value[key] = props[key];\n  }\n\n  return createElement(MotionPluginContext.Provider, {\n    value: value\n  }, children);\n}\n\nfunction useUnmountEffect(callback) {\n  return useEffect(function () {\n    return function () {\n      return callback();\n    };\n  }, []);\n}\n\nfunction addDomEvent(target, eventName, handler, options) {\n  if (!handler) return;\n  target.addEventListener(eventName, handler, options);\n  return function () {\n    return target.removeEventListener(eventName, handler, options);\n  };\n}\n/**\r\n * Attaches an event listener directly to the provided DOM element.\r\n *\r\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\r\n * event handlers.\r\n *\r\n * ```jsx\r\n * const ref = useRef(null)\r\n *\r\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\r\n *\r\n * return <div ref={ref} />\r\n * ```\r\n *\r\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\r\n * @param eventName - Name of the event you want listen for.\r\n * @param handler - Function to fire when receiving the event.\r\n * @param options - Options to pass to `Event.addEventListener`.\r\n *\r\n * @public\r\n */\n\n\nfunction useDomEvent(ref, eventName, handler, options) {\n  useEffect(function () {\n    var element = ref.current;\n\n    if (handler && element) {\n      return addDomEvent(element, eventName, handler, options);\n    }\n  }, [ref, eventName, handler, options]);\n}\n\nfunction isMouseEvent(event) {\n  // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n  if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n    return !!(event.pointerType === \"mouse\");\n  }\n\n  return event instanceof MouseEvent;\n}\n\nfunction isTouchEvent(event) {\n  var hasTouches = !!event.touches;\n  return hasTouches;\n}\n/**\r\n * Filters out events not attached to the primary pointer (currently left mouse button)\r\n * @param eventHandler\r\n */\n\n\nfunction filterPrimaryPointer(eventHandler) {\n  if (!eventHandler) return undefined;\n  return function (event) {\n    var isMouseEvent = event instanceof MouseEvent;\n    var isPrimaryPointer = !isMouseEvent || isMouseEvent && event.button === 0;\n\n    if (isPrimaryPointer) {\n      eventHandler(event);\n    }\n  };\n}\n\nvar defaultPagePoint = {\n  pageX: 0,\n  pageY: 0\n};\n\nfunction pointFromTouch(e) {\n  var primaryTouch = e.touches[0] || e.changedTouches[0];\n\n  var _a = primaryTouch || defaultPagePoint,\n      pageX = _a.pageX,\n      pageY = _a.pageY;\n\n  return {\n    x: pageX,\n    y: pageY\n  };\n}\n\nfunction pointFromMouse(_a) {\n  var _b = _a.pageX,\n      pageX = _b === void 0 ? 0 : _b,\n      _c = _a.pageY,\n      pageY = _c === void 0 ? 0 : _c;\n  return {\n    x: pageX,\n    y: pageY\n  };\n}\n\nfunction extractEventInfo(event) {\n  return {\n    point: isTouchEvent(event) ? pointFromTouch(event) : pointFromMouse(event)\n  };\n}\n\nvar wrapHandler = function wrapHandler(handler, shouldFilterPrimaryPointer) {\n  if (shouldFilterPrimaryPointer === void 0) {\n    shouldFilterPrimaryPointer = false;\n  }\n\n  if (!handler) return;\n\n  var listener = function listener(event) {\n    return handler(event, extractEventInfo(event));\n  };\n\n  return shouldFilterPrimaryPointer ? filterPrimaryPointer(listener) : listener;\n};\n\nvar isBrowser = typeof window !== \"undefined\"; // We check for event support via functions in case they've been mocked by a testing suite.\n\nvar supportsPointerEvents = function supportsPointerEvents() {\n  return isBrowser && window.onpointerdown === null;\n};\n\nvar supportsTouchEvents = function supportsTouchEvents() {\n  return isBrowser && window.ontouchstart === null;\n};\n\nvar supportsMouseEvents = function supportsMouseEvents() {\n  return isBrowser && window.onmousedown === null;\n};\n\nvar mouseEventNames = {\n  pointerdown: \"mousedown\",\n  pointermove: \"mousemove\",\n  pointerup: \"mouseup\",\n  pointercancel: \"mousecancel\",\n  pointerover: \"mouseover\",\n  pointerout: \"mouseout\",\n  pointerenter: \"mouseenter\",\n  pointerleave: \"mouseleave\"\n};\nvar touchEventNames = {\n  pointerdown: \"touchstart\",\n  pointermove: \"touchmove\",\n  pointerup: \"touchend\",\n  pointercancel: \"touchcancel\"\n};\n\nfunction getPointerEventName(name) {\n  if (supportsPointerEvents()) {\n    return name;\n  } else if (supportsTouchEvents()) {\n    return touchEventNames[name];\n  } else if (supportsMouseEvents()) {\n    return mouseEventNames[name];\n  }\n\n  return name;\n}\n\nfunction addPointerEvent(target, eventName, handler, options) {\n  return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nfunction usePointerEvent(ref, eventName, handler, options) {\n  return useDomEvent(ref, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n/** @public */\n\n\nvar Point;\n\n(function (Point) {\n  /** @beta */\n  Point.subtract = function (a, b) {\n    return {\n      x: a.x - b.x,\n      y: a.y - b.y\n    };\n  };\n  /** @beta */\n\n\n  Point.relativeTo = function (idOrElem) {\n    var elem;\n\n    var getElem = function getElem() {\n      // Caching element here could be leaky because of React lifecycle\n      if (elem !== undefined) return elem;\n\n      if (typeof idOrElem === \"string\") {\n        elem = document.getElementById(idOrElem);\n      } else {\n        elem = idOrElem;\n      }\n\n      return elem;\n    };\n\n    return function (_a) {\n      var x = _a.x,\n          y = _a.y;\n      var localElem = getElem();\n      if (!localElem) return undefined;\n      var rect = localElem.getBoundingClientRect();\n      return {\n        x: x - rect.left - window.scrollX,\n        y: y - rect.top - window.scrollY\n      };\n    };\n  };\n})(Point || (Point = {}));\n\nvar isViewportScrollBlocked = false;\nvar isBrowser$1 = typeof window !== \"undefined\";\n\nif (isBrowser$1) {\n  document.addEventListener(\"touchmove\", function (event) {\n    if (isViewportScrollBlocked) {\n      event.preventDefault();\n    }\n  }, {\n    passive: false\n  });\n}\n\nvar blockViewportScroll = function blockViewportScroll() {\n  return isViewportScrollBlocked = true;\n};\n\nvar unblockViewportScroll = function unblockViewportScroll() {\n  return isViewportScrollBlocked = false;\n};\n/**\r\n * @internal\r\n */\n\n\nvar PanSession = function () {\n  function PanSession(event, handlers, _a) {\n    var _this = this;\n\n    var transformPagePoint = (_a === void 0 ? {} : _a).transformPagePoint;\n    /**\r\n     * @internal\r\n     */\n\n    this.startEvent = null;\n    /**\r\n     * @internal\r\n     */\n\n    this.lastMoveEvent = null;\n    /**\r\n     * @internal\r\n     */\n\n    this.lastMoveEventInfo = null;\n    /**\r\n     * @internal\r\n     */\n\n    this.handlers = {};\n\n    this.updatePoint = function () {\n      if (!(_this.lastMoveEvent && _this.lastMoveEventInfo)) return;\n      var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n      var isPanStarted = _this.startEvent !== null; // Only start panning if the offset is larger than 3 pixels. If we make it\n      // any larger than this we'll want to reset the pointer history\n      // on the first update to avoid visual snapping to the cursoe.\n\n      var isDistancePastThreshold = distance(info.offset, {\n        x: 0,\n        y: 0\n      }) >= 3;\n      if (!isPanStarted && !isDistancePastThreshold) return;\n      var point = info.point;\n      var timestamp = getFrameData().timestamp;\n\n      _this.history.push(__assign(__assign({}, point), {\n        timestamp: timestamp\n      }));\n\n      var _a = _this.handlers,\n          onStart = _a.onStart,\n          onMove = _a.onMove;\n\n      if (!isPanStarted) {\n        onStart && onStart(_this.lastMoveEvent, info);\n        _this.startEvent = _this.lastMoveEvent;\n      }\n\n      onMove && onMove(_this.lastMoveEvent, info);\n    }; // If we have more than one touch, don't start detecting this gesture\n\n\n    if (isTouchEvent(event) && event.touches.length > 1) return;\n    this.handlers = handlers;\n    this.transformPagePoint = transformPagePoint;\n    var info = extractEventInfo(event);\n    var initialInfo = transformPoint(info, this.transformPagePoint);\n    var point = initialInfo.point;\n    var timestamp = getFrameData().timestamp;\n    this.history = [__assign(__assign({}, point), {\n      timestamp: timestamp\n    })];\n    var onSessionStart = handlers.onSessionStart;\n    onSessionStart && onSessionStart(event, getPanInfo(initialInfo, this.history));\n    var removeOnPointerMove = addPointerEvent(window, \"pointermove\", function (event, info) {\n      return _this.handlePointerMove(event, info);\n    });\n    var removeOnPointerUp = addPointerEvent(window, \"pointerup\", function (event, info) {\n      return _this.handlePointerUp(event, info);\n    });\n\n    this.removeListeners = function () {\n      removeOnPointerMove && removeOnPointerMove();\n      removeOnPointerUp && removeOnPointerUp();\n    };\n  }\n\n  PanSession.prototype.handlePointerMove = function (event, info) {\n    this.lastMoveEvent = event;\n    this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint); // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n\n    if (isMouseEvent(event) && event.buttons === 0) {\n      this.handlePointerUp(event, info);\n      return;\n    } // Throttle mouse move event to once per frame\n\n\n    sync.update(this.updatePoint, true);\n  };\n\n  PanSession.prototype.handlePointerUp = function (event, info) {\n    this.end();\n    var onEnd = this.handlers.onEnd;\n    if (!onEnd) return;\n    var panInfo = getPanInfo(transformPoint(info, this.transformPagePoint), this.history);\n    onEnd && onEnd(event, panInfo);\n  };\n\n  PanSession.prototype.updateHandlers = function (handlers) {\n    this.handlers = handlers;\n  };\n\n  PanSession.prototype.end = function () {\n    this.removeListeners && this.removeListeners();\n    cancelSync.update(this.updatePoint);\n    unblockViewportScroll();\n  };\n\n  return PanSession;\n}();\n\nfunction transformPoint(info, transformPagePoint) {\n  return transformPagePoint ? {\n    point: transformPagePoint(info.point)\n  } : info;\n}\n\nfunction getPanInfo(_a, history) {\n  var point = _a.point;\n  return {\n    point: point,\n    delta: Point.subtract(point, lastDevicePoint(history)),\n    offset: Point.subtract(point, startDevicePoint(history)),\n    velocity: getVelocity$1(history, 0.1)\n  };\n}\n\nfunction startDevicePoint(history) {\n  return history[0];\n}\n\nfunction lastDevicePoint(history) {\n  return history[history.length - 1];\n}\n\nfunction getVelocity$1(history, timeDelta) {\n  if (history.length < 2) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n\n  var i = history.length - 1;\n  var timestampedPoint = null;\n  var lastPoint = lastDevicePoint(history);\n\n  while (i >= 0) {\n    timestampedPoint = history[i];\n\n    if (lastPoint.timestamp - timestampedPoint.timestamp > secondsToMilliseconds(timeDelta)) {\n      break;\n    }\n\n    i--;\n  }\n\n  if (!timestampedPoint) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n\n  var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n\n  if (time === 0) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n\n  var currentVelocity = {\n    x: (lastPoint.x - timestampedPoint.x) / time,\n    y: (lastPoint.y - timestampedPoint.y) / time\n  };\n\n  if (currentVelocity.x === Infinity) {\n    currentVelocity.x = 0;\n  }\n\n  if (currentVelocity.y === Infinity) {\n    currentVelocity.y = 0;\n  }\n\n  return currentVelocity;\n}\n/**\r\n *\r\n * @param handlers -\r\n * @param ref -\r\n *\r\n * @internalremarks\r\n * Currently this sets new pan gesture functions every render. The memo route has been explored\r\n * in the past but ultimately we're still creating new functions every render. An optimisation\r\n * to explore is creating the pan gestures and loading them into a `ref`.\r\n *\r\n * @internal\r\n */\n\n\nfunction usePanGesture(_a, ref) {\n  var onPan = _a.onPan,\n      onPanStart = _a.onPanStart,\n      onPanEnd = _a.onPanEnd,\n      onPanSessionStart = _a.onPanSessionStart;\n  var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n  var panSession = useRef(null);\n  var transformPagePoint = useContext(MotionPluginContext).transformPagePoint;\n  var handlers = {\n    onSessionStart: onPanSessionStart,\n    onStart: onPanStart,\n    onMove: onPan,\n    onEnd: function onEnd(event, info) {\n      panSession.current = null;\n      onPanEnd && onPanEnd(event, info);\n    }\n  };\n\n  if (panSession.current !== null) {\n    panSession.current.updateHandlers(handlers);\n  }\n\n  function onPointerDown(event) {\n    panSession.current = new PanSession(event, handlers, {\n      transformPagePoint: transformPagePoint\n    });\n  }\n\n  usePointerEvent(ref, \"pointerdown\", hasPanEvents && onPointerDown);\n  useUnmountEffect(function () {\n    return panSession.current && panSession.current.end();\n  });\n}\n/**\r\n * Recursively traverse up the tree to check whether the provided child node\r\n * is the parent or a descendant of it.\r\n *\r\n * @param parent - Element to find\r\n * @param child - Element to test against parent\r\n */\n\n\nvar isNodeOrChild = function isNodeOrChild(parent, child) {\n  if (!child) {\n    return false;\n  } else if (parent === child) {\n    return true;\n  } else {\n    return isNodeOrChild(parent, child.parentElement);\n  }\n};\n\nvar order = [\"whileHover\", \"whileTap\", \"whileDrag\"];\n\nvar getGesturePriority = function getGesturePriority(gesture) {\n  return order.indexOf(gesture) + 1;\n};\n\nfunction createLock(name) {\n  var lock = null;\n  return function () {\n    var openLock = function openLock() {\n      lock = null;\n    };\n\n    if (lock === null) {\n      lock = name;\n      return openLock;\n    }\n\n    return false;\n  };\n}\n\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\n\nfunction getGlobalLock(drag) {\n  var lock = false;\n\n  if (drag === \"y\") {\n    lock = globalVerticalLock();\n  } else if (drag === \"x\") {\n    lock = globalHorizontalLock();\n  } else {\n    var openHorizontal_1 = globalHorizontalLock();\n    var openVertical_1 = globalVerticalLock();\n\n    if (openHorizontal_1 && openVertical_1) {\n      lock = function lock() {\n        openHorizontal_1();\n        openVertical_1();\n      };\n    } else {\n      // Release the locks because we don't use them\n      if (openHorizontal_1) openHorizontal_1();\n      if (openVertical_1) openVertical_1();\n    }\n  }\n\n  return lock;\n}\n\nvar tapGesturePriority = getGesturePriority(\"whileTap\");\n/**\r\n * @param handlers -\r\n * @internal\r\n */\n\nfunction useTapGesture(_a, ref) {\n  var onTap = _a.onTap,\n      onTapStart = _a.onTapStart,\n      onTapCancel = _a.onTapCancel,\n      whileTap = _a.whileTap,\n      controls = _a.controls;\n  var hasTapListeners = onTap || onTapStart || onTapCancel || whileTap;\n  var isTapping = useRef(false);\n  var cancelPointerEventListener = useRef(null);\n\n  function removePointerUp() {\n    cancelPointerEventListener.current && cancelPointerEventListener.current();\n    cancelPointerEventListener.current = null;\n  }\n\n  if (whileTap && controls) {\n    controls.setOverride(whileTap, tapGesturePriority);\n  } // We load this event handler into a ref so we can later refer to\n  // onPointerUp.current which will always have reference to the latest props\n\n\n  var onPointerUp = useRef(null);\n\n  onPointerUp.current = function (event, info) {\n    var element = ref.current;\n    removePointerUp();\n    if (!isTapping.current || !element) return;\n    isTapping.current = false;\n\n    if (controls && whileTap) {\n      controls.clearOverride(tapGesturePriority);\n    } // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n\n\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock) return;\n    openGestureLock();\n\n    if (!isNodeOrChild(element, event.target)) {\n      onTapCancel && onTapCancel(event, info);\n    } else {\n      onTap && onTap(event, info);\n    }\n  };\n\n  function onPointerDown(event, info) {\n    removePointerUp();\n    cancelPointerEventListener.current = addPointerEvent(window, \"pointerup\", function (event, info) {\n      return onPointerUp.current(event, info);\n    });\n    var element = ref.current;\n    if (!element || isTapping.current) return;\n    isTapping.current = true;\n    onTapStart && onTapStart(event, info);\n\n    if (controls && whileTap) {\n      controls.startOverride(tapGesturePriority);\n    }\n  }\n\n  usePointerEvent(ref, \"pointerdown\", hasTapListeners ? onPointerDown : undefined);\n  useUnmountEffect(removePointerUp);\n}\n\nvar hoverPriority = getGesturePriority(\"whileHover\");\n\nvar filterTouch = function filterTouch(listener) {\n  return function (event, info) {\n    if (isMouseEvent(event)) listener(event, info);\n  };\n};\n/**\r\n *\r\n * @param props\r\n * @param ref\r\n * @internal\r\n */\n\n\nfunction useHoverGesture(_a, ref) {\n  var whileHover = _a.whileHover,\n      onHoverStart = _a.onHoverStart,\n      onHoverEnd = _a.onHoverEnd,\n      controls = _a.controls;\n\n  if (whileHover && controls) {\n    controls.setOverride(whileHover, hoverPriority);\n  }\n\n  usePointerEvent(ref, \"pointerenter\", filterTouch(function (event, info) {\n    if (onHoverStart) onHoverStart(event, info);\n\n    if (whileHover && controls) {\n      controls.startOverride(hoverPriority);\n    }\n  }));\n  usePointerEvent(ref, \"pointerleave\", filterTouch(function (event, info) {\n    if (onHoverEnd) onHoverEnd(event, info);\n\n    if (whileHover && controls) {\n      controls.clearOverride(hoverPriority);\n    }\n  }));\n}\n/**\r\n * Add pan and tap gesture recognition to an element.\r\n *\r\n * @param props - Gesture event handlers\r\n * @param ref - React `ref` containing a DOM `Element`\r\n * @public\r\n */\n\n\nfunction useGestures(props, ref) {\n  usePanGesture(props, ref);\n  useTapGesture(props, ref);\n  useHoverGesture(props, ref);\n}\n\nvar makeRenderlessComponent = function makeRenderlessComponent(hook) {\n  return function (props) {\n    hook(props);\n    return null;\n  };\n};\n\nvar gestureProps = [\"onPan\", \"onPanStart\", \"onPanEnd\", \"onPanSessionStart\", \"onTap\", \"onTapStart\", \"onTapCancel\", \"whileTap\", \"whileHover\", \"onHoverStart\", \"onHoverEnd\"];\nvar Gestures = {\n  key: \"gestures\",\n  shouldRender: function shouldRender(props) {\n    return gestureProps.some(function (key) {\n      return props.hasOwnProperty(key);\n    });\n  },\n  Component: makeRenderlessComponent(function (_a) {\n    var innerRef = _a.innerRef,\n        props = __rest(_a, [\"innerRef\"]);\n\n    useGestures(props, innerRef);\n  })\n};\n\nvar isRefObject = function isRefObject(ref) {\n  return typeof ref === \"object\" && ref.hasOwnProperty(\"current\");\n};\n\nvar noop = function noop(v) {\n  return v;\n};\n/**\r\n * Don't block the default pointerdown behaviour of these elements.\r\n */\n\n\nvar allowDefaultPointerDown = new Set([\"INPUT\", \"TEXTAREA\", \"SELECT\"]);\n\nvar ComponentDragControls = function () {\n  function ComponentDragControls(_a) {\n    var ref = _a.ref,\n        values = _a.values,\n        controls = _a.controls;\n    /**\r\n     * Track whether we're currently dragging.\r\n     *\r\n     * @internal\r\n     */\n\n    this.isDragging = false;\n    /**\r\n     * The current direction of drag, or `null` if both.\r\n     *\r\n     * @internal\r\n     */\n\n    this.currentDirection = null;\n    /**\r\n     * The permitted t/r/b/l boundaries of travel, in pixels.\r\n     *\r\n     * @internal\r\n     */\n\n    this.constraints = false;\n    /**\r\n     * A reference to the host component's latest props.\r\n     *\r\n     * @internal\r\n     */\n\n    this.props = {\n      transformPagePoint: noop\n    };\n    /**\r\n     * References to the MotionValues used for tracking the current dragged point.\r\n     *\r\n     * @internal\r\n     */\n\n    this.point = {};\n    /**\r\n     * The origin point for the current drag gesture.\r\n     *\r\n     * @internal\r\n     */\n\n    this.origin = {\n      x: motionValue(0),\n      y: motionValue(0)\n    }; // This is a reference to the global drag gesture lock, ensuring only one component\n    // can \"capture\" the drag of one or both axes.\n    // TODO: Look into moving this into pansession?\n\n    this.openGlobalLock = null;\n    /**\r\n     * @internal\r\n     */\n\n    this.panSession = null;\n    /**\r\n     * A reference to the previous constraints bounding box\r\n     *\r\n     * @internal\r\n     */\n\n    this.prevConstraintsBox = {\n      width: 0,\n      height: 0,\n      x: 0,\n      y: 0\n    };\n    this.ref = ref;\n    this.values = values;\n    this.controls = controls;\n  }\n  /**\r\n   * Start dragging the host component.\r\n   *\r\n   * @param event - The originating pointer event.\r\n   * @param options -\r\n   *\r\n   * @public\r\n   */\n\n\n  ComponentDragControls.prototype.start = function (originEvent, _a) {\n    var _this = this;\n\n    var _b = (_a === void 0 ? {} : _a).snapToCursor,\n        snapToCursor = _b === void 0 ? false : _b;\n    snapToCursor && this.snapToCursor(originEvent);\n\n    var onSessionStart = function onSessionStart(event) {\n      // Prevent browser-specific behaviours like text selection or Chrome's image dragging.\n      if (event.target && !allowDefaultPointerDown.has(event.target.tagName)) {\n        // On iOS it's important to not `preventDefault` the `touchstart`\n        // event, as otherwise clicks won't fire inside the draggable element.\n        if (!supportsTouchEvents()) {\n          event.preventDefault(); // Make sure input elements loose focus when we prevent the default.\n\n          if (document.activeElement instanceof HTMLElement) {\n            document.activeElement.blur();\n          }\n        }\n      } // Initiate viewport scroll blocking on touch start. This is a very aggressive approach\n      // which has come out of the difficulty in us being able to do this once a scroll gesture\n      // has initiated in mobile browsers. This means if there's a horizontally-scrolling carousel\n      // on a page we can't let a user scroll the page itself from it. Ideally what we'd do is\n      // trigger this once we've got a scroll direction determined. This approach sort-of worked\n      // but if the component was dragged too far in a single frame page scrolling would initiate.\n\n\n      blockViewportScroll(); // Stop any animations on both axis values immediately. This allows the user to throw and catch\n      // the component.\n\n      bothAxis(function (axis) {\n        var axisPoint = _this.point[axis];\n        axisPoint && axisPoint.stop();\n      });\n    };\n\n    var onStart = function onStart(event, info) {\n      // If constraints are an element, resolve them again in case they've updated.\n      if (_this.constraintsNeedResolution) {\n        var _a = _this.props,\n            dragConstraints = _a.dragConstraints,\n            transformPagePoint_1 = _a.transformPagePoint;\n        _this.constraints = calculateConstraintsFromDom(dragConstraints, _this.ref, _this.point, transformPagePoint_1);\n\n        _this.applyConstraintsToPoint();\n      } // Set point origin and stop any existing animations.\n\n\n      bothAxis(function (axis) {\n        var axisPoint = _this.point[axis];\n        if (!axisPoint) return;\n\n        _this.origin[axis].set(axisPoint.get());\n      }); // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n\n      var _b = _this.props,\n          drag = _b.drag,\n          dragPropagation = _b.dragPropagation;\n\n      if (drag && !dragPropagation) {\n        if (_this.openGlobalLock) _this.openGlobalLock();\n        _this.openGlobalLock = getGlobalLock(drag);\n        if (!_this.openGlobalLock) return;\n      }\n\n      _this.isDragging = true;\n      _this.currentDirection = null;\n      var onDragStart = _this.props.onDragStart;\n      onDragStart && onDragStart(event, convertPanToDrag(info, _this.point));\n    };\n\n    var onMove = function onMove(event, info) {\n      var _a = _this.props,\n          dragPropagation = _a.dragPropagation,\n          dragDirectionLock = _a.dragDirectionLock; // If we didn't successfully receive the gesture lock, early return.\n\n      if (!dragPropagation && !_this.openGlobalLock) return;\n      var offset = info.offset; // Attempt to detect drag direction if directionLock is true\n\n      if (dragDirectionLock && _this.currentDirection === null) {\n        _this.currentDirection = getCurrentDirection(offset); // If we've successfully set a direction, notify listener\n\n        if (_this.currentDirection !== null) {\n          var onDirectionLock = _this.props.onDirectionLock;\n          onDirectionLock && onDirectionLock(_this.currentDirection);\n        }\n\n        return;\n      }\n\n      _this.updatePoint(\"x\", offset);\n\n      _this.updatePoint(\"y\", offset);\n\n      var onDrag = _this.props.onDrag;\n      onDrag && onDrag(event, convertPanToDrag(info, _this.point));\n    };\n\n    var onEnd = function onEnd(event, info) {\n      _this.stop(event, info);\n    };\n\n    var transformPagePoint = this.props.transformPagePoint;\n    this.panSession = new PanSession(originEvent, {\n      onSessionStart: onSessionStart,\n      onStart: onStart,\n      onMove: onMove,\n      onEnd: onEnd\n    }, {\n      transformPagePoint: transformPagePoint\n    });\n  };\n\n  ComponentDragControls.prototype.cancelDrag = function () {\n    unblockViewportScroll();\n    this.isDragging = false;\n    this.panSession && this.panSession.end();\n    this.panSession = null;\n\n    if (!this.props.dragPropagation && this.openGlobalLock) {\n      this.openGlobalLock();\n      this.openGlobalLock = null;\n    }\n  };\n\n  ComponentDragControls.prototype.stop = function (event, info) {\n    var _a;\n\n    (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n    this.panSession = null;\n    var isDragging = this.isDragging;\n    this.cancelDrag();\n    if (!isDragging) return;\n    var _b = this.props,\n        dragMomentum = _b.dragMomentum,\n        dragElastic = _b.dragElastic,\n        onDragEnd = _b.onDragEnd;\n\n    if (dragMomentum || dragElastic) {\n      var velocity = info.velocity;\n      this.animateDragEnd(velocity);\n    } else {\n      this.recordBoxInfo(this.constraints);\n    }\n\n    onDragEnd && onDragEnd(event, convertPanToDrag(info, this.point));\n  };\n\n  ComponentDragControls.prototype.recordBoxInfo = function (constraints) {\n    if (constraints) {\n      var right = constraints.right,\n          left = constraints.left,\n          bottom = constraints.bottom,\n          top_1 = constraints.top;\n      this.prevConstraintsBox.width = (right || 0) - (left || 0);\n      this.prevConstraintsBox.height = (bottom || 0) - (top_1 || 0);\n    }\n\n    if (this.point.x) this.prevConstraintsBox.x = this.point.x.get();\n    if (this.point.y) this.prevConstraintsBox.y = this.point.y.get();\n  };\n\n  ComponentDragControls.prototype.snapToCursor = function (event) {\n    var _this = this;\n\n    var transformPagePoint = this.props.transformPagePoint;\n    var point = extractEventInfo(event).point;\n    var boundingBox = getBoundingBox(this.ref, transformPagePoint);\n    var center = {\n      x: boundingBox.width / 2 + boundingBox.left + window.scrollX,\n      y: boundingBox.height / 2 + boundingBox.top + window.scrollY\n    };\n    var offset = {\n      x: point.x - center.x,\n      y: point.y - center.y\n    };\n    bothAxis(function (axis) {\n      var point = _this.point[axis];\n      if (!point) return;\n\n      _this.origin[axis].set(point.get());\n    });\n    this.updatePoint(\"x\", offset);\n    this.updatePoint(\"y\", offset);\n  };\n\n  ComponentDragControls.prototype.setPoint = function (axis, value) {\n    this.point[axis] = value;\n  };\n\n  ComponentDragControls.prototype.updatePoint = function (axis, offset) {\n    var _a = this.props,\n        drag = _a.drag,\n        dragElastic = _a.dragElastic;\n    var axisPoint = this.point[axis]; // If we're not dragging this axis, do an early return.\n\n    if (!shouldDrag(axis, drag, this.currentDirection) || !axisPoint) return;\n    var current = applyConstraints(axis, this.origin[axis].get() + offset[axis], this.constraints, dragElastic);\n    axisPoint.set(current);\n  };\n\n  ComponentDragControls.prototype.updateProps = function (_a) {\n    var _this = this;\n\n    var _b = _a.drag,\n        drag = _b === void 0 ? false : _b,\n        _c = _a.dragDirectionLock,\n        dragDirectionLock = _c === void 0 ? false : _c,\n        _d = _a.dragPropagation,\n        dragPropagation = _d === void 0 ? false : _d,\n        _e = _a.dragConstraints,\n        dragConstraints = _e === void 0 ? false : _e,\n        _f = _a.dragElastic,\n        dragElastic = _f === void 0 ? true : _f,\n        _g = _a.dragMomentum,\n        dragMomentum = _g === void 0 ? true : _g,\n        remainingProps = __rest(_a, [\"drag\", \"dragDirectionLock\", \"dragPropagation\", \"dragConstraints\", \"dragElastic\", \"dragMomentum\"]);\n\n    this.props = __assign({\n      drag: drag,\n      dragDirectionLock: dragDirectionLock,\n      dragPropagation: dragPropagation,\n      dragConstraints: dragConstraints,\n      dragElastic: dragElastic,\n      dragMomentum: dragMomentum\n    }, remainingProps);\n    var _dragValueX = remainingProps._dragValueX,\n        _dragValueY = remainingProps._dragValueY,\n        dragOriginX = remainingProps.dragOriginX,\n        dragOriginY = remainingProps.dragOriginY;\n    if (dragOriginX) this.origin.x = dragOriginX;\n    if (dragOriginY) this.origin.y = dragOriginY; // Get the `MotionValue` for both draggable axes, or create them if they don't already\n    // exist on this component.\n\n    bothAxis(function (axis) {\n      if (!shouldDrag(axis, drag, _this.currentDirection)) return;\n      var defaultValue = axis === \"x\" ? _dragValueX : _dragValueY;\n\n      _this.setPoint(axis, defaultValue || _this.values.get(axis, 0));\n    }); // If `dragConstraints` is a React `ref`, we should resolve the constraints once the\n    // component has rendered.\n\n    this.constraintsNeedResolution = isRefObject(dragConstraints);\n    this.constraints = this.constraintsNeedResolution ? this.constraints || false : dragConstraints;\n  };\n\n  ComponentDragControls.prototype.applyConstraintsToPoint = function (constraints) {\n    var _this = this;\n\n    if (constraints === void 0) {\n      constraints = this.constraints;\n    }\n\n    return bothAxis(function (axis) {\n      var axisPoint = _this.point[axis];\n      axisPoint && !axisPoint.isAnimating() && applyConstraints(axis, axisPoint, constraints, 0);\n    });\n  };\n\n  ComponentDragControls.prototype.animateDragEnd = function (velocity) {\n    var _this = this;\n\n    var _a = this.props,\n        drag = _a.drag,\n        dragMomentum = _a.dragMomentum,\n        dragElastic = _a.dragElastic,\n        dragTransition = _a.dragTransition,\n        _dragTransitionControls = _a._dragTransitionControls;\n    var momentumAnimations = bothAxis(function (axis) {\n      var _a;\n\n      if (!shouldDrag(axis, drag, _this.currentDirection)) {\n        return;\n      }\n\n      var transition = _this.constraints ? getConstraints(axis, _this.constraints) : {};\n      /**\r\n       * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\r\n       * of spring animations so we should look into adding a disable spring option to `inertia`.\r\n       * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\r\n       * using the value of `dragElastic`.\r\n       */\n\n      var bounceStiffness = dragElastic ? 200 : 1000000;\n      var bounceDamping = dragElastic ? 40 : 10000000;\n      var animationControls = _dragTransitionControls || _this.controls;\n      return animationControls.start((_a = {}, _a[axis] = 0, // TODO: It might be possible to allow `type` animations to be set as\n      // Popmotion animations as well as strings. Then people could define their own\n      // and it'd open another route for us to code-split.\n      _a.transition = __assign(__assign({\n        type: \"inertia\",\n        velocity: dragMomentum ? velocity[axis] : 0,\n        bounceStiffness: bounceStiffness,\n        bounceDamping: bounceDamping,\n        timeConstant: 750,\n        restDelta: 1\n      }, dragTransition), transition), _a));\n    }); // Run all animations and then resolve the new drag constraints.\n\n    return Promise.all(momentumAnimations).then(function () {\n      _this.recordBoxInfo(_this.constraints);\n\n      _this.scalePoint();\n\n      var onDragTransitionEnd = _this.props.onDragTransitionEnd;\n      onDragTransitionEnd && onDragTransitionEnd();\n    });\n  };\n\n  ComponentDragControls.prototype.scalePoint = function () {\n    var _this = this;\n\n    var _a = this.props,\n        dragConstraints = _a.dragConstraints,\n        transformPagePoint = _a.transformPagePoint;\n    if (!isRefObject(dragConstraints)) return;\n    var constraintsBox = getBoundingBox(dragConstraints, transformPagePoint);\n    var draggableBox = getBoundingBox(this.ref, transformPagePoint); // Scale a point relative to the transformation of a constraints-providing element.\n\n    var scaleAxisPoint = function scaleAxisPoint(axis, dimension) {\n      var pointToScale = _this.point[axis];\n      if (!pointToScale) return; // Stop any current animations as they bug out if you resize during one\n\n      if (pointToScale.isAnimating()) {\n        pointToScale.stop();\n\n        _this.recordBoxInfo();\n\n        return;\n      } // If the previous dimension was `0` (default), set `scale` to `1` to prevent\n      // divide by zero errors.\n\n\n      var scale = _this.prevConstraintsBox[dimension] ? (constraintsBox[dimension] - draggableBox[dimension]) / _this.prevConstraintsBox[dimension] : 1;\n      pointToScale.set(_this.prevConstraintsBox[axis] * scale);\n    };\n\n    scaleAxisPoint(\"x\", \"width\");\n    scaleAxisPoint(\"y\", \"height\");\n  };\n\n  ComponentDragControls.prototype.mount = function (element) {\n    var _this = this;\n\n    var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n      var _a = _this.props,\n          drag = _a.drag,\n          _b = _a.dragListener,\n          dragListener = _b === void 0 ? true : _b;\n      drag && dragListener && _this.start(event);\n    });\n    var stopResizeListener = addDomEvent(window, \"resize\", function () {\n      return _this.scalePoint();\n    });\n\n    if (this.constraintsNeedResolution) {\n      var _a = this.props,\n          dragConstraints = _a.dragConstraints,\n          transformPagePoint = _a.transformPagePoint;\n      var constraints = calculateConstraintsFromDom(dragConstraints, this.ref, this.point, transformPagePoint);\n      this.applyConstraintsToPoint(constraints);\n      this.recordBoxInfo(constraints);\n    } else if (!this.isDragging && this.constraints) {\n      this.applyConstraintsToPoint();\n    }\n\n    return function () {\n      stopPointerListener && stopPointerListener();\n      stopResizeListener && stopResizeListener();\n\n      _this.cancelDrag();\n    };\n  };\n\n  return ComponentDragControls;\n}(); // Call a handler once for each axis\n\n\nfunction bothAxis(handler) {\n  return [handler(\"x\"), handler(\"y\")];\n}\n\nfunction convertPanToDrag(info, point) {\n  return __assign(__assign({}, info), {\n    point: {\n      x: point.x ? point.x.get() : 0,\n      y: point.y ? point.y.get() : 0\n    }\n  });\n}\n\nfunction getConstraints(axis, _a) {\n  var top = _a.top,\n      right = _a.right,\n      bottom = _a.bottom,\n      left = _a.left;\n\n  if (axis === \"x\") {\n    return {\n      min: left,\n      max: right\n    };\n  } else {\n    return {\n      min: top,\n      max: bottom\n    };\n  }\n}\n\nfunction shouldDrag(direction, drag, currentDirection) {\n  return (drag === true || drag === direction) && (currentDirection === null || currentDirection === direction);\n}\n/**\r\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\r\n * than the provided threshold, return `null`.\r\n *\r\n * @param offset - The x/y offset from origin.\r\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\r\n */\n\n\nfunction getCurrentDirection(offset, lockThreshold) {\n  if (lockThreshold === void 0) {\n    lockThreshold = 10;\n  }\n\n  var direction = null;\n\n  if (Math.abs(offset.y) > lockThreshold) {\n    direction = \"y\";\n  } else if (Math.abs(offset.x) > lockThreshold) {\n    direction = \"x\";\n  }\n\n  return direction;\n}\n/**\r\n * Takes a parent Element and a draggable Element and returns pixel-based drag constraints.\r\n *\r\n * @param constraintsRef\r\n * @param draggableRef\r\n */\n\n\nfunction calculateConstraintsFromDom(constraintsRef, draggableRef, point, transformPagePoint) {\n  invariant(constraintsRef.current !== null && draggableRef.current !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n  var parentBoundingBox = getBoundingBox(constraintsRef, transformPagePoint);\n  var draggableBoundingBox = getBoundingBox(draggableRef, transformPagePoint);\n  var left = parentBoundingBox.left - draggableBoundingBox.left + getCurrentOffset(point.x);\n  var top = parentBoundingBox.top - draggableBoundingBox.top + getCurrentOffset(point.y);\n  var right = parentBoundingBox.width - draggableBoundingBox.width + left;\n  var bottom = parentBoundingBox.height - draggableBoundingBox.height + top;\n  return {\n    top: top,\n    left: left,\n    right: right,\n    bottom: bottom\n  };\n}\n\nfunction getBoundingBox(ref, transformPagePoint) {\n  var rect = ref.current.getBoundingClientRect();\n\n  var _a = transformPagePoint({\n    x: rect.left,\n    y: rect.top\n  }),\n      left = _a.x,\n      top = _a.y;\n\n  var _b = transformPagePoint({\n    x: rect.width,\n    y: rect.height\n  }),\n      width = _b.x,\n      height = _b.y;\n\n  return {\n    left: left,\n    top: top,\n    width: width,\n    height: height\n  };\n}\n\nfunction getCurrentOffset(point) {\n  return point ? point.get() : 0;\n}\n\nfunction applyConstraints(axis, value, constraints, dragElastic) {\n  var constrainedValue = value instanceof MotionValue ? value.get() : value;\n\n  if (!constraints) {\n    return constrainedValue;\n  }\n\n  var _a = getConstraints(axis, constraints),\n      min = _a.min,\n      max = _a.max;\n\n  if (min !== undefined && constrainedValue < min) {\n    constrainedValue = dragElastic ? applyOverdrag(min, constrainedValue, dragElastic) : Math.max(min, constrainedValue);\n  } else if (max !== undefined && constrainedValue > max) {\n    constrainedValue = dragElastic ? applyOverdrag(max, constrainedValue, dragElastic) : Math.min(max, constrainedValue);\n  }\n\n  if (value instanceof MotionValue) {\n    value.set(constrainedValue);\n  }\n\n  return constrainedValue;\n}\n\nfunction applyOverdrag(origin, current, dragElastic) {\n  var dragFactor = typeof dragElastic === \"number\" ? dragElastic : 0.35;\n  return mix(origin, current, dragFactor);\n}\n/**\r\n * A hook that allows an element to be dragged.\r\n *\r\n * @param param\r\n * @param ref\r\n * @param values\r\n * @param controls\r\n *\r\n * @internal\r\n */\n\n\nfunction useDrag(props, ref, values, controls) {\n  var groupDragControls = props.dragControls;\n  var transformPagePoint = useContext(MotionPluginContext).transformPagePoint;\n  var dragControls = useConstant(function () {\n    return new ComponentDragControls({\n      ref: ref,\n      values: values,\n      controls: controls\n    });\n  });\n  dragControls.updateProps(__assign(__assign({}, props), {\n    transformPagePoint: transformPagePoint\n  }));\n  useEffect(function () {\n    return groupDragControls && groupDragControls.subscribe(dragControls);\n  }, [dragControls]);\n  useEffect(function () {\n    return dragControls.mount(ref.current);\n  }, []);\n}\n\nvar Drag = {\n  key: \"drag\",\n  shouldRender: function shouldRender(props) {\n    return !!props.drag;\n  },\n  Component: makeRenderlessComponent(function (_a) {\n    var innerRef = _a.innerRef,\n        values = _a.values,\n        controls = _a.controls,\n        props = __rest(_a, [\"innerRef\", \"values\", \"controls\"]);\n\n    return useDrag(props, innerRef, values, controls);\n  })\n};\n\nfunction isCSSVariable(value) {\n  return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\r\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\r\n *\r\n * ```\r\n * `var(--foo, #fff)` => [`--foo`, '#fff']\r\n * ```\r\n *\r\n * @param current\r\n */\n\n\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\n\nfunction parseCSSVariable(current) {\n  var match = cssVariableRegex.exec(current);\n  if (!match) return [,];\n  var token = match[1],\n      fallback = match[2];\n  return [token, fallback];\n}\n\nvar maxDepth = 4;\n\nfunction getVariableValue(current, element, depth) {\n  if (depth === void 0) {\n    depth = 1;\n  }\n\n  invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\" + current + \"\\\". This may indicate a circular fallback dependency.\");\n\n  var _a = parseCSSVariable(current),\n      token = _a[0],\n      fallback = _a[1]; // No CSS variable detected\n\n\n  if (!token) return; // Attempt to read this CSS variable off the element\n\n  var resolved = window.getComputedStyle(element).getPropertyValue(token);\n\n  if (resolved) {\n    return resolved;\n  } else if (isCSSVariable(fallback)) {\n    // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n    return getVariableValue(fallback, element, depth + 1);\n  } else {\n    return fallback;\n  }\n}\n/**\r\n * Resolve CSS variables from\r\n *\r\n * @internal\r\n */\n\n\nfunction resolveCSSVariables(values, ref, _a, transitionEnd) {\n  var target = __rest(_a, []);\n\n  var element = ref.current;\n  if (!(element instanceof HTMLElement)) return {\n    target: target,\n    transitionEnd: transitionEnd\n  }; // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n  // only if they change but I think this reads clearer and this isn't a performance-critical path.\n\n  if (transitionEnd) {\n    transitionEnd = __assign({}, transitionEnd);\n  } // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n\n\n  values.forEach(function (value) {\n    var current = value.get();\n    if (!isCSSVariable(current)) return;\n    var resolved = getVariableValue(current, element);\n    if (resolved) value.set(resolved);\n  }); // Cycle through every target property and resolve CSS variables. Currently\n  // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n\n  for (var key in target) {\n    var current = target[key];\n    if (!isCSSVariable(current)) continue;\n    var resolved = getVariableValue(current, element);\n    if (!resolved) continue; // Clone target if it hasn't already been\n\n    target[key] = resolved; // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n    // CSS variable. This will ensure that after the animation the component will reflect\n    // changes in the value of the CSS variable.\n\n    if (transitionEnd && transitionEnd[key] === undefined) {\n      transitionEnd[key] = current;\n    }\n  }\n\n  return {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\n\nvar positionalKeys = new Set([\"width\", \"height\", \"top\", \"left\", \"right\", \"bottom\", \"x\", \"y\"]);\n\nvar isPositionalKey = function isPositionalKey(key) {\n  return positionalKeys.has(key);\n};\n\nvar hasPositionalKey = function hasPositionalKey(target) {\n  return Object.keys(target).some(isPositionalKey);\n};\n\nvar setAndResetVelocity = function setAndResetVelocity(value, to) {\n  // Looks odd but setting it twice doesn't render, it'll just\n  // set both prev and current to the latest value\n  value.set(to, false);\n  value.set(to);\n};\n\nvar isNumOrPxType = function isNumOrPxType(v) {\n  return v === number || v === px;\n};\n\nvar BoundingBoxDimension;\n\n(function (BoundingBoxDimension) {\n  BoundingBoxDimension[\"width\"] = \"width\";\n  BoundingBoxDimension[\"height\"] = \"height\";\n  BoundingBoxDimension[\"left\"] = \"left\";\n  BoundingBoxDimension[\"right\"] = \"right\";\n  BoundingBoxDimension[\"top\"] = \"top\";\n  BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\n\nvar getPosFromMatrix = function getPosFromMatrix(matrix, pos) {\n  return parseFloat(matrix.split(\", \")[pos]);\n};\n\nvar getTranslateFromMatrix = function getTranslateFromMatrix(pos2, pos3) {\n  return function (_bbox, _a) {\n    var transform = _a.transform;\n    if (transform === \"none\" || !transform) return 0;\n    var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n\n    if (matrix3d) {\n      return getPosFromMatrix(matrix3d[1], pos3);\n    } else {\n      var matrix = transform.match(/^matrix\\((.+)\\)$/);\n      return getPosFromMatrix(matrix[1], pos2);\n    }\n  };\n};\n\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) {\n  return !transformKeys.has(key);\n});\n\nfunction removeNonTranslationalTransform(values, elementStyler) {\n  var removedTransforms = [];\n  nonTranslationalTransformKeys.forEach(function (key) {\n    var value = values.get(key);\n\n    if (value !== undefined) {\n      removedTransforms.push([key, value.get()]);\n      value.set(key.startsWith(\"scale\") ? 1 : 0);\n    }\n  }); // Apply changes to element before measurement\n\n  if (removedTransforms.length) elementStyler.render();\n  return removedTransforms;\n}\n\nvar positionalValues = {\n  // Dimensions\n  width: function width(_a) {\n    var width = _a.width;\n    return width;\n  },\n  height: function height(_a) {\n    var height = _a.height;\n    return height;\n  },\n  top: function top(_bbox, _a) {\n    var top = _a.top;\n    return parseFloat(top);\n  },\n  left: function left(_bbox, _a) {\n    var left = _a.left;\n    return parseFloat(left);\n  },\n  bottom: function bottom(_a, _b) {\n    var height = _a.height;\n    var top = _b.top;\n    return parseFloat(top) + height;\n  },\n  right: function right(_a, _b) {\n    var width = _a.width;\n    var left = _b.left;\n    return parseFloat(left) + width;\n  },\n  // Transform\n  x: getTranslateFromMatrix(4, 13),\n  y: getTranslateFromMatrix(5, 14)\n};\n\nvar convertChangedValueTypes = function convertChangedValueTypes(target, values, element, elementStyler, changedKeys) {\n  var originBbox = element.getBoundingClientRect();\n  var elementComputedStyle = getComputedStyle(element);\n  var display = elementComputedStyle.display,\n      top = elementComputedStyle.top,\n      left = elementComputedStyle.left,\n      bottom = elementComputedStyle.bottom,\n      right = elementComputedStyle.right,\n      transform = elementComputedStyle.transform;\n  var originComputedStyle = {\n    top: top,\n    left: left,\n    bottom: bottom,\n    right: right,\n    transform: transform\n  }; // If the element is currently set to display: \"none\", make it visible before\n  // measuring the target bounding box\n\n  if (display === \"none\") {\n    elementStyler.set(\"display\", target.display || \"block\");\n  } // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n\n\n  elementStyler.render();\n  var targetBbox = element.getBoundingClientRect();\n  changedKeys.forEach(function (key) {\n    // Restore styles to their **calculated computed style**, not their actual\n    // originally set style. This allows us to animate between equivalent pixel units.\n    var value = values.get(key);\n    setAndResetVelocity(value, positionalValues[key](originBbox, originComputedStyle));\n    target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n  });\n  return target;\n};\n\nvar checkAndConvertChangedValueTypes = function checkAndConvertChangedValueTypes(values, ref, target, transitionEnd) {\n  if (transitionEnd === void 0) {\n    transitionEnd = {};\n  }\n\n  target = __assign({}, target);\n  transitionEnd = __assign({}, transitionEnd);\n  var element = ref.current;\n  var elementStyler = styler(element);\n  var targetPositionalKeys = Object.keys(target).filter(isPositionalKey); // We want to remove any transform values that could affect the element's bounding box before\n  // it's measured. We'll reapply these later.\n\n  var removedTransformValues = [];\n  var hasAttemptedToRemoveTransformValues = false;\n  var changedValueTypeKeys = targetPositionalKeys.reduce(function (acc, key) {\n    var value = values.get(key);\n    if (!value) return acc;\n    var from = value.get();\n    var to = target[key];\n    var fromType = getDimensionValueType(from);\n    var toType; // TODO: The current implementation of this basically throws an error\n    // if you try and do value conversion via keyframes. There's probably\n    // a way of doing this but the performance implications would need greater scrutiny,\n    // as it'd be doing multiple resize-remeasure operations.\n\n    if (isKeyframesTarget(to)) {\n      var numKeyframes = to.length;\n\n      for (var i = to[0] === null ? 1 : 0; i < numKeyframes; i++) {\n        if (!toType) {\n          toType = getDimensionValueType(to[i]);\n          invariant(toType === fromType || isNumOrPxType(fromType) && isNumOrPxType(toType), \"Keyframes must be of the same dimension as the current value\");\n        } else {\n          invariant(getDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n        }\n      }\n    } else {\n      toType = getDimensionValueType(to);\n    }\n\n    if (fromType !== toType) {\n      // If they're both just number or px, convert them both to numbers rather than\n      // relying on resize/remeasure to convert (which is wasteful in this situation)\n      if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n        var current = value.get();\n\n        if (typeof current === \"string\") {\n          value.set(parseFloat(current));\n        }\n\n        if (typeof to === \"string\") {\n          target[key] = parseFloat(to);\n        } else if (Array.isArray(to) && toType === px) {\n          target[key] = to.map(parseFloat);\n        }\n      } else {\n        // If we're going to do value conversion via DOM measurements, we first\n        // need to remove non-positional transform values that could affect the bbox measurements.\n        if (!hasAttemptedToRemoveTransformValues) {\n          removedTransformValues = removeNonTranslationalTransform(values, elementStyler);\n          hasAttemptedToRemoveTransformValues = true;\n        }\n\n        acc.push(key);\n        transitionEnd[key] = transitionEnd[key] !== undefined ? transitionEnd[key] : target[key];\n        setAndResetVelocity(value, to);\n      }\n    }\n\n    return acc;\n  }, []);\n\n  if (changedValueTypeKeys.length) {\n    var convertedTarget = convertChangedValueTypes(target, values, element, elementStyler, changedValueTypeKeys); // If we removed transform values, reapply them before the next render\n\n    if (removedTransformValues.length) {\n      removedTransformValues.forEach(function (_a) {\n        var key = _a[0],\n            value = _a[1];\n        values.get(key).set(value);\n      });\n    } // Reapply original values\n\n\n    elementStyler.render();\n    return {\n      target: convertedTarget,\n      transitionEnd: transitionEnd\n    };\n  } else {\n    return {\n      target: target,\n      transitionEnd: transitionEnd\n    };\n  }\n};\n/**\r\n * Convert value types for x/y/width/height/top/left/bottom/right\r\n *\r\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\r\n *\r\n * @param values\r\n * @param ref\r\n * @param target\r\n * @param transitionEnd\r\n * @internal\r\n */\n\n\nfunction unitConversion(values, ref, target, transitionEnd) {\n  return hasPositionalKey(target) ? checkAndConvertChangedValueTypes(values, ref, target, transitionEnd) : {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\n\nvar parseDomVariant = function parseDomVariant(values, ref) {\n  return function (target, transitionEnd) {\n    var resolved = resolveCSSVariables(values, ref, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(values, ref, target, transitionEnd);\n  };\n};\n\nfunction useForceUpdate() {\n  var _a = useState(0),\n      forcedRenderCount = _a[0],\n      setForcedRenderCount = _a[1];\n\n  return useCallback(function () {\n    return setForcedRenderCount(forcedRenderCount + 1);\n  }, [forcedRenderCount]);\n}\n\nvar SyncLayoutContext = createContext(null);\n/**\r\n * When layout changes happen asynchronously to their instigating render (ie when exiting\r\n * children of `AnimatePresence` are removed), `SyncLayout` can wrap parent and sibling\r\n * components that need to animate as a result of this layout change.\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * const MyComponent = ({ isVisible }) => {\r\n *   return (\r\n *     <SyncLayout>\r\n *       <AnimatePresence>\r\n *         {isVisible && (\r\n *           <motion.div exit={{ opacity: 0 }} />\r\n *         )}\r\n *       </AnimatePresence>\r\n *       <motion.div positionTransition />\r\n *     </SyncLayout>\r\n *   )\r\n * }\r\n * ```\r\n *\r\n * @internalremarks\r\n *\r\n * The way this component works is by memoising a function and passing it down via context.\r\n * The function, when called, updates the local state, which is used to invalidate the\r\n * memoisation cache. A new function is called, performing a synced re-render of components\r\n * that are using the SyncLayoutContext.\r\n *\r\n * @internal\r\n */\n\nvar UnstableSyncLayout = function UnstableSyncLayout(_a) {\n  var children = _a.children;\n  var forceUpdate = useForceUpdate();\n  return createElement(SyncLayoutContext.Provider, {\n    value: forceUpdate\n  }, children);\n};\n\nvar _a;\n\nvar StepName;\n\n(function (StepName) {\n  StepName[\"Prepare\"] = \"prepare\";\n  StepName[\"Read\"] = \"read\";\n  StepName[\"Render\"] = \"render\";\n})(StepName || (StepName = {}));\n\nvar stepOrder = [StepName.Prepare, StepName.Read, StepName.Render];\nvar jobs = stepOrder.reduce(function (acc, key) {\n  acc[key] = [];\n  return acc;\n}, {});\nvar jobsNeedProcessing = false;\n\nfunction flushCallbackList(list) {\n  var numJobs = list.length;\n\n  for (var i = 0; i < numJobs; i++) {\n    list[i]();\n  }\n\n  list.length = 0;\n}\n\nfunction flushAllJobs() {\n  if (!jobsNeedProcessing) return;\n  flushCallbackList(jobs.prepare);\n  flushCallbackList(jobs.read);\n  flushCallbackList(jobs.render);\n  jobsNeedProcessing = false;\n} // Note: The approach of schedulng jobs during the render step is incompatible with concurrent mode\n// where multiple renders might happen without a DOM update. This would result in unneccessary batched\n// jobs. But this was already a problem with our previous approach to positionTransition.\n// Hopefully the React team offer a getSnapshotBeforeUpdate-esque hook and we can move to that.\n\n\nvar createUseSyncEffect = function createUseSyncEffect(stepName) {\n  return function (callback) {\n    if (!callback) return;\n    jobsNeedProcessing = true;\n    jobs[stepName].push(callback);\n  };\n};\n\nvar layoutSync = (_a = {}, _a[StepName.Prepare] = createUseSyncEffect(StepName.Prepare), _a[StepName.Read] = createUseSyncEffect(StepName.Read), _a[StepName.Render] = createUseSyncEffect(StepName.Render), _a.flush = flushAllJobs, _a);\n\nfunction isHTMLElement(element) {\n  return element instanceof HTMLElement;\n}\n\nvar defaultLayoutTransition = {\n  duration: 0.8,\n  ease: [0.45, 0.05, 0.19, 1.0]\n};\nvar defaultPositionTransition = underDampedSpring();\n\nfunction getDefaultLayoutTransition(isPositionOnly) {\n  return isPositionOnly ? defaultPositionTransition : defaultLayoutTransition;\n}\n\nfunction isResolver(transition) {\n  return typeof transition === \"function\";\n}\n\nvar axisLabels = {\n  x: {\n    id: \"x\",\n    size: \"width\",\n    min: \"left\",\n    max: \"right\",\n    origin: \"originX\"\n  },\n  y: {\n    id: \"y\",\n    size: \"height\",\n    min: \"top\",\n    max: \"bottom\",\n    origin: \"originY\"\n  }\n};\n\nfunction centerOf(min, max) {\n  return (min + max) / 2;\n}\n\nfunction calcAxisDelta(prev, next, names) {\n  var _a;\n\n  var sizeDelta = prev[names.size] - next[names.size];\n  var origin = 0.5; // If the element has changed size we want to check whether either side is in\n  // the same position before/after the layout transition. If so, we can anchor\n  // the element to that position and only animate its size.\n\n  if (sizeDelta) {\n    if (prev[names.min] === next[names.min]) {\n      origin = 0;\n    } else if (prev[names.max] === next[names.max]) {\n      origin = 1;\n    }\n  }\n\n  var delta = (_a = {}, _a[names.size] = sizeDelta, _a[names.origin] = origin, _a[names.id] = // Only measure a position delta if we haven't anchored to one side\n  origin === 0.5 ? centerOf(prev[names.min], prev[names.max]) - centerOf(next[names.min], next[names.max]) : 0, _a);\n  return delta;\n}\n\nfunction calcDelta(prev, next) {\n  var delta = __assign(__assign({}, calcAxisDelta(prev, next, axisLabels.x)), calcAxisDelta(prev, next, axisLabels.y));\n\n  return delta;\n}\n\nvar offset = {\n  getLayout: function getLayout(_a) {\n    var offset = _a.offset;\n    return offset;\n  },\n  measure: function measure(element) {\n    var offsetLeft = element.offsetLeft,\n        offsetTop = element.offsetTop,\n        offsetWidth = element.offsetWidth,\n        offsetHeight = element.offsetHeight;\n    return {\n      left: offsetLeft,\n      top: offsetTop,\n      right: offsetLeft + offsetWidth,\n      bottom: offsetTop + offsetHeight,\n      width: offsetWidth,\n      height: offsetHeight\n    };\n  }\n};\nvar boundingBox = {\n  getLayout: function getLayout(_a) {\n    var boundingBox = _a.boundingBox;\n    return boundingBox;\n  },\n  measure: function measure(element) {\n    var _a = element.getBoundingClientRect(),\n        left = _a.left,\n        top = _a.top,\n        width = _a.width,\n        height = _a.height,\n        right = _a.right,\n        bottom = _a.bottom;\n\n    return {\n      left: left,\n      top: top,\n      width: width,\n      height: height,\n      right: right,\n      bottom: bottom\n    };\n  }\n};\n\nfunction readPositionStyle(element) {\n  return window.getComputedStyle(element).position;\n}\n\nfunction getLayoutType(prev, next, isPositionOnly) {\n  return isPositionOnly && prev === next ? offset : boundingBox;\n}\n\nfunction isSizeKey(key) {\n  return key === \"width\" || key === \"height\";\n}\n\nfunction getTransition(_a) {\n  var layoutTransition = _a.layoutTransition,\n      positionTransition = _a.positionTransition;\n  return layoutTransition || positionTransition;\n}\n\nvar LayoutAnimation = function (_super) {\n  __extends(LayoutAnimation, _super);\n\n  function LayoutAnimation() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  } // Measure the current state of the DOM before it's updated, and schedule checks to see\n  // if it's changed as a result of a React render.\n\n\n  LayoutAnimation.prototype.getSnapshotBeforeUpdate = function () {\n    var _a = this.props,\n        innerRef = _a.innerRef,\n        positionTransition = _a.positionTransition,\n        values = _a.values,\n        controls = _a.controls;\n    var element = innerRef.current;\n    if (!isHTMLElement(element)) return;\n    var layoutTransition = getTransition(this.props);\n    var isPositionOnly = !!positionTransition;\n    var positionStyle = readPositionStyle(element);\n    var prev = {\n      offset: offset.measure(element),\n      boundingBox: boundingBox.measure(element)\n    };\n    var transform;\n    var next;\n    var compare; // We split the unsetting, read and reapplication of the `transform` style prop into\n    // different steps via useSyncEffect. Multiple components might all be doing the same\n    // thing and by splitting these jobs and flushing them in batches we prevent layout thrashing.\n\n    layoutSync.prepare(function () {\n      // Unset the transform of all layoutTransition components so we can accurately measure\n      // the target bounding box\n      transform = element.style.transform;\n      element.style.transform = \"\";\n    });\n    layoutSync.read(function () {\n      // Read the target VisualInfo of all layoutTransition components\n      next = {\n        offset: offset.measure(element),\n        boundingBox: boundingBox.measure(element)\n      };\n      var nextPosition = readPositionStyle(element);\n      compare = getLayoutType(positionStyle, nextPosition, isPositionOnly);\n    });\n    layoutSync.render(function () {\n      // Reverse the layout delta of all newly laid-out layoutTransition components into their\n      // prev visual state and then animate them into their new one using transforms.\n      var prevLayout = compare.getLayout(prev);\n      var nextLayout = compare.getLayout(next);\n      var delta = calcDelta(prevLayout, nextLayout);\n      var hasAnyChanged = delta.x || delta.y || delta.width || delta.height;\n\n      if (!hasAnyChanged) {\n        // If layout hasn't changed, reapply the transform and get out of here.\n        transform && (element.style.transform = transform);\n        return;\n      }\n\n      styler(element).set({\n        originX: delta.originX,\n        originY: delta.originY\n      });\n      syncRenderSession.open();\n      var target = {};\n      var transition = {};\n      var transitionDefinition = isResolver(layoutTransition) ? layoutTransition({\n        delta: delta\n      }) : layoutTransition;\n\n      function makeTransition(layoutKey, transformKey, targetValue, visualOrigin) {\n        // If this dimension hasn't changed, early return\n        var deltaKey = isSizeKey(layoutKey) ? layoutKey : transformKey;\n        if (!delta[deltaKey]) return;\n        var baseTransition = typeof transitionDefinition === \"boolean\" ? __assign({}, getDefaultLayoutTransition(isPositionOnly)) : transitionDefinition;\n        var value = values.get(transformKey, targetValue);\n        var velocity = value.getVelocity();\n        transition[transformKey] = baseTransition[transformKey] ? __assign({}, baseTransition[transformKey]) : __assign({}, baseTransition);\n\n        if (transition[transformKey].velocity === undefined) {\n          transition[transformKey].velocity = velocity || 0;\n        } // The target value of all transforms is the default value of that prop (ie x = 0, scaleX = 1)\n        // This is because we're inverting the layout change with `transform` and then animating to `transform: none`\n\n\n        target[transformKey] = targetValue;\n        var offsetToApply = !isSizeKey(layoutKey) && compare === offset ? value.get() : 0;\n        value.set(visualOrigin + offsetToApply);\n      }\n\n      makeTransition(\"left\", \"x\", 0, delta.x);\n      makeTransition(\"top\", \"y\", 0, delta.y);\n\n      if (!isPositionOnly) {\n        makeTransition(\"width\", \"scaleX\", 1, prev.boundingBox.width / next.boundingBox.width);\n        makeTransition(\"height\", \"scaleY\", 1, prev.boundingBox.height / next.boundingBox.height);\n      }\n\n      target.transition = transition; // Only start the transition if `transitionDefinition` isn't `false`. Otherwise we want\n      // to leave the values in their newly-inverted state and let the user cope with the rest.\n\n      transitionDefinition && controls.start(target); // Force a render to ensure there's no visual flickering\n\n      syncRenderSession.flush();\n    });\n    return null;\n  };\n\n  LayoutAnimation.prototype.componentDidUpdate = function () {\n    layoutSync.flush();\n  };\n\n  LayoutAnimation.prototype.render = function () {\n    return null;\n  };\n\n  LayoutAnimation.contextType = SyncLayoutContext;\n  return LayoutAnimation;\n}(Component);\n\nvar Layout = {\n  key: \"layout\",\n  shouldRender: function shouldRender(_a) {\n    var positionTransition = _a.positionTransition,\n        layoutTransition = _a.layoutTransition;\n    invariant(!(positionTransition && layoutTransition), \"Don't set both positionTransition and layoutTransition on the same component\");\n    return typeof window !== \"undefined\" && !!(positionTransition || layoutTransition);\n  },\n  Component: LayoutAnimation\n};\n/**\r\n * A list of all valid MotionProps\r\n *\r\n * @internalremarks\r\n * This doesn't throw if a `MotionProp` name is missing - it should.\r\n */\n\nvar validMotionProps = new Set([\"initial\", \"animate\", \"exit\", \"style\", \"variants\", \"transition\", \"transformTemplate\", \"transformValues\", \"custom\", \"inherit\", \"static\", \"positionTransition\", \"layoutTransition\", \"onAnimationStart\", \"onAnimationComplete\", \"onUpdate\", \"onDragStart\", \"onDrag\", \"onDragEnd\", \"onDirectionLock\", \"onDragTransitionEnd\", \"drag\", \"dragControls\", \"dragListener\", \"dragConstraints\", \"dragDirectionLock\", \"dragElastic\", \"dragMomentum\", \"dragPropagation\", \"dragTransition\", \"_dragValueX\", \"_dragValueY\", \"_dragTransitionControls\", \"dragOriginX\", \"dragOriginY\", \"onPan\", \"onPanStart\", \"onPanEnd\", \"onPanSessionStart\", \"onTap\", \"onTapStart\", \"onTapCancel\", \"whileHover\", \"whileTap\", \"onHoverEnd\", \"onHoverStart\"]);\n/**\r\n * Check whether a prop name is a valid `MotionProp` key.\r\n *\r\n * @param key - Name of the property to check\r\n * @returns `true` is key is a valid `MotionProp`.\r\n *\r\n * @public\r\n */\n\nfunction isValidMotionProp(key) {\n  return validMotionProps.has(key);\n}\n\nvar AnimatePropType;\n\n(function (AnimatePropType) {\n  AnimatePropType[\"Target\"] = \"Target\";\n  AnimatePropType[\"VariantLabel\"] = \"VariantLabel\";\n  AnimatePropType[\"AnimationSubscription\"] = \"AnimationSubscription\";\n})(AnimatePropType || (AnimatePropType = {}));\n\nfunction shallowCompare(next, prev) {\n  if (prev === null) return false;\n  var prevLength = prev.length;\n  if (prevLength !== next.length) return false;\n\n  for (var i = 0; i < prevLength; i++) {\n    if (prev[i] !== next[i]) return false;\n  }\n\n  return true;\n}\n\nvar hasUpdated = function hasUpdated(prev, next) {\n  return next !== undefined && (Array.isArray(prev) && Array.isArray(next) ? !shallowCompare(next, prev) : prev !== next);\n};\n\nfunction targetWithoutTransition(_a, mergeTransitionEnd) {\n  if (mergeTransitionEnd === void 0) {\n    mergeTransitionEnd = false;\n  }\n\n  var transition = _a.transition,\n      transitionEnd = _a.transitionEnd,\n      target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n\n  return mergeTransitionEnd ? __assign(__assign({}, target), transitionEnd) : target;\n}\n/**\r\n * Handle the `animate` prop when its an object of values, ie:\r\n *\r\n * ```jsx\r\n * <motion.div animate={{ opacity: 1 }} />\r\n * ```\r\n *\r\n * @internalremarks\r\n * It might be worth consolidating this with `use-variants`\r\n *\r\n * ```jsx\r\n * <motion.div animate=\"visible\" />\r\n * ```\r\n *\r\n * @param target\r\n * @param controls\r\n * @param values\r\n * @param transition\r\n *\r\n * @internal\r\n */\n\n\nfunction useAnimateProp(targetAndTransition, controls, values, defaultTransition) {\n  var isInitialRender = useRef(true);\n  var prevValues = useRef(null);\n\n  if (!prevValues.current) {\n    prevValues.current = targetWithoutTransition(targetAndTransition, true);\n  }\n\n  useEffect(function () {\n    var targetToAnimate = {}; // These are the values we're actually animating\n\n    var animatingTarget = targetWithoutTransition(targetAndTransition); // This is the target as it'll be once transitionEnd values are applied\n\n    var finalTarget = targetWithoutTransition(targetAndTransition, true); // Detect which values have changed between renders\n\n    for (var key in animatingTarget) {\n      // This value should animate on mount if this value doesn't already exist (wasn't\n      // defined in `style` or `initial`) or if it does exist and it's already changed.\n      var shouldAnimateOnMount = isInitialRender.current && (!values.has(key) || values.get(key).get() !== finalTarget[key]); // If this value has updated between renders or it's we're animating this value on mount,\n      // add it to the animate target.\n\n      var isValidValue = finalTarget[key] !== null;\n      var valueHasUpdated = hasUpdated(prevValues.current[key], finalTarget[key]);\n\n      if (isValidValue && (valueHasUpdated || shouldAnimateOnMount)) {\n        targetToAnimate[key] = animatingTarget[key];\n      }\n    }\n\n    isInitialRender.current = false;\n    prevValues.current = __assign(__assign({}, prevValues.current), finalTarget);\n\n    if (Object.keys(targetToAnimate).length) {\n      controls.start(__assign(__assign({}, targetToAnimate), {\n        transition: targetAndTransition.transition || defaultTransition,\n        transitionEnd: targetAndTransition.transitionEnd\n      }));\n    }\n  }, [targetAndTransition]);\n}\n\nvar labelsToArray = function labelsToArray(label) {\n  if (!label) {\n    return [];\n  }\n\n  if (Array.isArray(label)) {\n    return label;\n  }\n\n  return [label];\n};\n\nvar resolveVariantLabels = function resolveVariantLabels(variant) {\n  var unresolvedVariant = variant instanceof MotionValue ? variant.get() : variant;\n  return Array.from(new Set(labelsToArray(unresolvedVariant)));\n};\n/**\r\n * Hooks in React sometimes accept a dependency array as their final argument. (ie useEffect/useMemo)\r\n * When values in this array change, React re-runs the dependency. However if the array\r\n * contains a variable number of items, React throws an error.\r\n */\n\n\nvar asDependencyList = function asDependencyList(list) {\n  return [list.join(\",\")];\n};\n\nvar hasVariantChanged = function hasVariantChanged(oldVariant, newVariant) {\n  return oldVariant.join(\",\") !== newVariant.join(\",\");\n};\n/**\r\n * Handle variants and the `animate` prop when its set as variant labels.\r\n *\r\n * @param initial - Initial variant(s)\r\n * @param animate - Variant(s) to animate to\r\n * @param inherit - `true` is inheriting animations from parent\r\n * @param controls - Animation controls\r\n *\r\n * @internal\r\n */\n\n\nfunction useVariants(initial, animate, inherit, controls) {\n  var targetVariants = resolveVariantLabels(animate);\n  var context = useContext(MotionContext);\n  var parentAlreadyMounted = context.hasMounted && context.hasMounted.current;\n  var hasMounted = useRef(false);\n  useEffect(function () {\n    var shouldAnimate = false;\n\n    if (inherit) {\n      // If we're inheriting variant changes and the parent has already\n      // mounted when this component loads, we need to manually trigger\n      // this animation.\n      shouldAnimate = !!parentAlreadyMounted;\n      targetVariants = resolveVariantLabels(context.animate);\n    } else {\n      shouldAnimate = hasMounted.current || hasVariantChanged(resolveVariantLabels(initial), targetVariants);\n    }\n\n    shouldAnimate && controls.start(targetVariants);\n    hasMounted.current = true;\n  }, asDependencyList(targetVariants));\n}\n/**\r\n * `useAnimationGroupSubscription` allows a component to subscribe to an\r\n * externally-created `AnimationControls`, created by the `useAnimation` hook.\r\n *\r\n * @param animation\r\n * @param controls\r\n *\r\n * @internal\r\n */\n\n\nfunction useAnimationGroupSubscription(animation, controls) {\n  var unsubscribe = useMemo(function () {\n    return animation.subscribe(controls);\n  }, [animation]);\n  useEffect(function () {\n    return function () {\n      unsubscribe && unsubscribe();\n    };\n  }, [unsubscribe]);\n}\n\nvar _a$1, _b;\n\nvar AnimatePropComponents = (_a$1 = {}, _a$1[AnimatePropType.Target] = makeRenderlessComponent(function (_a) {\n  var animate = _a.animate,\n      controls = _a.controls,\n      values = _a.values,\n      transition = _a.transition;\n  return useAnimateProp(animate, controls, values, transition);\n}), _a$1[AnimatePropType.VariantLabel] = makeRenderlessComponent(function (_a) {\n  var animate = _a.animate,\n      _b = _a.inherit,\n      inherit = _b === void 0 ? true : _b,\n      controls = _a.controls,\n      initial = _a.initial;\n  return useVariants(initial, animate, inherit, controls);\n}), _a$1[AnimatePropType.AnimationSubscription] = makeRenderlessComponent(function (_a) {\n  var animate = _a.animate,\n      controls = _a.controls;\n  return useAnimationGroupSubscription(animate, controls);\n}), _a$1);\n\nvar isVariantLabel$1 = function isVariantLabel$1(prop) {\n  return Array.isArray(prop) || typeof prop === \"string\";\n};\n\nvar isAnimationSubscription = function isAnimationSubscription(_a) {\n  var animate = _a.animate;\n  return animate instanceof AnimationControls;\n};\n\nvar animationProps = [\"initial\", \"animate\", \"whileTap\", \"whileHover\"];\nvar animatePropTypeTests = (_b = {}, _b[AnimatePropType.Target] = function (props) {\n  return props.animate !== undefined && !isVariantLabel$1(props.animate) && !isAnimationSubscription(props);\n}, _b[AnimatePropType.VariantLabel] = function (props) {\n  return props.variants !== undefined || animationProps.some(function (key) {\n    return typeof props[key] === \"string\";\n  });\n}, _b[AnimatePropType.AnimationSubscription] = isAnimationSubscription, _b);\n\nvar getAnimationComponent = function getAnimationComponent(props) {\n  var animatePropType = undefined;\n\n  for (var key in AnimatePropType) {\n    if (animatePropTypeTests[key](props)) {\n      animatePropType = key;\n    }\n  }\n\n  return animatePropType ? AnimatePropComponents[animatePropType] : undefined;\n};\n\nvar Exit = {\n  key: \"exit\",\n  shouldRender: function shouldRender(_a, _b) {\n    var exit = _a.exit;\n    var exitProps = _b.exitProps;\n    var hasExitProps = !!exitProps;\n    var hasExitAnimation = !!exit;\n    invariant(!hasExitProps || hasExitProps && hasExitAnimation, \"No exit prop defined on a child of AnimatePresence.\");\n    return hasExitProps && hasExitAnimation;\n  },\n  Component: makeRenderlessComponent(function (props) {\n    var animate = props.animate,\n        controls = props.controls,\n        parentContext = props.parentContext,\n        exit = props.exit;\n    var exitProps = parentContext.exitProps;\n    var isPlayingExitAnimation = useRef(false); // This early return is more for types - it won't actually run because of the `shouldRender` above.\n\n    if (!exitProps || !exit) return;\n    var isExiting = exitProps.isExiting,\n        custom = exitProps.custom,\n        onExitComplete = exitProps.onExitComplete;\n    useEffect(function () {\n      if (isExiting) {\n        if (!isPlayingExitAnimation.current && exit) {\n          controls.setProps(__assign(__assign({}, props), {\n            custom: custom !== undefined ? custom : props.custom\n          }));\n          controls.start(exit).then(onExitComplete);\n        }\n\n        isPlayingExitAnimation.current = true;\n      } else if (isPlayingExitAnimation.current && animate && !(animate instanceof AnimationControls)) {\n        controls.start(animate);\n      }\n\n      if (!isExiting) {\n        isPlayingExitAnimation.current = false;\n      }\n    }, [isExiting]);\n  })\n};\n\nvar isPropValid = function isPropValid(key) {\n  return !isValidMotionProp(key);\n};\n/**\r\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\r\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\r\n * of these should be passed to the underlying DOM node.\r\n *\r\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\r\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\r\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\r\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\r\n *\r\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\r\n * actually required.\r\n */\n\n\ntry {\n  var emotionIsPropValid_1 = require(\"@emotion/is-prop-valid\").default;\n\n  isPropValid = function isPropValid(key) {\n    // Handle events explicitly as Emotion validates them all as true\n    if (key.startsWith(\"on\")) {\n      return !isValidMotionProp(key);\n    } else {\n      return emotionIsPropValid_1(key);\n    }\n  };\n} catch (_a) {// We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\n\nfunction filterValidProps(props) {\n  var domProps = {};\n\n  for (var key in props) {\n    if (isPropValid(key)) {\n      domProps[key] = props[key];\n    }\n  }\n\n  return domProps;\n}\n\nvar buildSVGProps = function buildSVGProps(values, style) {\n  var motionValueStyles = resolveCurrent(values);\n  var props = buildSVGAttrs(motionValueStyles, undefined, undefined, undefined, undefined, false);\n  props.style = __assign(__assign({}, style), props.style);\n  return props;\n};\n\nvar functionalityComponents = [Layout, Drag, Gestures, Exit];\nvar numFunctionalityComponents = functionalityComponents.length;\n/**\r\n * Create a configuration for `motion` components that provides DOM-specific functionality.\r\n *\r\n * @internal\r\n */\n\nfunction createDomMotionConfig(Component) {\n  var isDOM = typeof Component === \"string\";\n  var isSVG = isDOM && svgElements.indexOf(Component) !== -1;\n  return {\n    renderComponent: function renderComponent(ref, style, values, props, isStatic) {\n      var forwardedProps = isDOM ? filterValidProps(props) : props;\n      var staticVisualStyles = isSVG ? buildSVGProps(values, style) : {\n        style: buildStyleAttr(values, style, isStatic)\n      };\n      return createElement(Component, __assign(__assign(__assign({}, forwardedProps), {\n        ref: ref\n      }), staticVisualStyles));\n    },\n\n    /**\r\n     * loadFunctionalityComponents gets used by the `motion` component\r\n     *\r\n     * Each functionality component gets provided the `ref`, animation controls and the `MotionValuesMap`\r\n     * generated for that component, as well as all the `props` passed to it by the user.\r\n     *\r\n     * The pattern used to determine whether to load and use each piece of functionality is\r\n     * consistent (should render? Then push component) and could be used to extend functionality.\r\n     *\r\n     * By exposing a mutable piece of memory via an API like `extendMotionComponent` we could\r\n     * allow users to add `FunctionalComponentDefinition`s. This would allow us to offer file size\r\n     * reductions by shipping an entry point that doesn't load gesture and drag functionality, and\r\n     * also offer a way for users to develop plugins/other functionality. Because these functionalities\r\n     * are loaded as components, we can look into using Suspense for this purpose.\r\n     *\r\n     * For user-defined functionality we'd need to allow\r\n     *  1) User-defined prop typing (extending `P`)\r\n     *  2) User-defined \"clean props\" function that removes their plugin's props before being passed to the DOM.\r\n     */\n    loadFunctionalityComponents: function loadFunctionalityComponents(ref, values, props, context, controls, inherit) {\n      var activeComponents = []; // TODO: Consolidate Animation functionality loading strategy with other functionality components\n\n      var Animation = getAnimationComponent(props);\n\n      if (Animation) {\n        activeComponents.push(createElement(Animation, {\n          key: \"animation\",\n          initial: props.initial,\n          animate: props.animate,\n          variants: props.variants,\n          transition: props.transition,\n          controls: controls,\n          inherit: inherit,\n          values: values\n        }));\n      }\n\n      for (var i = 0; i < numFunctionalityComponents; i++) {\n        var _a = functionalityComponents[i],\n            shouldRender = _a.shouldRender,\n            key = _a.key,\n            Component_1 = _a.Component;\n\n        if (shouldRender(props, context)) {\n          activeComponents.push(createElement(Component_1, __assign({\n            key: key\n          }, props, {\n            parentContext: context,\n            values: values,\n            controls: controls,\n            innerRef: ref\n          })));\n        }\n      }\n\n      return activeComponents;\n    },\n    getValueControlsConfig: function getValueControlsConfig(ref, values) {\n      return {\n        values: values,\n        readValueFromSource: function readValueFromSource(key) {\n          return styler(ref.current).get(key);\n        },\n        // TODO: This is a good second source of plugins. This function contains the CSS variable\n        // and unit conversion support. These functions share a common signature. We could make another\n        // API for adding these.\n        makeTargetAnimatable: parseDomVariant(values, ref)\n      };\n    }\n  };\n}\n\nvar htmlMotionComponents = htmlElements.reduce(function (acc, Component) {\n  var config = createDomMotionConfig(Component); // Suppress \"Expression produces a union type that is too complex to represent\" error\n  // @ts-ignore\n\n  acc[Component] = createMotionComponent(config);\n  return acc;\n}, {});\nvar svgMotionComponents = svgElements.reduce(function (acc, Component) {\n  // Suppress \"Expression produces a union type that is too complex to represent\" error\n  // @ts-ignore\n  acc[Component] = createMotionComponent(createDomMotionConfig(Component));\n  return acc;\n}, {});\n/**\r\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\r\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\r\n *\r\n * @internalremarks\r\n *\r\n * I'd like to make it possible for these to be loaded \"on demand\" - to reduce bundle size by only\r\n * including HTML/SVG stylers, animation and/or gesture support when necessary.\r\n *\r\n * ```jsx\r\n * <motion.div animate={{ x: 100 }} />\r\n *\r\n * <motion.p animate={{ height: 200 }} />\r\n *\r\n * <svg><motion.circle r={10} animate={{ r: 20 }} /></svg>\r\n * ```\r\n *\r\n * @public\r\n */\n\nvar motion = __assign(__assign({\n  /**\r\n   * Convert a custom React component into a `motion` component.\r\n   *\r\n   * It can also accept a string, to create [custom DOM elements](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements).\r\n   *\r\n   * ```jsx\r\n   * const Component = React.forwardRef((props: Props, ref) => {\r\n   *   return <div ref={ref} />\r\n   * })\r\n   *\r\n   * const MotionComponent = motion.custom<Props>(Component)\r\n   * ```\r\n   *\r\n   * @param Component -\r\n   */\n  custom: function custom(Component) {\n    return createMotionComponent(createDomMotionConfig(Component));\n  }\n}, htmlMotionComponents), svgMotionComponents);\n/**\r\n * Creates a `MotionValue` to track the state and velocity of a value.\r\n *\r\n * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * export function MyComponent() {\r\n *   const scale = useMotionValue(1)\r\n *\r\n *   return <Frame scale={scale} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * export const MyComponent = () => {\r\n *   const scale = useMotionValue(1)\r\n *\r\n *   return <motion.div style={{ scale }} />\r\n * }\r\n * ```\r\n *\r\n * @param initial - The initial state.\r\n *\r\n * @public\r\n */\n\n\nfunction useMotionValue(initial) {\n  return useConstant(function () {\n    return motionValue(initial);\n  });\n}\n/**\r\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\r\n *\r\n * TODO: Remove and move to library\r\n *\r\n * @internal\r\n */\n\n\nfunction unwrapMotionValue(value) {\n  var unwrappedValue = value instanceof MotionValue ? value.get() : value;\n  return isCustomValue(unwrappedValue) ? unwrappedValue.toValue() : unwrappedValue;\n}\n\nvar isCustomValueType = function isCustomValueType(v) {\n  return typeof v === \"object\" && v.mix;\n};\n\nvar getMixer = function getMixer(v) {\n  return isCustomValueType(v) ? v.mix : undefined;\n};\n\nfunction transform() {\n  var args = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    args[_i] = arguments[_i];\n  }\n\n  var useImmediate = !Array.isArray(args[0]);\n  var argOffset = useImmediate ? 0 : -1;\n  var inputValue = args[0 + argOffset];\n  var inputRange = args[1 + argOffset];\n  var outputRange = args[2 + argOffset];\n  var options = args[3 + argOffset];\n  var interpolator = interpolate(inputRange, outputRange, __assign({\n    mixer: getMixer(outputRange[0])\n  }, options));\n  return useImmediate ? interpolator(inputValue) : interpolator;\n}\n\nvar isTransformer = function isTransformer(v) {\n  return typeof v === \"function\";\n};\n\nvar noop$1 = function noop$1(v) {\n  return v;\n};\n\nfunction useTransform(parent, customTransform, to, options) {\n  var value = useRef(null);\n  var comparitor = [parent];\n  var transformer = noop$1;\n\n  if (isTransformer(customTransform)) {\n    transformer = customTransform;\n  } else if (Array.isArray(to)) {\n    var from = customTransform;\n    transformer = transform(from, to, options);\n    comparitor = [parent, from.join(\",\"), to.join(\",\")];\n  }\n\n  return useMemo(function () {\n    if (value.current) value.current.destroy();\n    value.current = parent.addChild({\n      transformer: transformer\n    });\n    return value.current;\n  }, comparitor);\n} // Keep things reasonable and avoid scale: Infinity. In practise we might need\n// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]\n// to simply hide content at unreasonable scales.\n\n\nvar maxScale = 100000;\n\nvar invertScale = function invertScale(scale) {\n  return scale > 0.001 ? 1 / scale : maxScale;\n};\n/**\r\n * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse\r\n * of their respective parent scales.\r\n *\r\n * This is useful for undoing the distortion of content when scaling a parent component.\r\n *\r\n * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.\r\n * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output\r\n * of those instead.\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * const MyComponent = () => {\r\n *   const { scaleX, scaleY } = useInvertedScale()\r\n *   return <motion.div style={{ scaleX, scaleY }} />\r\n * }\r\n * ```\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * function MyComponent() {\r\n *   const { scaleX, scaleY } = useInvertedScale()\r\n *   return <Frame scaleX={scaleX} scaleY={scaleY} />\r\n * }\r\n * ```\r\n *\r\n * @public\r\n */\n\n\nfunction useInvertedScale(scale) {\n  var parentScaleX = useMotionValue(1);\n  var parentScaleY = useMotionValue(1);\n  var values = useContext(MotionContext).values;\n  invariant(!!(scale || values), \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\");\n\n  if (scale) {\n    parentScaleX = scale.scaleX || parentScaleX;\n    parentScaleY = scale.scaleY || parentScaleY;\n  } else if (values) {\n    parentScaleX = values.get(\"scaleX\", 1);\n    parentScaleY = values.get(\"scaleY\", 1);\n  }\n\n  var scaleX = useTransform(parentScaleX, invertScale);\n  var scaleY = useTransform(parentScaleY, invertScale);\n  return {\n    scaleX: scaleX,\n    scaleY: scaleY\n  };\n}\n\nfunction useOnChange(value, callback) {\n  useEffect(function () {\n    return isMotionValue(value) ? value.onChange(callback) : undefined;\n  }, [value]);\n}\n/**\r\n * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.\r\n *\r\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\r\n * to another `MotionValue`.\r\n *\r\n * @remarks\r\n *\r\n * ```jsx\r\n * const x = useSpring(0, { stiffness: 300 })\r\n * const y = useSpring(x, { damping: 10 })\r\n * ```\r\n *\r\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.\r\n * @param springConfig - Configuration options for the spring.\r\n * @returns `MotionValue`\r\n *\r\n * @public\r\n */\n\n\nfunction useSpring(source, config) {\n  if (config === void 0) {\n    config = {};\n  }\n\n  var activeSpringAnimation = useRef(null);\n  var value = useMotionValue(isMotionValue(source) ? source.get() : source);\n  useMemo(function () {\n    return value.attach(function (v, set) {\n      if (activeSpringAnimation.current) {\n        activeSpringAnimation.current.stop();\n      }\n\n      activeSpringAnimation.current = spring(__assign({\n        from: value.get(),\n        to: v,\n        velocity: value.getVelocity()\n      }, config)).start(set);\n      return value.get();\n    });\n  }, Object.values(config));\n  useOnChange(source, function (v) {\n    return value.set(parseFloat(v));\n  });\n  return value;\n}\n\nvar scrollX = motionValue(0);\nvar scrollY = motionValue(0);\nvar scrollXProgress = motionValue(0);\nvar scrollYProgress = motionValue(0);\n\nvar setProgress = function setProgress(offset, maxOffset, value) {\n  value.set(!maxOffset || !offset ? 0 : offset / maxOffset);\n};\n\nvar hasEventListener = false;\n\nvar addScrollListener = function addScrollListener() {\n  hasEventListener = true;\n  if (typeof window === \"undefined\") return;\n\n  var updateScrollValues = function updateScrollValues() {\n    var xOffset = window.pageXOffset;\n    var yOffset = window.pageYOffset; // Set absolute positions\n\n    scrollX.set(xOffset);\n    scrollY.set(yOffset); // Set 0-1 progress\n\n    setProgress(xOffset, document.body.clientWidth - window.innerWidth, scrollXProgress);\n    setProgress(yOffset, document.body.clientHeight - window.innerHeight, scrollYProgress);\n  };\n\n  updateScrollValues();\n  window.addEventListener(\"resize\", updateScrollValues);\n  window.addEventListener(\"scroll\", updateScrollValues, {\n    passive: true\n  });\n};\n\nvar viewportMotionValues = {\n  scrollX: scrollX,\n  scrollY: scrollY,\n  scrollXProgress: scrollXProgress,\n  scrollYProgress: scrollYProgress\n};\n/**\r\n * Provides `MotionValue`s that update when the viewport scrolls:\r\n *\r\n * - `scrollX` — Horizontal scroll distance in pixels.\r\n * - `scrollY` — Vertical scroll distance in pixels.\r\n * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.\r\n * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.\r\n *\r\n * **Note:** If the returned scroll `MotionValue`s don't seem to be updating,\r\n * double check if the `body` tag styles are set to `width: 100%; height: 100%` or\r\n * similar, as this can break accurate measurement of viewport scroll.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import {\r\n *   Frame,\r\n *   useViewportScroll,\r\n *   useTransform\r\n * } from \"framer\"\r\n *\r\n * export function MyComponent() {\r\n *   const { scrollYProgress } = useViewportScroll()\r\n *   return <Frame scaleX={scrollYProgress} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * export const MyComponent = () => {\r\n *   const { scrollYProgress } = useViewportScroll()\r\n *   return <motion.div style={{ scaleX: scrollYProgress }} />\r\n * }\r\n * ```\r\n *\r\n * @internalremarks\r\n * This isn't technically a hook yet, but in the future it might be nice\r\n * to accept refs to elements and add scroll listeners to those, which\r\n * may involve the use of lifecycle.\r\n *\r\n * @public\r\n */\n\nfunction useViewportScroll() {\n  if (!hasEventListener) {\n    addScrollListener();\n  }\n\n  return viewportMotionValues;\n}\n/**\r\n * Creates `AnimationControls`, which can be used to manually start, stop\r\n * and sequence animations on one or more components.\r\n *\r\n * The returned `AnimationControls` should be passed to the `animate` property\r\n * of the components you want to animate.\r\n *\r\n * These components can then be animated with the `start` method.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from 'react'\r\n * import { Frame, useAnimation } from 'framer'\r\n *\r\n * export function MyComponent(props) {\r\n *    const controls = useAnimation()\r\n *\r\n *    controls.start({\r\n *        x: 100,\r\n *        transition: { duration: 0.5 },\r\n *    })\r\n *\r\n *    return <Frame animate={controls} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * import * as React from 'react'\r\n * import { motion, useAnimation } from 'framer-motion'\r\n *\r\n * export function MyComponent(props) {\r\n *    const controls = useAnimation()\r\n *\r\n *    controls.start({\r\n *        x: 100,\r\n *        transition: { duration: 0.5 },\r\n *    })\r\n *\r\n *    return <motion.div animate={controls} />\r\n * }\r\n * ```\r\n *\r\n * @returns Animation controller with `start` and `stop` methods\r\n *\r\n * @public\r\n */\n\n\nfunction useAnimation() {\n  var animationControls = useConstant(function () {\n    return new AnimationControls();\n  });\n  useEffect(function () {\n    animationControls.mount();\n    return function () {\n      return animationControls.unmount();\n    };\n  }, []);\n  return animationControls;\n}\n/**\r\n * Experimental API.\r\n *\r\n * Makes an animated version of `useState`.\r\n *\r\n * @remarks\r\n *\r\n * When the returned state setter is called, values will be animated to their new target.\r\n *\r\n * This allows the animation of arbitrary React components.\r\n *\r\n * **Note:** When animating DOM components, it's always preferable to use the `animate` prop, as Framer\r\n * will bypass React's rendering cycle with one optimised for 60fps motion. This Hook is specifically\r\n * for animating props on arbitrary React components, or for animating text content.\r\n *\r\n * ```jsx\r\n * const [state, setState] = useAnimatedState({ percentage: 0 })\r\n *\r\n * return (\r\n *   <Graph\r\n *     percentage={state.percentage}\r\n *     onTap={() => setState({ percentage: 50 })}\r\n *   />\r\n * )\r\n * ```\r\n *\r\n * @internalremarks\r\n *\r\n * TODO:\r\n * - Make hook accept a typed version of Target that accepts any value (not just DOM values)\r\n * - Allow hook to accept single values. ie useAnimatedState(0)\r\n * - Allow providing MotionValues via initialState.\r\n *\r\n * @beta\r\n */\n\n\nfunction useAnimatedState(initialState) {\n  var _a = useState(initialState),\n      animationState = _a[0],\n      onUpdate = _a[1];\n\n  var config = useConstant(function () {\n    return {\n      onUpdate: onUpdate\n    };\n  });\n  var values = useMotionValues(config);\n  var controls = useValueAnimationControls({\n    values: values,\n    readValueFromSource: function readValueFromSource(key) {\n      return animationState[key];\n    }\n  }, {}, false);\n  var startAnimation = useConstant(function () {\n    return function (animationDefinition) {\n      return controls.start(animationDefinition);\n    };\n  });\n  useEffect(function () {\n    values.mount();\n    return function () {\n      return values.unmount();\n    };\n  }, []);\n  return [animationState, startAnimation];\n}\n/**\r\n * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import { Frame, useCycle } from \"framer\"\r\n *\r\n * export function MyComponent() {\r\n *   const [x, cycleX] = useCycle(0, 50, 100)\r\n *\r\n *   return (\r\n *     <Frame\r\n *       animate={{ x: x }}\r\n *       onTap={() => cycleX()}\r\n *      />\r\n *    )\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * An index value can be passed to the returned `cycle` function to cycle to a specific index.\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import { motion, useCycle } from \"framer-motion\"\r\n *\r\n * export const MyComponent = () => {\r\n *   const [x, cycleX] = useCycle(0, 50, 100)\r\n *\r\n *   return (\r\n *     <motion.div\r\n *       animate={{ x: x }}\r\n *       onTap={() => cycleX()}\r\n *      />\r\n *    )\r\n * }\r\n * ```\r\n *\r\n * @param items - items to cycle through\r\n * @returns [currentState, cycleState]\r\n *\r\n * @public\r\n */\n\n\nfunction useCycle() {\n  var items = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    items[_i] = arguments[_i];\n  } // TODO: After Framer X beta, remove this warning\n\n\n  warning(items.length > 1, \"useCycle syntax has changed. `useCycle([0, 1, 2])` becomes `useCycle(0, 1, 2)`\");\n  var index = useRef(0);\n\n  var _a = useState(items[index.current]),\n      item = _a[0],\n      setItem = _a[1];\n\n  return [item, function (next) {\n    index.current = typeof next !== \"number\" ? wrap(0, items.length, index.current + 1) : next;\n    setItem(items[index.current]);\n  }];\n}\n/**\r\n * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * const dragControls = useDragControls()\r\n *\r\n * function startDrag(event) {\r\n *   dragControls.start(event, { snapToCursor: true })\r\n * }\r\n *\r\n * return (\r\n *   <>\r\n *     <Frame onTapStart={startDrag} />\r\n *     <Frame drag=\"x\" dragControls={dragControls} />\r\n *   </>\r\n * )\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * const dragControls = useDragControls()\r\n *\r\n * function startDrag(event) {\r\n *   dragControls.start(event, { snapToCursor: true })\r\n * }\r\n *\r\n * return (\r\n *   <>\r\n *     <div onMouseDown={startDrag} />\r\n *     <motion.div drag=\"x\" dragControls={dragControls} />\r\n *   </>\r\n * )\r\n * ```\r\n *\r\n * @public\r\n */\n\n\nvar DragControls = function () {\n  function DragControls() {\n    this.componentControls = new Set();\n  }\n  /**\r\n   * Subscribe a component's internal `ComponentDragControls` to the user-facing API.\r\n   *\r\n   * @internal\r\n   */\n\n\n  DragControls.prototype.subscribe = function (controls) {\n    var _this = this;\n\n    this.componentControls.add(controls);\n    return function () {\n      return _this.componentControls.delete(controls);\n    };\n  };\n  /**\r\n   * Start a drag gesture on every `motion` component that has this set of drag controls\r\n   * passed into it via the `dragControls` prop.\r\n   *\r\n   * ```jsx\r\n   * dragControls.start(e, {\r\n   *   snapToCursor: true\r\n   * })\r\n   * ```\r\n   *\r\n   * @param event - A mouse/touch/pointer event.\r\n   * @param options - Options\r\n   *\r\n   * @public\r\n   */\n\n\n  DragControls.prototype.start = function (event, options) {\n    this.componentControls.forEach(function (controls) {\n      controls.start(event.nativeEvent || event, options);\n    });\n  };\n\n  return DragControls;\n}();\n\nvar createDragControls = function createDragControls() {\n  return new DragControls();\n};\n/**\r\n * Usually, dragging is initiated by pressing down on a `motion` component with a `drag` prop\r\n * and moving it. For some use-cases, for instance clicking at an arbitrary point on a video scrubber, we\r\n * might want to initiate that dragging from a different component than the draggable one.\r\n *\r\n * By creating a `dragControls` using the `useDragControls` hook, we can pass this into\r\n * the draggable component's `dragControls` prop. It exposes a `start` method\r\n * that can start dragging from pointer events on other components.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * const dragControls = useDragControls()\r\n *\r\n * function startDrag(event) {\r\n *   dragControls.start(event, { snapToCursor: true })\r\n * }\r\n *\r\n * return (\r\n *   <>\r\n *     <Frame onTapStart={startDrag} />\r\n *     <Frame drag=\"x\" dragControls={dragControls} />\r\n *   </>\r\n * )\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * const dragControls = useDragControls()\r\n *\r\n * function startDrag(event) {\r\n *   dragControls.start(event, { snapToCursor: true })\r\n * }\r\n *\r\n * return (\r\n *   <>\r\n *     <div onMouseDown={startDrag} />\r\n *     <motion.div drag=\"x\" dragControls={dragControls} />\r\n *   </>\r\n * )\r\n * ```\r\n *\r\n * @public\r\n */\n\n\nfunction useDragControls() {\n  return useConstant(createDragControls);\n}\n\nvar PresenceChild = function PresenceChild(_a) {\n  var children = _a.children,\n      exitProps = _a.exitProps;\n  var context = useContext(MotionContext); // Create a new `value` in all instances to ensure `motion` children re-render\n  // and detect any layout changes that might have occurred.\n\n  context = __assign(__assign({}, context), {\n    exitProps: exitProps || {}\n  });\n  return createElement(MotionContext.Provider, {\n    value: context\n  }, children);\n};\n\nfunction getChildKey(child) {\n  return child.key || \"\";\n}\n\nfunction updateChildLookup(children, allChildren) {\n  var seenChildren = process.env.NODE_ENV !== \"production\" ? new Set() : null;\n  children.forEach(function (child) {\n    var key = getChildKey(child);\n\n    if (process.env.NODE_ENV !== \"production\" && seenChildren) {\n      if (seenChildren.has(key)) {\n        console.warn(\"Children of AnimatePresence require unique keys. \\\"\" + key + \"\\\" is a duplicate.\");\n      }\n\n      seenChildren.add(key);\n    }\n\n    allChildren.set(key, child);\n  });\n}\n\nfunction onlyElements(children) {\n  var filtered = []; // We use forEach here instead of map as map mutates the component key by preprending `.$`\n\n  Children.forEach(children, function (child) {\n    if (isValidElement(child)) filtered.push(child);\n  });\n  return filtered;\n}\n/**\r\n * The `AnimatePresence` component enables the use of the `exit` prop to animate components\r\n * when they're removed from the component tree.\r\n *\r\n * When adding/removing more than a single child component, every component\r\n * **must** be given a unique `key` prop.\r\n *\r\n * You can propagate exit animations throughout a tree by using variants.\r\n *\r\n * @library\r\n *\r\n * You can use any component(s) within `AnimatePresence`, but the first `Frame` in each should\r\n * have an `exit` property defined.\r\n *\r\n * ```jsx\r\n * import { Frame, AnimatePresence } from 'framer'\r\n *\r\n * // As items are added and removed from `items`\r\n * export function Items({ items }) {\r\n *   return (\r\n *     <AnimatePresence>\r\n *       {items.map(item => (\r\n *         <Frame\r\n *           key={item.id}\r\n *           initial={{ opacity: 0 }}\r\n *           animate={{ opacity: 1 }}\r\n *           exit={{ opacity: 0 }}\r\n *         />\r\n *       ))}\r\n *     </AnimatePresence>\r\n *   )\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * You can use any component(s) within `AnimatePresence`, but the first `motion` component in each should\r\n * have an `exit` property defined.\r\n *\r\n * ```jsx\r\n * import { motion, AnimatePresence } from 'framer-motion'\r\n *\r\n * export const Items = ({ items }) => (\r\n *   <AnimatePresence>\r\n *     {items.map(item => (\r\n *       <motion.div\r\n *         key={item.id}\r\n *         initial={{ opacity: 0 }}\r\n *         animate={{ opacity: 1 }}\r\n *         exit={{ opacity: 0 }}\r\n *       />\r\n *     ))}\r\n *   </AnimatePresence>\r\n * )\r\n * ```\r\n *\r\n * @public\r\n */\n\n\nvar AnimatePresence = function AnimatePresence(_a) {\n  var children = _a.children,\n      custom = _a.custom,\n      _b = _a.initial,\n      initial = _b === void 0 ? true : _b,\n      onExitComplete = _a.onExitComplete,\n      exitBeforeEnter = _a.exitBeforeEnter; // We want to force a re-render once all exiting animations have finished. We\n  // either use a local forceUpdate function, or one from a parent context if it exists.\n\n  var localForceUpdate = useForceUpdate();\n  var contextForceUpdate = useContext(SyncLayoutContext);\n  var forceUpdate = contextForceUpdate || localForceUpdate;\n  var isInitialRender = useRef(true); // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n\n  var filteredChildren = onlyElements(children); // Keep a living record of the children we're actually rendering so we\n  // can diff to figure out which are entering and exiting\n\n  var presentChildren = useRef(filteredChildren); // A lookup table to quickly reference components by key\n\n  var allChildren = useRef(new Map()).current; // A living record of all currently exiting components.\n\n  var exiting = useRef(new Set()).current;\n  updateChildLookup(filteredChildren, allChildren); // If this is the initial component render, just deal with logic surrounding whether\n  // we play onMount animations or not.\n\n  if (isInitialRender.current) {\n    isInitialRender.current = false;\n    return createElement(Fragment, null, filteredChildren.map(function (child) {\n      return createElement(PresenceChild, {\n        key: getChildKey(child),\n        exitProps: initial ? undefined : {\n          initial: false\n        }\n      }, child);\n    }));\n  } // If this is a subsequent render, deal with entering and exiting children\n\n\n  var childrenToRender = __spreadArrays(filteredChildren); // Diff the keys of the currently-present and target children to update our\n  // exiting list.\n\n\n  var presentKeys = presentChildren.current.map(getChildKey);\n  var targetKeys = filteredChildren.map(getChildKey); // Diff the present children with our target children and mark those that are exiting\n\n  var numPresent = presentKeys.length;\n\n  for (var i = 0; i < numPresent; i++) {\n    var key = presentKeys[i];\n\n    if (targetKeys.indexOf(key) === -1) {\n      exiting.add(key);\n    } else {\n      // In case this key has re-entered, remove from the exiting list\n      exiting.delete(key);\n    }\n  } // If we currently have exiting children, and we're deferring rendering incoming children\n  // until after all current children have exiting, empty the childrenToRender array\n\n\n  if (exitBeforeEnter && exiting.size) {\n    childrenToRender = [];\n  } // Loop through all currently exiting components and clone them to overwrite `animate`\n  // with any `exit` prop they might have defined.\n\n\n  exiting.forEach(function (key) {\n    // If this component is actually entering again, early return\n    if (targetKeys.indexOf(key) !== -1) return;\n    var child = allChildren.get(key);\n    if (!child) return;\n    var insertionIndex = presentKeys.indexOf(key);\n\n    var onExit = function onExit() {\n      exiting.delete(key); // Remove this child from the present children\n\n      var removeIndex = presentChildren.current.findIndex(function (child) {\n        return child.key === key;\n      });\n      presentChildren.current.splice(removeIndex, 1); // Defer re-rendering until all exiting children have indeed left\n\n      if (!exiting.size) {\n        presentChildren.current = filteredChildren;\n        forceUpdate();\n        onExitComplete && onExitComplete();\n      }\n    };\n\n    var exitProps = {\n      custom: custom,\n      isExiting: true,\n      onExitComplete: onExit\n    };\n    childrenToRender.splice(insertionIndex, 0, createElement(PresenceChild, {\n      key: getChildKey(child),\n      exitProps: exitProps\n    }, child));\n  }); // Add `MotionContext` even to children that don't need it to ensure we're rendering\n  // the same tree between renders\n\n  childrenToRender = childrenToRender.map(function (child) {\n    var key = child.key;\n    return exiting.has(key) ? child : createElement(PresenceChild, {\n      key: getChildKey(child)\n    }, child);\n  });\n  presentChildren.current = childrenToRender;\n\n  if (process.env.NODE_ENV !== \"production\" && exitBeforeEnter && childrenToRender.length > 1) {\n    console.warn(\"You're attempting to animate multiple children within AnimatePresence, but its exitBeforeEnter prop is set to true. This will lead to odd visual behaviour.\");\n  }\n\n  return createElement(Fragment, null, exiting.size ? childrenToRender : childrenToRender.map(function (child) {\n    return cloneElement(child);\n  }));\n}; // Does this device prefer reduced motion? Returns `null` server-side.\n\n\nvar prefersReducedMotion = motionValue(null);\n\nif (typeof window !== \"undefined\") {\n  if (window.matchMedia) {\n    var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n\n    var setReducedMotionPreferences = function setReducedMotionPreferences() {\n      return prefersReducedMotion.set(motionMediaQuery_1.matches);\n    };\n\n    motionMediaQuery_1.addListener(setReducedMotionPreferences);\n    setReducedMotionPreferences();\n  } else {\n    prefersReducedMotion.set(false);\n  }\n}\n\nfunction determineShouldReduceMotion(prefersReduced, isReducedMotion) {\n  return typeof isReducedMotion === \"boolean\" ? isReducedMotion : Boolean(prefersReduced);\n}\n/**\r\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\r\n *\r\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\r\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\r\n *\r\n * It will actively respond to changes and re-render your components with the latest setting.\r\n *\r\n * ```jsx\r\n * export function Sidebar({ isOpem }) {\r\n *   const shouldReduceMotion = useReducedMotion()\r\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\r\n *\r\n *   return (\r\n *     <motion.div animate={{\r\n *       opacity: isOpen ? 1 : 0,\r\n *       x: isOpen ? 0 : closedX\r\n *     }} />\r\n *   )\r\n * }\r\n * ```\r\n *\r\n * @return boolean\r\n *\r\n * @public\r\n */\n\n\nfunction useReducedMotion() {\n  var isReducedMotion = useContext(MotionContext).isReducedMotion;\n\n  var _a = useState(determineShouldReduceMotion(prefersReducedMotion.get(), isReducedMotion)),\n      shouldReduceMotion = _a[0],\n      setShouldReduceMotion = _a[1];\n\n  useEffect(function () {\n    return prefersReducedMotion.onChange(function (v) {\n      setShouldReduceMotion(determineShouldReduceMotion(v, isReducedMotion));\n    });\n  }, [setShouldReduceMotion, isReducedMotion]);\n  return shouldReduceMotion;\n}\n/**\r\n * Define accessibility options for a tree. Can be used to force the tree into Reduced Motion mode,\r\n * or disable device detection.\r\n *\r\n * @internal\r\n */\n\n\nfunction ReducedMotion(_a) {\n  var children = _a.children,\n      enabled = _a.enabled;\n  var context = useContext(MotionContext);\n  context = useMemo(function () {\n    return __assign(__assign({}, context), {\n      isReducedMotion: enabled\n    });\n  }, [enabled]);\n  return createElement(MotionContext.Provider, {\n    value: context\n  }, children);\n}\n\nexport { AnimatePresence, AnimationControls, DragControls, MotionContext, MotionPluginContext, MotionPlugins, MotionValue, Point, ReducedMotion, UnstableSyncLayout, animationControls, createMotionComponent, isValidMotionProp, motion, motionValue, transform, unwrapMotionValue, useAnimatedState, useAnimation, useCycle, useDomEvent, useDragControls, useExternalRef, useGestures, useInvertedScale, useMotionValue, usePanGesture, useReducedMotion, useSpring, useTapGesture, useTransform, useViewportScroll };"],"names":["MotionValue","init","_a","value","_this","this","_b","transformer","parent","timeDelta","lastUpdated","canTrackVelocity","updateAndNotify","v","render","prev","current","updateSubscribers","forEach","notifySubscriber","children","setChild","renderSubscribers","delta","timestamp","scheduleVelocityCheck","subscriber","velocityCheck","child","set","isNaN","parseFloat","prototype","addChild","config","Set","add","removeChild","delete","subscribeTo","subscriptions","subscription","updateSubscriber","onChange","onRenderRequest","attach","passiveEffect","get","getVelocity","start","animation","stop","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","clear","motionValue","opts","useConstant","ref","useRef","resolver","isMotionValue","updateStyler","onRead","onRender","state","onUpdate","MotionValuesMap","hasMounted","values","Map","unsubscribers","has","key","bindValueToOutput","defaultValue","undefined","callback","unsubscribeOnRender","output","unsubscribeOnChange","setOnUpdate","setTransformTemplate","transformTemplate","updateTransformTemplate","getTransformTemplate","mount","unmount","_value","unsubscribe","specialMotionValueProps","useMotionValues","props","motionValues","map","session","syncRenderSession","styler","push","Mount","memo","innerRef","isStatic","useEffect","Element","domStyler","preparseOutput","enableHardwareAcceleration","resolveCurrent","resolvedValues","transformOriginProps","isTransformOriginProp","buildStyleAttr","styleProp","motionValueStyles","transform","isKeyframesTarget","Array","isArray","resolveFinalValueInKeyframes","length","dimensionTypes","px","vw","vh","test","parse","valueTypes","testValueType","type","getDimensionValueType","find","getValueType","underDampedSpring","stiffness","damping","restDelta","restSpeed","overDampedSpring","to","linearTween","ease","duration","keyframes","defaultTransitions","x","y","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","color","default","just","update","complete","easingDefinitionToFunction","definition","x1","y1","x2","y2","cubicBezier","isEasingArray","isAnimatable","startsWith","secondsToMilliseconds","seconds","transitions","tween","spring","inertia","transitionOptionParser","from","velocity","easings","linear","getTransitionDefinition","transitionDefinition","delay","when","delayChildren","staggerChildren","staggerDirection","transition","Object","keys","isTransitionDefined","valueKey","transitionFactory","getDefaultTransition","valueTransitionDefinition","hasOwnProperty","getAnimation","target","origin","isOriginAnimatable","isTargetAnimatable","actionFactory","preprocessOptions","repeatDelay","startAnimation","delay$1","activeAnimation","animationFactory","valueDelay","options","animate","ValueAnimationControls","readValueFromSource","makeTargetAnimatable","variants","baseTarget","overrides","resolvedOverrides","activeOverrides","hasValue","setProps","setVariants","setDefaultTransition","defaultTransition","setValues","_c","isActive","priority","_d","resolveVariant","transitionEnd","transformValues","targetValue","checkForNewValues","newValueKeys","filter","numNewValues","i","variant","custom","getHighestPriority","size","Math","max","apply","setOverride","overrideIndex","startOverride","override","clearOverride","highest","resetIsAnimating","overrideTarget","remainingValues","onStart","onComplete","applyVariantLabels","variantLabelList","reverse","animateVariantLabels","animateVariant","animationDefinition","transitionOverride","_e","animatable","animations","valueTarget","allAnimations","all","variantLabels","label","variantLabel","getAnimations","getChildrenAnimations","animateChildren","last","first","maxStaggerDuration","generateStaggerDuration","childControls","onAnimationStart","onAnimationComplete","checkOverrideIsAnimating","numOverrides","resolvedOverride","controls","resetChildren","AnimationControls","pendingAnimations","componentControls","subscribe","animations_1","MotionContext","createContext","static","isVariantLabel","isAnimationControls","useMotionContext","parentContext","initialState","initial","whileTap","whileHover","exitProps","shouldPropagateControls","targetInitial","targetAnimate","initialDependency","animateDependency","context","useMemo","isReducedMotion","isInitialOnly","isInitialRender","useInitialOrEveryRender","initialToApply","useValueAnimationControls","subscribeToParentControls","parentControls","useContext","isExiting","unmountProps","createMotionComponent","getValueControlsConfig","loadFunctionalityComponents","renderComponent","forwardRef","externalRef","useExternalRef","style","prevMotionStyles","thisStyle","useMotionStyles","shouldInheritVariant","inherit","checkShouldInheritVariant","functionality","renderedComponent","createElement","Fragment","Provider","svgElements","MotionPluginContext","transformPagePoint","p","useUnmountEffect","addDomEvent","eventName","handler","addEventListener","removeEventListener","isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","e","changedTouches","pointFromMouse","extractEventInfo","point","Point","wrapHandler","shouldFilterPrimaryPointer","listener","eventHandler","button","filterPrimaryPointer","isBrowser","window","supportsTouchEvents","ontouchstart","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","onpointerdown","onmousedown","addPointerEvent","usePointerEvent","element","useDomEvent","subtract","a","b","relativeTo","idOrElem","elem","localElem","document","getElementById","rect","getBoundingClientRect","left","scrollX","top","scrollY","isViewportScrollBlocked","preventDefault","passive","unblockViewportScroll","PanSession","handlers","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","offset","onMove","initialInfo","transformPoint","onSessionStart","removeOnPointerMove","handlePointerMove","removeOnPointerUp","handlePointerUp","removeListeners","buttons","end","onEnd","panInfo","updateHandlers","lastDevicePoint","startDevicePoint","getVelocity$1","timestampedPoint","lastPoint","time","currentVelocity","Infinity","isNodeOrChild","parentElement","order","getGesturePriority","gesture","indexOf","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","tapGesturePriority","hoverPriority","filterTouch","useGestures","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","panSession","usePanGesture","onTap","onTapStart","onTapCancel","hasTapListeners","isTapping","cancelPointerEventListener","removePointerUp","onPointerUp","openGestureLock","useTapGesture","onHoverStart","onHoverEnd","useHoverGesture","makeRenderlessComponent","hook","gestureProps","Gestures","shouldRender","some","Component","isRefObject","noop","allowDefaultPointerDown","ComponentDragControls","isDragging","currentDirection","constraints","openGlobalLock","prevConstraintsBox","width","height","originEvent","snapToCursor","tagName","activeElement","HTMLElement","blur","bothAxis","axis","axisPoint","constraintsNeedResolution","dragConstraints","transformPagePoint_1","calculateConstraintsFromDom","applyConstraintsToPoint","dragPropagation","onDragStart","convertPanToDrag","dragDirectionLock","lockThreshold","direction","abs","getCurrentDirection","onDirectionLock","onDrag","cancelDrag","dragMomentum","dragElastic","onDragEnd","animateDragEnd","recordBoxInfo","right","bottom","top_1","boundingBox","getBoundingBox","center","setPoint","shouldDrag","applyConstraints","updateProps","_f","_g","remainingProps","_dragValueX","_dragValueY","dragOriginX","dragOriginY","dragTransition","_dragTransitionControls","momentumAnimations","getConstraints","bounceStiffness","bounceDamping","timeConstant","scalePoint","onDragTransitionEnd","constraintsBox","draggableBox","scaleAxisPoint","dimension","pointToScale","stopPointerListener","dragListener","stopResizeListener","min","constraintsRef","draggableRef","parentBoundingBox","draggableBoundingBox","getCurrentOffset","constrainedValue","applyOverdrag","dragFactor","Drag","groupDragControls","dragControls","useDrag","isCSSVariable","cssVariableRegex","getVariableValue","depth","match","exec","parseCSSVariable","token","fallback","resolved","getComputedStyle","getPropertyValue","BoundingBoxDimension","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","positionalValues","checkAndConvertChangedValueTypes","elementStyler","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","reduce","acc","toType","fromType","numKeyframes","removedTransforms","removeNonTranslationalTransform","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","originComputedStyle","targetBbox","convertChangedValueTypes","unitConversion","hasPositionalKey","parseDomVariant","resolveCSSVariables","useForceUpdate","useState","forcedRenderCount","setForcedRenderCount","useCallback","StepName","SyncLayoutContext","jobs","Prepare","Read","Render","jobsNeedProcessing","flushCallbackList","list","numJobs","createUseSyncEffect","stepName","layoutSync","flush","prepare","read","defaultLayoutTransition","defaultPositionTransition","axisLabels","id","centerOf","calcAxisDelta","next","names","sizeDelta","getLayout","measure","offsetLeft","offsetTop","offsetWidth","offsetHeight","readPositionStyle","position","isSizeKey","AnimatePropType","LayoutAnimation","_super","arguments","getSnapshotBeforeUpdate","positionTransition","isHTMLElement","compare","layoutTransition","getTransition","isPositionOnly","positionStyle","nextPosition","getLayoutType","calcDelta","originX","originY","isResolver","makeTransition","layoutKey","transformKey","visualOrigin","deltaKey","baseTransition","getDefaultLayoutTransition","offsetToApply","componentDidUpdate","contextType","Layout","validMotionProps","isValidMotionProp","targetWithoutTransition","mergeTransitionEnd","_a$1","resolveVariantLabels","unresolvedVariant","AnimatePropComponents","Target","targetAndTransition","prevValues","targetToAnimate","animatingTarget","finalTarget","shouldAnimateOnMount","isValidValue","valueHasUpdated","prevLength","shallowCompare","useAnimateProp","VariantLabel","targetVariants","parentAlreadyMounted","oldVariant","newVariant","shouldAnimate","join","useVariants","AnimationSubscription","useAnimationGroupSubscription","isAnimationSubscription","animationProps","animatePropTypeTests","prop","Exit","exit","hasExitProps","hasExitAnimation","isPlayingExitAnimation","onExitComplete","isPropValid","emotionIsPropValid_1","functionalityComponents","numFunctionalityComponents","createDomMotionConfig","isDOM","isSVG","forwardedProps","domProps","filterValidProps","staticVisualStyles","buildSVGProps","activeComponents","Animation","animatePropType","getAnimationComponent","Component_1","htmlMotionComponents","svgMotionComponents","DragControls","nativeEvent","PresenceChild","getChildKey","AnimatePresence","exitBeforeEnter","localForceUpdate","forceUpdate","filteredChildren","filtered","Children","isValidElement","onlyElements","presentChildren","allChildren","exiting","updateChildLookup","childrenToRender","presentKeys","targetKeys","numPresent","insertionIndex","removeIndex","findIndex","splice","cloneElement","prefersReducedMotion","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener"],"sourceRoot":""}