{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/framer-motion.es.js"],"names":["MotionValue","init","value","_this","this","timeDelta","lastUpdated","canTrackVelocity","updateAndNotify","v","render","prev","current","updateSubscribers","forEach","notifySubscriber","renderSubscribers","_a","delta","timestamp","postRender","scheduleVelocityCheck","subscriber","velocityCheck","set","isNaN","parseFloat","prototype","subscribeTo","subscriptions","subscription","updateSubscriber","add","onChange","Set","onRenderRequest","attach","passiveEffect","get","getPrevious","getVelocity","start","animation","stop","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","clear","motionValue","useConstant","ref","resolver","isMotionValue","updateStyler","onRead","onRender","state","onUpdate","MotionValuesMap","hasMounted","values","Map","unsubscribers","has","key","bindValueToOutput","unsubscribe","defaultValue","undefined","callback","unsubscribeOnRender","output","unsubscribeOnChange","setOnUpdate","setTransformTemplate","transformTemplate","updateTransformTemplate","mount","unmount","_value","specialMotionValueProps","resolveCurrent","resolvedValues","transformOriginProps","isTransformOriginProp","buildStyleAttr","styleProp","props","isStatic","motionValueStyles","transform","emptyObject","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","opts","from","velocity","easings","map","getTransitionDefinition","transitionDefinition","delay","when","delayChildren","staggerChildren","staggerDirection","transition","Object","keys","isTransitionDefined","valueKey","transitionFactory","getDefaultTransition","valueTransitionDefinition","hasOwnProperty","getAnimation","target","origin","isOriginAnimatable","isTargetAnimatable","_b","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","children","child","startOverride","override","clearOverride","highest","resetIsAnimating","overrideTarget","remainingValues","onStart","onComplete","applyVariantLabels","variantLabelList","reverse","animateVariantLabels","animateVariant","animationDefinition","transitionOverride","_e","getOriginFromTransition","getOrigin","animatable","animations","valueTarget","push","allAnimations","all","variantLabels","label","variantLabel","getAnimations","getChildrenAnimations","animateChildren","last","first","maxStaggerDuration","generateStaggerDuration","childControls","onAnimationStart","onAnimationComplete","checkOverrideIsAnimating","numOverrides","resolvedOverride","addChild","controls","removeChild","resetChildren","AnimationControls","pendingAnimations","componentControls","subscribe","animations_1","PresenceContext","useMotionValue","initial","resolveMotionValue","unwrappedValue","Boolean","mix","toValue","noop","any","convertBoundingBoxToAxisBox","top","min","left","right","bottom","transformBoundingBox","transformPoint","topLeft","bottomRight","calcAxisCenter","clampProgress","snapshotLayout","element","safeSize","getBoundingBox","snapshotStyle","valueHandlers","computedStyle","getComputedStyle","style","handler","read","display","snapshot","layout","calcDelta","before","after","beforeSize","afterSize","calcOrigin","originPoint","translate","calcTranslate","isNear","applyDelta","point","scaledPoint","applyAxisDelta","axis","applyBoxDelta","box","zeroDelta","tweenAxis","next","p","defaultHandler","snapshotTarget","batchTransitions","queue","flush","order","sort","sortByDepth","resetStyles","a","b","depth","maxDistance","resetAxis","originAxis","MotionContext","magicDepth","isVariantLabel","isAnimationControls","useMotionContext","parentContext","initialState","whileTap","whileHover","layoutId","presenceContext","shouldPropagateControls","targetInitial","targetAnimate","initialDependency","animateDependency","magicDelta","createZeroDelta","magicDeltas","magicProgress","context","isReducedMotion","isInitialOnly","isInitialRender","useInitialOrEveryRender","initialToApply","isVisible","checkShouldInheritVariant","inherit","isRefObject","session","syncRenderSession","view","id","subscribers","sub","NativeElement","stylerConfig","externalRef","mountSubscriptions","unmountSubscriptions","Element","styler","onMount","onUnmount","setStyle","getStyle","getInstance","getBoundingClientRect","window","forceRender","subscriberSymbol","Symbol","MotionPluginContext","transformPagePoint","autoValues","features","createMotionComponent","getValueControlsConfig","loadFeatures","renderComponent","motionValues","useMotionValues","prevMotionStyles","thisStyle","useMotionStyles","shouldInheritVariant","nativeElement","enableHardwareAcceleration","allowTransformNone","preparseOutput","useNativeElement","config","subscribeToParentControls","parentControls","isPresent","unmountProps","useValueAnimationControls","plugins","renderedComponent","Provider","svgElements","useUnmountEffect","addDomEvent","eventName","addEventListener","removeEventListener","isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","e","changedTouches","pointFromMouse","extractEventInfo","Point","wrapHandler","shouldFilterPrimaryPointer","listener","eventHandler","button","filterPrimaryPointer","isBrowser","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","onpointerdown","ontouchstart","onmousedown","addPointerEvent","usePointerEvent","useDomEvent","subtract","relativeTo","idOrElem","elem","localElem","document","getElementById","rect","scrollX","scrollY","isViewportScrollBlocked","preventDefault","passive","unblockViewportScroll","PanSession","handlers","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","offset","onMove","initialInfo","onSessionStart","removeOnPointerMove","handlePointerMove","removeOnPointerUp","handlePointerUp","removeListeners","buttons","end","onEnd","panInfo","updateHandlers","lastDevicePoint","startDevicePoint","getVelocity$1","timestampedPoint","lastPoint","time","currentVelocity","Infinity","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","parent","parentElement","useTapGesture","onHoverStart","onHoverEnd","useHoverGesture","makeRenderlessComponent","hook","gestureProps","Gestures","shouldRender","some","Component","elementDragControls","WeakMap","ComponentDragControls","isDragging","currentDirection","constraints","openGlobalLock","originEvent","snapToCursor","stopMotion","constraintsNeedResolution","dragConstraints","transformPagePoint_1","onMeasureDragConstraints","calculateConstraintsFromDom","applyConstraintsToPoint","convertAxisBoxToBoundingBox","bothAxis","axisPoint","dragPropagation","onDragStart","convertPanToDrag","dragDirectionLock","lockThreshold","direction","abs","getCurrentDirection","onDirectionLock","onDrag","cancelDrag","dragMomentum","dragElastic","onDragEnd","animateDragEnd","recordBoxInfo","prevConstraints","boundingBox","center","setPoint","shouldDrag","applyConstraints","updateProps","_f","_g","remainingProps","_dragValueX","_dragValueY","dragOriginX","dragOriginY","dragTransition","_dragTransitionControls","momentumAnimations","bounceStiffness","bounceDamping","animationControls","timeConstant","externalAxisMotionValue","scalePoint","onDragTransitionEnd","constraintsBox","draggableBox","scaleAxisPoint","pointToScale","width","constraintsWidth","draggableWidth","stopPointerListener","dragListener","stopResizeListener","constraintsElement","draggableElement","_point","parentBoundingBox","draggableTransform","parentBox","draggableBoundingBox","calculateAxisConstraints","parentAxis","draggableAxis","constrainedValue","applyOverdrag","dragFactor","usePresence","onExitComplete","register","useDrag","groupDragControls","dragControls","safeToRemove","useDisableDragOnExit","Drag","isCSSVariable","cssVariableRegex","getVariableValue","match","exec","parseCSSVariable","token","fallback","resolved","getPropertyValue","BoundingBoxDimension","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","removeNonTranslationalTransform","removedTransforms","positionalValues","height","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","fromType","toType","numKeyframes","convertedTarget","changedKeys","originBbox","elementComputedStyle","originComputedStyle","targetBbox","convertChangedValueTypes","unitConversion","hasPositionalKey","Presence","VisibilityAction","StackPosition","parseDomVariant","HTMLElement","resolveCSSVariables","SharedLayoutContext","convertSingleRadius","parsed","radiusAsPixels","singleBorderRadius","reset","borderRadius","createUpdater","treeScale","originBox","targetBox","originAsPixels","targetAsPixels","vx","vy","targetX","targetY","latest","defaultMagicValues","background","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","isEmptyBoxShadow","originShadow","getAnimatableShadow","targetShadow","currentShadow","mixShadowColor","shadowTemplate","createTransformer","dx","dy","averageXYScale","averageTreeXTScale","shadow","AnimatePropType","Auto","_super","call","willAnimate","shouldAnimate","correctedLayout","frameTarget","hasAnimatedRotate","localContext","progress","supportedAutoValues","animatableStyles","componentDidMount","sharedLayoutContext","unregisterSharedLayoutContext","componentDidUpdate","prevProps","layoutOrder","move","getSnapshotBeforeUpdate","snapshotOrigin","componentWillUnmount","stopLayoutAnimation","shouldComponentUpdate","nextProps","hasDependency","magicDependency","dependencyHasChanged","presenceHasChanged","resetRotation","applyCurrent","measuredOrigin","measuredTarget","hide","show","newOpacity","setVisibility","visibilityAction","Show","animationPromise","visualTarget","visualOrigin","parentDeltas","deltas","numDeltas","isTreeVisible","startLayoutAnimation","startStyleAnimation","onMagicComplete","originStyle","targetStyle","isAnimatingRotate","updaters","frame","updateBoundingBox","updateTransform","updateRotate","updater","crossfade","unsubscribeParentProgress","scheduleUpdate","unsubscribeProgress","shouldAnimateStyle","numAnimatableStyles","nextStyle","applyTreeDeltas","tweenAxisBox","calcBoxDelta","Auto$1","validMotionProps","isValidMotionProp","targetWithoutTransition","mergeTransitionEnd","resolveVariantLabels","unresolvedVariant","AnimatePropComponents","Target","targetAndTransition","prevValues","targetToAnimate","animatingTarget","finalTarget","shouldAnimateOnMount","isValidValue","valueHasUpdated","prevLength","shallowCompare","useAnimateProp","VariantLabel","targetVariants","parentAlreadyMounted","oldVariant","newVariant","join","useVariants","AnimationSubscription","useAnimationGroupSubscription","isAnimationSubscription","animationProps","animatePropTypeTests","prop","Exit","exit","isPlayingExitAnimation","isPropValid","emotionIsPropValid_1","defaultFeatures","createDomMotionConfig","ComponentToRender","isDOM","isSVG","forwardedProps","domProps","filterValidProps","staticVisualStyles","buildSVGProps","htmlProps","userSelect","draggable","buildHTMLProps","allFeatures","numFeatures","activeComponents","Animation","animatePropType","getAnimationComponent","htmlMotionComponents","reduce","acc","svgMotionComponents","motion","PresenceChild","_onExitComplete","numPresenceChildren","numExitComplete","allComplete","getChildKey","AnimatePresence","exitBeforeEnter","forcedRenderCount","setForcedRenderCount","useForceUpdate","magicContext","filteredChildren","filtered","onlyElements","presentChildren","allChildren","exiting","updateChildLookup","childrenToRender","presentKeys","targetKeys","numPresent","insertionIndex","splice","removeIndex","findIndex","presentChild","createSwitchAnimation","_isRoot","stack","lead","Hide","presence","Entering","prevLead","getFollowOrigin","Exiting","getFollowTarget","createCrossfadeAnimation","isRoot","stackLead","stackLeadPresence","follow","getLeadTarget","getLeadOrigin","crossfadeIn","crossfadeOut","compress","easing","easeCrossfadeIn","easeCrossfadeOut","_origin","_target","LayoutStack","index","stackChild","remove","updateLeadAndFollow","prevFollow","leadIndex","numInStack","lastIsPresent","findLeadAndFollow","updateSnapshot","isLeadPresent","defaultLayoutTransition","AnimateSharedLayout","arguments","stacks","batch","shouldRerender","setState","removeChildFromStack","addChildToStack","nextState","shouldTransition","dependency","hasChanged","supportRotate","setRootDepth","Present","getStack","rootDepth","numAnimations","numCompletedAnimations","createAnimation","isAutoAnimate","prefersReducedMotion","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","DragControls","nativeEvent"],"mappings":"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","file":"05d954cf-401ac0e95c1a3ca7d800.js","sourcesContent":["import \"core-js/modules/es7.object.values\";\nimport \"core-js/modules/es6.array.find-index\";\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.weak-map\";\nimport \"core-js/modules/es6.array.some\";\nimport \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es7.symbol.async-iterator\";\nimport \"core-js/modules/es6.symbol\";\nimport \"core-js/modules/es6.array.sort\";\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, createContext, useContext, useMemo, useEffect, createElement, forwardRef, Fragment, Component, useCallback, useState, cloneElement, Children, isValidElement } from 'react';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { velocityPerSecond, clamp, distance, mix, progress, mixColor, interpolate, wrap } from '@popmotion/popcorn';\nimport styler, { createStylerFactory, buildStyleProperty, isTransformProp, transformProps, buildSVGAttrs } from 'stylefire';\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 { invariant, warning } from 'hey-listen';\nimport * as easingLookup from '@popmotion/easing';\nimport { cubicBezier, linear, circOut } 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) {\n    var _this = this;\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 = v;\n\n      if (_this.updateSubscribers && _this.prev !== _this.current) {\n        _this.updateSubscribers.forEach(_this.notifySubscriber);\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\n    this.set(init, false);\n    this.canTrackVelocity = isFloat(this.current);\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   * @public\r\n   */\n\n\n  MotionValue.prototype.getPrevious = function () {\n    return this.prev;\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.stop();\n  };\n\n  return MotionValue;\n}();\n/**\r\n * @internal\r\n */\n\n\nfunction motionValue(init) {\n  return new MotionValue(init);\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[\"delete\"] = function (key) {\n    this.values[\"delete\"](key);\n    var unsubscribe = this.unsubscribers.get(key);\n    unsubscribe && unsubscribe();\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.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\", \"_dragValueX\", \"_dragValueY\"]);\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 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, props, isStatic) {\n  var motionValueStyles = resolveCurrent(values);\n  var transformTemplate = props.transformTemplate;\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 emptyObject = function emptyObject() {\n  return {};\n};\n\nvar useMotionStyles = function useMotionStyles(values, styleProp, transformValues) {\n  if (styleProp === void 0) {\n    styleProp = {};\n  }\n\n  var style = {};\n  var prevMotionStyles = useConstant(emptyObject); // Remove MotionValues that have been removed from the style prop\n\n  for (var key in prevMotionStyles) {\n    if (styleProp[key] === undefined) {\n      values[\"delete\"](key);\n      prevMotionStyles[key] = undefined;\n    }\n  }\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 (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      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  if (_a === void 0) {\n    _a = {};\n  }\n\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 * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\r\n */\n\n\nvar isNumericalString = function isNumericalString(v) {\n  return /^\\-?\\d*\\.?\\d+$/.test(v);\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 */\n\n\nvar isVariantLabels = function isVariantLabels(v) {\n  return Array.isArray(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 _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\n    for (var key in target) {\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          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    var origin = this.transformValues(getOrigin(target, transition, this.values));\n\n    if (this.makeTargetAnimatable) {\n      var animatable = this.makeTargetAnimatable(target, origin, 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\nfunction getOriginFromTransition(key, transition) {\n  if (!transition) return;\n  var valueTransition = transition[key] || transition[\"default\"] || transition;\n  return valueTransition.from;\n}\n\nfunction getOrigin(target, transition, values) {\n  var _a, _b;\n\n  var origin = {};\n\n  for (var key in target) {\n    origin[key] = (_a = getOriginFromTransition(key, transition), _a !== null && _a !== void 0 ? _a : (_b = values.get(key)) === null || _b === void 0 ? void 0 : _b.get());\n  }\n\n  return origin;\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/**\r\n * @public\r\n */\n\n\nvar PresenceContext = createContext(null);\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\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 resolveMotionValue(value) {\n  var unwrappedValue = value instanceof MotionValue ? value.get() : value;\n  return isCustomValue(unwrappedValue) ? unwrappedValue.toValue() : unwrappedValue;\n}\n\nfunction noop(any) {\n  return any;\n}\n/**\r\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\r\n * it's easier to consider each axis individually. This function returns a bounding box\r\n * as a map of single-axis min/max values.\r\n */\n\n\nfunction convertBoundingBoxToAxisBox(_a) {\n  var top = _a.top,\n      left = _a.left,\n      right = _a.right,\n      bottom = _a.bottom;\n  return {\n    x: {\n      min: left,\n      max: right\n    },\n    y: {\n      min: top,\n      max: bottom\n    }\n  };\n}\n\nfunction convertAxisBoxToBoundingBox(_a) {\n  var x = _a.x,\n      y = _a.y;\n  return {\n    top: y.min,\n    bottom: y.max,\n    left: x.min,\n    right: x.max\n  };\n}\n/**\r\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\r\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\r\n * when measuring DOM elements and DOM event points.\r\n */\n\n\nfunction transformBoundingBox(_a, transformPoint) {\n  var top = _a.top,\n      left = _a.left,\n      bottom = _a.bottom,\n      right = _a.right;\n\n  if (transformPoint === void 0) {\n    transformPoint = noop;\n  }\n\n  var topLeft = transformPoint({\n    x: left,\n    y: top\n  });\n  var bottomRight = transformPoint({\n    x: right,\n    y: bottom\n  });\n  return {\n    top: topLeft.y,\n    left: topLeft.x,\n    bottom: bottomRight.y,\n    right: bottomRight.x\n  };\n}\n/**\r\n * Calculate the center point of the provided axis\r\n */\n\n\nfunction calcAxisCenter(_a) {\n  var min = _a.min,\n      max = _a.max;\n  return (max - min) / 2 + min;\n}\n\nvar clampProgress = clamp(0, 1);\n/**\r\n * If a bounding box is measured as 0 on either axis we encounter\r\n * divide by zero errors. We can prevent the actual errors by dividing by\r\n * an arbitrarily low amount, but then it's possible to see bugs where\r\n * child elements appear smeared across the screen. By setting each axis\r\n * to a non-zero measurement, the element itself will disappear (as you\r\n * can't invert scale: 0) but it will correctly animate back out, and it\r\n * fixes distortion on any children.\r\n */\n\nfunction safeSize(_a) {\n  var top = _a.top,\n      right = _a.right,\n      bottom = _a.bottom,\n      left = _a.left;\n  var safePixels = 0.5;\n\n  if (top === bottom) {\n    top -= safePixels;\n    bottom += safePixels;\n  }\n\n  if (left === right) {\n    left -= safePixels;\n    right += safePixels;\n  }\n\n  return {\n    top: top,\n    right: right,\n    bottom: bottom,\n    left: left\n  };\n}\n\nfunction snapshotLayout(element, transformPoint) {\n  var boundingBox = element.getBoundingBox();\n  var safeBoundingBox = safeSize(boundingBox);\n  var transformedBoundingBox = transformBoundingBox(safeBoundingBox, transformPoint);\n  return convertBoundingBoxToAxisBox(transformedBoundingBox);\n}\n\nfunction snapshotStyle(element, valueHandlers) {\n  var computedStyle = element.getComputedStyle();\n  var style = {};\n\n  for (var key in valueHandlers) {\n    var handler = valueHandlers[key];\n\n    if (handler.read === false) {\n      continue;\n    } else if (handler.read) {\n      style[key] = handler.read(computedStyle[key]);\n    } else {\n      style[key] = computedStyle[key];\n    }\n  }\n\n  warning(computedStyle.display !== \"inline\", \"Magic components can't be display: inline, as inline elements don't accept a transform. Try inline-block instead.\");\n  return style;\n}\n\nfunction snapshot(element, valueHandlers, transformPoint) {\n  return {\n    layout: snapshotLayout(element, transformPoint),\n    style: snapshotStyle(element, valueHandlers)\n  };\n}\n/**\r\n * Calculate an appropriate transform origin for this delta.\r\n *\r\n * If components don't change size, it isn't really relavent what origin we provide.\r\n * When a component is scaling, we want to generate a visually appeasing transform origin and allow\r\n * the component to scale out (or in) from there. This means 0 for components whose left edge\r\n * is the same or beyond the `before`, 1 for the inverse, and 0-1 for in between.\r\n */\n\n\nfunction calcOrigin(before, after) {\n  var origin = 0.5;\n  var beforeSize = before.max - before.min;\n  var afterSize = after.max - after.min;\n\n  if (beforeSize > afterSize) {\n    origin = progress(before.min, before.max - afterSize, after.min);\n  } else if (afterSize > beforeSize) {\n    origin = progress(after.min, after.max - beforeSize, before.min);\n  }\n\n  return clampProgress(origin);\n}\n/**\r\n * Calculate a translation value that, if applied to `after` with the given\r\n * `origin`, would return `before`\r\n */\n\n\nfunction calcTranslate(before, after, origin) {\n  var beforePoint = mix(before.min, before.max, origin);\n  var afterPoint = mix(after.min, after.max, origin);\n  return beforePoint - afterPoint;\n}\n/**\r\n * Applies a `scale` to a `point` from the given `originPoint`.\r\n */\n\n\nfunction scaledPoint(_a, point) {\n  var scale = _a.scale,\n      originPoint = _a.originPoint;\n  var distanceFromOrigin = point - originPoint;\n  var scaled = scale * distanceFromOrigin;\n  return originPoint + scaled;\n}\n/**\r\n * Calculate a transform delta that, if applied to `after`, will\r\n * create `before`.\r\n *\r\n * The transform `origin` is optional. If not provided, it'll be automatically\r\n * calculated based on the relative positions of the two bounding boxes.\r\n *\r\n * This is a mutative operation to avoid creating new objects every frame.\r\n */\n\n\nfunction calcDelta(delta, before, after, origin) {\n  var beforeSize = before.max - before.min;\n  var afterSize = after.max - after.min;\n  delta.scale = beforeSize / afterSize;\n  delta.origin = origin !== undefined ? origin : calcOrigin(before, after);\n  delta.originPoint = after.min + delta.origin * afterSize;\n  delta.translate = calcTranslate(before, after, delta.origin); // Clamp\n\n  if (isNear(delta.scale, 1, 0.0001)) delta.scale = 1;\n  if (isNear(delta.translate)) delta.translate = 0;\n}\n/**\r\n * Calculate a transform delta between before and after.\r\n *\r\n * This is a mutative operation to avoid creating new objects every frame.\r\n */\n\n\nfunction calcBoxDelta(delta, before, after, origin) {\n  calcDelta(delta.x, before.x, after.x, origin);\n  calcDelta(delta.y, before.y, after.y, origin);\n}\n/**\r\n * Apple the translation and scale delta to a single point.\r\n */\n\n\nfunction applyDelta(point, delta) {\n  return scaledPoint(delta, point) + delta.translate;\n}\n/**\r\n * Scale and translate both points on an axis.\r\n *\r\n * This is a mutative operation to avoid creating new objects every frame.\r\n */\n\n\nfunction applyAxisDelta(axis, delta) {\n  axis.min = applyDelta(axis.min, delta);\n  axis.max = applyDelta(axis.max, delta);\n}\n/**\r\n * Scale and translate both axis of a box.\r\n */\n\n\nfunction applyBoxDelta(box, delta) {\n  applyAxisDelta(box.x, delta.x);\n  applyAxisDelta(box.y, delta.y);\n}\n/**\r\n * Apply a whole tree of deltas to a box. Along the way, keep track of the\r\n * resultant scale of the tree.\r\n *\r\n * This is a mutative operation to avoid creating new objects every frame.\r\n */\n\n\nfunction applyTreeDeltas(box, treeScale, deltas) {\n  var numDeltas = deltas.length;\n  treeScale.x = treeScale.y = 1;\n\n  for (var i = 0; i < numDeltas; i++) {\n    var delta = deltas[i];\n    applyBoxDelta(box, delta);\n    treeScale.x *= delta.x.scale;\n    treeScale.y *= delta.y.scale;\n  }\n}\n\nfunction resolve(defaultValue, value) {\n  return value === undefined ? defaultValue : resolveMotionValue(value);\n}\n/**\r\n * Reset `element.style` to ensure we're not reading styles that have previously been animated.\r\n * If anything is set in the incoming style prop, use that, otherwise unset to ensure the\r\n * underlying CSS is read.\r\n *\r\n * @param styleProp\r\n */\n\n\nfunction resetStyles(style, valueHandlers) {\n  var reset = {\n    x: 0,\n    y: 0,\n    scale: 1,\n    scaleX: 1,\n    scaleY: 1,\n    rotate: 0\n  }; // TODO: We need to resolve MotionValues\n\n  for (var key in valueHandlers) {\n    var handler = valueHandlers[key];\n\n    if (style[key] !== undefined) {\n      reset[key] = style[key];\n    } else if (handler.reset) {\n      reset[key] = handler.reset(style);\n    } else {\n      reset[key] = \"\";\n    }\n  } // if (offsetSnapshot) {\n  //     Object.assign(reset, offsetSnapshot, { position: \"absolute\" })\n  // }\n\n\n  return reset;\n}\n/**\r\n * Apply the saved current styles to the provided style object.\r\n */\n\n\nfunction applyCurrent(style, current) {\n  for (var key in current) {\n    style[key] = current[key];\n  }\n}\n/**\r\n * An object representing a zero or neutral delta. Applying this as a\r\n * transform would leave a bounding box unchanged.\r\n */\n\n\nvar zeroDelta = {\n  translate: 0,\n  scale: 1,\n  origin: 0,\n  originPoint: 0\n};\n/**\r\n * Tween a single axis between two bounding boxes.\r\n *\r\n * This is a mutative operation.\r\n */\n\nfunction tweenAxis(axis, target, prev, next, p) {\n  target[axis].min = mix(prev[axis].min, next[axis].min, p);\n  target[axis].max = mix(prev[axis].max, next[axis].max, p);\n}\n/**\r\n * Tween between two bounding boxes.\r\n *\r\n * This is a mutative operation.\r\n */\n\n\nfunction tweenAxisBox(target, prev, next, p) {\n  tweenAxis(\"x\", target, prev, next, p);\n  tweenAxis(\"y\", target, prev, next, p);\n}\n\nvar defaultHandler = {\n  snapshotTarget: function snapshotTarget(child) {\n    return child.snapshotTarget();\n  },\n  startAnimation: function startAnimation(child) {\n    return child.startAnimation();\n  }\n};\n\nvar batchTransitions = function batchTransitions() {\n  var queue = new Set();\n\n  var add = function add(child) {\n    return queue.add(child);\n  };\n\n  var flush = function flush(_a) {\n    var _b = _a === void 0 ? defaultHandler : _a,\n        snapshotTarget = _b.snapshotTarget,\n        startAnimation = _b.startAnimation;\n\n    if (!queue.size) return;\n    var order = Array.from(queue).sort(sortByDepth);\n    order.forEach(function (child) {\n      return child.resetStyles();\n    });\n    order.forEach(snapshotTarget);\n    order.forEach(startAnimation);\n    queue.clear();\n  };\n\n  return {\n    add: add,\n    flush: flush\n  };\n};\n\nvar sortByDepth = function sortByDepth(a, b) {\n  return a.depth - b.depth;\n};\n\nfunction isNear(value, target, maxDistance) {\n  if (target === void 0) {\n    target = 0;\n  }\n\n  if (maxDistance === void 0) {\n    maxDistance = 0.01;\n  }\n\n  return distance(value, target) < maxDistance;\n}\n/**\r\n * Check if the provided context is the SharedLayoutContext default\r\n * or if we're the child of an AnimateSharedLayout component.\r\n */\n\n\nfunction isSharedLayoutTree(context) {\n  return !!context.register;\n}\n/**\r\n * Reset an axis to the provided origin box.\r\n *\r\n * This is a mutative operation.\r\n */\n\n\nfunction resetAxis(axis, originAxis) {\n  axis.min = originAxis.min;\n  axis.max = originAxis.max;\n}\n/**\r\n * Reset a box to the provided origin box.\r\n *\r\n * This is a mutative operation.\r\n */\n\n\nfunction resetBox(box, originBox) {\n  resetAxis(box.x, originBox.x);\n  resetAxis(box.y, originBox.y);\n}\n/**\r\n * Look up the tree to check whether we're in a visible portion\r\n * of the tree. If we're not, we can optimise away this animation.\r\n */\n\n\nfunction isTreeVisible(deltas) {\n  var isVisible = true;\n  var numDeltas = deltas.length;\n\n  for (var i = 0; i < numDeltas; i++) {\n    if (!deltas[i].isVisible) {\n      isVisible = false;\n      continue;\n    }\n  }\n\n  return isVisible;\n}\n/**\r\n * Detect which automatically animatable values don't need scale correction and can be animated normally.\r\n */\n\n\nfunction getAnimatableValues(supportedAutoValues) {\n  return Object.keys(supportedAutoValues).filter(function (key) {\n    return !supportedAutoValues[key].createUpdater;\n  });\n}\n/**\r\n * @internal\r\n */\n\n\nvar MotionContext = createContext({\n  \"static\": false,\n  magicDepth: -1\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      layoutId = _a.layoutId;\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; // TODO: We need every motion component in the stack to communicate down - for performance we can look into\n  // ditching zero deltas if this isn't a motion component\n\n  var magicDelta = useConstant(createZeroDelta);\n  var magicDeltas = useRef(__spreadArrays(parentContext.magicDeltas || [], [magicDelta]));\n  var magicProgress = useMotionValue(0); // 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      magicDepth: // TODO: Make nice isMagic\n      animate || layoutId !== undefined ? parentContext.magicDepth + 1 : parentContext.magicDepth,\n      magicDelta: magicDelta,\n      magicDeltas: magicDeltas.current,\n      magicProgress: magicProgress\n    };\n  }, [initialDependency, animateDependency, parentContext.isReducedMotion, animate, layoutId]); // 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\nfunction createZeroDelta() {\n  return {\n    x: __assign({}, zeroDelta),\n    y: __assign({}, zeroDelta),\n    isVisible: true\n  };\n}\n/**\r\n * Creates an imperative set of controls to trigger animations.\r\n *\r\n * This allows a consolidated, uniform API for animations, to be triggered by other APIs like the `animate` prop, or the gesture handlers.\r\n *\r\n * @param values\r\n * @param props\r\n * @param ref\r\n * @param subscribeToParentControls\r\n *\r\n * @internal\r\n */\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\nvar isRefObject = function isRefObject(ref) {\n  return typeof ref === \"object\" && ref.hasOwnProperty(\"current\");\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 (view) {\n      return view.render();\n    });\n    session = null;\n  },\n  push: function push(view) {\n    invariant(session !== null, \"No sync render session found\");\n    session && session.push(view);\n  }\n}; // Subscriptions need to be added with unique identifiers to make them concurrent-safe\n\nfunction subscribe(id, subscribers, sub) {\n  subscribers.set(id, sub);\n  return function () {\n    return subscribers[\"delete\"](id);\n  };\n}\n\nvar NativeElement =\n/** @class */\nfunction () {\n  function NativeElement(stylerConfig, externalRef) {\n    var _this = this;\n\n    this.hasMounted = false; // TODO: We might be able to downsize this as we only have one mount/unmount subscription\n\n    this.mountSubscriptions = new Map();\n    this.unmountSubscriptions = new Map();\n\n    this.ref = function (element) {\n      if (element !== null && !_this.hasMounted) {\n        _this.mount(element);\n      } else if (element === null) {\n        _this.unmount();\n      }\n    };\n\n    this.externalRef = externalRef;\n    this.stylerConfig = stylerConfig;\n  }\n\n  NativeElement.prototype.mount = function (element) {\n    var _this = this;\n\n    invariant(element instanceof Element, \"No ref found. Ensure components created with motion.custom forward refs using React.forwardRef\");\n    this.hasMounted = true;\n    this.current = element;\n    this.styler = styler(element, this.stylerConfig);\n    this.mountSubscriptions.forEach(function (sub) {\n      return sub(_this);\n    });\n    this.mountSubscriptions.clear();\n    if (!this.externalRef) return;\n\n    if (typeof this.externalRef === \"function\") {\n      this.externalRef(element);\n    } else if (isRefObject(this.externalRef)) {\n      this.externalRef.current = element;\n    }\n  };\n\n  NativeElement.prototype.unmount = function () {\n    var _this = this;\n\n    this.unmountSubscriptions.forEach(function (sub) {\n      return sub(_this);\n    });\n    this.unmountSubscriptions.clear();\n    delete this.current;\n    delete this.styler;\n    if (!this.externalRef) return;\n\n    if (typeof this.externalRef === \"function\") {\n      this.externalRef(null);\n    } else if (isRefObject(this.externalRef)) {\n      this.externalRef.current = null;\n    }\n  };\n\n  NativeElement.prototype.onMount = function (id, sub) {\n    return subscribe(id, this.mountSubscriptions, sub);\n  };\n\n  NativeElement.prototype.onUnmount = function (id, sub) {\n    return subscribe(id, this.unmountSubscriptions, sub);\n  };\n\n  NativeElement.prototype.setStyle = function (key, value) {\n    this.styler && this.styler.set(key, value);\n  };\n\n  NativeElement.prototype.getStyle = function (key) {\n    invariant(this.hasMounted, \"Attempting to read styles of an unmounted element\");\n    return this.styler && this.styler.get(key);\n  };\n\n  NativeElement.prototype.getInstance = function () {\n    return this.current;\n  };\n\n  NativeElement.prototype.getBoundingBox = function () {\n    return this.current.getBoundingClientRect();\n  };\n\n  NativeElement.prototype.getComputedStyle = function () {\n    return window.getComputedStyle(this.current);\n  };\n\n  NativeElement.prototype.render = function (forceRender) {\n    if (forceRender === void 0) {\n      forceRender = false;\n    }\n\n    this.styler.render(forceRender);\n  };\n\n  return NativeElement;\n}();\n\nvar subscriberSymbol = Symbol(\"self\");\n\nfunction useNativeElement(values, enableHardwareAcceleration, allowTransformNone, externalRef) {\n  if (allowTransformNone === void 0) {\n    allowTransformNone = true;\n  }\n\n  return useConstant(function () {\n    var stylerConfig = {\n      preparseOutput: false,\n      enableHardwareAcceleration: enableHardwareAcceleration,\n      allowTransformNone: allowTransformNone\n    };\n    var nativeElement = new NativeElement(stylerConfig, externalRef);\n    nativeElement.onMount(subscriberSymbol, function () {\n      values.mount(function (key, value) {\n        nativeElement.setStyle(key, value);\n\n        if (syncRenderSession.isOpen()) {\n          syncRenderSession.push(nativeElement);\n        }\n      });\n    });\n    nativeElement.onUnmount(subscriberSymbol, function () {\n      return values.unmount();\n    });\n    return nativeElement;\n  });\n}\n/**\r\n * @internal\r\n */\n\n\nvar MotionPluginContext = createContext({\n  transformPagePoint: function transformPagePoint(p) {\n    return p;\n  },\n  autoValues: {},\n  features: []\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/**\r\n * @internal\r\n */\n\n\nvar createMotionComponent = function createMotionComponent(_a) {\n  var getValueControlsConfig = _a.getValueControlsConfig,\n      loadFeatures = _a.loadFeatures,\n      renderComponent = _a.renderComponent;\n\n  function MotionComponent(props, 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, props.transformValues);\n    var shouldInheritVariant = checkShouldInheritVariant(props);\n    var nativeElement = useNativeElement(values, !isStatic, props.allowTransformNone, externalRef);\n    var controlsConfig = useConstant(function () {\n      return getValueControlsConfig(nativeElement, values);\n    });\n    var controls = useValueAnimationControls(controlsConfig, props, shouldInheritVariant);\n    var context = useMotionContext(parentContext, controls, values, isStatic, props);\n    var plugins = useContext(MotionPluginContext);\n    var features = isStatic ? null : loadFeatures(nativeElement, values, props, context, parentContext, controls, shouldInheritVariant, plugins);\n    var renderedComponent = renderComponent(nativeElement, style, values, props, isStatic); // The mount order and hierarchy is specific to ensure our element ref is hydrated by the time\n    // all plugins and features has to execute.\n\n    return createElement(Fragment, null, createElement(MotionContext.Provider, {\n      value: context\n    }, renderedComponent), features);\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\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 nativeElement = _a.nativeElement,\n        props = __rest(_a, [\"nativeElement\"]);\n\n    useGestures(props, nativeElement);\n  })\n};\nvar elementDragControls = new WeakMap();\n\nvar ComponentDragControls =\n/** @class */\nfunction () {\n  function ComponentDragControls(_a) {\n    var nativeElement = _a.nativeElement,\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 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    /**\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    this.prev = {\n      x: 0,\n      y: 0\n    };\n    this.nativeElement = nativeElement;\n    this.values = values;\n    this.controls = controls;\n    elementDragControls.set(nativeElement, this);\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      _this.stopMotion();\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            onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        _this.constraints = calculateConstraintsFromDom(dragConstraints.current, _this.nativeElement.getInstance(), _this.point, transformPagePoint_1);\n\n        _this.applyConstraintsToPoint();\n\n        onMeasureDragConstraints && onMeasureDragConstraints(convertAxisBoxToBoundingBox(_this.constraints));\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) this.prevConstraints = constraints;\n    if (this.point.x) this.prev.x = this.point.x.get();\n    if (this.point.y) this.prev.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.nativeElement.getInstance(), transformPagePoint);\n    var center = {\n      x: calcAxisCenter(boundingBox.x) + window.scrollX,\n      y: calcAxisCenter(boundingBox.y) + 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 axisPoint = _this.point[axis];\n      if (!axisPoint) return;\n\n      _this.origin[axis].set(axisPoint.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\n    if (this.constraintsNeedResolution) {\n      this.constraints = this.constraints || false;\n    } else {\n      this.constraints = dragConstraints && dragConstraints !== false ? convertBoundingBoxToAxisBox(dragConstraints) : false;\n    }\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 ? _this.constraints[axis] : {};\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.stopMotion = function () {\n    var _this = this;\n\n    bothAxis(function (axis) {\n      var axisPoint = _this.point[axis];\n      axisPoint && axisPoint.stop();\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.current, transformPagePoint);\n    var draggableBox = getBoundingBox(this.nativeElement.getInstance(), transformPagePoint); // Scale a point relative to the transformation of a constraints-providing element.\n\n    var scaleAxisPoint = function scaleAxisPoint(axis) {\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 _a = _this.prevConstraints[axis],\n          min = _a.min,\n          max = _a.max;\n      var width = max - min;\n      var constraintsWidth = constraintsBox[axis].max - constraintsBox[axis].min;\n      var draggableWidth = draggableBox[axis].max - draggableBox[axis].min;\n      var scale = width ? (constraintsWidth - draggableWidth) / width : 1;\n      pointToScale.set(_this.prev[axis] * Math.abs(scale));\n    };\n\n    scaleAxisPoint(\"x\");\n    scaleAxisPoint(\"y\");\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.current, this.nativeElement.getInstance(), 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 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(constraintsElement, draggableElement, _point, // TODO: Remove this argument if we keep transform reset\ntransformPagePoint) {\n  invariant(constraintsElement !== null && draggableElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n  var parentBoundingBox = getBoundingBox(constraintsElement, transformPagePoint);\n  var draggableTransform = draggableElement.style.transform;\n  draggableElement.style.transform = \"none\";\n  var draggableBoundingBox = getBoundingBox(draggableElement, transformPagePoint);\n  draggableElement.style.transform = draggableTransform;\n  return calculateConstraints(parentBoundingBox, draggableBoundingBox);\n}\n\nfunction calculateAxisConstraints(parentAxis, draggableAxis) {\n  var _a;\n\n  var min = parentAxis.min - draggableAxis.min;\n  var max = parentAxis.max - draggableAxis.max; // If the parent axis is actually smaller than the draggable axis then we can\n  // flip the constraints\n\n  if (parentAxis.max - parentAxis.min < draggableAxis.max - draggableAxis.min) {\n    _a = [max, min], min = _a[0], max = _a[1];\n  }\n\n  return {\n    min: min,\n    max: max\n  };\n}\n\nfunction calculateConstraints(parentBox, draggableBox) {\n  return {\n    x: calculateAxisConstraints(parentBox.x, draggableBox.x),\n    y: calculateAxisConstraints(parentBox.y, draggableBox.y)\n  };\n}\n\nfunction getBoundingBox(element, transformPagePoint) {\n  var rect = element.getBoundingClientRect();\n  return convertBoundingBoxToAxisBox(transformBoundingBox(rect, transformPagePoint));\n} // function getCurrentOffset(point?: MotionValue<number>) {\n//     return point ? point.get() : 0\n// }\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 = constraints[axis],\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 * 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, null];\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/**\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, nativeElement, values, controls) {\n  var groupDragControls = props.dragControls;\n  var transformPagePoint = useContext(MotionPluginContext).transformPagePoint;\n  var dragControls = useConstant(function () {\n    return new ComponentDragControls({\n      nativeElement: nativeElement,\n      values: values,\n      controls: controls\n    });\n  });\n  dragControls.updateProps(__assign(__assign({}, props), {\n    transformPagePoint: transformPagePoint\n  }));\n  useDisableDragOnExit(dragControls);\n  useEffect(function () {\n    return groupDragControls && groupDragControls.subscribe(dragControls);\n  }, [dragControls]);\n  useEffect(function () {\n    return dragControls.mount(nativeElement.getInstance());\n  }, []);\n}\n\nfunction useDisableDragOnExit(dragControls) {\n  var _a = usePresence(),\n      isPresent = _a[0],\n      safeToRemove = _a[1];\n\n  useEffect(function () {\n    if (!isPresent && safeToRemove) {\n      safeToRemove();\n      dragControls.stopMotion();\n    }\n  }, [isPresent]);\n}\n\nvar Drag = {\n  key: \"drag\",\n  shouldRender: function shouldRender(props) {\n    return !!props.drag;\n  },\n  Component: makeRenderlessComponent(function (_a) {\n    var nativeElement = _a.nativeElement,\n        values = _a.values,\n        controls = _a.controls,\n        props = __rest(_a, [\"nativeElement\", \"values\", \"controls\"]);\n\n    return useDrag(props, nativeElement, 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, nativeElement, _a, transitionEnd) {\n  var target = __rest(_a, []);\n\n  var element = nativeElement.getInstance();\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, nativeElement) {\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) nativeElement.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, nativeElement, changedKeys) {\n  var originBbox = nativeElement.getBoundingBox();\n  var elementComputedStyle = nativeElement.getComputedStyle();\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    nativeElement.setStyle(\"display\", target.display || \"block\");\n  } // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n\n\n  nativeElement.render();\n  var targetBbox = nativeElement.getBoundingBox();\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, nativeElement, target, origin, transitionEnd) {\n  if (origin === void 0) {\n    origin = {};\n  }\n\n  if (transitionEnd === void 0) {\n    transitionEnd = {};\n  }\n\n  target = __assign({}, target);\n  transitionEnd = __assign({}, transitionEnd);\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 = [];\n\n  for (var key in targetPositionalKeys) {\n    var value = values.get(key);\n    if (!values.has(key)) continue;\n    var from = origin[key];\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    = void 0; // 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, nativeElement);\n          hasAttemptedToRemoveTransformValues = true;\n        }\n\n        changedValueTypeKeys.push(key);\n        transitionEnd[key] = transitionEnd[key] !== undefined ? transitionEnd[key] : target[key];\n        setAndResetVelocity(value, to);\n      }\n    }\n  }\n\n  if (changedValueTypeKeys.length) {\n    var convertedTarget = convertChangedValueTypes(target, values, nativeElement, 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    nativeElement.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 * @internal\r\n */\n\n\nfunction unitConversion(values, nativeElement, target, origin, transitionEnd) {\n  return hasPositionalKey(target) ? checkAndConvertChangedValueTypes(values, nativeElement, target, origin, transitionEnd) : {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\n\nvar parseDomVariant = function parseDomVariant(values, nativeElement) {\n  return function (target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(values, nativeElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(values, nativeElement, target, origin, transitionEnd);\n  };\n};\n/**\r\n * @internal\r\n */\n\n\nvar SharedLayoutContext = createContext(batchTransitions());\nvar Presence;\n\n(function (Presence) {\n  Presence[Presence[\"Entering\"] = 0] = \"Entering\";\n  Presence[Presence[\"Present\"] = 1] = \"Present\";\n  Presence[Presence[\"Exiting\"] = 2] = \"Exiting\";\n})(Presence || (Presence = {}));\n\nvar VisibilityAction;\n\n(function (VisibilityAction) {\n  VisibilityAction[VisibilityAction[\"Hide\"] = 0] = \"Hide\";\n  VisibilityAction[VisibilityAction[\"Show\"] = 1] = \"Show\";\n})(VisibilityAction || (VisibilityAction = {}));\n\nvar StackPosition;\n\n(function (StackPosition) {\n  StackPosition[StackPosition[\"Lead\"] = 0] = \"Lead\";\n  StackPosition[StackPosition[\"Previous\"] = 1] = \"Previous\";\n})(StackPosition || (StackPosition = {}));\n\nfunction convertSingleRadius(value, axis) {\n  var parsed = parseFloat(value);\n\n  if (px.test(value)) {\n    return parsed;\n  } else {\n    var factor = parsed / 100;\n    return factor * (axis.max - axis.min);\n  }\n}\n\nfunction radiusAsPixels(value, box) {\n  var _a = value.split(\" \"),\n      x = _a[0],\n      y = _a[1];\n\n  return {\n    x: convertSingleRadius(x, box.x),\n    y: convertSingleRadius(y || x, box.y)\n  };\n}\n\nvar singleBorderRadius = function singleBorderRadius(key) {\n  return {\n    reset: function reset(style) {\n      return style.borderRadius !== undefined ? style.borderRadius : \"\";\n    },\n    createUpdater: function createUpdater(values, origin, target, current, delta, treeScale, originBox, targetBox) {\n      if (!origin && !target) return;\n      var motionValue = values.get(key, \"\");\n      var originAsPixels = radiusAsPixels(origin, originBox);\n      var targetAsPixels = radiusAsPixels(target, targetBox);\n      return function (p) {\n        var vx = mix(originAsPixels.x, targetAsPixels.x, p);\n        var vy = mix(originAsPixels.y, targetAsPixels.y, p);\n        current[key] = vx + \"px \" + vy + \"px\";\n        var targetX = vx / delta.x.scale / treeScale.x;\n        var targetY = vy / delta.y.scale / treeScale.y; // Perform the animation in pixels but if we don't need correction just set\n        // to the target so percentages have an affect going forward\n\n        var latest = p === 1 && delta.x.scale / treeScale.x / delta.y.scale / treeScale.y === 1 ? target : targetX + \"px \" + targetY + \"px\";\n        motionValue.set(latest);\n      };\n    }\n  };\n};\n\nvar defaultMagicValues = {\n  backgroundColor: {\n    reset: function reset(style) {\n      return style.background !== undefined ? style.background : \"\";\n    }\n  },\n  borderRadius: {\n    read: false\n  },\n  borderTopLeftRadius: singleBorderRadius(\"borderTopLeftRadius\"),\n  borderTopRightRadius: singleBorderRadius(\"borderTopRightRadius\"),\n  borderBottomLeftRadius: singleBorderRadius(\"borderBottomLeftRadius\"),\n  borderBottomRightRadius: singleBorderRadius(\"borderBottomRightRadius\"),\n  boxShadow: {\n    createUpdater: function createUpdater(values, origin, target, current, delta, treeScale) {\n      if (isEmptyBoxShadow(origin) && isEmptyBoxShadow(target)) {\n        return;\n      }\n\n      var originShadow = getAnimatableShadow(origin, target);\n      var targetShadow = getAnimatableShadow(target, origin);\n\n      var currentShadow = __spreadArrays(originShadow);\n\n      var mixShadowColor = mixColor(originShadow[0], currentShadow[0]);\n      var shadowTemplate = complex.createTransformer(target !== \"none\" ? target : origin);\n      var dx = delta.x;\n      var dy = delta.y;\n      var boxShadow = values.get(\"boxShadow\", \"\");\n      return function (p) {\n        // Update box shadow\n        currentShadow[0] = mixShadowColor(p); // color\n\n        currentShadow[1] = mix(originShadow[1], targetShadow[1], p); // x\n\n        currentShadow[2] = mix(originShadow[2], targetShadow[2], p); // y\n\n        currentShadow[3] = mix(originShadow[3], targetShadow[3], p); // blur\n\n        currentShadow[4] = mix(originShadow[4], targetShadow[4], p); // spread\n        // Update prev box shadow before FLIPPing\n\n        current.boxShadow = shadowTemplate(currentShadow); // Apply FLIP inversion to physical dimensions. We need to take an average scale for XY to apply\n        // to blur and spread, which affect both axis equally.\n\n        currentShadow[1] = currentShadow[1] / dx.scale / treeScale.x;\n        currentShadow[2] = currentShadow[2] / dy.scale / treeScale.y;\n        var averageXYScale = mix(dx.scale, dy.scale, 0.5);\n        var averageTreeXTScale = mix(treeScale.x, treeScale.y, 0.5);\n        currentShadow[3] = currentShadow[3] / averageXYScale / averageTreeXTScale; // blur\n\n        currentShadow[4] = currentShadow[4] / averageXYScale / averageTreeXTScale; // spread\n\n        boxShadow.set(shadowTemplate(currentShadow));\n      };\n    }\n  },\n  color: {},\n  opacity: {\n    read: function read(opacity) {\n      return opacity !== null ? parseFloat(opacity) : 0;\n    }\n  }\n};\n\nfunction getAnimatableShadow(shadow, fallback) {\n  if (shadow === \"none\") {\n    shadow = complex.getAnimatableNone(fallback);\n  }\n\n  return complex.parse(shadow);\n}\n\nfunction isEmptyBoxShadow(shadow) {\n  return !shadow || shadow === \"none\";\n}\n/**\r\n * Magic Motion relies on multiple components and class components only support, hence this\r\n * wrapper component that provides those contexts as props.\r\n */\n\n\nvar SharedLayoutContextProvider = function SharedLayoutContextProvider(props) {\n  var _a = usePresence(),\n      isPresent = _a[0],\n      safeToRemove = _a[1];\n\n  var sharedLayoutContext = useContext(SharedLayoutContext);\n\n  var _b = useContext(MotionPluginContext),\n      autoValues = _b.autoValues,\n      transformPagePoint = _b.transformPagePoint;\n\n  return createElement(Auto // We allow isPresent to be overwritten by manually setting it to true/false\n  // This is only intended for optimisations in Framer\n  , __assign({\n    // We allow isPresent to be overwritten by manually setting it to true/false\n    // This is only intended for optimisations in Framer\n    isPresent: isPresent\n  }, props, {\n    safeToRemove: safeToRemove,\n    sharedLayoutContext: sharedLayoutContext,\n    autoValues: autoValues,\n    transformPagePoint: transformPagePoint\n  }));\n};\n\nvar Auto =\n/** @class */\nfunction (_super) {\n  __extends(Auto, _super);\n\n  function Auto(props) {\n    var _this = _super.call(this, props) || this;\n    /**\r\n     * If this component is a child of both AnimateSharedLayout and AnimatePresence we need to know if\r\n     * it's safe to remove. This logic usually runs when AnimateSharedLayout triggers this component's\r\n     * startAnimation method. But if this component renders apart from AnimateSharedLayout, it needs to know\r\n     * that it didn't run this method and in the event that it's leaving the tree, can safely call `safeToRemove`.\r\n     */\n\n\n    _this.willAnimate = false;\n    /**\r\n     * We use this value to track whether, on a given render, this component should animate. This is\r\n     * decided in shouldComponentUpdate, but the logic governing both is different.\r\n     */\n\n    _this.shouldAnimate = true;\n    /**\r\n     * The `measuredOrigin` layout as corrected for all the transforms being applied up the\r\n     * auto-animate tree. We use this as the final bounding box from which we calculate a transform\r\n     * delta to our desired visual position on any given frame.\r\n     *\r\n     * This is mutable to avoid object creation on each frame.\r\n     */\n\n    _this.correctedLayout = {\n      x: {\n        min: 0,\n        max: 0\n      },\n      y: {\n        min: 0,\n        max: 0\n      }\n    };\n    /**\r\n     * The visual target we want to project our component into on a given frame.\r\n     *\r\n     * This is mutable to avoid object creation on each frame.\r\n     */\n\n    _this.frameTarget = {\n      x: {\n        min: 0,\n        max: 0\n      },\n      y: {\n        min: 0,\n        max: 0\n      }\n    };\n    /**\r\n     * A flag to check whether this component has ever animated rotate. We use this to force\r\n     * originX/Y to 0.5\r\n     */\n\n    _this.hasAnimatedRotate = false;\n    /**\r\n     * The overall scale of the local coordinate system as transformed by all parents of this component. We use this\r\n     * for scale correction on our calculated layouts and scale-affected values like `boxShadow`.\r\n     *\r\n     * This is mutable to avoid object creation on each frame.\r\n     */\n\n    _this.treeScale = {\n      x: 1,\n      y: 1\n    };\n    /**\r\n     * The current, pre-correction values of every scale-corrected value. We keep a record of these throughout\r\n     * an animation so if the animation is interrupted we can resume from this value instead of a scale-corrected\r\n     * value that may have no relevance in the next treeScale context.\r\n     */\n\n    _this.current = {\n      rotate: 0\n    }; // TODO: Can we move these back here somehow\n\n    _this.delta = props.localContext.magicDelta;\n    _this.depth = props.localContext.magicDepth;\n    _this.progress = props.localContext.magicProgress;\n    var autoValues = props.autoValues;\n    _this.supportedAutoValues = __assign(__assign({}, defaultMagicValues), autoValues);\n    _this.animatableStyles = getAnimatableValues(_this.supportedAutoValues);\n    return _this;\n  }\n\n  Auto.prototype.componentDidMount = function () {\n    var _this = this;\n\n    var sharedLayoutContext = this.props.sharedLayoutContext;\n\n    if (isSharedLayoutTree(sharedLayoutContext)) {\n      this.unregisterSharedLayoutContext = sharedLayoutContext.register(this); // Check if this render was handled by AnimateSharedLayout. If it was,\n      // the usual logic in startAnimation to tell AnimatePresence that this component is safe to remove\n      // will have run. If it wasn't, we have to do that here.\n\n      this.componentDidUpdate = function (prevProps) {\n        var layoutOrder = _this.props.layoutOrder;\n\n        if (layoutOrder !== undefined && layoutOrder !== prevProps.layoutOrder) {\n          sharedLayoutContext.move(_this);\n        }\n\n        if (!_this.willAnimate) _this.safeToRemove();\n        _this.willAnimate = false;\n      };\n    } else {\n      /**\r\n       * If we're not a child of AnimateSharedLayout we can use some default batching that will\r\n       * ensure all auto-animation read/write cycles are batched across components. This\r\n       * reduces layout thrashing and ensures all measurements are correct. Currently, because componentDidUpdate\r\n       * fires before new component componentDidMount, newly entering components are missed out and need\r\n       * AnimateSharedLayout to work correctly.\r\n       */\n      this.getSnapshotBeforeUpdate = function () {\n        _this.snapshotOrigin();\n\n        sharedLayoutContext.add(_this);\n        return null;\n      };\n\n      this.componentDidUpdate = function () {\n        return sharedLayoutContext.flush();\n      };\n    }\n  };\n\n  Auto.prototype.componentWillUnmount = function () {\n    this.unregisterSharedLayoutContext && this.unregisterSharedLayoutContext();\n    this.stopLayoutAnimation && this.stopLayoutAnimation();\n  };\n\n  Auto.prototype.shouldComponentUpdate = function (nextProps) {\n    var hasDependency = this.props.magicDependency !== undefined || nextProps.magicDependency !== undefined;\n    var dependencyHasChanged = this.props.magicDependency !== nextProps.magicDependency;\n    var presenceHasChanged = this.props.isPresent !== nextProps.isPresent;\n    this.shouldAnimate = !hasDependency || hasDependency && dependencyHasChanged || presenceHasChanged;\n    /**\r\n     * We only use the component's lifecycle methods to snapshot and animate if\r\n     * it isn't a child of AnimateSharedLayout, so we can return false from this method.\r\n     *\r\n     * We do need to fire componentDidUpdate if the component's presence has changed so\r\n     * we can fire safeToRemove on exiting components.\r\n     */\n\n    return true; //!isSharedLayoutTree(sharedLayoutContext) || presenceHasChanged\n  };\n  /**\r\n   * Reset the component's rotation so we can accurately measure its bounding box. If it's rotated\r\n   * when we snapshot, the bounding box will be reported as larger than the component's actual size.\r\n   *\r\n   * This is currently only available inside of Framer by setting supportRotate on AnimateSharedLayout.\r\n   * It incurs an extra read/write cycle triggered on shouldComponentUpdate which, in concurrent mode,\r\n   * might trigger more than once per render. So it isn't recommended for production.\r\n   */\n\n\n  Auto.prototype.resetRotation = function () {\n    var _a = this.props,\n        nativeElement = _a.nativeElement,\n        values = _a.values;\n    var rotate = values.get(\"rotate\");\n    this.current.rotate = rotate ? rotate.get() : 0;\n    if (!this.current.rotate) return;\n    nativeElement.setStyle(\"rotate\", 0);\n    nativeElement.render();\n  };\n  /**\r\n   * Reset styles that we might be currently animating so we can read their target values from the DOM.\r\n   */\n\n\n  Auto.prototype.resetStyles = function () {\n    var _a = this.props,\n        animate = _a.animate,\n        nativeElement = _a.nativeElement,\n        _b = _a.style,\n        style = _b === void 0 ? {} : _b;\n    var reset = resetStyles(style, this.supportedAutoValues); // If we're animating opacity separately, we don't want to reset\n    // as it causes a visual flicker when adding the component\n    // TODO: We should do this universally for all animating props\n    // and account for variants too.\n\n    if (typeof animate === \"object\" && animate.hasOwnProperty(\"opacity\")) {\n      delete reset.opacity;\n    }\n\n    nativeElement.setStyle(reset);\n    nativeElement.render(true);\n  };\n  /**\r\n   * Take a snapshot of the component as it currently exists before a render.\r\n   */\n\n\n  Auto.prototype.snapshotOrigin = function () {\n    this.willAnimate = true;\n    var _a = this.props,\n        nativeElement = _a.nativeElement,\n        transformPagePoint = _a.transformPagePoint;\n    var origin = snapshot(nativeElement, this.supportedAutoValues, transformPagePoint);\n    applyCurrent(origin.style, this.current);\n    return this.measuredOrigin = origin;\n  };\n  /**\r\n   * Take a snapshot of a component as it will exist after a render.\r\n   */\n\n\n  Auto.prototype.snapshotTarget = function () {\n    var _a = this.props,\n        nativeElement = _a.nativeElement,\n        style = _a.style,\n        transformPagePoint = _a.transformPagePoint;\n    var target = snapshot(nativeElement, this.supportedAutoValues, transformPagePoint);\n    target.style.rotate = resolve(0, style && style.rotate);\n    this.measuredTarget = target;\n  };\n  /**\r\n   * Hide this component using opacity. We can't set it to display: none as we might\r\n   * still need to measure it or its children.\r\n   *\r\n   * This is triggered if the component is a child of AnimateSharedLayout and a new component\r\n   * enters the tree that shares this component's layoutId.\r\n   */\n\n\n  Auto.prototype.hide = function () {\n    this.delta.isVisible = false;\n    this.stopLayoutAnimation && this.stopLayoutAnimation();\n    var _a = this.props,\n        values = _a.values,\n        nativeElement = _a.nativeElement;\n    var opacity = values.get(\"opacity\", 0);\n    opacity.set(0);\n    nativeElement.render();\n    if (!this.isPresent()) this.safeToRemove();\n  };\n\n  Auto.prototype.show = function () {\n    this.delta.isVisible = true;\n    var _a = this.props,\n        values = _a.values,\n        style = _a.style;\n    var opacity = values.get(\"opacity\", 1);\n    var newOpacity = style ? resolve(1, style.opacity) : 1;\n    opacity.set(newOpacity);\n  };\n\n  Auto.prototype.setVisibility = function (visibilityAction) {\n    if (visibilityAction === VisibilityAction.Show) {\n      this.show();\n    } else {\n      this.hide();\n    }\n\n    return this.safeToRemove();\n  };\n  /**\r\n   * Start an auto or shared layout animation.\r\n   */\n\n\n  Auto.prototype.startAnimation = function (_a) {\n    var _this = this;\n\n    if (_a === void 0) {\n      _a = {};\n    }\n\n    var _b, _c;\n\n    var origin = _a.origin,\n        target = _a.target,\n        visibilityAction = _a.visibilityAction,\n        opts = __rest(_a, [\"origin\", \"target\", \"visibilityAction\"]);\n\n    if (visibilityAction !== undefined) {\n      return this.setVisibility(visibilityAction);\n    }\n\n    var animationPromise;\n    var animations = []; // Restore rotation before any writes. If we don't do this, and for whatever\n    // reason the animation doesn't execute, rotation will be left at 0\n\n    var _d = this.props,\n        nativeElement = _d.nativeElement,\n        values = _d.values;\n    var rotate = values.get(\"rotate\");\n    rotate && nativeElement.setStyle(\"rotate\", rotate.get());\n    this.visualTarget = target || this.measuredTarget; // If we don't have a provided or measured origin, for instance if this is a newly-added component,\n    // we can just take the target and use that to at least maintain its position on screen as parent\n    // components animate\n\n    this.visualOrigin = origin || this.measuredOrigin || this.visualTarget;\n    this.delta.isVisible = ((_b = this.visualOrigin) === null || _b === void 0 ? void 0 : _b.style.opacity) !== 0 || ((_c = this.visualTarget) === null || _c === void 0 ? void 0 : _c.style.opacity) !== 0;\n    var parentContext = this.props.parentContext;\n    var parentDeltas = parentContext.magicDeltas || [];\n\n    if (this.shouldAnimate && this.visualOrigin && this.visualTarget && this.delta.isVisible && isTreeVisible(parentDeltas)) {\n      syncRenderSession.open();\n      animations = [this.startLayoutAnimation(opts), this.startStyleAnimation(opts)].filter(Boolean);\n      animationPromise = Promise.all(animations).then(function () {\n        var onMagicComplete = _this.props.onMagicComplete;\n        onMagicComplete && onMagicComplete();\n      });\n      syncRenderSession.flush();\n    } // If we don't animate, make sure we call safeToRemove so if this is an\n    // exiting component it'll get removed\n\n\n    !animations.length && this.safeToRemove(); // Force render to ensure there's no flashes of unstyled content from the reset\n\n    nativeElement.render();\n    return animationPromise;\n  };\n  /**\r\n   * This uses the FLIP animation technique to animate physical dimensions\r\n   * and correct distortion on related styles (ie borderRadius etc)\r\n   */\n\n\n  Auto.prototype.startLayoutAnimation = function (opts) {\n    var _this = this;\n\n    var animation;\n    this.stopLayoutAnimation && this.stopLayoutAnimation();\n    var originStyle = this.visualOrigin.style;\n    var targetStyle = this.visualTarget.style;\n    var isAnimatingRotate = Boolean(originStyle.rotate || targetStyle.rotate); // We really want to know if its ever animated rotate and the above isn't good enough\n\n    if (isAnimatingRotate) this.hasAnimatedRotate = isAnimatingRotate;\n    var values = this.props.values;\n    var updaters = {};\n\n    for (var key in this.supportedAutoValues) {\n      var handler = this.supportedAutoValues[key];\n      if (!handler.createUpdater) continue;\n      updaters[key] = handler.createUpdater(values, originStyle[key], targetStyle[key], this.current, this.delta, this.treeScale, this.visualOrigin.layout, this.visualTarget.layout);\n    }\n\n    this.frameTarget = {\n      x: {\n        min: 0,\n        max: 0\n      },\n      y: {\n        min: 0,\n        max: 0\n      }\n    };\n    var x = values.get(\"x\", 0);\n    var y = values.get(\"y\", 0);\n    var scaleX = values.get(\"scaleX\", 1);\n    var scaleY = values.get(\"scaleY\", 1);\n    var rotate = values.get(\"rotate\", 0); // TODO: Make API for this, stop all values. Currently just doing this to stop drag inertia animations\n\n    x.stop();\n    y.stop();\n    var opacity = values.get(\"opacity\", originStyle.opacity);\n\n    var frame = function frame() {\n      // TODO: Break up each of these so we can animate separately\n      var p = _this.progress.get() / 1000;\n\n      _this.updateBoundingBox(p, _this.hasAnimatedRotate ? 0.5 : undefined);\n\n      _this.updateTransform(x, y, scaleX, scaleY);\n\n      _this.hasAnimatedRotate && _this.updateRotate(p, rotate);\n\n      for (var key in updaters) {\n        var updater = updaters[key];\n        updater && updater(p);\n      }\n\n      if (opts.crossfade) {\n        opacity.set(opts.crossfade(originStyle.opacity, targetStyle.opacity, p));\n      }\n    };\n\n    var progressOrigin = 0;\n    var progressTarget = 1000;\n    this.progress.set(progressOrigin);\n    this.progress.set(progressOrigin); // Set twice to hard-reset velocity\n\n    var _a = this.props,\n        transition = _a.transition,\n        animate = _a.animate,\n        nativeElement = _a.nativeElement;\n\n    if (animate !== false) {\n      var dragControls = elementDragControls.get(nativeElement);\n\n      if (!dragControls || !dragControls.isDragging) {\n        animation = startAnimation(\"progress\", this.progress, progressTarget, __assign(__assign({}, opts.transition || transition), {\n          restDelta: 1,\n          restSpeed: 10\n        })).then(function () {\n          return _this.safeToRemove();\n        });\n      } else {\n        this.updateBoundingBox(progressOrigin); // Reset drag origin so the element doesn't look like it's moved in the DOM\n        // TODO: This is currently lossy with big mouse movements\n\n        var _b = dragControls.origin,\n            dragOriginX = _b.x,\n            dragOriginY = _b.y;\n        dragOriginX.set(dragOriginX.get() + this.delta.x.translate - x.get());\n        dragOriginY.set(dragOriginY.get() + this.delta.y.translate - y.get());\n        this.safeToRemove();\n      }\n    } else {\n      this.safeToRemove();\n    }\n\n    var parentContext = this.props.parentContext;\n    var magicProgress = parentContext.magicProgress;\n\n    var scheduleUpdate = function scheduleUpdate() {\n      return sync.update(frame, false, true);\n    };\n\n    var unsubscribeProgress = this.progress.onChange(scheduleUpdate);\n    var unsubscribeParentProgress;\n\n    if (magicProgress) {\n      unsubscribeParentProgress = magicProgress.onChange(scheduleUpdate);\n    }\n\n    this.stopLayoutAnimation = function () {\n      cancelSync.update(frame);\n\n      _this.progress.stop();\n\n      unsubscribeProgress();\n      unsubscribeParentProgress && unsubscribeParentProgress();\n    }; // TODO: I would prefer this to be a scheduleUpdate call, for some reason this is breaking\n    // visualOrigin in the sharedLayoutFramerSetup demonstration\n\n\n    frame();\n    return animation;\n  };\n  /**\r\n   * This is a straight animation between prev/next styles. This animates\r\n   * styles that don't need scale inversion correction.\r\n   */\n\n\n  Auto.prototype.startStyleAnimation = function (opts) {\n    var shouldAnimateStyle = false;\n    var target = {};\n    var values = this.props.values;\n    var numAnimatableStyles = this.animatableStyles.length;\n\n    for (var i = 0; i < numAnimatableStyles; i++) {\n      var key = this.animatableStyles[i];\n      if (key === \"opacity\" && opts.crossfade) continue;\n      var originStyle = this.visualOrigin.style[key];\n      var nextStyle = this.visualTarget.style[key];\n\n      if (originStyle !== nextStyle) {\n        shouldAnimateStyle = true;\n        var value = values.get(key, originStyle);\n        value.set(originStyle);\n        target[key] = nextStyle;\n      }\n    }\n\n    var _a = this.props,\n        transition = _a.transition,\n        controls = _a.controls;\n    target.transition = opts.transition || transition || {};\n\n    if (shouldAnimateStyle) {\n      return controls.start(target);\n    }\n  };\n\n  Auto.prototype.updateBoundingBox = function (p, origin) {\n    var parentContext = this.props.parentContext;\n    var parentDeltas = parentContext.magicDeltas || [];\n    resetBox(this.correctedLayout, this.measuredTarget.layout);\n    applyTreeDeltas(this.correctedLayout, this.treeScale, parentDeltas);\n    tweenAxisBox(this.frameTarget, this.visualOrigin.layout, this.visualTarget.layout, p);\n    calcBoxDelta(this.delta, this.frameTarget, this.correctedLayout, origin);\n  };\n\n  Auto.prototype.updateTransform = function (x, y, scaleX, scaleY) {\n    var nativeElement = this.props.nativeElement;\n    var dx = this.delta.x;\n    var dy = this.delta.y;\n    nativeElement.setStyle(\"originX\", dx.origin);\n    nativeElement.setStyle(\"originY\", dy.origin);\n    x.set(dx.translate / this.treeScale.x);\n    y.set(dy.translate / this.treeScale.y);\n    scaleX.set(dx.scale);\n    scaleY.set(dy.scale);\n  };\n\n  Auto.prototype.updateRotate = function (p, rotate) {\n    var target = mix(this.visualOrigin.style.rotate, this.visualTarget.style.rotate, p);\n    rotate.set(target);\n  };\n\n  Auto.prototype.isPresent = function () {\n    return this.props.isPresent;\n  };\n\n  Auto.prototype.safeToRemove = function () {\n    var safeToRemove = this.props.safeToRemove;\n    safeToRemove && safeToRemove();\n  };\n\n  Auto.prototype.render = function () {\n    return null;\n  };\n\n  return Auto;\n}(Component);\n\nvar Auto$1 = {\n  key: \"auto\",\n  shouldRender: function shouldRender(_a) {\n    var animate = _a.animate,\n        layoutId = _a.layoutId;\n    var hasAutoAnimateProps = typeof animate === \"boolean\" || layoutId !== undefined;\n    return hasAutoAnimateProps && typeof window !== \"undefined\";\n  },\n  Component: SharedLayoutContextProvider\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\", \"layoutId\", \"layoutOrder\", \"isPresent\", \"magicDependency\", \"allowTransformNone\", \"onMagicComplete\", \"onAnimationStart\", \"onAnimationComplete\", \"onUpdate\", \"onDragStart\", \"onDrag\", \"onDragEnd\", \"onMeasureDragConstraints\", \"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, _b;\n\nvar AnimatePropComponents = (_a = {}, _a[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[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[AnimatePropType.AnimationSubscription] = makeRenderlessComponent(function (_a) {\n  var animate = _a.animate,\n      controls = _a.controls;\n  return useAnimationGroupSubscription(animate, controls);\n}), _a);\n\nvar isVariantLabel$1 = function isVariantLabel$1(prop) {\n  return Array.isArray(prop) || typeof prop === \"string\";\n};\n\nvar isAnimationSubscription = function isAnimationSubscription(_a) {\n  var animate = _a.animate;\n  return animate instanceof AnimationControls;\n};\n\nvar animationProps = [\"initial\", \"animate\", \"whileTap\", \"whileHover\"];\nvar animatePropTypeTests = (_b = {}, _b[AnimatePropType.Target] = function (props) {\n  return props.animate !== undefined && !isVariantLabel$1(props.animate) && !isAnimationSubscription(props);\n}, _b[AnimatePropType.VariantLabel] = function (props) {\n  return props.variants !== undefined || animationProps.some(function (key) {\n    return typeof props[key] === \"string\";\n  });\n}, _b[AnimatePropType.AnimationSubscription] = isAnimationSubscription, _b);\n\nvar getAnimationComponent = function getAnimationComponent(props) {\n  var animatePropType = undefined;\n\n  for (var key in AnimatePropType) {\n    if (animatePropTypeTests[key](props)) {\n      animatePropType = key;\n    }\n  }\n\n  return animatePropType ? AnimatePropComponents[animatePropType] : undefined;\n};\n\nvar Exit = {\n  key: \"exit\",\n  shouldRender: function shouldRender(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 && typeof animate !== \"boolean\" && !(animate instanceof AnimationControls)) {\n        controls.start(animate);\n      }\n\n      if (isPresent) {\n        isPlayingExitAnimation.current = false;\n      }\n    }, [animate, controls, custom, exit, isPresent, onExitComplete, props]);\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, props, isStatic) {\n  // The `any` isn't ideal but it is the type of createElement props argument\n  var htmlProps = {\n    style: buildStyleAttr(values, style, props, isStatic)\n  };\n\n  if (!!props.drag) {\n    // Disable text selection\n    htmlProps.style.userSelect = \"none\"; // Disable the ghost element when a user drags\n\n    htmlProps.draggable = false;\n  }\n\n  return htmlProps;\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 defaultFeatures = [Auto$1, Drag, Gestures, Exit];\n/**\r\n * Create a configuration for `motion` components that provides DOM-specific feature.\r\n *\r\n * @internal\r\n */\n\nfunction createDomMotionConfig(ComponentToRender) {\n  var isDOM = typeof ComponentToRender === \"string\";\n  var isSVG = isDOM && svgElements.indexOf(ComponentToRender) !== -1;\n  return {\n    renderComponent: function renderComponent(nativeElement, style, values, props, isStatic) {\n      var forwardedProps = isDOM ? filterValidProps(props) : props;\n      var staticVisualStyles = isSVG ? buildSVGProps(values, style) : buildHTMLProps(values, style, props, isStatic);\n      return createElement(ComponentToRender, __assign(__assign(__assign({}, forwardedProps), {\n        ref: nativeElement.ref\n      }), staticVisualStyles));\n    },\n\n    /**\r\n     * loadFeatures gets used by the `motion` component\r\n     *\r\n     * Each feature 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 feature is\r\n     * consistent (should render? Then push component) and could be used to extend feature.\r\n     *\r\n     * By exposing a mutable piece of memory via an API like `extendMotionComponent` we could\r\n     * allow users to add `MotionFeature`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 feature. 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 feature 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    loadFeatures: function loadFeatures(nativeElement, values, props, context, parentContext, controls, inherit, plugins) {\n      var allFeatures = __spreadArrays(defaultFeatures, plugins.features);\n\n      var numFeatures = allFeatures.length;\n      var activeComponents = []; // TODO: Consolidate Animation feature 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 < numFeatures; i++) {\n        var _a = allFeatures[i],\n            shouldRender = _a.shouldRender,\n            key = _a.key,\n            Component = _a.Component;\n\n        if (shouldRender(props, parentContext)) {\n          activeComponents.push(createElement(Component, __assign({\n            key: key\n          }, props, {\n            localContext: context,\n            parentContext: parentContext,\n            values: values,\n            controls: controls,\n            nativeElement: nativeElement\n          })));\n        }\n      }\n\n      return activeComponents;\n    },\n    getValueControlsConfig: function getValueControlsConfig(nativeElement, values) {\n      return {\n        values: values,\n        readValueFromSource: function readValueFromSource(key) {\n          return nativeElement.getStyle(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, nativeElement)\n      };\n    }\n  };\n}\n/**\r\n * Uses the ref that is passed in, or creates a new one\r\n * @param external - External ref\r\n * @internal\r\n */\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\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\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 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 forceRender function, or one from a parent context if it exists.\n\n  var forceRender = useForceUpdate();\n  var magicContext = useContext(SharedLayoutContext);\n\n  if (isControlledSharedLayoutContext(magicContext)) {\n    forceRender = magicContext.forceRender;\n  }\n\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 (presentChild) {\n        return presentChild.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        forceRender();\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};\n\nfunction isControlledSharedLayoutContext(context) {\n  return !!context.forceRender;\n}\n\nfunction createSwitchAnimation(child, _isRoot, stack) {\n  var _a, _b;\n\n  if (stack && child !== stack.lead) {\n    return {\n      visibilityAction: VisibilityAction.Hide\n    };\n  } else if (stack && child.presence !== Presence.Entering && child === stack.lead && stack.lead !== stack.prevLead) {\n    return {\n      visibilityAction: VisibilityAction.Show\n    };\n  }\n\n  var origin;\n  var target;\n\n  if (child.presence === Presence.Entering) {\n    origin = (_a = stack) === null || _a === void 0 ? void 0 : _a.getFollowOrigin();\n  } else if (child.presence === Presence.Exiting) {\n    target = (_b = stack) === null || _b === void 0 ? void 0 : _b.getFollowTarget();\n  }\n\n  return {\n    origin: origin,\n    target: target\n  };\n}\n\nfunction createCrossfadeAnimation(child, isRoot, stack) {\n  var _a;\n\n  var config = {};\n  var stackLead = stack && stack.lead;\n  var stackLeadPresence = (_a = stackLead) === null || _a === void 0 ? void 0 : _a.presence;\n\n  if (stack && child === stackLead) {\n    if (child.presence === Presence.Entering) {\n      config.origin = stack.getFollowOrigin();\n    } else if (child.presence === Presence.Exiting) {\n      config.target = stack.getFollowTarget();\n    }\n  } else if (stack && child === stack.follow) {\n    if (stackLeadPresence === Presence.Entering) {\n      config.target = stack.getLeadTarget();\n    } else if (stackLeadPresence === Presence.Exiting) {\n      config.origin = stack.getLeadOrigin();\n    }\n  } // // Handle crossfade opacity\n\n\n  if (!isRoot) return config;\n\n  if (!stack || child === stackLead) {\n    if (child.presence === Presence.Entering) {\n      config.crossfade = crossfadeIn;\n    } else if (child.presence === Presence.Exiting) {\n      config.crossfade = crossfadeOut;\n    }\n  } else if (stack && child === stack.follow) {\n    if (!stackLead || stackLeadPresence === Presence.Entering) {\n      config.crossfade = crossfadeOut;\n    } else if (stackLeadPresence === Presence.Exiting) {\n      config.crossfade = crossfadeIn;\n    }\n  } else {\n    config.visibilityAction = VisibilityAction.Hide;\n  }\n\n  return config;\n}\n\nfunction compress(min, max, easing) {\n  return function (p) {\n    // Could replace ifs with clamp\n    if (p < min) return 0;\n    if (p > max) return 1;\n    return easing(progress(min, max, p));\n  };\n}\n\nvar easeCrossfadeIn = compress(0, 0.5, circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, linear);\n\nvar crossfadeIn = function crossfadeIn(_origin, target, p) {\n  return mix(0, target, easeCrossfadeIn(p));\n};\n\nvar crossfadeOut = function crossfadeOut(origin, _target, p) {\n  return mix(origin, 0, easeCrossfadeOut(p));\n};\n/**\r\n * For each layout animation, we want to identify two components\r\n * within a stack that will serve as the \"lead\" and \"follow\" components.\r\n *\r\n * In the switch animation, the lead component performs the entire animation.\r\n * It uses the follow bounding box to animate out from and back to. The follow\r\n * component is hidden.\r\n *\r\n * In the crossfade animation, both the lead and follow components perform\r\n * the entire animation, animating from the follow origin bounding box to the lead\r\n * target bounding box.\r\n *\r\n * Generalising a stack as First In Last Out, *searching from the end* we can\r\n * generally consider the lead component to be:\r\n *  - If the last child is present, the last child\r\n *  - If the last child is exiting, the last *encountered* exiting component\r\n */\n\n\nfunction findLeadAndFollow(stack, _a) {\n  var prevLead = _a[0],\n      prevFollow = _a[1];\n  var lead = undefined;\n  var leadIndex = 0;\n  var follow = undefined; // Find the lead child first\n\n  var numInStack = stack.length;\n  var lastIsPresent = false;\n\n  for (var i = numInStack - 1; i >= 0; i--) {\n    var child = stack[i];\n    var isLastInStack = i === numInStack - 1;\n\n    if (isLastInStack) {\n      lastIsPresent = child.isPresent();\n    }\n\n    if (lastIsPresent) {\n      lead = child;\n    } else {\n      // If the child before this will be present, make this the\n      // lead.\n      var prev = stack[i - 1];\n      if (prev && prev.isPresent()) lead = child;\n    }\n\n    if (lead) {\n      leadIndex = i;\n      break;\n    }\n  }\n\n  if (!lead) lead = stack[0]; // Find the follow child\n\n  follow = stack[leadIndex - 1]; // If the lead component is exiting, find the closest follow\n  // present component\n\n  if (lead) {\n    for (var i = leadIndex - 1; i >= 0; i--) {\n      var child = stack[i];\n\n      if (child.isPresent()) {\n        follow = child;\n        break;\n      }\n    }\n  } // If the lead has changed and the previous lead still exists in the\n  // stack, set it to the previous lead. This allows us to differentiate between\n  // a, b, c(exit) -> a, b(exit), c(exit)\n  // and\n  // a, b(exit), c -> a, b(exit), c(exit)\n\n\n  if (lead !== prevLead && !lastIsPresent && follow === prevFollow && stack.find(function (stackChild) {\n    return stackChild === prevLead;\n  })) {\n    lead = prevLead;\n  }\n\n  return [lead, follow];\n}\n\nvar LayoutStack =\n/** @class */\nfunction () {\n  function LayoutStack() {\n    this.order = [];\n  }\n\n  LayoutStack.prototype.add = function (child) {\n    var layoutOrder = child.props.layoutOrder;\n\n    if (layoutOrder === undefined) {\n      this.order.push(child);\n    } else {\n      var index = this.order.findIndex(function (stackChild) {\n        return layoutOrder <= (stackChild.props.layoutOrder || 0);\n      });\n\n      if (index === -1) {\n        child.presence = Presence.Entering;\n        index = this.order.length;\n      }\n\n      this.order.splice(index, 0, child);\n    }\n  };\n\n  LayoutStack.prototype.remove = function (child) {\n    var index = this.order.findIndex(function (stackChild) {\n      return child === stackChild;\n    });\n    if (index !== -1) this.order.splice(index, 1);\n  };\n\n  LayoutStack.prototype.updateLeadAndFollow = function () {\n    this.prevLead = this.lead;\n    this.prevFollow = this.follow;\n\n    var _a = findLeadAndFollow(this.order, [this.lead, this.follow]),\n        lead = _a[0],\n        follow = _a[1];\n\n    this.lead = lead;\n    this.follow = follow;\n  };\n\n  LayoutStack.prototype.updateSnapshot = function () {\n    if (this.lead) this.snapshot = this.lead.measuredOrigin;\n  };\n\n  LayoutStack.prototype.isLeadPresent = function () {\n    var _a;\n\n    return this.lead && ((_a = this.lead) === null || _a === void 0 ? void 0 : _a.presence) !== Presence.Exiting;\n  };\n\n  LayoutStack.prototype.getFollowOrigin = function () {\n    return this.follow ? this.follow.measuredOrigin : this.snapshot;\n  };\n\n  LayoutStack.prototype.getFollowTarget = function () {\n    var _a;\n\n    return (_a = this.follow) === null || _a === void 0 ? void 0 : _a.measuredTarget;\n  };\n\n  LayoutStack.prototype.getLeadOrigin = function () {\n    var _a;\n\n    return (_a = this.lead) === null || _a === void 0 ? void 0 : _a.measuredOrigin;\n  };\n\n  LayoutStack.prototype.getLeadTarget = function () {\n    var _a;\n\n    return (_a = this.lead) === null || _a === void 0 ? void 0 : _a.measuredTarget;\n  };\n\n  return LayoutStack;\n}();\n\nvar defaultLayoutTransition = {\n  duration: 0.45,\n  ease: [0.4, 0, 0.1, 1]\n};\n/**\r\n * @public\r\n */\n\nvar AnimateSharedLayout =\n/** @class */\nfunction (_super) {\n  __extends(AnimateSharedLayout, _super);\n\n  function AnimateSharedLayout() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n    /**\r\n     * Keep track of all animate children.\r\n     */\n\n\n    _this.children = new Set();\n    /**\r\n     * As animate components with a defined `layoutId` are added/removed to the tree,\r\n     * we store them in order. When one is added, it will animate out from the\r\n     * previous one, and when it's removed, it'll animate to the previous one.\r\n     */\n\n    _this.stacks = new Map();\n    /**\r\n     * Create an instance of the update batcher so we can run snapshots across\r\n     * components and fire animate transitions in the correct order.\r\n     */\n\n    _this.batch = batchTransitions();\n    /**\r\n     * We're tracking mount status as only subsequently-entering components need\r\n     * tagging with `shouldResumeFromPrevious`.\r\n     */\n\n    _this.hasMounted = false;\n    /**\r\n     * Keep track of whether we're currently animating layout and block forced re-renders\r\n     * until we're not.\r\n     */\n\n    _this.isAnimating = false;\n    /**\r\n     * If a forced re-render is triggered while there's a shared layout animation we block\r\n     * it and check this boolean after all animations are complete.\r\n     */\n\n    _this.shouldRerender = false;\n    _this.state = {\n      /**\r\n       * Allow children, like AnimatePresence, to force-render this component\r\n       * to ensure animate children correctly identify parallel state changes that\r\n       * might affect their layout.\r\n       */\n      forceRender: function forceRender() {\n        if (!_this.isAnimating) {\n          _this.shouldRerender = false;\n\n          _this.setState(__assign({}, _this.state));\n        } else {\n          _this.shouldRerender = true;\n        }\n      },\n      register: function register(child) {\n        return _this.addChild(child);\n      },\n      move: function move(child) {\n        _this.removeChildFromStack(child);\n\n        _this.addChildToStack(child);\n      }\n    };\n    return _this;\n  }\n\n  AnimateSharedLayout.prototype.componentDidMount = function () {\n    this.hasMounted = true;\n    this.stacks.forEach(function (stack) {\n      return stack.updateLeadAndFollow();\n    });\n  };\n  /**\r\n   * We always want the component to re-render but for performance reasons we might\r\n   * want to control whether we take snapshots and perform animate transitions.\r\n   */\n\n\n  AnimateSharedLayout.prototype.shouldComponentUpdate = function (nextProps, nextState) {\n    this.shouldTransition = false;\n\n    if (this.state !== nextState) {\n      // This should always be true if we've got a new state as a result of a forced render\n      this.shouldTransition = true;\n    } else {\n      // If we don't have a defined dependency, or we do and it's changed,\n      // we want to transition\n      var dependency = this.props.dependency;\n      var hasDependency = !!(dependency !== null && dependency !== void 0 ? dependency : nextProps.dependency);\n      var hasChanged = dependency !== nextProps.dependency;\n      this.shouldTransition = !hasDependency || hasDependency && hasChanged;\n    }\n    /**\r\n     * Reset rotation on all children so we can properly measure the correct bounding box.\r\n     * The supportRotate prop isn't public API so this should only run in Framer.\r\n     *\r\n     * Ideally this would run in getSnapshotBeforeUpdate as shouldComponentUpdate may run\r\n     * multiple times in concurrent mode, but currently this is introducing bugs.\r\n     */\n\n\n    if (this.shouldTransition) {\n      var supportRotate = this.props.supportRotate;\n      supportRotate && this.children.forEach(function (child) {\n        return child.resetRotation();\n      });\n    }\n\n    return true;\n  };\n  /**\r\n   * Loop through all children and update their latest origin snapshots.\r\n   */\n\n\n  AnimateSharedLayout.prototype.getSnapshotBeforeUpdate = function () {\n    if (!this.shouldTransition) return null;\n    /**\r\n     * Snapshot the visual origin of every child.\r\n     */\n\n    this.children.forEach(function (child) {\n      return child.snapshotOrigin();\n    });\n    /**\r\n     * Every child keeps a local snapshot, but we also want to record\r\n     * snapshots of the visible children as, if they're are being removed\r\n     * in this render, we can still access them.\r\n     */\n\n    this.stacks.forEach(function (stack) {\n      return stack.updateSnapshot();\n    });\n    return null;\n  };\n  /**\r\n   * Once all children have updated, snapshot their target snapshots and run\r\n   * animate transitions.\r\n   */\n\n\n  AnimateSharedLayout.prototype.componentDidUpdate = function () {\n    // TODO: This would currently prevent animate children from working\n    this.shouldTransition && this.startAnimation();\n  };\n  /**\r\n   * Register a new `Auto` child\r\n   */\n\n\n  AnimateSharedLayout.prototype.addChild = function (child) {\n    var _this = this;\n\n    this.setRootDepth(child);\n    this.children.add(child);\n    child.presence = this.hasMounted ? Presence.Entering : Presence.Present;\n    this.addChildToStack(child);\n    return function () {\n      return _this.removeChild(child);\n    };\n  };\n\n  AnimateSharedLayout.prototype.addChildToStack = function (child) {\n    var layoutId = child.props.layoutId;\n    if (layoutId === undefined) return;\n    var stack = this.getStack(layoutId);\n    stack.add(child);\n  };\n\n  AnimateSharedLayout.prototype.removeChild = function (child) {\n    this.children[\"delete\"](child);\n    this.removeChildFromStack(child);\n  };\n\n  AnimateSharedLayout.prototype.removeChildFromStack = function (child) {\n    var layoutId = child.props.layoutId;\n    if (layoutId === undefined) return;\n    var stack = this.getStack(layoutId);\n    stack.remove(child);\n  };\n  /**\r\n   * Return a stack of animate children based on the provided layoutId.\r\n   * Will create a stack if none currently exists with that layoutId.\r\n   */\n\n\n  AnimateSharedLayout.prototype.getStack = function (id) {\n    !this.stacks.has(id) && this.stacks.set(id, new LayoutStack());\n    return this.stacks.get(id);\n  };\n  /**\r\n   * The root depth is the shallowest `depth` of all our children.\r\n   * Children with the shallowest depth get used to crossfade between trees.\r\n   */\n\n\n  AnimateSharedLayout.prototype.setRootDepth = function (child) {\n    if (this.rootDepth === undefined) {\n      this.rootDepth = child.depth;\n    } else {\n      this.rootDepth = Math.min(child.depth, this.rootDepth);\n    }\n  };\n\n  AnimateSharedLayout.prototype.startAnimation = function () {\n    var _this = this;\n\n    var numAnimations = 0;\n    var numCompletedAnimations = 0;\n    var _a = this.props,\n        type = _a.type,\n        _b = _a.transition,\n        transition = _b === void 0 ? defaultLayoutTransition : _b;\n    var options = {\n      type: type,\n      transition: transition\n    };\n    var createAnimation = type === \"crossfade\" ? createCrossfadeAnimation : createSwitchAnimation; // Update presence metadata based on latest AnimatePresence status\n\n    this.children.forEach(function (child) {\n      if (!child.isPresent()) {\n        child.presence = Presence.Exiting;\n      } else if (child.presence !== Presence.Entering) {\n        child.presence = child.presence === Presence.Exiting ? Presence.Entering : Presence.Present;\n      }\n    });\n    this.stacks.forEach(function (stack) {\n      return stack.updateLeadAndFollow();\n    });\n    var handler = {\n      snapshotTarget: function snapshotTarget(child) {\n        var _a, _b;\n\n        var layoutId = child.props.layoutId;\n        var stack = layoutId !== undefined ? _this.getStack(layoutId) : undefined;\n\n        if ( // If this component has an animate prop\n        isAutoAnimate(child) || // If this component is either entering or present\n        child.presence !== Presence.Exiting || ((_b = (_a = // If the lead component in the stack is present, snapshot\n        // TODO: Figure out what this breaks if removed\n        stack) === null || _a === void 0 ? void 0 : _a.lead) === null || _b === void 0 ? void 0 : _b.isPresent())) {\n          child.snapshotTarget();\n        }\n      },\n      startAnimation: function startAnimation(child) {\n        var layoutId = child.props.layoutId;\n        var stack = layoutId !== undefined ? _this.getStack(layoutId) : undefined;\n        var config = createAnimation(child, child.depth === _this.rootDepth, stack);\n        var animation = child.startAnimation(__assign(__assign({}, options), config));\n\n        if (animation) {\n          _this.isAnimating = true;\n          numAnimations++;\n          animation.then(function () {\n            if (child.isPresent()) child.presence = Presence.Present;\n            numCompletedAnimations++;\n\n            if (_this.shouldRerender && numCompletedAnimations >= numAnimations) {\n              _this.isAnimating = false;\n\n              _this.state.forceRender();\n            }\n          });\n        }\n      }\n    };\n    /**\r\n     * Shared layout animations can be used without the AnimateSharedLayout wrapping component.\r\n     * This requires some co-ordination across components to stop layout thrashing\r\n     * and ensure measurements are taken at the correct time.\r\n     *\r\n     * Here we use that same mechanism of schedule/flush.\r\n     */\n\n    this.children.forEach(function (child) {\n      return _this.batch.add(child);\n    });\n    this.batch.flush(handler);\n    /**\r\n     * Clear snapshots so subsequent rerenders don't retain memory of outgoing components\r\n     */\n\n    this.stacks.forEach(function (stack) {\n      return stack.snapshot = undefined;\n    });\n  };\n\n  AnimateSharedLayout.prototype.render = function () {\n    return createElement(SharedLayoutContext.Provider, {\n      value: this.state\n    }, this.props.children);\n  };\n\n  return AnimateSharedLayout;\n}(Component);\n\nfunction isAutoAnimate(child) {\n  return child.props.animate === true;\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\nfunction useTransform(parent, customTransform, to, options) {\n  var _a;\n\n  var comparitor = isTransformer(customTransform) ? [parent] : [parent, customTransform.join(\",\"), (_a = to) === null || _a === void 0 ? void 0 : _a.join(\",\")];\n  var transformer = useMemo(function () {\n    return isTransformer(customTransform) ? customTransform : transform(customTransform, to, options);\n  }, comparitor);\n  var initialValue = transformer(parent.get());\n  var value = useMotionValue(initialValue); // Handle subscription to parent\n\n  var unsubscribe = useRef();\n  useMemo(function () {\n    unsubscribe.current && unsubscribe.current();\n    unsubscribe.current = parent.onChange(function (v) {\n      return value.set(transformer(v));\n    }); // Manually set with the latest parent value in case we've re-parented\n\n    value.set(initialValue);\n  }, [parent, value, transformer]);\n  useUnmountEffect(function () {\n    return unsubscribe.current && unsubscribe.current();\n  });\n  return value;\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\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\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/**\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 * 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} // 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/**\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\nexport { AnimatePresence, AnimateSharedLayout, AnimationControls, DragControls, MotionContext, MotionPluginContext, MotionPlugins, MotionValue, PresenceContext, ReducedMotion, SharedLayoutContext, animationControls, createMotionComponent, isValidMotionProp, motion, motionValue, resolveMotionValue, transform, useAnimation, useCycle, useDomEvent, useDragControls, useExternalRef, useGestures, useInvertedScale, useMotionValue, usePanGesture, usePresence, useReducedMotion, useSpring, useTapGesture, useTransform, useViewportScroll };"],"sourceRoot":""}