{"version":3,"sources":["webpack:///./node_modules/popmotion/dist/es/utils/mix.js","webpack:///./node_modules/style-value-types/dist/es/color/index.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/layout/utils.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/utils/make-renderless-component.js","webpack:///./node_modules/framer-motion/dist/es/utils/geometry/delta-apply.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/framer-motion/dist/es/components/AnimateSharedLayout/types.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/utils/is-numerical-string.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/rgba.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/utils/compare-by-depth.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-unmount-effect.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/popmotion/dist/es/utils/clamp.js","webpack:///./node_modules/framer-motion/dist/es/utils/time-conversion.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/animation.js","webpack:///./node_modules/popmotion/dist/es/utils/inc.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/style-value-types/dist/es/color/hsla.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/is-draggable.js","webpack:///./node_modules/popmotion/dist/es/utils/pipe.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/test.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/utils/mix-color.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/easing/utils.js","webpack:///./node_modules/popmotion/dist/es/easing/index.js","webpack:///./node_modules/style-value-types/dist/es/complex/index.js","webpack:///./node_modules/style-value-types/dist/es/color/hex.js","webpack:///./node_modules/framer-motion/dist/es/utils/shallow-compare.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/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/popmotion/dist/es/animations/utils/find-spring.js","webpack:///./node_modules/popmotion/dist/es/animations/generators/spring.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/style-value-types/dist/es/complex/filter.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/types.js","webpack:///./node_modules/framer-motion/dist/es/components/LazyMotion/index.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/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/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"],"names":["mix","from","to","progress","color","test","v","parse","transform","hasOwnProperty","tweenAxis","target","prev","next","p","min","max","calcRelativeOffsetAxis","parent","child","calcRelativeOffset","x","y","checkIfParentHasChanged","prevId","getLayoutId","nextId","undefined","a","a1","a2","b","c","calcBezier","t","getSlope","cubicBezier","mX1","mY1","mX2","mY2","sampleValues","Float32Array","i","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","Math","abs","binarySubdivide","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","definition","Array","isArray","length","_a","isAnimatable","key","value","complex","startsWith","underDampedSpring","type","stiffness","damping","restDelta","restSpeed","criticallyDampedSpring","sqrt","linearTween","ease","duration","keyframes","values","defaultTransitions","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","default","legacyRepeatWarning","convertTransitionToAnimationOptions","times","yoyo","flip","loop","transition","options","repeatDelay","isEasingArray","map","repeatType","repeat","getPopmotionAnimationOptions","valueKey","transitionFactory","hydrateKeyframes","when","delay","delayChildren","staggerChildren","staggerDirection","Object","keys","isTransitionDefined","getAnimation","onComplete","valueTransition","getValueTransition","origin","get","isTargetAnimatable","isZero","getZeroUnit","isOriginAnimatable","velocity","getVelocity","onUpdate","set","currentAnimation","_b","_c","_d","power","_e","timeConstant","_f","bounceStiffness","_g","bounceDamping","_h","modifyTarget","driver","isOutOfBounds","boundaryNearest","startAnimation","stop","call","startSpring","prev_1","current_1","boundary_1","heading_1","delta","inertia","parseFloat","indexOf","potentialUnitType","start","delayTimer","controls","animation","getDelayFromTransition","setTimeout","clearTimeout","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","isColorString","testProp","Boolean","prototype","splitColor","aName","bName","cName","match","alpha","addDomEvent","eventName","handler","addEventListener","removeEventListener","useDomEvent","ref","element","current","Presence","VisibilityAction","valueTypes","findValueType","find","setMotionValue","visualElement","hasValue","getValue","addValue","setTarget","resolved","makeTargetAnimatable","transitionEnd","setVariants","variantLabels","reverse","forEach","variant","getVariant","variantChildren","setValues","checkTargetForNewValues","newValueKeys","filter","numNewValues","targetValue","readValue","setBaseTarget","getOriginFromTransition","getOrigin","isNear","maxDistance","calcLength","calcOrigin","source","sourceLength","targetLength","updateAxisDelta","updateBoxDelta","defaultOrigin","originX","originY","calcRelativeAxis","relative","calcRelativeBox","projection","parentProjection","relativeTarget","defaultPagePoint","pageX","pageY","pointFromTouch","e","pointType","touches","changedTouches","pointFromMouse","extractEventInfo","event","getViewportPointFromEvent","wrapHandler","shouldFilterPrimaryPointer","eventHandler","listener","isMouseEvent","MouseEvent","button","PointerEvent","pointerType","isTouchEvent","clampRgbUnit","rgbUnit","round","rgba","red","green","blue","alpha$1","dimensionValueTypes","findDimensionValueType","compareByDepth","depth","useUnmountEffect","callback","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","createLock","name","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","clamp","secondsToMilliseconds","seconds","animateVisualElement","notifyAnimationStart","animations","animateVariant","Promise","all","resolvedDefinition","custom","animateTarget","then","notifyAnimationComplete","getDefaultTransition","transitionOverride","resolve","getChildAnimations","size","forwardDelay","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","push","animateChildren","first","last","animationTypeState","animationState","getState","valueTarget","shouldBlockAnimation","stopAnimation","forEachValue","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","isNum","getAnimatableNone","defaultValueType","toFromDifference","hsla","hue","saturation","lightness","isDraggable","getProps","_dragX","combineFunctions","pipe","transformers","_i","arguments","reduce","testValueType","getBoundingBox","transformPagePoint","getBoundingClientRect","isCSSVariable","cssVariableRegex","getVariableValue","exec","parseCSSVariable","token","fallback","window","getComputedStyle","getPropertyValue","trim","resolveCSSVariables","getInstance","HTMLElement","mixLinearColor","fromExpo","toExpo","colorTypes","hex","getColorType","notAnimatable","mixColor","fromColorType","toColorType","fromColor","toColor","blended","mixFunc","getMixer","mixComplex","mixArray","output","numValues","blendValue","fromThis","mixObject","analyse","parsed","numNumbers","numRGB","numHSL","template","createTransformer","originStats","targetStats","mixNumber","createMixers","customMixer","mixers","mixerFactory","numMixers","mixer","easingFunction","interpolate","input","isClamp","inputLength","concat","interpolator","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","slowInterpolate","reverseEasing","easing","mirrorEasing","createBackIn","pow","sin","acos","backEasing","createAnticipate","p2","numColors","colors","replace","apply","numbers","tokenised","convertNumbersToZero","isNaN","transformer","r","g","substr","parseInt","shallowCompare","prevLength","variantPriorityOrder","Animate","Hover","Tap","Drag","Focus","Exit","reversePriorityOrder","numAnimationTypes","createAnimationState","animate","animateList","state","createTypeState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","context","getVariantContext","removedKeys","Set","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","prop","propIsVariant","activeDelta","isActive","isInherited","manuallyAnimateOnMount","prevProp","shouldAnimateType","variantsHaveChanged","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","delete","add","has","blockInitialAnimation","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","initial","isAnimated","setActive","setAnimateFunction","makeAnimator","subscribe","exit","isPresent","onExitComplete","presenceContext","PresenceContext","createHoverEvent","info","isNodeOrChild","parentElement","gestureAnimations","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","removePointerEndListener","checkPointerEnd","onPointerUp","onPointerCancel","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","createLayoutState","isHydrated","layout","layoutCorrected","deltaFinal","deltaTransform","zeroLayout","buildLayoutProjectionTransform","latestTransform","identityProjection","buildLayoutProjectionTransformOrigin","names","FlatTree","this","children","isDirty","remove","treeType","build","measureViewportBox","renderInstance","render","readValueFromInstance","resetTransform","restoreTransform","removeValueFromRenderState","scrapeMotionValuesFromProps","presenceId","visualState","instance","projectionParent","unsubscribeFromLeadVisualElement","crossfader","projectionTargetProgress","removeFromVariantTree","latestValues","renderState","lifecycles","managers","propSubscriptions","clearAllListeners","manager","clear","updatePropListeners","on","propListener","args","notify","createLifecycles","isEnabled","isTargetLocked","targetFinal","leadProjection","leadLatestValues","layoutState","hasViewportBoxUpdated","Map","valueSubscriptions","prevMotionValues","baseTarget","isProjectionReady","triggerBuild","valuesToRender","crossfadedValues","getCrossfadeState","update","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","onChange","latestValue","removeOnRenderRequest","onRenderRequest","bindToMotionValue","defaultValue","syncRender","setProps","newProps","nextValue","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","variants","startAtParent","context_1","numVariantProps","name_1","variantProps","enableLayoutProjection","lockProjectionTarget","unlockProjectionTarget","setCrossfader","newCrossfader","startLayoutAnimation","isRelative","getProjectionAnimationProgress","clearListeners","setProjectionTargetAxis","animateMotionValue","withTransform","viewportBox","notifySetAxisTarget","rebaseProjectionTarget","force","shouldRebase","isAnimating","notifyLayoutReady","config","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","transformKeys","nonTranslationalTransformKeys","positionalValues","width","height","top","left","bottom","right","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","removedTransforms","removeNonTranslationalTransform","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","originComputedStyle","targetBbox","convertChangedValueTypes","unitConversion","some","hasPositionalKey","htmlConfig","domElement","defaultType","computedStyle","compareDocumentPosition","style","transformTemplate","mutableState","vars","transformValues","parseDomVariant","isProjectionTranform","htmlVisualElement","svgVisualElement","getAttribute","_element","domAnimation","renderer","Component","enableHardwareAcceleration","findSpring","envelope","derivative","bounce","mass","maxDuration","dampingRatio","undampedFreq","exponentialDecay","calcAngularFreq","exp","d","f","initialGuess","result","approximateRoot","durationKeys","physicsKeys","isSpringType","spring","done","springOptions","isResolvedFromDuration","derived","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","angularFreq_1","cos","dampedAngularFreq_1","freqForT","sinh","cosh","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","_t","defaultEasing","splice","offset","o","convertOffsetToTimes","_value","defaultOffset","createInterpolator","types","decay","amplitude","ideal","loopElapsed","elapsed","framesync","passTimestamp","driverControls","latest","interpolateFromNumber","autoplay","repeatMax","_j","onPlay","onStop","onRepeat","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","detectAnimationFromOptions","reverseElapsed","hasRepeatDelayElapsed","maxDefaults","applyDefaultFilter","slice","number","unit","functionRegex","functions","join","AnimationType","LazyMotion","features","strict","setIsLoaded","isLazyBundle","loadedRenderer","loadedFeatures","Provider","noop","any","convertBoundingBoxToAxisBox","convertAxisBoxToBoundingBox","transformBoundingBox","transformPoint","topLeft","bottomRight","axisBox","copyAxisBox","zeroDelta","isPoint","isPoint3D","distance1D","distance","xDelta","yDelta","zDelta","eachAxis","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","onpointerdown","ontouchstart","onmousedown","addPointerEvent","usePointerEvent"],"mappings":"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","file":"4-60f40ea462305846b518.js","sourcesContent":["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 { 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","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","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","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","/**\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","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","/**\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 { 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 { __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 { 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","var compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nexport { compareByDepth };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(function () { return function () { return callback(); }; }, []);\n}\n\nexport { useUnmountEffect };\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","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","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","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","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","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","function isDraggable(visualElement) {\n    var _a = visualElement.getProps(), drag = _a.drag, _dragX = _a._dragX;\n    return drag && !_dragX;\n}\n\nexport { isDraggable };\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","/**\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 { 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","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 { __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","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 { 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 { 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 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","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","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 { 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 { 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 { __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 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","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","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","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","// 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"],"sourceRoot":""}