{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/context/PresenceContext.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/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/utils.js","webpack:///./node_modules/style-value-types/dist/es/numbers/units.js","webpack:///./node_modules/hey-listen/dist/hey-listen.es.js","webpack:///./node_modules/framer-motion/dist/es/render/utils/variants.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-constant.js","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/transform.js"],"names":["PresenceContext","isKeyframesTarget","v","Array","isArray","createDefinition","propNames","isEnabled","props","some","name","featureDefinitions","measureLayout","animation","exit","drag","focus","hover","tap","pan","layoutAnimation","loadFeatures","features","key","Component","valueScaleCorrection","addScaleCorrection","correctors","isBrowser","window","number","test","parse","parseFloat","transform","alpha","scale","default","LazyContext","strict","isAnimationControls","start","scrapeMotionValuesFromProps","style","newValues","usePresence","context","isPresent","onExitComplete","register","id","useUniqueId","counter","incrementId","translateAlias","x","y","z","transformPerspective","getValueAsType","value","type","buildHTMLStyles","state","latestValues","projection","layoutState","options","transformTemplate","buildProjectionTransform","buildProjectionTransformOrigin","_a","vars","transformKeys","transformOrigin","length","hasTransform","hasTransformOrigin","transformIsNone","valueType","valueAsType","push","isHydrated","correctedValue","process","applyTo","num","i","deltaFinal","treeScale","undefined","_b","transformIsDefault","_c","enableHardwareAcceleration","_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","attrs","dimensions","totalPathLength","width","height","calcSVGTransformOrigin","totalLength","spacing","useDashCase","keys","buildSVGPath","lowercaseSVGElements","isSVGComponent","includes","indexOf","isCustomValue","Boolean","mix","toValue","resolveFinalValueInKeyframes","isCSSVariable","startsWith","isForcedMotionValue","layout","layoutId","renderHTML","element","Object","assign","setProperty","camelCaseAttributes","Set","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","toUpperCase","renderSVG","renderState","setAttribute","has","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","clamp","min","max","sanitize","Number","toFixed","floatRegex","colorRegex","singleColorRegex","isString","createUnitType","unit","endsWith","split","degrees","percent","px","vh","vw","progressPercentage","warning","invariant","isVariantLabels","isVariantLabel","resolveVariantFromProps","definition","custom","currentValues","currentVelocity","variants","resolveVariant","visualElement","getProps","current","forEachValue","get","getCurrent","velocity","getVelocity","checkIfControllingVariants","animate","initial","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","useConstant","init","ref","transformAxes","transformProps","sortTransformProps","a","b","forEach","operationKey","axesKey","transformPropSet","isTransformProp","transformOriginProps","isTransformOriginProp"],"mappings":"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","file":"3-6d10a298f1c01ce0215b.js","sourcesContent":["import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\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","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","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","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","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","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","/**\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"],"sourceRoot":""}