{"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: \"\",\n initialValue: \"0deg\",\n toDefaultUnit: (v) => v + \"deg\",\n};\nconst baseTransformProperties = {\n translate: {\n syntax: \"\",\n initialValue: \"0px\",\n toDefaultUnit: (v) => v + \"px\",\n },\n rotate: rotation,\n scale: {\n syntax: \"\",\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":""}