{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/render/html/utils/transform.js","webpack:///./node_modules/framer-motion/dist/es/value/utils/is-motion-value.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-constant.js","webpack:///./node_modules/framer-motion/dist/es/context/MotionConfigContext.js","webpack:///./node_modules/framer-motion/dist/es/context/PresenceContext.js","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/index.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/use-features.js","webpack:///./node_modules/framer-motion/dist/es/context/LayoutGroupContext.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.js","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.js","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/create.js","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/utils.js","webpack:///./node_modules/framer-motion/dist/es/motion/index.js","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.js","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.js","webpack:///./node_modules/framer-motion/dist/es/render/html/use-props.js","webpack:///./node_modules/framer-motion/dist/es/motion/utils/valid-prop.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/use-props.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/use-render.js","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.js","webpack:///./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/config-motion.js","webpack:///./node_modules/framer-motion/dist/es/render/html/config-motion.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion-minimal.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion-proxy.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/create-config.js","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/definitions.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/scale-correction.js","webpack:///./node_modules/framer-motion/dist/es/utils/is-browser.js","webpack:///./node_modules/style-value-types/dist/es/numbers/index.js","webpack:///./node_modules/framer-motion/dist/es/context/LazyContext.js","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.js","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.js","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-transform.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.js","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-styles.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/path.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.js","webpack:///./node_modules/framer-motion/dist/es/utils/is-ref-object.js","webpack:///./node_modules/framer-motion/dist/es/utils/resolve-value.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.js","webpack:///./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.js","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/render.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.js","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/render.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/number.js","webpack:///./node_modules/style-value-types/dist/es/numbers/units.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/style-value-types/dist/es/utils.js","webpack:///./node_modules/hey-listen/dist/hey-listen.es.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/variants.js"],"names":["transformAxes","transformProps","sortTransformProps","a","b","indexOf","forEach","operationKey","axesKey","push","transformPropSet","Set","isTransformProp","key","has","transformOriginProps","isTransformOriginProp","isMotionValue","value","getVelocity","useConstant","init","ref","current","MotionConfigContext","transformPagePoint","p","isStatic","PresenceContext","MotionContext","useVisualElementContext","visualElement","featureNames","Object","keys","numFeatures","length","LayoutGroupContext","useIsomorphicLayoutEffect","useVisualElement","Component","visualState","props","createVisualElement","config","lazyContext","LazyContext","parent","presenceContext","layoutId","_a","layoutGroupId","undefined","useLayoutId","visualElementRef","renderer","presenceId","id","blockInitialAnimation","initial","setProps","isPresent","isPresenceRoot","syncRender","animationState","animateChanges","notifyUnmount","useCreateMotionContext","context","animate","inherit","getCurrentTreeVariants","variantLabelsAsDependency","prop","Array","isArray","join","createMotionComponent","preloadedFeatures","useRender","useVisualState","externalRef","features","i","name_1","isEnabled","useFeatures","Provider","instance","mount","call","unmount","useMotionRef","createHtmlRenderState","style","transform","transformKeys","transformOrigin","vars","copyRawValuesOnly","target","source","useStyle","assign","transformTemplate","state","enableHardwareAcceleration","useInitialMotionValues","transformValues","useHTMLProps","htmlProps","Boolean","drag","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","validMotionProps","isValidMotionProp","shouldForward","emotionIsPropValid_1","default","startsWith","createSvgRenderState","attrs","useSVGProps","visualProps","rawStyles","createUseRender","forwardMotionProps","latestValues","filteredProps","isDom","filterProps","elementProps","makeState","scrapeMotionValuesFromProps","createRenderState","onMount","makeLatestValues","renderState","makeUseVisualState","scrapeMotionValues","unwrappedValue","values","motionValues","get","toValue","isControllingVariants","isVariantNode","variantToSet","definition","resolved","transitionEnd","transition","svgMotionConfig","dimensions","getBBox","getBoundingClientRect","e","x","y","width","height","tagName","totalPathLength","getTotalLength","render","htmlMotionConfig","m","createConfig","custom","customMotionComponentConfig","componentCache","Map","Proxy","_target","set","createMotionProxy","_b","baseConfig","isKeyframesTarget","v","createDefinition","propNames","some","name","featureDefinitions","measureLayout","animation","exit","focus","hover","tap","pan","layoutAnimation","loadFeatures","valueScaleCorrection","addScaleCorrection","correctors","isBrowser","window","number","test","parse","parseFloat","alpha","scale","strict","isAnimationControls","start","newValues","usePresence","onExitComplete","register","useUniqueId","counter","incrementId","translateAlias","z","transformPerspective","getValueAsType","type","buildHTMLStyles","projection","layoutState","options","buildProjectionTransform","buildProjectionTransformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","valueAsType","isHydrated","correctedValue","process","applyTo","num","deltaFinal","treeScale","transformIsDefault","_c","_d","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","trim","buildTransform","originX","originY","originZ","buildTransformOrigin","calcOrigin","origin","offset","size","progressToPixels","progress","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","latest","calcSVGTransformOrigin","totalLength","spacing","useDashCase","buildSVGPath","lowercaseSVGElements","isSVGComponent","includes","isRefObject","prototype","hasOwnProperty","isCustomValue","mix","resolveFinalValueInKeyframes","isCSSVariable","isForcedMotionValue","layout","renderHTML","element","setProperty","camelCaseAttributes","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","toUpperCase","renderSVG","setAttribute","Math","round","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxWidth","maxHeight","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","opacity","zIndex","fillOpacity","strokeOpacity","numOctaves","createUnitType","unit","endsWith","split","degrees","percent","px","vh","vw","progressPercentage","extendStatics","d","setPrototypeOf","__proto__","__extends","TypeError","String","__","this","constructor","create","__assign","t","s","n","arguments","apply","__rest","getOwnPropertySymbols","propertyIsEnumerable","__read","o","Symbol","iterator","r","ar","next","done","error","__spreadArray","to","from","pack","l","slice","concat","clamp","min","max","sanitize","Number","toFixed","floatRegex","colorRegex","singleColorRegex","isString","warning","invariant","isVariantLabels","isVariantLabel","resolveVariantFromProps","currentValues","currentVelocity","variants","resolveVariant","getProps","forEachValue","getCurrent","velocity","checkIfControllingVariants","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode"],"mappings":"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","file":"vendors~CenterText~CustomerPortalDashboard~FiftyFiftyTextImage~HomepageCarousel~LoginBanner~MyHires~~4983fca8-a198576a5651a6c1b6f2.js","sourcesContent":["/**\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","var isMotionValue = function (value) {\n    return value !== null && typeof value === \"object\" && value.getVelocity;\n};\n\nexport { isMotionValue };\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 { createContext } from 'react';\n\n/**\n * @public\n */\nvar MotionConfigContext = createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n});\n\nexport { MotionConfigContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","import { useContext, createContext } from 'react';\n\nvar MotionContext = createContext({});\nfunction useVisualElementContext() {\n    return useContext(MotionContext).visualElement;\n}\n\nexport { MotionContext, useVisualElementContext };\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport { featureDefinitions } from './definitions.js';\nimport { invariant } from 'hey-listen';\nimport { LazyContext } from '../../context/LazyContext.js';\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 (process.env.NODE_ENV !== \"production\" &&\n        preloadedFeatures &&\n        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 } from 'react';\n\n/**\n * @internal\n */\nvar LayoutGroupContext = createContext(null);\n\nexport { LayoutGroupContext };\n","import { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.js';\n\nvar useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\n","import { __assign } from 'tslib';\nimport { useContext, useRef, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { isPresent } from '../../components/AnimatePresence/use-presence.js';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.js';\nimport { useVisualElementContext } from '../../context/MotionContext/index.js';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.js';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.js';\nimport { LazyContext } from '../../context/LazyContext.js';\n\nfunction useLayoutId(_a) {\n    var layoutId = _a.layoutId;\n    var layoutGroupId = useContext(LayoutGroupContext);\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var config = useContext(MotionConfigContext);\n    var lazyContext = useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = useContext(PresenceContext);\n    var layoutId = useLayoutId(props);\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: __assign(__assign({}, props), { layoutId: layoutId }),\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        if (!visualElement)\n            return;\n        visualElement.setProps(__assign(__assign(__assign({}, config), props), { layoutId: layoutId }));\n        visualElement.isPresent = isPresent(presenceContext);\n        visualElement.isPresenceRoot =\n            !parent || parent.presenceId !== (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id);\n        /**\n         * Fire a render to ensure the latest state is reflected on-screen.\n         */\n        visualElement.syncRender();\n    });\n    useEffect(function () {\n        var _a;\n        if (!visualElement)\n            return;\n        /**\n         * In a future refactor we can replace the features-as-components and\n         * have this loop through them all firing \"effect\" listeners\n         */\n        (_a = 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.js';\nimport { getCurrentTreeVariants } from './utils.js';\n\nfunction useCreateMotionContext(props, isStatic) {\n    var _a = getCurrentTreeVariants(props, useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return useMemo(function () { return ({ initial: initial, animate: animate }); }, \n    /**\n     * Only break memoisation in static mode\n     */\n    isStatic\n        ? [\n            variantLabelsAsDependency(initial),\n            variantLabelsAsDependency(animate),\n        ]\n        : []);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nexport { useCreateMotionContext };\n","import { checkIfControllingVariants, isVariantLabel } from '../../render/utils/variants.js';\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 * as React from 'react';\nimport { forwardRef, useContext } from 'react';\nimport { useFeatures } from './features/use-features.js';\nimport { MotionConfigContext } from '../context/MotionConfigContext.js';\nimport { MotionContext } from '../context/MotionContext/index.js';\nimport { useVisualElement } from './utils/use-visual-element.js';\nimport { useMotionRef } from './utils/use-motion-ref.js';\nimport { useCreateMotionContext } from '../context/MotionContext/create.js';\nimport { loadFeatures } from './features/definitions.js';\nimport { isBrowser } from '../utils/is-browser.js';\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 *\n * @internal\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\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 isStatic = useContext(MotionConfigContext).isStatic;\n        var features = null;\n        /**\n         * Create the tree context. This is memoized and will only trigger renders\n         * when the current tree variant changes in static mode.\n         */\n        var context = useCreateMotionContext(props, isStatic);\n        /**\n         *\n         */\n        var visualState = useVisualState(props, isStatic);\n        if (!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, props, createVisualElement);\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             * TODO: The intention is to move these away from a React-centric to a\n             * VisualElement-centric lifecycle scheme.\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(React.Fragment, null,\n            React.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic)),\n            features));\n    }\n    return forwardRef(MotionComponent);\n}\n\nexport { createMotionComponent };\n","import { useCallback } from 'react';\nimport { isRefObject } from '../../utils/is-ref-object.js';\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.js';\nimport { isMotionValue } from '../../value/utils/is-motion-value.js';\nimport { buildHTMLStyles } from './utils/build-styles.js';\nimport { createHtmlRenderState } from './utils/create-render-state.js';\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, undefined, undefined, { 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)) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect = style.WebkitUserSelect = style.WebkitTouchCallout =\n            \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\" + (props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\nexport { copyRawValuesOnly, useHTMLProps, useStyle };\n","/**\n * A list of all valid MotionProps.\n *\n * @internalremarks\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    \"_layoutResetTransform\",\n    \"onLayoutAnimationComplete\",\n    \"onViewportBoxUpdate\",\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    \"_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]);\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.js';\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\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    var emotionIsPropValid_1 = require(\"@emotion/is-prop-valid\").default;\n    shouldForward = function (key) {\n        // Handle events explicitly as Emotion validates them all as true\n        if (key.startsWith(\"on\")) {\n            return !isValidMotionProp(key);\n        }\n        else {\n            return emotionIsPropValid_1(key);\n        }\n    };\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            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nexport { filterProps };\n","import { __assign } from 'tslib';\nimport { createHtmlRenderState } from '../../html/utils/create-render-state.js';\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.js';\nimport { buildSVGAttrs } from './utils/build-attrs.js';\nimport { createSvgRenderState } from './utils/create-render-state.js';\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, undefined, undefined, { 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.js';\nimport { filterProps } from './utils/filter-props.js';\nimport { isSVGComponent } from './utils/is-svg-component.js';\nimport { useSVGProps } from '../svg/use-props.js';\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, 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        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.js';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { checkIfControllingVariants, checkIfVariantNode, resolveVariantFromProps } from '../../render/utils/variants.js';\nimport { useConstant } from '../../utils/use-constant.js';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.js';\nimport { MotionContext } from '../../context/MotionContext/index.js';\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) { 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 () { return makeState(config, props, context, presenceContext); });\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 variantToSet = blockInitialAnimation || initial === false ? 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                values[key] = target[key];\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nexport { makeUseVisualState };\n","import { isCustomValue } from '../../utils/resolve-value.js';\nimport { isMotionValue } from './is-motion-value.js';\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 *\n * @internal\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 { renderSVG } from './utils/render.js';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';\nimport { makeUseVisualState } from '../../motion/utils/use-visual-state.js';\nimport { createSvgRenderState } from './utils/create-render-state.js';\nimport { buildSVGAttrs } from './utils/build-attrs.js';\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            if (isPath(instance)) {\n                renderState.totalPathLength = instance.getTotalLength();\n            }\n            buildSVGAttrs(renderState, latestValues, undefined, undefined, { enableHardwareAcceleration: false }, props.transformTemplate);\n            // TODO: Replace with direct assignment\n            renderSVG(instance, renderState);\n        },\n    }),\n};\nfunction isPath(element) {\n    return element.tagName === \"path\";\n}\n\nexport { svgMotionConfig };\n","import { makeUseVisualState } from '../../motion/utils/use-visual-state.js';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';\nimport { createHtmlRenderState } from './utils/create-render-state.js';\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nexport { htmlMotionConfig };\n","import { createMotionProxy } from './motion-proxy.js';\nimport { createDomMotionConfig } from './utils/create-config.js';\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nexport { m };\n","import { createMotionComponent } from '../../motion/index.js';\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    /**\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.js';\nimport { createUseRender } from '../use-render.js';\nimport { svgMotionConfig } from '../../svg/config-motion.js';\nimport { htmlMotionConfig } from '../../html/config-motion.js';\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement) {\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,\n        Component: Component });\n}\n\nexport { createDomMotionConfig };\n","var isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n","var createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\n        \"layout\",\n        \"layoutId\",\n        \"drag\",\n        \"_layoutResetTransform\",\n    ]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\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    layoutAnimation: createDefinition([\"layout\", \"layoutId\"]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        var Component = features[key];\n        if (Component !== null)\n            featureDefinitions[key].Component = Component;\n    }\n}\n\nexport { featureDefinitions, loadFeatures };\n","var valueScaleCorrection = {};\n/**\n * @internal\n */\nfunction addScaleCorrection(correctors) {\n    for (var key in correctors) {\n        valueScaleCorrection[key] = correctors[key];\n    }\n}\n\nexport { addScaleCorrection, valueScaleCorrection };\n","var isBrowser = typeof window !== \"undefined\";\n\nexport { isBrowser };\n","import { __assign } from 'tslib';\nimport { clamp } from '../utils.js';\n\nvar number = {\n    test: function (v) { return typeof v === 'number'; },\n    parse: parseFloat,\n    transform: function (v) { return v; },\n};\nvar alpha = __assign(__assign({}, number), { transform: clamp(0, 1) });\nvar scale = __assign(__assign({}, number), { default: 1 });\n\nexport { alpha, number, scale };\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.js';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.js';\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","import { useContext, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { useConstant } from '../../utils/use-constant.js';\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 useOpaqueId when released in React\n    var id = useUniqueId();\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}\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useUniqueId = function () { return useConstant(incrementId); };\n\nexport { isPresent, useIsPresent, usePresence };\n","import { sortTransformProps } from './transform.js';\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 += (translateAlias[key] || key) + \"(\" + 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 originX + \" \" + originY + \" \" + 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 { valueScaleCorrection } from '../../dom/projection/scale-correction.js';\nimport { buildTransform, buildTransformOrigin } from './build-transform.js';\nimport { isCSSVariable } from '../../dom/utils/is-css-variable.js';\nimport { isTransformProp, isTransformOriginProp } from './transform.js';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.js';\nimport { numberValueTypes } from '../../dom/value-types/number.js';\n\nfunction buildHTMLStyles(state, latestValues, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin) {\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            /**\n             * If layout projection is on, and we need to perform scale correction for this\n             * value type, perform it.\n             */\n            if ((projection === null || projection === void 0 ? void 0 : projection.isHydrated) &&\n                (layoutState === null || layoutState === void 0 ? void 0 : layoutState.isHydrated) &&\n                valueScaleCorrection[key]) {\n                var correctedValue = valueScaleCorrection[key].process(value, layoutState, projection);\n                /**\n                 * Scale-correctable values can define a number of other values to break\n                 * down into. For instance borderRadius needs applying to borderBottomLeftRadius etc\n                 */\n                var applyTo = valueScaleCorrection[key].applyTo;\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        style[applyTo[i]] = correctedValue;\n                    }\n                }\n                else {\n                    style[key] = correctedValue;\n                }\n            }\n            else {\n                style[key] = valueAsType;\n            }\n        }\n    }\n    if (layoutState &&\n        projection &&\n        buildProjectionTransform &&\n        buildProjectionTransformOrigin) {\n        style.transform = buildProjectionTransform(layoutState.deltaFinal, layoutState.treeScale, hasTransform ? transform : undefined);\n        if (transformTemplate) {\n            style.transform = transformTemplate(transform, style.transform);\n        }\n        style.transformOrigin = buildProjectionTransformOrigin(layoutState);\n    }\n    else {\n        if (hasTransform) {\n            style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n        }\n        if (hasTransformOrigin) {\n            style.transformOrigin = buildTransformOrigin(transformOrigin);\n        }\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 pxOriginX + \" \" + pxOriginY;\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from 'style-value-types';\n\n// Convert a progress 0-1 to a pixels value based on the provided length\nvar progressToPixels = function (progress, length) {\n    return px.transform(progress * length);\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, totalLength, 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    // 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] = progressToPixels(-offset, totalLength);\n    // Build the dash array\n    var pathLength = progressToPixels(length, totalLength);\n    var pathSpacing = progressToPixels(spacing, totalLength);\n    attrs[keys.array] = pathLength + \" \" + pathSpacing;\n}\n\nexport { buildSVGPath };\n","import { __rest } from 'tslib';\nimport { buildHTMLStyles } from '../../html/utils/build-styles.js';\nimport { calcSVGTransformOrigin } from './transform-origin.js';\nimport { buildSVGPath } from './path.js';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin) {\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, projection, layoutState, options, transformTemplate, buildProjectionTransform, buildProjectionTransformOrigin);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions, totalPathLength = state.totalPathLength;\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 measured\n    if (totalPathLength !== undefined && pathLength !== undefined) {\n        buildSVGPath(attrs, totalPathLength, 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.js';\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","function isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\nexport { isRefObject };\n","import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.js';\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nexport { isCustomValue, resolveFinalValueInKeyframes };\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 { valueScaleCorrection } from '../../render/dom/projection/scale-correction.js';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.js';\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            (!!valueScaleCorrection[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","function renderHTML(element, _a) {\n    var style = _a.style, vars = _a.vars;\n    // Directly assign style into the Element's style prop. In tests Object.assign is the\n    // fastest way to assign styles.\n    Object.assign(element.style, style);\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]);\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.js';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.js';\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.js';\nimport { renderHTML } from '../../html/utils/render.js';\nimport { camelCaseAttributes } from './camel-case-attrs.js';\n\nfunction renderSVG(element, renderState) {\n    renderHTML(element, renderState);\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 { __assign } from 'tslib';\nimport { number } from 'style-value-types';\n\nvar int = __assign(__assign({}, number), { transform: Math.round });\n\nexport { int };\n","import { px, degrees, scale, alpha, progressPercentage } from 'style-value-types';\nimport { int } from './type-int.js';\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    radius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    size: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    // Transform props\n    rotate: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale: scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n\nexport { numberValueTypes };\n","import { __assign } from 'tslib';\nimport { isString } from '../utils.js';\n\nvar createUnitType = function (unit) { return ({\n    test: function (v) {\n        return isString(v) && v.endsWith(unit) && v.split(' ').length === 1;\n    },\n    parse: parseFloat,\n    transform: function (v) { return \"\" + v + unit; },\n}); };\nvar degrees = createUnitType('deg');\nvar percent = createUnitType('%');\nvar px = createUnitType('px');\nvar vh = createUnitType('vh');\nvar vw = createUnitType('vw');\nvar progressPercentage = __assign(__assign({}, percent), { parse: function (v) { return percent.parse(v) / 100; }, transform: function (v) { return percent.transform(v * 100); } });\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || from);\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","var clamp = function (min, max) { return function (v) {\n    return Math.max(Math.min(v, max), min);\n}; };\nvar sanitize = function (v) { return (v % 1 ? Number(v.toFixed(5)) : v); };\nvar floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nvar colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))/gi;\nvar singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))$/i;\nfunction isString(v) {\n    return typeof v === 'string';\n}\n\nexport { clamp, colorRegex, floatRegex, isString, sanitize, singleColorRegex };\n","var warning = function () { };\r\nvar invariant = function () { };\r\nif (process.env.NODE_ENV !== 'production') {\r\n    warning = function (check, message) {\r\n        if (!check && typeof console !== 'undefined') {\r\n            console.warn(message);\r\n        }\r\n    };\r\n    invariant = function (check, message) {\r\n        if (!check) {\r\n            throw new Error(message);\r\n        }\r\n    };\r\n}\n\nexport { invariant, warning };\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    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    return typeof definition === \"function\"\n        ? definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity)\n        : 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"],"sourceRoot":""}