{"version":3,"file":"128.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"],"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\", } = {}) {\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        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    if (namedEasings[definition])\n        return namedEasings[definition];\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] = 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        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, } = 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        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]) === \"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)\n        ? easing[wrap(0, easing.length, i)]\n        : 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"],"names":["Animation","constructor","output","keyframes","easing","duration","initialDuration","delay","endDelay","repeat","offset","direction","this","startTime","rate","t","cancelTimestamp","totalDuration","playState","finished","Promise","resolve","reject","custom","createAnimation","updateDuration","interpolate$1","input","length","remainder","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","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"],"sourceRoot":""}