{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/utils/each-axis.js","webpack:///./node_modules/framer-motion/dist/es/events/use-pointer-event.js","webpack:///./node_modules/framer-motion/dist/es/events/utils.js","webpack:///./node_modules/framer-motion/dist/es/value/index.js","webpack:///./node_modules/popmotion/dist/es/utils/mix.js","webpack:///./node_modules/style-value-types/dist/es/color/index.js","webpack:///./node_modules/popmotion/dist/es/animations/utils/find-spring.js","webpack:///./node_modules/popmotion/dist/es/animations/generators/spring.js","webpack:///./node_modules/popmotion/dist/es/utils/mix-complex.js","webpack:///./node_modules/popmotion/dist/es/utils/interpolate.js","webpack:///./node_modules/popmotion/dist/es/animations/generators/keyframes.js","webpack:///./node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.js","webpack:///./node_modules/popmotion/dist/es/animations/generators/decay.js","webpack:///./node_modules/popmotion/dist/es/animations/utils/elapsed.js","webpack:///./node_modules/popmotion/dist/es/animations/index.js","webpack:///./node_modules/popmotion/dist/es/easing/cubic-bezier.js","webpack:///./node_modules/framer-motion/dist/es/animation/utils/easing.js","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-animatable.js","webpack:///./node_modules/framer-motion/dist/es/animation/utils/default-transitions.js","webpack:///./node_modules/framer-motion/dist/es/animation/utils/transitions.js","webpack:///./node_modules/popmotion/dist/es/animations/inertia.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/layout/utils.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.js","webpack:///./node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.js","webpack:///./node_modules/framer-motion/dist/es/utils/geometry/delta-apply.js","webpack:///./node_modules/framer-motion/dist/es/utils/shallow-compare.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/test.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/find.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/setters.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/animation.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/animation-state.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/animations.js","webpack:///./node_modules/framer-motion/dist/es/gestures/use-hover-gesture.js","webpack:///./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/gestures.js","webpack:///./node_modules/framer-motion/dist/es/gestures/use-tap-gesture.js","webpack:///./node_modules/framer-motion/dist/es/gestures/use-focus-gesture.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/state.js","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-projection-transform.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/lifecycles.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/flat-tree.js","webpack:///./node_modules/framer-motion/dist/es/render/index.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/motion-values.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/relative-set.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/projection.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.js","webpack:///./node_modules/framer-motion/dist/es/render/html/visual-element.js","webpack:///./node_modules/framer-motion/dist/es/utils/is-numerical-string.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/visual-element.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/features-animation.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/create-visual-element.js","webpack:///./node_modules/framer-motion/dist/es/components/LazyMotion/index.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-unmount-effect.js","webpack:///./node_modules/style-value-types/dist/es/color/utils.js","webpack:///./node_modules/framer-motion/dist/es/events/use-dom-event.js","webpack:///./node_modules/style-value-types/dist/es/color/rgba.js","webpack:///./node_modules/framer-motion/dist/es/utils/geometry/delta-calc.js","webpack:///./node_modules/framer-motion/dist/es/events/event-info.js","webpack:///./node_modules/framer-motion/dist/es/gestures/utils/event-type.js","webpack:///./node_modules/style-value-types/dist/es/color/hsla.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.js","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.js","webpack:///./node_modules/framer-motion/dist/es/utils/subscription-manager.js","webpack:///./node_modules/framer-motion/dist/es/utils/array.js","webpack:///./node_modules/popmotion/dist/es/utils/clamp.js","webpack:///./node_modules/framer-motion/dist/es/utils/time-conversion.js","webpack:///./node_modules/popmotion/dist/es/utils/inc.js","webpack:///./node_modules/popmotion/dist/es/utils/pipe.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.js","webpack:///./node_modules/popmotion/dist/es/utils/progress.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/is-draggable.js","webpack:///./node_modules/popmotion/dist/es/utils/mix-color.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/measure.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.js","webpack:///./node_modules/popmotion/dist/es/easing/utils.js","webpack:///./node_modules/popmotion/dist/es/easing/index.js","webpack:///./node_modules/style-value-types/dist/es/color/hex.js","webpack:///./node_modules/popmotion/dist/es/utils/velocity-per-second.js","webpack:///./node_modules/style-value-types/dist/es/complex/index.js","webpack:///./node_modules/style-value-types/dist/es/complex/filter.js","webpack:///./node_modules/popmotion/dist/es/utils/is-point.js","webpack:///./node_modules/popmotion/dist/es/utils/is-point-3d.js","webpack:///./node_modules/popmotion/dist/es/utils/distance.js","webpack:///./node_modules/framesync/dist/es/on-next-frame.js","webpack:///./node_modules/framesync/dist/es/index.js","webpack:///./node_modules/framesync/dist/es/create-render-step.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/types.js","webpack:///./node_modules/framer-motion/dist/es/utils/noop.js","webpack:///./node_modules/framer-motion/dist/es/utils/geometry/index.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimateSharedLayout/types.js"],"names":["eachAxis","handler","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","window","onpointerdown","ontouchstart","onmousedown","addPointerEvent","target","eventName","options","usePointerEvent","ref","MotionValue","init","value","_this","this","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","v","render","prev","current","_a","delta","timestamp","postRender","scheduleVelocityCheck","notify","getSize","getVelocity","velocityCheck","hasAnimated","isNaN","parseFloat","prototype","onChange","subscription","add","clearListeners","clear","onRenderRequest","get","attach","passiveEffect","set","getPrevious","start","animation","stop","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","motionValue","mix","from","to","progress","color","test","parse","transform","hasOwnProperty","findSpring","envelope","derivative","_b","duration","_c","bounce","_d","velocity","_e","mass","maxDuration","dampingRatio","clamp","undampedFreq","exponentialDecay","calcAngularFreq","Math","exp","d","e","pow","f","g","initialGuess","result","i","approximateRoot","stiffness","damping","sqrt","durationKeys","physicsKeys","isSpringType","keys","some","key","undefined","spring","restSpeed","restDelta","state","done","springOptions","isResolvedFromDuration","derived","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","abs","angularFreq_1","t","sin","cos","dampedAngularFreq_1","freqForT","min","sinh","cosh","next","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","a","b","_t","getMixer","origin","mixComplex","mixArray","output","numValues","length","blendValue","map","fromThis","mixObject","analyse","parsed","complex","numNumbers","numRGB","numHSL","hue","template","createTransformer","originStats","targetStats","pipe","mixNumber","p","createMixers","ease","customMixer","mixers","mixerFactory","Array","isArray","numMixers","mixer","easingFunction","push","interpolate","input","isClamp","inputLength","concat","reverse","interpolator","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","slowInterpolate","defaultEasing","values","easing","splice","keyframes","offset","times","o","convertOffsetToTimes","_value","defaultOffset","createInterpolator","types","decay","power","timeConstant","_f","modifyTarget","amplitude","ideal","loopElapsed","elapsed","delay","framesync","update","passTimestamp","animate","driverControls","latest","interpolateFromNumber","autoplay","driver","_g","repeat","repeatMax","_h","repeatType","_j","repeatDelay","onPlay","onStop","onComplete","onRepeat","onUpdate","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","config","type","Set","Object","has","detectAnimationFromOptions","call","reverseElapsed","max","hasRepeatDelayElapsed","a1","a2","c","calcBezier","getSlope","cubicBezier","mX1","mY1","mX2","mY2","sampleValues","Float32Array","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","definition","isAnimatable","startsWith","underDampedSpring","criticallyDampedSpring","linearTween","defaultTransitions","x","y","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","default","legacyRepeatWarning","convertTransitionToAnimationOptions","yoyo","flip","loop","transition","isEasingArray","getPopmotionAnimationOptions","valueKey","transitionFactory","hydrateKeyframes","when","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","getAnimation","valueTransition","getValueTransition","isTargetAnimatable","isZero","getZeroUnit","isOriginAnimatable","currentAnimation","bounceStiffness","bounceDamping","isOutOfBounds","boundaryNearest","startAnimation","startSpring","prev_1","current_1","boundary_1","heading_1","inertia","indexOf","potentialUnitType","delayTimer","controls","getDelayFromTransition","setTimeout","clearTimeout","tweenAxis","calcRelativeOffsetAxis","parent","child","calcRelativeOffset","checkIfParentHasChanged","prevId","getLayoutId","nextId","compareByDepth","depth","makeRenderlessComponent","hook","props","resetAxis","axis","originAxis","resetBox","box","originBox","scalePoint","point","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","applyBoxDelta","applyAxisTransforms","final","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","applyBoxTransforms","finalBox","removePointDelta","removeAxisTransforms","removeAxisDelta","removeBoxTransforms","applyTreeDeltas","treeScale","treePath","treeLength","node","getLayoutState","getLatestValues","shallowCompare","prevLength","testValueType","dimensionValueTypes","findDimensionValueType","find","valueTypes","findValueType","setMotionValue","visualElement","hasValue","getValue","addValue","setTarget","resolved","makeTargetAnimatable","transitionEnd","getOriginFromTransition","animateVariant","variant","custom","getDefaultTransition","transitionOverride","animateTarget","getChildAnimations","variantChildren","size","forwardDelay","animations","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","forEach","notifyAnimationComplete","all","animateChildren","first","last","animationTypeState","animationState","getState","valueTarget","shouldBlockAnimation","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","variantPriorityOrder","Animate","Hover","Tap","Drag","Focus","Exit","reversePriorityOrder","numAnimationTypes","animateList","notifyAnimationStart","resolvedDefinition","animateVisualElement","createAnimationState","createTypeState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","getProps","context","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","prop","propIsVariant","activeDelta","isActive","isInherited","manuallyAnimateOnMount","prevProp","shouldAnimateType","variantsHaveChanged","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","delete","blockInitialAnimation","apply","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","initial","isAnimated","setActive","setAnimateFunction","makeAnimator","subscribe","exit","isPresent","onExitComplete","presenceContext","PresenceContext","createHoverEvent","callback","event","info","isNodeOrChild","parentElement","gestureAnimations","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","removePointerEndListener","checkPointerEnd","onPointerUp","getInstance","onPointerCancel","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","createLayoutState","isHydrated","layout","layoutCorrected","deltaFinal","deltaTransform","zeroLayout","buildLayoutProjectionTransform","latestTransform","identityProjection","buildLayoutProjectionTransformOrigin","names","FlatTree","children","isDirty","remove","treeType","build","measureViewportBox","renderInstance","readValueFromInstance","resetTransform","restoreTransform","removeValueFromRenderState","scrapeMotionValuesFromProps","presenceId","visualState","instance","projectionParent","unsubscribeFromLeadVisualElement","crossfader","projectionTargetProgress","removeFromVariantTree","latestValues","renderState","lifecycles","managers","propSubscriptions","clearAllListeners","manager","updatePropListeners","on","propListener","args","_i","arguments","createLifecycles","projection","isEnabled","isTargetLocked","targetFinal","leadProjection","leadLatestValues","layoutState","hasViewportBoxUpdated","Map","valueSubscriptions","prevMotionValues","baseTarget","element","isProjectionReady","triggerBuild","valuesToRender","crossfadedValues","getCrossfadeState","notifyUpdate","updateTreeLayoutProjection","layoutTree","fireUpdateLayoutProjection","initialMotionValues","isControllingVariants","isVariantNode","path","isVisible","isMounted","mount","newInstance","pointTo","addVariantChild","unmount","preRender","updateLayoutProjection","stopLayoutAnimation","closestVariantNode","getClosestVariantNode","other","scheduleUpdateLayoutProjection","layoutId","getStaticValue","setStaticValue","setVisibility","visibility","scheduleRender","canMutate","removeValue","removeOnChange","latestValue","removeOnRenderRequest","bindToMotionValue","defaultValue","forEachValue","readValue","setBaseTarget","syncRender","setProps","newProps","nextValue","prevValue","existingValue","updateMotionValuesFromProps","getVariant","variants","startAtParent","context_1","numVariantProps","name_1","variantProps","enableLayoutProjection","lockProjectionTarget","unlockProjectionTarget","setCrossfader","newCrossfader","startLayoutAnimation","isRelative","getProjectionAnimationProgress","relativeTarget","setProjectionTargetAxis","animateMotionValue","withTransform","viewportBox","notifySetAxisTarget","rebaseProjectionTarget","force","shouldRebase","notifyLayoutReady","getProjectionParent","relativeOffset","setCurrentViewportBox","notifyLayoutUpdate","prevViewportBox","prevTreeScaleX","prevTreeScaleY","prevDeltaTransform","transformOrigin","updateLayoutDeltas","notifyViewportBoxUpdate","fireResolveRelativeTargetBox","foundParent","ancestor","resolveRelativeTargetBox","relativeParent","shouldResetTransform","_layoutResetTransform","newLead","onSetAxisTarget","onLayoutAnimationComplete","presence","Present","layoutSafeToRemove","Entering","BoundingBoxDimension","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","match","transformKeys","nonTranslationalTransformKeys","filter","positionalValues","width","height","top","left","bottom","right","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","removedTransforms","removeNonTranslationalTransform","convertedTarget","changedKeys","originBbox","elementComputedStyle","getComputedStyle","display","originComputedStyle","targetBbox","convertChangedValueTypes","unitConversion","hasPositionalKey","htmlConfig","domElement","defaultType","computedStyle","getPropertyValue","compareDocumentPosition","style","transformPagePoint","transformTemplate","mutableState","vars","transformValues","getOrigin","newValueKeys","numNewValues","targetValue","checkTargetForNewValues","parseDomVariant","isProjectionTranform","htmlVisualElement","svgVisualElement","getAttribute","_element","domAnimation","renderer","Component","enableHardwareAcceleration","LazyMotion","features","strict","setIsLoaded","isLazyBundle","loadedRenderer","loadedFeatures","Provider","useUnmountEffect","isColorString","testProp","splitColor","aName","bName","cName","alpha","addDomEvent","addEventListener","removeEventListener","useDomEvent","clampRgbUnit","rgbUnit","round","rgba","red","green","blue","alpha$1","isNear","maxDistance","calcLength","calcOrigin","source","sourceLength","targetLength","updateAxisDelta","updateBoxDelta","defaultOrigin","originX","originY","calcRelativeAxis","relative","calcRelativeBox","parentProjection","defaultPagePoint","pageX","pageY","pointFromTouch","pointType","touches","changedTouches","pointFromMouse","extractEventInfo","getViewportPointFromEvent","wrapHandler","shouldFilterPrimaryPointer","eventHandler","listener","isMouseEvent","MouseEvent","button","PointerEvent","pointerType","isTouchEvent","hsla","saturation","lightness","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","SubscriptionManager","subscriptions","numSubscriptions","addUniqueItem","arr","item","removeItem","index","secondsToMilliseconds","seconds","isNum","combineFunctions","transformers","getAnimatableNone","defaultValueType","toFromDifference","isDraggable","_dragX","mixLinearColor","fromExpo","toExpo","colorTypes","getColorType","notAnimatable","mixColor","fromColorType","toColorType","fromColor","toColor","blended","mixFunc","getBoundingBox","getBoundingClientRect","isCSSVariable","cssVariableRegex","getVariableValue","exec","parseCSSVariable","token","fallback","trim","resolveCSSVariables","HTMLElement","reverseEasing","mirrorEasing","createBackIn","acos","backEasing","createAnticipate","p2","hex","r","substr","parseInt","velocityPerSecond","frameDuration","numColors","colors","replace","numbers","tokenised","convertNumbersToZero","transformer","maxDefaults","applyDefaultFilter","slice","number","unit","functionRegex","functions","join","isPoint","isPoint3D","distance1D","distance","xDelta","yDelta","zDelta","getCurrentTime","performance","now","Date","onNextFrame","requestAnimationFrame","useDefaultElapsed","runNextFrame","isProcessing","stepsOrder","steps","toRun","toRunNextFrame","numToRun","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","cancel","process","frameData","createRenderStep","sync","startLoop","cancelSync","flushSync","processStep","stepId","processFrame","getFrameData","AnimationType","noop","any","convertBoundingBoxToAxisBox","convertAxisBoxToBoundingBox","transformBoundingBox","transformPoint","topLeft","bottomRight","axisBox","copyAxisBox","zeroDelta","Presence","VisibilityAction"],"mappings":"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","file":"vendors~CenterText~CustomerPortalDashboard~FiftyFiftyTextImage~HomepageCarousel~LoginBanner~MyHires~~fc72ff48-3ac2bed3960bec15ceb5.js","sourcesContent":["// Call a handler once for each axis\nfunction eachAxis(handler) {\n    return [handler(\"x\"), handler(\"y\")];\n}\n\nexport { eachAxis };\n","import { useDomEvent, addDomEvent } from './use-dom-event.js';\nimport { wrapHandler } from './event-info.js';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.js';\n\nvar mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nvar touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nexport { addPointerEvent, usePointerEvent };\n","import { isBrowser } from '../utils/is-browser.js';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","import sync, { getFrameData } from 'framesync';\nimport { velocityPerSecond } from 'popmotion';\nimport { SubscriptionManager } from '../utils/subscription-manager.js';\n\nvar isFloat = function (value) {\n    return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */ (function () {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    function MotionValue(init) {\n        var _this = this;\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync.postRender(_this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (_this.prev !== _this.current) {\n                _this.updateSubscribers.notify(_this.current);\n            }\n            // Update velocity subscribers\n            if (_this.velocityUpdateSubscribers.getSize()) {\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n            // Update render subscribers\n            if (render) {\n                _this.renderSubscribers.notify(_this.current);\n            }\n        };\n        /**\n         * Schedule a velocity check for the next frame.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.scheduleVelocityCheck = function () { return sync.postRender(_this.velocityCheck); };\n        /**\n         * Updates `prev` with `current` if the value hasn't been updated this frame.\n         * This ensures velocity calculations return `0`.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.velocityCheck = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * @library\n     *\n     * ```jsx\n     * function MyComponent() {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <Frame x={x} />\n     * }\n     * ```\n     *\n     * @motion\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @internalremarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\n    };\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\n        return this.prev;\n    };\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    MotionValue.prototype.getVelocity = function () {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 0;\n    };\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    MotionValue.prototype.start = function (animation) {\n        var _this = this;\n        this.stop();\n        return new Promise(function (resolve) {\n            _this.hasAnimated = true;\n            _this.stopAnimation = animation(resolve);\n        }).then(function () { return _this.clearAnimation(); });\n    };\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    MotionValue.prototype.stop = function () {\n        if (this.stopAnimation)\n            this.stopAnimation();\n        this.clearAnimation();\n    };\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    MotionValue.prototype.isAnimating = function () {\n        return !!this.stopAnimation;\n    };\n    MotionValue.prototype.clearAnimation = function () {\n        this.stopAnimation = null;\n    };\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    MotionValue.prototype.destroy = function () {\n        this.updateSubscribers.clear();\n        this.renderSubscribers.clear();\n        this.stop();\n    };\n    return MotionValue;\n}());\n/**\n * @internal\n */\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\nexport { MotionValue, motionValue };\n","var mix = function (from, to, progress) {\n    return -progress * from + progress * to + from;\n};\n\nexport { mix };\n","import { isString } from '../utils.js';\nimport { hex } from './hex.js';\nimport { hsla } from './hsla.js';\nimport { rgba } from './rgba.js';\n\nvar color = {\n    test: function (v) { return rgba.test(v) || hex.test(v) || hsla.test(v); },\n    parse: function (v) {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: function (v) {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty('red')\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { warning } from 'hey-listen';\nimport { clamp } from '../../utils/clamp.js';\n\nvar safeMin = 0.001;\nvar minDuration = 0.01;\nvar maxDuration = 10.0;\nvar minDamping = 0.05;\nvar maxDamping = 1;\nfunction findSpring(_a) {\n    var _b = _a.duration, duration = _b === void 0 ? 800 : _b, _c = _a.bounce, bounce = _c === void 0 ? 0.25 : _c, _d = _a.velocity, velocity = _d === void 0 ? 0 : _d, _e = _a.mass, mass = _e === void 0 ? 1 : _e;\n    var envelope;\n    var derivative;\n    warning(duration <= maxDuration * 1000, \"Spring duration must be 10 seconds or less\");\n    var dampingRatio = 1 - bounce;\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\n        envelope = function (undampedFreq) {\n            var exponentialDecay = undampedFreq * dampingRatio;\n            var delta = exponentialDecay * duration;\n            var a = exponentialDecay - velocity;\n            var b = calcAngularFreq(undampedFreq, dampingRatio);\n            var c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = function (undampedFreq) {\n            var exponentialDecay = undampedFreq * dampingRatio;\n            var delta = exponentialDecay * duration;\n            var d = delta * velocity + velocity;\n            var e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            var f = Math.exp(-delta);\n            var g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            var factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        envelope = function (undampedFreq) {\n            var a = Math.exp(-undampedFreq * duration);\n            var b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = function (undampedFreq) {\n            var a = Math.exp(-undampedFreq * duration);\n            var b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    var initialGuess = 5 / duration;\n    var undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = duration * 1000;\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: 100,\n            damping: 10,\n            duration: duration,\n        };\n    }\n    else {\n        var stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness: stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration: duration,\n        };\n    }\n}\nvar rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    var result = initialGuess;\n    for (var i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };\n","import { __rest, __assign } from 'tslib';\nimport { findSpring, calcAngularFreq } from '../utils/find-spring.js';\n\nvar durationKeys = [\"duration\", \"bounce\"];\nvar physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some(function (key) { return options[key] !== undefined; });\n}\nfunction getSpringOptions(options) {\n    var springOptions = __assign({ velocity: 0.0, stiffness: 100, damping: 10, mass: 1.0, isResolvedFromDuration: false }, options);\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        var derived = findSpring(options);\n        springOptions = __assign(__assign(__assign({}, springOptions), derived), { velocity: 0.0, mass: 1.0 });\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring(_a) {\n    var _b = _a.from, from = _b === void 0 ? 0.0 : _b, _c = _a.to, to = _c === void 0 ? 1.0 : _c, _d = _a.restSpeed, restSpeed = _d === void 0 ? 2 : _d, restDelta = _a.restDelta, options = __rest(_a, [\"from\", \"to\", \"restSpeed\", \"restDelta\"]);\n    var state = { done: false, value: from };\n    var _e = getSpringOptions(options), stiffness = _e.stiffness, damping = _e.damping, mass = _e.mass, velocity = _e.velocity, duration = _e.duration, isResolvedFromDuration = _e.isResolvedFromDuration;\n    var resolveSpring = zero;\n    var resolveVelocity = zero;\n    function createSpring() {\n        var initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n        var initialDelta = to - from;\n        var dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n        var undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        restDelta !== null && restDelta !== void 0 ? restDelta : (restDelta = Math.abs(to - from) <= 1 ? 0.01 : 0.4);\n        if (dampingRatio < 1) {\n            var angularFreq_1 = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            resolveSpring = function (t) {\n                var envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (to -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq_1) *\n                            Math.sin(angularFreq_1 * t) +\n                            initialDelta * Math.cos(angularFreq_1 * t)));\n            };\n            resolveVelocity = function (t) {\n                var envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (dampingRatio *\n                    undampedAngularFreq *\n                    envelope *\n                    ((Math.sin(angularFreq_1 * t) *\n                        (initialVelocity +\n                            dampingRatio *\n                                undampedAngularFreq *\n                                initialDelta)) /\n                        angularFreq_1 +\n                        initialDelta * Math.cos(angularFreq_1 * t)) -\n                    envelope *\n                        (Math.cos(angularFreq_1 * t) *\n                            (initialVelocity +\n                                dampingRatio *\n                                    undampedAngularFreq *\n                                    initialDelta) -\n                            angularFreq_1 *\n                                initialDelta *\n                                Math.sin(angularFreq_1 * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            resolveSpring = function (t) {\n                return to -\n                    Math.exp(-undampedAngularFreq * t) *\n                        (initialDelta +\n                            (initialVelocity + undampedAngularFreq * initialDelta) *\n                                t);\n            };\n        }\n        else {\n            var dampedAngularFreq_1 = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = function (t) {\n                var envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                var freqForT = Math.min(dampedAngularFreq_1 * t, 300);\n                return (to -\n                    (envelope *\n                        ((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) *\n                            Math.sinh(freqForT) +\n                            dampedAngularFreq_1 *\n                                initialDelta *\n                                Math.cosh(freqForT))) /\n                        dampedAngularFreq_1);\n            };\n        }\n    }\n    createSpring();\n    return {\n        next: function (t) {\n            var current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                var currentVelocity = resolveVelocity(t) * 1000;\n                var isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                var isBelowDisplacementThreshold = Math.abs(to - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? to : current;\n            return state;\n        },\n        flipTarget: function () {\n            var _a;\n            velocity = -velocity;\n            _a = [to, from], from = _a[0], to = _a[1];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = function (a, b) {\n    return typeof a === \"string\" || typeof b === \"string\";\n};\nvar zero = function (_t) { return 0; };\n\nexport { spring };\n","import { __spreadArray, __assign } from 'tslib';\nimport { complex, color } from 'style-value-types';\nimport { mix } from './mix.js';\nimport { mixColor } from './mix-color.js';\nimport { isNum } from './inc.js';\nimport { pipe } from './pipe.js';\nimport { invariant } from 'hey-listen';\n\nfunction getMixer(origin, target) {\n    if (isNum(origin)) {\n        return function (v) { return mix(origin, target, v); };\n    }\n    else if (color.test(origin)) {\n        return mixColor(origin, target);\n    }\n    else {\n        return mixComplex(origin, target);\n    }\n}\nvar mixArray = function (from, to) {\n    var output = __spreadArray([], from);\n    var numValues = output.length;\n    var blendValue = from.map(function (fromThis, i) { return getMixer(fromThis, to[i]); });\n    return function (v) {\n        for (var i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](v);\n        }\n        return output;\n    };\n};\nvar mixObject = function (origin, target) {\n    var output = __assign(__assign({}, origin), target);\n    var blendValue = {};\n    for (var key in output) {\n        if (origin[key] !== undefined && target[key] !== undefined) {\n            blendValue[key] = getMixer(origin[key], target[key]);\n        }\n    }\n    return function (v) {\n        for (var key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n};\nfunction analyse(value) {\n    var parsed = complex.parse(value);\n    var numValues = parsed.length;\n    var numNumbers = 0;\n    var numRGB = 0;\n    var numHSL = 0;\n    for (var i = 0; i < numValues; i++) {\n        if (numNumbers || typeof parsed[i] === \"number\") {\n            numNumbers++;\n        }\n        else {\n            if (parsed[i].hue !== undefined) {\n                numHSL++;\n            }\n            else {\n                numRGB++;\n            }\n        }\n    }\n    return { parsed: parsed, numNumbers: numNumbers, numRGB: numRGB, numHSL: numHSL };\n}\nvar mixComplex = function (origin, target) {\n    var template = complex.createTransformer(target);\n    var originStats = analyse(origin);\n    var targetStats = analyse(target);\n    invariant(originStats.numHSL === targetStats.numHSL &&\n        originStats.numRGB === targetStats.numRGB &&\n        originStats.numNumbers >= targetStats.numNumbers, \"Complex values '\" + origin + \"' and '\" + target + \"' too different to mix. Ensure all colors are of the same type.\");\n    return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n};\n\nexport { mixArray, mixComplex, mixObject };\n","import { progress } from './progress.js';\nimport { mix } from './mix.js';\nimport { mixColor } from './mix-color.js';\nimport { mixComplex, mixArray, mixObject } from './mix-complex.js';\nimport { color } from 'style-value-types';\nimport { clamp } from './clamp.js';\nimport { pipe } from './pipe.js';\nimport { invariant } from 'hey-listen';\n\nvar mixNumber = function (from, to) { return function (p) { return mix(from, to, p); }; };\nfunction detectMixerFactory(v) {\n    if (typeof v === 'number') {\n        return mixNumber;\n    }\n    else if (typeof v === 'string') {\n        if (color.test(v)) {\n            return mixColor;\n        }\n        else {\n            return mixComplex;\n        }\n    }\n    else if (Array.isArray(v)) {\n        return mixArray;\n    }\n    else if (typeof v === 'object') {\n        return mixObject;\n    }\n}\nfunction createMixers(output, ease, customMixer) {\n    var mixers = [];\n    var mixerFactory = customMixer || detectMixerFactory(output[0]);\n    var numMixers = output.length - 1;\n    for (var i = 0; i < numMixers; i++) {\n        var mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            var easingFunction = Array.isArray(ease) ? ease[i] : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\nfunction fastInterpolate(_a, _b) {\n    var from = _a[0], to = _a[1];\n    var mixer = _b[0];\n    return function (v) { return mixer(progress(from, to, v)); };\n}\nfunction slowInterpolate(input, mixers) {\n    var inputLength = input.length;\n    var lastInputIndex = inputLength - 1;\n    return function (v) {\n        var mixerIndex = 0;\n        var foundMixerIndex = false;\n        if (v <= input[0]) {\n            foundMixerIndex = true;\n        }\n        else if (v >= input[lastInputIndex]) {\n            mixerIndex = lastInputIndex - 1;\n            foundMixerIndex = true;\n        }\n        if (!foundMixerIndex) {\n            var i = 1;\n            for (; i < inputLength; i++) {\n                if (input[i] > v || i === lastInputIndex) {\n                    break;\n                }\n            }\n            mixerIndex = i - 1;\n        }\n        var progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n        return mixers[mixerIndex](progressInRange);\n    };\n}\nfunction interpolate(input, output, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.clamp, isClamp = _c === void 0 ? true : _c, ease = _b.ease, mixer = _b.mixer;\n    var inputLength = input.length;\n    invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n    invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n    if (input[0] > input[inputLength - 1]) {\n        input = [].concat(input);\n        output = [].concat(output);\n        input.reverse();\n        output.reverse();\n    }\n    var mixers = createMixers(output, ease, mixer);\n    var interpolator = inputLength === 2\n        ? fastInterpolate(input, mixers)\n        : slowInterpolate(input, mixers);\n    return isClamp\n        ? function (v) { return interpolator(clamp(input[0], input[inputLength - 1], v)); }\n        : interpolator;\n}\n\nexport { interpolate };\n","import { interpolate } from '../../utils/interpolate.js';\nimport { easeInOut } from '../../easing/index.js';\n\nfunction defaultEasing(values, easing) {\n    return values.map(function () { return easing || easeInOut; }).splice(0, values.length - 1);\n}\nfunction defaultOffset(values) {\n    var numValues = values.length;\n    return values.map(function (_value, i) {\n        return i !== 0 ? i / (numValues - 1) : 0;\n    });\n}\nfunction convertOffsetToTimes(offset, duration) {\n    return offset.map(function (o) { return o * duration; });\n}\nfunction keyframes(_a) {\n    var _b = _a.from, from = _b === void 0 ? 0 : _b, _c = _a.to, to = _c === void 0 ? 1 : _c, ease = _a.ease, offset = _a.offset, _d = _a.duration, duration = _d === void 0 ? 300 : _d;\n    var state = { done: false, value: from };\n    var values = Array.isArray(to) ? to : [from, to];\n    var times = convertOffsetToTimes(offset && offset.length === values.length\n        ? offset\n        : defaultOffset(values), duration);\n    function createInterpolator() {\n        return interpolate(times, values, {\n            ease: Array.isArray(ease) ? ease : defaultEasing(values, ease),\n        });\n    }\n    var interpolator = createInterpolator();\n    return {\n        next: function (t) {\n            state.value = interpolator(t);\n            state.done = t >= duration;\n            return state;\n        },\n        flipTarget: function () {\n            values.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nexport { convertOffsetToTimes, defaultEasing, defaultOffset, keyframes };\n","import { spring } from '../generators/spring.js';\nimport { keyframes } from '../generators/keyframes.js';\nimport { decay } from '../generators/decay.js';\n\nvar types = { keyframes: keyframes, spring: spring, decay: decay };\nfunction detectAnimationFromOptions(config) {\n    if (Array.isArray(config.to)) {\n        return keyframes;\n    }\n    else if (types[config.type]) {\n        return types[config.type];\n    }\n    var keys = new Set(Object.keys(config));\n    if (keys.has(\"ease\") ||\n        (keys.has(\"duration\") && !keys.has(\"dampingRatio\"))) {\n        return keyframes;\n    }\n    else if (keys.has(\"dampingRatio\") ||\n        keys.has(\"stiffness\") ||\n        keys.has(\"mass\") ||\n        keys.has(\"damping\") ||\n        keys.has(\"restSpeed\") ||\n        keys.has(\"restDelta\")) {\n        return spring;\n    }\n    return keyframes;\n}\n\nexport { detectAnimationFromOptions };\n","function decay(_a) {\n    var _b = _a.velocity, velocity = _b === void 0 ? 0 : _b, _c = _a.from, from = _c === void 0 ? 0 : _c, _d = _a.power, power = _d === void 0 ? 0.8 : _d, _e = _a.timeConstant, timeConstant = _e === void 0 ? 350 : _e, _f = _a.restDelta, restDelta = _f === void 0 ? 0.5 : _f, modifyTarget = _a.modifyTarget;\n    var state = { done: false, value: from };\n    var amplitude = power * velocity;\n    var ideal = from + amplitude;\n    var target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    if (target !== ideal)\n        amplitude = target - from;\n    return {\n        next: function (t) {\n            var delta = -amplitude * Math.exp(-t / timeConstant);\n            state.done = !(delta > restDelta || delta < -restDelta);\n            state.value = state.done ? target : target + delta;\n            return state;\n        },\n        flipTarget: function () { },\n    };\n}\n\nexport { decay };\n","function loopElapsed(elapsed, duration, delay) {\n    if (delay === void 0) { delay = 0; }\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration, delay, isForwardPlayback) {\n    if (delay === void 0) { delay = 0; }\n    if (isForwardPlayback === void 0) { isForwardPlayback = true; }\n    return isForwardPlayback\n        ? loopElapsed(duration + -elapsed, duration, delay)\n        : duration - (elapsed - duration) + delay;\n}\nfunction hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {\n    return isForwardPlayback ? elapsed >= duration + delay : elapsed <= -delay;\n}\n\nexport { hasRepeatDelayElapsed, loopElapsed, reverseElapsed };\n","import { __rest, __assign } from 'tslib';\nimport { detectAnimationFromOptions } from './utils/detect-animation-from-options.js';\nimport sync, { cancelSync } from 'framesync';\nimport { interpolate } from '../utils/interpolate.js';\nimport { hasRepeatDelayElapsed, reverseElapsed, loopElapsed } from './utils/elapsed.js';\n\nvar framesync = function (update) {\n    var passTimestamp = function (_a) {\n        var delta = _a.delta;\n        return update(delta);\n    };\n    return {\n        start: function () { return sync.update(passTimestamp, true); },\n        stop: function () { return cancelSync.update(passTimestamp); },\n    };\n};\nfunction animate(_a) {\n    var _b, _c;\n    var from = _a.from, _d = _a.autoplay, autoplay = _d === void 0 ? true : _d, _e = _a.driver, driver = _e === void 0 ? framesync : _e, _f = _a.elapsed, elapsed = _f === void 0 ? 0 : _f, _g = _a.repeat, repeatMax = _g === void 0 ? 0 : _g, _h = _a.repeatType, repeatType = _h === void 0 ? \"loop\" : _h, _j = _a.repeatDelay, repeatDelay = _j === void 0 ? 0 : _j, onPlay = _a.onPlay, onStop = _a.onStop, onComplete = _a.onComplete, onRepeat = _a.onRepeat, onUpdate = _a.onUpdate, options = __rest(_a, [\"from\", \"autoplay\", \"driver\", \"elapsed\", \"repeat\", \"repeatType\", \"repeatDelay\", \"onPlay\", \"onStop\", \"onComplete\", \"onRepeat\", \"onUpdate\"]);\n    var to = options.to;\n    var driverControls;\n    var repeatCount = 0;\n    var computedDuration = options.duration;\n    var latest;\n    var isComplete = false;\n    var isForwardPlayback = true;\n    var interpolateFromNumber;\n    var animator = detectAnimationFromOptions(options);\n    if ((_c = (_b = animator).needsInterpolation) === null || _c === void 0 ? void 0 : _c.call(_b, from, to)) {\n        interpolateFromNumber = interpolate([0, 100], [from, to], {\n            clamp: false,\n        });\n        from = 0;\n        to = 100;\n    }\n    var animation = animator(__assign(__assign({}, options), { from: from, to: to }));\n    function repeat() {\n        repeatCount++;\n        if (repeatType === \"reverse\") {\n            isForwardPlayback = repeatCount % 2 === 0;\n            elapsed = reverseElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback);\n        }\n        else {\n            elapsed = loopElapsed(elapsed, computedDuration, repeatDelay);\n            if (repeatType === \"mirror\")\n                animation.flipTarget();\n        }\n        isComplete = false;\n        onRepeat && onRepeat();\n    }\n    function complete() {\n        driverControls.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            var state = animation.next(Math.max(0, elapsed));\n            latest = state.value;\n            if (interpolateFromNumber)\n                latest = interpolateFromNumber(latest);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(latest);\n        if (isComplete) {\n            if (repeatCount === 0)\n                computedDuration !== null && computedDuration !== void 0 ? computedDuration : (computedDuration = elapsed);\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay === null || onPlay === void 0 ? void 0 : onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: function () {\n            onStop === null || onStop === void 0 ? void 0 : onStop();\n            driverControls.stop();\n        },\n    };\n}\n\nexport { animate };\n","import { linear } from './index.js';\n\nvar a = function (a1, a2) { return 1.0 - 3.0 * a2 + 3.0 * a1; };\nvar b = function (a1, a2) { return 3.0 * a2 - 6.0 * a1; };\nvar c = function (a1) { return 3.0 * a1; };\nvar calcBezier = function (t, a1, a2) {\n    return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\n};\nvar getSlope = function (t, a1, a2) {\n    return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\n};\nvar subdivisionPrecision = 0.0000001;\nvar subdivisionMaxIterations = 10;\nfunction binarySubdivide(aX, aA, aB, mX1, mX2) {\n    var currentX;\n    var currentT;\n    var i = 0;\n    do {\n        currentT = aA + (aB - aA) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - aX;\n        if (currentX > 0.0) {\n            aB = currentT;\n        }\n        else {\n            aA = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nvar newtonIterations = 8;\nvar newtonMinSlope = 0.001;\nfunction newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {\n    for (var i = 0; i < newtonIterations; ++i) {\n        var currentSlope = getSlope(aGuessT, mX1, mX2);\n        if (currentSlope === 0.0) {\n            return aGuessT;\n        }\n        var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n        aGuessT -= currentX / currentSlope;\n    }\n    return aGuessT;\n}\nvar kSplineTableSize = 11;\nvar kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    if (mX1 === mY1 && mX2 === mY2)\n        return linear;\n    var sampleValues = new Float32Array(kSplineTableSize);\n    for (var i = 0; i < kSplineTableSize; ++i) {\n        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n    }\n    function getTForX(aX) {\n        var intervalStart = 0.0;\n        var currentSample = 1;\n        var lastSample = kSplineTableSize - 1;\n        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += kSampleStepSize;\n        }\n        --currentSample;\n        var dist = (aX - sampleValues[currentSample]) /\n            (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n        var guessForT = intervalStart + dist * kSampleStepSize;\n        var initialSlope = getSlope(guessForT, mX1, mX2);\n        if (initialSlope >= newtonMinSlope) {\n            return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n        }\n        else if (initialSlope === 0.0) {\n            return guessForT;\n        }\n        else {\n            return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n        }\n    }\n    return function (t) {\n        return t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n    };\n}\n\nexport { cubicBezier };\n","import { __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { cubicBezier, linear, easeIn, easeInOut, easeOut, circIn, circInOut, circOut, backIn, backInOut, backOut, anticipate, bounceIn, bounceInOut, bounceOut } from 'popmotion';\n\nvar easingLookup = {\n    linear: linear,\n    easeIn: easeIn,\n    easeInOut: easeInOut,\n    easeOut: easeOut,\n    circIn: circIn,\n    circInOut: circInOut,\n    circOut: circOut,\n    backIn: backIn,\n    backInOut: backInOut,\n    backOut: backOut,\n    anticipate: anticipate,\n    bounceIn: bounceIn,\n    bounceInOut: bounceInOut,\n    bounceOut: bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = __read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\" + definition + \"'\");\n        return easingLookup[definition];\n    }\n    return definition;\n};\nvar isEasingArray = function (ease) {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { easingDefinitionToFunction, isEasingArray };\n","import { complex } from 'style-value-types';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nvar isAnimatable = function (key, value) {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\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    return false;\n};\n\nexport { isAnimatable };\n","import { __assign } from 'tslib';\nimport { isKeyframesTarget } from './is-keyframes-target.js';\n\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restDelta: 0.5,\n    restSpeed: 10,\n}); };\nvar criticallyDampedSpring = function (to) { return ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restDelta: 0.01,\n    restSpeed: 10,\n}); };\nvar linearTween = function () { return ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n}); };\nvar keyframes = function (values) { return ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values,\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: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nvar getDefaultTransition = function (valueKey, to) {\n    var transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return __assign({ to: to }, transitionFactory(to));\n};\n\nexport { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };\n","import { __assign, __rest, __spreadArray, __read } from 'tslib';\nimport { inertia, animate } from 'popmotion';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.js';\nimport { isEasingArray, easingDefinitionToFunction } from './easing.js';\nimport { isAnimatable } from './is-animatable.js';\nimport { getDefaultTransition } from './default-transitions.js';\nimport { warning } from 'hey-listen';\nimport { getAnimatableNone } from '../../render/dom/value-types/animatable-none.js';\n\n/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined(_a) {\n    _a.when; _a.delay; _a.delayChildren; _a.staggerChildren; _a.staggerDirection; _a.repeat; _a.repeatType; _a.repeatDelay; _a.from; var transition = __rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\", \"repeat\", \"repeatType\", \"repeatDelay\", \"from\"]);\n    return !!Object.keys(transition).length;\n}\nvar legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions(_a) {\n    var ease = _a.ease, times = _a.times, yoyo = _a.yoyo, flip = _a.flip, loop = _a.loop, transition = __rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = __assign({}, transition);\n    if (times)\n        options[\"offset\"] = times;\n    /**\n     * Convert any existing durations from seconds to milliseconds\n     */\n    if (transition.duration)\n        options[\"duration\"] = secondsToMilliseconds(transition.duration);\n    if (transition.repeatDelay)\n        options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n    /**\n     * Map easing names to Popmotion's easing functions\n     */\n    if (ease) {\n        options[\"ease\"] = isEasingArray(ease)\n            ? ease.map(easingDefinitionToFunction)\n            : easingDefinitionToFunction(ease);\n    }\n    /**\n     * Support legacy transition API\n     */\n    if (transition.type === \"tween\")\n        options.type = \"keyframes\";\n    /**\n     * TODO: These options are officially removed from the API.\n     */\n    if (yoyo || loop || flip) {\n        warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n        legacyRepeatWarning = true;\n        if (yoyo) {\n            options.repeatType = \"reverse\";\n        }\n        else if (loop) {\n            options.repeatType = \"loop\";\n        }\n        else if (flip) {\n            options.repeatType = \"mirror\";\n        }\n        options.repeat = loop || yoyo || flip || transition.repeat;\n    }\n    /**\n     * TODO: Popmotion 9 has the ability to automatically detect whether to use\n     * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n     * It'd be good to introduce a similar thing here.\n     */\n    if (transition.type !== \"spring\")\n        options.type = \"keyframes\";\n    return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n    var _a;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = __spreadArray([], __read(options.to));\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    var _a;\n    if (Array.isArray(options.to)) {\n        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = __assign(__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return __assign(__assign({}, options), convertTransitionToAnimationOptions(transition));\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n    var _a;\n    var valueTransition = getValueTransition(transition, key);\n    var origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();\n    var isTargetAnimatable = isAnimatable(key, target);\n    if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n        /**\n         * If we're trying to animate from \"none\", try and get an animatable version\n         * of the target. This could be improved to work both ways.\n         */\n        origin = getAnimatableNone(key, target);\n    }\n    else if (isZero(origin) && typeof target === \"string\") {\n        origin = getZeroUnit(target);\n    }\n    else if (!Array.isArray(target) &&\n        isZero(target) &&\n        typeof origin === \"string\") {\n        target = getZeroUnit(origin);\n    }\n    var isOriginAnimatable = isAnimatable(key, origin);\n    warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \" + key + \" from \\\"\" + origin + \"\\\" to \\\"\" + target + \"\\\". \" + origin + \" is not an animatable value - to enable this animation set \" + origin + \" to a value animatable to \" + target + \" via the `style` property.\");\n    function start() {\n        var options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete: onComplete,\n            onUpdate: function (v) { return value.set(v); },\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? inertia(__assign(__assign({}, options), valueTransition))\n            : animate(__assign(__assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), { onUpdate: function (v) {\n                    var _a;\n                    options.onUpdate(v);\n                    (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);\n                }, onComplete: function () {\n                    var _a;\n                    options.onComplete();\n                    (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n                } }));\n    }\n    function set() {\n        var _a;\n        value.set(target);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n        return { stop: function () { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n *\n * @internal\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\n    return value.start(function (onComplete) {\n        var delayTimer;\n        var controls;\n        var animation = getAnimation(key, value, target, transition, onComplete);\n        var delay = getDelayFromTransition(transition, key);\n        var start = function () { return (controls = animation()); };\n        if (delay) {\n            delayTimer = setTimeout(start, secondsToMilliseconds(delay));\n        }\n        else {\n            start();\n        }\n        return function () {\n            clearTimeout(delayTimer);\n            controls === null || controls === void 0 ? void 0 : controls.stop();\n        };\n    });\n}\n\nexport { convertTransitionToAnimationOptions, getDelayFromTransition, getPopmotionAnimationOptions, getValueTransition, getZeroUnit, hydrateKeyframes, isTransitionDefined, isZero, startAnimation };\n","import { __assign } from 'tslib';\nimport { animate } from './index.js';\nimport { velocityPerSecond } from '../utils/velocity-per-second.js';\nimport { getFrameData } from 'framesync';\n\nfunction inertia(_a) {\n    var _b = _a.from, from = _b === void 0 ? 0 : _b, _c = _a.velocity, velocity = _c === void 0 ? 0 : _c, min = _a.min, max = _a.max, _d = _a.power, power = _d === void 0 ? 0.8 : _d, _e = _a.timeConstant, timeConstant = _e === void 0 ? 750 : _e, _f = _a.bounceStiffness, bounceStiffness = _f === void 0 ? 500 : _f, _g = _a.bounceDamping, bounceDamping = _g === void 0 ? 10 : _g, _h = _a.restDelta, restDelta = _h === void 0 ? 1 : _h, modifyTarget = _a.modifyTarget, driver = _a.driver, onUpdate = _a.onUpdate, onComplete = _a.onComplete;\n    var currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function boundaryNearest(v) {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    }\n    function startAnimation(options) {\n        currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n        currentAnimation = animate(__assign(__assign({}, options), { driver: driver, onUpdate: function (v) {\n                var _a;\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n                (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n            }, onComplete: onComplete }));\n    }\n    function startSpring(options) {\n        startAnimation(__assign({ type: \"spring\", stiffness: bounceStiffness, damping: bounceDamping, restDelta: restDelta }, options));\n    }\n    if (isOutOfBounds(from)) {\n        startSpring({ from: from, velocity: velocity, to: boundaryNearest(from) });\n    }\n    else {\n        var target = power * velocity + from;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        var boundary_1 = boundaryNearest(target);\n        var heading_1 = boundary_1 === min ? -1 : 1;\n        var prev_1;\n        var current_1;\n        var checkBoundary = function (v) {\n            prev_1 = current_1;\n            current_1 = v;\n            velocity = velocityPerSecond(v - prev_1, getFrameData().delta);\n            if ((heading_1 === 1 && v > boundary_1) ||\n                (heading_1 === -1 && v < boundary_1)) {\n                startSpring({ from: v, to: boundary_1, velocity: velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            from: from,\n            velocity: velocity,\n            timeConstant: timeConstant,\n            power: power,\n            restDelta: restDelta,\n            modifyTarget: modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: function () { return currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop(); },\n    };\n}\n\nexport { inertia };\n","import { mix } from 'popmotion';\n\nfunction tweenAxis(target, prev, next, p) {\n    target.min = mix(prev.min, next.min, p);\n    target.max = mix(prev.max, next.max, p);\n}\nfunction calcRelativeOffsetAxis(parent, child) {\n    return {\n        min: child.min - parent.min,\n        max: child.max - parent.min,\n    };\n}\nfunction calcRelativeOffset(parent, child) {\n    return {\n        x: calcRelativeOffsetAxis(parent.x, child.x),\n        y: calcRelativeOffsetAxis(parent.y, child.y),\n    };\n}\nfunction checkIfParentHasChanged(prev, next) {\n    var prevId = prev.getLayoutId();\n    var nextId = next.getLayoutId();\n    return prevId !== nextId || (nextId === undefined && prev !== next);\n}\n\nexport { calcRelativeOffset, calcRelativeOffsetAxis, checkIfParentHasChanged, tweenAxis };\n","var compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nexport { compareByDepth };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { isDraggable } from '../../render/utils/is-draggable.js';\n\n/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction resetAxis(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction resetBox(box, originBox) {\n    resetAxis(box.x, originBox.x);\n    resetAxis(box.y, originBox.y);\n}\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    var distanceFromOrigin = point - originPoint;\n    var scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _a) {\n    var x = _a.x, y = _a.y;\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction applyAxisTransforms(final, axis, transforms, _a) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    // Copy the current axis to the final axis before mutation\n    final.min = axis.min;\n    final.max = axis.max;\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(final, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction applyBoxTransforms(finalBox, box, transforms) {\n    applyAxisTransforms(finalBox.x, box.x, transforms, xKeys);\n    applyAxisTransforms(finalBox.y, box.y, transforms, yKeys);\n}\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate, scale, origin, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    var originPoint = mix(axis.min, axis.max, origin) - translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, _a) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale);\n}\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms) {\n    removeAxisTransforms(box.x, transforms, xKeys);\n    removeAxisTransforms(box.y, transforms, yKeys);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath) {\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.getLayoutState().delta;\n        // Incoporate each ancestor's scale into a culmulative treeScale for this component\n        treeScale.x *= delta.x.scale;\n        treeScale.y *= delta.y.scale;\n        // Apply each ancestor's calculated delta into this component's recorded layout box\n        applyBoxDelta(box, delta);\n        // If this is a draggable ancestor, also incorporate the node's transform to the layout box\n        if (isDraggable(node)) {\n            applyBoxTransforms(box, box, node.getLatestValues());\n        }\n    }\n}\n\nexport { applyAxisDelta, applyAxisTransforms, applyBoxDelta, applyBoxTransforms, applyPointDelta, applyTreeDeltas, removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta, resetAxis, resetBox, scalePoint };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    var prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (var i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\nexport { testValueType };\n","import { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.js';\nimport { auto } from './type-auto.js';\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n    return dimensionValueTypes.find(testValueType(v));\n};\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\nexport { auto };\n","import { __spreadArray, __read } from 'tslib';\nimport { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.js';\nimport { testValueType } from './test.js';\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = __spreadArray(__spreadArray([], __read(dimensionValueTypes)), [color, complex]);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\n\nexport { findValueType };\n","import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { complex } from 'style-value-types';\nimport { isNumericalString } from '../../utils/is-numerical-string.js';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.js';\nimport { motionValue } from '../../value/index.js';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.js';\nimport { findValueType } from '../dom/value-types/find.js';\nimport { resolveVariant } from './variants.js';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    var resolved = resolveVariant(visualElement, definition);\n    var _a = resolved\n        ? visualElement.makeTargetAnimatable(resolved, false)\n        : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = __rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = __assign(__assign({}, target), transitionEnd);\n    for (var key in target) {\n        var value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    var reversedLabels = __spreadArray([], __read(variantLabels)).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\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        }\n        else if (!findValueType(value) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : (_d[key] = value);\n        visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    var valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a, _b;\n    var origin = {};\n    for (var key in target) {\n        origin[key] =\n            (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","import { __read, __rest, __assign } from 'tslib';\nimport { startAnimation } from '../../animation/utils/transitions.js';\nimport { setTarget } from './setters.js';\nimport { resolveVariant } from './variants.js';\n\n/**\n * @internal\n */\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart();\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return Promise.resolve(); };\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return Promise.resolve(); };\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    var when = transition.when;\n    if (when) {\n        var _c = __read(when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n    var _b;\n    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;\n    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = __rest(_e, [\"transition\", \"transitionEnd\"]);\n    if (transitionOverride)\n        transition = transitionOverride;\n    var animations = [];\n    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n    for (var key in target) {\n        var value = visualElement.getValue(key);\n        var valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        var animation = startAnimation(key, value, valueTarget, __assign({ delay: delay }, transition));\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, __assign(__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.forEachValue(function (value) { return value.stop(); });\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation(_a, key) {\n    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;\n    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\n","import { __spreadArray, __read, __assign, __rest } from 'tslib';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.js';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.js';\nimport { shallowCompare } from '../../utils/shallow-compare.js';\nimport { animateVisualElement } from './animation.js';\nimport { AnimationType } from './types.js';\nimport { isVariantLabels, resolveVariant, isVariantLabel } from './variants.js';\n\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Focus,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = __spreadArray([], __read(variantPriorityOrder)).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = __rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = __assign(__assign(__assign({}, acc), target), transitionEnd);\n        }\n        return acc;\n    };\n    function isAnimated(key) {\n        return allAnimatedKeys[key] !== undefined;\n    }\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        var _a;\n        var props = visualElement.getProps();\n        var context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        var animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        var removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        var encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        var removedVariantIndex = Infinity;\n        var _loop_1 = function (i) {\n            var type = reversePriorityOrder[i];\n            var typeState = state[type];\n            var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            var propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            var activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            var isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = __assign({}, encounteredKeys);\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                return \"continue\";\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            var shouldAnimateType = variantsHaveChanged(typeState.prevProp, prop) ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            var definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = __assign(__assign({}, prevResolvedValues), resolvedValues);\n            var markToAnimate = function (key) {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (var key in allKeys) {\n                var next = resolvedValues[key];\n                var prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev)) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = __assign(__assign({}, encounteredKeys), resolvedValues);\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push.apply(animations, __spreadArray([], __read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: __assign({ type: type }, options),\n                }); }))));\n            }\n        };\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = __assign({}, encounteredKeys);\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            var fallbackAnimation_1 = {};\n            removedKeys.forEach(function (key) {\n                var fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation_1[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation_1 });\n        }\n        var shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        return animateChanges(options, type);\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction variantsHaveChanged(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[AnimationType.Animate] = createTypeState(true),\n        _a[AnimationType.Hover] = createTypeState(),\n        _a[AnimationType.Tap] = createTypeState(),\n        _a[AnimationType.Drag] = createTypeState(),\n        _a[AnimationType.Focus] = createTypeState(),\n        _a[AnimationType.Exit] = createTypeState(),\n        _a;\n}\n\nexport { createAnimationState, variantPriorityOrder, variantsHaveChanged };\n","import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.js';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.js';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { createAnimationState } from '../../render/utils/animation-state.js';\nimport { AnimationType } from '../../render/utils/types.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\n\nvar animations = {\n    animation: makeRenderlessComponent(function (_a) {\n        var visualElement = _a.visualElement, animate = _a.animate;\n        /**\n         * We dynamically generate the AnimationState manager as it contains a reference\n         * to the underlying animation library. We only want to load that if we load this,\n         * so people can optionally code split it out using the `m` component.\n         */\n        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            useEffect(function () { return animate.subscribe(visualElement); }, [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent(function (props) {\n        var custom = props.custom, visualElement = props.visualElement;\n        var _a = __read(usePresence(), 2), isPresent = _a[0], onExitComplete = _a[1];\n        var presenceContext = useContext(PresenceContext);\n        useEffect(function () {\n            var _a, _b;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(onExitComplete));\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n","import { isMouseEvent } from './utils/event-type.js';\nimport { AnimationType } from '../render/utils/types.js';\nimport { usePointerEvent } from '../events/use-pointer-event.js';\nimport { isDragActive } from './drag/utils/lock.js';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined);\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined);\n}\n\nexport { useHoverGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nvar isNodeOrChild = function (parent, child) {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","import { useFocusGesture } from '../../gestures/use-focus-gesture.js';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.js';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\n\nvar gestureAnimations = {\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nexport { gestureAnimations };\n","import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.js';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.js';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.js';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.js';\nimport { isDragActive } from './drag/utils/lock.js';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n    var onTap = _a.onTap, onTapStart = _a.onTapStart, onTapCancel = _a.onTapCancel, whileTap = _a.whileTap, visualElement = _a.visualElement;\n    var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    var isPressing = useRef(false);\n    var cancelPointerEndListeners = useRef(null);\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.getInstance(), event.target)\n            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)\n            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        var _a;\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp), addPointerEvent(window, \"pointercancel\", onPointerCancel));\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n","import { AnimationType } from '../render/utils/types.js';\nimport { useDomEvent } from '../events/use-dom-event.js';\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n    var whileFocus = _a.whileFocus, visualElement = _a.visualElement;\n    var onFocus = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nexport { useFocusGesture };\n","import { axisBox, delta } from '../../utils/geometry/index.js';\n\nvar createProjectionState = function () { return ({\n    isEnabled: false,\n    isHydrated: false,\n    isTargetLocked: false,\n    target: axisBox(),\n    targetFinal: axisBox(),\n}); };\nfunction createLayoutState() {\n    return {\n        isHydrated: false,\n        layout: axisBox(),\n        layoutCorrected: axisBox(),\n        treeScale: { x: 1, y: 1 },\n        delta: delta(),\n        deltaFinal: delta(),\n        deltaTransform: \"\",\n    };\n}\nvar zeroLayout = createLayoutState();\n\nexport { createLayoutState, createProjectionState, zeroLayout };\n","import { zeroLayout } from '../../utils/state.js';\n\n/**\n * Build a transform style that takes a calculated delta between the element's current\n * space on screen and projects it into the desired space.\n */\nfunction buildLayoutProjectionTransform(_a, treeScale, latestTransform) {\n    var x = _a.x, y = _a.y;\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = x.translate / treeScale.x;\n    var yTranslate = y.translate / treeScale.y;\n    var transform = \"translate3d(\" + xTranslate + \"px, \" + yTranslate + \"px, 0) \";\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\" + rotate + \") \";\n        if (rotateX)\n            transform += \"rotateX(\" + rotateX + \") \";\n        if (rotateY)\n            transform += \"rotateY(\" + rotateY + \") \";\n    }\n    transform += \"scale(\" + x.scale + \", \" + y.scale + \")\";\n    return !latestTransform && transform === identityProjection ? \"\" : transform;\n}\n/**\n * Take the calculated delta origin and apply it as a transform string.\n */\nfunction buildLayoutProjectionTransformOrigin(_a) {\n    var deltaFinal = _a.deltaFinal;\n    return deltaFinal.x.origin * 100 + \"% \" + deltaFinal.y.origin * 100 + \"% 0\";\n}\nvar identityProjection = buildLayoutProjectionTransform(zeroLayout.delta, zeroLayout.treeScale, { x: 1, y: 1 });\n\nexport { buildLayoutProjectionTransform, buildLayoutProjectionTransformOrigin, identityProjection };\n","import { __spreadArray, __read } from 'tslib';\nimport { SubscriptionManager } from '../../utils/subscription-manager.js';\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            return names.forEach(function (name) {\n                var _a;\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                var on = \"on\" + name;\n                var propListener = props[on];\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, __spreadArray([], __read(args)));\n        };\n    });\n    return lifecycles;\n}\n\nexport { createLifecycles };\n","import { addUniqueItem, removeItem } from '../../utils/array.js';\nimport { compareByDepth } from './compare-by-depth.js';\n\nvar FlatTree = /** @class */ (function () {\n    function FlatTree() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    FlatTree.prototype.add = function (child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.remove = function (child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.forEach = function (callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    };\n    return FlatTree;\n}());\n\nexport { FlatTree };\n","import { __assign, __spreadArray, __read } from 'tslib';\nimport sync, { cancelSync } from 'framesync';\nimport { pipe } from 'popmotion';\nimport { Presence } from '../components/AnimateSharedLayout/types.js';\nimport { eachAxis } from '../utils/each-axis.js';\nimport { axisBox } from '../utils/geometry/index.js';\nimport { removeBoxTransforms, applyBoxTransforms } from '../utils/geometry/delta-apply.js';\nimport { calcRelativeBox, updateBoxDelta } from '../utils/geometry/delta-calc.js';\nimport { motionValue } from '../value/index.js';\nimport { isMotionValue } from '../value/utils/is-motion-value.js';\nimport { buildLayoutProjectionTransform } from './html/utils/build-projection-transform.js';\nimport { variantPriorityOrder } from './utils/animation-state.js';\nimport { createLifecycles } from './utils/lifecycles.js';\nimport { updateMotionValuesFromProps } from './utils/motion-values.js';\nimport { updateLayoutDeltas } from './utils/projection.js';\nimport { createLayoutState, createProjectionState } from './utils/state.js';\nimport { FlatTree } from './utils/flat-tree.js';\nimport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.js';\nimport { setCurrentViewportBox } from './dom/projection/relative-set.js';\nimport { isDraggable } from './utils/is-draggable.js';\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, resetTransform = _a.resetTransform, restoreTransform = _a.restoreTransform, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState;\n        if (options === void 0) { options = {}; }\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender and onViewportBoxUpdate.\n         */\n        var lifecycles = createLifecycles();\n        /**\n         *\n         */\n        var projection = createProjectionState();\n        /**\n         * A reference to the nearest projecting parent. This is either\n         * undefined if we haven't looked for the nearest projecting parent,\n         * false if there is no parent performing layout projection, or a reference\n         * to the projecting parent.\n         */\n        var projectionParent;\n        /**\n         * This is a reference to the visual state of the \"lead\" visual element.\n         * Usually, this will be this visual element. But if it shares a layoutId\n         * with other visual elements, only one of them will be designated lead by\n         * AnimateSharedLayout. All the other visual elements will take on the visual\n         * appearance of the lead while they crossfade to it.\n         */\n        var leadProjection = projection;\n        var leadLatestValues = latestValues;\n        var unsubscribeFromLeadVisualElement;\n        /**\n         * The latest layout measurements and calculated projections. This\n         * is seperate from the target projection data in visualState as\n         * many visual elements might point to the same piece of visualState as\n         * a target, whereas they might each have different layouts and thus\n         * projection calculations needed to project into the same viewport box.\n         */\n        var layoutState = createLayoutState();\n        /**\n         *\n         */\n        var crossfader;\n        /**\n         * Keep track of whether the viewport box has been updated since the\n         * last time the layout projection was re-calculated.\n         */\n        var hasViewportBoxUpdated = false;\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        var prevMotionValues = {};\n        /**\n         * x/y motion values that track the progress of initiated layout\n         * animations.\n         *\n         * TODO: Target for removal\n         */\n        var projectionTargetProgress;\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = __assign({}, latestValues);\n        // Internal methods ========================\n        /**\n         * On mount, this will be hydrated with a callback to disconnect\n         * this visual element from its parent on unmount.\n         */\n        var removeFromVariantTree;\n        /**\n         *\n         */\n        function render() {\n            if (!instance)\n                return;\n            if (element.isProjectionReady()) {\n                /**\n                 * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n                 * This is the final box that we will then project into by calculating a transform delta and\n                 * applying it to the corrected box.\n                 */\n                applyBoxTransforms(leadProjection.targetFinal, leadProjection.target, leadLatestValues);\n                /**\n                 * Update the delta between the corrected box and the final target box, after\n                 * user-set transforms are applied to it. This will be used by the renderer to\n                 * create a transform style that will reproject the element from its actual layout\n                 * into the desired bounding box.\n                 */\n                updateBoxDelta(layoutState.deltaFinal, layoutState.layoutCorrected, leadProjection.targetFinal, latestValues);\n            }\n            triggerBuild();\n            renderInstance(instance, renderState);\n        }\n        function triggerBuild() {\n            var valuesToRender = latestValues;\n            if (crossfader && crossfader.isActive()) {\n                var crossfadedValues = crossfader.getCrossfadeState(element);\n                if (crossfadedValues)\n                    valuesToRender = crossfadedValues;\n            }\n            build(element, renderState, valuesToRender, leadProjection, layoutState, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        function updateLayoutProjection() {\n            if (!element.isProjectionReady())\n                return;\n            var delta = layoutState.delta, treeScale = layoutState.treeScale;\n            var prevTreeScaleX = treeScale.x;\n            var prevTreeScaleY = treeScale.y;\n            var prevDeltaTransform = layoutState.deltaTransform;\n            updateLayoutDeltas(layoutState, leadProjection, element.path, latestValues);\n            hasViewportBoxUpdated &&\n                element.notifyViewportBoxUpdate(leadProjection.target, delta);\n            hasViewportBoxUpdated = false;\n            var deltaTransform = buildLayoutProjectionTransform(delta, treeScale);\n            if (deltaTransform !== prevDeltaTransform ||\n                // Also compare calculated treeScale, for values that rely on this only for scale correction\n                prevTreeScaleX !== treeScale.x ||\n                prevTreeScaleY !== treeScale.y) {\n                element.scheduleRender();\n            }\n            layoutState.deltaTransform = deltaTransform;\n        }\n        function updateTreeLayoutProjection() {\n            element.layoutTree.forEach(fireUpdateLayoutProjection);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync.update(update, false, true);\n            });\n            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n            valueSubscriptions.set(key, function () {\n                removeOnChange();\n                removeOnRenderRequest();\n            });\n        }\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        var initialMotionValues = scrapeMotionValuesFromProps(props);\n        for (var key in initialMotionValues) {\n            var value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        var isControllingVariants = checkIfControllingVariants(props);\n        var isVariantNode = checkIfVariantNode(props);\n        var element = __assign(__assign({ treeType: treeType, \n            /**\n             * This is a mirror of the internal instance prop, which keeps\n             * VisualElement type-compatible with React's RefObject.\n             */\n            current: null, \n            /**\n             * The depth of this visual element within the visual element tree.\n             */\n            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), \n            /**\n             * An ancestor path back to the root visual element. This is used\n             * by layout projection to quickly recurse back up the tree.\n             */\n            path: parent ? __spreadArray(__spreadArray([], __read(parent.path)), [parent]) : [], layoutTree: parent ? parent.layoutTree : new FlatTree(), \n            /**\n             *\n             */\n            presenceId: presenceId,\n            projection: projection, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by AnimateSharedLayout, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                instance = element.current = newInstance;\n                element.pointTo(element);\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n            },\n            /**\n             *\n             */\n            unmount: function () {\n                cancelSync.update(update);\n                cancelSync.render(render);\n                cancelSync.preRender(element.updateLayoutProjection);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                element.stopLayoutAnimation();\n                element.layoutTree.remove(element);\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n                lifecycles.clearAllListeners();\n            },\n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () { return closestVariantNode.variantChildren.delete(child); };\n                }\n            },\n            sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * A method that schedules an update to layout projections throughout\n             * the tree. We inherit from the parent so there's only ever one\n             * job scheduled on the next frame - that of the root visual element.\n             */\n            scheduleUpdateLayoutProjection: parent\n                ? parent.scheduleUpdateLayoutProjection\n                : function () {\n                    return sync.preRender(element.updateTreeLayoutProjection, false, true);\n                }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\n            },\n            /**\n             * Make a target animatable by Popmotion. For instance, if we're\n             * trying to animate width from 100px to 100vw we need to measure 100vw\n             * in pixels to determine what we really need to animate to. This is also\n             * pluggable to support Framer's custom value types like Color,\n             * and CSS variables.\n             */\n            makeTargetAnimatable: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\n            },\n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            },\n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \n            /**\n             * If we're trying to animate to a previously unencountered value,\n             * we need to check for it in our state and as a last resort read it\n             * directly from the instance (which might have performance implications).\n             */\n            readValue: function (key) { var _a; return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options); }, \n            /**\n             * Set the base target to later animate back to. This is currently\n             * only hydrated on creation and when we first read a value.\n             */\n            setBaseTarget: function (key, value) {\n                baseTarget[key] = value;\n            },\n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            },\n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync.render(render, false, true);\n            }, \n            /**\n             * Synchronously fire render. It's prefered that we batch renders but\n             * in many circumstances, like layout measurement, we need to run this\n             * synchronously. However in those instances other measures should be taken\n             * to batch reads/writes.\n             */\n            syncRender: render, \n            /**\n             * Update the provided props. Ensure any newly-added motion values are\n             * added to our map, old ones removed, and listeners updated.\n             */\n            setProps: function (newProps) {\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            },\n            // Layout projection ==============================\n            /**\n             * Enable layout projection for this visual element. Won't actually\n             * occur until we also have hydrated layout measurements.\n             */\n            enableLayoutProjection: function () {\n                projection.isEnabled = true;\n                element.layoutTree.add(element);\n            },\n            /**\n             * Lock the projection target, for instance when dragging, so\n             * nothing else can try and animate it.\n             */\n            lockProjectionTarget: function () {\n                projection.isTargetLocked = true;\n            },\n            unlockProjectionTarget: function () {\n                element.stopLayoutAnimation();\n                projection.isTargetLocked = false;\n            }, getLayoutState: function () { return layoutState; }, setCrossfader: function (newCrossfader) {\n                crossfader = newCrossfader;\n            }, isProjectionReady: function () {\n                return projection.isEnabled &&\n                    projection.isHydrated &&\n                    layoutState.isHydrated;\n            }, \n            /**\n             * Start a layout animation on a given axis.\n             */\n            startLayoutAnimation: function (axis, transition, isRelative) {\n                if (isRelative === void 0) { isRelative = false; }\n                var progress = element.getProjectionAnimationProgress()[axis];\n                var _a = isRelative\n                    ? projection.relativeTarget[axis]\n                    : projection.target[axis], min = _a.min, max = _a.max;\n                var length = max - min;\n                progress.clearListeners();\n                progress.set(min);\n                progress.set(min); // Set twice to hard-reset velocity\n                progress.onChange(function (v) {\n                    element.setProjectionTargetAxis(axis, v, v + length, isRelative);\n                });\n                return element.animateMotionValue(axis, progress, 0, transition);\n            },\n            /**\n             * Stop layout animations.\n             */\n            stopLayoutAnimation: function () {\n                eachAxis(function (axis) {\n                    return element.getProjectionAnimationProgress()[axis].stop();\n                });\n            },\n            /**\n             * Measure the current viewport box with or without transforms.\n             * Only measures axis-aligned boxes, rotate and skew must be manually\n             * removed with a re-render to work.\n             */\n            measureViewportBox: function (withTransform) {\n                if (withTransform === void 0) { withTransform = true; }\n                var viewportBox = measureViewportBox(instance, options);\n                if (!withTransform)\n                    removeBoxTransforms(viewportBox, latestValues);\n                return viewportBox;\n            },\n            /**\n             * Get the motion values tracking the layout animations on each\n             * axis. Lazy init if not already created.\n             */\n            getProjectionAnimationProgress: function () {\n                projectionTargetProgress || (projectionTargetProgress = {\n                    x: motionValue(0),\n                    y: motionValue(0),\n                });\n                return projectionTargetProgress;\n            },\n            /**\n             * Update the projection of a single axis. Schedule an update to\n             * the tree layout projection.\n             */\n            setProjectionTargetAxis: function (axis, min, max, isRelative) {\n                if (isRelative === void 0) { isRelative = false; }\n                var target;\n                if (isRelative) {\n                    if (!projection.relativeTarget) {\n                        projection.relativeTarget = axisBox();\n                    }\n                    target = projection.relativeTarget[axis];\n                }\n                else {\n                    projection.relativeTarget = undefined;\n                    target = projection.target[axis];\n                }\n                projection.isHydrated = true;\n                target.min = min;\n                target.max = max;\n                // Flag that we want to fire the onViewportBoxUpdate event handler\n                hasViewportBoxUpdated = true;\n                lifecycles.notifySetAxisTarget();\n            },\n            /**\n             * Rebase the projection target on top of the provided viewport box\n             * or the measured layout. This ensures that non-animating elements\n             * don't fall out of sync differences in measurements vs projections\n             * after a page scroll or other relayout.\n             */\n            rebaseProjectionTarget: function (force, box) {\n                if (box === void 0) { box = layoutState.layout; }\n                var _a = element.getProjectionAnimationProgress(), x = _a.x, y = _a.y;\n                var shouldRebase = !projection.relativeTarget &&\n                    !projection.isTargetLocked &&\n                    !x.isAnimating() &&\n                    !y.isAnimating();\n                if (force || shouldRebase) {\n                    eachAxis(function (axis) {\n                        var _a = box[axis], min = _a.min, max = _a.max;\n                        element.setProjectionTargetAxis(axis, min, max);\n                    });\n                }\n            },\n            /**\n             * Notify the visual element that its layout is up-to-date.\n             * Currently Animate.tsx uses this to check whether a layout animation\n             * needs to be performed.\n             */\n            notifyLayoutReady: function (config) {\n                setCurrentViewportBox(element);\n                element.notifyLayoutUpdate(layoutState.layout, element.prevViewportBox || layoutState.layout, config);\n            }, \n            /**\n             * Temporarily reset the transform of the instance.\n             */\n            resetTransform: function () { return resetTransform(element, instance, props); }, restoreTransform: function () { return restoreTransform(instance, renderState); }, updateLayoutProjection: updateLayoutProjection,\n            updateTreeLayoutProjection: function () {\n                element.layoutTree.forEach(fireResolveRelativeTargetBox);\n                /**\n                 * Schedule the projection updates at the end of the current preRender\n                 * step. This will ensure that all layout trees will first resolve\n                 * relative projection boxes into viewport boxes, and *then*\n                 * update projections.\n                 */\n                sync.preRender(updateTreeLayoutProjection, false, true);\n                // sync.postRender(() => element.scheduleUpdateLayoutProjection())\n            },\n            getProjectionParent: function () {\n                if (projectionParent === undefined) {\n                    var foundParent = false;\n                    // Search backwards through the tree path\n                    for (var i = element.path.length - 1; i >= 0; i--) {\n                        var ancestor = element.path[i];\n                        if (ancestor.projection.isEnabled) {\n                            foundParent = ancestor;\n                            break;\n                        }\n                    }\n                    projectionParent = foundParent;\n                }\n                return projectionParent;\n            },\n            resolveRelativeTargetBox: function () {\n                var relativeParent = element.getProjectionParent();\n                if (!projection.relativeTarget || !relativeParent)\n                    return;\n                calcRelativeBox(projection, relativeParent.projection);\n                if (isDraggable(relativeParent)) {\n                    var target = projection.target;\n                    applyBoxTransforms(target, target, relativeParent.getLatestValues());\n                }\n            },\n            shouldResetTransform: function () {\n                return Boolean(props._layoutResetTransform);\n            },\n            /**\n             *\n             */\n            pointTo: function (newLead) {\n                leadProjection = newLead.projection;\n                leadLatestValues = newLead.getLatestValues();\n                /**\n                 * Subscribe to lead component's layout animations\n                 */\n                unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n                unsubscribeFromLeadVisualElement = pipe(newLead.onSetAxisTarget(element.scheduleUpdateLayoutProjection), newLead.onLayoutAnimationComplete(function () {\n                    var _a;\n                    if (element.isPresent) {\n                        element.presence = Presence.Present;\n                    }\n                    else {\n                        (_a = element.layoutSafeToRemove) === null || _a === void 0 ? void 0 : _a.call(element);\n                    }\n                }));\n            }, \n            // TODO: Clean this up\n            isPresent: true, presence: Presence.Entering });\n        return element;\n    };\n};\nfunction fireResolveRelativeTargetBox(child) {\n    child.resolveRelativeTargetBox();\n}\nfunction fireUpdateLayoutProjection(child) {\n    child.updateLayoutProjection();\n}\nvar variantProps = __spreadArray([\"initial\"], __read(variantPriorityOrder));\nvar numVariantProps = variantProps.length;\n\nexport { visualElement };\n","import { motionValue } from '../../value/index.js';\nimport { isMotionValue } from '../../value/utils/is-motion-value.js';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    var _a;\n    for (var key in next) {\n        var nextValue = next[key];\n        var prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                var existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { calcRelativeOffset } from '../../../motion/features/layout/utils.js';\nimport { eachAxis } from '../../../utils/each-axis.js';\n\nfunction setCurrentViewportBox(visualElement) {\n    var projectionParent = visualElement.getProjectionParent();\n    if (!projectionParent) {\n        visualElement.rebaseProjectionTarget();\n        return;\n    }\n    var relativeOffset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n    eachAxis(function (axis) {\n        visualElement.setProjectionTargetAxis(axis, relativeOffset[axis].min, relativeOffset[axis].max, true);\n    });\n}\n\nexport { setCurrentViewportBox };\n","import { resetBox, applyTreeDeltas } from '../../utils/geometry/delta-apply.js';\nimport { updateBoxDelta } from '../../utils/geometry/delta-calc.js';\n\nfunction updateLayoutDeltas(_a, _b, treePath, transformOrigin) {\n    var delta = _a.delta, layout = _a.layout, layoutCorrected = _a.layoutCorrected, treeScale = _a.treeScale;\n    var target = _b.target;\n    /**\n     * Reset the corrected box with the latest values from box, as we're then going\n     * to perform mutative operations on it.\n     */\n    resetBox(layoutCorrected, layout);\n    /**\n     * Apply all the parent deltas to this box to produce the corrected box. This\n     * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n     */\n    applyTreeDeltas(layoutCorrected, treeScale, treePath);\n    /**\n     * Update the delta between the corrected box and the target box before user-set transforms were applied.\n     * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n     * for our layout reprojection, but still allow them to be scaled correctly by the user.\n     * It might be that to simplify this we may want to accept that user-set scale is also corrected\n     * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n     * to allow people to choose whether these styles are corrected based on just the\n     * layout reprojection or the final bounding box.\n     */\n    updateBoxDelta(delta, layoutCorrected, target, transformOrigin);\n}\n\nexport { updateLayoutDeltas };\n","import { __assign, __read } from 'tslib';\nimport { number, px } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.js';\nimport { invariant } from 'hey-listen';\nimport { transformProps } from '../../html/utils/transform.js';\nimport { findDimensionValueType } from '../value-types/dimensions.js';\n\nvar positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nvar isPositionalKey = function (key) { return positionalKeys.has(key); };\nvar hasPositionalKey = function (target) {\n    return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nvar isNumOrPxType = function (v) {\n    return v === number || v === px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n    return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) { return function (_bbox, _a) {\n    var transform = _a.transform;\n    if (transform === \"none\" || !transform)\n        return 0;\n    var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        var matrix = transform.match(/^matrix\\((.+)\\)$/);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n}; };\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a) {\n        var x = _a.x;\n        return x.max - x.min;\n    },\n    height: function (_a) {\n        var y = _a.y;\n        return y.max - y.min;\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display, top = elementComputedStyle.top, left = elementComputedStyle.left, bottom = elementComputedStyle.bottom, right = elementComputedStyle.right, transform = elementComputedStyle.transform;\n    var originComputedStyle = { top: top, left: left, bottom: bottom, right: right, transform: transform };\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\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 = visualElement.getValue(key);\n        setAndResetVelocity(value, positionalValues[key](originBbox, originComputedStyle));\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = __assign({}, target);\n    transitionEnd = __assign({}, transitionEnd);\n    var targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    var removedTransformValues = [];\n    var hasAttemptedToRemoveTransformValues = false;\n    var changedValueTypeKeys = [];\n    targetPositionalKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        var from = origin[key];\n        var to = target[key];\n        var fromType = findDimensionValueType(from);\n        var toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            var numKeyframes = to.length;\n            for (var i = to[0] === null ? 1 : 0; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                var current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\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(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = __read(_a, 2), key = _b[0], value = _b[1];\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.syncRender();\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\n}\n\nexport { BoundingBoxDimension, unitConversion };\n","import { resolveCSSVariables } from './css-variables-conversion.js';\nimport { unitConversion } from './unit-conversion.js';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","import { __rest, __assign } from 'tslib';\nimport { visualElement } from '../index.js';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.js';\nimport { getBoundingBox } from '../dom/projection/measure.js';\nimport { buildHTMLStyles } from './utils/build-styles.js';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.js';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.js';\nimport { isTransformProp } from './utils/transform.js';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';\nimport { renderHTML } from './utils/render.js';\nimport { getDefaultValueType } from '../dom/value-types/defaults.js';\nimport { buildLayoutProjectionTransformOrigin, buildLayoutProjectionTransform } from './utils/build-projection-transform.js';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle(domElement);\n            return ((isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    },\n    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return getBoundingBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return __assign({ transition: transition,\n            transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (element, renderState, latestValues, projection, layoutState, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n        buildHTMLStyles(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform\n            ? buildLayoutProjectionTransformOrigin\n            : undefined);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nexport { getComputedStyle, htmlConfig, htmlVisualElement };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nvar isNumericalString = function (v) { return /^\\-?\\d*\\.?\\d+$/.test(v); };\n\nexport { isNumericalString };\n","import { __assign } from 'tslib';\nimport { visualElement } from '../index.js';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';\nimport { htmlConfig } from '../html/visual-element.js';\nimport { buildSVGAttrs } from './utils/build-attrs.js';\nimport { camelToDash } from '../dom/utils/camel-to-dash.js';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.js';\nimport { isTransformProp } from '../html/utils/transform.js';\nimport { renderSVG } from './utils/render.js';\nimport { getDefaultValueType } from '../dom/value-types/defaults.js';\nimport { buildLayoutProjectionTransformOrigin, buildLayoutProjectionTransform } from '../html/utils/build-projection-transform.js';\n\nvar svgVisualElement = visualElement(__assign(__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    },\n    readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (_element, renderState, latestValues, projection, layoutState, options, props) {\n        var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n        buildSVGAttrs(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform\n            ? buildLayoutProjectionTransformOrigin\n            : undefined);\n    }, render: renderSVG }));\n\nexport { svgVisualElement };\n","import { __assign } from 'tslib';\nimport { animations } from '../../motion/features/animations.js';\nimport { gestureAnimations } from '../../motion/features/gestures.js';\nimport { createDomVisualElement } from './create-visual-element.js';\n\n/**\n * @public\n */\nvar domAnimation = __assign(__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\nexport { domAnimation };\n","import { htmlVisualElement } from '../html/visual-element.js';\nimport { svgVisualElement } from '../svg/visual-element.js';\nimport { isSVGComponent } from './utils/is-svg-component.js';\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { __read, __rest } from 'tslib';\nimport * as React from 'react';\nimport { useState, useRef, useEffect } from 'react';\nimport { LazyContext } from '../../context/LazyContext.js';\nimport { loadFeatures } from '../../motion/features/definitions.js';\n\n/**\n * Used in conjunction with the `m` component to reduce bundle size.\n *\n * `m` is a version of the `motion` component that only loads functionality\n * critical for the initial render.\n *\n * `LazyMotion` can then be used to either synchronously or asynchronously\n * load animation and gesture support.\n *\n * ```jsx\n * // Synchronous loading\n * import { LazyMotion, m, domAnimations } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimations}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n *\n * // Asynchronous loading\n * import { LazyMotion, m } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={() => import('./path/to/domAnimations')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion(_a) {\n    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;\n    var _c = __read(useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];\n    var loadedRenderer = useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        var renderer = features.renderer, loadedFeatures = __rest(features, [\"renderer\"]);\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    useEffect(function () {\n        if (isLazyBundle(features)) {\n            features().then(function (_a) {\n                var renderer = _a.renderer, loadedFeatures = __rest(_a, [\"renderer\"]);\n                loadFeatures(loadedFeatures);\n                loadedRenderer.current = renderer;\n                setIsLoaded(true);\n            });\n        }\n    }, []);\n    return (React.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\nexport { LazyMotion };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(function () { return function () { return callback(); }; }, []);\n}\n\nexport { useUnmountEffect };\n","import { isString, singleColorRegex, floatRegex } from '../utils.js';\n\nvar isColorString = function (type, testProp) { return function (v) {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n}; };\nvar splitColor = function (aName, bName, cName) { return function (v) {\n    var _a;\n    if (!isString(v))\n        return v;\n    var _b = v.match(floatRegex), a = _b[0], b = _b[1], c = _b[2], alpha = _b[3];\n    return _a = {},\n        _a[aName] = parseFloat(a),\n        _a[bName] = parseFloat(b),\n        _a[cName] = parseFloat(c),\n        _a.alpha = alpha !== undefined ? parseFloat(alpha) : 1,\n        _a;\n}; };\n\nexport { isColorString, splitColor };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options) {\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler, options); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\nexport { addDomEvent, useDomEvent };\n","import { __assign } from 'tslib';\nimport { number, alpha } from '../numbers/index.js';\nimport { sanitize, clamp } from '../utils.js';\nimport { isColorString, splitColor } from './utils.js';\n\nvar clampRgbUnit = clamp(0, 255);\nvar rgbUnit = __assign(__assign({}, number), { transform: function (v) { return Math.round(clampRgbUnit(v)); } });\nvar rgba = {\n    test: isColorString('rgb', 'red'),\n    parse: splitColor('red', 'green', 'blue'),\n    transform: function (_a) {\n        var red = _a.red, green = _a.green, blue = _a.blue, _b = _a.alpha, alpha$1 = _b === void 0 ? 1 : _b;\n        return 'rgba(' +\n            rgbUnit.transform(red) +\n            ', ' +\n            rgbUnit.transform(green) +\n            ', ' +\n            rgbUnit.transform(blue) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')';\n    },\n};\n\nexport { rgbUnit, rgba };\n","import { mix, distance, clamp, progress } from 'popmotion';\n\nvar clampProgress = function (v) { return clamp(0, 1, v); };\n/**\n * Returns true if the provided value is within maxDistance of the provided target\n */\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return distance(value, target) < maxDistance;\n}\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clampProgress(origin);\n}\n/**\n * Update the AxisDelta with a transform that projects source into target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001))\n        delta.scale = 1;\n    delta.translate =\n        mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate))\n        delta.translate = 0;\n}\n/**\n * Update the BoxDelta with a transform that projects the source into the target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateBoxDelta(delta, source, target, origin) {\n    updateAxisDelta(delta.x, source.x, target.x, defaultOrigin(origin.originX));\n    updateAxisDelta(delta.y, source.y, target.y, defaultOrigin(origin.originY));\n}\n/**\n * Currently this only accepts numerical origins, measured as 0-1, but could\n * accept pixel values by comparing to the target axis.\n */\nfunction defaultOrigin(origin) {\n    return typeof origin === \"number\" ? origin : 0.5;\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(projection, parentProjection) {\n    calcRelativeAxis(projection.target.x, projection.relativeTarget.x, parentProjection.target.x);\n    calcRelativeAxis(projection.target.y, projection.relativeTarget.y, parentProjection.target.y);\n}\n\nexport { calcOrigin, calcRelativeAxis, calcRelativeBox, isNear, updateAxisDelta, updateBoxDelta };\n","import { isTouchEvent } from '../gestures/utils/event-type.js';\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return function (event) {\n        var isMouseEvent = event instanceof MouseEvent;\n        var isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nvar defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    var primaryTouch = e.touches[0] || e.changedTouches[0];\n    var point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nfunction getViewportPointFromEvent(event) {\n    return extractEventInfo(event, \"client\");\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }\n    var listener = function (event) {\n        return handler(event, extractEventInfo(event));\n    };\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\nexport { extractEventInfo, getViewportPointFromEvent, wrapHandler };\n","function isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    var hasTouches = !!event.touches;\n    return hasTouches;\n}\n\nexport { isMouseEvent, isTouchEvent };\n","import { alpha } from '../numbers/index.js';\nimport { percent } from '../numbers/units.js';\nimport { sanitize } from '../utils.js';\nimport { isColorString, splitColor } from './utils.js';\n\nvar hsla = {\n    test: isColorString('hsl', 'hue'),\n    parse: splitColor('hue', 'saturation', 'lightness'),\n    transform: function (_a) {\n        var hue = _a.hue, saturation = _a.saturation, lightness = _a.lightness, _b = _a.alpha, alpha$1 = _b === void 0 ? 1 : _b;\n        return ('hsla(' +\n            Math.round(hue) +\n            ', ' +\n            percent.transform(sanitize(saturation)) +\n            ', ' +\n            percent.transform(sanitize(lightness)) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')');\n    },\n};\n\nexport { hsla };\n","import { __assign } from 'tslib';\nimport { color, filter } from 'style-value-types';\nimport { numberValueTypes } from './number.js';\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = __assign(__assign({}, numberValueTypes), { \n    // Color props\n    color: color, backgroundColor: color, outlineColor: color, fill: color, stroke: color, \n    // Border props\n    borderColor: color, borderTopColor: color, borderRightColor: color, borderBottomColor: color, borderLeftColor: color, filter: filter, WebkitFilter: filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nexport { defaultValueTypes, getDefaultValueType };\n","function createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","import { addUniqueItem, removeItem } from './array.js';\n\nvar SubscriptionManager = /** @class */ (function () {\n    function SubscriptionManager() {\n        this.subscriptions = [];\n    }\n    SubscriptionManager.prototype.add = function (handler) {\n        var _this = this;\n        addUniqueItem(this.subscriptions, handler);\n        return function () { return removeItem(_this.subscriptions, handler); };\n    };\n    SubscriptionManager.prototype.notify = function (a, b, c) {\n        var numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (var i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                var handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    };\n    SubscriptionManager.prototype.getSize = function () {\n        return this.subscriptions.length;\n    };\n    SubscriptionManager.prototype.clear = function () {\n        this.subscriptions.length = 0;\n    };\n    return SubscriptionManager;\n}());\n\nexport { SubscriptionManager };\n","function addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n\nexport { addUniqueItem, removeItem };\n","var clamp = function (min, max, v) {\n    return Math.min(Math.max(v, min), max);\n};\n\nexport { clamp };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nvar secondsToMilliseconds = function (seconds) { return seconds * 1000; };\n\nexport { secondsToMilliseconds };\n","var zeroPoint = {\n    x: 0,\n    y: 0,\n    z: 0\n};\nvar isNum = function (v) { return typeof v === 'number'; };\n\nexport { isNum, zeroPoint };\n","var combineFunctions = function (a, b) { return function (v) { return b(a(v)); }; };\nvar pipe = function () {\n    var transformers = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        transformers[_i] = arguments[_i];\n    }\n    return transformers.reduce(combineFunctions);\n};\n\nexport { pipe };\n","import { filter, complex } from 'style-value-types';\nimport { getDefaultValueType } from './defaults.js';\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nexport { getAnimatableNone };\n","var progress = function (from, to, value) {\n    var toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","function isDraggable(visualElement) {\n    var _a = visualElement.getProps(), drag = _a.drag, _dragX = _a._dragX;\n    return drag && !_dragX;\n}\n\nexport { isDraggable };\n","import { __assign } from 'tslib';\nimport { mix } from './mix.js';\nimport { hex, rgba, hsla } from 'style-value-types';\nimport { invariant } from 'hey-listen';\n\nvar mixLinearColor = function (from, to, v) {\n    var fromExpo = from * from;\n    var toExpo = to * to;\n    return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\nvar colorTypes = [hex, rgba, hsla];\nvar getColorType = function (v) {\n    return colorTypes.find(function (type) { return type.test(v); });\n};\nvar notAnimatable = function (color) {\n    return \"'\" + color + \"' is not an animatable color. Use the equivalent color code instead.\";\n};\nvar mixColor = function (from, to) {\n    var fromColorType = getColorType(from);\n    var toColorType = getColorType(to);\n    invariant(!!fromColorType, notAnimatable(from));\n    invariant(!!toColorType, notAnimatable(to));\n    invariant(fromColorType.transform === toColorType.transform, \"Both colors must be hex/RGBA, OR both must be HSLA.\");\n    var fromColor = fromColorType.parse(from);\n    var toColor = toColorType.parse(to);\n    var blended = __assign({}, fromColor);\n    var mixFunc = fromColorType === hsla ? mix : mixLinearColor;\n    return function (v) {\n        for (var key in blended) {\n            if (key !== \"alpha\") {\n                blended[key] = mixFunc(fromColor[key], toColor[key], v);\n            }\n        }\n        blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n        return fromColorType.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","import { convertBoundingBoxToAxisBox, transformBoundingBox } from '../../../utils/geometry/index.js';\n\n/**\n * Measure and return the element bounding box.\n *\n * We convert the box into an AxisBox2D to make it easier to work with each axis\n * individually and programmatically.\n *\n * This function optionally accepts a transformPagePoint function which allows us to compensate\n * for, for instance, measuring the element within a scaled plane like a Framer devivce preview component.\n */\nfunction getBoundingBox(element, transformPagePoint) {\n    var box = element.getBoundingClientRect();\n    return convertBoundingBoxToAxisBox(transformBoundingBox(box, transformPagePoint));\n}\n\nexport { getBoundingBox };\n","import { __rest, __assign, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    var match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    var _a = __read(match, 3), token = _a[1], fallback = _a[2];\n    return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n    if (depth === void 0) { depth = 1; }\n    invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\" + current + \"\\\". This may indicate a circular fallback dependency.\");\n    var _a = __read(parseCSSVariable(current), 2), token = _a[0], fallback = _a[1];\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    var resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\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    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n    var _b;\n    var target = __rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof HTMLElement))\n        return { target: target, 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    if (transitionEnd) {\n        transitionEnd = __assign({}, transitionEnd);\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.forEachValue(function (value) {\n        var current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        var resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (var key in target) {\n        var current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        var resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd)\n            (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : (transitionEnd[key] = current);\n    }\n    return { target: target, transitionEnd: transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","var reverseEasing = function (easing) { return function (p) { return 1 - easing(1 - p); }; };\nvar mirrorEasing = function (easing) { return function (p) {\n    return p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n}; };\nvar createExpoIn = function (power) { return function (p) { return Math.pow(p, power); }; };\nvar createBackIn = function (power) { return function (p) {\n    return p * p * ((power + 1) * p - power);\n}; };\nvar createAnticipate = function (power) {\n    var backEasing = createBackIn(power);\n    return function (p) {\n        return (p *= 2) < 1\n            ? 0.5 * backEasing(p)\n            : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n    };\n};\n\nexport { createAnticipate, createBackIn, createExpoIn, mirrorEasing, reverseEasing };\n","import { createExpoIn, reverseEasing, mirrorEasing, createBackIn, createAnticipate } from './utils.js';\n\nvar DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nvar BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nvar BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nvar BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nvar linear = function (p) { return p; };\nvar easeIn = createExpoIn(2);\nvar easeOut = reverseEasing(easeIn);\nvar easeInOut = mirrorEasing(easeIn);\nvar circIn = function (p) { return 1 - Math.sin(Math.acos(p)); };\nvar circOut = reverseEasing(circIn);\nvar circInOut = mirrorEasing(circOut);\nvar backIn = createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nvar backOut = reverseEasing(backIn);\nvar backInOut = mirrorEasing(backIn);\nvar anticipate = createAnticipate(DEFAULT_OVERSHOOT_STRENGTH);\nvar ca = 4356.0 / 361.0;\nvar cb = 35442.0 / 1805.0;\nvar cc = 16061.0 / 1805.0;\nvar bounceOut = function (p) {\n    if (p === 1 || p === 0)\n        return p;\n    var p2 = p * p;\n    return p < BOUNCE_FIRST_THRESHOLD\n        ? 7.5625 * p2\n        : p < BOUNCE_SECOND_THRESHOLD\n            ? 9.075 * p2 - 9.9 * p + 3.4\n            : p < BOUNCE_THIRD_THRESHOLD\n                ? ca * p2 - cb * p + cc\n                : 10.8 * p * p - 20.52 * p + 10.72;\n};\nvar bounceIn = reverseEasing(bounceOut);\nvar bounceInOut = function (p) {\n    return p < 0.5\n        ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0))\n        : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n};\n\nexport { anticipate, backIn, backInOut, backOut, bounceIn, bounceInOut, bounceOut, circIn, circInOut, circOut, easeIn, easeInOut, easeOut, linear };\n","import { rgba } from './rgba.js';\nimport { isColorString } from './utils.js';\n\nfunction parseHex(v) {\n    var r = '';\n    var g = '';\n    var b = '';\n    var a = '';\n    if (v.length > 5) {\n        r = v.substr(1, 2);\n        g = v.substr(3, 2);\n        b = v.substr(5, 2);\n        a = v.substr(7, 2);\n    }\n    else {\n        r = v.substr(1, 1);\n        g = v.substr(2, 1);\n        b = v.substr(3, 1);\n        a = v.substr(4, 1);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nvar hex = {\n    test: isColorString('#'),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","function velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","import { color } from '../color/index.js';\nimport { number } from '../numbers/index.js';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.js';\n\nvar colorToken = '${c}';\nvar numberToken = '${n}';\nfunction test(v) {\n    var _a, _b, _c, _d;\n    return (isNaN(v) &&\n        isString(v) &&\n        ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0);\n}\nfunction analyse(v) {\n    var values = [];\n    var numColors = 0;\n    var colors = v.match(colorRegex);\n    if (colors) {\n        numColors = colors.length;\n        v = v.replace(colorRegex, colorToken);\n        values.push.apply(values, colors.map(color.parse));\n    }\n    var numbers = v.match(floatRegex);\n    if (numbers) {\n        v = v.replace(floatRegex, numberToken);\n        values.push.apply(values, numbers.map(number.parse));\n    }\n    return { values: values, numColors: numColors, tokenised: v };\n}\nfunction parse(v) {\n    return analyse(v).values;\n}\nfunction createTransformer(v) {\n    var _a = analyse(v), values = _a.values, numColors = _a.numColors, tokenised = _a.tokenised;\n    var numValues = values.length;\n    return function (v) {\n        var output = tokenised;\n        for (var i = 0; i < numValues; i++) {\n            output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n        }\n        return output;\n    };\n}\nvar convertNumbersToZero = function (v) {\n    return typeof v === 'number' ? 0 : v;\n};\nfunction getAnimatableNone(v) {\n    var parsed = parse(v);\n    var transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nvar complex = { test: test, parse: parse, createTransformer: createTransformer, getAnimatableNone: getAnimatableNone };\n\nexport { complex };\n","import { __assign } from 'tslib';\nimport { complex } from './index.js';\nimport { floatRegex } from '../utils.js';\n\nvar maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n    var _a = v.slice(0, -1).split('('), name = _a[0], value = _a[1];\n    if (name === 'drop-shadow')\n        return v;\n    var number = (value.match(floatRegex) || [])[0];\n    if (!number)\n        return v;\n    var unit = value.replace(number, '');\n    var defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + '(' + defaultValue + unit + ')';\n}\nvar functionRegex = /([a-z-]*)\\(.*?\\)/g;\nvar filter = __assign(__assign({}, complex), { getAnimatableNone: function (v) {\n        var functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n    } });\n\nexport { filter };\n","var isPoint = function (point) {\n    return point.hasOwnProperty('x') && point.hasOwnProperty('y');\n};\n\nexport { isPoint };\n","import { isPoint } from './is-point.js';\n\nvar isPoint3D = function (point) {\n    return isPoint(point) && point.hasOwnProperty('z');\n};\n\nexport { isPoint3D };\n","import { isPoint } from './is-point.js';\nimport { isPoint3D } from './is-point-3d.js';\nimport { isNum } from './inc.js';\n\nvar distance1D = function (a, b) { return Math.abs(a - b); };\nfunction distance(a, b) {\n    if (isNum(a) && isNum(b)) {\n        return distance1D(a, b);\n    }\n    else if (isPoint(a) && isPoint(b)) {\n        var xDelta = distance1D(a.x, b.x);\n        var yDelta = distance1D(a.y, b.y);\n        var zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n    }\n}\n\nexport { distance };\n","var defaultTimestep = (1 / 60) * 1000;\nvar getCurrentTime = typeof performance !== \"undefined\"\n    ? function () { return performance.now(); }\n    : function () { return Date.now(); };\nvar onNextFrame = typeof window !== \"undefined\"\n    ? function (callback) {\n        return window.requestAnimationFrame(callback);\n    }\n    : function (callback) {\n        return setTimeout(function () { return callback(getCurrentTime()); }, defaultTimestep);\n    };\n\nexport { defaultTimestep, onNextFrame };\n","import { onNextFrame, defaultTimestep } from './on-next-frame.js';\nimport { createRenderStep } from './create-render-step.js';\n\nvar maxElapsed = 40;\nvar useDefaultElapsed = true;\nvar runNextFrame = false;\nvar isProcessing = false;\nvar frame = {\n    delta: 0,\n    timestamp: 0\n};\nvar stepsOrder = [\"read\", \"update\", \"preRender\", \"render\", \"postRender\"];\nvar steps = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    acc[key] = createRenderStep(function () {\n        return runNextFrame = true;\n    });\n    return acc;\n}, {});\nvar sync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    var step = steps[key];\n    acc[key] = function (process, keepAlive, immediate) {\n        if (keepAlive === void 0) {\n            keepAlive = false;\n        }\n        if (immediate === void 0) {\n            immediate = false;\n        }\n        if (!runNextFrame) startLoop();\n        return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n}, {});\nvar cancelSync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    acc[key] = steps[key].cancel;\n    return acc;\n}, {});\nvar flushSync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n    acc[key] = function () {\n        return steps[key].process(frame);\n    };\n    return acc;\n}, {});\nvar processStep = function (stepId) {\n    return steps[stepId].process(frame);\n};\nvar processFrame = function (timestamp) {\n    runNextFrame = false;\n    frame.delta = useDefaultElapsed ? defaultTimestep : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n    frame.timestamp = timestamp;\n    isProcessing = true;\n    stepsOrder.forEach(processStep);\n    isProcessing = false;\n    if (runNextFrame) {\n        useDefaultElapsed = false;\n        onNextFrame(processFrame);\n    }\n};\nvar startLoop = function () {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!isProcessing) onNextFrame(processFrame);\n};\nvar getFrameData = function () {\n    return frame;\n};\n\nexport default sync;\nexport { cancelSync, flushSync, getFrameData };\n","function createRenderStep(runNextFrame) {\n    var toRun = [];\n    var toRunNextFrame = [];\n    var numToRun = 0;\n    var isProcessing = false;\n    var toKeepAlive = new WeakSet();\n    var step = {\n        schedule: function (callback, keepAlive, immediate) {\n            if (keepAlive === void 0) { keepAlive = false; }\n            if (immediate === void 0) { immediate = false; }\n            var addToCurrentFrame = immediate && isProcessing;\n            var buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        cancel: function (callback) {\n            var index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        process: function (frameData) {\n            var _a;\n            isProcessing = true;\n            _a = [toRunNextFrame, toRun], toRun = _a[0], toRunNextFrame = _a[1];\n            toRunNextFrame.length = 0;\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (var i = 0; i < numToRun; i++) {\n                    var callback = toRun[i];\n                    callback(frameData);\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                }\n            }\n            isProcessing = false;\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","var AnimationType;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nexport { AnimationType };\n","function noop(any) {\n    return any;\n}\n\nexport { noop };\n","import { __assign } from 'tslib';\nimport { noop } from '../noop.js';\n\n/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToAxisBox(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertAxisBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return {\n        top: y.min,\n        bottom: y.max,\n        left: x.min,\n        right: x.max,\n    };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoundingBox(_a, transformPoint) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    if (transformPoint === void 0) { transformPoint = noop; }\n    var topLeft = transformPoint({ x: left, y: top });\n    var bottomRight = transformPoint({ x: right, y: bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n/**\n * Create an empty axis box of zero size\n */\nfunction axisBox() {\n    return { x: { min: 0, max: 1 }, y: { min: 0, max: 1 } };\n}\nfunction copyAxisBox(box) {\n    return {\n        x: __assign({}, box.x),\n        y: __assign({}, box.y),\n    };\n}\n/**\n * Create an empty box delta\n */\nvar zeroDelta = {\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n};\nfunction delta() {\n    return {\n        x: __assign({}, zeroDelta),\n        y: __assign({}, zeroDelta),\n    };\n}\n\nexport { axisBox, convertAxisBoxToBoundingBox, convertBoundingBoxToAxisBox, copyAxisBox, delta, transformBoundingBox };\n","/**\n * @public\n */\nvar Presence;\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/**\n * @public\n */\nvar VisibilityAction;\n(function (VisibilityAction) {\n    VisibilityAction[VisibilityAction[\"Hide\"] = 0] = \"Hide\";\n    VisibilityAction[VisibilityAction[\"Show\"] = 1] = \"Show\";\n})(VisibilityAction || (VisibilityAction = {}));\n\nexport { Presence, VisibilityAction };\n"],"sourceRoot":""}