{"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","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","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","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","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","DragControls","nativeEvent","prefersReducedMotion","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener"],"mappings":"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","file":"05d954cf-aa8c216dd45c4356cb1f.js","sourcesContent":["import \"core-js/modules/es6.array.find-index\";\nimport \"core-js/modules/es7.object.values\";\nimport \"core-js/modules/es6.array.reduce\";\nimport \"core-js/modules/es6.regexp.match\";\nimport \"core-js/modules/es6.regexp.split\";\nimport \"core-js/modules/es6.array.some\";\nimport \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es6.array.from\";\nimport \"core-js/modules/es6.array.filter\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.array.map\";\nimport \"core-js/modules/es6.string.starts-with\";\nimport \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/es6.array.is-array\";\nimport \"core-js/modules/es6.map\";\nimport \"core-js/modules/es6.promise\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.set\";\nimport \"core-js/modules/es6.array.for-each\";\nimport { __assign, __spreadArrays, __rest, __extends } from 'tslib';\nimport { useRef, memo, useEffect, createContext, useContext, useMemo, forwardRef, createElement, Fragment, useCallback, useState, Component, cloneElement, Children, isValidElement } from 'react';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { velocityPerSecond, distance, mix, interpolate, wrap } from '@popmotion/popcorn';\nimport styler, { createStylerFactory, buildStyleProperty, isTransformProp, transformProps, buildSVGAttrs } from 'stylefire';\nimport { invariant, warning } from 'hey-listen';\nimport { color, complex, number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { action, delay, tween, spring, keyframes as keyframes$1, inertia } from 'popmotion';\nimport * as easingLookup from '@popmotion/easing';\nimport { cubicBezier, linear } from '@popmotion/easing';\n\nvar isFloat = function isFloat(value) {\n  return !isNaN(parseFloat(value));\n};\n/**\r\n * `MotionValue` is used to track the state and velocity of motion values.\r\n *\r\n * @public\r\n */\n\n\nvar MotionValue =\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\n  if (panSession.current !== null) {\n    panSession.current.updateHandlers(handlers);\n  }\n\n  function onPointerDown(event) {\n    panSession.current = new PanSession(event, handlers, {\n      transformPagePoint: transformPagePoint\n    });\n  }\n\n  usePointerEvent(ref, \"pointerdown\", hasPanEvents && onPointerDown);\n  useUnmountEffect(function () {\n    return panSession.current && panSession.current.end();\n  });\n}\n/**\r\n * Recursively traverse up the tree to check whether the provided child node\r\n * is the parent or a descendant of it.\r\n *\r\n * @param parent - Element to find\r\n * @param child - Element to test against parent\r\n */\n\n\nvar isNodeOrChild = function isNodeOrChild(parent, child) {\n  if (!child) {\n    return false;\n  } else if (parent === child) {\n    return true;\n  } else {\n    return isNodeOrChild(parent, child.parentElement);\n  }\n};\n\nvar order = [\"whileHover\", \"whileTap\", \"whileDrag\"];\n\nvar getGesturePriority = function getGesturePriority(gesture) {\n  return order.indexOf(gesture) + 1;\n};\n\nfunction createLock(name) {\n  var lock = null;\n  return function () {\n    var openLock = function openLock() {\n      lock = null;\n    };\n\n    if (lock === null) {\n      lock = name;\n      return openLock;\n    }\n\n    return false;\n  };\n}\n\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\n\nfunction getGlobalLock(drag) {\n  var lock = false;\n\n  if (drag === \"y\") {\n    lock = globalVerticalLock();\n  } else if (drag === \"x\") {\n    lock = globalHorizontalLock();\n  } else {\n    var openHorizontal_1 = globalHorizontalLock();\n    var openVertical_1 = globalVerticalLock();\n\n    if (openHorizontal_1 && openVertical_1) {\n      lock = function lock() {\n        openHorizontal_1();\n        openVertical_1();\n      };\n    } else {\n      // Release the locks because we don't use them\n      if (openHorizontal_1) openHorizontal_1();\n      if (openVertical_1) openVertical_1();\n    }\n  }\n\n  return lock;\n}\n\nvar tapGesturePriority = getGesturePriority(\"whileTap\");\n/**\r\n * @param handlers -\r\n * @internal\r\n */\n\nfunction useTapGesture(_a, ref) {\n  var onTap = _a.onTap,\n      onTapStart = _a.onTapStart,\n      onTapCancel = _a.onTapCancel,\n      whileTap = _a.whileTap,\n      controls = _a.controls;\n  var hasTapListeners = onTap || onTapStart || onTapCancel || whileTap;\n  var isTapping = useRef(false);\n  var cancelPointerEventListener = useRef(null);\n\n  function removePointerUp() {\n    cancelPointerEventListener.current && cancelPointerEventListener.current();\n    cancelPointerEventListener.current = null;\n  }\n\n  if (whileTap && controls) {\n    controls.setOverride(whileTap, tapGesturePriority);\n  } // We load this event handler into a ref so we can later refer to\n  // onPointerUp.current which will always have reference to the latest props\n\n\n  var onPointerUp = useRef(null);\n\n  onPointerUp.current = function (event, info) {\n    var element = ref.current;\n    removePointerUp();\n    if (!isTapping.current || !element) return;\n    isTapping.current = false;\n\n    if (controls && whileTap) {\n      controls.clearOverride(tapGesturePriority);\n    } // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n\n\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock) return;\n    openGestureLock();\n\n    if (!isNodeOrChild(element, event.target)) {\n      onTapCancel && onTapCancel(event, info);\n    } else {\n      onTap && onTap(event, info);\n    }\n  };\n\n  function onPointerDown(event, info) {\n    removePointerUp();\n    cancelPointerEventListener.current = addPointerEvent(window, \"pointerup\", function (event, info) {\n      return onPointerUp.current(event, info);\n    });\n    var element = ref.current;\n    if (!element || isTapping.current) return;\n    isTapping.current = true;\n    onTapStart && onTapStart(event, info);\n\n    if (controls && whileTap) {\n      controls.startOverride(tapGesturePriority);\n    }\n  }\n\n  usePointerEvent(ref, \"pointerdown\", hasTapListeners ? onPointerDown : undefined);\n  useUnmountEffect(removePointerUp);\n}\n\nvar hoverPriority = getGesturePriority(\"whileHover\");\n\nvar filterTouch = function filterTouch(listener) {\n  return function (event, info) {\n    if (isMouseEvent(event)) listener(event, info);\n  };\n};\n/**\r\n *\r\n * @param props\r\n * @param ref\r\n * @internal\r\n */\n\n\nfunction useHoverGesture(_a, ref) {\n  var whileHover = _a.whileHover,\n      onHoverStart = _a.onHoverStart,\n      onHoverEnd = _a.onHoverEnd,\n      controls = _a.controls;\n\n  if (whileHover && controls) {\n    controls.setOverride(whileHover, hoverPriority);\n  }\n\n  usePointerEvent(ref, \"pointerenter\", filterTouch(function (event, info) {\n    if (onHoverStart) onHoverStart(event, info);\n\n    if (whileHover && controls) {\n      controls.startOverride(hoverPriority);\n    }\n  }));\n  usePointerEvent(ref, \"pointerleave\", filterTouch(function (event, info) {\n    if (onHoverEnd) onHoverEnd(event, info);\n\n    if (whileHover && controls) {\n      controls.clearOverride(hoverPriority);\n    }\n  }));\n}\n/**\r\n * Add pan and tap gesture recognition to an element.\r\n *\r\n * @param props - Gesture event handlers\r\n * @param ref - React `ref` containing a DOM `Element`\r\n * @public\r\n */\n\n\nfunction useGestures(props, ref) {\n  usePanGesture(props, ref);\n  useTapGesture(props, ref);\n  useHoverGesture(props, ref);\n}\n\nvar makeRenderlessComponent = function makeRenderlessComponent(hook) {\n  return function (props) {\n    hook(props);\n    return null;\n  };\n};\n\nvar gestureProps = [\"onPan\", \"onPanStart\", \"onPanEnd\", \"onPanSessionStart\", \"onTap\", \"onTapStart\", \"onTapCancel\", \"whileTap\", \"whileHover\", \"onHoverStart\", \"onHoverEnd\"];\nvar Gestures = {\n  key: \"gestures\",\n  shouldRender: function shouldRender(props) {\n    return gestureProps.some(function (key) {\n      return props.hasOwnProperty(key);\n    });\n  },\n  Component: makeRenderlessComponent(function (_a) {\n    var innerRef = _a.innerRef,\n        props = __rest(_a, [\"innerRef\"]);\n\n    useGestures(props, innerRef);\n  })\n};\n\nvar isRefObject = function isRefObject(ref) {\n  return typeof ref === \"object\" && ref.hasOwnProperty(\"current\");\n};\n\nvar noop = function noop(v) {\n  return v;\n};\n\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\nvar scrollX = motionValue(0);\nvar scrollY = motionValue(0);\nvar scrollXProgress = motionValue(0);\nvar scrollYProgress = motionValue(0);\n\nvar setProgress = function setProgress(offset, maxOffset, value) {\n  value.set(!maxOffset || !offset ? 0 : offset / maxOffset);\n};\n\nvar hasEventListener = false;\n\nvar addScrollListener = function addScrollListener() {\n  hasEventListener = true;\n  if (typeof window === \"undefined\") return;\n\n  var updateScrollValues = function updateScrollValues() {\n    var xOffset = window.pageXOffset;\n    var yOffset = window.pageYOffset; // Set absolute positions\n\n    scrollX.set(xOffset);\n    scrollY.set(yOffset); // Set 0-1 progress\n\n    setProgress(xOffset, document.body.clientWidth - window.innerWidth, scrollXProgress);\n    setProgress(yOffset, document.body.clientHeight - window.innerHeight, scrollYProgress);\n  };\n\n  updateScrollValues();\n  window.addEventListener(\"resize\", updateScrollValues);\n  window.addEventListener(\"scroll\", updateScrollValues, {\n    passive: true\n  });\n};\n\nvar viewportMotionValues = {\n  scrollX: scrollX,\n  scrollY: scrollY,\n  scrollXProgress: scrollXProgress,\n  scrollYProgress: scrollYProgress\n};\n/**\r\n * Provides `MotionValue`s that update when the viewport scrolls:\r\n *\r\n * - `scrollX` — Horizontal scroll distance in pixels.\r\n * - `scrollY` — Vertical scroll distance in pixels.\r\n * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.\r\n * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.\r\n *\r\n * **Note:** If the returned scroll `MotionValue`s don't seem to be updating,\r\n * double check if the `body` tag styles are set to `width: 100%; height: 100%` or\r\n * similar, as this can break accurate measurement of viewport scroll.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import {\r\n *   Frame,\r\n *   useViewportScroll,\r\n *   useTransform\r\n * } from \"framer\"\r\n *\r\n * export function MyComponent() {\r\n *   const { scrollYProgress } = useViewportScroll()\r\n *   return <Frame scaleX={scrollYProgress} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * export const MyComponent = () => {\r\n *   const { scrollYProgress } = useViewportScroll()\r\n *   return <motion.div style={{ scaleX: scrollYProgress }} />\r\n * }\r\n * ```\r\n *\r\n * @internalremarks\r\n * This isn't technically a hook yet, but in the future it might be nice\r\n * to accept refs to elements and add scroll listeners to those, which\r\n * may involve the use of lifecycle.\r\n *\r\n * @public\r\n */\n\nfunction useViewportScroll() {\n  if (!hasEventListener) {\n    addScrollListener();\n  }\n\n  return viewportMotionValues;\n}\n/**\r\n * Creates `AnimationControls`, which can be used to manually start, stop\r\n * and sequence animations on one or more components.\r\n *\r\n * The returned `AnimationControls` should be passed to the `animate` property\r\n * of the components you want to animate.\r\n *\r\n * These components can then be animated with the `start` method.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from 'react'\r\n * import { Frame, useAnimation } from 'framer'\r\n *\r\n * export function MyComponent(props) {\r\n *    const controls = useAnimation()\r\n *\r\n *    controls.start({\r\n *        x: 100,\r\n *        transition: { duration: 0.5 },\r\n *    })\r\n *\r\n *    return <Frame animate={controls} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * import * as React from 'react'\r\n * import { motion, useAnimation } from 'framer-motion'\r\n *\r\n * export function MyComponent(props) {\r\n *    const controls = useAnimation()\r\n *\r\n *    controls.start({\r\n *        x: 100,\r\n *        transition: { duration: 0.5 },\r\n *    })\r\n *\r\n *    return <motion.div animate={controls} />\r\n * }\r\n * ```\r\n *\r\n * @returns Animation controller with `start` and `stop` methods\r\n *\r\n * @public\r\n */\n\n\nfunction useAnimation() {\n  var animationControls = useConstant(function () {\n    return new AnimationControls();\n  });\n  useEffect(function () {\n    animationControls.mount();\n    return function () {\n      return animationControls.unmount();\n    };\n  }, []);\n  return animationControls;\n}\n/**\r\n * Experimental API.\r\n *\r\n * Makes an animated version of `useState`.\r\n *\r\n * @remarks\r\n *\r\n * When the returned state setter is called, values will be animated to their new target.\r\n *\r\n * This allows the animation of arbitrary React components.\r\n *\r\n * **Note:** When animating DOM components, it's always preferable to use the `animate` prop, as Framer\r\n * will bypass React's rendering cycle with one optimised for 60fps motion. This Hook is specifically\r\n * for animating props on arbitrary React components, or for animating text content.\r\n *\r\n * ```jsx\r\n * const [state, setState] = useAnimatedState({ percentage: 0 })\r\n *\r\n * return (\r\n *   <Graph\r\n *     percentage={state.percentage}\r\n *     onTap={() => setState({ percentage: 50 })}\r\n *   />\r\n * )\r\n * ```\r\n *\r\n * @internalremarks\r\n *\r\n * TODO:\r\n * - Make hook accept a typed version of Target that accepts any value (not just DOM values)\r\n * - Allow hook to accept single values. ie useAnimatedState(0)\r\n * - Allow providing MotionValues via initialState.\r\n *\r\n * @beta\r\n */\n\n\nfunction useAnimatedState(initialState) {\n  var _a = useState(initialState),\n      animationState = _a[0],\n      onUpdate = _a[1];\n\n  var config = useConstant(function () {\n    return {\n      onUpdate: onUpdate\n    };\n  });\n  var values = useMotionValues(config);\n  var controls = useValueAnimationControls({\n    values: values,\n    readValueFromSource: function readValueFromSource(key) {\n      return animationState[key];\n    }\n  }, {}, false);\n  var startAnimation = useConstant(function () {\n    return function (animationDefinition) {\n      return controls.start(animationDefinition);\n    };\n  });\n  useEffect(function () {\n    values.mount();\n    return function () {\n      return values.unmount();\n    };\n  }, []);\n  return [animationState, startAnimation];\n}\n/**\r\n * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import { Frame, useCycle } from \"framer\"\r\n *\r\n * export function MyComponent() {\r\n *   const [x, cycleX] = useCycle(0, 50, 100)\r\n *\r\n *   return (\r\n *     <Frame\r\n *       animate={{ x: x }}\r\n *       onTap={() => cycleX()}\r\n *      />\r\n *    )\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * An index value can be passed to the returned `cycle` function to cycle to a specific index.\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import { motion, useCycle } from \"framer-motion\"\r\n *\r\n * export const MyComponent = () => {\r\n *   const [x, cycleX] = useCycle(0, 50, 100)\r\n *\r\n *   return (\r\n *     <motion.div\r\n *       animate={{ x: x }}\r\n *       onTap={() => cycleX()}\r\n *      />\r\n *    )\r\n * }\r\n * ```\r\n *\r\n * @param items - items to cycle through\r\n * @returns [currentState, cycleState]\r\n *\r\n * @public\r\n */\n\n\nfunction useCycle() {\n  var items = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    items[_i] = arguments[_i];\n  } // TODO: After Framer X beta, remove this warning\n\n\n  warning(items.length > 1, \"useCycle syntax has changed. `useCycle([0, 1, 2])` becomes `useCycle(0, 1, 2)`\");\n  var index = useRef(0);\n\n  var _a = useState(items[index.current]),\n      item = _a[0],\n      setItem = _a[1];\n\n  return [item, function (next) {\n    index.current = typeof next !== \"number\" ? wrap(0, items.length, index.current + 1) : next;\n    setItem(items[index.current]);\n  }];\n}\n/**\r\n * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * const dragControls = useDragControls()\r\n *\r\n * function startDrag(event) {\r\n *   dragControls.start(event, { snapToCursor: true })\r\n * }\r\n *\r\n * return (\r\n *   <>\r\n *     <Frame onTapStart={startDrag} />\r\n *     <Frame drag=\"x\" dragControls={dragControls} />\r\n *   </>\r\n * )\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * const dragControls = useDragControls()\r\n *\r\n * function startDrag(event) {\r\n *   dragControls.start(event, { snapToCursor: true })\r\n * }\r\n *\r\n * return (\r\n *   <>\r\n *     <div onMouseDown={startDrag} />\r\n *     <motion.div drag=\"x\" dragControls={dragControls} />\r\n *   </>\r\n * )\r\n * ```\r\n *\r\n * @public\r\n */\n\n\nvar DragControls =\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({ isOpem }) {\r\n *   const shouldReduceMotion = useReducedMotion()\r\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\r\n *\r\n *   return (\r\n *     <motion.div animate={{\r\n *       opacity: isOpen ? 1 : 0,\r\n *       x: isOpen ? 0 : closedX\r\n *     }} />\r\n *   )\r\n * }\r\n * ```\r\n *\r\n * @return boolean\r\n *\r\n * @public\r\n */\n\n\nfunction useReducedMotion() {\n  var isReducedMotion = useContext(MotionContext).isReducedMotion;\n\n  var _a = useState(determineShouldReduceMotion(prefersReducedMotion.get(), isReducedMotion)),\n      shouldReduceMotion = _a[0],\n      setShouldReduceMotion = _a[1];\n\n  useEffect(function () {\n    return prefersReducedMotion.onChange(function (v) {\n      setShouldReduceMotion(determineShouldReduceMotion(v, isReducedMotion));\n    });\n  }, [setShouldReduceMotion, isReducedMotion]);\n  return shouldReduceMotion;\n}\n/**\r\n * Define accessibility options for a tree. Can be used to force the tree into Reduced Motion mode,\r\n * or disable device detection.\r\n *\r\n * @internal\r\n */\n\n\nfunction ReducedMotion(_a) {\n  var children = _a.children,\n      enabled = _a.enabled;\n  var context = useContext(MotionContext);\n  context = useMemo(function () {\n    return __assign(__assign({}, context), {\n      isReducedMotion: enabled\n    });\n  }, [enabled]);\n  return createElement(MotionContext.Provider, {\n    value: context\n  }, children);\n}\n\nexport { AnimatePresence, AnimationControls, DragControls, MotionContext, MotionPluginContext, MotionPlugins, MotionValue, Point, ReducedMotion, UnstableSyncLayout, animationControls, createMotionComponent, isValidMotionProp, motion, motionValue, transform, unwrapMotionValue, useAnimatedState, useAnimation, useCycle, useDomEvent, useDragControls, useExternalRef, useGestures, useInvertedScale, useMotionValue, usePanGesture, usePresence, useReducedMotion, useSpring, useTapGesture, useTransform, useViewportScroll };"],"sourceRoot":""}