{"version":3,"file":"05d954cf-7ef538cef43c9a450ccc.js","mappings":"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","sources":["webpack://sc-app-orders/./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';\nvar isFloat = function (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 */\nvar MotionValue = /** @class */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    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    this.timeDelta = 0;\n    /**\r\n     * Timestamp of the last time this `MotionValue` was updated.\r\n     *\r\n     * @internal\r\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    this.canTrackVelocity = false;\n    this.updateAndNotify = function (v, render) {\n      if (render === void 0) {\n        render = true;\n      }\n      _this.prev = _this.current;\n      _this.current = _this.transformer ? _this.transformer(v) : v;\n      if (_this.updateSubscribers && _this.prev !== _this.current) {\n        _this.updateSubscribers.forEach(_this.notifySubscriber);\n      }\n      if (_this.children) {\n        _this.children.forEach(_this.setChild);\n      }\n      if (render && _this.renderSubscribers) {\n        _this.renderSubscribers.forEach(_this.notifySubscriber);\n      }\n      // Update timestamp\n      var _a = getFrameData(),\n        delta = _a.delta,\n        timestamp = _a.timestamp;\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    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    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    this.velocityCheck = function (_a) {\n      var timestamp = _a.timestamp;\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    this.setChild = function (child) {\n      return child.set(_this.current);\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  MotionValue.prototype.addChild = function (config) {\n    if (config === void 0) {\n      config = {};\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  MotionValue.prototype.removeChild = function (child) {\n    if (!this.children) {\n      return;\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  MotionValue.prototype.subscribeTo = function (subscriptions, subscription) {\n    var _this = this;\n    var updateSubscriber = function () {\n      return subscription(_this.current);\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  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  MotionValue.prototype.onRenderRequest = function (subscription) {\n    if (!this.renderSubscribers) this.renderSubscribers = new Set();\n    // Render immediately\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  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  MotionValue.prototype.set = function (v, render) {\n    if (render === void 0) {\n      render = true;\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  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  MotionValue.prototype.getVelocity = function () {\n    // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n    return this.canTrackVelocity ?\n    // 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  MotionValue.prototype.start = function (animation) {\n    var _this = this;\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  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  MotionValue.prototype.isAnimating = function () {\n    return !!this.stopAnimation;\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  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  return MotionValue;\n}();\n/**\r\n * @internal\r\n */\nfunction motionValue(init, opts) {\n  return new MotionValue(init, opts);\n}\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 */\nfunction useConstant(init) {\n  var ref = useRef(null);\n  if (ref.current === null) {\n    ref.current = init();\n  }\n  return ref.current;\n}\nvar isMotionValue = function (value) {\n  return value instanceof MotionValue;\n};\n\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\nvar updateStyler = createStylerFactory({\n  onRead: function () {\n    return null;\n  },\n  onRender: function (state, _a) {\n    var onUpdate = _a.onUpdate;\n    return onUpdate(state);\n  }\n});\nvar MotionValuesMap = /** @class */function () {\n  function MotionValuesMap() {\n    this.hasMounted = false;\n    this.values = new Map();\n    this.unsubscribers = new Map();\n  }\n  MotionValuesMap.prototype.has = function (key) {\n    return this.values.has(key);\n  };\n  MotionValuesMap.prototype.set = function (key, value) {\n    this.values.set(key, value);\n    if (this.hasMounted) {\n      this.bindValueToOutput(key, value);\n    }\n  };\n  MotionValuesMap.prototype.get = function (key, defaultValue) {\n    var value = this.values.get(key);\n    if (value === undefined && defaultValue !== undefined) {\n      value = new MotionValue(defaultValue);\n      this.set(key, value);\n    }\n    return value;\n  };\n  MotionValuesMap.prototype.forEach = function (callback) {\n    return this.values.forEach(callback);\n  };\n  MotionValuesMap.prototype.bindValueToOutput = function (key, value) {\n    var _this = this;\n    var onRender = function (v) {\n      return _this.output && _this.output(key, v);\n    };\n    var unsubscribeOnRender = value.onRenderRequest(onRender);\n    var onChange = function (v) {\n      _this.onUpdate && _this.onUpdate.set(key, v);\n    };\n    var unsubscribeOnChange = value.onChange(onChange);\n    if (this.unsubscribers.has(key)) {\n      this.unsubscribers.get(key)();\n    }\n    this.unsubscribers.set(key, function () {\n      unsubscribeOnRender();\n      unsubscribeOnChange();\n    });\n  };\n  MotionValuesMap.prototype.setOnUpdate = function (onUpdate) {\n    this.onUpdate = undefined;\n    if (onUpdate) {\n      this.onUpdate = updateStyler({\n        onUpdate: onUpdate\n      });\n    }\n  };\n  MotionValuesMap.prototype.setTransformTemplate = function (transformTemplate) {\n    if (this.transformTemplate !== transformTemplate) {\n      this.transformTemplate = transformTemplate;\n      this.updateTransformTemplate();\n    }\n  };\n  MotionValuesMap.prototype.getTransformTemplate = function () {\n    return this.transformTemplate;\n  };\n  MotionValuesMap.prototype.updateTransformTemplate = function () {\n    if (this.output) {\n      this.output(\"transform\", this.transformTemplate);\n    }\n  };\n  MotionValuesMap.prototype.mount = function (output) {\n    var _this = this;\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  MotionValuesMap.prototype.unmount = function () {\n    var _this = this;\n    this.values.forEach(function (_value, key) {\n      var unsubscribe = _this.unsubscribers.get(key);\n      unsubscribe && unsubscribe();\n    });\n  };\n  return MotionValuesMap;\n}();\nvar specialMotionValueProps = new Set([\"dragOriginX\", \"dragOriginY\"]);\nvar useMotionValues = function (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    for (var key in props) {\n      if (isMotionValue(props[key]) && !specialMotionValueProps.has(key)) {\n        map.set(key, props[key]);\n      }\n    }\n    return map;\n  });\n  motionValues.setOnUpdate(props.onUpdate);\n  motionValues.setTransformTemplate(props.transformTemplate);\n  return motionValues;\n};\nvar session = null;\nvar syncRenderSession = {\n  isOpen: function () {\n    return session !== null;\n  },\n  open: function () {\n    invariant(!session, \"Sync render session already open\");\n    session = [];\n  },\n  flush: function () {\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 (styler) {\n    invariant(session !== null, \"No sync render session found\");\n    session && session.push(styler);\n  }\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 */\nvar MountComponent = function (_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      if (syncRenderSession.isOpen()) {\n        syncRenderSession.push(domStyler);\n      }\n    });\n    return function () {\n      return values.unmount();\n    };\n  }, []);\n  return null;\n};\nvar Mount = memo(MountComponent);\nvar createValueResolver = function (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};\nvar resolveCurrent = createValueResolver(function (value) {\n  return value.get();\n});\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nvar isTransformOriginProp = function (key) {\n  return transformOriginProps.has(key);\n};\nvar buildStyleAttr = function (values, styleProp, isStatic) {\n  var motionValueStyles = resolveCurrent(values);\n  var transformTemplate = values.getTransformTemplate();\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  return buildStyleProperty(__assign(__assign({}, styleProp), motionValueStyles), !isStatic);\n};\nvar useMotionStyles = function (values, styleProp, isStatic, transformValues) {\n  if (styleProp === void 0) {\n    styleProp = {};\n  }\n  var style = {};\n  var prevMotionStyles = useRef({}).current;\n  for (var key in styleProp) {\n    var thisStyle = styleProp[key];\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      prevMotionStyles[key] = thisStyle;\n    } else {\n      style[key] = thisStyle;\n    }\n  }\n  return transformValues ? transformValues(style) : style;\n};\nvar isKeyframesTarget = function (v) {\n  return Array.isArray(v);\n};\nvar isCustomValue = function (v) {\n  return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n  // TODO maybe throw if v.length - 1 is placeholder token?\n  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\nvar auto = {\n  test: function (v) {\n    return v === \"auto\";\n  },\n  parse: function (v) {\n    return v;\n  }\n};\nvar dimensionTypes = [number, px, percent, degrees, vw, vh, auto];\nvar valueTypes = __spreadArrays(dimensionTypes, [color, complex]);\nvar testValueType = function (v) {\n  return function (type) {\n    return type.test(v);\n  };\n};\nvar getDimensionValueType = function (v) {\n  return dimensionTypes.find(testValueType(v));\n};\nvar getValueType = function (v) {\n  return valueTypes.find(testValueType(v));\n};\nvar underDampedSpring = function () {\n  return {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restDelta: 0.5,\n    restSpeed: 10\n  };\n};\nvar overDampedSpring = function (to) {\n  return {\n    type: \"spring\",\n    stiffness: 700,\n    damping: to === 0 ? 100 : 35\n  };\n};\nvar linearTween = function () {\n  return {\n    ease: \"linear\",\n    duration: 0.3\n  };\n};\nvar keyframes = function (values) {\n  return {\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values\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};\nvar getDefaultTransition = function (valueKey, to) {\n  var transitionFactory;\n  if (isKeyframesTarget(to)) {\n    transitionFactory = keyframes;\n  } else {\n    transitionFactory = defaultTransitions[valueKey] || defaultTransitions.default;\n  }\n  return __assign({\n    to: to\n  }, transitionFactory(to));\n};\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 */\nvar just = function (_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};\nvar easingDefinitionToFunction = function (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  return definition;\n};\nvar isEasingArray = function (ease) {\n  return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\nvar isDurationAnimation = function (v) {\n  return v.hasOwnProperty(\"duration\") || v.hasOwnProperty(\"repeatDelay\");\n};\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 */\nvar isAnimatable = function (key, value) {\n  // If the list of keys tat might be non-animatable grows, replace with Set\n  if (key === \"zIndex\") return false;\n  // 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  if (typeof value === \"number\" || Array.isArray(value)) return true;\n  if (typeof value === \"string\" &&\n  // It's animatable if we have a string\n  complex.test(value) &&\n  // And it contains numbers and/or colors\n  !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n  ) {\n    return true;\n  }\n  return false;\n};\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 */\nvar secondsToMilliseconds = function (seconds) {\n  return seconds * 1000;\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 (opts) {\n    if (opts.ease) {\n      var ease = isEasingArray(opts.ease) ? opts.ease[0] : opts.ease;\n      opts.ease = easingDefinitionToFunction(ease);\n    }\n    return opts;\n  },\n  keyframes: function (_a) {\n    var from = _a.from,\n      to = _a.to,\n      velocity = _a.velocity,\n      opts = __rest(_a, [\"from\", \"to\", \"velocity\"]);\n    if (opts.values && opts.values[0] === null) {\n      var values = __spreadArrays(opts.values);\n      values[0] = from;\n      opts.values = values;\n    }\n    if (opts.ease) {\n      opts.easings = isEasingArray(opts.ease) ? opts.ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(opts.ease);\n    }\n    opts.ease = linear;\n    return opts;\n  }\n};\nvar isTransitionDefined = function (_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  return Object.keys(transition).length;\n};\nvar getTransitionDefinition = function (key, to, transitionDefinition) {\n  var delay = transitionDefinition ? transitionDefinition.delay : 0;\n  // 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  if (transitionDefinition === undefined || !isTransitionDefined(transitionDefinition)) {\n    return __assign({\n      delay: delay\n    }, getDefaultTransition(key, to));\n  }\n  var valueTransitionDefinition = transitionDefinition[key] || transitionDefinition.default || transitionDefinition;\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};\nvar preprocessOptions = function (type, opts) {\n  return transitionOptionParser[type] ? transitionOptionParser[type](opts) : opts;\n};\nvar getAnimation = function (key, value, target, transition) {\n  var origin = value.get();\n  var isOriginAnimatable = isAnimatable(key, origin);\n  var isTargetAnimatable = isAnimatable(key, target);\n  // 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  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.\");\n  // Parse the `transition` prop and return options for the Popmotion animation\n  var _a = getTransitionDefinition(key, target, transition),\n    _b = _a.type,\n    type = _b === void 0 ? \"tween\" : _b,\n    transitionDefinition = __rest(_a, [\"type\"]);\n  // If this is an animatable pair of values, return an animation, otherwise use `just`\n  var actionFactory = isOriginAnimatable && isTargetAnimatable ? transitions[type] : just;\n  var opts = preprocessOptions(type, __assign({\n    from: origin,\n    velocity: value.getVelocity()\n  }, transitionDefinition));\n  // Convert duration from Framer Motion's seconds into Popmotion's milliseconds\n  if (isDurationAnimation(opts)) {\n    if (opts.duration) {\n      opts.duration = secondsToMilliseconds(opts.duration);\n    }\n    if (opts.repeatDelay) {\n      opts.repeatDelay = secondsToMilliseconds(opts.repeatDelay);\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 */\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  return value.start(function (complete) {\n    var activeAnimation;\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    if (valueDelay !== undefined) {\n      delay$1 = valueDelay;\n    }\n    var animate = function () {\n      var animation = animationFactory(options);\n      // Bind animation opts to animation\n      activeAnimation = animation.start({\n        update: function (v) {\n          return value.set(v);\n        },\n        complete: complete\n      });\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    if (delay$1) {\n      activeAnimation = delay(secondsToMilliseconds(delay$1)).start({\n        complete: animate\n      });\n    } else {\n      animate();\n    }\n    return function () {\n      if (activeAnimation) activeAnimation.stop();\n    };\n  });\n}\n\n/**\r\n * Get the current value of every `MotionValue`\r\n * @param values -\r\n */\nvar getCurrent = function (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 */\nvar getVelocity = function (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 */\nvar isTargetResolver = function (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 */\nvar isVariantLabels = function (v) {\n  return Array.isArray(v);\n};\n/**\r\n * Check if value is a numerical string, ie \"100\" or \"100px\"\r\n */\nvar isNumericalString = function (v) {\n  return /^\\d*\\.?\\d+$/.test(v);\n};\n/**\r\n * Control animations for a single component\r\n *\r\n * @internal\r\n */\nvar ValueAnimationControls = /** @class */function () {\n  function ValueAnimationControls(_a) {\n    var _this = this;\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    this.props = {};\n    /**\r\n     * The component's variants, as provided by `variants`\r\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    this.baseTarget = {};\n    /**\r\n     * A series of target overrides that we can animate to/from when overrides are set/cleared.\r\n     */\n    this.overrides = [];\n    /**\r\n     * A series of target overrides as they were originally resolved.\r\n     */\n    this.resolvedOverrides = [];\n    /**\r\n     * A Set of currently active override indexes\r\n     */\n    this.activeOverrides = new Set();\n    /**\r\n     * A Set of value keys that are currently animating.\r\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    this.hasValue = function (key) {\n      return !_this.values.has(key);\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  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  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  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  ValueAnimationControls.prototype.setValues = function (definition, _a) {\n    var _this = this;\n    var _b = _a === void 0 ? {} : _a,\n      _c = _b.isActive,\n      isActive = _c === void 0 ? new Set() : _c,\n      priority = _b.priority;\n    var _d = this.resolveVariant(definition),\n      target = _d.target,\n      transitionEnd = _d.transitionEnd;\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      if (target) {\n        var targetValue = resolveFinalValueInKeyframes(target[key]);\n        if (_this.values.has(key)) {\n          var value = _this.values.get(key);\n          value && value.set(targetValue);\n        } else {\n          _this.values.set(key, motionValue(targetValue));\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  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  ValueAnimationControls.prototype.checkForNewValues = function (target) {\n    var newValueKeys = Object.keys(target).filter(this.hasValue);\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues) return;\n    for (var i = 0; i < numNewValues; i++) {\n      var key = newValueKeys[i];\n      var targetValue = target[key];\n      var value = null;\n      // 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      if (Array.isArray(targetValue)) {\n        value = targetValue[0];\n      }\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      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      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      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  ValueAnimationControls.prototype.resolveVariant = function (variant) {\n    if (!variant) {\n      return {\n        target: undefined,\n        transition: undefined,\n        transitionEnd: undefined\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    var _a = variant.transition,\n      transition = _a === void 0 ? this.defaultTransition : _a,\n      transitionEnd = variant.transitionEnd,\n      target = __rest(variant, [\"transition\", \"transitionEnd\"]);\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  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  ValueAnimationControls.prototype.setOverride = function (definition, overrideIndex) {\n    this.overrides[overrideIndex] = definition;\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  ValueAnimationControls.prototype.startOverride = function (overrideIndex) {\n    var override = this.overrides[overrideIndex];\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  ValueAnimationControls.prototype.clearOverride = function (overrideIndex) {\n    var _this = this;\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.clearOverride(overrideIndex);\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    if (highest) {\n      var highestOverride = this.overrides[highest];\n      highestOverride && this.startOverride(highest);\n    }\n    // Figure out which remaining values were affected by the override and animate those\n    var overrideTarget = this.resolvedOverrides[overrideIndex];\n    if (!overrideTarget) return;\n    var remainingValues = {};\n    for (var key in this.baseTarget) {\n      if (overrideTarget[key] !== undefined) {\n        remainingValues[key] = this.baseTarget[key];\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  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  ValueAnimationControls.prototype.applyVariantLabels = function (variantLabelList) {\n    var _this = this;\n    var isActive = new Set();\n    var reversedList = __spreadArrays(variantLabelList).reverse();\n    reversedList.forEach(function (key) {\n      var _a = _this.resolveVariant(_this.variants[key]),\n        target = _a.target,\n        transitionEnd = _a.transitionEnd;\n      if (transitionEnd) {\n        _this.setValues(transitionEnd, {\n          isActive: isActive\n        });\n      }\n      if (target) {\n        _this.setValues(target, {\n          isActive: isActive\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  ValueAnimationControls.prototype.start = function (definition, opts) {\n    var _this = this;\n    if (opts === void 0) {\n      opts = {};\n    }\n    if (opts.priority) {\n      this.activeOverrides.add(opts.priority);\n    }\n    this.resetIsAnimating(opts.priority);\n    var animation;\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    this.onStart();\n    return animation.then(function () {\n      return _this.onComplete();\n    });\n  };\n  ValueAnimationControls.prototype.animate = function (animationDefinition, _a) {\n    var _this = this;\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    var _e = this.resolveVariant(animationDefinition),\n      target = _e.target,\n      transition = _e.transition,\n      transitionEnd = _e.transitionEnd;\n    if (transitionOverride) {\n      transition = transitionOverride;\n    }\n    if (!target) return Promise.resolve();\n    target = this.transformValues(target);\n    if (transitionEnd) {\n      transitionEnd = this.transformValues(transitionEnd);\n    }\n    this.checkForNewValues(target);\n    if (this.makeTargetAnimatable) {\n      var animatable = this.makeTargetAnimatable(target, transitionEnd);\n      target = animatable.target;\n      transitionEnd = animatable.transitionEnd;\n    }\n    if (priority) {\n      this.resolvedOverrides[priority] = target;\n    }\n    this.checkForNewValues(target);\n    var animations = [];\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      if (!priority) {\n        this.baseTarget[key] = resolveFinalValueInKeyframes(valueTarget);\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    var allAnimations = Promise.all(animations);\n    return transitionEnd ? allAnimations.then(function () {\n      _this.setValues(transitionEnd, {\n        priority: priority\n      });\n    }) : allAnimations;\n  };\n  ValueAnimationControls.prototype.animateVariantLabels = function (variantLabels, opts) {\n    var _this = this;\n    var animations = __spreadArrays(variantLabels).reverse().map(function (label) {\n      return _this.animateVariant(label, opts);\n    });\n    return Promise.all(animations);\n  };\n  ValueAnimationControls.prototype.animateVariant = function (variantLabel, opts) {\n    var _this = this;\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    if (variant && this.children) {\n      var transition = this.resolveVariant(variant).transition;\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    if (when) {\n      var _a = when === \"beforeChildren\" ? [getAnimations, getChildrenAnimations] : [getChildrenAnimations, getAnimations],\n        first = _a[0],\n        last = _a[1];\n      return first().then(last);\n    } else {\n      return Promise.all([getAnimations(), getChildrenAnimations()]);\n    }\n  };\n  ValueAnimationControls.prototype.animateChildren = function (variantLabel, delayChildren, staggerChildren, staggerDirection, priority) {\n    if (delayChildren === void 0) {\n      delayChildren = 0;\n    }\n    if (staggerChildren === void 0) {\n      staggerChildren = 0;\n    }\n    if (staggerDirection === void 0) {\n      staggerDirection = 1;\n    }\n    if (priority === void 0) {\n      priority = 0;\n    }\n    if (!this.children) {\n      return Promise.resolve();\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  ValueAnimationControls.prototype.onStart = function () {\n    var onAnimationStart = this.props.onAnimationStart;\n    onAnimationStart && onAnimationStart();\n  };\n  ValueAnimationControls.prototype.onComplete = function () {\n    var onAnimationComplete = this.props.onAnimationComplete;\n    onAnimationComplete && onAnimationComplete();\n  };\n  ValueAnimationControls.prototype.checkOverrideIsAnimating = function (priority) {\n    var numOverrides = this.overrides.length;\n    for (var i = priority + 1; i < numOverrides; i++) {\n      var resolvedOverride = this.resolvedOverrides[i];\n      if (resolvedOverride) {\n        for (var key in resolvedOverride) {\n          this.isAnimating.add(key);\n        }\n      }\n    }\n  };\n  ValueAnimationControls.prototype.resetIsAnimating = function (priority) {\n    if (priority === void 0) {\n      priority = 0;\n    }\n    this.isAnimating.clear();\n    // If this isn't the highest priority gesture, block the animation\n    // of anything that's currently being animated\n    if (priority < this.getHighestPriority()) {\n      this.checkOverrideIsAnimating(priority);\n    }\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.resetIsAnimating(priority);\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  ValueAnimationControls.prototype.addChild = function (controls) {\n    if (!this.children) {\n      this.children = new Set();\n    }\n    this.children.add(controls);\n    // 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    this.overrides.forEach(function (override, i) {\n      override && controls.setOverride(override, i);\n    });\n  };\n  ValueAnimationControls.prototype.removeChild = function (controls) {\n    if (!this.children) {\n      return;\n    }\n    this.children.delete(controls);\n  };\n  ValueAnimationControls.prototype.resetChildren = function () {\n    if (this.children) this.children.clear();\n  };\n  return ValueAnimationControls;\n}();\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 */\nfunction useInitialOrEveryRender(callback, isInitialOnly) {\n  if (isInitialOnly === void 0) {\n    isInitialOnly = false;\n  }\n  var isInitialRender = useRef(true);\n  if (!isInitialOnly || isInitialOnly && isInitialRender.current) {\n    callback();\n  }\n  isInitialRender.current = false;\n}\n\n/**\r\n * Control animations on one or more components.\r\n *\r\n * @public\r\n */\nvar AnimationControls = /** @class */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    this.pendingAnimations = [];\n    /**\r\n     * A collection of linked component animation controls.\r\n     *\r\n     * @internal\r\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  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  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  AnimationControls.prototype.subscribe = function (controls) {\n    var _this = this;\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  AnimationControls.prototype.start = function (definition, transitionOverride) {\n    var _this = this;\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  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  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  AnimationControls.prototype.mount = function () {\n    var _this = this;\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  AnimationControls.prototype.unmount = function () {\n    this.hasMounted = false;\n    this.stop();\n  };\n  return AnimationControls;\n}();\n/**\r\n * @internal\r\n */\nvar animationControls = function () {\n  return new AnimationControls();\n};\n\n/**\r\n * @internal\r\n */\nvar MotionContext = createContext({\n  static: false\n});\nvar isVariantLabel = function (v) {\n  return typeof v === \"string\" || Array.isArray(v);\n};\nvar isAnimationControls = function (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 */\nvar useMotionContext = function (parentContext, controls, values, isStatic, _a) {\n  if (isStatic === void 0) {\n    isStatic = false;\n  }\n  var initial = _a.initial,\n    animate = _a.animate,\n    variants = _a.variants,\n    whileTap = _a.whileTap,\n    whileHover = _a.whileHover;\n  // Override initial with that from a parent context, if defined\n  if (parentContext.exitProps && parentContext.exitProps.initial !== undefined) {\n    initial = parentContext.exitProps.initial;\n  }\n  var initialState;\n  if (initial === false && !isAnimationControls(animate)) {\n    initialState = animate;\n  } else if (typeof initial !== \"boolean\") {\n    initialState = initial;\n  }\n  // Track mounted status so children can detect whether they were present during their\n  // parent's first render\n  var hasMounted = useRef(false);\n  // 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  var shouldPropagateControls = variants || isVariantLabel(animate) || isVariantLabel(whileTap) || isVariantLabel(whileHover) || isAnimationControls(animate);\n  // If this component's `initial` prop is a variant label, propagate it. Otherwise pass the parent's.\n  var targetInitial = isVariantLabel(initialState) ? initialState : parentContext.initial;\n  // 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  var targetAnimate = isVariantLabel(animate) ? animate : parentContext.animate;\n  // 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  var initialDependency = isStatic ? targetInitial : null;\n  // 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  var animateDependency = shouldPropagateControls && isVariantLabel(targetAnimate) ? targetAnimate : null;\n  // 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  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]);\n  // Update the `static` property every render. This is unlikely to change but also essentially free.\n  context.static = isStatic;\n  // Set initial state. If this is a static component (ie in Framer canvas), respond to updates\n  // in `initial`.\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\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 */\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  });\n  // Reset and resubscribe children every render to ensure stagger order is correct\n  if (!parentContext || !parentContext.exitProps || !parentContext.exitProps.isExiting) {\n    controls.resetChildren();\n    controls.setProps(props);\n    controls.setVariants(variants);\n    controls.setDefaultTransition(transition);\n  }\n  // We have to subscribe to the parent controls within a useEffect rather than during render,\n  // as\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      controls.setProps(unmountProps);\n      parentControls && parentControls.removeChild(controls);\n    };\n  }, []);\n  return controls;\n}\nvar checkShouldInheritVariant = function (_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\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 */\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;\n  // 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  if (externalRef && typeof externalRef === \"function\") {\n    useEffect(function () {\n      externalRef(ref.current);\n      return function () {\n        return externalRef(null);\n      };\n    }, []);\n  }\n  return ref;\n}\n\n/**\r\n * @internal\r\n */\nvar createMotionComponent = function (_a) {\n  var getValueControlsConfig = _a.getValueControlsConfig,\n    loadFunctionalityComponents = _a.loadFunctionalityComponents,\n    renderComponent = _a.renderComponent;\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  return forwardRef(MotionComponent);\n};\n\n/**\r\n * @internal\r\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 */\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\n/**\r\n * @internal\r\n */\nvar MotionPluginContext = createContext({\n  transformPagePoint: function (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 */\nfunction MotionPlugins(_a) {\n  var children = _a.children,\n    props = __rest(_a, [\"children\"]);\n  var pluginContext = useContext(MotionPluginContext);\n  var value = useRef(__assign({}, pluginContext)).current;\n  // Mutative to prevent triggering rerenders in all listening\n  // components every time this component renders\n  for (var key in props) {\n    value[key] = props[key];\n  }\n  return createElement(MotionPluginContext.Provider, {\n    value: value\n  }, children);\n}\nfunction useUnmountEffect(callback) {\n  return useEffect(function () {\n    return function () {\n      return callback();\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 */\nfunction useDomEvent(ref, eventName, handler, options) {\n  useEffect(function () {\n    var element = ref.current;\n    if (handler && element) {\n      return addDomEvent(element, eventName, handler, options);\n    }\n  }, [ref, eventName, handler, options]);\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  return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n  var hasTouches = !!event.touches;\n  return hasTouches;\n}\n\n/**\r\n * Filters out events not attached to the primary pointer (currently left mouse button)\r\n * @param eventHandler\r\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    if (isPrimaryPointer) {\n      eventHandler(event);\n    }\n  };\n}\nvar defaultPagePoint = {\n  pageX: 0,\n  pageY: 0\n};\nfunction pointFromTouch(e) {\n  var primaryTouch = e.touches[0] || e.changedTouches[0];\n  var _a = primaryTouch || defaultPagePoint,\n    pageX = _a.pageX,\n    pageY = _a.pageY;\n  return {\n    x: pageX,\n    y: pageY\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}\nfunction extractEventInfo(event) {\n  return {\n    point: isTouchEvent(event) ? pointFromTouch(event) : pointFromMouse(event)\n  };\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n  if (shouldFilterPrimaryPointer === void 0) {\n    shouldFilterPrimaryPointer = false;\n  }\n  if (!handler) return;\n  var listener = function (event) {\n    return handler(event, extractEventInfo(event));\n  };\n  return shouldFilterPrimaryPointer ? filterPrimaryPointer(listener) : listener;\n};\nvar isBrowser = typeof window !== \"undefined\";\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n  return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n  return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n  return isBrowser && window.onmousedown === null;\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};\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  return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n  return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n  return useDomEvent(ref, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\n/** @public */\nvar Point;\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  Point.relativeTo = function (idOrElem) {\n    var elem;\n    var getElem = function () {\n      // Caching element here could be leaky because of React lifecycle\n      if (elem !== undefined) return elem;\n      if (typeof idOrElem === \"string\") {\n        elem = document.getElementById(idOrElem);\n      } else {\n        elem = idOrElem;\n      }\n      return elem;\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 = {}));\nvar isViewportScrollBlocked = false;\nvar isBrowser$1 = typeof window !== \"undefined\";\nif (isBrowser$1) {\n  document.addEventListener(\"touchmove\", function (event) {\n    if (isViewportScrollBlocked) {\n      event.preventDefault();\n    }\n  }, {\n    passive: false\n  });\n}\nvar blockViewportScroll = function () {\n  return isViewportScrollBlocked = true;\n};\nvar unblockViewportScroll = function () {\n  return isViewportScrollBlocked = false;\n};\n\n/**\r\n * @internal\r\n */\nvar PanSession = /** @class */function () {\n  function PanSession(event, handlers, _a) {\n    var _this = this;\n    var transformPagePoint = (_a === void 0 ? {} : _a).transformPagePoint;\n    /**\r\n     * @internal\r\n     */\n    this.startEvent = null;\n    /**\r\n     * @internal\r\n     */\n    this.lastMoveEvent = null;\n    /**\r\n     * @internal\r\n     */\n    this.lastMoveEventInfo = null;\n    /**\r\n     * @internal\r\n     */\n    this.handlers = {};\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;\n      // 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      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      _this.history.push(__assign(__assign({}, point), {\n        timestamp: timestamp\n      }));\n      var _a = _this.handlers,\n        onStart = _a.onStart,\n        onMove = _a.onMove;\n      if (!isPanStarted) {\n        onStart && onStart(_this.lastMoveEvent, info);\n        _this.startEvent = _this.lastMoveEvent;\n      }\n      onMove && onMove(_this.lastMoveEvent, info);\n    };\n    // If we have more than one touch, don't start detecting this gesture\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    this.removeListeners = function () {\n      removeOnPointerMove && removeOnPointerMove();\n      removeOnPointerUp && removeOnPointerUp();\n    };\n  }\n  PanSession.prototype.handlePointerMove = function (event, info) {\n    this.lastMoveEvent = event;\n    this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);\n    // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n    if (isMouseEvent(event) && event.buttons === 0) {\n      this.handlePointerUp(event, info);\n      return;\n    }\n    // Throttle mouse move event to once per frame\n    sync.update(this.updatePoint, true);\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  PanSession.prototype.updateHandlers = function (handlers) {\n    this.handlers = handlers;\n  };\n  PanSession.prototype.end = function () {\n    this.removeListeners && this.removeListeners();\n    cancelSync.update(this.updatePoint);\n    unblockViewportScroll();\n  };\n  return PanSession;\n}();\nfunction transformPoint(info, transformPagePoint) {\n  return transformPagePoint ? {\n    point: transformPagePoint(info.point)\n  } : info;\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}\nfunction startDevicePoint(history) {\n  return history[0];\n}\nfunction lastDevicePoint(history) {\n  return history[history.length - 1];\n}\nfunction getVelocity$1(history, timeDelta) {\n  if (history.length < 2) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n  var i = history.length - 1;\n  var timestampedPoint = null;\n  var lastPoint = lastDevicePoint(history);\n  while (i >= 0) {\n    timestampedPoint = history[i];\n    if (lastPoint.timestamp - timestampedPoint.timestamp > secondsToMilliseconds(timeDelta)) {\n      break;\n    }\n    i--;\n  }\n  if (!timestampedPoint) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n  var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n  if (time === 0) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n  var currentVelocity = {\n    x: (lastPoint.x - timestampedPoint.x) / time,\n    y: (lastPoint.y - timestampedPoint.y) / time\n  };\n  if (currentVelocity.x === Infinity) {\n    currentVelocity.x = 0;\n  }\n  if (currentVelocity.y === Infinity) {\n    currentVelocity.y = 0;\n  }\n  return currentVelocity;\n}\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 */\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 (event, info) {\n      panSession.current = null;\n      onPanEnd && onPanEnd(event, info);\n    }\n  };\n  if (panSession.current !== null) {\n    panSession.current.updateHandlers(handlers);\n  }\n  function onPointerDown(event) {\n    panSession.current = new PanSession(event, handlers, {\n      transformPagePoint: transformPagePoint\n    });\n  }\n  usePointerEvent(ref, \"pointerdown\", hasPanEvents && onPointerDown);\n  useUnmountEffect(function () {\n    return panSession.current && panSession.current.end();\n  });\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 */\nvar isNodeOrChild = function (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};\nvar order = [\"whileHover\", \"whileTap\", \"whileDrag\"];\nvar getGesturePriority = function (gesture) {\n  return order.indexOf(gesture) + 1;\n};\nfunction createLock(name) {\n  var lock = null;\n  return function () {\n    var openLock = function () {\n      lock = null;\n    };\n    if (lock === null) {\n      lock = name;\n      return openLock;\n    }\n    return false;\n  };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n  var lock = false;\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    if (openHorizontal_1 && openVertical_1) {\n      lock = function () {\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  return lock;\n}\nvar tapGesturePriority = getGesturePriority(\"whileTap\");\n/**\r\n * @param handlers -\r\n * @internal\r\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  function removePointerUp() {\n    cancelPointerEventListener.current && cancelPointerEventListener.current();\n    cancelPointerEventListener.current = null;\n  }\n  if (whileTap && controls) {\n    controls.setOverride(whileTap, tapGesturePriority);\n  }\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  var onPointerUp = useRef(null);\n  onPointerUp.current = function (event, info) {\n    var element = ref.current;\n    removePointerUp();\n    if (!isTapping.current || !element) return;\n    isTapping.current = false;\n    if (controls && whileTap) {\n      controls.clearOverride(tapGesturePriority);\n    }\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    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock) return;\n    openGestureLock();\n    if (!isNodeOrChild(element, event.target)) {\n      onTapCancel && onTapCancel(event, info);\n    } else {\n      onTap && onTap(event, info);\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    if (controls && whileTap) {\n      controls.startOverride(tapGesturePriority);\n    }\n  }\n  usePointerEvent(ref, \"pointerdown\", hasTapListeners ? onPointerDown : undefined);\n  useUnmountEffect(removePointerUp);\n}\nvar hoverPriority = getGesturePriority(\"whileHover\");\nvar filterTouch = function (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 */\nfunction useHoverGesture(_a, ref) {\n  var whileHover = _a.whileHover,\n    onHoverStart = _a.onHoverStart,\n    onHoverEnd = _a.onHoverEnd,\n    controls = _a.controls;\n  if (whileHover && controls) {\n    controls.setOverride(whileHover, hoverPriority);\n  }\n  usePointerEvent(ref, \"pointerenter\", filterTouch(function (event, info) {\n    if (onHoverStart) onHoverStart(event, info);\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    if (whileHover && controls) {\n      controls.clearOverride(hoverPriority);\n    }\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 */\nfunction useGestures(props, ref) {\n  usePanGesture(props, ref);\n  useTapGesture(props, ref);\n  useHoverGesture(props, ref);\n}\nvar makeRenderlessComponent = function (hook) {\n  return function (props) {\n    hook(props);\n    return null;\n  };\n};\nvar gestureProps = [\"onPan\", \"onPanStart\", \"onPanEnd\", \"onPanSessionStart\", \"onTap\", \"onTapStart\", \"onTapCancel\", \"whileTap\", \"whileHover\", \"onHoverStart\", \"onHoverEnd\"];\nvar Gestures = {\n  key: \"gestures\",\n  shouldRender: function (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    useGestures(props, innerRef);\n  })\n};\nvar isRefObject = function (ref) {\n  return typeof ref === \"object\" && ref.hasOwnProperty(\"current\");\n};\nvar noop = function (v) {\n  return v;\n};\n/**\r\n * Don't block the default pointerdown behaviour of these elements.\r\n */\nvar allowDefaultPointerDown = new Set([\"INPUT\", \"TEXTAREA\", \"SELECT\"]);\nvar ComponentDragControls = /** @class */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    this.isDragging = false;\n    /**\r\n     * The current direction of drag, or `null` if both.\r\n     *\r\n     * @internal\r\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    this.constraints = false;\n    /**\r\n     * A reference to the host component's latest props.\r\n     *\r\n     * @internal\r\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    this.point = {};\n    /**\r\n     * The origin point for the current drag gesture.\r\n     *\r\n     * @internal\r\n     */\n    this.origin = {\n      x: motionValue(0),\n      y: motionValue(0)\n    };\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    this.openGlobalLock = null;\n    /**\r\n     * @internal\r\n     */\n    this.panSession = null;\n    /**\r\n     * A reference to the previous constraints bounding box\r\n     *\r\n     * @internal\r\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  ComponentDragControls.prototype.start = function (originEvent, _a) {\n    var _this = this;\n    var _b = (_a === void 0 ? {} : _a).snapToCursor,\n      snapToCursor = _b === void 0 ? false : _b;\n    snapToCursor && this.snapToCursor(originEvent);\n    var onSessionStart = function (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();\n          // Make sure input elements loose focus when we prevent the default.\n          if (document.activeElement instanceof HTMLElement) {\n            document.activeElement.blur();\n          }\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      blockViewportScroll();\n      // Stop any animations on both axis values immediately. This allows the user to throw and catch\n      // the component.\n      bothAxis(function (axis) {\n        var axisPoint = _this.point[axis];\n        axisPoint && axisPoint.stop();\n      });\n    };\n    var onStart = function (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        _this.applyConstraintsToPoint();\n      }\n      // Set point origin and stop any existing animations.\n      bothAxis(function (axis) {\n        var axisPoint = _this.point[axis];\n        if (!axisPoint) return;\n        _this.origin[axis].set(axisPoint.get());\n      });\n      // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n      var _b = _this.props,\n        drag = _b.drag,\n        dragPropagation = _b.dragPropagation;\n      if (drag && !dragPropagation) {\n        if (_this.openGlobalLock) _this.openGlobalLock();\n        _this.openGlobalLock = getGlobalLock(drag);\n        if (!_this.openGlobalLock) return;\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    var onMove = function (event, info) {\n      var _a = _this.props,\n        dragPropagation = _a.dragPropagation,\n        dragDirectionLock = _a.dragDirectionLock;\n      // If we didn't successfully receive the gesture lock, early return.\n      if (!dragPropagation && !_this.openGlobalLock) return;\n      var offset = info.offset;\n      // Attempt to detect drag direction if directionLock is true\n      if (dragDirectionLock && _this.currentDirection === null) {\n        _this.currentDirection = getCurrentDirection(offset);\n        // If we've successfully set a direction, notify listener\n        if (_this.currentDirection !== null) {\n          var onDirectionLock = _this.props.onDirectionLock;\n          onDirectionLock && onDirectionLock(_this.currentDirection);\n        }\n        return;\n      }\n      _this.updatePoint(\"x\", offset);\n      _this.updatePoint(\"y\", offset);\n      var onDrag = _this.props.onDrag;\n      onDrag && onDrag(event, convertPanToDrag(info, _this.point));\n    };\n    var onEnd = function (event, info) {\n      _this.stop(event, info);\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  ComponentDragControls.prototype.cancelDrag = function () {\n    unblockViewportScroll();\n    this.isDragging = false;\n    this.panSession && this.panSession.end();\n    this.panSession = null;\n    if (!this.props.dragPropagation && this.openGlobalLock) {\n      this.openGlobalLock();\n      this.openGlobalLock = null;\n    }\n  };\n  ComponentDragControls.prototype.stop = function (event, info) {\n    var _a;\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    if (dragMomentum || dragElastic) {\n      var velocity = info.velocity;\n      this.animateDragEnd(velocity);\n    } else {\n      this.recordBoxInfo(this.constraints);\n    }\n    onDragEnd && onDragEnd(event, convertPanToDrag(info, this.point));\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    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  ComponentDragControls.prototype.snapToCursor = function (event) {\n    var _this = this;\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      _this.origin[axis].set(point.get());\n    });\n    this.updatePoint(\"x\", offset);\n    this.updatePoint(\"y\", offset);\n  };\n  ComponentDragControls.prototype.setPoint = function (axis, value) {\n    this.point[axis] = value;\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];\n    // If we're not dragging this axis, do an early return.\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  ComponentDragControls.prototype.updateProps = function (_a) {\n    var _this = this;\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    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;\n    // Get the `MotionValue` for both draggable axes, or create them if they don't already\n    // exist on this component.\n    bothAxis(function (axis) {\n      if (!shouldDrag(axis, drag, _this.currentDirection)) return;\n      var defaultValue = axis === \"x\" ? _dragValueX : _dragValueY;\n      _this.setPoint(axis, defaultValue || _this.values.get(axis, 0));\n    });\n    // If `dragConstraints` is a React `ref`, we should resolve the constraints once the\n    // component has rendered.\n    this.constraintsNeedResolution = isRefObject(dragConstraints);\n    this.constraints = this.constraintsNeedResolution ? this.constraints || false : dragConstraints;\n  };\n  ComponentDragControls.prototype.applyConstraintsToPoint = function (constraints) {\n    var _this = this;\n    if (constraints === void 0) {\n      constraints = this.constraints;\n    }\n    return bothAxis(function (axis) {\n      var axisPoint = _this.point[axis];\n      axisPoint && !axisPoint.isAnimating() && applyConstraints(axis, axisPoint, constraints, 0);\n    });\n  };\n  ComponentDragControls.prototype.animateDragEnd = function (velocity) {\n    var _this = this;\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      if (!shouldDrag(axis, drag, _this.currentDirection)) {\n        return;\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      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,\n      // 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    });\n    // Run all animations and then resolve the new drag constraints.\n    return Promise.all(momentumAnimations).then(function () {\n      _this.recordBoxInfo(_this.constraints);\n      _this.scalePoint();\n      var onDragTransitionEnd = _this.props.onDragTransitionEnd;\n      onDragTransitionEnd && onDragTransitionEnd();\n    });\n  };\n  ComponentDragControls.prototype.scalePoint = function () {\n    var _this = this;\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);\n    // Scale a point relative to the transformation of a constraints-providing element.\n    var scaleAxisPoint = function (axis, dimension) {\n      var pointToScale = _this.point[axis];\n      if (!pointToScale) return;\n      // Stop any current animations as they bug out if you resize during one\n      if (pointToScale.isAnimating()) {\n        pointToScale.stop();\n        _this.recordBoxInfo();\n        return;\n      }\n      // If the previous dimension was `0` (default), set `scale` to `1` to prevent\n      // divide by zero errors.\n      var scale = _this.prevConstraintsBox[dimension] ? (constraintsBox[dimension] - draggableBox[dimension]) / _this.prevConstraintsBox[dimension] : 1;\n      pointToScale.set(_this.prevConstraintsBox[axis] * scale);\n    };\n    scaleAxisPoint(\"x\", \"width\");\n    scaleAxisPoint(\"y\", \"height\");\n  };\n  ComponentDragControls.prototype.mount = function (element) {\n    var _this = this;\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    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    return function () {\n      stopPointerListener && stopPointerListener();\n      stopResizeListener && stopResizeListener();\n      _this.cancelDrag();\n    };\n  };\n  return ComponentDragControls;\n}();\n// Call a handler once for each axis\nfunction bothAxis(handler) {\n  return [handler(\"x\"), handler(\"y\")];\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}\nfunction getConstraints(axis, _a) {\n  var top = _a.top,\n    right = _a.right,\n    bottom = _a.bottom,\n    left = _a.left;\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}\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 */\nfunction getCurrentDirection(offset, lockThreshold) {\n  if (lockThreshold === void 0) {\n    lockThreshold = 10;\n  }\n  var direction = null;\n  if (Math.abs(offset.y) > lockThreshold) {\n    direction = \"y\";\n  } else if (Math.abs(offset.x) > lockThreshold) {\n    direction = \"x\";\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 */\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}\nfunction getBoundingBox(ref, transformPagePoint) {\n  var rect = ref.current.getBoundingClientRect();\n  var _a = transformPagePoint({\n      x: rect.left,\n      y: rect.top\n    }),\n    left = _a.x,\n    top = _a.y;\n  var _b = transformPagePoint({\n      x: rect.width,\n      y: rect.height\n    }),\n    width = _b.x,\n    height = _b.y;\n  return {\n    left: left,\n    top: top,\n    width: width,\n    height: height\n  };\n}\nfunction getCurrentOffset(point) {\n  return point ? point.get() : 0;\n}\nfunction applyConstraints(axis, value, constraints, dragElastic) {\n  var constrainedValue = value instanceof MotionValue ? value.get() : value;\n  if (!constraints) {\n    return constrainedValue;\n  }\n  var _a = getConstraints(axis, constraints),\n    min = _a.min,\n    max = _a.max;\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  if (value instanceof MotionValue) {\n    value.set(constrainedValue);\n  }\n  return constrainedValue;\n}\nfunction applyOverdrag(origin, current, dragElastic) {\n  var dragFactor = typeof dragElastic === \"number\" ? dragElastic : 0.35;\n  return mix(origin, current, dragFactor);\n}\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 */\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}\nvar Drag = {\n  key: \"drag\",\n  shouldRender: function (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    return useDrag(props, innerRef, values, controls);\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 */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\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}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n  if (depth === void 0) {\n    depth = 1;\n  }\n  invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\" + current + \"\\\". This may indicate a circular fallback dependency.\");\n  var _a = parseCSSVariable(current),\n    token = _a[0],\n    fallback = _a[1];\n  // No CSS variable detected\n  if (!token) return;\n  // Attempt to read this CSS variable off the element\n  var resolved = window.getComputedStyle(element).getPropertyValue(token);\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 */\nfunction resolveCSSVariables(values, ref, _a, transitionEnd) {\n  var target = __rest(_a, []);\n  var element = ref.current;\n  if (!(element instanceof HTMLElement)) return {\n    target: target,\n    transitionEnd: transitionEnd\n  };\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  if (transitionEnd) {\n    transitionEnd = __assign({}, transitionEnd);\n  }\n  // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\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  });\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  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;\n    // Clone target if it hasn't already been\n    target[key] = resolved;\n    // 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    if (transitionEnd && transitionEnd[key] === undefined) {\n      transitionEnd[key] = current;\n    }\n  }\n  return {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\nvar positionalKeys = new Set([\"width\", \"height\", \"top\", \"left\", \"right\", \"bottom\", \"x\", \"y\"]);\nvar isPositionalKey = function (key) {\n  return positionalKeys.has(key);\n};\nvar hasPositionalKey = function (target) {\n  return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (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};\nvar isNumOrPxType = function (v) {\n  return v === number || v === px;\n};\nvar BoundingBoxDimension;\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 = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n  return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (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    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};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) {\n  return !transformKeys.has(key);\n});\nfunction removeNonTranslationalTransform(values, elementStyler) {\n  var removedTransforms = [];\n  nonTranslationalTransformKeys.forEach(function (key) {\n    var value = values.get(key);\n    if (value !== undefined) {\n      removedTransforms.push([key, value.get()]);\n      value.set(key.startsWith(\"scale\") ? 1 : 0);\n    }\n  });\n  // Apply changes to element before measurement\n  if (removedTransforms.length) elementStyler.render();\n  return removedTransforms;\n}\nvar positionalValues = {\n  // Dimensions\n  width: function (_a) {\n    var width = _a.width;\n    return width;\n  },\n  height: function (_a) {\n    var height = _a.height;\n    return height;\n  },\n  top: function (_bbox, _a) {\n    var top = _a.top;\n    return parseFloat(top);\n  },\n  left: function (_bbox, _a) {\n    var left = _a.left;\n    return parseFloat(left);\n  },\n  bottom: function (_a, _b) {\n    var height = _a.height;\n    var top = _b.top;\n    return parseFloat(top) + height;\n  },\n  right: function (_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};\nvar convertChangedValueTypes = function (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  };\n  // If the element is currently set to display: \"none\", make it visible before\n  // measuring the target bounding box\n  if (display === \"none\") {\n    elementStyler.set(\"display\", target.display || \"block\");\n  }\n  // Apply the latest values (as set in checkAndConvertChangedValueTypes)\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};\nvar checkAndConvertChangedValueTypes = function (values, ref, target, transitionEnd) {\n  if (transitionEnd === void 0) {\n    transitionEnd = {};\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);\n  // 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  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;\n    // 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    if (isKeyframesTarget(to)) {\n      var numKeyframes = to.length;\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    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        if (typeof current === \"string\") {\n          value.set(parseFloat(current));\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        acc.push(key);\n        transitionEnd[key] = transitionEnd[key] !== undefined ? transitionEnd[key] : target[key];\n        setAndResetVelocity(value, to);\n      }\n    }\n    return acc;\n  }, []);\n  if (changedValueTypeKeys.length) {\n    var convertedTarget = convertChangedValueTypes(target, values, element, elementStyler, changedValueTypeKeys);\n    // If we removed transform values, reapply them before the next render\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    }\n    // Reapply original values\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 */\nfunction unitConversion(values, ref, target, transitionEnd) {\n  return hasPositionalKey(target) ? checkAndConvertChangedValueTypes(values, ref, target, transitionEnd) : {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\nvar parseDomVariant = function (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};\nfunction useForceUpdate() {\n  var _a = useState(0),\n    forcedRenderCount = _a[0],\n    setForcedRenderCount = _a[1];\n  return useCallback(function () {\n    return setForcedRenderCount(forcedRenderCount + 1);\n  }, [forcedRenderCount]);\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 */\nvar UnstableSyncLayout = function (_a) {\n  var children = _a.children;\n  var forceUpdate = useForceUpdate();\n  return createElement(SyncLayoutContext.Provider, {\n    value: forceUpdate\n  }, children);\n};\nvar _a;\nvar StepName;\n(function (StepName) {\n  StepName[\"Prepare\"] = \"prepare\";\n  StepName[\"Read\"] = \"read\";\n  StepName[\"Render\"] = \"render\";\n})(StepName || (StepName = {}));\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;\nfunction flushCallbackList(list) {\n  var numJobs = list.length;\n  for (var i = 0; i < numJobs; i++) {\n    list[i]();\n  }\n  list.length = 0;\n}\nfunction flushAllJobs() {\n  if (!jobsNeedProcessing) return;\n  flushCallbackList(jobs.prepare);\n  flushCallbackList(jobs.read);\n  flushCallbackList(jobs.render);\n  jobsNeedProcessing = false;\n}\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.\nvar createUseSyncEffect = function (stepName) {\n  return function (callback) {\n    if (!callback) return;\n    jobsNeedProcessing = true;\n    jobs[stepName].push(callback);\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);\nfunction isHTMLElement(element) {\n  return element instanceof HTMLElement;\n}\nvar defaultLayoutTransition = {\n  duration: 0.8,\n  ease: [0.45, 0.05, 0.19, 1.0]\n};\nvar defaultPositionTransition = underDampedSpring();\nfunction getDefaultLayoutTransition(isPositionOnly) {\n  return isPositionOnly ? defaultPositionTransition : defaultLayoutTransition;\n}\nfunction isResolver(transition) {\n  return typeof transition === \"function\";\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};\nfunction centerOf(min, max) {\n  return (min + max) / 2;\n}\nfunction calcAxisDelta(prev, next, names) {\n  var _a;\n  var sizeDelta = prev[names.size] - next[names.size];\n  var origin = 0.5;\n  // 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  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  var delta = (_a = {}, _a[names.size] = sizeDelta, _a[names.origin] = origin, _a[names.id] =\n  // 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}\nfunction calcDelta(prev, next) {\n  var delta = __assign(__assign({}, calcAxisDelta(prev, next, axisLabels.x)), calcAxisDelta(prev, next, axisLabels.y));\n  return delta;\n}\nvar offset = {\n  getLayout: function (_a) {\n    var offset = _a.offset;\n    return offset;\n  },\n  measure: function (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 (_a) {\n    var boundingBox = _a.boundingBox;\n    return boundingBox;\n  },\n  measure: function (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    return {\n      left: left,\n      top: top,\n      width: width,\n      height: height,\n      right: right,\n      bottom: bottom\n    };\n  }\n};\nfunction readPositionStyle(element) {\n  return window.getComputedStyle(element).position;\n}\nfunction getLayoutType(prev, next, isPositionOnly) {\n  return isPositionOnly && prev === next ? offset : boundingBox;\n}\nfunction isSizeKey(key) {\n  return key === \"width\" || key === \"height\";\n}\nfunction getTransition(_a) {\n  var layoutTransition = _a.layoutTransition,\n    positionTransition = _a.positionTransition;\n  return layoutTransition || positionTransition;\n}\nvar LayoutAnimation = /** @class */function (_super) {\n  __extends(LayoutAnimation, _super);\n  function LayoutAnimation() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\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  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;\n    // 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    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      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      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      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        if (transition[transformKey].velocity === undefined) {\n          transition[transformKey].velocity = velocity || 0;\n        }\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        target[transformKey] = targetValue;\n        var offsetToApply = !isSizeKey(layoutKey) && compare === offset ? value.get() : 0;\n        value.set(visualOrigin + offsetToApply);\n      }\n      makeTransition(\"left\", \"x\", 0, delta.x);\n      makeTransition(\"top\", \"y\", 0, delta.y);\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      target.transition = transition;\n      // 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      transitionDefinition && controls.start(target);\n      // Force a render to ensure there's no visual flickering\n      syncRenderSession.flush();\n    });\n    return null;\n  };\n  LayoutAnimation.prototype.componentDidUpdate = function () {\n    layoutSync.flush();\n  };\n  LayoutAnimation.prototype.render = function () {\n    return null;\n  };\n  LayoutAnimation.contextType = SyncLayoutContext;\n  return LayoutAnimation;\n}(Component);\nvar Layout = {\n  key: \"layout\",\n  shouldRender: function (_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\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 */\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 */\nfunction isValidMotionProp(key) {\n  return validMotionProps.has(key);\n}\nvar AnimatePropType;\n(function (AnimatePropType) {\n  AnimatePropType[\"Target\"] = \"Target\";\n  AnimatePropType[\"VariantLabel\"] = \"VariantLabel\";\n  AnimatePropType[\"AnimationSubscription\"] = \"AnimationSubscription\";\n})(AnimatePropType || (AnimatePropType = {}));\nfunction shallowCompare(next, prev) {\n  if (prev === null) return false;\n  var prevLength = prev.length;\n  if (prevLength !== next.length) return false;\n  for (var i = 0; i < prevLength; i++) {\n    if (prev[i] !== next[i]) return false;\n  }\n  return true;\n}\nvar hasUpdated = function (prev, next) {\n  return next !== undefined && (Array.isArray(prev) && Array.isArray(next) ? !shallowCompare(next, prev) : prev !== next);\n};\nfunction targetWithoutTransition(_a, mergeTransitionEnd) {\n  if (mergeTransitionEnd === void 0) {\n    mergeTransitionEnd = false;\n  }\n  var transition = _a.transition,\n    transitionEnd = _a.transitionEnd,\n    target = __rest(_a, [\"transition\", \"transitionEnd\"]);\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 */\nfunction useAnimateProp(targetAndTransition, controls, values, defaultTransition) {\n  var isInitialRender = useRef(true);\n  var prevValues = useRef(null);\n  if (!prevValues.current) {\n    prevValues.current = targetWithoutTransition(targetAndTransition, true);\n  }\n  useEffect(function () {\n    var targetToAnimate = {};\n    // These are the values we're actually animating\n    var animatingTarget = targetWithoutTransition(targetAndTransition);\n    // This is the target as it'll be once transitionEnd values are applied\n    var finalTarget = targetWithoutTransition(targetAndTransition, true);\n    // Detect which values have changed between renders\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]);\n      // 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      var isValidValue = finalTarget[key] !== null;\n      var valueHasUpdated = hasUpdated(prevValues.current[key], finalTarget[key]);\n      if (isValidValue && (valueHasUpdated || shouldAnimateOnMount)) {\n        targetToAnimate[key] = animatingTarget[key];\n      }\n    }\n    isInitialRender.current = false;\n    prevValues.current = __assign(__assign({}, prevValues.current), finalTarget);\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}\nvar labelsToArray = function (label) {\n  if (!label) {\n    return [];\n  }\n  if (Array.isArray(label)) {\n    return label;\n  }\n  return [label];\n};\nvar resolveVariantLabels = function (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 */\nvar asDependencyList = function (list) {\n  return [list.join(\",\")];\n};\nvar hasVariantChanged = function (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 */\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    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    shouldAnimate && controls.start(targetVariants);\n    hasMounted.current = true;\n  }, asDependencyList(targetVariants));\n}\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 */\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}\nvar _a$1, _b;\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);\nvar isVariantLabel$1 = function (prop) {\n  return Array.isArray(prop) || typeof prop === \"string\";\n};\nvar isAnimationSubscription = function (_a) {\n  var animate = _a.animate;\n  return animate instanceof AnimationControls;\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);\nvar getAnimationComponent = function (props) {\n  var animatePropType = undefined;\n  for (var key in AnimatePropType) {\n    if (animatePropTypeTests[key](props)) {\n      animatePropType = key;\n    }\n  }\n  return animatePropType ? AnimatePropComponents[animatePropType] : undefined;\n};\nvar Exit = {\n  key: \"exit\",\n  shouldRender: function (_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);\n    // This early return is more for types - it won't actually run because of the `shouldRender` above.\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        isPlayingExitAnimation.current = true;\n      } else if (isPlayingExitAnimation.current && animate && !(animate instanceof AnimationControls)) {\n        controls.start(animate);\n      }\n      if (!isExiting) {\n        isPlayingExitAnimation.current = false;\n      }\n    }, [isExiting]);\n  })\n};\nvar isPropValid = function (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 */\ntry {\n  var emotionIsPropValid_1 = require(\"@emotion/is-prop-valid\").default;\n  isPropValid = function (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) {\n  // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterValidProps(props) {\n  var domProps = {};\n  for (var key in props) {\n    if (isPropValid(key)) {\n      domProps[key] = props[key];\n    }\n  }\n  return domProps;\n}\nvar buildSVGProps = function (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};\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 */\nfunction createDomMotionConfig(Component) {\n  var isDOM = typeof Component === \"string\";\n  var isSVG = isDOM && svgElements.indexOf(Component) !== -1;\n  return {\n    renderComponent: function (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    /**\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 (ref, values, props, context, controls, inherit) {\n      var activeComponents = [];\n      // TODO: Consolidate Animation functionality loading strategy with other functionality components\n      var Animation = getAnimationComponent(props);\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      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        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      return activeComponents;\n    },\n    getValueControlsConfig: function (ref, values) {\n      return {\n        values: values,\n        readValueFromSource: function (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}\nvar htmlMotionComponents = htmlElements.reduce(function (acc, Component) {\n  var config = createDomMotionConfig(Component);\n  // Suppress \"Expression produces a union type that is too complex to represent\" error\n  // @ts-ignore\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 */\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\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 */\nfunction useMotionValue(initial) {\n  return useConstant(function () {\n    return motionValue(initial);\n  });\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 */\nfunction unwrapMotionValue(value) {\n  var unwrappedValue = value instanceof MotionValue ? value.get() : value;\n  return isCustomValue(unwrappedValue) ? unwrappedValue.toValue() : unwrappedValue;\n}\nvar isCustomValueType = function (v) {\n  return typeof v === \"object\" && v.mix;\n};\nvar getMixer = function (v) {\n  return isCustomValueType(v) ? v.mix : undefined;\n};\nfunction transform() {\n  var args = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    args[_i] = arguments[_i];\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}\nvar isTransformer = function (v) {\n  return typeof v === \"function\";\n};\nvar noop$1 = function (v) {\n  return v;\n};\nfunction useTransform(parent, customTransform, to, options) {\n  var value = useRef(null);\n  var comparitor = [parent];\n  var transformer = noop$1;\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  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}\n\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.\nvar maxScale = 100000;\nvar invertScale = function (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 */\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  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  var scaleX = useTransform(parentScaleX, invertScale);\n  var scaleY = useTransform(parentScaleY, invertScale);\n  return {\n    scaleX: scaleX,\n    scaleY: scaleY\n  };\n}\nfunction useOnChange(value, callback) {\n  useEffect(function () {\n    return isMotionValue(value) ? value.onChange(callback) : undefined;\n  }, [value]);\n}\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 */\nfunction useSpring(source, config) {\n  if (config === void 0) {\n    config = {};\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      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}\nvar scrollX = motionValue(0);\nvar scrollY = motionValue(0);\nvar scrollXProgress = motionValue(0);\nvar scrollYProgress = motionValue(0);\nvar setProgress = function (offset, maxOffset, value) {\n  value.set(!maxOffset || !offset ? 0 : offset / maxOffset);\n};\nvar hasEventListener = false;\nvar addScrollListener = function () {\n  hasEventListener = true;\n  if (typeof window === \"undefined\") return;\n  var updateScrollValues = function () {\n    var xOffset = window.pageXOffset;\n    var yOffset = window.pageYOffset;\n    // Set absolute positions\n    scrollX.set(xOffset);\n    scrollY.set(yOffset);\n    // Set 0-1 progress\n    setProgress(xOffset, document.body.clientWidth - window.innerWidth, scrollXProgress);\n    setProgress(yOffset, document.body.clientHeight - window.innerHeight, scrollYProgress);\n  };\n  updateScrollValues();\n  window.addEventListener(\"resize\", updateScrollValues);\n  window.addEventListener(\"scroll\", updateScrollValues, {\n    passive: true\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 */\nfunction useViewportScroll() {\n  if (!hasEventListener) {\n    addScrollListener();\n  }\n  return viewportMotionValues;\n}\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 */\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\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 */\nfunction useAnimatedState(initialState) {\n  var _a = useState(initialState),\n    animationState = _a[0],\n    onUpdate = _a[1];\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 (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\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 */\nfunction useCycle() {\n  var items = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    items[_i] = arguments[_i];\n  }\n  // TODO: After Framer X beta, remove this warning\n  warning(items.length > 1, \"useCycle syntax has changed. `useCycle([0, 1, 2])` becomes `useCycle(0, 1, 2)`\");\n  var index = useRef(0);\n  var _a = useState(items[index.current]),\n    item = _a[0],\n    setItem = _a[1];\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\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 */\nvar DragControls = /** @class */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  DragControls.prototype.subscribe = function (controls) {\n    var _this = this;\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  DragControls.prototype.start = function (event, options) {\n    this.componentControls.forEach(function (controls) {\n      controls.start(event.nativeEvent || event, options);\n    });\n  };\n  return DragControls;\n}();\nvar createDragControls = function () {\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 */\nfunction useDragControls() {\n  return useConstant(createDragControls);\n}\nvar PresenceChild = function (_a) {\n  var children = _a.children,\n    exitProps = _a.exitProps;\n  var context = useContext(MotionContext);\n  // Create a new `value` in all instances to ensure `motion` children re-render\n  // and detect any layout changes that might have occurred.\n  context = __assign(__assign({}, context), {\n    exitProps: exitProps || {}\n  });\n  return createElement(MotionContext.Provider, {\n    value: context\n  }, children);\n};\nfunction getChildKey(child) {\n  return child.key || \"\";\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    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      seenChildren.add(key);\n    }\n    allChildren.set(key, child);\n  });\n}\nfunction onlyElements(children) {\n  var filtered = [];\n  // We use forEach here instead of map as map mutates the component key by preprending `.$`\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 */\nvar AnimatePresence = function (_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;\n  // 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  var localForceUpdate = useForceUpdate();\n  var contextForceUpdate = useContext(SyncLayoutContext);\n  var forceUpdate = contextForceUpdate || localForceUpdate;\n  var isInitialRender = useRef(true);\n  // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n  var filteredChildren = onlyElements(children);\n  // 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  var presentChildren = useRef(filteredChildren);\n  // A lookup table to quickly reference components by key\n  var allChildren = useRef(new Map()).current;\n  // A living record of all currently exiting components.\n  var exiting = useRef(new Set()).current;\n  updateChildLookup(filteredChildren, allChildren);\n  // If this is the initial component render, just deal with logic surrounding whether\n  // we play onMount animations or not.\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  }\n  // If this is a subsequent render, deal with entering and exiting children\n  var childrenToRender = __spreadArrays(filteredChildren);\n  // Diff the keys of the currently-present and target children to update our\n  // exiting list.\n  var presentKeys = presentChildren.current.map(getChildKey);\n  var targetKeys = filteredChildren.map(getChildKey);\n  // Diff the present children with our target children and mark those that are exiting\n  var numPresent = presentKeys.length;\n  for (var i = 0; i < numPresent; i++) {\n    var key = presentKeys[i];\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  }\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  if (exitBeforeEnter && exiting.size) {\n    childrenToRender = [];\n  }\n  // Loop through all currently exiting components and clone them to overwrite `animate`\n  // with any `exit` prop they might have defined.\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    var onExit = function () {\n      exiting.delete(key);\n      // Remove this child from the present children\n      var removeIndex = presentChildren.current.findIndex(function (child) {\n        return child.key === key;\n      });\n      presentChildren.current.splice(removeIndex, 1);\n      // Defer re-rendering until all exiting children have indeed left\n      if (!exiting.size) {\n        presentChildren.current = filteredChildren;\n        forceUpdate();\n        onExitComplete && onExitComplete();\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  });\n  // Add `MotionContext` even to children that don't need it to ensure we're rendering\n  // the same tree between renders\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  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  return createElement(Fragment, null, exiting.size ? childrenToRender : childrenToRender.map(function (child) {\n    return cloneElement(child);\n  }));\n};\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = motionValue(null);\nif (typeof window !== \"undefined\") {\n  if (window.matchMedia) {\n    var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n    var setReducedMotionPreferences = function () {\n      return prefersReducedMotion.set(motionMediaQuery_1.matches);\n    };\n    motionMediaQuery_1.addListener(setReducedMotionPreferences);\n    setReducedMotionPreferences();\n  } else {\n    prefersReducedMotion.set(false);\n  }\n}\nfunction determineShouldReduceMotion(prefersReduced, isReducedMotion) {\n  return typeof isReducedMotion === \"boolean\" ? isReducedMotion : Boolean(prefersReduced);\n}\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 */\nfunction useReducedMotion() {\n  var isReducedMotion = useContext(MotionContext).isReducedMotion;\n  var _a = useState(determineShouldReduceMotion(prefersReducedMotion.get(), isReducedMotion)),\n    shouldReduceMotion = _a[0],\n    setShouldReduceMotion = _a[1];\n  useEffect(function () {\n    return prefersReducedMotion.onChange(function (v) {\n      setShouldReduceMotion(determineShouldReduceMotion(v, isReducedMotion));\n    });\n  }, [setShouldReduceMotion, isReducedMotion]);\n  return shouldReduceMotion;\n}\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 */\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}\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","postRender","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","getAnimatableNone","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","supportsPointerEvents","onpointerdown","supportsTouchEvents","ontouchstart","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","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","maxDepth","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":""}