{"version":3,"file":"938a2da7-a129a2651d03fa7e57b8.js","mappings":"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","sources":["webpack://batmaid-www/../node_modules/framer-motion/dist/cjs/index-legacy-c80d64bf.js"],"sourcesContent":["'use strict';\n\nconst isBrowser = typeof document !== \"undefined\";\n\n/**\n * Convert camelCase to dash-case properties.\n */\nconst camelToDash = str => str.replace(/([a-z])([A-Z])/g, \"$1-$2\").toLowerCase();\nconst optimizedAppearDataId = \"framerAppearId\";\nconst optimizedAppearDataAttribute = \"data-\" + camelToDash(optimizedAppearDataId);\nfunction isRefObject(ref) {\n  return typeof ref === \"object\" && Object.prototype.hasOwnProperty.call(ref, \"current\");\n}\n\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n  return typeof v === \"string\" || Array.isArray(v);\n}\nfunction isAnimationControls(v) {\n  return typeof v === \"object\" && typeof v.start === \"function\";\n}\nconst variantPriorityOrder = [\"animate\", \"whileInView\", \"whileFocus\", \"whileHover\", \"whileTap\", \"whileDrag\", \"exit\"];\nconst variantProps = [\"initial\", ...variantPriorityOrder];\nfunction isControllingVariants(props) {\n  return isAnimationControls(props.animate) || variantProps.some(name => isVariantLabel(props[name]));\n}\nfunction isVariantNode(props) {\n  return Boolean(isControllingVariants(props) || props.variants);\n}\nconst featureProps = {\n  animation: [\"animate\", \"variants\", \"whileHover\", \"whileTap\", \"exit\", \"whileInView\", \"whileFocus\", \"whileDrag\"],\n  exit: [\"exit\"],\n  drag: [\"drag\", \"dragControls\"],\n  focus: [\"whileFocus\"],\n  hover: [\"whileHover\", \"onHoverStart\", \"onHoverEnd\"],\n  tap: [\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"],\n  pan: [\"onPan\", \"onPanStart\", \"onPanSessionStart\", \"onPanEnd\"],\n  inView: [\"whileInView\", \"onViewportEnter\", \"onViewportLeave\"],\n  layout: [\"layout\", \"layoutId\"]\n};\nconst featureDefinitions = {};\nfor (const key in featureProps) {\n  featureDefinitions[key] = {\n    isEnabled: props => featureProps[key].some(name => !!props[name])\n  };\n}\nconst scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n  Object.assign(scaleCorrectors, correctors);\n}\n\n/**\n * Generate a list of every possible transform key.\n */\nconst transformPropOrder = [\"transformPerspective\", \"x\", \"y\", \"z\", \"translateX\", \"translateY\", \"translateZ\", \"scale\", \"scaleX\", \"scaleY\", \"rotate\", \"rotateX\", \"rotateY\", \"rotateZ\", \"skew\", \"skewX\", \"skewY\"];\n/**\n * A quick lookup for transform props.\n */\nconst transformProps = new Set(transformPropOrder);\nfunction isForcedMotionValue(key, _ref) {\n  let {\n    layout,\n    layoutId\n  } = _ref;\n  return transformProps.has(key) || key.startsWith(\"origin\") || (layout || layoutId !== undefined) && (!!scaleCorrectors[key] || key === \"opacity\");\n}\nconst isMotionValue = value => Boolean(value && value.getVelocity);\nconst translateAlias = {\n  x: \"translateX\",\n  y: \"translateY\",\n  z: \"translateZ\",\n  transformPerspective: \"perspective\"\n};\nconst numTransforms = transformPropOrder.length;\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(transform, _ref2, transformIsDefault, transformTemplate) {\n  let {\n    enableHardwareAcceleration = true,\n    allowTransformNone = true\n  } = _ref2;\n  // The transform string we're going to build into.\n  let transformString = \"\";\n  /**\n   * Loop over all possible transforms in order, adding the ones that\n   * are present to the transform string.\n   */\n  for (let i = 0; i < numTransforms; i++) {\n    const key = transformPropOrder[i];\n    if (transform[key] !== undefined) {\n      const transformName = translateAlias[key] || key;\n      transformString += `${transformName}(${transform[key]}) `;\n    }\n  }\n  if (enableHardwareAcceleration && !transform.z) {\n    transformString += \"translateZ(0)\";\n  }\n  transformString = transformString.trim();\n  // If we have a custom `transform` template, pass our transform values and\n  // generated transformString to that before returning\n  if (transformTemplate) {\n    transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n  } else if (allowTransformNone && transformIsDefault) {\n    transformString = \"none\";\n  }\n  return transformString;\n}\nconst checkStringStartsWith = token => key => typeof key === \"string\" && key.startsWith(token);\nconst isCSSVariableName = checkStringStartsWith(\"--\");\nconst isCSSVariableToken = checkStringStartsWith(\"var(--\");\nconst cssVariableRegex = /var\\s*\\(\\s*--[\\w-]+(\\s*,\\s*(?:(?:[^)(]|\\((?:[^)(]+|\\([^)(]*\\))*\\))*)+)?\\s*\\)/g;\n\n/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nconst getValueAsType = (value, type) => {\n  return type && typeof value === \"number\" ? type.transform(value) : value;\n};\nconst clamp = (min, max, v) => Math.min(Math.max(v, min), max);\nconst number = {\n  test: v => typeof v === \"number\",\n  parse: parseFloat,\n  transform: v => v\n};\nconst alpha = {\n  ...number,\n  transform: v => clamp(0, 1, v)\n};\nconst scale = {\n  ...number,\n  default: 1\n};\n\n/**\n * TODO: When we move from string as a source of truth to data models\n * everything in this folder should probably be referred to as models vs types\n */\n// If this number is a decimal, make it just five decimal places\n// to avoid exponents\nconst sanitize = v => Math.round(v * 100000) / 100000;\nconst floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nconst colorRegex = /(#[0-9a-f]{3,8}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2}(-?[\\d\\.]+%?)\\s*[\\,\\/]?\\s*[\\d\\.]*%?\\))/gi;\nconst singleColorRegex = /^(#[0-9a-f]{3,8}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2}(-?[\\d\\.]+%?)\\s*[\\,\\/]?\\s*[\\d\\.]*%?\\))$/i;\nfunction isString(v) {\n  return typeof v === \"string\";\n}\nconst createUnitType = unit => ({\n  test: v => isString(v) && v.endsWith(unit) && v.split(\" \").length === 1,\n  parse: parseFloat,\n  transform: v => `${v}${unit}`\n});\nconst degrees = createUnitType(\"deg\");\nconst percent = createUnitType(\"%\");\nconst px = createUnitType(\"px\");\nconst vh = createUnitType(\"vh\");\nconst vw = createUnitType(\"vw\");\nconst progressPercentage = {\n  ...percent,\n  parse: v => percent.parse(v) / 100,\n  transform: v => percent.transform(v * 100)\n};\nconst int = {\n  ...number,\n  transform: Math.round\n};\nconst numberValueTypes = {\n  // Border props\n  borderWidth: px,\n  borderTopWidth: px,\n  borderRightWidth: px,\n  borderBottomWidth: px,\n  borderLeftWidth: px,\n  borderRadius: px,\n  radius: px,\n  borderTopLeftRadius: px,\n  borderTopRightRadius: px,\n  borderBottomRightRadius: px,\n  borderBottomLeftRadius: px,\n  // Positioning props\n  width: px,\n  maxWidth: px,\n  height: px,\n  maxHeight: px,\n  size: px,\n  top: px,\n  right: px,\n  bottom: px,\n  left: px,\n  // Spacing props\n  padding: px,\n  paddingTop: px,\n  paddingRight: px,\n  paddingBottom: px,\n  paddingLeft: px,\n  margin: px,\n  marginTop: px,\n  marginRight: px,\n  marginBottom: px,\n  marginLeft: px,\n  // Transform props\n  rotate: degrees,\n  rotateX: degrees,\n  rotateY: degrees,\n  rotateZ: degrees,\n  scale,\n  scaleX: scale,\n  scaleY: scale,\n  scaleZ: scale,\n  skew: degrees,\n  skewX: degrees,\n  skewY: degrees,\n  distance: px,\n  translateX: px,\n  translateY: px,\n  translateZ: px,\n  x: px,\n  y: px,\n  z: px,\n  perspective: px,\n  transformPerspective: px,\n  opacity: alpha,\n  originX: progressPercentage,\n  originY: progressPercentage,\n  originZ: px,\n  // Misc\n  zIndex: int,\n  // SVG\n  fillOpacity: alpha,\n  strokeOpacity: alpha,\n  numOctaves: int\n};\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n  const {\n    style,\n    vars,\n    transform,\n    transformOrigin\n  } = state;\n  // Track whether we encounter any transform or transformOrigin values.\n  let hasTransform = false;\n  let hasTransformOrigin = false;\n  // Does the calculated transform essentially equal \"none\"?\n  let transformIsNone = true;\n  /**\n   * Loop over all our latest animated values and decide whether to handle them\n   * as a style or CSS variable.\n   *\n   * Transforms and transform origins are kept seperately for further processing.\n   */\n  for (const key in latestValues) {\n    const value = latestValues[key];\n    /**\n     * If this is a CSS variable we don't do any further processing.\n     */\n    if (isCSSVariableName(key)) {\n      vars[key] = value;\n      continue;\n    }\n    // Convert the value to its default value type, ie 0 -> \"0px\"\n    const valueType = numberValueTypes[key];\n    const valueAsType = getValueAsType(value, valueType);\n    if (transformProps.has(key)) {\n      // If this is a transform, flag to enable further transform processing\n      hasTransform = true;\n      transform[key] = valueAsType;\n      // If we already know we have a non-default transform, early return\n      if (!transformIsNone) continue;\n      // Otherwise check to see if this is a default transform\n      if (value !== (valueType.default || 0)) transformIsNone = false;\n    } else if (key.startsWith(\"origin\")) {\n      // If this is a transform origin, flag and enable further transform-origin processing\n      hasTransformOrigin = true;\n      transformOrigin[key] = valueAsType;\n    } else {\n      style[key] = valueAsType;\n    }\n  }\n  if (!latestValues.transform) {\n    if (hasTransform || transformTemplate) {\n      style.transform = buildTransform(state.transform, options, transformIsNone, transformTemplate);\n    } else if (style.transform) {\n      /**\n       * If we have previously created a transform but currently don't have any,\n       * reset transform style to none.\n       */\n      style.transform = \"none\";\n    }\n  }\n  /**\n   * Build a transformOrigin style. Uses the same defaults as the browser for\n   * undefined origins.\n   */\n  if (hasTransformOrigin) {\n    const {\n      originX = \"50%\",\n      originY = \"50%\",\n      originZ = 0\n    } = transformOrigin;\n    style.transformOrigin = `${originX} ${originY} ${originZ}`;\n  }\n}\nfunction calcOrigin(origin, offset, size) {\n  return typeof origin === \"string\" ? origin : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n  const pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n  const pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n  return `${pxOriginX} ${pxOriginY}`;\n}\nconst dashKeys = {\n  offset: \"stroke-dashoffset\",\n  array: \"stroke-dasharray\"\n};\nconst camelKeys = {\n  offset: \"strokeDashoffset\",\n  array: \"strokeDasharray\"\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length) {\n  let spacing = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n  let offset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  let useDashCase = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;\n  // Normalise path length by setting SVG attribute pathLength to 1\n  attrs.pathLength = 1;\n  // We use dash case when setting attributes directly to the DOM node and camel case\n  // when defining props on a React component.\n  const keys = useDashCase ? dashKeys : camelKeys;\n  // Build the dash offset\n  attrs[keys.offset] = px.transform(-offset);\n  // Build the dash array\n  const pathLength = px.transform(length);\n  const pathSpacing = px.transform(spacing);\n  attrs[keys.array] = `${pathLength} ${pathSpacing}`;\n}\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _ref3, options, isSVGTag, transformTemplate) {\n  let {\n    attrX,\n    attrY,\n    attrScale,\n    originX,\n    originY,\n    pathLength,\n    pathSpacing = 1,\n    pathOffset = 0,\n    // This is object creation, which we try to avoid per-frame.\n    ...latest\n  } = _ref3;\n  buildHTMLStyles(state, latest, options, transformTemplate);\n  /**\n   * For svg tags we just want to make sure viewBox is animatable and treat all the styles\n   * as normal HTML tags.\n   */\n  if (isSVGTag) {\n    if (state.style.viewBox) {\n      state.attrs.viewBox = state.style.viewBox;\n    }\n    return;\n  }\n  state.attrs = state.style;\n  state.style = {};\n  const {\n    attrs,\n    style,\n    dimensions\n  } = state;\n  /**\n   * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n   * and copy it into style.\n   */\n  if (attrs.transform) {\n    if (dimensions) style.transform = attrs.transform;\n    delete attrs.transform;\n  }\n  // Parse transformOrigin\n  if (dimensions && (originX !== undefined || originY !== undefined || style.transform)) {\n    style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n  }\n  // Render attrX/attrY/attrScale as attributes\n  if (attrX !== undefined) attrs.x = attrX;\n  if (attrY !== undefined) attrs.y = attrY;\n  if (attrScale !== undefined) attrs.scale = attrScale;\n  // Build SVG path if one has been defined\n  if (pathLength !== undefined) {\n    buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n  }\n}\nconst isSVGTag = tag => typeof tag === \"string\" && tag.toLowerCase() === \"svg\";\nfunction renderHTML(element, _ref4, styleProp, projection) {\n  let {\n    style,\n    vars\n  } = _ref4;\n  Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n  // Loop over any CSS variables and assign those.\n  for (const key in vars) {\n    element.style.setProperty(key, vars[key]);\n  }\n}\n\n/**\n * A set of attribute names that are always read/written as camel case.\n */\nconst camelCaseAttributes = new Set([\"baseFrequency\", \"diffuseConstant\", \"kernelMatrix\", \"kernelUnitLength\", \"keySplines\", \"keyTimes\", \"limitingConeAngle\", \"markerHeight\", \"markerWidth\", \"numOctaves\", \"targetX\", \"targetY\", \"surfaceScale\", \"specularConstant\", \"specularExponent\", \"stdDeviation\", \"tableValues\", \"viewBox\", \"gradientTransform\", \"pathLength\", \"startOffset\", \"textLength\", \"lengthAdjust\"]);\nfunction renderSVG(element, renderState, _styleProp, projection) {\n  renderHTML(element, renderState, undefined, projection);\n  for (const key in renderState.attrs) {\n    element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n  }\n}\nfunction scrapeMotionValuesFromProps$1(props, prevProps) {\n  const {\n    style\n  } = props;\n  const newValues = {};\n  for (const key in style) {\n    if (isMotionValue(style[key]) || prevProps.style && isMotionValue(prevProps.style[key]) || isForcedMotionValue(key, props)) {\n      newValues[key] = style[key];\n    }\n  }\n  return newValues;\n}\nfunction scrapeMotionValuesFromProps(props, prevProps) {\n  const newValues = scrapeMotionValuesFromProps$1(props, prevProps);\n  for (const key in props) {\n    if (isMotionValue(props[key]) || isMotionValue(prevProps[key])) {\n      const targetKey = transformPropOrder.indexOf(key) !== -1 ? \"attr\" + key.charAt(0).toUpperCase() + key.substring(1) : key;\n      newValues[targetKey] = props[key];\n    }\n  }\n  return newValues;\n}\nfunction resolveVariantFromProps(props, definition, custom) {\n  let currentValues = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  let currentVelocity = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};\n  /**\n   * If the variant definition is a function, resolve.\n   */\n  if (typeof definition === \"function\") {\n    definition = definition(custom !== undefined ? custom : props.custom, currentValues, currentVelocity);\n  }\n  /**\n   * If the variant definition is a variant label, or\n   * the function returned a variant label, resolve.\n   */\n  if (typeof definition === \"string\") {\n    definition = props.variants && props.variants[definition];\n  }\n  /**\n   * At this point we've resolved both functions and variant labels,\n   * but the resolved variant label might itself have been a function.\n   * If so, resolve. This can only have returned a valid target object.\n   */\n  if (typeof definition === \"function\") {\n    definition = definition(custom !== undefined ? custom : props.custom, currentValues, currentVelocity);\n  }\n  return definition;\n}\nconst isKeyframesTarget = v => {\n  return Array.isArray(v);\n};\nconst isCustomValue = v => {\n  return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nconst resolveFinalValueInKeyframes = v => {\n  // TODO maybe throw if v.length - 1 is placeholder token?\n  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\nconst noop = any => any;\nclass Queue {\n  constructor() {\n    this.order = [];\n    this.scheduled = new Set();\n  }\n  add(process) {\n    if (!this.scheduled.has(process)) {\n      this.scheduled.add(process);\n      this.order.push(process);\n      return true;\n    }\n  }\n  remove(process) {\n    const index = this.order.indexOf(process);\n    if (index !== -1) {\n      this.order.splice(index, 1);\n      this.scheduled.delete(process);\n    }\n  }\n  clear() {\n    this.order.length = 0;\n    this.scheduled.clear();\n  }\n}\nfunction createRenderStep(runNextFrame) {\n  /**\n   * We create and reuse two queues, one to queue jobs for the current frame\n   * and one for the next. We reuse to avoid triggering GC after x frames.\n   */\n  let thisFrame = new Queue();\n  let nextFrame = new Queue();\n  let numToRun = 0;\n  /**\n   * Track whether we're currently processing jobs in this step. This way\n   * we can decide whether to schedule new jobs for this frame or next.\n   */\n  let isProcessing = false;\n  let flushNextFrame = false;\n  /**\n   * A set of processes which were marked keepAlive when scheduled.\n   */\n  const toKeepAlive = new WeakSet();\n  const step = {\n    /**\n     * Schedule a process to run on the next frame.\n     */\n    schedule: function (callback) {\n      let keepAlive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      let immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n      const addToCurrentFrame = immediate && isProcessing;\n      const queue = addToCurrentFrame ? thisFrame : nextFrame;\n      if (keepAlive) toKeepAlive.add(callback);\n      if (queue.add(callback) && addToCurrentFrame && isProcessing) {\n        // If we're adding it to the currently running queue, update its measured size\n        numToRun = thisFrame.order.length;\n      }\n      return callback;\n    },\n    /**\n     * Cancel the provided callback from running on the next frame.\n     */\n    cancel: callback => {\n      nextFrame.remove(callback);\n      toKeepAlive.delete(callback);\n    },\n    /**\n     * Execute all schedule callbacks.\n     */\n    process: frameData => {\n      /**\n       * If we're already processing we've probably been triggered by a flushSync\n       * inside an existing process. Instead of executing, mark flushNextFrame\n       * as true and ensure we flush the following frame at the end of this one.\n       */\n      if (isProcessing) {\n        flushNextFrame = true;\n        return;\n      }\n      isProcessing = true;\n      [thisFrame, nextFrame] = [nextFrame, thisFrame];\n      // Clear the next frame queue\n      nextFrame.clear();\n      // Execute this frame\n      numToRun = thisFrame.order.length;\n      if (numToRun) {\n        for (let i = 0; i < numToRun; i++) {\n          const callback = thisFrame.order[i];\n          callback(frameData);\n          if (toKeepAlive.has(callback)) {\n            step.schedule(callback);\n            runNextFrame();\n          }\n        }\n      }\n      isProcessing = false;\n      if (flushNextFrame) {\n        flushNextFrame = false;\n        step.process(frameData);\n      }\n    }\n  };\n  return step;\n}\nconst stepsOrder = [\"prepare\", \"read\", \"update\", \"preRender\", \"render\", \"postRender\"];\nconst maxElapsed$1 = 40;\nfunction createRenderBatcher(scheduleNextBatch, allowKeepAlive) {\n  let runNextFrame = false;\n  let useDefaultElapsed = true;\n  const state = {\n    delta: 0,\n    timestamp: 0,\n    isProcessing: false\n  };\n  const steps = stepsOrder.reduce((acc, key) => {\n    acc[key] = createRenderStep(() => runNextFrame = true);\n    return acc;\n  }, {});\n  const processStep = stepId => steps[stepId].process(state);\n  const processBatch = () => {\n    const timestamp = performance.now();\n    runNextFrame = false;\n    state.delta = useDefaultElapsed ? 1000 / 60 : Math.max(Math.min(timestamp - state.timestamp, maxElapsed$1), 1);\n    state.timestamp = timestamp;\n    state.isProcessing = true;\n    stepsOrder.forEach(processStep);\n    state.isProcessing = false;\n    if (runNextFrame && allowKeepAlive) {\n      useDefaultElapsed = false;\n      scheduleNextBatch(processBatch);\n    }\n  };\n  const wake = () => {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!state.isProcessing) {\n      scheduleNextBatch(processBatch);\n    }\n  };\n  const schedule = stepsOrder.reduce((acc, key) => {\n    const step = steps[key];\n    acc[key] = function (process) {\n      let keepAlive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      let immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n      if (!runNextFrame) wake();\n      return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n  }, {});\n  const cancel = process => stepsOrder.forEach(key => steps[key].cancel(process));\n  return {\n    schedule,\n    cancel,\n    state,\n    steps\n  };\n}\nconst {\n  schedule: frame,\n  cancel: cancelFrame,\n  state: frameData,\n  steps\n} = createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true);\n\n/**\n * Pipe\n * Compose other transformers to run linearily\n * pipe(min(20), max(40))\n * @param  {...functions} transformers\n * @return {function}\n */\nconst combineFunctions = (a, b) => v => b(a(v));\nconst pipe = function () {\n  for (var _len = arguments.length, transformers = new Array(_len), _key = 0; _key < _len; _key++) {\n    transformers[_key] = arguments[_key];\n  }\n  return transformers.reduce(combineFunctions);\n};\n\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n  const current = {};\n  visualElement.values.forEach((value, key) => current[key] = value.get());\n  return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n  const velocity = {};\n  visualElement.values.forEach((value, key) => velocity[key] = value.getVelocity());\n  return velocity;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n  const props = visualElement.getProps();\n  return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\nexports.warning = noop;\nexports.invariant = noop;\nif (process.env.NODE_ENV !== \"production\") {\n  exports.warning = (check, message) => {\n    if (!check && typeof console !== \"undefined\") {\n      console.warn(message);\n    }\n  };\n  exports.invariant = (check, message) => {\n    if (!check) {\n      throw new Error(message);\n    }\n  };\n}\n\n/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nconst secondsToMilliseconds = seconds => seconds * 1000;\nconst millisecondsToSeconds = milliseconds => milliseconds / 1000;\nconst instantAnimationState = {\n  current: false\n};\nconst isBezierDefinition = easing => Array.isArray(easing) && typeof easing[0] === \"number\";\nfunction isWaapiSupportedEasing(easing) {\n  return Boolean(!easing || typeof easing === \"string\" && supportedWaapiEasing[easing] || isBezierDefinition(easing) || Array.isArray(easing) && easing.every(isWaapiSupportedEasing));\n}\nconst cubicBezierAsString = _ref5 => {\n  let [a, b, c, d] = _ref5;\n  return `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\n};\nconst supportedWaapiEasing = {\n  linear: \"linear\",\n  ease: \"ease\",\n  easeIn: \"ease-in\",\n  easeOut: \"ease-out\",\n  easeInOut: \"ease-in-out\",\n  circIn: cubicBezierAsString([0, 0.65, 0.55, 1]),\n  circOut: cubicBezierAsString([0.55, 0, 1, 0.45]),\n  backIn: cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),\n  backOut: cubicBezierAsString([0.33, 1.53, 0.69, 0.99])\n};\nfunction mapEasingToNativeEasing(easing) {\n  if (!easing) return undefined;\n  return isBezierDefinition(easing) ? cubicBezierAsString(easing) : Array.isArray(easing) ? easing.map(mapEasingToNativeEasing) : supportedWaapiEasing[easing];\n}\nfunction animateStyle(element, valueName, keyframes) {\n  let {\n    delay = 0,\n    duration,\n    repeat = 0,\n    repeatType = \"loop\",\n    ease,\n    times\n  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  const keyframeOptions = {\n    [valueName]: keyframes\n  };\n  if (times) keyframeOptions.offset = times;\n  const easing = mapEasingToNativeEasing(ease);\n  /**\n   * If this is an easing array, apply to keyframes, not animation as a whole\n   */\n  if (Array.isArray(easing)) keyframeOptions.easing = easing;\n  return element.animate(keyframeOptions, {\n    delay,\n    duration,\n    easing: !Array.isArray(easing) ? easing : \"linear\",\n    fill: \"both\",\n    iterations: repeat + 1,\n    direction: repeatType === \"reverse\" ? \"alternate\" : \"normal\"\n  });\n}\nfunction getFinalKeyframe(keyframes, _ref6) {\n  let {\n    repeat,\n    repeatType = \"loop\"\n  } = _ref6;\n  const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1 ? 0 : keyframes.length - 1;\n  return keyframes[index];\n}\n\n/*\n  Bezier function generator\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  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  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    } else {\n      lowerBound = currentT;\n    }\n  } while (Math.abs(currentX) > subdivisionPrecision && ++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) return noop;\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}\nconst easeIn = cubicBezier(0.42, 0, 1, 1);\nconst easeOut = cubicBezier(0, 0, 0.58, 1);\nconst easeInOut = cubicBezier(0.42, 0, 0.58, 1);\nconst isEasingArray = ease => {\n  return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\n// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = easing => p => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\n// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = easing => p => 1 - easing(1 - p);\nconst circIn = p => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circIn);\nconst backOut = cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = reverseEasing(backOut);\nconst backInOut = mirrorEasing(backIn);\nconst anticipate = p => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\nconst easingLookup = {\n  linear: noop,\n  easeIn,\n  easeInOut,\n  easeOut,\n  circIn,\n  circInOut,\n  circOut,\n  backIn,\n  backInOut,\n  backOut,\n  anticipate\n};\nconst easingDefinitionToFunction = definition => {\n  if (Array.isArray(definition)) {\n    // If cubic bezier definition, create bezier curve\n    exports.invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);\n    const [x1, y1, x2, y2] = definition;\n    return cubicBezier(x1, y1, x2, y2);\n  } else if (typeof definition === \"string\") {\n    // Else lookup from table\n    exports.invariant(easingLookup[definition] !== undefined, `Invalid easing type '${definition}'`);\n    return easingLookup[definition];\n  }\n  return definition;\n};\n\n/**\n * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,\n * but false if a number or multiple colors\n */\nconst isColorString = (type, testProp) => v => {\n  return Boolean(isString(v) && singleColorRegex.test(v) && v.startsWith(type) || testProp && Object.prototype.hasOwnProperty.call(v, testProp));\n};\nconst splitColor = (aName, bName, cName) => v => {\n  if (!isString(v)) return v;\n  const [a, b, c, alpha] = v.match(floatRegex);\n  return {\n    [aName]: parseFloat(a),\n    [bName]: parseFloat(b),\n    [cName]: parseFloat(c),\n    alpha: alpha !== undefined ? parseFloat(alpha) : 1\n  };\n};\nconst clampRgbUnit = v => clamp(0, 255, v);\nconst rgbUnit = {\n  ...number,\n  transform: v => Math.round(clampRgbUnit(v))\n};\nconst rgba = {\n  test: isColorString(\"rgb\", \"red\"),\n  parse: splitColor(\"red\", \"green\", \"blue\"),\n  transform: _ref7 => {\n    let {\n      red,\n      green,\n      blue,\n      alpha: alpha$1 = 1\n    } = _ref7;\n    return \"rgba(\" + rgbUnit.transform(red) + \", \" + rgbUnit.transform(green) + \", \" + rgbUnit.transform(blue) + \", \" + sanitize(alpha.transform(alpha$1)) + \")\";\n  }\n};\nfunction parseHex(v) {\n  let r = \"\";\n  let g = \"\";\n  let b = \"\";\n  let a = \"\";\n  // If we have 6 characters, ie #FF0000\n  if (v.length > 5) {\n    r = v.substring(1, 3);\n    g = v.substring(3, 5);\n    b = v.substring(5, 7);\n    a = v.substring(7, 9);\n    // Or we have 3 characters, ie #F00\n  } else {\n    r = v.substring(1, 2);\n    g = v.substring(2, 3);\n    b = v.substring(3, 4);\n    a = v.substring(4, 5);\n    r += r;\n    g += g;\n    b += b;\n    a += a;\n  }\n  return {\n    red: parseInt(r, 16),\n    green: parseInt(g, 16),\n    blue: parseInt(b, 16),\n    alpha: a ? parseInt(a, 16) / 255 : 1\n  };\n}\nconst hex = {\n  test: isColorString(\"#\"),\n  parse: parseHex,\n  transform: rgba.transform\n};\nconst hsla = {\n  test: isColorString(\"hsl\", \"hue\"),\n  parse: splitColor(\"hue\", \"saturation\", \"lightness\"),\n  transform: _ref8 => {\n    let {\n      hue,\n      saturation,\n      lightness,\n      alpha: alpha$1 = 1\n    } = _ref8;\n    return \"hsla(\" + Math.round(hue) + \", \" + percent.transform(sanitize(saturation)) + \", \" + percent.transform(sanitize(lightness)) + \", \" + sanitize(alpha.transform(alpha$1)) + \")\";\n  }\n};\nconst color = {\n  test: v => rgba.test(v) || hex.test(v) || hsla.test(v),\n  parse: v => {\n    if (rgba.test(v)) {\n      return rgba.parse(v);\n    } else if (hsla.test(v)) {\n      return hsla.parse(v);\n    } else {\n      return hex.parse(v);\n    }\n  },\n  transform: v => {\n    return isString(v) ? v : v.hasOwnProperty(\"red\") ? rgba.transform(v) : hsla.transform(v);\n  }\n};\n\n/*\n  Value in range from progress\n\n  Given a lower limit and an upper limit, we return the value within\n  that range as expressed by progress (usually a number from 0 to 1)\n\n  So progress = 0.5 would change\n\n  from -------- to\n\n  to\n\n  from ---- to\n\n  E.g. from = 10, to = 20, progress = 0.5 => 15\n\n  @param [number]: Lower limit of range\n  @param [number]: Upper limit of range\n  @param [number]: The progress between lower and upper limits expressed 0-1\n  @return [number]: Value as calculated from progress within range (not limited within range)\n*/\nconst mix = (from, to, progress) => -progress * from + progress * to + from;\n\n// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n  if (t < 0) t += 1;\n  if (t > 1) t -= 1;\n  if (t < 1 / 6) return p + (q - p) * 6 * t;\n  if (t < 1 / 2) return q;\n  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n  return p;\n}\nfunction hslaToRgba(_ref9) {\n  let {\n    hue,\n    saturation,\n    lightness,\n    alpha\n  } = _ref9;\n  hue /= 360;\n  saturation /= 100;\n  lightness /= 100;\n  let red = 0;\n  let green = 0;\n  let blue = 0;\n  if (!saturation) {\n    red = green = blue = lightness;\n  } else {\n    const q = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;\n    const p = 2 * lightness - q;\n    red = hueToRgb(p, q, hue + 1 / 3);\n    green = hueToRgb(p, q, hue);\n    blue = hueToRgb(p, q, hue - 1 / 3);\n  }\n  return {\n    red: Math.round(red * 255),\n    green: Math.round(green * 255),\n    blue: Math.round(blue * 255),\n    alpha\n  };\n}\n\n// Linear color space blending\n// Explained https://www.youtube.com/watch?v=LKnqECcg6Gw\n// Demonstrated http://codepen.io/osublake/pen/xGVVaN\nconst mixLinearColor = (from, to, v) => {\n  const fromExpo = from * from;\n  return Math.sqrt(Math.max(0, v * (to * to - fromExpo) + fromExpo));\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = v => colorTypes.find(type => type.test(v));\nfunction asRGBA(color) {\n  const type = getColorType(color);\n  exports.invariant(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`);\n  let model = type.parse(color);\n  if (type === hsla) {\n    // TODO Remove this cast - needed since Framer Motion's stricter typing\n    model = hslaToRgba(model);\n  }\n  return model;\n}\nconst mixColor = (from, to) => {\n  const fromRGBA = asRGBA(from);\n  const toRGBA = asRGBA(to);\n  const blended = {\n    ...fromRGBA\n  };\n  return v => {\n    blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);\n    blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);\n    blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);\n    blended.alpha = mix(fromRGBA.alpha, toRGBA.alpha, v);\n    return rgba.transform(blended);\n  };\n};\nfunction test(v) {\n  var _a, _b;\n  return isNaN(v) && isString(v) && (((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) + (((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) > 0;\n}\nconst cssVarTokeniser = {\n  regex: cssVariableRegex,\n  countKey: \"Vars\",\n  token: \"${v}\",\n  parse: noop\n};\nconst colorTokeniser = {\n  regex: colorRegex,\n  countKey: \"Colors\",\n  token: \"${c}\",\n  parse: color.parse\n};\nconst numberTokeniser = {\n  regex: floatRegex,\n  countKey: \"Numbers\",\n  token: \"${n}\",\n  parse: number.parse\n};\nfunction tokenise(info, _ref10) {\n  let {\n    regex,\n    countKey,\n    token,\n    parse\n  } = _ref10;\n  const matches = info.tokenised.match(regex);\n  if (!matches) return;\n  info[\"num\" + countKey] = matches.length;\n  info.tokenised = info.tokenised.replace(regex, token);\n  info.values.push(...matches.map(parse));\n}\nfunction analyseComplexValue(value) {\n  const originalValue = value.toString();\n  const info = {\n    value: originalValue,\n    tokenised: originalValue,\n    values: [],\n    numVars: 0,\n    numColors: 0,\n    numNumbers: 0\n  };\n  if (info.value.includes(\"var(--\")) tokenise(info, cssVarTokeniser);\n  tokenise(info, colorTokeniser);\n  tokenise(info, numberTokeniser);\n  return info;\n}\nfunction parseComplexValue(v) {\n  return analyseComplexValue(v).values;\n}\nfunction createTransformer(source) {\n  const {\n    values,\n    numColors,\n    numVars,\n    tokenised\n  } = analyseComplexValue(source);\n  const numValues = values.length;\n  return v => {\n    let output = tokenised;\n    for (let i = 0; i < numValues; i++) {\n      if (i < numVars) {\n        output = output.replace(cssVarTokeniser.token, v[i]);\n      } else if (i < numVars + numColors) {\n        output = output.replace(colorTokeniser.token, color.transform(v[i]));\n      } else {\n        output = output.replace(numberTokeniser.token, sanitize(v[i]));\n      }\n    }\n    return output;\n  };\n}\nconst convertNumbersToZero = v => typeof v === \"number\" ? 0 : v;\nfunction getAnimatableNone$1(v) {\n  const parsed = parseComplexValue(v);\n  const transformer = createTransformer(v);\n  return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = {\n  test,\n  parse: parseComplexValue,\n  createTransformer,\n  getAnimatableNone: getAnimatableNone$1\n};\nconst mixImmediate = (origin, target) => p => `${p > 0 ? target : origin}`;\nfunction getMixer$1(origin, target) {\n  if (typeof origin === \"number\") {\n    return v => mix(origin, target, v);\n  } else if (color.test(origin)) {\n    return mixColor(origin, target);\n  } else {\n    return origin.startsWith(\"var(\") ? mixImmediate(origin, target) : mixComplex(origin, target);\n  }\n}\nconst mixArray = (from, to) => {\n  const output = [...from];\n  const numValues = output.length;\n  const blendValue = from.map((fromThis, i) => getMixer$1(fromThis, to[i]));\n  return v => {\n    for (let i = 0; i < numValues; i++) {\n      output[i] = blendValue[i](v);\n    }\n    return output;\n  };\n};\nconst mixObject = (origin, target) => {\n  const output = {\n    ...origin,\n    ...target\n  };\n  const blendValue = {};\n  for (const key in output) {\n    if (origin[key] !== undefined && target[key] !== undefined) {\n      blendValue[key] = getMixer$1(origin[key], target[key]);\n    }\n  }\n  return v => {\n    for (const key in blendValue) {\n      output[key] = blendValue[key](v);\n    }\n    return output;\n  };\n};\nconst mixComplex = (origin, target) => {\n  const template = complex.createTransformer(target);\n  const originStats = analyseComplexValue(origin);\n  const targetStats = analyseComplexValue(target);\n  const canInterpolate = originStats.numVars === targetStats.numVars && originStats.numColors === targetStats.numColors && originStats.numNumbers >= targetStats.numNumbers;\n  if (canInterpolate) {\n    return pipe(mixArray(originStats.values, targetStats.values), template);\n  } else {\n    exports.warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n    return mixImmediate(origin, target);\n  }\n};\n\n/*\n  Progress within given range\n\n  Given a lower limit and an upper limit, we return the progress\n  (expressed as a number 0-1) represented by the given value, and\n  limit that progress to within 0-1.\n\n  @param [number]: Lower limit\n  @param [number]: Upper limit\n  @param [number]: Value to find progress within given range\n  @return [number]: Progress of value within range as expressed 0-1\n*/\nconst progress = (from, to, value) => {\n  const toFromDifference = to - from;\n  return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\nconst mixNumber = (from, to) => p => mix(from, to, p);\nfunction detectMixerFactory(v) {\n  if (typeof v === \"number\") {\n    return mixNumber;\n  } else if (typeof v === \"string\") {\n    return color.test(v) ? mixColor : mixComplex;\n  } else if (Array.isArray(v)) {\n    return mixArray;\n  } else if (typeof v === \"object\") {\n    return mixObject;\n  }\n  return mixNumber;\n}\nfunction createMixers(output, ease, customMixer) {\n  const mixers = [];\n  const mixerFactory = customMixer || detectMixerFactory(output[0]);\n  const numMixers = output.length - 1;\n  for (let i = 0; i < numMixers; i++) {\n    let mixer = mixerFactory(output[i], output[i + 1]);\n    if (ease) {\n      const easingFunction = Array.isArray(ease) ? ease[i] || noop : ease;\n      mixer = pipe(easingFunction, mixer);\n    }\n    mixers.push(mixer);\n  }\n  return mixers;\n}\n/**\n * Create a function that maps from a numerical input array to a generic output array.\n *\n * Accepts:\n *   - Numbers\n *   - Colors (hex, hsl, hsla, rgb, rgba)\n *   - Complex (combinations of one or more numbers or strings)\n *\n * ```jsx\n * const mixColor = interpolate([0, 1], ['#fff', '#000'])\n *\n * mixColor(0.5) // 'rgba(128, 128, 128, 1)'\n * ```\n *\n * TODO Revist this approach once we've moved to data models for values,\n * probably not needed to pregenerate mixer functions.\n *\n * @public\n */\nfunction interpolate(input, output) {\n  let {\n    clamp: isClamp = true,\n    ease,\n    mixer\n  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  const inputLength = input.length;\n  exports.invariant(inputLength === output.length, \"Both input and output ranges must be the same length\");\n  /**\n   * If we're only provided a single input, we can just make a function\n   * that returns the output.\n   */\n  if (inputLength === 1) return () => output[0];\n  // If input runs highest -> lowest, reverse both arrays\n  if (input[0] > input[inputLength - 1]) {\n    input = [...input].reverse();\n    output = [...output].reverse();\n  }\n  const mixers = createMixers(output, ease, mixer);\n  const numMixers = mixers.length;\n  const interpolator = v => {\n    let i = 0;\n    if (numMixers > 1) {\n      for (; i < input.length - 2; i++) {\n        if (v < input[i + 1]) break;\n      }\n    }\n    const progressInRange = progress(input[i], input[i + 1], v);\n    return mixers[i](progressInRange);\n  };\n  return isClamp ? v => interpolator(clamp(input[0], input[inputLength - 1], v)) : interpolator;\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$1(arr) {\n  const offset = [0];\n  fillOffset(offset, arr.length - 1);\n  return offset;\n}\nfunction convertOffsetToTimes(offset, duration) {\n  return offset.map(o => o * duration);\n}\nfunction defaultEasing(values, easing) {\n  return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes(_ref11) {\n  let {\n    duration = 300,\n    keyframes: keyframeValues,\n    times,\n    ease = \"easeInOut\"\n  } = _ref11;\n  /**\n   * Easing functions can be externally defined as strings. Here we convert them\n   * into actual functions.\n   */\n  const easingFunctions = isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);\n  /**\n   * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n   * to reduce GC during animation.\n   */\n  const state = {\n    done: false,\n    value: keyframeValues[0]\n  };\n  /**\n   * Create a times array based on the provided 0-1 offsets\n   */\n  const absoluteTimes = convertOffsetToTimes(\n  // Only use the provided offsets if they're the correct length\n  // TODO Maybe we should warn here if there's a length mismatch\n  times && times.length === keyframeValues.length ? times : defaultOffset$1(keyframeValues), duration);\n  const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n    ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions)\n  });\n  return {\n    calculatedDuration: duration,\n    next: t => {\n      state.value = mapTimeToKeyframe(t);\n      state.done = t >= duration;\n      return state;\n    }\n  };\n}\n\n/*\n  Convert velocity into velocity per second\n\n  @param [number]: Unit per frame\n  @param [number]: Frame duration in ms\n*/\nfunction velocityPerSecond(velocity, frameDuration) {\n  return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\nconst velocitySampleDuration = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n  const prevT = Math.max(t - velocitySampleDuration, 0);\n  return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\nconst safeMin = 0.001;\nconst minDuration = 0.01;\nconst maxDuration$1 = 10.0;\nconst minDamping = 0.05;\nconst maxDamping = 1;\nfunction findSpring(_ref12) {\n  let {\n    duration = 800,\n    bounce = 0.25,\n    velocity = 0,\n    mass = 1\n  } = _ref12;\n  let envelope;\n  let derivative;\n  exports.warning(duration <= secondsToMilliseconds(maxDuration$1), \"Spring duration must be 10 seconds or less\");\n  let dampingRatio = 1 - bounce;\n  /**\n   * Restrict dampingRatio and duration to within acceptable ranges.\n   */\n  dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n  duration = clamp(minDuration, maxDuration$1, millisecondsToSeconds(duration));\n  if (dampingRatio < 1) {\n    /**\n     * Underdamped spring\n     */\n    envelope = undampedFreq => {\n      const exponentialDecay = undampedFreq * dampingRatio;\n      const delta = exponentialDecay * duration;\n      const a = exponentialDecay - velocity;\n      const b = calcAngularFreq(undampedFreq, dampingRatio);\n      const c = Math.exp(-delta);\n      return safeMin - a / b * c;\n    };\n    derivative = undampedFreq => {\n      const exponentialDecay = undampedFreq * dampingRatio;\n      const delta = exponentialDecay * duration;\n      const d = delta * velocity + velocity;\n      const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n      const f = Math.exp(-delta);\n      const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n      const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n      return factor * ((d - e) * f) / g;\n    };\n  } else {\n    /**\n     * Critically-damped spring\n     */\n    envelope = undampedFreq => {\n      const a = Math.exp(-undampedFreq * duration);\n      const b = (undampedFreq - velocity) * duration + 1;\n      return -safeMin + a * b;\n    };\n    derivative = undampedFreq => {\n      const a = Math.exp(-undampedFreq * duration);\n      const b = (velocity - undampedFreq) * (duration * duration);\n      return a * b;\n    };\n  }\n  const initialGuess = 5 / duration;\n  const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n  duration = secondsToMilliseconds(duration);\n  if (isNaN(undampedFreq)) {\n    return {\n      stiffness: 100,\n      damping: 10,\n      duration\n    };\n  } else {\n    const stiffness = Math.pow(undampedFreq, 2) * mass;\n    return {\n      stiffness,\n      damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n      duration\n    };\n  }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n  let result = initialGuess;\n  for (let i = 1; i < rootIterations; i++) {\n    result = result - envelope(result) / derivative(result);\n  }\n  return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n  return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n  return keys.some(key => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n  let springOptions = {\n    velocity: 0.0,\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    isResolvedFromDuration: false,\n    ...options\n  };\n  // stiffness/damping/mass overrides duration/bounce\n  if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {\n    const derived = findSpring(options);\n    springOptions = {\n      ...springOptions,\n      ...derived,\n      velocity: 0.0,\n      mass: 1.0\n    };\n    springOptions.isResolvedFromDuration = true;\n  }\n  return springOptions;\n}\nfunction spring(_ref13) {\n  let {\n    keyframes,\n    restDelta,\n    restSpeed,\n    ...options\n  } = _ref13;\n  const origin = keyframes[0];\n  const target = keyframes[keyframes.length - 1];\n  /**\n   * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n   * to reduce GC during animation.\n   */\n  const state = {\n    done: false,\n    value: origin\n  };\n  const {\n    stiffness,\n    damping,\n    mass,\n    velocity,\n    duration,\n    isResolvedFromDuration\n  } = getSpringOptions(options);\n  const initialVelocity = velocity ? -millisecondsToSeconds(velocity) : 0.0;\n  const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n  const initialDelta = target - origin;\n  const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n  /**\n   * If we're working on a granular scale, use smaller defaults for determining\n   * when the spring is finished.\n   *\n   * These defaults have been selected emprically based on what strikes a good\n   * ratio between feeling good and finishing as soon as changes are imperceptible.\n   */\n  const isGranularScale = Math.abs(initialDelta) < 5;\n  restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);\n  restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\n  let resolveSpring;\n  if (dampingRatio < 1) {\n    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n    // Underdamped spring\n    resolveSpring = t => {\n      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));\n    };\n  } else if (dampingRatio === 1) {\n    // Critically damped spring\n    resolveSpring = t => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);\n  } else {\n    // Overdamped spring\n    const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n    resolveSpring = t => {\n      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n      // When performing sinh or cosh values can hit Infinity so we cap them here\n      const freqForT = Math.min(dampedAngularFreq * t, 300);\n      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;\n    };\n  }\n  return {\n    calculatedDuration: isResolvedFromDuration ? duration || null : null,\n    next: t => {\n      const current = resolveSpring(t);\n      if (!isResolvedFromDuration) {\n        let currentVelocity = initialVelocity;\n        if (t !== 0) {\n          /**\n           * We only need to calculate velocity for under-damped springs\n           * as over- and critically-damped springs can't overshoot, so\n           * checking only for displacement is enough.\n           */\n          if (dampingRatio < 1) {\n            currentVelocity = calcGeneratorVelocity(resolveSpring, t, current);\n          } else {\n            currentVelocity = 0;\n          }\n        }\n        const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n        const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n        state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;\n      } else {\n        state.done = t >= duration;\n      }\n      state.value = state.done ? target : current;\n      return state;\n    }\n  };\n}\nfunction inertia(_ref14) {\n  let {\n    keyframes,\n    velocity = 0.0,\n    power = 0.8,\n    timeConstant = 325,\n    bounceDamping = 10,\n    bounceStiffness = 500,\n    modifyTarget,\n    min,\n    max,\n    restDelta = 0.5,\n    restSpeed\n  } = _ref14;\n  const origin = keyframes[0];\n  const state = {\n    done: false,\n    value: origin\n  };\n  const isOutOfBounds = v => min !== undefined && v < min || max !== undefined && v > max;\n  const nearestBoundary = v => {\n    if (min === undefined) return max;\n    if (max === undefined) return min;\n    return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n  };\n  let amplitude = power * velocity;\n  const ideal = origin + amplitude;\n  const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n  /**\n   * If the target has changed we need to re-calculate the amplitude, otherwise\n   * the animation will start from the wrong position.\n   */\n  if (target !== ideal) amplitude = target - origin;\n  const calcDelta = t => -amplitude * Math.exp(-t / timeConstant);\n  const calcLatest = t => target + calcDelta(t);\n  const applyFriction = t => {\n    const delta = calcDelta(t);\n    const latest = calcLatest(t);\n    state.done = Math.abs(delta) <= restDelta;\n    state.value = state.done ? target : latest;\n  };\n  /**\n   * Ideally this would resolve for t in a stateless way, we could\n   * do that by always precalculating the animation but as we know\n   * this will be done anyway we can assume that spring will\n   * be discovered during that.\n   */\n  let timeReachedBoundary;\n  let spring$1;\n  const checkCatchBoundary = t => {\n    if (!isOutOfBounds(state.value)) return;\n    timeReachedBoundary = t;\n    spring$1 = spring({\n      keyframes: [state.value, nearestBoundary(state.value)],\n      velocity: calcGeneratorVelocity(calcLatest, t, state.value),\n      damping: bounceDamping,\n      stiffness: bounceStiffness,\n      restDelta,\n      restSpeed\n    });\n  };\n  checkCatchBoundary(0);\n  return {\n    calculatedDuration: null,\n    next: t => {\n      /**\n       * We need to resolve the friction to figure out if we need a\n       * spring but we don't want to do this twice per frame. So here\n       * we flag if we updated for this frame and later if we did\n       * we can skip doing it again.\n       */\n      let hasUpdatedFrame = false;\n      if (!spring$1 && timeReachedBoundary === undefined) {\n        hasUpdatedFrame = true;\n        applyFriction(t);\n        checkCatchBoundary(t);\n      }\n      /**\n       * If we have a spring and the provided t is beyond the moment the friction\n       * animation crossed the min/max boundary, use the spring.\n       */\n      if (timeReachedBoundary !== undefined && t > timeReachedBoundary) {\n        return spring$1.next(t - timeReachedBoundary);\n      } else {\n        !hasUpdatedFrame && applyFriction(t);\n        return state;\n      }\n    }\n  };\n}\nconst frameloopDriver = update => {\n  const passTimestamp = _ref15 => {\n    let {\n      timestamp\n    } = _ref15;\n    return update(timestamp);\n  };\n  return {\n    start: () => frame.update(passTimestamp, true),\n    stop: () => cancelFrame(passTimestamp),\n    /**\n     * If we're processing this frame we can use the\n     * framelocked timestamp to keep things in sync.\n     */\n    now: () => frameData.isProcessing ? frameData.timestamp : performance.now()\n  };\n};\n\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n  let duration = 0;\n  const timeStep = 50;\n  let state = generator.next(duration);\n  while (!state.done && duration < maxGeneratorDuration) {\n    duration += timeStep;\n    state = generator.next(duration);\n  }\n  return duration >= maxGeneratorDuration ? Infinity : duration;\n}\nconst types = {\n  decay: inertia,\n  inertia,\n  tween: keyframes,\n  keyframes: keyframes,\n  spring\n};\n/**\n * Animate a single value on the main thread.\n *\n * This function is written, where functionality overlaps,\n * to be largely spec-compliant with WAAPI to allow fungibility\n * between the two.\n */\nfunction animateValue(_ref16) {\n  let {\n    autoplay = true,\n    delay = 0,\n    driver = frameloopDriver,\n    keyframes: keyframes$1,\n    type = \"keyframes\",\n    repeat = 0,\n    repeatDelay = 0,\n    repeatType = \"loop\",\n    onPlay,\n    onStop,\n    onComplete,\n    onUpdate,\n    ...options\n  } = _ref16;\n  let speed = 1;\n  let hasStopped = false;\n  let resolveFinishedPromise;\n  let currentFinishedPromise;\n  /**\n   * Resolve the current Promise every time we enter the\n   * finished state. This is WAAPI-compatible behaviour.\n   */\n  const updateFinishedPromise = () => {\n    currentFinishedPromise = new Promise(resolve => {\n      resolveFinishedPromise = resolve;\n    });\n  };\n  // Create the first finished promise\n  updateFinishedPromise();\n  let animationDriver;\n  const generatorFactory = types[type] || keyframes;\n  /**\n   * If this isn't the keyframes generator and we've been provided\n   * strings as keyframes, we need to interpolate these.\n   * TODO: Support velocity for units and complex value types/\n   */\n  let mapNumbersToKeyframes;\n  if (generatorFactory !== keyframes && typeof keyframes$1[0] !== \"number\") {\n    mapNumbersToKeyframes = interpolate([0, 100], keyframes$1, {\n      clamp: false\n    });\n    keyframes$1 = [0, 100];\n  }\n  const generator = generatorFactory({\n    ...options,\n    keyframes: keyframes$1\n  });\n  let mirroredGenerator;\n  if (repeatType === \"mirror\") {\n    mirroredGenerator = generatorFactory({\n      ...options,\n      keyframes: [...keyframes$1].reverse(),\n      velocity: -(options.velocity || 0)\n    });\n  }\n  let playState = \"idle\";\n  let holdTime = null;\n  let startTime = null;\n  let cancelTime = null;\n  /**\n   * If duration is undefined and we have repeat options,\n   * we need to calculate a duration from the generator.\n   *\n   * We set it to the generator itself to cache the duration.\n   * Any timeline resolver will need to have already precalculated\n   * the duration by this step.\n   */\n  if (generator.calculatedDuration === null && repeat) {\n    generator.calculatedDuration = calcGeneratorDuration(generator);\n  }\n  const {\n    calculatedDuration\n  } = generator;\n  let resolvedDuration = Infinity;\n  let totalDuration = Infinity;\n  if (calculatedDuration !== null) {\n    resolvedDuration = calculatedDuration + repeatDelay;\n    totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n  }\n  let currentTime = 0;\n  const tick = timestamp => {\n    if (startTime === null) return;\n    /**\n     * requestAnimationFrame timestamps can come through as lower than\n     * the startTime as set by performance.now(). Here we prevent this,\n     * though in the future it could be possible to make setting startTime\n     * a pending operation that gets resolved here.\n     */\n    if (speed > 0) startTime = Math.min(startTime, timestamp);\n    if (speed < 0) startTime = Math.min(timestamp - totalDuration / speed, startTime);\n    if (holdTime !== null) {\n      currentTime = holdTime;\n    } else {\n      // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n      // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n      // example.\n      currentTime = Math.round(timestamp - startTime) * speed;\n    }\n    // Rebase on delay\n    const timeWithoutDelay = currentTime - delay * (speed >= 0 ? 1 : -1);\n    const isInDelayPhase = speed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;\n    currentTime = Math.max(timeWithoutDelay, 0);\n    /**\n     * If this animation has finished, set the current time\n     * to the total duration.\n     */\n    if (playState === \"finished\" && holdTime === null) {\n      currentTime = totalDuration;\n    }\n    let elapsed = currentTime;\n    let frameGenerator = generator;\n    if (repeat) {\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 = currentTime / resolvedDuration;\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      /**\n       * If iteration progress is 1 we count that as the end\n       * of the previous iteration.\n       */\n      if (!iterationProgress && progress >= 1) {\n        iterationProgress = 1;\n      }\n      iterationProgress === 1 && currentIteration--;\n      currentIteration = Math.min(currentIteration, repeat + 1);\n      /**\n       * Reverse progress if we're not running in \"normal\" direction\n       */\n      const iterationIsOdd = Boolean(currentIteration % 2);\n      if (iterationIsOdd) {\n        if (repeatType === \"reverse\") {\n          iterationProgress = 1 - iterationProgress;\n          if (repeatDelay) {\n            iterationProgress -= repeatDelay / resolvedDuration;\n          }\n        } else if (repeatType === \"mirror\") {\n          frameGenerator = mirroredGenerator;\n        }\n      }\n      let p = clamp(0, 1, iterationProgress);\n      if (currentTime > totalDuration) {\n        p = repeatType === \"reverse\" && iterationIsOdd ? 1 : 0;\n      }\n      elapsed = p * resolvedDuration;\n    }\n    /**\n     * If we're in negative time, set state as the initial keyframe.\n     * This prevents delay: x, duration: 0 animations from finishing\n     * instantly.\n     */\n    const state = isInDelayPhase ? {\n      done: false,\n      value: keyframes$1[0]\n    } : frameGenerator.next(elapsed);\n    if (mapNumbersToKeyframes) {\n      state.value = mapNumbersToKeyframes(state.value);\n    }\n    let {\n      done\n    } = state;\n    if (!isInDelayPhase && calculatedDuration !== null) {\n      done = speed >= 0 ? currentTime >= totalDuration : currentTime <= 0;\n    }\n    const isAnimationFinished = holdTime === null && (playState === \"finished\" || playState === \"running\" && done);\n    if (onUpdate) {\n      onUpdate(state.value);\n    }\n    if (isAnimationFinished) {\n      finish();\n    }\n    return state;\n  };\n  const stopAnimationDriver = () => {\n    animationDriver && animationDriver.stop();\n    animationDriver = undefined;\n  };\n  const cancel = () => {\n    playState = \"idle\";\n    stopAnimationDriver();\n    resolveFinishedPromise();\n    updateFinishedPromise();\n    startTime = cancelTime = null;\n  };\n  const finish = () => {\n    playState = \"finished\";\n    onComplete && onComplete();\n    stopAnimationDriver();\n    resolveFinishedPromise();\n  };\n  const play = () => {\n    if (hasStopped) return;\n    if (!animationDriver) animationDriver = driver(tick);\n    const now = animationDriver.now();\n    onPlay && onPlay();\n    if (holdTime !== null) {\n      startTime = now - holdTime;\n    } else if (!startTime || playState === \"finished\") {\n      startTime = now;\n    }\n    if (playState === \"finished\") {\n      updateFinishedPromise();\n    }\n    cancelTime = startTime;\n    holdTime = null;\n    /**\n     * Set playState to running only after we've used it in\n     * the previous logic.\n     */\n    playState = \"running\";\n    animationDriver.start();\n  };\n  if (autoplay) {\n    play();\n  }\n  const controls = {\n    then(resolve, reject) {\n      return currentFinishedPromise.then(resolve, reject);\n    },\n    get time() {\n      return millisecondsToSeconds(currentTime);\n    },\n    set time(newTime) {\n      newTime = secondsToMilliseconds(newTime);\n      currentTime = newTime;\n      if (holdTime !== null || !animationDriver || speed === 0) {\n        holdTime = newTime;\n      } else {\n        startTime = animationDriver.now() - newTime / speed;\n      }\n    },\n    get duration() {\n      const duration = generator.calculatedDuration === null ? calcGeneratorDuration(generator) : generator.calculatedDuration;\n      return millisecondsToSeconds(duration);\n    },\n    get speed() {\n      return speed;\n    },\n    set speed(newSpeed) {\n      if (newSpeed === speed || !animationDriver) return;\n      speed = newSpeed;\n      controls.time = millisecondsToSeconds(currentTime);\n    },\n    get state() {\n      return playState;\n    },\n    play,\n    pause: () => {\n      playState = \"paused\";\n      holdTime = currentTime;\n    },\n    stop: () => {\n      hasStopped = true;\n      if (playState === \"idle\") return;\n      playState = \"idle\";\n      onStop && onStop();\n      cancel();\n    },\n    cancel: () => {\n      if (cancelTime !== null) tick(cancelTime);\n      cancel();\n    },\n    complete: () => {\n      playState = \"finished\";\n    },\n    sample: elapsed => {\n      startTime = 0;\n      return tick(elapsed);\n    }\n  };\n  return controls;\n}\nfunction memo(callback) {\n  let result;\n  return () => {\n    if (result === undefined) result = callback();\n    return result;\n  };\n}\nconst supportsWaapi = memo(() => Object.hasOwnProperty.call(Element.prototype, \"animate\"));\n/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\"opacity\", \"clipPath\", \"filter\", \"transform\", \"backgroundColor\"]);\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxDuration = 20000;\nconst requiresPregeneratedKeyframes = (valueName, options) => options.type === \"spring\" || valueName === \"backgroundColor\" || !isWaapiSupportedEasing(options.ease);\nfunction createAcceleratedAnimation(value, valueName, _ref17) {\n  let {\n    onUpdate,\n    onComplete,\n    ...options\n  } = _ref17;\n  const canAccelerateAnimation = supportsWaapi() && acceleratedValues.has(valueName) && !options.repeatDelay && options.repeatType !== \"mirror\" && options.damping !== 0 && options.type !== \"inertia\";\n  if (!canAccelerateAnimation) return false;\n  /**\n   * TODO: Unify with js/index\n   */\n  let hasStopped = false;\n  let resolveFinishedPromise;\n  let currentFinishedPromise;\n  /**\n   * Resolve the current Promise every time we enter the\n   * finished state. This is WAAPI-compatible behaviour.\n   */\n  const updateFinishedPromise = () => {\n    currentFinishedPromise = new Promise(resolve => {\n      resolveFinishedPromise = resolve;\n    });\n  };\n  // Create the first finished promise\n  updateFinishedPromise();\n  let {\n    keyframes,\n    duration = 300,\n    ease,\n    times\n  } = options;\n  /**\n   * If this animation needs pre-generated keyframes then generate.\n   */\n  if (requiresPregeneratedKeyframes(valueName, options)) {\n    const sampleAnimation = animateValue({\n      ...options,\n      repeat: 0,\n      delay: 0\n    });\n    let state = {\n      done: false,\n      value: keyframes[0]\n    };\n    const pregeneratedKeyframes = [];\n    /**\n     * Bail after 20 seconds of pre-generated keyframes as it's likely\n     * we're heading for an infinite loop.\n     */\n    let t = 0;\n    while (!state.done && t < maxDuration) {\n      state = sampleAnimation.sample(t);\n      pregeneratedKeyframes.push(state.value);\n      t += sampleDelta;\n    }\n    times = undefined;\n    keyframes = pregeneratedKeyframes;\n    duration = t - sampleDelta;\n    ease = \"linear\";\n  }\n  const animation = animateStyle(value.owner.current, valueName, keyframes, {\n    ...options,\n    duration,\n    /**\n     * This function is currently not called if ease is provided\n     * as a function so the cast is safe.\n     *\n     * However it would be possible for a future refinement to port\n     * in easing pregeneration from Motion One for browsers that\n     * support the upcoming `linear()` easing function.\n     */\n    ease: ease,\n    times\n  });\n  const cancelAnimation = () => animation.cancel();\n  const safeCancel = () => {\n    frame.update(cancelAnimation);\n    resolveFinishedPromise();\n    updateFinishedPromise();\n  };\n  /**\n   * Prefer the `onfinish` prop as it's more widely supported than\n   * the `finished` promise.\n   *\n   * Here, we synchronously set the provided MotionValue to the end\n   * keyframe. If we didn't, when the WAAPI animation is finished it would\n   * be removed from the element which would then revert to its old styles.\n   */\n  animation.onfinish = () => {\n    value.set(getFinalKeyframe(keyframes, options));\n    onComplete && onComplete();\n    safeCancel();\n  };\n  /**\n   * Animation interrupt callback.\n   */\n  const controls = {\n    then(resolve, reject) {\n      return currentFinishedPromise.then(resolve, reject);\n    },\n    attachTimeline(timeline) {\n      animation.timeline = timeline;\n      animation.onfinish = null;\n      return noop;\n    },\n    get time() {\n      return millisecondsToSeconds(animation.currentTime || 0);\n    },\n    set time(newTime) {\n      animation.currentTime = secondsToMilliseconds(newTime);\n    },\n    get speed() {\n      return animation.playbackRate;\n    },\n    set speed(newSpeed) {\n      animation.playbackRate = newSpeed;\n    },\n    get duration() {\n      return millisecondsToSeconds(duration);\n    },\n    play: () => {\n      if (hasStopped) return;\n      animation.play();\n      /**\n       * Cancel any pending cancel tasks\n       */\n      cancelFrame(cancelAnimation);\n    },\n    pause: () => animation.pause(),\n    stop: () => {\n      hasStopped = true;\n      if (animation.playState === \"idle\") return;\n      /**\n       * WAAPI doesn't natively have any interruption capabilities.\n       *\n       * Rather than read commited styles back out of the DOM, we can\n       * create a renderless JS animation and sample it twice to calculate\n       * its current value, \"previous\" value, and therefore allow\n       * Motion to calculate velocity for any subsequent animation.\n       */\n      const {\n        currentTime\n      } = animation;\n      if (currentTime) {\n        const sampleAnimation = animateValue({\n          ...options,\n          autoplay: false\n        });\n        value.setWithVelocity(sampleAnimation.sample(currentTime - sampleDelta).value, sampleAnimation.sample(currentTime).value, sampleDelta);\n      }\n      safeCancel();\n    },\n    complete: () => animation.finish(),\n    cancel: safeCancel\n  };\n  return controls;\n}\nfunction createInstantAnimation(_ref18) {\n  let {\n    keyframes,\n    delay,\n    onUpdate,\n    onComplete\n  } = _ref18;\n  const setValue = () => {\n    onUpdate && onUpdate(keyframes[keyframes.length - 1]);\n    onComplete && onComplete();\n    /**\n     * TODO: As this API grows it could make sense to always return\n     * animateValue. This will be a bigger project as animateValue\n     * is frame-locked whereas this function resolves instantly.\n     * This is a behavioural change and also has ramifications regarding\n     * assumptions within tests.\n     */\n    return {\n      time: 0,\n      speed: 1,\n      duration: 0,\n      play: noop,\n      pause: noop,\n      stop: noop,\n      then: resolve => {\n        resolve();\n        return Promise.resolve();\n      },\n      cancel: noop,\n      complete: noop\n    };\n  };\n  return delay ? animateValue({\n    keyframes: [0, 1],\n    duration: 0,\n    delay,\n    onComplete: setValue\n  }) : setValue();\n}\nconst underDampedSpring = {\n  type: \"spring\",\n  stiffness: 500,\n  damping: 25,\n  restSpeed: 10\n};\nconst criticallyDampedSpring = target => ({\n  type: \"spring\",\n  stiffness: 550,\n  damping: target === 0 ? 2 * Math.sqrt(550) : 30,\n  restSpeed: 10\n});\nconst keyframesTransition = {\n  type: \"keyframes\",\n  duration: 0.8\n};\n/**\n * Default easing curve is a slightly shallower version of\n * the default browser easing curve.\n */\nconst ease = {\n  type: \"keyframes\",\n  ease: [0.25, 0.1, 0.35, 1],\n  duration: 0.3\n};\nconst getDefaultTransition = (valueKey, _ref19) => {\n  let {\n    keyframes\n  } = _ref19;\n  if (keyframes.length > 2) {\n    return keyframesTransition;\n  } else if (transformProps.has(valueKey)) {\n    return valueKey.startsWith(\"scale\") ? criticallyDampedSpring(keyframes[1]) : underDampedSpring;\n  }\n  return ease;\n};\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (key, value) => {\n  // If the list of keys tat might be non-animatable grows, replace with Set\n  if (key === \"zIndex\") return false;\n  // If it's a number or a keyframes array, we can animate it. We might at some point\n  // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n  // but for now lets leave it like this for performance reasons\n  if (typeof value === \"number\" || Array.isArray(value)) return true;\n  if (typeof value === \"string\" && (\n  // It's animatable if we have a string\n  complex.test(value) || value === \"0\") &&\n  // And it contains numbers and/or colors\n  !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n  ) {\n    return true;\n  }\n  return false;\n};\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n  const [name, value] = v.slice(0, -1).split(\"(\");\n  if (name === \"drop-shadow\") return v;\n  const [number] = value.match(floatRegex) || [];\n  if (!number) return v;\n  const unit = value.replace(number, \"\");\n  let defaultValue = maxDefaults.has(name) ? 1 : 0;\n  if (number !== value) defaultValue *= 100;\n  return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = {\n  ...complex,\n  getAnimatableNone: v => {\n    const functions = v.match(functionRegex);\n    return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n  }\n};\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n  ...numberValueTypes,\n  // Color props\n  color,\n  backgroundColor: color,\n  outlineColor: color,\n  fill: color,\n  stroke: color,\n  // Border props\n  borderColor: color,\n  borderTopColor: color,\n  borderRightColor: color,\n  borderBottomColor: color,\n  borderLeftColor: color,\n  filter,\n  WebkitFilter: filter\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = key => defaultValueTypes[key];\nfunction getAnimatableNone(key, value) {\n  let defaultValueType = getDefaultValueType(key);\n  if (defaultValueType !== filter) defaultValueType = complex;\n  // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n  return defaultValueType.getAnimatableNone ? defaultValueType.getAnimatableNone(value) : undefined;\n}\n\n/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nconst isZeroValueString = v => /^0[^.\\s]+$/.test(v);\nfunction isNone(value) {\n  if (typeof value === \"number\") {\n    return value === 0;\n  } else if (value !== null) {\n    return value === \"none\" || value === \"0\" || isZeroValueString(value);\n  }\n}\nfunction getKeyframes(value, valueName, target, transition) {\n  const isTargetAnimatable = isAnimatable(valueName, target);\n  let keyframes;\n  if (Array.isArray(target)) {\n    keyframes = [...target];\n  } else {\n    keyframes = [null, target];\n  }\n  const defaultOrigin = transition.from !== undefined ? transition.from : value.get();\n  let animatableTemplateValue = undefined;\n  const noneKeyframeIndexes = [];\n  for (let i = 0; i < keyframes.length; i++) {\n    /**\n     * Fill null/wildcard keyframes\n     */\n    if (keyframes[i] === null) {\n      keyframes[i] = i === 0 ? defaultOrigin : keyframes[i - 1];\n    }\n    if (isNone(keyframes[i])) {\n      noneKeyframeIndexes.push(i);\n    }\n    // TODO: Clean this conditional, it works for now\n    if (typeof keyframes[i] === \"string\" && keyframes[i] !== \"none\" && keyframes[i] !== \"0\") {\n      animatableTemplateValue = keyframes[i];\n    }\n  }\n  if (isTargetAnimatable && noneKeyframeIndexes.length && animatableTemplateValue) {\n    for (let i = 0; i < noneKeyframeIndexes.length; i++) {\n      const index = noneKeyframeIndexes[i];\n      keyframes[index] = getAnimatableNone(valueName, animatableTemplateValue);\n    }\n  }\n  return keyframes;\n}\n\n/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined(_ref20) {\n  let {\n    when,\n    delay: _delay,\n    delayChildren,\n    staggerChildren,\n    staggerDirection,\n    repeat,\n    repeatType,\n    repeatDelay,\n    from,\n    elapsed,\n    ...transition\n  } = _ref20;\n  return !!Object.keys(transition).length;\n}\nfunction getValueTransition$1(transition, key) {\n  return transition[key] || transition[\"default\"] || transition;\n}\nconst animateMotionValue = function (valueName, value, target) {\n  let transition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  return onComplete => {\n    const valueTransition = getValueTransition$1(transition, valueName) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let {\n      elapsed = 0\n    } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    const keyframes = getKeyframes(value, valueName, target, valueTransition);\n    /**\n     * Check if we're able to animate between the start and end keyframes,\n     * and throw a warning if we're attempting to animate between one that's\n     * animatable and another that isn't.\n     */\n    const originKeyframe = keyframes[0];\n    const targetKeyframe = keyframes[keyframes.length - 1];\n    const isOriginAnimatable = isAnimatable(valueName, originKeyframe);\n    const isTargetAnimatable = isAnimatable(valueName, targetKeyframe);\n    exports.warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${valueName} from \"${originKeyframe}\" to \"${targetKeyframe}\". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \\`style\\` property.`);\n    let options = {\n      keyframes,\n      velocity: value.getVelocity(),\n      ease: \"easeOut\",\n      ...valueTransition,\n      delay: -elapsed,\n      onUpdate: v => {\n        value.set(v);\n        valueTransition.onUpdate && valueTransition.onUpdate(v);\n      },\n      onComplete: () => {\n        onComplete();\n        valueTransition.onComplete && valueTransition.onComplete();\n      }\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unqiue transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n      options = {\n        ...options,\n        ...getDefaultTransition(valueName, options)\n      };\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    if (options.duration) {\n      options.duration = secondsToMilliseconds(options.duration);\n    }\n    if (options.repeatDelay) {\n      options.repeatDelay = secondsToMilliseconds(options.repeatDelay);\n    }\n    if (!isOriginAnimatable || !isTargetAnimatable || instantAnimationState.current || valueTransition.type === false) {\n      /**\n       * If we can't animate this value, or the global instant animation flag is set,\n       * or this is simply defined as an instant transition, return an instant transition.\n       */\n      return createInstantAnimation(instantAnimationState.current ? {\n        ...options,\n        delay: 0\n      } : options);\n    }\n    /**\n     * Animate via WAAPI if possible.\n     */\n    if (\n    /**\n     * If this is a handoff animation, the optimised animation will be running via\n     * WAAPI. Therefore, this animation must be JS to ensure it runs \"under\" the\n     * optimised animation.\n     */\n    !transition.isHandoff && value.owner && value.owner.current instanceof HTMLElement &&\n    /**\n     * If we're outputting values to onUpdate then we can't use WAAPI as there's\n     * no way to read the value from WAAPI every frame.\n     */\n    !value.owner.getProps().onUpdate) {\n      const acceleratedAnimation = createAcceleratedAnimation(value, valueName, options);\n      if (acceleratedAnimation) return acceleratedAnimation;\n    }\n    /**\n     * If we didn't create an accelerated animation, create a JS animation\n     */\n    return animateValue(options);\n  };\n};\nfunction isWillChangeMotionValue(value) {\n  return Boolean(isMotionValue(value) && value.add);\n}\n\n/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nconst isNumericalString = v => /^\\-?\\d*\\.?\\d+$/.test(v);\nfunction addUniqueItem(arr, item) {\n  if (arr.indexOf(item) === -1) arr.push(item);\n}\nfunction removeItem(arr, item) {\n  const index = arr.indexOf(item);\n  if (index > -1) arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem(_ref21, fromIndex, toIndex) {\n  let [...arr] = _ref21;\n  const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n  if (startIndex >= 0 && startIndex < arr.length) {\n    const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n    const [item] = arr.splice(fromIndex, 1);\n    arr.splice(endIndex, 0, item);\n  }\n  return arr;\n}\nclass SubscriptionManager {\n  constructor() {\n    this.subscriptions = [];\n  }\n  add(handler) {\n    addUniqueItem(this.subscriptions, handler);\n    return () => removeItem(this.subscriptions, handler);\n  }\n  notify(a, b, c) {\n    const numSubscriptions = this.subscriptions.length;\n    if (!numSubscriptions) return;\n    if (numSubscriptions === 1) {\n      /**\n       * If there's only a single handler we can just call it without invoking a loop.\n       */\n      this.subscriptions[0](a, b, c);\n    } else {\n      for (let i = 0; i < numSubscriptions; i++) {\n        /**\n         * Check whether the handler exists before firing as it's possible\n         * the subscriptions were modified during this loop running.\n         */\n        const handler = this.subscriptions[i];\n        handler && handler(a, b, c);\n      }\n    }\n  }\n  getSize() {\n    return this.subscriptions.length;\n  }\n  clear() {\n    this.subscriptions.length = 0;\n  }\n}\nconst warned = new Set();\nfunction warnOnce(condition, message, element) {\n  if (condition || warned.has(message)) return;\n  console.warn(message);\n  if (element) console.warn(element);\n  warned.add(message);\n}\nconst isFloat = value => {\n  return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n  current: undefined\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n  /**\n   * @param init - The initiating value\n   * @param config - Optional configuration options\n   *\n   * -  `transformer`: A function to transform incoming values with.\n   *\n   * @internal\n   */\n  constructor(init) {\n    var _this = this;\n    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    /**\n     * This will be replaced by the build step with the latest version number.\n     * When MotionValues are provided to motion components, warn if versions are mixed.\n     */\n    this.version = \"10.16.16\";\n    /**\n     * Duration, in milliseconds, since last updating frame.\n     *\n     * @internal\n     */\n    this.timeDelta = 0;\n    /**\n     * Timestamp of the last time this `MotionValue` was updated.\n     *\n     * @internal\n     */\n    this.lastUpdated = 0;\n    /**\n     * Tracks whether this value can output a velocity. Currently this is only true\n     * if the value is numerical, but we might be able to widen the scope here and support\n     * other value types.\n     *\n     * @internal\n     */\n    this.canTrackVelocity = false;\n    /**\n     * An object containing a SubscriptionManager for each active event.\n     */\n    this.events = {};\n    this.updateAndNotify = function (v) {\n      let render = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n      _this.prev = _this.current;\n      _this.current = v;\n      // Update timestamp\n      const {\n        delta,\n        timestamp\n      } = frameData;\n      if (_this.lastUpdated !== timestamp) {\n        _this.timeDelta = delta;\n        _this.lastUpdated = timestamp;\n        frame.postRender(_this.scheduleVelocityCheck);\n      }\n      // Update update subscribers\n      if (_this.prev !== _this.current && _this.events.change) {\n        _this.events.change.notify(_this.current);\n      }\n      // Update velocity subscribers\n      if (_this.events.velocityChange) {\n        _this.events.velocityChange.notify(_this.getVelocity());\n      }\n      // Update render subscribers\n      if (render && _this.events.renderRequest) {\n        _this.events.renderRequest.notify(_this.current);\n      }\n    };\n    /**\n     * Schedule a velocity check for the next frame.\n     *\n     * This is an instanced and bound function to prevent generating a new\n     * function once per frame.\n     *\n     * @internal\n     */\n    this.scheduleVelocityCheck = () => frame.postRender(this.velocityCheck);\n    /**\n     * Updates `prev` with `current` if the value hasn't been updated this frame.\n     * This ensures velocity calculations return `0`.\n     *\n     * This is an instanced and bound function to prevent generating a new\n     * function once per frame.\n     *\n     * @internal\n     */\n    this.velocityCheck = _ref22 => {\n      let {\n        timestamp\n      } = _ref22;\n      if (timestamp !== this.lastUpdated) {\n        this.prev = this.current;\n        if (this.events.velocityChange) {\n          this.events.velocityChange.notify(this.getVelocity());\n        }\n      }\n    };\n    this.hasAnimated = false;\n    this.prev = this.current = init;\n    this.canTrackVelocity = isFloat(this.current);\n    this.owner = options.owner;\n  }\n  /**\n   * Adds a function that will be notified when the `MotionValue` is updated.\n   *\n   * It returns a function that, when called, will cancel the subscription.\n   *\n   * When calling `onChange` inside a React component, it should be wrapped with the\n   * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n   * from the `useEffect` function to ensure you don't add duplicate subscribers..\n   *\n   * ```jsx\n   * export const MyComponent = () => {\n   *   const x = useMotionValue(0)\n   *   const y = useMotionValue(0)\n   *   const opacity = useMotionValue(1)\n   *\n   *   useEffect(() => {\n   *     function updateOpacity() {\n   *       const maxXY = Math.max(x.get(), y.get())\n   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n   *       opacity.set(newOpacity)\n   *     }\n   *\n   *     const unsubscribeX = x.on(\"change\", updateOpacity)\n   *     const unsubscribeY = y.on(\"change\", updateOpacity)\n   *\n   *     return () => {\n   *       unsubscribeX()\n   *       unsubscribeY()\n   *     }\n   *   }, [])\n   *\n   *   return <motion.div style={{ x }} />\n   * }\n   * ```\n   *\n   * @param subscriber - A function that receives the latest value.\n   * @returns A function that, when called, will cancel this subscription.\n   *\n   * @deprecated\n   */\n  onChange(subscription) {\n    if (process.env.NODE_ENV !== \"production\") {\n      warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n    }\n    return this.on(\"change\", subscription);\n  }\n  on(eventName, callback) {\n    if (!this.events[eventName]) {\n      this.events[eventName] = new SubscriptionManager();\n    }\n    const unsubscribe = this.events[eventName].add(callback);\n    if (eventName === \"change\") {\n      return () => {\n        unsubscribe();\n        /**\n         * If we have no more change listeners by the start\n         * of the next frame, stop active animations.\n         */\n        frame.read(() => {\n          if (!this.events.change.getSize()) {\n            this.stop();\n          }\n        });\n      };\n    }\n    return unsubscribe;\n  }\n  clearListeners() {\n    for (const eventManagers in this.events) {\n      this.events[eventManagers].clear();\n    }\n  }\n  /**\n   * Attaches a passive effect to the `MotionValue`.\n   *\n   * @internal\n   */\n  attach(passiveEffect, stopPassiveEffect) {\n    this.passiveEffect = passiveEffect;\n    this.stopPassiveEffect = stopPassiveEffect;\n  }\n  /**\n   * Sets the state of the `MotionValue`.\n   *\n   * @remarks\n   *\n   * ```jsx\n   * const x = useMotionValue(0)\n   * x.set(10)\n   * ```\n   *\n   * @param latest - Latest value to set.\n   * @param render - Whether to notify render subscribers. Defaults to `true`\n   *\n   * @public\n   */\n  set(v) {\n    let render = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n    if (!render || !this.passiveEffect) {\n      this.updateAndNotify(v, render);\n    } else {\n      this.passiveEffect(v, this.updateAndNotify);\n    }\n  }\n  setWithVelocity(prev, current, delta) {\n    this.set(current);\n    this.prev = prev;\n    this.timeDelta = delta;\n  }\n  /**\n   * Set the state of the `MotionValue`, stopping any active animations,\n   * effects, and resets velocity to `0`.\n   */\n  jump(v) {\n    this.updateAndNotify(v);\n    this.prev = v;\n    this.stop();\n    if (this.stopPassiveEffect) this.stopPassiveEffect();\n  }\n  /**\n   * Returns the latest state of `MotionValue`\n   *\n   * @returns - The latest state of `MotionValue`\n   *\n   * @public\n   */\n  get() {\n    if (collectMotionValues.current) {\n      collectMotionValues.current.push(this);\n    }\n    return this.current;\n  }\n  /**\n   * @public\n   */\n  getPrevious() {\n    return this.prev;\n  }\n  /**\n   * Returns the latest velocity of `MotionValue`\n   *\n   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n   *\n   * @public\n   */\n  getVelocity() {\n    // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n    return this.canTrackVelocity ?\n    // These casts could be avoided if parseFloat would be typed better\n    velocityPerSecond(parseFloat(this.current) - parseFloat(this.prev), this.timeDelta) : 0;\n  }\n  /**\n   * Registers a new animation to control this `MotionValue`. Only one\n   * animation can drive a `MotionValue` at one time.\n   *\n   * ```jsx\n   * value.start()\n   * ```\n   *\n   * @param animation - A function that starts the provided animation\n   *\n   * @internal\n   */\n  start(startAnimation) {\n    this.stop();\n    return new Promise(resolve => {\n      this.hasAnimated = true;\n      this.animation = startAnimation(resolve);\n      if (this.events.animationStart) {\n        this.events.animationStart.notify();\n      }\n    }).then(() => {\n      if (this.events.animationComplete) {\n        this.events.animationComplete.notify();\n      }\n      this.clearAnimation();\n    });\n  }\n  /**\n   * Stop the currently active animation.\n   *\n   * @public\n   */\n  stop() {\n    if (this.animation) {\n      this.animation.stop();\n      if (this.events.animationCancel) {\n        this.events.animationCancel.notify();\n      }\n    }\n    this.clearAnimation();\n  }\n  /**\n   * Returns `true` if this value is currently animating.\n   *\n   * @public\n   */\n  isAnimating() {\n    return !!this.animation;\n  }\n  clearAnimation() {\n    delete this.animation;\n  }\n  /**\n   * Destroy and clean up subscribers to this `MotionValue`.\n   *\n   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n   * created a `MotionValue` via the `motionValue` function.\n   *\n   * @public\n   */\n  destroy() {\n    this.clearListeners();\n    this.stop();\n    if (this.stopPassiveEffect) {\n      this.stopPassiveEffect();\n    }\n  }\n}\nfunction motionValue(init, options) {\n  return new MotionValue(init, options);\n}\n\n/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = v => type => type.test(v);\n\n/**\n * ValueType for \"auto\"\n */\nconst auto = {\n  test: v => v === \"auto\",\n  parse: v => v\n};\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = v => dimensionValueTypes.find(testValueType(v));\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = v => valueTypes.find(testValueType(v));\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n  if (visualElement.hasValue(key)) {\n    visualElement.getValue(key).set(value);\n  } else {\n    visualElement.addValue(key, motionValue(value));\n  }\n}\nfunction setTarget(visualElement, definition) {\n  const resolved = resolveVariant(visualElement, definition);\n  let {\n    transitionEnd = {},\n    transition = {},\n    ...target\n  } = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {};\n  target = {\n    ...target,\n    ...transitionEnd\n  };\n  for (const key in target) {\n    const value = resolveFinalValueInKeyframes(target[key]);\n    setMotionValue(visualElement, key, value);\n  }\n}\nfunction setVariants(visualElement, variantLabels) {\n  const reversedLabels = [...variantLabels].reverse();\n  reversedLabels.forEach(key => {\n    const variant = visualElement.getVariant(key);\n    variant && setTarget(visualElement, variant);\n    if (visualElement.variantChildren) {\n      visualElement.variantChildren.forEach(child => {\n        setVariants(child, variantLabels);\n      });\n    }\n  });\n}\nfunction setValues(visualElement, definition) {\n  if (Array.isArray(definition)) {\n    return setVariants(visualElement, definition);\n  } else if (typeof definition === \"string\") {\n    return setVariants(visualElement, [definition]);\n  } else {\n    setTarget(visualElement, definition);\n  }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n  var _a, _b;\n  const newValueKeys = Object.keys(target).filter(key => !visualElement.hasValue(key));\n  const numNewValues = newValueKeys.length;\n  if (!numNewValues) return;\n  for (let i = 0; i < numNewValues; i++) {\n    const key = newValueKeys[i];\n    const targetValue = target[key];\n    let value = null;\n    /**\n     * If the target is a series of keyframes, we can use the first value\n     * in the array. If this first value is null, we'll still need to read from the DOM.\n     */\n    if (Array.isArray(targetValue)) {\n      value = targetValue[0];\n    }\n    /**\n     * If the target isn't keyframes, or the first keyframe was null, we need to\n     * first check if an origin value was explicitly defined in the transition as \"from\",\n     * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n     */\n    if (value === null) {\n      value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n    }\n    /**\n     * If value is still undefined or null, ignore it. Preferably this would throw,\n     * but this was causing issues in Framer.\n     */\n    if (value === undefined || value === null) continue;\n    if (typeof value === \"string\" && (isNumericalString(value) || isZeroValueString(value))) {\n      // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n      value = parseFloat(value);\n    } else if (!findValueType(value) && complex.test(targetValue)) {\n      value = getAnimatableNone(key, targetValue);\n    }\n    visualElement.addValue(key, motionValue(value, {\n      owner: visualElement\n    }));\n    if (origin[key] === undefined) {\n      origin[key] = value;\n    }\n    if (value !== null) visualElement.setBaseTarget(key, value);\n  }\n}\nfunction getOriginFromTransition(key, transition) {\n  if (!transition) return;\n  const valueTransition = transition[key] || transition[\"default\"] || transition;\n  return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n  const origin = {};\n  for (const key in target) {\n    const transitionOrigin = getOriginFromTransition(key, transition);\n    if (transitionOrigin !== undefined) {\n      origin[key] = transitionOrigin;\n    } else {\n      const value = visualElement.getValue(key);\n      if (value) {\n        origin[key] = value.get();\n      }\n    }\n  }\n  return origin;\n}\n\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation(_ref23, key) {\n  let {\n    protectedKeys,\n    needsAnimating\n  } = _ref23;\n  const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n  needsAnimating[key] = false;\n  return shouldBlock;\n}\nfunction hasKeyframesChanged(value, target) {\n  const current = value.get();\n  if (Array.isArray(target)) {\n    for (let i = 0; i < target.length; i++) {\n      if (target[i] !== current) return true;\n    }\n  } else {\n    return current !== target;\n  }\n}\nfunction animateTarget(visualElement, definition) {\n  let {\n    delay = 0,\n    transitionOverride,\n    type\n  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  let {\n    transition = visualElement.getDefaultTransition(),\n    transitionEnd,\n    ...target\n  } = visualElement.makeTargetAnimatable(definition);\n  const willChange = visualElement.getValue(\"willChange\");\n  if (transitionOverride) transition = transitionOverride;\n  const animations = [];\n  const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];\n  for (const key in target) {\n    const value = visualElement.getValue(key);\n    const valueTarget = target[key];\n    if (!value || valueTarget === undefined || animationTypeState && shouldBlockAnimation(animationTypeState, key)) {\n      continue;\n    }\n    const valueTransition = {\n      delay,\n      elapsed: 0,\n      ...getValueTransition$1(transition || {}, key)\n    };\n    /**\n     * If this is the first time a value is being animated, check\n     * to see if we're handling off from an existing animation.\n     */\n    if (window.HandoffAppearAnimations) {\n      const appearId = visualElement.getProps()[optimizedAppearDataAttribute];\n      if (appearId) {\n        const elapsed = window.HandoffAppearAnimations(appearId, key, value, frame);\n        if (elapsed !== null) {\n          valueTransition.elapsed = elapsed;\n          valueTransition.isHandoff = true;\n        }\n      }\n    }\n    let canSkip = !valueTransition.isHandoff && !hasKeyframesChanged(value, valueTarget);\n    if (valueTransition.type === \"spring\" && (value.getVelocity() || valueTransition.velocity)) {\n      canSkip = false;\n    }\n    /**\n     * Temporarily disable skipping animations if there's an animation in\n     * progress. Better would be to track the current target of a value\n     * and compare that against valueTarget.\n     */\n    if (value.animation) {\n      canSkip = false;\n    }\n    if (canSkip) continue;\n    value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key) ? {\n      type: false\n    } : valueTransition));\n    const animation = value.animation;\n    if (isWillChangeMotionValue(willChange)) {\n      willChange.add(key);\n      animation.then(() => willChange.remove(key));\n    }\n    animations.push(animation);\n  }\n  if (transitionEnd) {\n    Promise.all(animations).then(() => {\n      transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n  }\n  return animations;\n}\nconst distance = (a, b) => Math.abs(a - b);\nfunction distance2D(a, b) {\n  // Multi-dimensional\n  const xDelta = distance(a.x, b.x);\n  const yDelta = distance(a.y, b.y);\n  return Math.sqrt(xDelta ** 2 + yDelta ** 2);\n}\nconst createAxisDelta = () => ({\n  translate: 0,\n  scale: 1,\n  origin: 0,\n  originPoint: 0\n});\nconst createDelta = () => ({\n  x: createAxisDelta(),\n  y: createAxisDelta()\n});\nconst createAxis = () => ({\n  min: 0,\n  max: 0\n});\nconst createBox = () => ({\n  x: createAxis(),\n  y: createAxis()\n});\n\n/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox(_ref24) {\n  let {\n    top,\n    left,\n    right,\n    bottom\n  } = _ref24;\n  return {\n    x: {\n      min: left,\n      max: right\n    },\n    y: {\n      min: top,\n      max: bottom\n    }\n  };\n}\nfunction convertBoxToBoundingBox(_ref25) {\n  let {\n    x,\n    y\n  } = _ref25;\n  return {\n    top: y.min,\n    right: x.max,\n    bottom: y.max,\n    left: x.min\n  };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n  if (!transformPoint) return point;\n  const topLeft = transformPoint({\n    x: point.left,\n    y: point.top\n  });\n  const bottomRight = transformPoint({\n    x: point.right,\n    y: point.bottom\n  });\n  return {\n    top: topLeft.y,\n    left: topLeft.x,\n    bottom: bottomRight.y,\n    right: bottomRight.x\n  };\n}\nfunction isIdentityScale(scale) {\n  return scale === undefined || scale === 1;\n}\nfunction hasScale(_ref26) {\n  let {\n    scale,\n    scaleX,\n    scaleY\n  } = _ref26;\n  return !isIdentityScale(scale) || !isIdentityScale(scaleX) || !isIdentityScale(scaleY);\n}\nfunction hasTransform(values) {\n  return hasScale(values) || has2DTranslate(values) || values.z || values.rotate || values.rotateX || values.rotateY;\n}\nfunction has2DTranslate(values) {\n  return is2DTranslate(values.x) || is2DTranslate(values.y);\n}\nfunction is2DTranslate(value) {\n  return value && value !== \"0%\";\n}\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n  const distanceFromOrigin = point - originPoint;\n  const scaled = scale * distanceFromOrigin;\n  return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n  if (boxScale !== undefined) {\n    point = scalePoint(point, boxScale, originPoint);\n  }\n  return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis) {\n  let translate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  let scale = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n  let originPoint = arguments.length > 3 ? arguments[3] : undefined;\n  let boxScale = arguments.length > 4 ? arguments[4] : undefined;\n  axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n  axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _ref27) {\n  let {\n    x,\n    y\n  } = _ref27;\n  applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n  applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath) {\n  let isSharedTransition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n  const treeLength = treePath.length;\n  if (!treeLength) return;\n  // Reset the treeScale\n  treeScale.x = treeScale.y = 1;\n  let node;\n  let delta;\n  for (let i = 0; i < treeLength; i++) {\n    node = treePath[i];\n    delta = node.projectionDelta;\n    /**\n     * TODO: Prefer to remove this, but currently we have motion components with\n     * display: contents in Framer.\n     */\n    const instance = node.instance;\n    if (instance && instance.style && instance.style.display === \"contents\") {\n      continue;\n    }\n    if (isSharedTransition && node.options.layoutScroll && node.scroll && node !== node.root) {\n      transformBox(box, {\n        x: -node.scroll.offset.x,\n        y: -node.scroll.offset.y\n      });\n    }\n    if (delta) {\n      // Incoporate each ancestor's scale into a culmulative treeScale for this component\n      treeScale.x *= delta.x.scale;\n      treeScale.y *= delta.y.scale;\n      // Apply each ancestor's calculated delta into this component's recorded layout box\n      applyBoxDelta(box, delta);\n    }\n    if (isSharedTransition && hasTransform(node.latestValues)) {\n      transformBox(box, node.latestValues);\n    }\n  }\n  /**\n   * Snap tree scale back to 1 if it's within a non-perceivable threshold.\n   * This will help reduce useless scales getting rendered.\n   */\n  treeScale.x = snapToDefault(treeScale.x);\n  treeScale.y = snapToDefault(treeScale.y);\n}\nfunction snapToDefault(scale) {\n  if (Number.isInteger(scale)) return scale;\n  return scale > 1.0000000000001 || scale < 0.999999999999 ? scale : 1;\n}\nfunction translateAxis(axis, distance) {\n  axis.min = axis.min + distance;\n  axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, transforms, _ref28) {\n  let [key, scaleKey, originKey] = _ref28;\n  const axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n  const originPoint = mix(axis.min, axis.max, axisOrigin);\n  // Apply the axis delta to the final axis\n  applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n  transformAxis(box.x, transform, xKeys);\n  transformAxis(box.y, transform, yKeys);\n}\nfunction measureViewportBox(instance, transformPoint) {\n  return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n  const viewportBox = measureViewportBox(element, transformPagePoint);\n  const {\n    scroll\n  } = rootProjectionNode;\n  if (scroll) {\n    translateAxis(viewportBox.x, scroll.offset.x);\n    translateAxis(viewportBox.y, scroll.offset.y);\n  }\n  return viewportBox;\n}\n\n/**\n * Timeout defined in ms\n */\nfunction delay(callback, timeout) {\n  const start = performance.now();\n  const checkElapsed = _ref29 => {\n    let {\n      timestamp\n    } = _ref29;\n    const elapsed = timestamp - start;\n    if (elapsed >= timeout) {\n      cancelFrame(checkElapsed);\n      callback(elapsed - timeout);\n    }\n  };\n  frame.read(checkElapsed, true);\n  return () => cancelFrame(checkElapsed);\n}\nfunction resolveElements(elements, scope, selectorCache) {\n  var _a;\n  if (typeof elements === \"string\") {\n    let root = document;\n    if (scope) {\n      exports.invariant(Boolean(scope.current), \"Scope provided, but no element detected.\");\n      root = scope.current;\n    }\n    if (selectorCache) {\n      (_a = selectorCache[elements]) !== null && _a !== void 0 ? _a : selectorCache[elements] = root.querySelectorAll(elements);\n      elements = selectorCache[elements];\n    } else {\n      elements = root.querySelectorAll(elements);\n    }\n  } else if (elements instanceof Element) {\n    elements = [elements];\n  }\n  /**\n   * Return an empty array\n   */\n  return Array.from(elements || []);\n}\nconst visualElementStore = new WeakMap();\nfunction observeTimeline(update, timeline) {\n  let prevProgress;\n  const onFrame = () => {\n    const {\n      currentTime\n    } = timeline;\n    const percentage = currentTime === null ? 0 : currentTime.value;\n    const progress = percentage / 100;\n    if (prevProgress !== progress) {\n      update(progress);\n    }\n    prevProgress = progress;\n  };\n  frame.update(onFrame, true);\n  return () => cancelFrame(onFrame);\n}\nconst supportsScrollTimeline = memo(() => window.ScrollTimeline !== undefined);\nclass GroupPlaybackControls {\n  constructor(animations) {\n    this.animations = animations.filter(Boolean);\n  }\n  then(onResolve, onReject) {\n    return Promise.all(this.animations).then(onResolve).catch(onReject);\n  }\n  /**\n   * TODO: Filter out cancelled or stopped animations before returning\n   */\n  getAll(propName) {\n    return this.animations[0][propName];\n  }\n  setAll(propName, newValue) {\n    for (let i = 0; i < this.animations.length; i++) {\n      this.animations[i][propName] = newValue;\n    }\n  }\n  attachTimeline(timeline) {\n    const cancelAll = this.animations.map(animation => {\n      if (supportsScrollTimeline() && animation.attachTimeline) {\n        animation.attachTimeline(timeline);\n      } else {\n        animation.pause();\n        return observeTimeline(progress => {\n          animation.time = animation.duration * progress;\n        }, timeline);\n      }\n    });\n    return () => {\n      cancelAll.forEach((cancelTimeline, i) => {\n        if (cancelTimeline) cancelTimeline();\n        this.animations[i].stop();\n      });\n    };\n  }\n  get time() {\n    return this.getAll(\"time\");\n  }\n  set time(time) {\n    this.setAll(\"time\", time);\n  }\n  get speed() {\n    return this.getAll(\"speed\");\n  }\n  set speed(speed) {\n    this.setAll(\"speed\", speed);\n  }\n  get duration() {\n    let max = 0;\n    for (let i = 0; i < this.animations.length; i++) {\n      max = Math.max(max, this.animations[i].duration);\n    }\n    return max;\n  }\n  runAll(methodName) {\n    this.animations.forEach(controls => controls[methodName]());\n  }\n  play() {\n    this.runAll(\"play\");\n  }\n  pause() {\n    this.runAll(\"pause\");\n  }\n  stop() {\n    this.runAll(\"stop\");\n  }\n  cancel() {\n    this.runAll(\"cancel\");\n  }\n  complete() {\n    this.runAll(\"complete\");\n  }\n}\nfunction isDOMKeyframes(keyframes) {\n  return typeof keyframes === \"object\" && !Array.isArray(keyframes);\n}\nfunction isSVGElement(element) {\n  return element instanceof SVGElement && element.tagName !== \"svg\";\n}\n\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst splitCSSVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n  const match = splitCSSVariableRegex.exec(current);\n  if (!match) return [,];\n  const [, token, fallback] = match;\n  return [token, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element) {\n  let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n  exports.invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n  const [token, fallback] = parseCSSVariable(current);\n  // No CSS variable detected\n  if (!token) return;\n  // Attempt to read this CSS variable off the element\n  const resolved = window.getComputedStyle(element).getPropertyValue(token);\n  if (resolved) {\n    const trimmed = resolved.trim();\n    return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;\n  } else if (isCSSVariableToken(fallback)) {\n    // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n    return getVariableValue(fallback, element, depth + 1);\n  } else {\n    return fallback;\n  }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _ref30, transitionEnd) {\n  let {\n    ...target\n  } = _ref30;\n  const element = visualElement.current;\n  if (!(element instanceof Element)) return {\n    target,\n    transitionEnd\n  };\n  // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n  // only if they change but I think this reads clearer and this isn't a performance-critical path.\n  if (transitionEnd) {\n    transitionEnd = {\n      ...transitionEnd\n    };\n  }\n  // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n  visualElement.values.forEach(value => {\n    const current = value.get();\n    if (!isCSSVariableToken(current)) return;\n    const resolved = getVariableValue(current, element);\n    if (resolved) value.set(resolved);\n  });\n  // Cycle through every target property and resolve CSS variables. Currently\n  // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n  for (const key in target) {\n    const current = target[key];\n    if (!isCSSVariableToken(current)) continue;\n    const resolved = getVariableValue(current, element);\n    if (!resolved) continue;\n    // Clone target if it hasn't already been\n    target[key] = resolved;\n    if (!transitionEnd) transitionEnd = {};\n    // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n    // CSS variable. This will ensure that after the animation the component will reflect\n    // changes in the value of the CSS variable.\n    if (transitionEnd[key] === undefined) {\n      transitionEnd[key] = current;\n    }\n  }\n  return {\n    target,\n    transitionEnd\n  };\n}\nconst positionalKeys = new Set([\"width\", \"height\", \"top\", \"left\", \"right\", \"bottom\", \"x\", \"y\", \"translateX\", \"translateY\"]);\nconst isPositionalKey = key => positionalKeys.has(key);\nconst hasPositionalKey = target => {\n  return Object.keys(target).some(isPositionalKey);\n};\nconst isNumOrPxType = v => v === number || v === px;\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, _ref31) => {\n  let {\n    transform\n  } = _ref31;\n  if (transform === \"none\" || !transform) return 0;\n  const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n  if (matrix3d) {\n    return getPosFromMatrix(matrix3d[1], pos3);\n  } else {\n    const matrix = transform.match(/^matrix\\((.+)\\)$/);\n    if (matrix) {\n      return getPosFromMatrix(matrix[1], pos2);\n    } else {\n      return 0;\n    }\n  }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter(key => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n  const removedTransforms = [];\n  nonTranslationalTransformKeys.forEach(key => {\n    const value = visualElement.getValue(key);\n    if (value !== undefined) {\n      removedTransforms.push([key, value.get()]);\n      value.set(key.startsWith(\"scale\") ? 1 : 0);\n    }\n  });\n  // Apply changes to element before measurement\n  if (removedTransforms.length) visualElement.render();\n  return removedTransforms;\n}\nconst positionalValues = {\n  // Dimensions\n  width: (_ref32, _ref33) => {\n    let {\n      x\n    } = _ref32;\n    let {\n      paddingLeft = \"0\",\n      paddingRight = \"0\"\n    } = _ref33;\n    return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n  },\n  height: (_ref34, _ref35) => {\n    let {\n      y\n    } = _ref34;\n    let {\n      paddingTop = \"0\",\n      paddingBottom = \"0\"\n    } = _ref35;\n    return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n  },\n  top: (_bbox, _ref36) => {\n    let {\n      top\n    } = _ref36;\n    return parseFloat(top);\n  },\n  left: (_bbox, _ref37) => {\n    let {\n      left\n    } = _ref37;\n    return parseFloat(left);\n  },\n  bottom: (_ref38, _ref39) => {\n    let {\n      y\n    } = _ref38;\n    let {\n      top\n    } = _ref39;\n    return parseFloat(top) + (y.max - y.min);\n  },\n  right: (_ref40, _ref41) => {\n    let {\n      x\n    } = _ref40;\n    let {\n      left\n    } = _ref41;\n    return parseFloat(left) + (x.max - x.min);\n  },\n  // Transform\n  x: getTranslateFromMatrix(4, 13),\n  y: getTranslateFromMatrix(5, 14)\n};\n// Alias translate longform names\npositionalValues.translateX = positionalValues.x;\npositionalValues.translateY = positionalValues.y;\nconst convertChangedValueTypes = (target, visualElement, changedKeys) => {\n  const originBbox = visualElement.measureViewportBox();\n  const element = visualElement.current;\n  const elementComputedStyle = getComputedStyle(element);\n  const {\n    display\n  } = elementComputedStyle;\n  const origin = {};\n  // If the element is currently set to display: \"none\", make it visible before\n  // measuring the target bounding box\n  if (display === \"none\") {\n    visualElement.setStaticValue(\"display\", target.display || \"block\");\n  }\n  /**\n   * Record origins before we render and update styles\n   */\n  changedKeys.forEach(key => {\n    origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n  });\n  // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n  visualElement.render();\n  const targetBbox = visualElement.measureViewportBox();\n  changedKeys.forEach(key => {\n    // Restore styles to their **calculated computed style**, not their actual\n    // originally set style. This allows us to animate between equivalent pixel units.\n    const value = visualElement.getValue(key);\n    value && value.jump(origin[key]);\n    target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n  });\n  return target;\n};\nconst checkAndConvertChangedValueTypes = function (visualElement, target) {\n  let origin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  let transitionEnd = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  target = {\n    ...target\n  };\n  transitionEnd = {\n    ...transitionEnd\n  };\n  const targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n  // We want to remove any transform values that could affect the element's bounding box before\n  // it's measured. We'll reapply these later.\n  let removedTransformValues = [];\n  let hasAttemptedToRemoveTransformValues = false;\n  const changedValueTypeKeys = [];\n  targetPositionalKeys.forEach(key => {\n    const value = visualElement.getValue(key);\n    if (!visualElement.hasValue(key)) return;\n    let from = origin[key];\n    let fromType = findDimensionValueType(from);\n    const to = target[key];\n    let toType;\n    // TODO: The current implementation of this basically throws an error\n    // if you try and do value conversion via keyframes. There's probably\n    // a way of doing this but the performance implications would need greater scrutiny,\n    // as it'd be doing multiple resize-remeasure operations.\n    if (isKeyframesTarget(to)) {\n      const numKeyframes = to.length;\n      const fromIndex = to[0] === null ? 1 : 0;\n      from = to[fromIndex];\n      fromType = findDimensionValueType(from);\n      for (let i = fromIndex; i < numKeyframes; i++) {\n        /**\n         * Don't allow wildcard keyframes to be used to detect\n         * a difference in value types.\n         */\n        if (to[i] === null) break;\n        if (!toType) {\n          toType = findDimensionValueType(to[i]);\n          exports.invariant(toType === fromType || isNumOrPxType(fromType) && isNumOrPxType(toType), \"Keyframes must be of the same dimension as the current value\");\n        } else {\n          exports.invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n        }\n      }\n    } else {\n      toType = findDimensionValueType(to);\n    }\n    if (fromType !== toType) {\n      // If they're both just number or px, convert them both to numbers rather than\n      // relying on resize/remeasure to convert (which is wasteful in this situation)\n      if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n        const current = value.get();\n        if (typeof current === \"string\") {\n          value.set(parseFloat(current));\n        }\n        if (typeof to === \"string\") {\n          target[key] = parseFloat(to);\n        } else if (Array.isArray(to) && toType === px) {\n          target[key] = to.map(parseFloat);\n        }\n      } else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) && (toType === null || toType === void 0 ? void 0 : toType.transform) && (from === 0 || to === 0)) {\n        // If one or the other value is 0, it's safe to coerce it to the\n        // type of the other without measurement\n        if (from === 0) {\n          value.set(toType.transform(from));\n        } else {\n          target[key] = fromType.transform(to);\n        }\n      } else {\n        // If we're going to do value conversion via DOM measurements, we first\n        // need to remove non-positional transform values that could affect the bbox measurements.\n        if (!hasAttemptedToRemoveTransformValues) {\n          removedTransformValues = removeNonTranslationalTransform(visualElement);\n          hasAttemptedToRemoveTransformValues = true;\n        }\n        changedValueTypeKeys.push(key);\n        transitionEnd[key] = transitionEnd[key] !== undefined ? transitionEnd[key] : target[key];\n        value.jump(to);\n      }\n    }\n  });\n  if (changedValueTypeKeys.length) {\n    const scrollY = changedValueTypeKeys.indexOf(\"height\") >= 0 ? window.pageYOffset : null;\n    const convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n    // If we removed transform values, reapply them before the next render\n    if (removedTransformValues.length) {\n      removedTransformValues.forEach(_ref42 => {\n        let [key, value] = _ref42;\n        visualElement.getValue(key).set(value);\n      });\n    }\n    // Reapply original values\n    visualElement.render();\n    // Restore scroll position\n    if (isBrowser && scrollY !== null) {\n      window.scrollTo({\n        top: scrollY\n      });\n    }\n    return {\n      target: convertedTarget,\n      transitionEnd\n    };\n  } else {\n    return {\n      target,\n      transitionEnd\n    };\n  }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n  return hasPositionalKey(target) ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd) : {\n    target,\n    transitionEnd\n  };\n}\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nconst parseDomVariant = (visualElement, target, origin, transitionEnd) => {\n  const resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n  target = resolved.target;\n  transitionEnd = resolved.transitionEnd;\n  return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = {\n  current: null\n};\nconst hasReducedMotionListener = {\n  current: false\n};\nfunction initPrefersReducedMotion() {\n  hasReducedMotionListener.current = true;\n  if (!isBrowser) return;\n  if (window.matchMedia) {\n    const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n    const setReducedMotionPreferences = () => prefersReducedMotion.current = motionMediaQuery.matches;\n    motionMediaQuery.addListener(setReducedMotionPreferences);\n    setReducedMotionPreferences();\n  } else {\n    prefersReducedMotion.current = false;\n  }\n}\nfunction updateMotionValuesFromProps(element, next, prev) {\n  const {\n    willChange\n  } = next;\n  for (const key in next) {\n    const nextValue = next[key];\n    const prevValue = prev[key];\n    if (isMotionValue(nextValue)) {\n      /**\n       * If this is a motion value found in props or style, we want to add it\n       * to our visual element's motion value map.\n       */\n      element.addValue(key, nextValue);\n      if (isWillChangeMotionValue(willChange)) {\n        willChange.add(key);\n      }\n      /**\n       * Check the version of the incoming motion value with this version\n       * and warn against mismatches.\n       */\n      if (process.env.NODE_ENV === \"development\") {\n        warnOnce(nextValue.version === \"10.16.16\", `Attempting to mix Framer Motion versions ${nextValue.version} with 10.16.16 may not work as expected.`);\n      }\n    } else if (isMotionValue(prevValue)) {\n      /**\n       * If we're swapping from a motion value to a static value,\n       * create a new motion value from that\n       */\n      element.addValue(key, motionValue(nextValue, {\n        owner: element\n      }));\n      if (isWillChangeMotionValue(willChange)) {\n        willChange.remove(key);\n      }\n    } else if (prevValue !== nextValue) {\n      /**\n       * If this is a flat value that has changed, update the motion value\n       * or create one if it doesn't exist. We only want to do this if we're\n       * not handling the value with our animation state.\n       */\n      if (element.hasValue(key)) {\n        const existingValue = element.getValue(key);\n        // TODO: Only update values that aren't being animated or even looked at\n        !existingValue.hasAnimated && existingValue.set(nextValue);\n      } else {\n        const latestValue = element.getStaticValue(key);\n        element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, {\n          owner: element\n        }));\n      }\n    }\n  }\n  // Handle removed values\n  for (const key in prev) {\n    if (next[key] === undefined) element.removeValue(key);\n  }\n  return next;\n}\nconst featureNames = Object.keys(featureDefinitions);\nconst numFeatures = featureNames.length;\nconst propEventHandlers = [\"AnimationStart\", \"AnimationComplete\", \"Update\", \"BeforeLayoutMeasure\", \"LayoutMeasure\", \"LayoutAnimationStart\", \"LayoutAnimationComplete\"];\nconst numVariantProps = variantProps.length;\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n  constructor(_ref43) {\n    let {\n      parent,\n      props,\n      presenceContext,\n      reducedMotionConfig,\n      visualState\n    } = _ref43;\n    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    /**\n     * A reference to the current underlying Instance, e.g. a HTMLElement\n     * or Three.Mesh etc.\n     */\n    this.current = null;\n    /**\n     * A set containing references to this VisualElement's children.\n     */\n    this.children = new Set();\n    /**\n     * Determine what role this visual element should take in the variant tree.\n     */\n    this.isVariantNode = false;\n    this.isControllingVariants = false;\n    /**\n     * Decides whether this VisualElement should animate in reduced motion\n     * mode.\n     *\n     * TODO: This is currently set on every individual VisualElement but feels\n     * like it could be set globally.\n     */\n    this.shouldReduceMotion = null;\n    /**\n     * A map of all motion values attached to this visual element. Motion\n     * values are source of truth for any given animated value. A motion\n     * value might be provided externally by the component via props.\n     */\n    this.values = new Map();\n    /**\n     * Cleanup functions for active features (hover/tap/exit etc)\n     */\n    this.features = {};\n    /**\n     * A map of every subscription that binds the provided or generated\n     * motion values onChange listeners to this visual element.\n     */\n    this.valueSubscriptions = new Map();\n    /**\n     * A reference to the previously-provided motion values as returned\n     * from scrapeMotionValuesFromProps. We use the keys in here to determine\n     * if any motion values need to be removed after props are updated.\n     */\n    this.prevMotionValues = {};\n    /**\n     * An object containing a SubscriptionManager for each active event.\n     */\n    this.events = {};\n    /**\n     * An object containing an unsubscribe function for each prop event subscription.\n     * For example, every \"Update\" event can have multiple subscribers via\n     * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n     */\n    this.propEventSubscriptions = {};\n    this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n    this.render = () => {\n      if (!this.current) return;\n      this.triggerBuild();\n      this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n    };\n    this.scheduleRender = () => frame.render(this.render, false, true);\n    const {\n      latestValues,\n      renderState\n    } = visualState;\n    this.latestValues = latestValues;\n    this.baseTarget = {\n      ...latestValues\n    };\n    this.initialValues = props.initial ? {\n      ...latestValues\n    } : {};\n    this.renderState = renderState;\n    this.parent = parent;\n    this.props = props;\n    this.presenceContext = presenceContext;\n    this.depth = parent ? parent.depth + 1 : 0;\n    this.reducedMotionConfig = reducedMotionConfig;\n    this.options = options;\n    this.isControllingVariants = isControllingVariants(props);\n    this.isVariantNode = isVariantNode(props);\n    if (this.isVariantNode) {\n      this.variantChildren = new Set();\n    }\n    this.manuallyAnimateOnMount = Boolean(parent && parent.current);\n    /**\n     * Any motion values that are provided to the element when created\n     * aren't yet bound to the element, as this would technically be impure.\n     * However, we iterate through the motion values and set them to the\n     * initial values for this component.\n     *\n     * TODO: This is impure and we should look at changing this to run on mount.\n     * Doing so will break some tests but this isn't neccessarily a breaking change,\n     * more a reflection of the test.\n     */\n    const {\n      willChange,\n      ...initialMotionValues\n    } = this.scrapeMotionValuesFromProps(props, {});\n    for (const key in initialMotionValues) {\n      const value = initialMotionValues[key];\n      if (latestValues[key] !== undefined && isMotionValue(value)) {\n        value.set(latestValues[key], false);\n        if (isWillChangeMotionValue(willChange)) {\n          willChange.add(key);\n        }\n      }\n    }\n  }\n  /**\n   * This method takes React props and returns found MotionValues. For example, HTML\n   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n   *\n   * This isn't an abstract method as it needs calling in the constructor, but it is\n   * intended to be one.\n   */\n  scrapeMotionValuesFromProps(_props, _prevProps) {\n    return {};\n  }\n  mount(instance) {\n    this.current = instance;\n    visualElementStore.set(instance, this);\n    if (this.projection && !this.projection.instance) {\n      this.projection.mount(instance);\n    }\n    if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n      this.removeFromVariantTree = this.parent.addVariantChild(this);\n    }\n    this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n    if (!hasReducedMotionListener.current) {\n      initPrefersReducedMotion();\n    }\n    this.shouldReduceMotion = this.reducedMotionConfig === \"never\" ? false : this.reducedMotionConfig === \"always\" ? true : prefersReducedMotion.current;\n    if (process.env.NODE_ENV !== \"production\") {\n      warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n    }\n    if (this.parent) this.parent.children.add(this);\n    this.update(this.props, this.presenceContext);\n  }\n  unmount() {\n    visualElementStore.delete(this.current);\n    this.projection && this.projection.unmount();\n    cancelFrame(this.notifyUpdate);\n    cancelFrame(this.render);\n    this.valueSubscriptions.forEach(remove => remove());\n    this.removeFromVariantTree && this.removeFromVariantTree();\n    this.parent && this.parent.children.delete(this);\n    for (const key in this.events) {\n      this.events[key].clear();\n    }\n    for (const key in this.features) {\n      this.features[key].unmount();\n    }\n    this.current = null;\n  }\n  bindToMotionValue(key, value) {\n    const valueIsTransform = transformProps.has(key);\n    const removeOnChange = value.on(\"change\", latestValue => {\n      this.latestValues[key] = latestValue;\n      this.props.onUpdate && frame.update(this.notifyUpdate, false, true);\n      if (valueIsTransform && this.projection) {\n        this.projection.isTransformDirty = true;\n      }\n    });\n    const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n    this.valueSubscriptions.set(key, () => {\n      removeOnChange();\n      removeOnRenderRequest();\n    });\n  }\n  sortNodePosition(other) {\n    /**\n     * If these nodes aren't even of the same type we can't compare their depth.\n     */\n    if (!this.current || !this.sortInstanceNodePosition || this.type !== other.type) {\n      return 0;\n    }\n    return this.sortInstanceNodePosition(this.current, other.current);\n  }\n  loadFeatures(_ref44, isStrict, preloadedFeatures, initialLayoutGroupConfig) {\n    let {\n      children,\n      ...renderedProps\n    } = _ref44;\n    let ProjectionNodeConstructor;\n    let MeasureLayout;\n    /**\n     * If we're in development mode, check to make sure we're not rendering a motion component\n     * as a child of LazyMotion, as this will break the file-size benefits of using it.\n     */\n    if (process.env.NODE_ENV !== \"production\" && preloadedFeatures && isStrict) {\n      const strictMessage = \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\";\n      renderedProps.ignoreStrict ? exports.warning(false, strictMessage) : exports.invariant(false, strictMessage);\n    }\n    for (let i = 0; i < numFeatures; i++) {\n      const name = featureNames[i];\n      const {\n        isEnabled,\n        Feature: FeatureConstructor,\n        ProjectionNode,\n        MeasureLayout: MeasureLayoutComponent\n      } = featureDefinitions[name];\n      if (ProjectionNode) ProjectionNodeConstructor = ProjectionNode;\n      if (isEnabled(renderedProps)) {\n        if (!this.features[name] && FeatureConstructor) {\n          this.features[name] = new FeatureConstructor(this);\n        }\n        if (MeasureLayoutComponent) {\n          MeasureLayout = MeasureLayoutComponent;\n        }\n      }\n    }\n    if (!this.projection && ProjectionNodeConstructor) {\n      this.projection = new ProjectionNodeConstructor(this.latestValues, this.parent && this.parent.projection);\n      const {\n        layoutId,\n        layout,\n        drag,\n        dragConstraints,\n        layoutScroll,\n        layoutRoot\n      } = renderedProps;\n      this.projection.setOptions({\n        layoutId,\n        layout,\n        alwaysMeasureLayout: Boolean(drag) || dragConstraints && isRefObject(dragConstraints),\n        visualElement: this,\n        scheduleRender: () => this.scheduleRender(),\n        /**\n         * TODO: Update options in an effect. This could be tricky as it'll be too late\n         * to update by the time layout animations run.\n         * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n         * ensuring it gets called if there's no potential layout animations.\n         *\n         */\n        animationType: typeof layout === \"string\" ? layout : \"both\",\n        initialPromotionConfig: initialLayoutGroupConfig,\n        layoutScroll,\n        layoutRoot\n      });\n    }\n    return MeasureLayout;\n  }\n  updateFeatures() {\n    for (const key in this.features) {\n      const feature = this.features[key];\n      if (feature.isMounted) {\n        feature.update();\n      } else {\n        feature.mount();\n        feature.isMounted = true;\n      }\n    }\n  }\n  triggerBuild() {\n    this.build(this.renderState, this.latestValues, this.options, this.props);\n  }\n  /**\n   * Measure the current viewport box with or without transforms.\n   * Only measures axis-aligned boxes, rotate and skew must be manually\n   * removed with a re-render to work.\n   */\n  measureViewportBox() {\n    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : createBox();\n  }\n  getStaticValue(key) {\n    return this.latestValues[key];\n  }\n  setStaticValue(key, value) {\n    this.latestValues[key] = value;\n  }\n  /**\n   * Make a target animatable by Popmotion. For instance, if we're\n   * trying to animate width from 100px to 100vw we need to measure 100vw\n   * in pixels to determine what we really need to animate to. This is also\n   * pluggable to support Framer's custom value types like Color,\n   * and CSS variables.\n   */\n  makeTargetAnimatable(target) {\n    let canMutate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n    return this.makeTargetAnimatableFromInstance(target, this.props, canMutate);\n  }\n  /**\n   * Update the provided props. Ensure any newly-added motion values are\n   * added to our map, old ones removed, and listeners updated.\n   */\n  update(props, presenceContext) {\n    if (props.transformTemplate || this.props.transformTemplate) {\n      this.scheduleRender();\n    }\n    this.prevProps = this.props;\n    this.props = props;\n    this.prevPresenceContext = this.presenceContext;\n    this.presenceContext = presenceContext;\n    /**\n     * Update prop event handlers ie onAnimationStart, onAnimationComplete\n     */\n    for (let i = 0; i < propEventHandlers.length; i++) {\n      const key = propEventHandlers[i];\n      if (this.propEventSubscriptions[key]) {\n        this.propEventSubscriptions[key]();\n        delete this.propEventSubscriptions[key];\n      }\n      const listener = props[\"on\" + key];\n      if (listener) {\n        this.propEventSubscriptions[key] = this.on(key, listener);\n      }\n    }\n    this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps), this.prevMotionValues);\n    if (this.handleChildMotionValue) {\n      this.handleChildMotionValue();\n    }\n  }\n  getProps() {\n    return this.props;\n  }\n  /**\n   * Returns the variant definition with a given name.\n   */\n  getVariant(name) {\n    return this.props.variants ? this.props.variants[name] : undefined;\n  }\n  /**\n   * Returns the defined default transition on this component.\n   */\n  getDefaultTransition() {\n    return this.props.transition;\n  }\n  getTransformPagePoint() {\n    return this.props.transformPagePoint;\n  }\n  getClosestVariantNode() {\n    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : undefined;\n  }\n  getVariantContext() {\n    let startAtParent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n    if (startAtParent) {\n      return this.parent ? this.parent.getVariantContext() : undefined;\n    }\n    if (!this.isControllingVariants) {\n      const context = this.parent ? this.parent.getVariantContext() || {} : {};\n      if (this.props.initial !== undefined) {\n        context.initial = this.props.initial;\n      }\n      return context;\n    }\n    const context = {};\n    for (let i = 0; i < numVariantProps; i++) {\n      const name = variantProps[i];\n      const prop = this.props[name];\n      if (isVariantLabel(prop) || prop === false) {\n        context[name] = prop;\n      }\n    }\n    return context;\n  }\n  /**\n   * Add a child visual element to our set of children.\n   */\n  addVariantChild(child) {\n    const closestVariantNode = this.getClosestVariantNode();\n    if (closestVariantNode) {\n      closestVariantNode.variantChildren && closestVariantNode.variantChildren.add(child);\n      return () => closestVariantNode.variantChildren.delete(child);\n    }\n  }\n  /**\n   * Add a motion value and bind it to this visual element.\n   */\n  addValue(key, value) {\n    // Remove existing value if it exists\n    if (value !== this.values.get(key)) {\n      this.removeValue(key);\n      this.bindToMotionValue(key, value);\n    }\n    this.values.set(key, value);\n    this.latestValues[key] = value.get();\n  }\n  /**\n   * Remove a motion value and unbind any active subscriptions.\n   */\n  removeValue(key) {\n    this.values.delete(key);\n    const unsubscribe = this.valueSubscriptions.get(key);\n    if (unsubscribe) {\n      unsubscribe();\n      this.valueSubscriptions.delete(key);\n    }\n    delete this.latestValues[key];\n    this.removeValueFromRenderState(key, this.renderState);\n  }\n  /**\n   * Check whether we have a motion value for this key\n   */\n  hasValue(key) {\n    return this.values.has(key);\n  }\n  getValue(key, defaultValue) {\n    if (this.props.values && this.props.values[key]) {\n      return this.props.values[key];\n    }\n    let value = this.values.get(key);\n    if (value === undefined && defaultValue !== undefined) {\n      value = motionValue(defaultValue, {\n        owner: this\n      });\n      this.addValue(key, value);\n    }\n    return value;\n  }\n  /**\n   * If we're trying to animate to a previously unencountered value,\n   * we need to check for it in our state and as a last resort read it\n   * directly from the instance (which might have performance implications).\n   */\n  readValue(key) {\n    var _a;\n    return this.latestValues[key] !== undefined || !this.current ? this.latestValues[key] : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);\n  }\n  /**\n   * Set the base target to later animate back to. This is currently\n   * only hydrated on creation and when we first read a value.\n   */\n  setBaseTarget(key, value) {\n    this.baseTarget[key] = value;\n  }\n  /**\n   * Find the base target for a value thats been removed from all animation\n   * props.\n   */\n  getBaseTarget(key) {\n    var _a;\n    const {\n      initial\n    } = this.props;\n    const valueFromInitial = typeof initial === \"string\" || typeof initial === \"object\" ? (_a = resolveVariantFromProps(this.props, initial)) === null || _a === void 0 ? void 0 : _a[key] : undefined;\n    /**\n     * If this value still exists in the current initial variant, read that.\n     */\n    if (initial && valueFromInitial !== undefined) {\n      return valueFromInitial;\n    }\n    /**\n     * Alternatively, if this VisualElement config has defined a getBaseTarget\n     * so we can read the value from an alternative source, try that.\n     */\n    const target = this.getBaseTargetFromProps(this.props, key);\n    if (target !== undefined && !isMotionValue(target)) return target;\n    /**\n     * If the value was initially defined on initial, but it doesn't any more,\n     * return undefined. Otherwise return the value as initially read from the DOM.\n     */\n    return this.initialValues[key] !== undefined && valueFromInitial === undefined ? undefined : this.baseTarget[key];\n  }\n  on(eventName, callback) {\n    if (!this.events[eventName]) {\n      this.events[eventName] = new SubscriptionManager();\n    }\n    return this.events[eventName].add(callback);\n  }\n  notify(eventName) {\n    if (this.events[eventName]) {\n      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        args[_key2 - 1] = arguments[_key2];\n      }\n      this.events[eventName].notify(...args);\n    }\n  }\n}\nclass DOMVisualElement extends VisualElement {\n  sortInstanceNodePosition(a, b) {\n    /**\n     * compareDocumentPosition returns a bitmask, by using the bitwise &\n     * we're returning true if 2 in that bitmask is set to true. 2 is set\n     * to true if b preceeds a.\n     */\n    return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n  }\n  getBaseTargetFromProps(props, key) {\n    return props.style ? props.style[key] : undefined;\n  }\n  removeValueFromRenderState(key, _ref45) {\n    let {\n      vars,\n      style\n    } = _ref45;\n    delete vars[key];\n    delete style[key];\n  }\n  makeTargetAnimatableFromInstance(_ref46, _ref47, isMounted) {\n    let {\n      transition,\n      transitionEnd,\n      ...target\n    } = _ref46;\n    let {\n      transformValues\n    } = _ref47;\n    let origin = getOrigin(target, transition || {}, this);\n    /**\n     * If Framer has provided a function to convert `Color` etc value types, convert them\n     */\n    if (transformValues) {\n      if (transitionEnd) transitionEnd = transformValues(transitionEnd);\n      if (target) target = transformValues(target);\n      if (origin) origin = transformValues(origin);\n    }\n    if (isMounted) {\n      checkTargetForNewValues(this, target, origin);\n      const parsed = parseDomVariant(this, target, origin, transitionEnd);\n      transitionEnd = parsed.transitionEnd;\n      target = parsed.target;\n    }\n    return {\n      transition,\n      transitionEnd,\n      ...target\n    };\n  }\n}\nclass SVGVisualElement extends DOMVisualElement {\n  constructor() {\n    super(...arguments);\n    this.isSVGTag = false;\n  }\n  getBaseTargetFromProps(props, key) {\n    return props[key];\n  }\n  readValueFromInstance(instance, key) {\n    if (transformProps.has(key)) {\n      const defaultType = getDefaultValueType(key);\n      return defaultType ? defaultType.default || 0 : 0;\n    }\n    key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n    return instance.getAttribute(key);\n  }\n  measureInstanceViewportBox() {\n    return createBox();\n  }\n  scrapeMotionValuesFromProps(props, prevProps) {\n    return scrapeMotionValuesFromProps(props, prevProps);\n  }\n  build(renderState, latestValues, options, props) {\n    buildSVGAttrs(renderState, latestValues, options, this.isSVGTag, props.transformTemplate);\n  }\n  renderInstance(instance, renderState, styleProp, projection) {\n    renderSVG(instance, renderState, styleProp, projection);\n  }\n  mount(instance) {\n    this.isSVGTag = isSVGTag(instance.tagName);\n    super.mount(instance);\n  }\n}\nfunction getComputedStyle$1(element) {\n  return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n  readValueFromInstance(instance, key) {\n    if (transformProps.has(key)) {\n      const defaultType = getDefaultValueType(key);\n      return defaultType ? defaultType.default || 0 : 0;\n    } else {\n      const computedStyle = getComputedStyle$1(instance);\n      const value = (isCSSVariableName(key) ? computedStyle.getPropertyValue(key) : computedStyle[key]) || 0;\n      return typeof value === \"string\" ? value.trim() : value;\n    }\n  }\n  measureInstanceViewportBox(instance, _ref48) {\n    let {\n      transformPagePoint\n    } = _ref48;\n    return measureViewportBox(instance, transformPagePoint);\n  }\n  build(renderState, latestValues, options, props) {\n    buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n  }\n  scrapeMotionValuesFromProps(props, prevProps) {\n    return scrapeMotionValuesFromProps$1(props, prevProps);\n  }\n  handleChildMotionValue() {\n    if (this.childSubscription) {\n      this.childSubscription();\n      delete this.childSubscription;\n    }\n    const {\n      children\n    } = this.props;\n    if (isMotionValue(children)) {\n      this.childSubscription = children.on(\"change\", latest => {\n        if (this.current) this.current.textContent = `${latest}`;\n      });\n    }\n  }\n  renderInstance(instance, renderState, styleProp, projection) {\n    renderHTML(instance, renderState, styleProp, projection);\n  }\n}\nfunction createVisualElement(element) {\n  const options = {\n    presenceContext: null,\n    props: {},\n    visualState: {\n      renderState: {\n        transform: {},\n        transformOrigin: {},\n        style: {},\n        vars: {},\n        attrs: {}\n      },\n      latestValues: {}\n    }\n  };\n  const node = isSVGElement(element) ? new SVGVisualElement(options, {\n    enableHardwareAcceleration: false\n  }) : new HTMLVisualElement(options, {\n    enableHardwareAcceleration: true\n  });\n  node.mount(element);\n  visualElementStore.set(element, node);\n}\nfunction animateSingleValue(value, keyframes, options) {\n  const motionValue$1 = isMotionValue(value) ? value : motionValue(value);\n  motionValue$1.start(animateMotionValue(\"\", motionValue$1, keyframes, options));\n  return motionValue$1.animation;\n}\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options) {\n  let scale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;\n  const generator = spring({\n    keyframes: [0, scale],\n    ...options\n  });\n  const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n  return {\n    type: \"keyframes\",\n    ease: progress => generator.next(duration * progress).value / scale,\n    duration: millisecondsToSeconds(duration)\n  };\n}\n\n/**\n * Given a absolute or relative time definition and current/prev time state of the sequence,\n * calculate an absolute time for the next keyframes.\n */\nfunction calcNextTime(current, next, prev, labels) {\n  var _a;\n  if (typeof next === \"number\") {\n    return next;\n  } else if (next.startsWith(\"-\") || next.startsWith(\"+\")) {\n    return Math.max(0, current + parseFloat(next));\n  } else if (next === \"<\") {\n    return prev;\n  } else {\n    return (_a = labels.get(next)) !== null && _a !== void 0 ? _a : current;\n  }\n}\nconst wrap = (min, max, v) => {\n  const rangeSize = max - min;\n  return ((v - min) % rangeSize + rangeSize) % rangeSize + min;\n};\nfunction getEasingForSegment(easing, i) {\n  return isEasingArray(easing) ? easing[wrap(0, easing.length, i)] : easing;\n}\nfunction eraseKeyframes(sequence, startTime, endTime) {\n  for (let i = 0; i < sequence.length; i++) {\n    const keyframe = sequence[i];\n    if (keyframe.at > startTime && keyframe.at < endTime) {\n      removeItem(sequence, keyframe);\n      // If we remove this item we have to push the pointer back one\n      i--;\n    }\n  }\n}\nfunction addKeyframes(sequence, keyframes, easing, offset, startTime, endTime) {\n  /**\n   * Erase every existing value between currentTime and targetTime,\n   * this will essentially splice this timeline into any currently\n   * defined ones.\n   */\n  eraseKeyframes(sequence, startTime, endTime);\n  for (let i = 0; i < keyframes.length; i++) {\n    sequence.push({\n      value: keyframes[i],\n      at: mix(startTime, endTime, offset[i]),\n      easing: getEasingForSegment(easing, i)\n    });\n  }\n}\nfunction compareByTime(a, b) {\n  if (a.at === b.at) {\n    if (a.value === null) return 1;\n    if (b.value === null) return -1;\n    return 0;\n  } else {\n    return a.at - b.at;\n  }\n}\nconst defaultSegmentEasing = \"easeInOut\";\nfunction createAnimationsFromSequence(sequence) {\n  let {\n    defaultTransition = {},\n    ...sequenceTransition\n  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  let scope = arguments.length > 2 ? arguments[2] : undefined;\n  const defaultDuration = defaultTransition.duration || 0.3;\n  const animationDefinitions = new Map();\n  const sequences = new Map();\n  const elementCache = {};\n  const timeLabels = new Map();\n  let prevTime = 0;\n  let currentTime = 0;\n  let totalDuration = 0;\n  /**\n   * Build the timeline by mapping over the sequence array and converting\n   * the definitions into keyframes and offsets with absolute time values.\n   * These will later get converted into relative offsets in a second pass.\n   */\n  for (let i = 0; i < sequence.length; i++) {\n    const segment = sequence[i];\n    /**\n     * If this is a timeline label, mark it and skip the rest of this iteration.\n     */\n    if (typeof segment === \"string\") {\n      timeLabels.set(segment, currentTime);\n      continue;\n    } else if (!Array.isArray(segment)) {\n      timeLabels.set(segment.name, calcNextTime(currentTime, segment.at, prevTime, timeLabels));\n      continue;\n    }\n    let [subject, keyframes, transition = {}] = segment;\n    /**\n     * If a relative or absolute time value has been specified we need to resolve\n     * it in relation to the currentTime.\n     */\n    if (transition.at !== undefined) {\n      currentTime = calcNextTime(currentTime, transition.at, prevTime, timeLabels);\n    }\n    /**\n     * Keep track of the maximum duration in this definition. This will be\n     * applied to currentTime once the definition has been parsed.\n     */\n    let maxDuration = 0;\n    const resolveValueSequence = function (valueKeyframes, valueTransition, valueSequence) {\n      let elementIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n      let numElements = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;\n      const valueKeyframesAsList = keyframesAsList(valueKeyframes);\n      const {\n        delay = 0,\n        times = defaultOffset$1(valueKeyframesAsList),\n        type = \"keyframes\",\n        ...remainingTransition\n      } = valueTransition;\n      let {\n        ease = defaultTransition.ease || \"easeOut\",\n        duration\n      } = valueTransition;\n      /**\n       * Resolve stagger() if defined.\n       */\n      const calculatedDelay = typeof delay === \"function\" ? delay(elementIndex, numElements) : delay;\n      /**\n       * If this animation should and can use a spring, generate a spring easing function.\n       */\n      const numKeyframes = valueKeyframesAsList.length;\n      if (numKeyframes <= 2 && type === \"spring\") {\n        /**\n         * As we're creating an easing function from a spring,\n         * ideally we want to generate it using the real distance\n         * between the two keyframes. However this isn't always\n         * possible - in these situations we use 0-100.\n         */\n        let absoluteDelta = 100;\n        if (numKeyframes === 2 && isNumberKeyframesArray(valueKeyframesAsList)) {\n          const delta = valueKeyframesAsList[1] - valueKeyframesAsList[0];\n          absoluteDelta = Math.abs(delta);\n        }\n        const springTransition = {\n          ...remainingTransition\n        };\n        if (duration !== undefined) {\n          springTransition.duration = secondsToMilliseconds(duration);\n        }\n        const springEasing = createGeneratorEasing(springTransition, absoluteDelta);\n        ease = springEasing.ease;\n        duration = springEasing.duration;\n      }\n      duration !== null && duration !== void 0 ? duration : duration = defaultDuration;\n      const startTime = currentTime + calculatedDelay;\n      const targetTime = startTime + duration;\n      /**\n       * If there's only one time offset of 0, fill in a second with length 1\n       */\n      if (times.length === 1 && times[0] === 0) {\n        times[1] = 1;\n      }\n      /**\n       * Fill out if offset if fewer offsets than keyframes\n       */\n      const remainder = times.length - valueKeyframesAsList.length;\n      remainder > 0 && fillOffset(times, remainder);\n      /**\n       * If only one value has been set, ie [1], push a null to the start of\n       * the keyframe array. This will let us mark a keyframe at this point\n       * that will later be hydrated with the previous value.\n       */\n      valueKeyframesAsList.length === 1 && valueKeyframesAsList.unshift(null);\n      /**\n       * Add keyframes, mapping offsets to absolute time.\n       */\n      addKeyframes(valueSequence, valueKeyframesAsList, ease, times, startTime, targetTime);\n      maxDuration = Math.max(calculatedDelay + duration, maxDuration);\n      totalDuration = Math.max(targetTime, totalDuration);\n    };\n    if (isMotionValue(subject)) {\n      const subjectSequence = getSubjectSequence(subject, sequences);\n      resolveValueSequence(keyframes, transition, getValueSequence(\"default\", subjectSequence));\n    } else {\n      /**\n       * Find all the elements specified in the definition and parse value\n       * keyframes from their timeline definitions.\n       */\n      const elements = resolveElements(subject, scope, elementCache);\n      const numElements = elements.length;\n      /**\n       * For every element in this segment, process the defined values.\n       */\n      for (let elementIndex = 0; elementIndex < numElements; elementIndex++) {\n        /**\n         * Cast necessary, but we know these are of this type\n         */\n        keyframes = keyframes;\n        transition = transition;\n        const element = elements[elementIndex];\n        const subjectSequence = getSubjectSequence(element, sequences);\n        for (const key in keyframes) {\n          resolveValueSequence(keyframes[key], getValueTransition(transition, key), getValueSequence(key, subjectSequence), elementIndex, numElements);\n        }\n      }\n      prevTime = currentTime;\n      currentTime += maxDuration;\n    }\n  }\n  /**\n   * For every element and value combination create a new animation.\n   */\n  sequences.forEach((valueSequences, element) => {\n    for (const key in valueSequences) {\n      const valueSequence = valueSequences[key];\n      /**\n       * Arrange all the keyframes in ascending time order.\n       */\n      valueSequence.sort(compareByTime);\n      const keyframes = [];\n      const valueOffset = [];\n      const valueEasing = [];\n      /**\n       * For each keyframe, translate absolute times into\n       * relative offsets based on the total duration of the timeline.\n       */\n      for (let i = 0; i < valueSequence.length; i++) {\n        const {\n          at,\n          value,\n          easing\n        } = valueSequence[i];\n        keyframes.push(value);\n        valueOffset.push(progress(0, totalDuration, at));\n        valueEasing.push(easing || \"easeOut\");\n      }\n      /**\n       * If the first keyframe doesn't land on offset: 0\n       * provide one by duplicating the initial keyframe. This ensures\n       * it snaps to the first keyframe when the animation starts.\n       */\n      if (valueOffset[0] !== 0) {\n        valueOffset.unshift(0);\n        keyframes.unshift(keyframes[0]);\n        valueEasing.unshift(defaultSegmentEasing);\n      }\n      /**\n       * If the last keyframe doesn't land on offset: 1\n       * provide one with a null wildcard value. This will ensure it\n       * stays static until the end of the animation.\n       */\n      if (valueOffset[valueOffset.length - 1] !== 1) {\n        valueOffset.push(1);\n        keyframes.push(null);\n      }\n      if (!animationDefinitions.has(element)) {\n        animationDefinitions.set(element, {\n          keyframes: {},\n          transition: {}\n        });\n      }\n      const definition = animationDefinitions.get(element);\n      definition.keyframes[key] = keyframes;\n      definition.transition[key] = {\n        ...defaultTransition,\n        duration: totalDuration,\n        ease: valueEasing,\n        times: valueOffset,\n        ...sequenceTransition\n      };\n    }\n  });\n  return animationDefinitions;\n}\nfunction getSubjectSequence(subject, sequences) {\n  !sequences.has(subject) && sequences.set(subject, {});\n  return sequences.get(subject);\n}\nfunction getValueSequence(name, sequences) {\n  if (!sequences[name]) sequences[name] = [];\n  return sequences[name];\n}\nfunction keyframesAsList(keyframes) {\n  return Array.isArray(keyframes) ? keyframes : [keyframes];\n}\nfunction getValueTransition(transition, key) {\n  return transition[key] ? {\n    ...transition,\n    ...transition[key]\n  } : {\n    ...transition\n  };\n}\nconst isNumber = keyframe => typeof keyframe === \"number\";\nconst isNumberKeyframesArray = keyframes => keyframes.every(isNumber);\nfunction animateElements(elementOrSelector, keyframes, options, scope) {\n  const elements = resolveElements(elementOrSelector, scope);\n  const numElements = elements.length;\n  exports.invariant(Boolean(numElements), \"No valid element provided.\");\n  const animations = [];\n  for (let i = 0; i < numElements; i++) {\n    const element = elements[i];\n    /**\n     * Check each element for an associated VisualElement. If none exists,\n     * we need to create one.\n     */\n    if (!visualElementStore.has(element)) {\n      /**\n       * TODO: We only need render-specific parts of the VisualElement.\n       * With some additional work the size of the animate() function\n       * could be reduced significantly.\n       */\n      createVisualElement(element);\n    }\n    const visualElement = visualElementStore.get(element);\n    const transition = {\n      ...options\n    };\n    /**\n     * Resolve stagger function if provided.\n     */\n    if (typeof transition.delay === \"function\") {\n      transition.delay = transition.delay(i, numElements);\n    }\n    animations.push(...animateTarget(visualElement, {\n      ...keyframes,\n      transition\n    }, {}));\n  }\n  return new GroupPlaybackControls(animations);\n}\nconst isSequence = value => Array.isArray(value) && Array.isArray(value[0]);\nfunction animateSequence(sequence, options, scope) {\n  const animations = [];\n  const animationDefinitions = createAnimationsFromSequence(sequence, options, scope);\n  animationDefinitions.forEach((_ref49, subject) => {\n    let {\n      keyframes,\n      transition\n    } = _ref49;\n    let animation;\n    if (isMotionValue(subject)) {\n      animation = animateSingleValue(subject, keyframes.default, transition.default);\n    } else {\n      animation = animateElements(subject, keyframes, transition);\n    }\n    animations.push(animation);\n  });\n  return new GroupPlaybackControls(animations);\n}\nconst createScopedAnimate = scope => {\n  /**\n   * Implementation\n   */\n  function scopedAnimate(valueOrElementOrSequence, keyframes, options) {\n    let animation;\n    if (isSequence(valueOrElementOrSequence)) {\n      animation = animateSequence(valueOrElementOrSequence, keyframes, scope);\n    } else if (isDOMKeyframes(keyframes)) {\n      animation = animateElements(valueOrElementOrSequence, keyframes, options, scope);\n    } else {\n      animation = animateSingleValue(valueOrElementOrSequence, keyframes, options);\n    }\n    if (scope) {\n      scope.animations.push(animation);\n    }\n    return animation;\n  }\n  return scopedAnimate;\n};\nconst animate = createScopedAnimate();\nconst resizeHandlers = new WeakMap();\nlet observer;\nfunction getElementSize(target, borderBoxSize) {\n  if (borderBoxSize) {\n    const {\n      inlineSize,\n      blockSize\n    } = borderBoxSize[0];\n    return {\n      width: inlineSize,\n      height: blockSize\n    };\n  } else if (target instanceof SVGElement && \"getBBox\" in target) {\n    return target.getBBox();\n  } else {\n    return {\n      width: target.offsetWidth,\n      height: target.offsetHeight\n    };\n  }\n}\nfunction notifyTarget(_ref50) {\n  let {\n    target,\n    contentRect,\n    borderBoxSize\n  } = _ref50;\n  var _a;\n  (_a = resizeHandlers.get(target)) === null || _a === void 0 ? void 0 : _a.forEach(handler => {\n    handler({\n      target,\n      contentSize: contentRect,\n      get size() {\n        return getElementSize(target, borderBoxSize);\n      }\n    });\n  });\n}\nfunction notifyAll(entries) {\n  entries.forEach(notifyTarget);\n}\nfunction createResizeObserver() {\n  if (typeof ResizeObserver === \"undefined\") return;\n  observer = new ResizeObserver(notifyAll);\n}\nfunction resizeElement(target, handler) {\n  if (!observer) createResizeObserver();\n  const elements = resolveElements(target);\n  elements.forEach(element => {\n    let elementHandlers = resizeHandlers.get(element);\n    if (!elementHandlers) {\n      elementHandlers = new Set();\n      resizeHandlers.set(element, elementHandlers);\n    }\n    elementHandlers.add(handler);\n    observer === null || observer === void 0 ? void 0 : observer.observe(element);\n  });\n  return () => {\n    elements.forEach(element => {\n      const elementHandlers = resizeHandlers.get(element);\n      elementHandlers === null || elementHandlers === void 0 ? void 0 : elementHandlers.delete(handler);\n      if (!(elementHandlers === null || elementHandlers === void 0 ? void 0 : elementHandlers.size)) {\n        observer === null || observer === void 0 ? void 0 : observer.unobserve(element);\n      }\n    });\n  };\n}\nconst windowCallbacks = new Set();\nlet windowResizeHandler;\nfunction createWindowResizeHandler() {\n  windowResizeHandler = () => {\n    const size = {\n      width: window.innerWidth,\n      height: window.innerHeight\n    };\n    const info = {\n      target: window,\n      size,\n      contentSize: size\n    };\n    windowCallbacks.forEach(callback => callback(info));\n  };\n  window.addEventListener(\"resize\", windowResizeHandler);\n}\nfunction resizeWindow(callback) {\n  windowCallbacks.add(callback);\n  if (!windowResizeHandler) createWindowResizeHandler();\n  return () => {\n    windowCallbacks.delete(callback);\n    if (!windowCallbacks.size && windowResizeHandler) {\n      windowResizeHandler = undefined;\n    }\n  };\n}\nfunction resize(a, b) {\n  return typeof a === \"function\" ? resizeWindow(a) : resizeElement(a, b);\n}\n\n/**\n * A time in milliseconds, beyond which we consider the scroll velocity to be 0.\n */\nconst maxElapsed = 50;\nconst createAxisInfo = () => ({\n  current: 0,\n  offset: [],\n  progress: 0,\n  scrollLength: 0,\n  targetOffset: 0,\n  targetLength: 0,\n  containerLength: 0,\n  velocity: 0\n});\nconst createScrollInfo = () => ({\n  time: 0,\n  x: createAxisInfo(),\n  y: createAxisInfo()\n});\nconst keys = {\n  x: {\n    length: \"Width\",\n    position: \"Left\"\n  },\n  y: {\n    length: \"Height\",\n    position: \"Top\"\n  }\n};\nfunction updateAxisInfo(element, axisName, info, time) {\n  const axis = info[axisName];\n  const {\n    length,\n    position\n  } = keys[axisName];\n  const prev = axis.current;\n  const prevTime = info.time;\n  axis.current = element[\"scroll\" + position];\n  axis.scrollLength = element[\"scroll\" + length] - element[\"client\" + length];\n  axis.offset.length = 0;\n  axis.offset[0] = 0;\n  axis.offset[1] = axis.scrollLength;\n  axis.progress = progress(0, axis.scrollLength, axis.current);\n  const elapsed = time - prevTime;\n  axis.velocity = elapsed > maxElapsed ? 0 : velocityPerSecond(axis.current - prev, elapsed);\n}\nfunction updateScrollInfo(element, info, time) {\n  updateAxisInfo(element, \"x\", info, time);\n  updateAxisInfo(element, \"y\", info, time);\n  info.time = time;\n}\nfunction calcInset(element, container) {\n  const inset = {\n    x: 0,\n    y: 0\n  };\n  let current = element;\n  while (current && current !== container) {\n    if (current instanceof HTMLElement) {\n      inset.x += current.offsetLeft;\n      inset.y += current.offsetTop;\n      current = current.offsetParent;\n    } else if (current.tagName === \"svg\") {\n      /**\n       * This isn't an ideal approach to measuring the offset of <svg /> tags.\n       * It would be preferable, given they behave like HTMLElements in most ways\n       * to use offsetLeft/Top. But these don't exist on <svg />. Likewise we\n       * can't use .getBBox() like most SVG elements as these provide the offset\n       * relative to the SVG itself, which for <svg /> is usually 0x0.\n       */\n      const svgBoundingBox = current.getBoundingClientRect();\n      current = current.parentElement;\n      const parentBoundingBox = current.getBoundingClientRect();\n      inset.x += svgBoundingBox.left - parentBoundingBox.left;\n      inset.y += svgBoundingBox.top - parentBoundingBox.top;\n    } else if (current instanceof SVGGraphicsElement) {\n      const {\n        x,\n        y\n      } = current.getBBox();\n      inset.x += x;\n      inset.y += y;\n      let svg = null;\n      let parent = current.parentNode;\n      while (!svg) {\n        if (parent.tagName === \"svg\") {\n          svg = parent;\n        }\n        parent = current.parentNode;\n      }\n      current = svg;\n    } else {\n      break;\n    }\n  }\n  return inset;\n}\nconst ScrollOffset = {\n  Enter: [[0, 1], [1, 1]],\n  Exit: [[0, 0], [1, 0]],\n  Any: [[1, 0], [0, 1]],\n  All: [[0, 0], [1, 1]]\n};\nconst namedEdges = {\n  start: 0,\n  center: 0.5,\n  end: 1\n};\nfunction resolveEdge(edge, length) {\n  let inset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n  let delta = 0;\n  /**\n   * If we have this edge defined as a preset, replace the definition\n   * with the numerical value.\n   */\n  if (namedEdges[edge] !== undefined) {\n    edge = namedEdges[edge];\n  }\n  /**\n   * Handle unit values\n   */\n  if (typeof edge === \"string\") {\n    const asNumber = parseFloat(edge);\n    if (edge.endsWith(\"px\")) {\n      delta = asNumber;\n    } else if (edge.endsWith(\"%\")) {\n      edge = asNumber / 100;\n    } else if (edge.endsWith(\"vw\")) {\n      delta = asNumber / 100 * document.documentElement.clientWidth;\n    } else if (edge.endsWith(\"vh\")) {\n      delta = asNumber / 100 * document.documentElement.clientHeight;\n    } else {\n      edge = asNumber;\n    }\n  }\n  /**\n   * If the edge is defined as a number, handle as a progress value.\n   */\n  if (typeof edge === \"number\") {\n    delta = length * edge;\n  }\n  return inset + delta;\n}\nconst defaultOffset = [0, 0];\nfunction resolveOffset(offset, containerLength, targetLength, targetInset) {\n  let offsetDefinition = Array.isArray(offset) ? offset : defaultOffset;\n  let targetPoint = 0;\n  let containerPoint = 0;\n  if (typeof offset === \"number\") {\n    /**\n     * If we're provided offset: [0, 0.5, 1] then each number x should become\n     * [x, x], so we default to the behaviour of mapping 0 => 0 of both target\n     * and container etc.\n     */\n    offsetDefinition = [offset, offset];\n  } else if (typeof offset === \"string\") {\n    offset = offset.trim();\n    if (offset.includes(\" \")) {\n      offsetDefinition = offset.split(\" \");\n    } else {\n      /**\n       * If we're provided a definition like \"100px\" then we want to apply\n       * that only to the top of the target point, leaving the container at 0.\n       * Whereas a named offset like \"end\" should be applied to both.\n       */\n      offsetDefinition = [offset, namedEdges[offset] ? offset : `0`];\n    }\n  }\n  targetPoint = resolveEdge(offsetDefinition[0], targetLength, targetInset);\n  containerPoint = resolveEdge(offsetDefinition[1], containerLength);\n  return targetPoint - containerPoint;\n}\nconst point = {\n  x: 0,\n  y: 0\n};\nfunction getTargetSize(target) {\n  return \"getBBox\" in target && target.tagName !== \"svg\" ? target.getBBox() : {\n    width: target.clientWidth,\n    height: target.clientHeight\n  };\n}\nfunction resolveOffsets(container, info, options) {\n  let {\n    offset: offsetDefinition = ScrollOffset.All\n  } = options;\n  const {\n    target = container,\n    axis = \"y\"\n  } = options;\n  const lengthLabel = axis === \"y\" ? \"height\" : \"width\";\n  const inset = target !== container ? calcInset(target, container) : point;\n  /**\n   * Measure the target and container. If they're the same thing then we\n   * use the container's scrollWidth/Height as the target, from there\n   * all other calculations can remain the same.\n   */\n  const targetSize = target === container ? {\n    width: container.scrollWidth,\n    height: container.scrollHeight\n  } : getTargetSize(target);\n  const containerSize = {\n    width: container.clientWidth,\n    height: container.clientHeight\n  };\n  /**\n   * Reset the length of the resolved offset array rather than creating a new one.\n   * TODO: More reusable data structures for targetSize/containerSize would also be good.\n   */\n  info[axis].offset.length = 0;\n  /**\n   * Populate the offset array by resolving the user's offset definition into\n   * a list of pixel scroll offets.\n   */\n  let hasChanged = !info[axis].interpolate;\n  const numOffsets = offsetDefinition.length;\n  for (let i = 0; i < numOffsets; i++) {\n    const offset = resolveOffset(offsetDefinition[i], containerSize[lengthLabel], targetSize[lengthLabel], inset[axis]);\n    if (!hasChanged && offset !== info[axis].interpolatorOffsets[i]) {\n      hasChanged = true;\n    }\n    info[axis].offset[i] = offset;\n  }\n  /**\n   * If the pixel scroll offsets have changed, create a new interpolator function\n   * to map scroll value into a progress.\n   */\n  if (hasChanged) {\n    info[axis].interpolate = interpolate(info[axis].offset, defaultOffset$1(offsetDefinition));\n    info[axis].interpolatorOffsets = [...info[axis].offset];\n  }\n  info[axis].progress = info[axis].interpolate(info[axis].current);\n}\nfunction measure(container) {\n  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : container;\n  let info = arguments.length > 2 ? arguments[2] : undefined;\n  /**\n   * Find inset of target within scrollable container\n   */\n  info.x.targetOffset = 0;\n  info.y.targetOffset = 0;\n  if (target !== container) {\n    let node = target;\n    while (node && node !== container) {\n      info.x.targetOffset += node.offsetLeft;\n      info.y.targetOffset += node.offsetTop;\n      node = node.offsetParent;\n    }\n  }\n  info.x.targetLength = target === container ? target.scrollWidth : target.clientWidth;\n  info.y.targetLength = target === container ? target.scrollHeight : target.clientHeight;\n  info.x.containerLength = container.clientWidth;\n  info.y.containerLength = container.clientHeight;\n}\nfunction createOnScrollHandler(element, onScroll, info) {\n  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  return {\n    measure: () => measure(element, options.target, info),\n    update: time => {\n      updateScrollInfo(element, info, time);\n      if (options.offset || options.target) {\n        resolveOffsets(element, info, options);\n      }\n    },\n    notify: () => onScroll(info)\n  };\n}\nconst scrollListeners = new WeakMap();\nconst resizeListeners = new WeakMap();\nconst onScrollHandlers = new WeakMap();\nconst getEventTarget = element => element === document.documentElement ? window : element;\nfunction scrollInfo(onScroll) {\n  let {\n    container = document.documentElement,\n    ...options\n  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  let containerHandlers = onScrollHandlers.get(container);\n  /**\n   * Get the onScroll handlers for this container.\n   * If one isn't found, create a new one.\n   */\n  if (!containerHandlers) {\n    containerHandlers = new Set();\n    onScrollHandlers.set(container, containerHandlers);\n  }\n  /**\n   * Create a new onScroll handler for the provided callback.\n   */\n  const info = createScrollInfo();\n  const containerHandler = createOnScrollHandler(container, onScroll, info, options);\n  containerHandlers.add(containerHandler);\n  /**\n   * Check if there's a scroll event listener for this container.\n   * If not, create one.\n   */\n  if (!scrollListeners.has(container)) {\n    const measureAll = () => {\n      for (const handler of containerHandlers) handler.measure();\n    };\n    const updateAll = () => {\n      for (const handler of containerHandlers) {\n        handler.update(frameData.timestamp);\n      }\n    };\n    const notifyAll = () => {\n      for (const handler of containerHandlers) handler.notify();\n    };\n    const listener = () => {\n      frame.read(measureAll, false, true);\n      frame.update(updateAll, false, true);\n      frame.update(notifyAll, false, true);\n    };\n    scrollListeners.set(container, listener);\n    const target = getEventTarget(container);\n    window.addEventListener(\"resize\", listener, {\n      passive: true\n    });\n    if (container !== document.documentElement) {\n      resizeListeners.set(container, resize(container, listener));\n    }\n    target.addEventListener(\"scroll\", listener, {\n      passive: true\n    });\n  }\n  const listener = scrollListeners.get(container);\n  frame.read(listener, false, true);\n  return () => {\n    var _a;\n    cancelFrame(listener);\n    /**\n     * Check if we even have any handlers for this container.\n     */\n    const currentHandlers = onScrollHandlers.get(container);\n    if (!currentHandlers) return;\n    currentHandlers.delete(containerHandler);\n    if (currentHandlers.size) return;\n    /**\n     * If no more handlers, remove the scroll listener too.\n     */\n    const scrollListener = scrollListeners.get(container);\n    scrollListeners.delete(container);\n    if (scrollListener) {\n      getEventTarget(container).removeEventListener(\"scroll\", scrollListener);\n      (_a = resizeListeners.get(container)) === null || _a === void 0 ? void 0 : _a();\n      window.removeEventListener(\"resize\", scrollListener);\n    }\n  };\n}\nfunction scrollTimelineFallback(_ref51) {\n  let {\n    source,\n    axis = \"y\"\n  } = _ref51;\n  // ScrollTimeline records progress as a percentage CSSUnitValue\n  const currentTime = {\n    value: 0\n  };\n  const cancel = scrollInfo(info => {\n    currentTime.value = info[axis].progress * 100;\n  }, {\n    container: source,\n    axis\n  });\n  return {\n    currentTime,\n    cancel\n  };\n}\nconst timelineCache = new Map();\nfunction getTimeline() {\n  let {\n    source = document.documentElement,\n    axis = \"y\"\n  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  if (!timelineCache.has(source)) {\n    timelineCache.set(source, {});\n  }\n  const elementCache = timelineCache.get(source);\n  if (!elementCache[axis]) {\n    elementCache[axis] = supportsScrollTimeline() ? new ScrollTimeline({\n      source,\n      axis\n    }) : scrollTimelineFallback({\n      source,\n      axis\n    });\n  }\n  return elementCache[axis];\n}\nfunction scroll(onScroll, options) {\n  const timeline = getTimeline(options);\n  if (typeof onScroll === \"function\") {\n    return observeTimeline(onScroll, timeline);\n  } else {\n    return onScroll.attachTimeline(timeline);\n  }\n}\nconst thresholds = {\n  some: 0,\n  all: 1\n};\nfunction inView(elementOrSelector, onStart) {\n  let {\n    root,\n    margin: rootMargin,\n    amount = \"some\"\n  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\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)) return;\n      if (entry.isIntersecting) {\n        const newOnEnd = onStart(entry);\n        if (typeof newOnEnd === \"function\") {\n          activeIntersections.set(entry.target, newOnEnd);\n        } else {\n          observer.unobserve(entry.target);\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}\nfunction getOriginIndex(from, total) {\n  if (from === \"first\") {\n    return 0;\n  } else {\n    const lastIndex = total - 1;\n    return from === \"last\" ? lastIndex : lastIndex / 2;\n  }\n}\nfunction stagger() {\n  let duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.1;\n  let {\n    startDelay = 0,\n    from = 0,\n    ease\n  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return (i, total) => {\n    const fromIndex = typeof from === \"number\" ? from : getOriginIndex(from, total);\n    const distance = Math.abs(fromIndex - i);\n    let delay = duration * distance;\n    if (ease) {\n      const maxDelay = total * duration;\n      const easingFunction = easingDefinitionToFunction(ease);\n      delay = easingFunction(delay / maxDelay) * maxDelay;\n    }\n    return startDelay + delay;\n  };\n}\nconst isCustomValueType = v => {\n  return typeof v === \"object\" && v.mix;\n};\nconst getMixer = v => isCustomValueType(v) ? v.mix : undefined;\nfunction transform() {\n  const useImmediate = !Array.isArray(arguments.length <= 0 ? undefined : arguments[0]);\n  const argOffset = useImmediate ? 0 : -1;\n  const inputValue = 0 + argOffset < 0 || arguments.length <= 0 + argOffset ? undefined : arguments[0 + argOffset];\n  const inputRange = 1 + argOffset < 0 || arguments.length <= 1 + argOffset ? undefined : arguments[1 + argOffset];\n  const outputRange = 2 + argOffset < 0 || arguments.length <= 2 + argOffset ? undefined : arguments[2 + argOffset];\n  const options = 3 + argOffset < 0 || arguments.length <= 3 + argOffset ? undefined : arguments[3 + argOffset];\n  const interpolator = interpolate(inputRange, outputRange, {\n    mixer: getMixer(outputRange[0]),\n    ...options\n  });\n  return useImmediate ? interpolator(inputValue) : interpolator;\n}\n\n/**\n * @deprecated\n *\n * Import as `frame` instead.\n */\nconst sync = frame;\n/**\n * @deprecated\n *\n * Use cancelFrame(callback) instead.\n */\nconst cancelSync = stepsOrder.reduce((acc, key) => {\n  acc[key] = process => cancelFrame(process);\n  return acc;\n}, {});\nexports.HTMLVisualElement = HTMLVisualElement;\nexports.MotionValue = MotionValue;\nexports.SVGVisualElement = SVGVisualElement;\nexports.SubscriptionManager = SubscriptionManager;\nexports.VisualElement = VisualElement;\nexports.addScaleCorrector = addScaleCorrector;\nexports.addUniqueItem = addUniqueItem;\nexports.animate = animate;\nexports.animateMotionValue = animateMotionValue;\nexports.animateSingleValue = animateSingleValue;\nexports.animateStyle = animateStyle;\nexports.animateTarget = animateTarget;\nexports.animateValue = animateValue;\nexports.anticipate = anticipate;\nexports.applyBoxDelta = applyBoxDelta;\nexports.applyTreeDeltas = applyTreeDeltas;\nexports.backIn = backIn;\nexports.backInOut = backInOut;\nexports.backOut = backOut;\nexports.buildHTMLStyles = buildHTMLStyles;\nexports.buildSVGAttrs = buildSVGAttrs;\nexports.buildTransform = buildTransform;\nexports.camelToDash = camelToDash;\nexports.cancelFrame = cancelFrame;\nexports.cancelSync = cancelSync;\nexports.checkTargetForNewValues = checkTargetForNewValues;\nexports.circIn = circIn;\nexports.circInOut = circInOut;\nexports.circOut = circOut;\nexports.clamp = clamp;\nexports.collectMotionValues = collectMotionValues;\nexports.color = color;\nexports.complex = complex;\nexports.convertBoundingBoxToBox = convertBoundingBoxToBox;\nexports.convertBoxToBoundingBox = convertBoxToBoundingBox;\nexports.createBox = createBox;\nexports.createDelta = createDelta;\nexports.createScopedAnimate = createScopedAnimate;\nexports.cubicBezier = cubicBezier;\nexports.delay = delay;\nexports.distance = distance;\nexports.distance2D = distance2D;\nexports.easeIn = easeIn;\nexports.easeInOut = easeInOut;\nexports.easeOut = easeOut;\nexports.featureDefinitions = featureDefinitions;\nexports.frame = frame;\nexports.frameData = frameData;\nexports.getOrigin = getOrigin;\nexports.getValueTransition = getValueTransition$1;\nexports.has2DTranslate = has2DTranslate;\nexports.hasReducedMotionListener = hasReducedMotionListener;\nexports.hasScale = hasScale;\nexports.hasTransform = hasTransform;\nexports.inView = inView;\nexports.initPrefersReducedMotion = initPrefersReducedMotion;\nexports.instantAnimationState = instantAnimationState;\nexports.interpolate = interpolate;\nexports.isAnimationControls = isAnimationControls;\nexports.isBrowser = isBrowser;\nexports.isCSSVariableName = isCSSVariableName;\nexports.isControllingVariants = isControllingVariants;\nexports.isCustomValue = isCustomValue;\nexports.isForcedMotionValue = isForcedMotionValue;\nexports.isKeyframesTarget = isKeyframesTarget;\nexports.isMotionValue = isMotionValue;\nexports.isRefObject = isRefObject;\nexports.isSVGElement = isSVGElement;\nexports.isSVGTag = isSVGTag;\nexports.isVariantLabel = isVariantLabel;\nexports.isVariantNode = isVariantNode;\nexports.measurePageBox = measurePageBox;\nexports.millisecondsToSeconds = millisecondsToSeconds;\nexports.mirrorEasing = mirrorEasing;\nexports.mix = mix;\nexports.motionValue = motionValue;\nexports.moveItem = moveItem;\nexports.noop = noop;\nexports.optimizedAppearDataAttribute = optimizedAppearDataAttribute;\nexports.optimizedAppearDataId = optimizedAppearDataId;\nexports.percent = percent;\nexports.pipe = pipe;\nexports.prefersReducedMotion = prefersReducedMotion;\nexports.progress = progress;\nexports.px = px;\nexports.removeItem = removeItem;\nexports.renderSVG = renderSVG;\nexports.resolveVariant = resolveVariant;\nexports.resolveVariantFromProps = resolveVariantFromProps;\nexports.reverseEasing = reverseEasing;\nexports.scaleCorrectors = scaleCorrectors;\nexports.scalePoint = scalePoint;\nexports.scrapeMotionValuesFromProps = scrapeMotionValuesFromProps;\nexports.scrapeMotionValuesFromProps$1 = scrapeMotionValuesFromProps$1;\nexports.scroll = scroll;\nexports.scrollInfo = scrollInfo;\nexports.secondsToMilliseconds = secondsToMilliseconds;\nexports.setValues = setValues;\nexports.spring = spring;\nexports.stagger = stagger;\nexports.steps = steps;\nexports.sync = sync;\nexports.transform = transform;\nexports.transformBox = transformBox;\nexports.transformProps = transformProps;\nexports.translateAxis = translateAxis;\nexports.variantPriorityOrder = variantPriorityOrder;\nexports.visualElementStore = visualElementStore;\nexports.warnOnce = warnOnce;\nexports.wrap = wrap;"],"names":["isBrowser","document","camelToDash","str","replace","toLowerCase","optimizedAppearDataId","optimizedAppearDataAttribute","isRefObject","ref","Object","prototype","hasOwnProperty","call","isVariantLabel","v","Array","isArray","isAnimationControls","start","variantPriorityOrder","variantProps","isControllingVariants","props","animate","some","name","isVariantNode","Boolean","variants","featureProps","animation","exit","drag","focus","hover","tap","pan","inView","layout","featureDefinitions","key","isEnabled","scaleCorrectors","transformPropOrder","transformProps","Set","isForcedMotionValue","_ref","layoutId","has","startsWith","undefined","isMotionValue","value","getVelocity","translateAlias","x","y","z","transformPerspective","numTransforms","length","buildTransform","transform","_ref2","transformIsDefault","transformTemplate","enableHardwareAcceleration","allowTransformNone","transformString","i","trim","checkStringStartsWith","token","isCSSVariableName","isCSSVariableToken","getValueAsType","type","clamp","min","max","Math","number","test","parse","parseFloat","alpha","scale","default","sanitize","round","floatRegex","colorRegex","singleColorRegex","isString","createUnitType","unit","endsWith","split","degrees","percent","px","vh","vw","progressPercentage","int","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","width","maxWidth","height","maxHeight","size","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","opacity","originX","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","buildHTMLStyles","state","latestValues","options","style","vars","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","valueAsType","calcOrigin","origin","offset","dashKeys","array","camelKeys","buildSVGAttrs","_ref3","isSVGTag","attrX","attrY","attrScale","pathLength","pathSpacing","pathOffset","latest","viewBox","attrs","dimensions","calcSVGTransformOrigin","spacing","arguments","useDashCase","keys","buildSVGPath","tag","renderHTML","element","_ref4","styleProp","projection","assign","getProjectionStyles","setProperty","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","scrapeMotionValuesFromProps$1","prevProps","newValues","scrapeMotionValuesFromProps","indexOf","charAt","toUpperCase","substring","resolveVariantFromProps","definition","custom","currentValues","currentVelocity","isKeyframesTarget","resolveFinalValueInKeyframes","noop","any","Queue","constructor","this","order","scheduled","add","process","push","remove","index","splice","delete","clear","stepsOrder","schedule","frame","cancel","cancelFrame","frameData","steps","scheduleNextBatch","allowKeepAlive","runNextFrame","useDefaultElapsed","delta","timestamp","isProcessing","reduce","acc","thisFrame","nextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","callback","addToCurrentFrame","queue","createRenderStep","processStep","stepId","processBatch","performance","now","forEach","keepAlive","immediate","createRenderBatcher","requestAnimationFrame","combineFunctions","a","b","pipe","_len","transformers","_key","resolveVariant","visualElement","getProps","current","values","get","getCurrent","velocity","exports","warning","invariant","secondsToMilliseconds","seconds","millisecondsToSeconds","milliseconds","instantAnimationState","isBezierDefinition","easing","isWaapiSupportedEasing","supportedWaapiEasing","every","cubicBezierAsString","_ref5","c","d","linear","ease","easeIn","easeOut","easeInOut","circIn","circOut","backIn","backOut","mapEasingToNativeEasing","map","animateStyle","valueName","keyframes","delay","duration","repeat","repeatType","times","keyframeOptions","fill","iterations","direction","calcBezier","t","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","getTForX","aX","lowerBound","upperBound","currentX","currentT","abs","binarySubdivide","isEasingArray","mirrorEasing","p","reverseEasing","sin","acos","circInOut","backInOut","anticipate","pow","easingLookup","easingDefinitionToFunction","x1","y1","x2","y2","isColorString","testProp","splitColor","aName","bName","cName","match","rgbUnit","clampRgbUnit","rgba","_ref7","red","green","blue","alpha$1","hex","r","g","parseInt","hsla","_ref8","hue","saturation","lightness","color","mix","from","to","progress","hueToRgb","q","mixLinearColor","fromExpo","sqrt","colorTypes","asRGBA","find","model","_ref9","hslaToRgba","mixColor","fromRGBA","toRGBA","blended","cssVarTokeniser","regex","countKey","colorTokeniser","numberTokeniser","tokenise","info","_ref10","matches","tokenised","analyseComplexValue","originalValue","toString","numVars","numColors","numNumbers","includes","parseComplexValue","createTransformer","source","numValues","output","convertNumbersToZero","complex","_a","_b","isNaN","getAnimatableNone","parsed","transformer","mixImmediate","target","getMixer$1","mixComplex","mixArray","blendValue","fromThis","mixObject","template","originStats","targetStats","toFromDifference","mixNumber","createMixers","customMixer","mixers","mixerFactory","numMixers","mixer","easingFunction","interpolate","input","isClamp","inputLength","reverse","interpolator","progressInRange","fillOffset","remaining","offsetProgress","defaultOffset$1","arr","_ref11","keyframeValues","easingFunctions","done","absoluteTimes","o","convertOffsetToTimes","mapTimeToKeyframe","calculatedDuration","next","velocityPerSecond","frameDuration","velocitySampleDuration","calcGeneratorVelocity","resolveValue","prevT","safeMin","minDuration","maxDuration$1","minDamping","maxDamping","findSpring","_ref12","envelope","derivative","bounce","mass","dampingRatio","undampedFreq","exponentialDecay","calcAngularFreq","exp","e","f","initialGuess","result","rootIterations","approximateRoot","stiffness","damping","durationKeys","physicsKeys","isSpringType","spring","_ref13","restDelta","restSpeed","isResolvedFromDuration","springOptions","derived","getSpringOptions","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","cos","dampedAngularFreq","freqForT","sinh","cosh","isBelowVelocityThreshold","isBelowDisplacementThreshold","inertia","_ref14","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","nearestBoundary","amplitude","ideal","calcDelta","calcLatest","applyFriction","timeReachedBoundary","spring$1","checkCatchBoundary","hasUpdatedFrame","frameloopDriver","update","passTimestamp","_ref15","stop","maxGeneratorDuration","calcGeneratorDuration","generator","Infinity","types","decay","tween","animateValue","_ref16","resolveFinishedPromise","currentFinishedPromise","autoplay","driver","keyframes$1","repeatDelay","onPlay","onStop","onComplete","onUpdate","speed","hasStopped","updateFinishedPromise","Promise","resolve","animationDriver","generatorFactory","mapNumbersToKeyframes","mirroredGenerator","playState","holdTime","startTime","cancelTime","resolvedDuration","totalDuration","currentTime","tick","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","currentIteration","floor","iterationProgress","iterationIsOdd","isAnimationFinished","finish","stopAnimationDriver","play","controls","then","reject","time","newTime","newSpeed","pause","complete","sample","memo","supportsWaapi","Element","acceleratedValues","createAcceleratedAnimation","_ref17","requiresPregeneratedKeyframes","sampleAnimation","pregeneratedKeyframes","owner","cancelAnimation","safeCancel","onfinish","set","_ref6","getFinalKeyframe","attachTimeline","timeline","playbackRate","setWithVelocity","underDampedSpring","keyframesTransition","getDefaultTransition","valueKey","_ref19","isAnimatable","maxDefaults","applyDefaultFilter","slice","defaultValue","functionRegex","filter","functions","join","defaultValueTypes","backgroundColor","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","defaultValueType","isZeroValueString","isNone","getValueTransition$1","transition","animateMotionValue","valueTransition","isTargetAnimatable","defaultOrigin","animatableTemplateValue","noneKeyframeIndexes","getKeyframes","originKeyframe","targetKeyframe","isOriginAnimatable","_ref20","when","_delay","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","_ref18","setValue","createInstantAnimation","isHandoff","HTMLElement","acceleratedAnimation","isWillChangeMotionValue","isNumericalString","addUniqueItem","item","removeItem","SubscriptionManager","subscriptions","handler","notify","numSubscriptions","getSize","warned","collectMotionValues","MotionValue","init","_this","version","timeDelta","lastUpdated","canTrackVelocity","events","updateAndNotify","render","prev","postRender","scheduleVelocityCheck","change","velocityChange","renderRequest","velocityCheck","_ref22","hasAnimated","onChange","subscription","on","eventName","unsubscribe","read","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","jump","getPrevious","startAnimation","animationStart","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","motionValue","testValueType","dimensionValueTypes","findDimensionValueType","valueTypes","setMotionValue","hasValue","getValue","addValue","setTarget","resolved","transitionEnd","makeTargetAnimatable","setVariants","variantLabels","variant","getVariant","variantChildren","child","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","getOriginFromTransition","getOrigin","transitionOrigin","shouldBlockAnimation","_ref23","protectedKeys","needsAnimating","shouldBlock","hasKeyframesChanged","animateTarget","transitionOverride","willChange","animations","animationTypeState","animationState","getState","valueTarget","window","HandoffAppearAnimations","appearId","canSkip","shouldReduceMotion","all","createBox","convertBoundingBoxToBox","_ref24","isIdentityScale","hasScale","_ref26","has2DTranslate","is2DTranslate","scalePoint","point","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","axis","applyBoxDelta","box","_ref27","snapToDefault","Number","isInteger","translateAxis","transformAxis","transforms","_ref28","scaleKey","originKey","axisOrigin","xKeys","yKeys","transformBox","measureViewportBox","instance","transformPoint","topLeft","bottomRight","transformBoxPoints","getBoundingClientRect","resolveElements","elements","scope","selectorCache","root","querySelectorAll","visualElementStore","WeakMap","observeTimeline","prevProgress","onFrame","supportsScrollTimeline","ScrollTimeline","GroupPlaybackControls","onResolve","onReject","catch","getAll","propName","setAll","newValue","cancelAll","cancelTimeline","runAll","methodName","isSVGElement","SVGElement","tagName","splitCSSVariableRegex","maxDepth","getVariableValue","depth","fallback","exec","parseCSSVariable","getComputedStyle","getPropertyValue","trimmed","positionalKeys","isPositionalKey","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","_ref31","matrix3d","transformKeys","nonTranslationalTransformKeys","positionalValues","_ref32","_ref33","_ref34","_ref35","_ref36","_ref37","_ref38","_ref39","_ref40","_ref41","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","fromType","toType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","scrollY","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","setStaticValue","targetBbox","convertChangedValueTypes","_ref42","scrollTo","unitConversion","hasPositionalKey","parseDomVariant","_ref30","resolveCSSVariables","prefersReducedMotion","hasReducedMotionListener","initPrefersReducedMotion","matchMedia","motionMediaQuery","setReducedMotionPreferences","addListener","featureNames","numFeatures","propEventHandlers","numVariantProps","VisualElement","_ref43","parent","presenceContext","reducedMotionConfig","visualState","children","Map","features","valueSubscriptions","prevMotionValues","propEventSubscriptions","notifyUpdate","triggerBuild","renderInstance","scheduleRender","baseTarget","initialValues","initial","manuallyAnimateOnMount","initialMotionValues","_props","_prevProps","mount","removeFromVariantTree","addVariantChild","bindToMotionValue","unmount","valueIsTransform","removeOnChange","latestValue","isTransformDirty","removeOnRenderRequest","sortNodePosition","other","sortInstanceNodePosition","loadFeatures","_ref44","isStrict","preloadedFeatures","initialLayoutGroupConfig","ProjectionNodeConstructor","MeasureLayout","renderedProps","Feature","FeatureConstructor","ProjectionNode","MeasureLayoutComponent","dragConstraints","layoutScroll","layoutRoot","setOptions","alwaysMeasureLayout","animationType","initialPromotionConfig","updateFeatures","feature","isMounted","build","measureInstanceViewportBox","getStaticValue","canMutate","makeTargetAnimatableFromInstance","prevPresenceContext","listener","nextValue","prevValue","existingValue","removeValue","updateMotionValuesFromProps","handleChildMotionValue","getTransformPagePoint","transformPagePoint","getClosestVariantNode","getVariantContext","context","prop","closestVariantNode","removeValueFromRenderState","getBaseTargetFromProps","readValueFromInstance","getBaseTarget","valueFromInitial","_len2","args","_key2","DOMVisualElement","compareDocumentPosition","_ref45","_ref46","_ref47","transformValues","SVGVisualElement","super","defaultType","getAttribute","HTMLVisualElement","computedStyle","_ref48","childSubscription","textContent","createVisualElement","node","animateSingleValue","motionValue$1","createGeneratorEasing","calcNextTime","labels","wrap","rangeSize","getEasingForSegment","addKeyframes","sequence","endTime","keyframe","at","eraseKeyframes","compareByTime","defaultSegmentEasing","getSubjectSequence","subject","sequences","getValueSequence","keyframesAsList","getValueTransition","isNumber","isNumberKeyframesArray","animateElements","elementOrSelector","numElements","animateSequence","animationDefinitions","defaultTransition","sequenceTransition","defaultDuration","elementCache","timeLabels","prevTime","segment","maxDuration","resolveValueSequence","valueKeyframes","valueSequence","elementIndex","valueKeyframesAsList","remainingTransition","calculatedDelay","absoluteDelta","springTransition","springEasing","targetTime","remainder","unshift","subjectSequence","valueSequences","sort","valueOffset","valueEasing","createAnimationsFromSequence","_ref49","createScopedAnimate","valueOrElementOrSequence","isDOMKeyframes","resizeHandlers","observer","notifyTarget","_ref50","contentRect","borderBoxSize","contentSize","inlineSize","blockSize","getBBox","offsetWidth","offsetHeight","getElementSize","notifyAll","entries","resizeElement","ResizeObserver","elementHandlers","observe","unobserve","windowCallbacks","windowResizeHandler","resizeWindow","innerWidth","innerHeight","addEventListener","maxElapsed","createScrollInfo","scrollLength","targetOffset","targetLength","containerLength","position","updateAxisInfo","axisName","ScrollOffset","Enter","Exit","Any","All","namedEdges","center","end","resolveEdge","edge","inset","asNumber","documentElement","clientWidth","clientHeight","defaultOffset","resolveOffset","targetInset","offsetDefinition","targetPoint","containerPoint","resolveOffsets","container","lengthLabel","offsetLeft","offsetTop","offsetParent","svgBoundingBox","parentElement","parentBoundingBox","SVGGraphicsElement","svg","parentNode","calcInset","targetSize","scrollWidth","scrollHeight","getTargetSize","containerSize","hasChanged","numOffsets","interpolatorOffsets","createOnScrollHandler","onScroll","measure","updateScrollInfo","scrollListeners","resizeListeners","onScrollHandlers","getEventTarget","scrollInfo","containerHandlers","containerHandler","measureAll","updateAll","passive","currentHandlers","scrollListener","removeEventListener","timelineCache","getTimeline","_ref51","scrollTimelineFallback","thresholds","sync","cancelSync","addScaleCorrector","correctors","applyTreeDeltas","treeScale","treePath","isSharedTransition","treeLength","projectionDelta","scroll","convertBoxToBoundingBox","_ref25","createDelta","timeout","checkElapsed","_ref29","distance2D","xDelta","yDelta","onStart","rootMargin","amount","activeIntersections","IntersectionObserver","entry","onEnd","isIntersecting","newOnEnd","threshold","disconnect","isCustomValue","toValue","measurePageBox","rootProjectionNode","viewportBox","moveItem","_ref21","toIndex","startIndex","endIndex","setValues","stagger","startDelay","total","lastIndex","getOriginIndex","maxDelay","useImmediate","argOffset","inputValue","outputRange","isCustomValueType","warnOnce","condition","message","console","warn"],"sourceRoot":""}