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