{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/projection/node/state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack:///./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","webpack:///./node_modules/core-js/modules/es.array.includes.js","webpack:///./node_modules/framer-motion/dist/es/utils/process.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs","webpack:///./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack:///./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/animation.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/use-id.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack:///./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/types.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/warn-once.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","webpack:///./node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/lifecycles.mjs","webpack:///./node_modules/framer-motion/dist/es/render/index.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/visual-element.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/visual-element.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/use-reduced-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/components/LazyMotion/index.mjs","webpack:///./node_modules/core-js/internals/add-to-unscopables.js","webpack:///./node_modules/core-js/internals/object-create.js","webpack:///./node_modules/core-js/internals/object-define-properties.js","webpack:///./node_modules/core-js/internals/object-keys.js","webpack:///./node_modules/core-js/internals/html.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/variants.mjs","webpack:///./node_modules/@emotion/is-prop-valid/dist/is-prop-valid.browser.cjs.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/use-features.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/node/id.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/VisualElementHandler.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/index.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/use-projection.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/use-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/use-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/use-render.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/config-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion-minimal.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion-proxy.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack:///./node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","webpack:///./node_modules/framer-motion/dist/es/events/utils.mjs","webpack:///./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack:///./node_modules/framer-motion/dist/es/events/use-dom-event.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack:///./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/definitions.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/is-ref-object.mjs"],"names":["globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","dimensionValueTypes","number","px","percent","degrees","vw","vh","test","v","parse","findDimensionValueType","find","testValueType","isZeroValueString","valueTypes","__spreadArray","__read","color","complex","findValueType","setMotionValue","visualElement","key","value","hasValue","getValue","set","addValue","motionValue","setTarget","definition","resolved","resolveVariant","_a","makeTargetAnimatable","_b","transitionEnd","transition","target","__rest","__assign","resolveFinalValueInKeyframes","setVariants","variantLabels","reverse","forEach","variant","getVariant","variantChildren","child","setValues","Array","isArray","checkTargetForNewValues","origin","_c","_d","newValueKeys","Object","keys","filter","numNewValues","length","i","targetValue","readValue","parseFloat","getAnimatableNone","setBaseTarget","getOriginFromTransition","from","getOrigin","get","useIsomorphicLayoutEffect","isBrowser","useLayoutEffect","useEffect","scaleCorrectors","addScaleCorrector","correctors","assign","defaultPagePoint","pageX","pageY","pointFromTouch","e","pointType","point","touches","changedTouches","x","y","pointFromMouse","extractEventInfo","event","isTouchEvent","wrapHandler","handler","shouldFilterPrimaryPointer","eventHandler","listener","isMouseEvent","MouseEvent","button","PointerEvent","pointerType","$","$includes","includes","fails","addToUnscopables","proto","forced","el","this","arguments","undefined","env","process","useUnmountEffect","callback","LazyContext","createContext","strict","isAnimationControls","start","scrapeMotionValuesFromProps","props","style","newValues","isMotionValue","isForcedMotionValue","createLock","name","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","translateAlias","z","transformPerspective","getValueAsType","type","transform","buildHTMLStyles","state","latestValues","options","transformTemplate","vars","transformKeys","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","isCSSVariable","valueType","numberValueTypes","valueAsType","isTransformProp","push","default","isTransformOriginProp","transformIsDefault","enableHardwareAcceleration","allowTransformNone","transformString","sort","sortTransformProps","transformHasZ","numTransformKeys","concat","trim","buildTransform","originX","originY","originZ","buildTransformOrigin","calcOrigin","offset","size","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","latest","attrs","dimensions","pxOriginX","width","pxOriginY","height","calcSVGTransformOrigin","spacing","useDashCase","buildSVGPath","lowercaseSVGElements","isSVGComponent","Component","indexOf","convertBoundingBoxToBox","top","min","left","max","right","bottom","convertBoxToBoundingBox","transformBoxPoints","transformPoint","topLeft","bottomRight","resolveMotionValue","unwrappedValue","isCustomValue","toValue","animateVisualElement","animation","notifyAnimationStart","animations","map","animateVariant","Promise","all","resolvedDefinition","custom","animateTarget","then","notifyAnimationComplete","getDefaultTransition","transitionOverride","getAnimation","resolve","getChildAnimations","forwardDelay","delayChildren","staggerChildren","staggerDirection","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","delay","animateChildren","when","first","last","_e","_f","animationTypeState","animationState","getState","valueTarget","shouldBlockAnimation","valueTransition","shouldReduceMotion","startAnimation","stopAnimation","forEachValue","stop","a","b","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","hasOwnProperty","validMotionProps","Set","isValidMotionProp","has","shouldForward","loadExternalIsValidProp","isValidProp","startsWith","require","filterProps","isDom","forwardMotionProps","filteredProps","counter","incrementId","useId","useConstant","measureViewportBox","instance","getBoundingClientRect","measurePageBox","element","rootProjectionNode","transformPagePoint","viewportBox","scroll","translateAxis","cssVariableRegex","getVariableValue","current","depth","invariant","match","exec","parseCSSVariable","token","fallback","window","getComputedStyle","getPropertyValue","resolveCSSVariables","getInstance","Element","layout","layoutId","renderHTML","styleProp","projection","getProjectionStyles","setProperty","camelCaseAttributes","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","scrapeMotionValuesFromProps$1","toUpperCase","renderSVG","renderState","_styleProp","setAttribute","usePresence","context","useContext","PresenceContext","isPresent","onExitComplete","register","id","SwitchLayoutGroupContext","AnimationType","shallowCompare","next","prev","prevLength","variantPriorityOrder","Animate","InView","Focus","Hover","Tap","Drag","Exit","reversePriorityOrder","numAnimationTypes","createAnimationState","animate","animateList","createTypeState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","getProps","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isActive","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","isVariantLabels","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","delete","isKeyframesTarget","add","blockInitialAnimation","apply","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","initial","isAnimated","setActive","setAnimateFunction","makeAnimator","makeRenderlessComponent","subscribe","exit","safeToRemove","presenceContext","createHoverEvent","info","isNodeOrChild","parent","parentElement","warned","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","root","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","thresholdNames","some","useIntersectionObserver","shouldObserve","rootMargin","margin","amount","once","threshold","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","message","console","warn","requestAnimationFrame","gestureAnimations","inView","whileInView","viewport","useRef","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","passive","onPointerDown","removePointerEndListener","call","checkPointerEnd","onPointerUp","onPointerCancel","pipe","addPointerEvent","usePointerEvent","focus","whileFocus","useDomEvent","hover","onHoverStart","onHoverEnd","whileHover","names","BoundingBoxDimension","treeType","build","renderInstance","render","readValueFromInstance","removeValueFromRenderState","presenceId","visualState","removeFromVariantTree","isMounted","lifecycles","managers","SubscriptionManager","propSubscriptions","clearAllListeners","manager","clear","updatePropListeners","on","propListener","args","_i","notify","createLifecycles","values","Map","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","update","notifyUpdate","bindToMotionValue","removeOnChange","onChange","latestValue","onUpdate","sync","removeOnRenderRequest","onRenderRequest","scheduleRender","initialMotionValues","isControllingVariants","checkIfControllingVariants","isVariantNode","checkIfVariantNode","children","isVisible","mount","newInstance","addVariantChild","setProps","unmount","cancelSync","remove","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","getLatestValues","setVisibility","visibility","canMutate","removeValue","defaultValue","syncRender","newProps","nextValue","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","variants","getTransformPagePoint","startAtParent","context_1","numVariantProps","name_1","variantProps","positionalKeys","isPositionalKey","setAndResetVelocity","to","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","nonTranslationalTransformKeys","transformProps","positionalValues","paddingLeft","paddingRight","paddingTop","paddingBottom","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","scrollY_1","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","targetBbox","convertChangedValueTypes","scrollTo","unitConversion","hasPositionalKey","htmlConfig","domElement","defaultType","getDefaultValueType","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","transformValues","parsed","parseDomVariant","htmlVisualElement","svgVisualElement","getAttribute","_element","domAnimation","renderer","prefersReducedMotion","hasDetected","useReducedMotion","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","useState","useReducedMotionConfig","reducedMotionPreference","reducedMotion","MotionConfigContext","LazyMotion","features","setIsLoaded","isLazyBundle","loadedRenderer","loadedFeatures","loadFeatures","React","Provider","wellKnownSymbol","create","defineProperty","f","UNSCOPABLES","ArrayPrototype","prototype","configurable","module","exports","activeXDocument","anObject","definePropertiesModule","enumBugKeys","hiddenKeys","html","documentCreateElement","sharedKey","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","error","iframeDocument","iframe","domain","appendChild","src","String","contentWindow","open","F","O","Properties","result","DESCRIPTORS","V8_PROTOTYPE_DEFINE_BUG","definePropertyModule","toIndexedObject","objectKeys","defineProperties","index","internalObjectKeys","getBuiltIn","resolveVariantFromProps","currentValues","currentVelocity","getCurrent","velocity","getVelocity","whileDrag","ex","memoize","reactPropsRegex","charCodeAt","featureNames","featureDefinitions","numFeatures","MotionContext","useVisualElement","createVisualElement","lazyContext","visualElementRef","notifyUnmount","useCreateMotionContext","inherit","getCurrentTreeVariants","useMemo","variantLabelsAsDependency","join","VisualElementHandler","_super","__extends","getSnapshotBeforeUpdate","updateProps","componentDidUpdate","React__default","createMotionComponent","preloadedFeatures","projectionNodeConstructor","useRender","useVisualState","MotionComponent","externalRef","layoutGroupId","LayoutGroupContext","useLayoutId","config","projectionId","isStatic","ProjectionNodeConstructor","dragConstraints","layoutScroll","initialPromotionConfig","setOptions","alwaysMeasureLayout","isRefObject","animationType","useProjection","isEnabled","useFeatures","useCallback","useMotionRef","forwardRef","createHtmlRenderState","copyRawValuesOnly","source","useStyle","useInitialMotionValues","useHTMLProps","htmlProps","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","createSvgRenderState","useSVGProps","visualProps","rawStyles","createUseRender","ref","elementProps","createElement","makeState","createRenderState","onMount","makeLatestValues","makeUseVisualState","scrapeMotionValues","motionValues","initialAnimationIsBlocked","variantToSet","svgMotionConfig","getBBox","htmlMotionConfig","m","createConfig","customMotionComponentConfig","Proxy","componentCache","_target","createMotionProxy","baseConfig","transformAxes","operationKey","axesKey","transformPropSet","transformOriginProps","scalePoint","scale","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","axis","applyBoxDelta","box","applyTreeDeltas","treeScale","treePath","isSharedTransition","treeLength","node","delta","projectionDelta","transformBox","distance","transformAxis","transforms","scaleKey","originKey","axisOrigin","mix","xKeys","yKeys","init","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","onpointerdown","ontouchstart","onmousedown","eventName","addDomEvent","hook","isIdentityScale","hasScale","scaleX","scaleY","hasTranslate","rotate","rotateX","rotateY","addEventListener","removeEventListener","p","createDefinition","propNames","measureLayout","pan"],"mappings":"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","file":"defaultVendors~Accordion~ApartmentCards~ArticleCardList~AwardsCarousel~ContentSignpostCards~Developm~44ef05a9-6f11a7d40b2a50e6fe2d.js","sourcesContent":["/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nexport { globalProjectionState };\n","import { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\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","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nexport { isZeroValueString };\n","import { __spreadArray, __read } from 'tslib';\nimport { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = __spreadArray(__spreadArray([], __read(dimensionValueTypes), false), [color, complex], false);\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.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './variants.mjs';\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 ? visualElement.makeTargetAnimatable(resolved, false) : {}, _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), false).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\" &&\n            (isNumericalString(value) || isZeroValueString(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 { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.mjs';\n\nvar useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\n","var scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n","import { isTouchEvent } from '../gestures/utils/event-type.mjs';\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}\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, 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","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar fails = require('../internals/fails');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// FF99+ bug\nvar BROKEN_ON_SPARSE = fails(function () {\n  return !Array(1).includes();\n});\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","/**\n * Browser-safe usage of process\n */\nvar defaultEnvironment = \"production\";\nvar env = typeof process === \"undefined\" || process.env === undefined\n    ? defaultEnvironment\n    : process.env.NODE_ENV || defaultEnvironment;\n\nexport { env };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(function () { return function () { return callback(); }; }, []);\n}\n\nexport { useUnmountEffect };\n","import { createContext } from 'react';\n\nvar LazyContext = createContext({ strict: false });\n\nexport { LazyContext };\n","function isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nexport { isAnimationControls };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","function createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","import { sortTransformProps } from './transform.mjs';\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\nexport { buildTransform, buildTransformOrigin };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","import { buildTransform, buildTransformOrigin } from './build-transform.mjs';\nimport { isCSSVariable } from '../../dom/utils/is-css-variable.mjs';\nimport { isTransformProp, isTransformOriginProp } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nexport { buildHTMLStyles };\n","import { px } from 'style-value-types';\n\nfunction calcOrigin(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    var pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from 'style-value-types';\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    var pathLength = px.transform(length);\n    var pathSpacing = px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\nexport { buildSVGPath };\n","import { __rest } from 'tslib';\nimport { buildHTMLStyles } from '../../html/utils/build-styles.mjs';\nimport { calcSVGTransformOrigin } from './transform-origin.mjs';\nimport { buildSVGPath } from './path.mjs';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = __rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nexport { buildSVGAttrs };\n","/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n","import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\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 convertBoundingBoxToBox(_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 convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\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 transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","import { isCustomValue } from '../../utils/resolve-value.mjs';\nimport { isMotionValue } from './is-motion-value.mjs';\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nexport { resolveMotionValue };\n","import { __read, __rest, __assign } from 'tslib';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { setTarget } from './setters.mjs';\nimport { resolveVariant } from './variants.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\n\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\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 valueTransition = __assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = __assign(__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\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","/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"layoutDependency\",\n    \"onLayoutAnimationStart\",\n    \"onLayoutAnimationComplete\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"dragSnapToOrigin\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n    \"whileInView\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"viewport\",\n    \"layoutScroll\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nexport { isValidMotionProp };\n","import { isValidMotionProp } from '../../../motion/utils/valid-prop.mjs';\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = function (key) {\n        return key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n    };\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    var filteredProps = {};\n    for (var key in props) {\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nexport { filterProps, loadExternalIsValidProp };\n","import { useConstant } from './use-constant.mjs';\n\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useId = function () { return useConstant(incrementId); };\n/**\n * Ideally we'd use the following code to support React 18 optionally.\n * But this fairly fails in Webpack (otherwise treeshaking wouldn't work at all).\n * Need to come up with a different way of figuring this out.\n */\n// export const useId = (React as any).useId\n//     ? (React as any).useId\n//     : () => useConstant(incrementId)\n\nexport { useId };\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","/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable(key) {\n    return key.startsWith(\"--\");\n}\n\nexport { isCSSVariable };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\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 \\\"\".concat(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 Element))\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 { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.mjs';\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","function renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nexport { camelCaseAttributes };\n","var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nexport { camelToDash };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';\nimport { renderHTML } from '../../html/utils/render.mjs';\nimport { camelCaseAttributes } from './camel-case-attrs.mjs';\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","import { useContext, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useId } from '../../utils/use-id.mjs';\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    var context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    // Replace with useId when released in React\n    var id = useId();\n    useEffect(function () { return register(id); }, []);\n    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id); };\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","import { createContext } from 'react';\n\n/**\n * Internal, exported only for usage in Framer\n */\nvar SwitchLayoutGroupContext = createContext({});\n\nexport { SwitchLayoutGroupContext };\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[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nexport { AnimationType };\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.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { animateVisualElement } from './animation.mjs';\nimport { AnimationType } from './types.mjs';\nimport { isVariantLabels, resolveVariant, isVariantLabel } from './variants.mjs';\n\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.InView,\n    AnimationType.Focus,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = __spreadArray([], __read(variantPriorityOrder), false).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 variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var shouldAnimateType = variantDidChange ||\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) || variantDidChange) {\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                }); })), false));\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        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(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.InView] = createTypeState(),\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 { checkVariantsDidChange, createAnimationState, variantPriorityOrder };\n","import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { createAnimationState } from '../../render/utils/animation-state.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\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], safeToRemove = _a[1];\n        var presenceContext = useContext(PresenceContext);\n        useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\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(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n","import { isMouseEvent } from './utils/event-type.mjs';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\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, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\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","var warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\nexport { warnOnce };\n","import { __rest, __assign } from 'tslib';\n\n/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nvar observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = __rest(_a, [\"root\"]);\n    var lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    var rootObservers = observers.get(lookupRoot);\n    var key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, __assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { env } from '../../../utils/process.mjs';\nimport { useRef, useEffect } from 'react';\nimport { AnimationType } from '../../../render/utils/types.mjs';\nimport { warnOnce } from '../../../utils/warn-once.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nexport { useViewport };\n","import { useFocusGesture } from '../../gestures/use-focus-gesture.mjs';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.mjs';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.mjs';\nimport { useViewport } from './viewport/use-viewport.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\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.mjs';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\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    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    var eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\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, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n","import { AnimationType } from '../render/utils/types.mjs';\nimport { useDomEvent } from '../events/use-dom-event.mjs';\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 { __spreadArray, __read } from 'tslib';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"LayoutAnimationStart\",\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            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\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), false));\n        };\n    });\n    return lifecycles;\n}\n\nexport { createLifecycles };\n","import { __assign, __spreadArray, __read } from 'tslib';\nimport sync, { cancelSync } from 'framesync';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { variantPriorityOrder } from './utils/animation-state.mjs';\nimport { createLifecycles } from './utils/lifecycles.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.mjs';\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, 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, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\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\n         */\n        var lifecycles = createLifecycles();\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         * 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         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\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             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \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 the projection tree, 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                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                cancelSync.update(update);\n                cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\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 () {\n                        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             * 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            /**\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 () {\n                return measureViewportBox(instance, props);\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) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\n            }, \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                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\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; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \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        return element;\n    };\n};\nvar variantProps = __spreadArray([\"initial\"], __read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\n\nexport { visualElement };\n","import { __assign, __read } from 'tslib';\nimport { number, px } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from 'hey-listen';\nimport { transformProps } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\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) {\n    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    };\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, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\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;\n    var origin = {};\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    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\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, origin[key]);\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 fromType = findDimensionValueType(from);\n        var to = target[key];\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            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; 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 =\n                        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 scrollY_1 = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\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        // Restore scroll position\n        if (scrollY_1 !== null)\n            window.scrollTo({ top: scrollY_1 });\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, positionalValues, unitConversion };\n","import { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\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             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"6.5.1\", \"Attempting to mix Framer Motion versions \".concat(nextValue.version, \" with 6.5.1 may not work as expected.\"));\n            }\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 { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\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.mjs';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.mjs';\nimport { isTransformProp } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\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 measureViewportBox(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, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nexport { getComputedStyle, htmlConfig, htmlVisualElement };\n","import { __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { htmlConfig } from '../html/visual-element.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\n\nvar svgVisualElement = visualElement(__assign(__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\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    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nexport { svgVisualElement };\n","import { __assign } from 'tslib';\nimport { animations } from '../../motion/features/animations.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\n\n/**\n * @public\n */\nvar domAnimation = __assign(__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\nexport { domAnimation };\n","import { htmlVisualElement } from '../html/visual-element.mjs';\nimport { svgVisualElement } from '../svg/visual-element.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { __read } from 'tslib';\nimport { useState, useContext } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { isBrowser } from './is-browser.mjs';\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = { current: null };\nvar hasDetected = false;\nfunction initPrefersReducedMotion() {\n    hasDetected = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return (prefersReducedMotion.current = motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n/**\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\n *\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\n *\n * It will actively respond to changes and re-render your components with the latest setting.\n *\n * ```jsx\n * export function Sidebar({ isOpen }) {\n *   const shouldReduceMotion = useReducedMotion()\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\n *\n *   return (\n *     <motion.div animate={{\n *       opacity: isOpen ? 1 : 0,\n *       x: isOpen ? 0 : closedX\n *     }} />\n *   )\n * }\n * ```\n *\n * @return boolean\n *\n * @public\n */\nfunction useReducedMotion() {\n    /**\n     * Lazy initialisation of prefersReducedMotion\n     */\n    !hasDetected && initPrefersReducedMotion();\n    var _a = __read(useState(prefersReducedMotion.current), 1), shouldReduceMotion = _a[0];\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\nfunction useReducedMotionConfig() {\n    var reducedMotionPreference = useReducedMotion();\n    var reducedMotion = useContext(MotionConfigContext).reducedMotion;\n    if (reducedMotion === \"never\") {\n        return false;\n    }\n    else if (reducedMotion === \"always\") {\n        return true;\n    }\n    else {\n        return reducedMotionPreference;\n    }\n}\n\nexport { useReducedMotion, useReducedMotionConfig };\n","import { __read, __rest } from 'tslib';\nimport * as React from 'react';\nimport { useState, useRef, useEffect } from 'react';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { loadFeatures } from '../../motion/features/definitions.mjs';\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","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  defineProperty(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    activeXDocument = new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = typeof document != 'undefined'\n    ? document.domain && activeXDocument\n      ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n      : NullProtoObjectViaIFrame()\n    : NullProtoObjectViaActiveX(activeXDocument); // WSH\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var props = toIndexedObject(Properties);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n  return O;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nexport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel, isVariantLabels, resolveVariant, resolveVariantFromProps };\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar memoize = _interopDefault(require('@emotion/memoize'));\n\nvar reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|inert|itemProp|itemScope|itemType|itemID|itemRef|on|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23\n\nvar index = memoize(function (prop) {\n  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111\n  /* o */\n  && prop.charCodeAt(1) === 110\n  /* n */\n  && prop.charCodeAt(2) < 91;\n}\n/* Z+1 */\n);\n\nexports.default = index;\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport { env } from '../../utils/process.mjs';\nimport { featureDefinitions } from './definitions.mjs';\nimport { invariant } from 'hey-listen';\nimport { LazyContext } from '../../context/LazyContext.mjs';\n\nvar featureNames = Object.keys(featureDefinitions);\nvar numFeatures = featureNames.length;\n/**\n * Load features via renderless components based on the provided MotionProps.\n */\nfunction useFeatures(props, visualElement, preloadedFeatures) {\n    var features = [];\n    var lazyContext = useContext(LazyContext);\n    if (!visualElement)\n        return null;\n    /**\n     * If we're in development mode, check to make sure we're not rendering a motion component\n     * as a child of LazyMotion, as this will break the file-size benefits of using it.\n     */\n    if (env !== \"production\" && preloadedFeatures && lazyContext.strict) {\n        invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n    }\n    for (var i = 0; i < numFeatures; i++) {\n        var name_1 = featureNames[i];\n        var _a = featureDefinitions[name_1], isEnabled = _a.isEnabled, Component = _a.Component;\n        /**\n         * It might be possible in the future to use this moment to\n         * dynamically request functionality. In initial tests this\n         * was producing a lot of duplication amongst bundles.\n         */\n        if (isEnabled(props) && Component) {\n            features.push(React.createElement(Component, __assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\nexport { useFeatures };\n","import { createContext, useContext } from 'react';\n\nvar MotionContext = createContext({});\nfunction useVisualElementContext() {\n    return useContext(MotionContext).visualElement;\n}\n\nexport { MotionContext, useVisualElementContext };\n","import { useContext, useRef, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useVisualElementContext } from '../../context/MotionContext/index.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { useReducedMotionConfig } from '../../utils/use-reduced-motion.mjs';\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var lazyContext = useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = useContext(PresenceContext);\n    var shouldReduceMotion = useReducedMotionConfig();\n    var visualElementRef = useRef(undefined);\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    if (!createVisualElement)\n        createVisualElement = lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState: visualState,\n            parent: parent,\n            props: props,\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n            shouldReduceMotion: shouldReduceMotion,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n    });\n    useEffect(function () {\n        var _a;\n        (_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\nexport { useVisualElement };\n","import { useMemo, useContext } from 'react';\nimport { MotionContext } from './index.mjs';\nimport { getCurrentTreeVariants } from './utils.mjs';\n\nfunction useCreateMotionContext(props) {\n    var _a = getCurrentTreeVariants(props, useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nexport { useCreateMotionContext };\n","import { checkIfControllingVariants, isVariantLabel } from '../../render/utils/variants.mjs';\n\nfunction getCurrentTreeVariants(props, context) {\n    if (checkIfControllingVariants(props)) {\n        var initial = props.initial, animate = props.animate;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nexport { getCurrentTreeVariants };\n","import { useConstant } from '../../utils/use-constant.mjs';\nimport { globalProjectionState } from './state.mjs';\n\nvar id = 1;\nfunction useProjectionId() {\n    return useConstant(function () {\n        if (globalProjectionState.hasEverUpdated) {\n            return id++;\n        }\n    });\n}\n\nexport { useProjectionId };\n","import { __extends } from 'tslib';\nimport React__default from 'react';\n\nvar VisualElementHandler = /** @class */ (function (_super) {\n    __extends(VisualElementHandler, _super);\n    function VisualElementHandler() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Update visual element props as soon as we know this update is going to be commited.\n     */\n    VisualElementHandler.prototype.getSnapshotBeforeUpdate = function () {\n        this.updateProps();\n        return null;\n    };\n    VisualElementHandler.prototype.componentDidUpdate = function () { };\n    VisualElementHandler.prototype.updateProps = function () {\n        var _a = this.props, visualElement = _a.visualElement, props = _a.props;\n        if (visualElement)\n            visualElement.setProps(props);\n    };\n    VisualElementHandler.prototype.render = function () {\n        return this.props.children;\n    };\n    return VisualElementHandler;\n}(React__default.Component));\n\nexport { VisualElementHandler };\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { forwardRef, useContext } from 'react';\nimport { useFeatures } from './features/use-features.mjs';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { MotionContext } from '../context/MotionContext/index.mjs';\nimport { useVisualElement } from './utils/use-visual-element.mjs';\nimport { useMotionRef } from './utils/use-motion-ref.mjs';\nimport { useCreateMotionContext } from '../context/MotionContext/create.mjs';\nimport { loadFeatures, featureDefinitions } from './features/definitions.mjs';\nimport { isBrowser } from '../utils/is-browser.mjs';\nimport { useProjectionId } from '../projection/node/id.mjs';\nimport { LayoutGroupContext } from '../context/LayoutGroupContext.mjs';\nimport { useProjection } from './features/use-projection.mjs';\nimport { VisualElementHandler } from './utils/VisualElementHandler.mjs';\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, projectionNodeConstructor = _a.projectionNodeConstructor, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        var layoutId = useLayoutId(props);\n        props = __assign(__assign({}, props), { layoutId: layoutId });\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var config = useContext(MotionConfigContext);\n        var features = null;\n        var context = useCreateMotionContext(props);\n        /**\n         * Create a unique projection ID for this component. If a new component is added\n         * during a layout animation we'll use this to query the DOM and hydrate its ref early, allowing\n         * us to measure it as soon as any layout effect flushes pending layout animations.\n         *\n         * Performance note: It'd be better not to have to search the DOM for these elements.\n         * For newly-entering components it could be enough to only correct treeScale, in which\n         * case we could mount in a scale-correction mode. This wouldn't be enough for\n         * shared element transitions however. Perhaps for those we could revert to a root node\n         * that gets forceRendered and layout animations are triggered on its layout effect.\n         */\n        var projectionId = config.isStatic ? undefined : useProjectionId();\n        /**\n         *\n         */\n        var visualState = useVisualState(props, config.isStatic);\n        if (!config.isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, __assign(__assign({}, config), props), createVisualElement);\n            useProjection(projectionId, props, context.visualElement, projectionNodeConstructor ||\n                featureDefinitions.projectionNodeConstructor);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React.createElement(VisualElementHandler, { visualElement: context.visualElement, props: __assign(__assign({}, config), props) },\n            features,\n            React.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, projectionId, useMotionRef(visualState, context.visualElement, externalRef), visualState, config.isStatic, context.visualElement))));\n    }\n    return forwardRef(MotionComponent);\n}\nfunction useLayoutId(_a) {\n    var _b;\n    var layoutId = _a.layoutId;\n    var layoutGroupId = (_b = useContext(LayoutGroupContext)) === null || _b === void 0 ? void 0 : _b.id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\n\nexport { createMotionComponent };\n","import { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { useContext } from 'react';\nimport { SwitchLayoutGroupContext } from '../../context/SwitchLayoutGroupContext.mjs';\n\nfunction useProjection(projectionId, _a, visualElement, ProjectionNodeConstructor) {\n    var _b;\n    var layoutId = _a.layoutId, layout = _a.layout, drag = _a.drag, dragConstraints = _a.dragConstraints, layoutScroll = _a.layoutScroll;\n    var initialPromotionConfig = useContext(SwitchLayoutGroupContext);\n    if (!ProjectionNodeConstructor ||\n        !visualElement ||\n        (visualElement === null || visualElement === void 0 ? void 0 : visualElement.projection)) {\n        return;\n    }\n    visualElement.projection = new ProjectionNodeConstructor(projectionId, visualElement.getLatestValues(), (_b = visualElement.parent) === null || _b === void 0 ? void 0 : _b.projection);\n    visualElement.projection.setOptions({\n        layoutId: layoutId,\n        layout: layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement: visualElement,\n        scheduleRender: function () { return visualElement.scheduleRender(); },\n        /**\n         * TODO: Update options in an effect. This could be tricky as it'll be too late\n         * to update by the time layout animations run.\n         * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n         * ensuring it gets called if there's no potential layout animations.\n         *\n         */\n        animationType: typeof layout === \"string\" ? layout : \"both\",\n        initialPromotionConfig: initialPromotionConfig,\n        layoutScroll: layoutScroll,\n    });\n}\n\nexport { useProjection };\n","import { useCallback } from 'react';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return useCallback(function (instance) {\n        var _a;\n        instance && ((_a = visualState.mount) === null || _a === void 0 ? void 0 : _a.call(visualState, instance));\n        if (visualElement) {\n            instance\n                ? visualElement.mount(instance)\n                : visualElement.unmount();\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\nexport { useMotionRef };\n","var createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\n\nexport { createHtmlRenderState };\n","import { __assign } from 'tslib';\nimport { useMemo } from 'react';\nimport { isForcedMotionValue } from '../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (var key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues(_a, visualState, isStatic) {\n    var transformTemplate = _a.transformTemplate;\n    return useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return __assign(__assign({}, vars), style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    var styleProp = props.style || {};\n    var style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));\n    if (props.transformValues) {\n        style = props.transformValues(style);\n    }\n    return style;\n}\nfunction useHTMLProps(props, visualState, isStatic) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    var htmlProps = {};\n    var style = useStyle(props, visualState, isStatic);\n    if (Boolean(props.drag) && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\".concat(props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\nexport { copyRawValuesOnly, useHTMLProps, useStyle };\n","import { __assign } from 'tslib';\nimport { createHtmlRenderState } from '../../html/utils/create-render-state.mjs';\n\nvar createSvgRenderState = function () { return (__assign(__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nexport { createSvgRenderState };\n","import { __assign } from 'tslib';\nimport { useMemo } from 'react';\nimport { copyRawValuesOnly } from '../html/use-props.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return __assign(__assign({}, state.attrs), { style: __assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = __assign(__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nexport { useSVGProps };\n","import { __assign } from 'tslib';\nimport { createElement } from 'react';\nimport { useHTMLProps } from '../html/use-props.mjs';\nimport { filterProps } from './utils/filter-props.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\nimport { useSVGProps } from '../svg/use-props.mjs';\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, projectionId, ref, _a, isStatic) {\n        var latestValues = _a.latestValues;\n        var useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        var visualProps = useVisualProps(props, latestValues, isStatic);\n        var filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        var elementProps = __assign(__assign(__assign({}, filteredProps), visualProps), { ref: ref });\n        if (projectionId) {\n            elementProps[\"data-projection-id\"] = projectionId;\n        }\n        return createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nexport { createUseRender };\n","import { __rest } from 'tslib';\nimport { useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, resolveVariantFromProps } from '../../render/utils/variants.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { MotionContext } from '../../context/MotionContext/index.mjs';\n\nfunction makeState(_a, props, context, presenceContext) {\n    var scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps, createRenderState = _a.createRenderState, onMount = _a.onMount;\n    var state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = function (instance) { return onMount(props, instance, state); };\n    }\n    return state;\n}\nvar makeUseVisualState = function (config) {\n    return function (props, isStatic) {\n        var context = useContext(MotionContext);\n        var presenceContext = useContext(PresenceContext);\n        return isStatic\n            ? makeState(config, props, context, presenceContext)\n            : useConstant(function () {\n                return makeState(config, props, context, presenceContext);\n            });\n    };\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var initialAnimationIsBlocked = blockInitialAnimation || initial === false;\n    var variantToSet = initialAnimationIsBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = __rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target) {\n                var valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    var index = initialAnimationIsBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nexport { makeUseVisualState };\n","import { renderSVG } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\n\nvar svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: function (props, instance, _a) {\n            var renderState = _a.renderState, latestValues = _a.latestValues;\n            try {\n                renderState.dimensions =\n                    typeof instance.getBBox ===\n                        \"function\"\n                        ? instance.getBBox()\n                        : instance.getBoundingClientRect();\n            }\n            catch (e) {\n                // Most likely trying to measure an unrendered element under Firefox\n                renderState.dimensions = {\n                    x: 0,\n                    y: 0,\n                    width: 0,\n                    height: 0,\n                };\n            }\n            buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, props.transformTemplate);\n            renderSVG(instance, renderState);\n        },\n    }),\n};\n\nexport { svgMotionConfig };\n","import { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nexport { htmlMotionConfig };\n","import { createMotionProxy } from './motion-proxy.mjs';\nimport { createDomMotionConfig } from './utils/create-config.mjs';\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nexport { m };\n","import { createMotionComponent } from '../../motion/index.mjs';\n\n/**\n * Convert any React component into a `motion` component. The provided component\n * **must** use `React.forwardRef` to the underlying DOM component you want to animate.\n *\n * ```jsx\n * const Component = React.forwardRef((props, ref) => {\n *   return <div ref={ref} />\n * })\n *\n * const MotionComponent = motion(Component)\n * ```\n *\n * @public\n */\nfunction createMotionProxy(createConfig) {\n    function custom(Component, customMotionComponentConfig) {\n        if (customMotionComponentConfig === void 0) { customMotionComponentConfig = {}; }\n        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    var componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: function (_target, key) {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\nexport { createMotionProxy };\n","import { __assign } from 'tslib';\nimport { isSVGComponent } from './is-svg-component.mjs';\nimport { createUseRender } from '../use-render.mjs';\nimport { svgMotionConfig } from '../../svg/config-motion.mjs';\nimport { htmlMotionConfig } from '../../html/config-motion.mjs';\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement, projectionNodeConstructor) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return __assign(__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement, projectionNodeConstructor: projectionNodeConstructor, Component: Component });\n}\n\nexport { createDomMotionConfig };\n","/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nexport { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { hasTransform } from '../utils/has-transform.mjs';\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 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, isSharedTransition) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\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.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\n        }\n        if (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        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\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 transformAxis(axis, transforms, _a) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\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(axis, 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 transformBox(box, transform) {\n    transformAxis(box.x, transform, xKeys);\n    transformAxis(box.y, transform, yKeys);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","import { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\n","import { addDomEvent, useDomEvent } from './use-dom-event.mjs';\nimport { wrapHandler } from './event-info.mjs';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.mjs';\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.mjs';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { hasScale, hasTransform };\n","var isBrowser = typeof document !== \"undefined\";\n\nexport { isBrowser };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options) {\n    if (options === void 0) { options = { passive: true }; }\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\nexport { addDomEvent, useDomEvent };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar MotionConfigContext = createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nexport { MotionConfigContext };\n","import { createContext } from 'react';\n\nvar LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","var createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\nexport { featureDefinitions, loadFeatures };\n","function isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\nexport { isRefObject };\n"],"sourceRoot":""}