{"version":3,"file":"react/js/vendor.framer-motion@current-17e8d8c2.123a6f6f46fb5296cbf1.js","mappings":"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","sources":["webpack:///./node_modules/framer-motion/dist/es/value/index.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/color/hex.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/color/hsla.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/color/index.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/color/rgba.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/color/utils.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/complex/index.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/numbers/index.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/numbers/units.mjs","webpack:///./node_modules/framer-motion/dist/es/value/types/utils.mjs","webpack:///./node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","webpack:///./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack:///./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs"],"sourcesContent":["import { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    constructor(init, options = {}) {\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"11.2.10\";\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = null;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v, render = true) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev && this.events.change) {\n                this.events.change.notify(this.current);\n            }\n            // Update render subscribers\n            if (render && this.events.renderRequest) {\n                this.events.renderRequest.notify(this.current);\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n        if (this.canTrackVelocity === null && current !== undefined) {\n            this.canTrackVelocity = isFloat(this.current);\n        }\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v, render = true) {\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v, endAnimation = true) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        endAnimation && this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nfunction motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n\nexport { MotionValue, collectMotionValues, motionValue };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = \"\";\n    let g = \"\";\n    let b = \"\";\n    let a = \"\";\n    // If we have 6 characters, ie #FF0000\n    if (v.length > 5) {\n        r = v.substring(1, 3);\n        g = v.substring(3, 5);\n        b = v.substring(5, 7);\n        a = v.substring(7, 9);\n        // Or we have 3 characters, ie #F00\n    }\n    else {\n        r = v.substring(1, 2);\n        g = v.substring(2, 3);\n        b = v.substring(3, 4);\n        a = v.substring(4, 5);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString(\"#\"),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: isColorString(\"hsl\", \"hue\"),\n    parse: splitColor(\"hue\", \"saturation\", \"lightness\"),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return (\"hsla(\" +\n            Math.round(hue) +\n            \", \" +\n            percent.transform(sanitize(saturation)) +\n            \", \" +\n            percent.transform(sanitize(lightness)) +\n            \", \" +\n            sanitize(alpha.transform(alpha$1)) +\n            \")\");\n    },\n};\n\nexport { hsla };\n","import { isString } from '../utils.mjs';\nimport { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty(\"red\")\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { clamp } from '../../../utils/clamp.mjs';\nimport { number, alpha } from '../numbers/index.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = (v) => clamp(0, 255, v);\nconst rgbUnit = {\n    ...number,\n    transform: (v) => Math.round(clampRgbUnit(v)),\n};\nconst rgba = {\n    test: isColorString(\"rgb\", \"red\"),\n    parse: splitColor(\"red\", \"green\", \"blue\"),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => \"rgba(\" +\n        rgbUnit.transform(red) +\n        \", \" +\n        rgbUnit.transform(green) +\n        \", \" +\n        rgbUnit.transform(blue) +\n        \", \" +\n        sanitize(alpha.transform(alpha$1)) +\n        \")\",\n};\n\nexport { rgbUnit, rgba };\n","import { isString, singleColorRegex, floatRegex } from '../utils.mjs';\n\n/**\n * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,\n * but false if a number or multiple colors\n */\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /\\b([a-z-]*)\\(.*?\\)/gu;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n","import { color } from '../color/index.mjs';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.mjs';\n\nfunction test(v) {\n    var _a, _b;\n    return (isNaN(v) &&\n        isString(v) &&\n        (((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) +\n            (((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) >\n            0);\n}\nconst NUMBER_TOKEN = \"number\";\nconst COLOR_TOKEN = \"color\";\nconst VAR_TOKEN = \"var\";\nconst VAR_FUNCTION_TOKEN = \"var(\";\nconst SPLIT_TOKEN = \"${}\";\n// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`\nconst complexRegex = /var\\s*\\(\\s*--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)|#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\)|-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/giu;\nfunction analyseComplexValue(value) {\n    const originalValue = value.toString();\n    const values = [];\n    const indexes = {\n        color: [],\n        number: [],\n        var: [],\n    };\n    const types = [];\n    let i = 0;\n    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {\n        if (color.test(parsedValue)) {\n            indexes.color.push(i);\n            types.push(COLOR_TOKEN);\n            values.push(color.parse(parsedValue));\n        }\n        else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {\n            indexes.var.push(i);\n            types.push(VAR_TOKEN);\n            values.push(parsedValue);\n        }\n        else {\n            indexes.number.push(i);\n            types.push(NUMBER_TOKEN);\n            values.push(parseFloat(parsedValue));\n        }\n        ++i;\n        return SPLIT_TOKEN;\n    });\n    const split = tokenised.split(SPLIT_TOKEN);\n    return { values, split, indexes, types };\n}\nfunction parseComplexValue(v) {\n    return analyseComplexValue(v).values;\n}\nfunction createTransformer(source) {\n    const { split, types } = analyseComplexValue(source);\n    const numSections = split.length;\n    return (v) => {\n        let output = \"\";\n        for (let i = 0; i < numSections; i++) {\n            output += split[i];\n            if (v[i] !== undefined) {\n                const type = types[i];\n                if (type === NUMBER_TOKEN) {\n                    output += sanitize(v[i]);\n                }\n                else if (type === COLOR_TOKEN) {\n                    output += color.transform(v[i]);\n                }\n                else {\n                    output += v[i];\n                }\n            }\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === \"number\" ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parseComplexValue(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = {\n    test,\n    parse: parseComplexValue,\n    createTransformer,\n    getAnimatableNone,\n};\n\nexport { analyseComplexValue, complex };\n","import { clamp } from '../../../utils/clamp.mjs';\n\nconst number = {\n    test: (v) => typeof v === \"number\",\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = {\n    ...number,\n    transform: (v) => clamp(0, 1, v),\n};\nconst scale = {\n    ...number,\n    default: 1,\n};\n\nexport { alpha, number, scale };\n","import { isString } from '../utils.mjs';\n\nconst createUnitType = (unit) => ({\n    test: (v) => isString(v) && v.endsWith(unit) && v.split(\" \").length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = createUnitType(\"deg\");\nconst percent = createUnitType(\"%\");\nconst px = createUnitType(\"px\");\nconst vh = createUnitType(\"vh\");\nconst vw = createUnitType(\"vw\");\nconst progressPercentage = {\n    ...percent,\n    parse: (v) => percent.parse(v) / 100,\n    transform: (v) => percent.transform(v * 100),\n};\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n","/**\n * TODO: When we move from string as a source of truth to data models\n * everything in this folder should probably be referred to as models vs types\n */\n// If this number is a decimal, make it just five decimal places\n// to avoid exponents\nconst sanitize = (v) => Math.round(v * 100000) / 100000;\nconst floatRegex = /-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/gu;\nconst colorRegex = /(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))/giu;\nconst singleColorRegex = /^(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))$/iu;\nfunction isString(v) {\n    return typeof v === \"string\";\n}\n\nexport { colorRegex, floatRegex, isString, sanitize, singleColorRegex };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n","const isMotionValue = (value) => Boolean(value && value.getVelocity);\n\nexport { isMotionValue };\n","import { isCustomValue } from '../../utils/resolve-value.mjs';\nimport { isMotionValue } from './is-motion-value.mjs';\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    const unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nexport { resolveMotionValue };\n"],"names":["collectMotionValues","current","undefined","MotionValue","constructor","init","options","this","version","canTrackVelocity","events","updateAndNotify","v","render","currentTime","now","updatedAt","setPrevFrameValue","prev","setCurrent","change","notify","renderRequest","hasAnimated","owner","value","isNaN","parseFloat","prevFrameValue","prevUpdatedAt","onChange","subscription","on","eventName","callback","unsubscribe","add","read","getSize","stop","clearListeners","eventManagers","clear","attach","passiveEffect","stopPassiveEffect","set","setWithVelocity","delta","jump","endAnimation","get","push","getPrevious","getVelocity","Math","min","start","startAnimation","Promise","resolve","animation","animationStart","then","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","motionValue","hex","test","parse","r","g","b","a","length","substring","red","parseInt","green","blue","alpha","transform","hsla","hue","saturation","lightness","alpha$1","round","color","hasOwnProperty","rgbUnit","clampRgbUnit","rgba","isColorString","type","testProp","Boolean","startsWith","Object","prototype","call","splitColor","aName","bName","cName","c","match","maxDefaults","Set","applyDefaultFilter","name","slice","split","number","unit","replace","defaultValue","has","functionRegex","filter","getAnimatableNone","functions","map","join","NUMBER_TOKEN","COLOR_TOKEN","VAR_TOKEN","VAR_FUNCTION_TOKEN","SPLIT_TOKEN","complexRegex","analyseComplexValue","originalValue","toString","values","indexes","var","types","i","parsedValue","parseComplexValue","createTransformer","source","numSections","output","convertNumbersToZero","complex","_a","_b","parsed","transformer","scale","default","createUnitType","endsWith","degrees","percent","px","vh","vw","progressPercentage","sanitize","floatRegex","colorRegex","singleColorRegex","isString","isWillChangeMotionValue","isMotionValue","resolveMotionValue","unwrappedValue","toValue"],"sourceRoot":""}