{"version":3,"file":"310.js","mappings":"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","sources":["webpack://silverstripe-base/./node_modules/@motionone/animation/dist/Animation.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/interpolate.es.js","webpack://silverstripe-base/./node_modules/@motionone/easing/dist/cubic-bezier.es.js","webpack://silverstripe-base/./node_modules/@motionone/easing/dist/steps.es.js","webpack://silverstripe-base/./node_modules/@motionone/animation/dist/utils/easing.es.js","webpack://silverstripe-base/./node_modules/@motionone/types/dist/MotionValue.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/data.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/transforms.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/css-var.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/feature-detection.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/easing.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/get-style-name.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/style.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/animate-style.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/get-unit.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/controls.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/keyframes.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/options.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/stop-animation.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/gestures/in-view.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/utils/resolve-elements.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/utils/stagger.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/array.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/clamp.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/defaults.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/wrap.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/easing.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-cubic-bezier.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-easing-generator.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-easing-list.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-function.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-number.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-string.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/mix.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/noop.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/offset.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/progress.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/time.es.js","webpack://silverstripe-base/./node_modules/hey-listen/dist/hey-listen.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/index.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/create-animate.es.js","webpack://silverstripe-base/./node_modules/motion/dist/animate.es.js"],"sourcesContent":["import { noopReturn, defaults, isEasingGenerator, isEasingList, interpolate } from '@motionone/utils';\nimport { getEasingFunction } from './utils/easing.es.js';\n\nclass Animation {\n    constructor(output, keyframes = [0, 1], { easing, duration: initialDuration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, offset, direction = \"normal\", autoplay = true, } = {}) {\n        this.startTime = null;\n        this.rate = 1;\n        this.t = 0;\n        this.cancelTimestamp = null;\n        this.easing = noopReturn;\n        this.duration = 0;\n        this.totalDuration = 0;\n        this.repeat = 0;\n        this.playState = \"idle\";\n        this.finished = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n        easing = easing || defaults.easing;\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes);\n            easing = custom.easing;\n            keyframes = custom.keyframes || keyframes;\n            initialDuration = custom.duration || initialDuration;\n        }\n        this.repeat = repeat;\n        this.easing = isEasingList(easing) ? noopReturn : getEasingFunction(easing);\n        this.updateDuration(initialDuration);\n        const interpolate$1 = interpolate(keyframes, offset, isEasingList(easing) ? easing.map(getEasingFunction) : noopReturn);\n        this.tick = (timestamp) => {\n            var _a;\n            // TODO: Temporary fix for OptionsResolver typing\n            delay = delay;\n            let t = 0;\n            if (this.pauseTime !== undefined) {\n                t = this.pauseTime;\n            }\n            else {\n                t = (timestamp - this.startTime) * this.rate;\n            }\n            this.t = t;\n            // Convert to seconds\n            t /= 1000;\n            // Rebase on delay\n            t = Math.max(t - delay, 0);\n            /**\n             * If this animation has finished, set the current time\n             * to the total duration.\n             */\n            if (this.playState === \"finished\" && this.pauseTime === undefined) {\n                t = this.totalDuration;\n            }\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = t / this.duration;\n            // TODO progress += iterationStart\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            iterationProgress === 1 && currentIteration--;\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const iterationIsOdd = currentIteration % 2;\n            if (direction === \"reverse\" ||\n                (direction === \"alternate\" && iterationIsOdd) ||\n                (direction === \"alternate-reverse\" && !iterationIsOdd)) {\n                iterationProgress = 1 - iterationProgress;\n            }\n            const p = t >= this.totalDuration ? 1 : Math.min(iterationProgress, 1);\n            const latest = interpolate$1(this.easing(p));\n            output(latest);\n            const isAnimationFinished = this.pauseTime === undefined &&\n                (this.playState === \"finished\" || t >= this.totalDuration + endDelay);\n            if (isAnimationFinished) {\n                this.playState = \"finished\";\n                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, latest);\n            }\n            else if (this.playState !== \"idle\") {\n                this.frameRequestId = requestAnimationFrame(this.tick);\n            }\n        };\n        if (autoplay)\n            this.play();\n    }\n    play() {\n        const now = performance.now();\n        this.playState = \"running\";\n        if (this.pauseTime !== undefined) {\n            this.startTime = now - this.pauseTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = now;\n        }\n        this.cancelTimestamp = this.startTime;\n        this.pauseTime = undefined;\n        this.frameRequestId = requestAnimationFrame(this.tick);\n    }\n    pause() {\n        this.playState = \"paused\";\n        this.pauseTime = this.t;\n    }\n    finish() {\n        this.playState = \"finished\";\n        this.tick(0);\n    }\n    stop() {\n        var _a;\n        this.playState = \"idle\";\n        if (this.frameRequestId !== undefined) {\n            cancelAnimationFrame(this.frameRequestId);\n        }\n        (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, false);\n    }\n    cancel() {\n        this.stop();\n        this.tick(this.cancelTimestamp);\n    }\n    reverse() {\n        this.rate *= -1;\n    }\n    commitStyles() { }\n    updateDuration(duration) {\n        this.duration = duration;\n        this.totalDuration = duration * (this.repeat + 1);\n    }\n    get currentTime() {\n        return this.t;\n    }\n    set currentTime(t) {\n        if (this.pauseTime !== undefined || this.rate === 0) {\n            this.pauseTime = t;\n        }\n        else {\n            this.startTime = performance.now() - t / this.rate;\n        }\n    }\n    get playbackRate() {\n        return this.rate;\n    }\n    set playbackRate(rate) {\n        this.rate = rate;\n    }\n}\n\nexport { Animation };\n","import { mix } from './mix.es.js';\nimport { noopReturn } from './noop.es.js';\nimport { fillOffset, defaultOffset } from './offset.es.js';\nimport { progress } from './progress.es.js';\nimport { getEasingForSegment } from './easing.es.js';\nimport { clamp } from './clamp.es.js';\n\nfunction interpolate(output, input = defaultOffset(output.length), easing = noopReturn) {\n    const length = output.length;\n    /**\n     * If the input length is lower than the output we\n     * fill the input to match. This currently assumes the input\n     * is an animation progress value so is a good candidate for\n     * moving outside the function.\n     */\n    const remainder = length - input.length;\n    remainder > 0 && fillOffset(input, remainder);\n    return (t) => {\n        let i = 0;\n        for (; i < length - 2; i++) {\n            if (t < input[i + 1])\n                break;\n        }\n        let progressInRange = clamp(0, 1, progress(input[i], input[i + 1], t));\n        const segmentEasing = getEasingForSegment(easing, i);\n        progressInRange = segmentEasing(progressInRange);\n        return mix(output[i], output[i + 1], progressInRange);\n    };\n}\n\nexport { interpolate };\n","import { noopReturn } from '@motionone/utils';\n\n/*\n  Bezier function generator\n\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) * t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noopReturn;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { clamp } from '@motionone/utils';\n\nconst steps = (steps, direction = \"end\") => (progress) => {\n    progress =\n        direction === \"end\"\n            ? Math.min(progress, 0.999)\n            : Math.max(progress, 0.001);\n    const expanded = progress * steps;\n    const rounded = direction === \"end\" ? Math.floor(expanded) : Math.ceil(expanded);\n    return clamp(0, 1, rounded / steps);\n};\n\nexport { steps };\n","import { cubicBezier, steps } from '@motionone/easing';\nimport { isFunction, isCubicBezier, noopReturn } from '@motionone/utils';\n\nconst namedEasings = {\n    ease: cubicBezier(0.25, 0.1, 0.25, 1.0),\n    \"ease-in\": cubicBezier(0.42, 0.0, 1.0, 1.0),\n    \"ease-in-out\": cubicBezier(0.42, 0.0, 0.58, 1.0),\n    \"ease-out\": cubicBezier(0.0, 0.0, 0.58, 1.0),\n};\nconst functionArgsRegex = /\\((.*?)\\)/;\nfunction getEasingFunction(definition) {\n    // If already an easing function, return\n    if (isFunction(definition))\n        return definition;\n    // If an easing curve definition, return bezier function\n    if (isCubicBezier(definition))\n        return cubicBezier(...definition);\n    // If we have a predefined easing function, return\n    const namedEasing = namedEasings[definition];\n    if (namedEasing)\n        return namedEasing;\n    // If this is a steps function, attempt to create easing curve\n    if (definition.startsWith(\"steps\")) {\n        const args = functionArgsRegex.exec(definition);\n        if (args) {\n            const argsArray = args[1].split(\",\");\n            return steps(parseFloat(argsArray[0]), argsArray[1].trim());\n        }\n    }\n    return noopReturn;\n}\n\nexport { getEasingFunction };\n","/**\n * The MotionValue tracks the state of a single animatable\n * value. Currently, updatedAt and current are unused. The\n * long term idea is to use this to minimise the number\n * of DOM reads, and to abstract the DOM interactions here.\n */\nclass MotionValue {\n    setAnimation(animation) {\n        this.animation = animation;\n        animation === null || animation === void 0 ? void 0 : animation.finished.then(() => this.clearAnimation()).catch(() => { });\n    }\n    clearAnimation() {\n        this.animation = this.generator = undefined;\n    }\n}\n\nexport { MotionValue };\n","import { MotionValue } from '@motionone/types';\n\nconst data = new WeakMap();\nfunction getAnimationData(element) {\n    if (!data.has(element)) {\n        data.set(element, {\n            transforms: [],\n            values: new Map(),\n        });\n    }\n    return data.get(element);\n}\nfunction getMotionValue(motionValues, name) {\n    if (!motionValues.has(name)) {\n        motionValues.set(name, new MotionValue());\n    }\n    return motionValues.get(name);\n}\n\nexport { getAnimationData, getMotionValue };\n","import { noopReturn, addUniqueItem } from '@motionone/utils';\nimport { getAnimationData } from '../data.es.js';\n\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 */\nconst axes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nconst order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\nconst transformAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n};\nconst rotation = {\n    syntax: \"<angle>\",\n    initialValue: \"0deg\",\n    toDefaultUnit: (v) => v + \"deg\",\n};\nconst baseTransformProperties = {\n    translate: {\n        syntax: \"<length-percentage>\",\n        initialValue: \"0px\",\n        toDefaultUnit: (v) => v + \"px\",\n    },\n    rotate: rotation,\n    scale: {\n        syntax: \"<number>\",\n        initialValue: 1,\n        toDefaultUnit: noopReturn,\n    },\n    skew: rotation,\n};\nconst transformDefinitions = new Map();\nconst asTransformCssVar = (name) => `--motion-${name}`;\n/**\n * Generate a list of every possible transform key\n */\nconst transforms = [\"x\", \"y\", \"z\"];\norder.forEach((name) => {\n    axes.forEach((axis) => {\n        transforms.push(name + axis);\n        transformDefinitions.set(asTransformCssVar(name + axis), baseTransformProperties[name]);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nconst compareTransformOrder = (a, b) => transforms.indexOf(a) - transforms.indexOf(b);\n/**\n * Provide a quick way to check if a string is the name of a transform\n */\nconst transformLookup = new Set(transforms);\nconst isTransform = (name) => transformLookup.has(name);\nconst addTransformToElement = (element, name) => {\n    // Map x to translateX etc\n    if (transformAlias[name])\n        name = transformAlias[name];\n    const { transforms } = getAnimationData(element);\n    addUniqueItem(transforms, name);\n    /**\n     * TODO: An optimisation here could be to cache the transform in element data\n     * and only update if this has changed.\n     */\n    element.style.transform = buildTransformTemplate(transforms);\n};\nconst buildTransformTemplate = (transforms) => transforms\n    .sort(compareTransformOrder)\n    .reduce(transformListToString, \"\")\n    .trim();\nconst transformListToString = (template, name) => `${template} ${name}(var(${asTransformCssVar(name)}))`;\n\nexport { addTransformToElement, asTransformCssVar, axes, buildTransformTemplate, compareTransformOrder, isTransform, transformAlias, transformDefinitions };\n","import { transformDefinitions } from './transforms.es.js';\n\nconst isCssVar = (name) => name.startsWith(\"--\");\nconst registeredProperties = new Set();\nfunction registerCssVariable(name) {\n    if (registeredProperties.has(name))\n        return;\n    registeredProperties.add(name);\n    try {\n        const { syntax, initialValue } = transformDefinitions.has(name)\n            ? transformDefinitions.get(name)\n            : {};\n        CSS.registerProperty({\n            name,\n            inherits: false,\n            syntax,\n            initialValue,\n        });\n    }\n    catch (e) { }\n}\n\nexport { isCssVar, registerCssVariable, registeredProperties };\n","const testAnimation = (keyframes, options) => document.createElement(\"div\").animate(keyframes, options);\nconst featureTests = {\n    cssRegisterProperty: () => typeof CSS !== \"undefined\" &&\n        Object.hasOwnProperty.call(CSS, \"registerProperty\"),\n    waapi: () => Object.hasOwnProperty.call(Element.prototype, \"animate\"),\n    partialKeyframes: () => {\n        try {\n            testAnimation({ opacity: [1] });\n        }\n        catch (e) {\n            return false;\n        }\n        return true;\n    },\n    finished: () => Boolean(testAnimation({ opacity: [0, 1] }, { duration: 0.001 }).finished),\n    linearEasing: () => {\n        try {\n            testAnimation({ opacity: 0 }, { easing: \"linear(0, 1)\" });\n        }\n        catch (e) {\n            return false;\n        }\n        return true;\n    },\n};\nconst results = {};\nconst supports = {};\nfor (const key in featureTests) {\n    supports[key] = () => {\n        if (results[key] === undefined)\n            results[key] =\n                featureTests[key]();\n        return results[key];\n    };\n}\n\nexport { supports };\n","import { isFunction, defaults, isCubicBezier, progress } from '@motionone/utils';\nimport { supports } from './feature-detection.es.js';\n\n// Create a linear easing point for every x second\nconst resolution = 0.015;\nconst generateLinearEasingPoints = (easing, duration) => {\n    let points = \"\";\n    const numPoints = Math.round(duration / resolution);\n    for (let i = 0; i < numPoints; i++) {\n        points += easing(progress(0, numPoints - 1, i)) + \", \";\n    }\n    return points.substring(0, points.length - 2);\n};\nconst convertEasing = (easing, duration) => {\n    if (isFunction(easing)) {\n        return supports.linearEasing()\n            ? `linear(${generateLinearEasingPoints(easing, duration)})`\n            : defaults.easing;\n    }\n    else {\n        return isCubicBezier(easing) ? cubicBezierAsString(easing) : easing;\n    }\n};\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\n\nexport { convertEasing, cubicBezierAsString, generateLinearEasingPoints };\n","import { isTransform, asTransformCssVar, transformAlias } from './transforms.es.js';\n\nfunction getStyleName(key) {\n    if (transformAlias[key])\n        key = transformAlias[key];\n    return isTransform(key) ? asTransformCssVar(key) : key;\n}\n\nexport { getStyleName };\n","import { isCssVar } from './utils/css-var.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { transformDefinitions } from './utils/transforms.es.js';\n\nconst style = {\n    get: (element, name) => {\n        name = getStyleName(name);\n        let value = isCssVar(name)\n            ? element.style.getPropertyValue(name)\n            : getComputedStyle(element)[name];\n        // TODO Decide if value can be 0\n        if (!value && value !== 0) {\n            const definition = transformDefinitions.get(name);\n            if (definition)\n                value = definition.initialValue;\n        }\n        return value;\n    },\n    set: (element, name, value) => {\n        name = getStyleName(name);\n        if (isCssVar(name)) {\n            element.style.setProperty(name, value);\n        }\n        else {\n            element.style[name] = value;\n        }\n    },\n};\n\nexport { style };\n","import { getAnimationData, getMotionValue } from './data.es.js';\nimport { isCssVar, registerCssVariable } from './utils/css-var.es.js';\nimport { defaults, isEasingGenerator, isFunction, isEasingList, isNumber, time, noop } from '@motionone/utils';\nimport { isTransform, addTransformToElement, transformDefinitions } from './utils/transforms.es.js';\nimport { convertEasing } from './utils/easing.es.js';\nimport { supports } from './utils/feature-detection.es.js';\nimport { hydrateKeyframes, keyframesList } from './utils/keyframes.es.js';\nimport { style } from './style.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { stopAnimation } from './utils/stop-animation.es.js';\nimport { getUnitConverter } from './utils/get-unit.es.js';\n\nfunction getDevToolsRecord() {\n    return window.__MOTION_DEV_TOOLS_RECORD;\n}\nfunction animateStyle(element, key, keyframesDefinition, options = {}, AnimationPolyfill) {\n    const record = getDevToolsRecord();\n    const isRecording = options.record !== false && record;\n    let animation;\n    let { duration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, easing = defaults.easing, persist = false, direction, offset, allowWebkitAcceleration = false, autoplay = true, } = options;\n    const data = getAnimationData(element);\n    const valueIsTransform = isTransform(key);\n    let canAnimateNatively = supports.waapi();\n    /**\n     * If this is an individual transform, we need to map its\n     * key to a CSS variable and update the element's transform style\n     */\n    valueIsTransform && addTransformToElement(element, key);\n    const name = getStyleName(key);\n    const motionValue = getMotionValue(data.values, name);\n    /**\n     * Get definition of value, this will be used to convert numerical\n     * keyframes into the default value type.\n     */\n    const definition = transformDefinitions.get(name);\n    /**\n     * Stop the current animation, if any. Because this will trigger\n     * commitStyles (DOM writes) and we might later trigger DOM reads,\n     * this is fired now and we return a factory function to create\n     * the actual animation that can get called in batch,\n     */\n    stopAnimation(motionValue.animation, !(isEasingGenerator(easing) && motionValue.generator) &&\n        options.record !== false);\n    /**\n     * Batchable factory function containing all DOM reads.\n     */\n    return () => {\n        const readInitialValue = () => { var _a, _b; return (_b = (_a = style.get(element, name)) !== null && _a !== void 0 ? _a : definition === null || definition === void 0 ? void 0 : definition.initialValue) !== null && _b !== void 0 ? _b : 0; };\n        /**\n         * Replace null values with the previous keyframe value, or read\n         * it from the DOM if it's the first keyframe.\n         */\n        let keyframes = hydrateKeyframes(keyframesList(keyframesDefinition), readInitialValue);\n        /**\n         * Detect unit type of keyframes.\n         */\n        const toUnit = getUnitConverter(keyframes, definition);\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes, key !== \"opacity\", readInitialValue, name, motionValue);\n            easing = custom.easing;\n            keyframes = custom.keyframes || keyframes;\n            duration = custom.duration || duration;\n        }\n        /**\n         * If this is a CSS variable we need to register it with the browser\n         * before it can be animated natively. We also set it with setProperty\n         * rather than directly onto the element.style object.\n         */\n        if (isCssVar(name)) {\n            if (supports.cssRegisterProperty()) {\n                registerCssVariable(name);\n            }\n            else {\n                canAnimateNatively = false;\n            }\n        }\n        /**\n         * If we've been passed a custom easing function, and this browser\n         * does **not** support linear() easing, and the value is a transform\n         * (and thus a pure number) we can still support the custom easing\n         * by falling back to the animation polyfill.\n         */\n        if (valueIsTransform &&\n            !supports.linearEasing() &&\n            (isFunction(easing) || (isEasingList(easing) && easing.some(isFunction)))) {\n            canAnimateNatively = false;\n        }\n        /**\n         * If we can animate this value with WAAPI, do so.\n         */\n        if (canAnimateNatively) {\n            /**\n             * Convert numbers to default value types. Currently this only supports\n             * transforms but it could also support other value types.\n             */\n            if (definition) {\n                keyframes = keyframes.map((value) => isNumber(value) ? definition.toDefaultUnit(value) : value);\n            }\n            /**\n             * If this browser doesn't support partial/implicit keyframes we need to\n             * explicitly provide one.\n             */\n            if (keyframes.length === 1 &&\n                (!supports.partialKeyframes() || isRecording)) {\n                keyframes.unshift(readInitialValue());\n            }\n            const animationOptions = {\n                delay: time.ms(delay),\n                duration: time.ms(duration),\n                endDelay: time.ms(endDelay),\n                easing: !isEasingList(easing)\n                    ? convertEasing(easing, duration)\n                    : undefined,\n                direction,\n                iterations: repeat + 1,\n                fill: \"both\",\n            };\n            animation = element.animate({\n                [name]: keyframes,\n                offset,\n                easing: isEasingList(easing)\n                    ? easing.map((thisEasing) => convertEasing(thisEasing, duration))\n                    : undefined,\n            }, animationOptions);\n            /**\n             * Polyfill finished Promise in browsers that don't support it\n             */\n            if (!animation.finished) {\n                animation.finished = new Promise((resolve, reject) => {\n                    animation.onfinish = resolve;\n                    animation.oncancel = reject;\n                });\n            }\n            const target = keyframes[keyframes.length - 1];\n            animation.finished\n                .then(() => {\n                if (persist)\n                    return;\n                // Apply styles to target\n                style.set(element, name, target);\n                // Ensure fill modes don't persist\n                animation.cancel();\n            })\n                .catch(noop);\n            /**\n             * This forces Webkit to run animations on the main thread by exploiting\n             * this condition:\n             * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp?rev=281238#L1099\n             *\n             * This fixes Webkit's timing bugs, like accelerated animations falling\n             * out of sync with main thread animations and massive delays in starting\n             * accelerated animations in WKWebView.\n             */\n            if (!allowWebkitAcceleration)\n                animation.playbackRate = 1.000001;\n            /**\n             * If we can't animate the value natively then we can fallback to the numbers-only\n             * polyfill for transforms.\n             */\n        }\n        else if (AnimationPolyfill && valueIsTransform) {\n            /**\n             * If any keyframe is a string (because we measured it from the DOM), we need to convert\n             * it into a number before passing to the Animation polyfill.\n             */\n            keyframes = keyframes.map((value) => typeof value === \"string\" ? parseFloat(value) : value);\n            /**\n             * If we only have a single keyframe, we need to create an initial keyframe by reading\n             * the current value from the DOM.\n             */\n            if (keyframes.length === 1) {\n                keyframes.unshift(parseFloat(readInitialValue()));\n            }\n            animation = new AnimationPolyfill((latest) => {\n                style.set(element, name, toUnit ? toUnit(latest) : latest);\n            }, keyframes, Object.assign(Object.assign({}, options), { duration,\n                easing }));\n        }\n        else {\n            const target = keyframes[keyframes.length - 1];\n            style.set(element, name, definition && isNumber(target)\n                ? definition.toDefaultUnit(target)\n                : target);\n        }\n        if (isRecording) {\n            record(element, key, keyframes, {\n                duration,\n                delay: delay,\n                easing,\n                repeat,\n                offset,\n            }, \"motion-one\");\n        }\n        motionValue.setAnimation(animation);\n        if (animation && !autoplay)\n            animation.pause();\n        return animation;\n    };\n}\n\nexport { animateStyle };\n","import { noopReturn, isString } from '@motionone/utils';\n\nfunction getUnitConverter(keyframes, definition) {\n    var _a;\n    let toUnit = (definition === null || definition === void 0 ? void 0 : definition.toDefaultUnit) || noopReturn;\n    const finalKeyframe = keyframes[keyframes.length - 1];\n    if (isString(finalKeyframe)) {\n        const unit = ((_a = finalKeyframe.match(/(-?[\\d.]+)([a-z%]*)/)) === null || _a === void 0 ? void 0 : _a[2]) || \"\";\n        if (unit)\n            toUnit = (value) => value + unit;\n    }\n    return toUnit;\n}\n\nexport { getUnitConverter };\n","import { defaults, noop, time } from '@motionone/utils';\nimport { stopAnimation } from './stop-animation.es.js';\n\nconst createAnimation = (factory) => factory();\nconst withControls = (animationFactory, options, duration = defaults.duration) => {\n    return new Proxy({\n        animations: animationFactory.map(createAnimation).filter(Boolean),\n        duration,\n        options,\n    }, controls);\n};\n/**\n * TODO:\n * Currently this returns the first animation, ideally it would return\n * the first active animation.\n */\nconst getActiveAnimation = (state) => state.animations[0];\nconst controls = {\n    get: (target, key) => {\n        const activeAnimation = getActiveAnimation(target);\n        switch (key) {\n            case \"duration\":\n                return target.duration;\n            case \"currentTime\":\n                return time.s((activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) || 0);\n            case \"playbackRate\":\n            case \"playState\":\n                return activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key];\n            case \"finished\":\n                if (!target.finished) {\n                    target.finished = Promise.all(target.animations.map(selectFinished)).catch(noop);\n                }\n                return target.finished;\n            case \"stop\":\n                return () => {\n                    target.animations.forEach((animation) => stopAnimation(animation));\n                };\n            case \"forEachNative\":\n                /**\n                 * This is for internal use only, fire a callback for each\n                 * underlying animation.\n                 */\n                return (callback) => {\n                    target.animations.forEach((animation) => callback(animation, target));\n                };\n            default:\n                return typeof (activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) ===\n                    \"undefined\"\n                    ? undefined\n                    : () => target.animations.forEach((animation) => animation[key]());\n        }\n    },\n    set: (target, key, value) => {\n        switch (key) {\n            case \"currentTime\":\n                value = time.ms(value);\n            // Fall-through\n            case \"playbackRate\":\n                for (let i = 0; i < target.animations.length; i++) {\n                    target.animations[i][key] = value;\n                }\n                return true;\n        }\n        return false;\n    },\n};\nconst selectFinished = (animation) => animation.finished;\n\nexport { controls, withControls };\n","function hydrateKeyframes(keyframes, readInitialValue) {\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] === null) {\n            keyframes[i] = i ? keyframes[i - 1] : readInitialValue();\n        }\n    }\n    return keyframes;\n}\nconst keyframesList = (keyframes) => Array.isArray(keyframes) ? keyframes : [keyframes];\n\nexport { hydrateKeyframes, keyframesList };\n","const getOptions = (options, key) => \n/**\n * TODO: Make test for this\n * Always return a new object otherwise delay is overwritten by results of stagger\n * and this results in no stagger\n */\noptions[key] ? Object.assign(Object.assign({}, options), options[key]) : Object.assign({}, options);\n\nexport { getOptions };\n","function stopAnimation(animation, needsCommit = true) {\n    if (!animation || animation.playState === \"finished\")\n        return;\n    // Suppress error thrown by WAAPI\n    try {\n        if (animation.stop) {\n            animation.stop();\n        }\n        else {\n            needsCommit && animation.commitStyles();\n            animation.cancel();\n        }\n    }\n    catch (e) { }\n}\n\nexport { stopAnimation };\n","import { resolveElements } from '../utils/resolve-elements.es.js';\nimport { isFunction } from '@motionone/utils';\n\nconst thresholds = {\n    any: 0,\n    all: 1,\n};\nfunction inView(elementOrSelector, onStart, { root, margin: rootMargin, amount = \"any\" } = {}) {\n    /**\n     * If this browser doesn't support IntersectionObserver, return a dummy stop function.\n     * Default triggering of onStart is tricky - it could be used for starting/stopping\n     * videos, lazy loading content etc. We could provide an option to enable a fallback, or\n     * provide a fallback callback option.\n     */\n    if (typeof IntersectionObserver === \"undefined\") {\n        return () => { };\n    }\n    const elements = resolveElements(elementOrSelector);\n    const activeIntersections = new WeakMap();\n    const onIntersectionChange = (entries) => {\n        entries.forEach((entry) => {\n            const onEnd = activeIntersections.get(entry.target);\n            /**\n             * If there's no change to the intersection, we don't need to\n             * do anything here.\n             */\n            if (entry.isIntersecting === Boolean(onEnd))\n                return;\n            if (entry.isIntersecting) {\n                const newOnEnd = onStart(entry);\n                if (isFunction(newOnEnd)) {\n                    activeIntersections.set(entry.target, newOnEnd);\n                }\n                else {\n                    observer.unobserve(entry.target);\n                }\n            }\n            else if (onEnd) {\n                onEnd(entry);\n                activeIntersections.delete(entry.target);\n            }\n        });\n    };\n    const observer = new IntersectionObserver(onIntersectionChange, {\n        root,\n        rootMargin,\n        threshold: typeof amount === \"number\" ? amount : thresholds[amount],\n    });\n    elements.forEach((element) => observer.observe(element));\n    return () => observer.disconnect();\n}\n\nexport { inView };\n","function resolveElements(elements, selectorCache) {\n    var _a;\n    if (typeof elements === \"string\") {\n        if (selectorCache) {\n            (_a = selectorCache[elements]) !== null && _a !== void 0 ? _a : (selectorCache[elements] = document.querySelectorAll(elements));\n            elements = selectorCache[elements];\n        }\n        else {\n            elements = document.querySelectorAll(elements);\n        }\n    }\n    else if (elements instanceof Element) {\n        elements = [elements];\n    }\n    /**\n     * Return an empty array\n     */\n    return Array.from(elements || []);\n}\n\nexport { resolveElements };\n","import { isNumber, isFunction } from '@motionone/utils';\nimport { getEasingFunction } from '@motionone/animation';\n\nfunction stagger(duration = 0.1, { start = 0, from = 0, easing } = {}) {\n    return (i, total) => {\n        const fromIndex = isNumber(from) ? from : getFromIndex(from, total);\n        const distance = Math.abs(fromIndex - i);\n        let delay = duration * distance;\n        if (easing) {\n            const maxDelay = total * duration;\n            const easingFunction = getEasingFunction(easing);\n            delay = easingFunction(delay / maxDelay) * maxDelay;\n        }\n        return start + delay;\n    };\n}\nfunction getFromIndex(from, total) {\n    if (from === \"first\") {\n        return 0;\n    }\n    else {\n        const lastIndex = total - 1;\n        return from === \"last\" ? lastIndex : lastIndex / 2;\n    }\n}\nfunction resolveOption(option, i, total) {\n    return isFunction(option) ? option(i, total) : option;\n}\n\nexport { getFromIndex, resolveOption, stagger };\n","function addUniqueItem(array, item) {\n    array.indexOf(item) === -1 && array.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n\nexport { addUniqueItem, removeItem };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","const defaults = {\n    duration: 0.3,\n    delay: 0,\n    endDelay: 0,\n    repeat: 0,\n    easing: \"ease\",\n};\n\nexport { defaults };\n","const wrap = (min, max, v) => {\n    const rangeSize = max - min;\n    return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;\n};\n\nexport { wrap };\n","import { isEasingList } from './is-easing-list.es.js';\nimport { wrap } from './wrap.es.js';\n\nfunction getEasingForSegment(easing, i) {\n    return isEasingList(easing) ? easing[wrap(0, easing.length, i)] : easing;\n}\n\nexport { getEasingForSegment };\n","import { isNumber } from './is-number.es.js';\n\nconst isCubicBezier = (easing) => Array.isArray(easing) && isNumber(easing[0]);\n\nexport { isCubicBezier };\n","const isEasingGenerator = (easing) => typeof easing === \"object\" &&\n    Boolean(easing.createAnimation);\n\nexport { isEasingGenerator };\n","import { isNumber } from './is-number.es.js';\n\nconst isEasingList = (easing) => Array.isArray(easing) && !isNumber(easing[0]);\n\nexport { isEasingList };\n","const isFunction = (value) => typeof value === \"function\";\n\nexport { isFunction };\n","const isNumber = (value) => typeof value === \"number\";\n\nexport { isNumber };\n","const isString = (value) => typeof value === \"string\";\n\nexport { isString };\n","const mix = (min, max, progress) => -progress * min + progress * max + min;\n\nexport { mix };\n","const noop = () => { };\nconst noopReturn = (v) => v;\n\nexport { noop, noopReturn };\n","import { mix } from './mix.es.js';\nimport { progress } from './progress.es.js';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mix(min, 1, offsetProgress));\n    }\n}\nfunction defaultOffset(length) {\n    const offset = [0];\n    fillOffset(offset, length - 1);\n    return offset;\n}\n\nexport { defaultOffset, fillOffset };\n","const progress = (min, max, value) => max - min === 0 ? 1 : (value - min) / (max - min);\n\nexport { progress };\n","const time = {\n    ms: (seconds) => seconds * 1000,\n    s: (milliseconds) => milliseconds / 1000,\n};\n\nexport { time };\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","import { Animation } from '@motionone/animation';\nimport { createAnimate } from './create-animate.es.js';\n\nconst animate = createAnimate(Animation);\n\nexport { animate };\n","import { invariant } from 'hey-listen';\nimport { animateStyle } from './animate-style.es.js';\nimport { getOptions } from './utils/options.es.js';\nimport { resolveElements } from '../utils/resolve-elements.es.js';\nimport { withControls } from './utils/controls.es.js';\nimport { resolveOption } from '../utils/stagger.es.js';\n\nfunction createAnimate(AnimatePolyfill) {\n    return function animate(elements, keyframes, options = {}) {\n        elements = resolveElements(elements);\n        const numElements = elements.length;\n        invariant(Boolean(numElements), \"No valid element provided.\");\n        invariant(Boolean(keyframes), \"No keyframes defined.\");\n        /**\n         * Create and start new animations\n         */\n        const animationFactories = [];\n        for (let i = 0; i < numElements; i++) {\n            const element = elements[i];\n            for (const key in keyframes) {\n                const valueOptions = getOptions(options, key);\n                valueOptions.delay = resolveOption(valueOptions.delay, i, numElements);\n                const animation = animateStyle(element, key, keyframes[key], valueOptions, AnimatePolyfill);\n                animationFactories.push(animation);\n            }\n        }\n        return withControls(animationFactories, options, \n        /**\n         * TODO:\n         * If easing is set to spring or glide, duration will be dynamically\n         * generated. Ideally we would dynamically generate this from\n         * animation.effect.getComputedTiming().duration but this isn't\n         * supported in iOS13 or our number polyfill. Perhaps it's possible\n         * to Proxy animations returned from animateStyle that has duration\n         * as a getter.\n         */\n        options.duration);\n    };\n}\n\nexport { createAnimate };\n","import { animate as animate$1, withControls } from '@motionone/dom';\nimport { isFunction } from '@motionone/utils';\nimport { Animation } from '@motionone/animation';\n\nfunction animateProgress(target, options = {}) {\n    return withControls([\n        () => {\n            const animation = new Animation(target, [0, 1], options);\n            animation.finished.catch(() => { });\n            return animation;\n        },\n    ], options, options.duration);\n}\nfunction animate(target, keyframesOrOptions, options) {\n    const factory = isFunction(target) ? animateProgress : animate$1;\n    return factory(target, keyframesOrOptions, options);\n}\n\nexport { animate, animateProgress };\n"],"names":["Animation","constructor","output","keyframes","easing","duration","initialDuration","delay","endDelay","repeat","offset","direction","autoplay","this","startTime","rate","t","cancelTimestamp","totalDuration","playState","finished","Promise","resolve","reject","custom","createAnimation","updateDuration","interpolate$1","input","length","remainder","f","i","progressInRange","segmentEasing","interpolate","map","tick","timestamp","_a","undefined","pauseTime","Math","max","progress","currentIteration","floor","iterationProgress","iterationIsOdd","p","min","latest","call","frameRequestId","requestAnimationFrame","play","now","performance","pause","finish","stop","cancelAnimationFrame","cancel","reverse","commitStyles","currentTime","playbackRate","calcBezier","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","x","lowerBound","upperBound","currentX","currentT","abs","binarySubdivide","steps","expanded","rounded","ceil","namedEasings","ease","functionArgsRegex","getEasingFunction","definition","namedEasing","startsWith","args","exec","argsArray","split","parseFloat","trim","MotionValue","setAnimation","animation","then","clearAnimation","catch","generator","data","WeakMap","getAnimationData","element","has","set","transforms","values","Map","get","axes","transformAlias","y","z","rotation","syntax","initialValue","toDefaultUnit","v","baseTransformProperties","translate","rotate","scale","skew","transformDefinitions","asTransformCssVar","name","forEach","axis","push","compareTransformOrder","a","b","indexOf","transformLookup","Set","isTransform","addTransformToElement","style","transform","buildTransformTemplate","sort","reduce","transformListToString","template","isCssVar","registeredProperties","testAnimation","options","document","createElement","animate","featureTests","cssRegisterProperty","CSS","Object","hasOwnProperty","waapi","Element","prototype","partialKeyframes","opacity","e","Boolean","linearEasing","results","supports","key","convertEasing","points","numPoints","round","substring","generateLinearEasingPoints","cubicBezierAsString","c","d","getStyleName","value","getPropertyValue","getComputedStyle","setProperty","animateStyle","keyframesDefinition","AnimationPolyfill","record","window","__MOTION_DEV_TOOLS_RECORD","isRecording","persist","allowWebkitAcceleration","valueIsTransform","canAnimateNatively","motionValue","motionValues","getMotionValue","readInitialValue","_b","toUnit","finalKeyframe","unit","match","getUnitConverter","add","registerProperty","inherits","registerCssVariable","some","unshift","animationOptions","ms","iterations","fill","thisEasing","onfinish","oncancel","target","assign","factory","withControls","animationFactory","Proxy","animations","filter","controls","activeAnimation","s","all","selectFinished","callback","hydrateKeyframes","keyframesList","Array","isArray","getOptions","stopAnimation","needsCommit","thresholds","any","inView","elementOrSelector","onStart","root","margin","rootMargin","amount","IntersectionObserver","elements","activeIntersections","observer","entries","entry","onEnd","isIntersecting","newOnEnd","unobserve","delete","threshold","observe","disconnect","resolveElements","selectorCache","querySelectorAll","from","stagger","start","total","fromIndex","lastIndex","getFromIndex","distance","maxDelay","easingFunction","resolveOption","option","addUniqueItem","array","item","removeItem","arr","index","splice","clamp","defaults","wrap","rangeSize","getEasingForSegment","isCubicBezier","isEasingGenerator","isEasingList","isFunction","isNumber","isString","mix","noop","noopReturn","fillOffset","remaining","offsetProgress","defaultOffset","time","seconds","milliseconds","invariant","AnimatePolyfill","numElements","animationFactories","valueOptions","animateProgress","keyframesOrOptions"],"sourceRoot":""}