{"version":3,"file":"static/js/7514.1a0707d9.chunk.js","mappings":"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","sources":["../node_modules/@emotion/memoize/dist/memoize.browser.esm.js","../node_modules/@emotion/is-prop-valid/dist/is-prop-valid.browser.esm.js","../node_modules/@material-ui/core/esm/ClickAwayListener/ClickAwayListener.js","../node_modules/@material-ui/core/esm/utils/ownerDocument.js","../node_modules/@micado-digital/react-overlay/ReactOverlay/backdrop.js","../node_modules/@micado-digital/react-overlay/ReactOverlay/container.js","../node_modules/@micado-digital/react-overlay/ReactOverlay/content.js","../node_modules/@micado-digital/react-overlay/ReactOverlay/context/overlayContext.js","../node_modules/@micado-digital/react-overlay/ReactOverlay/index.js","../node_modules/@micado-digital/react-overlay/ReactOverlay/portals.js","../node_modules/@micado-digital/react-overlay/ReactOverlay/utils/getImagePos.js","../node_modules/@motionone/types/dist/MotionValue.es.js","../node_modules/@motionone/dom/dist/animate/data.es.js","../node_modules/@motionone/utils/dist/noop.es.js","../node_modules/@motionone/utils/dist/array.es.js","../node_modules/@motionone/dom/dist/animate/utils/transforms.es.js","../node_modules/@motionone/dom/dist/animate/utils/css-var.es.js","../node_modules/@motionone/utils/dist/defaults.es.js","../node_modules/@motionone/utils/dist/is-easing-generator.es.js","../node_modules/@motionone/utils/dist/is-number.es.js","../node_modules/@motionone/utils/dist/is-easing-list.es.js","../node_modules/@motionone/utils/dist/mix.es.js","../node_modules/@motionone/utils/dist/progress.es.js","../node_modules/@motionone/utils/dist/offset.es.js","../node_modules/@motionone/utils/dist/wrap.es.js","../node_modules/@motionone/utils/dist/easing.es.js","../node_modules/@motionone/utils/dist/clamp.es.js","../node_modules/@motionone/utils/dist/interpolate.es.js","../node_modules/@motionone/easing/dist/cubic-bezier.es.js","../node_modules/@motionone/easing/dist/steps.es.js","../node_modules/@motionone/utils/dist/is-function.es.js","../node_modules/@motionone/utils/dist/is-cubic-bezier.es.js","../node_modules/@motionone/animation/dist/utils/easing.es.js","../node_modules/@motionone/animation/dist/Animation.es.js","../node_modules/@motionone/utils/dist/time.es.js","../node_modules/@motionone/dom/dist/animate/utils/easing.es.js","../node_modules/@motionone/dom/dist/animate/utils/feature-detection.es.js","../node_modules/@motionone/dom/dist/animate/utils/keyframes.es.js","../node_modules/@motionone/dom/dist/animate/utils/get-style-name.es.js","../node_modules/@motionone/dom/dist/animate/style.es.js","../node_modules/@motionone/dom/dist/animate/utils/stop-animation.es.js","../node_modules/@motionone/dom/dist/animate/animate-style.es.js","../node_modules/@motionone/dom/dist/animate/utils/options.es.js","../node_modules/@motionone/dom/dist/utils/resolve-elements.es.js","../node_modules/@motionone/dom/dist/animate/utils/controls.es.js","../node_modules/@motionone/dom/dist/utils/stagger.es.js","../node_modules/@motionone/dom/dist/animate/index.es.js","../node_modules/@motionone/utils/dist/is-string.es.js","../node_modules/@motionone/dom/dist/timeline/utils/calc-time.es.js","../node_modules/@motionone/dom/dist/timeline/utils/edit.es.js","../node_modules/@motionone/dom/dist/timeline/utils/sort.es.js","../node_modules/@motionone/dom/dist/timeline/index.es.js","../node_modules/@motionone/generators/dist/spring/defaults.es.js","../node_modules/@motionone/generators/dist/spring/utils.es.js","../node_modules/@motionone/utils/dist/velocity.es.js","../node_modules/@motionone/generators/dist/utils/velocity.es.js","../node_modules/@motionone/generators/dist/spring/index.es.js","../node_modules/@motionone/generators/dist/utils/has-reached-target.es.js","../node_modules/@motionone/generators/dist/utils/pregenerate-keyframes.es.js","../node_modules/@motionone/dom/dist/easing/create-generator-easing.es.js","../node_modules/@motionone/dom/dist/easing/spring/index.es.js","../node_modules/@motionone/dom/dist/easing/glide/index.es.js","../node_modules/@motionone/generators/dist/glide/index.es.js","../node_modules/@motionone/dom/dist/gestures/in-view.es.js","../node_modules/@motionone/dom/dist/gestures/resize/handle-element.es.js","../node_modules/@motionone/dom/dist/gestures/resize/handle-window.es.js","../node_modules/@motionone/dom/dist/gestures/resize/index.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/info.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/offsets/presets.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/offsets/edge.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/offsets/offset.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/offsets/index.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/offsets/inset.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/on-scroll-handler.es.js","../node_modules/@motionone/dom/dist/gestures/scroll/index.es.js","../node_modules/@motionone/dom/dist/state/utils/resolve-variant.es.js","../node_modules/@motionone/dom/dist/state/utils/is-variant.es.js","../node_modules/@motionone/dom/dist/state/utils/schedule.es.js","../node_modules/@motionone/dom/dist/state/utils/events.es.js","../node_modules/@motionone/dom/dist/state/gestures/in-view.es.js","../node_modules/@motionone/dom/dist/state/gestures/hover.es.js","../node_modules/@motionone/dom/dist/state/index.es.js","../node_modules/@motionone/dom/dist/state/gestures/press.es.js","../node_modules/@motionone/dom/dist/state/utils/has-changed.es.js","../node_modules/@motionone/dom/dist/animate/utils/style-object.es.js","../node_modules/@motionone/dom/dist/animate/utils/style-string.es.js","../node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js","../node_modules/framer-motion/dist/cjs/index.js","../node_modules/framesync/dist/framesync.cjs.js","../node_modules/popmotion/dist/popmotion.cjs.js","../node_modules/style-value-types/dist/valueTypes.cjs.js","../node_modules/@babel/runtime/helpers/arrayLikeToArray.js","../node_modules/@babel/runtime/helpers/arrayWithHoles.js","../node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","../node_modules/@babel/runtime/helpers/iterableToArray.js","../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","../node_modules/@babel/runtime/helpers/nonIterableRest.js","../node_modules/@babel/runtime/helpers/nonIterableSpread.js","../node_modules/@babel/runtime/helpers/slicedToArray.js","../node_modules/@babel/runtime/helpers/toConsumableArray.js","../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"],"sourcesContent":["function memoize(fn) {\n  var cache = {};\n  return function (arg) {\n    if (cache[arg] === undefined) cache[arg] = fn(arg);\n    return cache[arg];\n  };\n}\n\nexport default memoize;\n","import memoize from '@emotion/memoize';\n\nvar reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|inert|itemProp|itemScope|itemType|itemID|itemRef|on|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23\n\nvar index = memoize(function (prop) {\n  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111\n  /* o */\n  && prop.charCodeAt(1) === 110\n  /* n */\n  && prop.charCodeAt(2) < 91;\n}\n/* Z+1 */\n);\n\nexport default index;\n","import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport PropTypes from 'prop-types';\nimport ownerDocument from '../utils/ownerDocument';\nimport useForkRef from '../utils/useForkRef';\nimport useEventCallback from '../utils/useEventCallback';\nimport { elementAcceptingRef, exactProp } from '@material-ui/utils';\n\nfunction mapEventPropToEvent(eventProp) {\n  return eventProp.substring(2).toLowerCase();\n}\n\nfunction clickedRootScrollbar(event) {\n  return document.documentElement.clientWidth < event.clientX || document.documentElement.clientHeight < event.clientY;\n}\n/**\n * Listen for click events that occur somewhere in the document, outside of the element itself.\n * For instance, if you need to hide a menu when people click anywhere else on your page.\n */\n\n\nfunction ClickAwayListener(props) {\n  var children = props.children,\n      _props$disableReactTr = props.disableReactTree,\n      disableReactTree = _props$disableReactTr === void 0 ? false : _props$disableReactTr,\n      _props$mouseEvent = props.mouseEvent,\n      mouseEvent = _props$mouseEvent === void 0 ? 'onClick' : _props$mouseEvent,\n      onClickAway = props.onClickAway,\n      _props$touchEvent = props.touchEvent,\n      touchEvent = _props$touchEvent === void 0 ? 'onTouchEnd' : _props$touchEvent;\n  var movedRef = React.useRef(false);\n  var nodeRef = React.useRef(null);\n  var activatedRef = React.useRef(false);\n  var syntheticEventRef = React.useRef(false);\n  React.useEffect(function () {\n    // Ensure that this component is not \"activated\" synchronously.\n    // https://github.com/facebook/react/issues/20074\n    setTimeout(function () {\n      activatedRef.current = true;\n    }, 0);\n    return function () {\n      activatedRef.current = false;\n    };\n  }, []); // can be removed once we drop support for non ref forwarding class components\n\n  var handleOwnRef = React.useCallback(function (instance) {\n    // #StrictMode ready\n    nodeRef.current = ReactDOM.findDOMNode(instance);\n  }, []);\n  var handleRef = useForkRef(children.ref, handleOwnRef); // The handler doesn't take event.defaultPrevented into account:\n  //\n  // event.preventDefault() is meant to stop default behaviours like\n  // clicking a checkbox to check it, hitting a button to submit a form,\n  // and hitting left arrow to move the cursor in a text input etc.\n  // Only special HTML elements have these default behaviors.\n\n  var handleClickAway = useEventCallback(function (event) {\n    // Given developers can stop the propagation of the synthetic event,\n    // we can only be confident with a positive value.\n    var insideReactTree = syntheticEventRef.current;\n    syntheticEventRef.current = false; // 1. IE 11 support, which trigger the handleClickAway even after the unbind\n    // 2. The child might render null.\n    // 3. Behave like a blur listener.\n\n    if (!activatedRef.current || !nodeRef.current || clickedRootScrollbar(event)) {\n      return;\n    } // Do not act if user performed touchmove\n\n\n    if (movedRef.current) {\n      movedRef.current = false;\n      return;\n    }\n\n    var insideDOM; // If not enough, can use https://github.com/DieterHolvoet/event-propagation-path/blob/master/propagationPath.js\n\n    if (event.composedPath) {\n      insideDOM = event.composedPath().indexOf(nodeRef.current) > -1;\n    } else {\n      // TODO v6 remove dead logic https://caniuse.com/#search=composedPath.\n      var doc = ownerDocument(nodeRef.current);\n      insideDOM = !doc.documentElement.contains(event.target) || nodeRef.current.contains(event.target);\n    }\n\n    if (!insideDOM && (disableReactTree || !insideReactTree)) {\n      onClickAway(event);\n    }\n  }); // Keep track of mouse/touch events that bubbled up through the portal.\n\n  var createHandleSynthetic = function createHandleSynthetic(handlerName) {\n    return function (event) {\n      syntheticEventRef.current = true;\n      var childrenPropsHandler = children.props[handlerName];\n\n      if (childrenPropsHandler) {\n        childrenPropsHandler(event);\n      }\n    };\n  };\n\n  var childrenProps = {\n    ref: handleRef\n  };\n\n  if (touchEvent !== false) {\n    childrenProps[touchEvent] = createHandleSynthetic(touchEvent);\n  }\n\n  React.useEffect(function () {\n    if (touchEvent !== false) {\n      var mappedTouchEvent = mapEventPropToEvent(touchEvent);\n      var doc = ownerDocument(nodeRef.current);\n\n      var handleTouchMove = function handleTouchMove() {\n        movedRef.current = true;\n      };\n\n      doc.addEventListener(mappedTouchEvent, handleClickAway);\n      doc.addEventListener('touchmove', handleTouchMove);\n      return function () {\n        doc.removeEventListener(mappedTouchEvent, handleClickAway);\n        doc.removeEventListener('touchmove', handleTouchMove);\n      };\n    }\n\n    return undefined;\n  }, [handleClickAway, touchEvent]);\n\n  if (mouseEvent !== false) {\n    childrenProps[mouseEvent] = createHandleSynthetic(mouseEvent);\n  }\n\n  React.useEffect(function () {\n    if (mouseEvent !== false) {\n      var mappedMouseEvent = mapEventPropToEvent(mouseEvent);\n      var doc = ownerDocument(nodeRef.current);\n      doc.addEventListener(mappedMouseEvent, handleClickAway);\n      return function () {\n        doc.removeEventListener(mappedMouseEvent, handleClickAway);\n      };\n    }\n\n    return undefined;\n  }, [handleClickAway, mouseEvent]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.cloneElement(children, childrenProps));\n}\n\nprocess.env.NODE_ENV !== \"production\" ? ClickAwayListener.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The wrapped element.\n   */\n  children: elementAcceptingRef.isRequired,\n\n  /**\n   * If `true`, the React tree is ignored and only the DOM tree is considered.\n   * This prop changes how portaled elements are handled.\n   */\n  disableReactTree: PropTypes.bool,\n\n  /**\n   * The mouse event to listen to. You can disable the listener by providing `false`.\n   */\n  mouseEvent: PropTypes.oneOf(['onClick', 'onMouseDown', 'onMouseUp', false]),\n\n  /**\n   * Callback fired when a \"click away\" event is detected.\n   */\n  onClickAway: PropTypes.func.isRequired,\n\n  /**\n   * The touch event to listen to. You can disable the listener by providing `false`.\n   */\n  touchEvent: PropTypes.oneOf(['onTouchEnd', 'onTouchStart', false])\n} : void 0;\n\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  ClickAwayListener['propTypes' + ''] = exactProp(ClickAwayListener.propTypes);\n}\n\nexport default ClickAwayListener;","export default function ownerDocument(node) {\n  return node && node.ownerDocument || document;\n}","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _react = _interopRequireWildcard(require(\"react\"));\nvar _clsx = _interopRequireDefault(require(\"clsx\"));\nvar _makeStyles = _interopRequireDefault(require(\"@material-ui/styles/makeStyles\"));\nvar _overlayContext = _interopRequireDefault(require(\"./context/overlayContext\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\nfunction _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nvar useStyles = function useStyles(background) {\n  return (0, _makeStyles.default)(function (theme) {\n    var _theme$palette$backgr, _theme$palette, _theme$palette$backgr2, _theme$zIndex;\n    return {\n      backdrop: {\n        background: background ? background : (_theme$palette$backgr = theme === null || theme === void 0 ? void 0 : (_theme$palette = theme.palette) === null || _theme$palette === void 0 ? void 0 : (_theme$palette$backgr2 = _theme$palette.background) === null || _theme$palette$backgr2 === void 0 ? void 0 : _theme$palette$backgr2.backdrop) !== null && _theme$palette$backgr !== void 0 ? _theme$palette$backgr : \"rgba(0, 0, 0, 0.65)\",\n        bottom: 0,\n        left: 0,\n        right: 0,\n        top: 0,\n        position: \"fixed\",\n        zIndex: (theme === null || theme === void 0 ? void 0 : (_theme$zIndex = theme.zIndex) === null || _theme$zIndex === void 0 ? void 0 : _theme$zIndex.modal) - 1\n      }\n    };\n  })();\n};\nvar Backdrop = function Backdrop() {\n  var _useContext = (0, _react.useContext)(_overlayContext.default),\n    _useContext2 = _slicedToArray(_useContext, 1),\n    overlayProps = _useContext2[0];\n  var classes = overlayProps.classes,\n    background = overlayProps.background;\n  var css = useStyles(background);\n  return /*#__PURE__*/_react.default.createElement(\"div\", {\n    className: (0, _clsx.default)(\"mco-overlay-backdrop\", css.backdrop, classes === null || classes === void 0 ? void 0 : classes.backdrop)\n  });\n};\nvar _default = Backdrop;\nexports.default = _default;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _react = _interopRequireWildcard(require(\"react\"));\nvar _clsx = _interopRequireDefault(require(\"clsx\"));\nvar _framerMotion = require(\"framer-motion\");\nvar _makeStyles = _interopRequireDefault(require(\"@material-ui/styles/makeStyles\"));\nvar _overlayContext = _interopRequireDefault(require(\"./context/overlayContext\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\nfunction _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nvar useStyles = function useStyles(_ref) {\n  var fullscreen = _ref.fullscreen,\n    isMobile = _ref.isMobile,\n    nativeFullscreen = _ref.nativeFullscreen;\n  if (isMobile) {\n    return (0, _makeStyles.default)(function (theme) {\n      var _theme$zIndex;\n      return {\n        container: {\n          alignItems: \"center\",\n          bottom: 0,\n          display: \"flex\",\n          height: \"100%\",\n          justifyContent: \"center\",\n          left: 0,\n          maxHeight: !fullscreen ? \"90vh\" : \"100%\",\n          position: \"fixed\",\n          right: 0,\n          top: \"auto\",\n          zIndex: theme === null || theme === void 0 ? void 0 : (_theme$zIndex = theme.zIndex) === null || _theme$zIndex === void 0 ? void 0 : _theme$zIndex.modal\n        }\n      };\n    })();\n  }\n  return (0, _makeStyles.default)(function (theme) {\n    var _theme$zIndex2;\n    return {\n      container: {\n        alignItems: \"center\",\n        bottom: 0,\n        display: \"flex\",\n        justifyContent: \"center\",\n        left: 0,\n        padding: !fullscreen && !nativeFullscreen ? theme === null || theme === void 0 ? void 0 : theme.spacing(3) : 0,\n        position: \"fixed\",\n        right: 0,\n        top: 0,\n        zIndex: theme === null || theme === void 0 ? void 0 : (_theme$zIndex2 = theme.zIndex) === null || _theme$zIndex2 === void 0 ? void 0 : _theme$zIndex2.modal\n      }\n    };\n  })();\n};\nvar Container = function Container(props) {\n  var _useContext = (0, _react.useContext)(_overlayContext.default),\n    _useContext2 = _slicedToArray(_useContext, 1),\n    overlayProps = _useContext2[0];\n  var classes = overlayProps.classes,\n    fullscreen = overlayProps.fullscreen,\n    isMobile = overlayProps.isMobile,\n    nativeFullscreen = overlayProps.nativeFullscreen,\n    setOpen = overlayProps.setOpen;\n  var css = useStyles({\n    fullscreen: fullscreen,\n    isMobile: isMobile,\n    nativeFullscreen: nativeFullscreen\n  });\n  (0, _react.useEffect)(function () {\n    if (nativeFullscreen && window.innerWidth > 500) {\n      var exitHandler = function exitHandler() {\n        if (!document.webkitIsFullScreen && !document.mozFullScreen && !document.msFullscreenElement) {\n          setOpen(false);\n        }\n      };\n      var elem = document.documentElement;\n      if (elem.requestFullscreen) {\n        elem.requestFullscreen();\n      } else if (elem.webkitRequestFullscreen) {\n        elem.webkitRequestFullscreen();\n      } else if (elem.msRequestFullscreen) {\n        elem.msRequestFullscreen();\n      }\n      if (document.addEventListener) {\n        document.addEventListener(\"fullscreenchange\", exitHandler, false);\n        document.addEventListener(\"mozfullscreenchange\", exitHandler, false);\n        document.addEventListener(\"MSFullscreenChange\", exitHandler, false);\n        document.addEventListener(\"webkitfullscreenchange\", exitHandler, false);\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [nativeFullscreen]);\n  return /*#__PURE__*/_react.default.createElement(_framerMotion.motion.div, {\n    initial: {\n      y: isMobile ? window.innerHeight : 50,\n      opacity: 0\n    },\n    animate: {\n      y: 0,\n      opacity: 1\n    },\n    transition: {\n      type: \"spring\",\n      bounce: 0\n    },\n    className: (0, _clsx.default)(\"mco-overlay-container\", css.container, classes === null || classes === void 0 ? void 0 : classes.container)\n  }, props.children);\n};\nvar _default = Container;\nexports.default = _default;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _react = _interopRequireWildcard(require(\"react\"));\nvar _clsx3 = _interopRequireDefault(require(\"clsx\"));\nvar _makeStyles = _interopRequireDefault(require(\"@material-ui/styles/makeStyles\"));\nvar _ClickAwayListener = _interopRequireDefault(require(\"@material-ui/core/ClickAwayListener\"));\nvar _overlayContext = _interopRequireDefault(require(\"./context/overlayContext\"));\nvar _getImagePos = _interopRequireDefault(require(\"./utils/getImagePos\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\nfunction _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nvar ContentHtml = /*#__PURE__*/(0, _react.lazy)(function () {\n  return import(\"./contentHtml\");\n});\nvar ContentIframe = /*#__PURE__*/(0, _react.lazy)(function () {\n  return import(\"./contentIframe\");\n});\nvar ContentImages = /*#__PURE__*/(0, _react.lazy)(function () {\n  return import(\"./contentImages\");\n});\nvar ContentPrev = /*#__PURE__*/(0, _react.lazy)(function () {\n  return import(\"./contentPrev\");\n});\nvar ContentNext = /*#__PURE__*/(0, _react.lazy)(function () {\n  return import(\"./contentNext\");\n});\nvar useStyles = function useStyles(_ref) {\n  var fullscreen = _ref.fullscreen,\n    size = _ref.size,\n    noPadding = _ref.noPadding,\n    isMobile = _ref.isMobile;\n  var maxWidth = null;\n  if (typeof size === \"number\") {\n    maxWidth = size;\n  }\n  if (size === \"xsmall\") {\n    maxWidth = 375;\n  }\n  if (size === \"small\") {\n    maxWidth = 600;\n  }\n  if (size === \"medium\") {\n    maxWidth = 700;\n  }\n  if (size === \"large\") {\n    maxWidth = 980;\n  }\n  if (size === \"xlarge\") {\n    maxWidth = 1600;\n  }\n  return (0, _makeStyles.default)(function (theme) {\n    var _theme$zIndex;\n    return {\n      content: {\n        background: \"#FFFFFF\",\n        display: \"flex\",\n        flexDirection: \"column\",\n        height: isMobile || fullscreen ? \"100%\" : \"auto\",\n        maxHeight: isMobile ? \"none\" : \"100%\",\n        maxWidth: fullscreen ? \"none\" : maxWidth,\n        overflow: \"hidden\",\n        position: \"relative\",\n        width: \"100%\",\n        zIndex: theme === null || theme === void 0 ? void 0 : (_theme$zIndex = theme.zIndex) === null || _theme$zIndex === void 0 ? void 0 : _theme$zIndex.modal\n      },\n      contentImages: {\n        background: \"transparent\",\n        height: \"auto\",\n        maxHeight: \"100%\",\n        maxWidth: \"none\",\n        width: \"auto\"\n      },\n      scroll: {\n        padding: fullscreen || noPadding ? 0 : theme === null || theme === void 0 ? void 0 : theme.spacing(3, 3, 3),\n        overflow: \"auto\"\n      }\n    };\n  })();\n};\nvar Content = function Content(props) {\n  var _useContext = (0, _react.useContext)(_overlayContext.default),\n    _useContext2 = _slicedToArray(_useContext, 2),\n    overlayProps = _useContext2[0],\n    setOverlayProps = _useContext2[1];\n  var avoidCloseOnOutsideClickAndESC = overlayProps.avoidCloseOnOutsideClickAndESC,\n    classes = overlayProps.classes,\n    fullscreen = overlayProps.fullscreen,\n    images = overlayProps.images,\n    isMobile = overlayProps.isMobile,\n    mode = overlayProps.mode,\n    noPadding = overlayProps.noPadding,\n    setOpen = overlayProps.setOpen,\n    _overlayProps$showNex = overlayProps.showNext,\n    showNext = _overlayProps$showNex === void 0 ? false : _overlayProps$showNex,\n    _overlayProps$showPre = overlayProps.showPrev,\n    showPrev = _overlayProps$showPre === void 0 ? false : _overlayProps$showPre,\n    size = overlayProps.size,\n    onNext = overlayProps.onNext,\n    onPrev = overlayProps.onPrev;\n  var css = useStyles({\n    fullscreen: fullscreen,\n    size: size,\n    noPadding: noPadding,\n    isMobile: isMobile\n  });\n  (0, _react.useEffect)(function () {\n    function onKeyup(event) {\n      if (event.keyCode === 27) {\n        setOpen(false);\n      }\n    }\n    if (!avoidCloseOnOutsideClickAndESC) {\n      window.addEventListener(\"keyup\", onKeyup);\n      return function () {\n        return window.removeEventListener(\"keyup\", onKeyup);\n      };\n    }\n  }, [overlayProps, avoidCloseOnOutsideClickAndESC, setOpen]);\n  var element = null;\n  switch (mode) {\n    case \"html\":\n      element = /*#__PURE__*/_react.default.createElement(ContentHtml, null, props.children);\n      break;\n    case \"iframe\":\n      element = /*#__PURE__*/_react.default.createElement(ContentIframe, null);\n      break;\n    case \"images\":\n    case \"native-images\":\n      element = /*#__PURE__*/_react.default.createElement(ContentImages, null);\n      break;\n    default:\n      element = null;\n  }\n  var handleNextClick = function handleNextClick() {\n    if (mode === \"images\" || mode === \"native-images\") {\n      var newIndex = (0, _getImagePos.default)(overlayProps.images, overlayProps.imagesPos, \"next\");\n      setOverlayProps(_objectSpread(_objectSpread({}, overlayProps), {}, {\n        imagesPos: newIndex\n      }));\n    }\n    if (onNext) onNext();\n  };\n  var handlePrevClick = function handlePrevClick() {\n    if (mode === \"images\" || mode === \"native-images\") {\n      var newIndex = (0, _getImagePos.default)(overlayProps.images, overlayProps.imagesPos, \"prev\");\n      setOverlayProps(_objectSpread(_objectSpread({}, overlayProps), {}, {\n        imagesPos: newIndex\n      }));\n    }\n    if (onPrev) onPrev();\n  };\n  if (avoidCloseOnOutsideClickAndESC || showNext || showPrev) {\n    return /*#__PURE__*/_react.default.createElement(_react.Suspense, {\n      fallback: /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null)\n    }, /*#__PURE__*/_react.default.createElement(\"div\", {\n      className: (0, _clsx3.default)(\"mco-overlay-content\", css.content, classes === null || classes === void 0 ? void 0 : classes.content, _defineProperty({}, css.contentImages, mode === \"images\" || mode === \"native-images\"))\n    }, (images && images.length > 1 && !isMobile || showPrev) && /*#__PURE__*/_react.default.createElement(ContentPrev, {\n      onClick: handlePrevClick\n    }), element, (images && images.length > 1 && !isMobile || showNext) && /*#__PURE__*/_react.default.createElement(ContentNext, {\n      onClick: handleNextClick\n    })));\n  }\n  return /*#__PURE__*/_react.default.createElement(_react.Suspense, {\n    fallback: /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null)\n  }, /*#__PURE__*/_react.default.createElement(_ClickAwayListener.default, {\n    onClickAway: function onClickAway() {\n      setTimeout(function () {\n        setOpen(false);\n      }, 10);\n    }\n  }, /*#__PURE__*/_react.default.createElement(\"div\", {\n    className: (0, _clsx3.default)(\"mco-overlay-content\", css.content, _defineProperty({}, css.contentImages, mode === \"images\" || mode === \"native-images\"))\n  }, images && images.length > 1 && !isMobile && /*#__PURE__*/_react.default.createElement(ContentPrev, {\n    onClick: handlePrevClick\n  }), element, images && images.length > 1 && !isMobile && /*#__PURE__*/_react.default.createElement(ContentNext, {\n    onClick: handleNextClick\n  }))));\n};\nvar _default = Content;\nexports.default = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _react = require(\"react\");\nvar OverlayContext = /*#__PURE__*/(0, _react.createContext)();\nOverlayContext.displayName = \"OverlayContext\";\nvar _default = OverlayContext;\nexports.default = _default;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _react = _interopRequireWildcard(require(\"react\"));\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\nvar _portals = _interopRequireDefault(require(\"./portals\"));\nvar _overlayContext = _interopRequireDefault(require(\"./context/overlayContext\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\nfunction _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nvar ReactOverlay = function ReactOverlay(props) {\n  var _useState = (0, _react.useState)({}),\n    _useState2 = _slicedToArray(_useState, 2),\n    overlayProps = _useState2[0],\n    setOverlayProps = _useState2[1];\n  var newProps = (0, _react.useMemo)(function () {\n    return _objectSpread({}, props);\n  }, [props]);\n  (0, _react.useEffect)(function () {\n    setOverlayProps(newProps);\n  }, [newProps]);\n  var isMobile = window.innerWidth <= 600;\n  if (newProps.imagesPos === undefined) newProps.imagesPos = 0;\n  if (newProps.avoidCloseOnOutsideClickAndESC === undefined) newProps.avoidCloseOnOutsideClickAndESC = false;\n  if (newProps.mode === undefined) newProps.mode = \"html\";\n  if (newProps.noPadding === undefined) newProps.noPadding = false;\n  if (newProps.showClose === undefined) newProps.showClose = true;\n  if (newProps.showToolbar === undefined) newProps.showToolbar = true;\n  if (newProps.fullscreen === undefined) newProps.fullscreen = false;\n  if (newProps.nativeFullscreen === undefined) newProps.nativeFullscreen = false;\n\n  //if (newProps.toolbarInside === undefined) newProps.toolbarInside = false;\n\n  newProps.isMobile = isMobile;\n  return /*#__PURE__*/_react.default.createElement(_overlayContext.default.Provider, {\n    value: [overlayProps, setOverlayProps]\n  }, /*#__PURE__*/_react.default.createElement(_portals.default, null, props.children));\n};\nReactOverlay.propTypes = {\n  absoluteMediaURLs: _propTypes.default.bool,\n  aspectRatio: _propTypes.default.string,\n  avoidCloseOnOutsideClickAndESC: _propTypes.default.bool,\n  backdrop: _propTypes.default.string,\n  classes: _propTypes.default.object,\n  footer: _propTypes.default.object,\n  fullscreen: _propTypes.default.bool,\n  iframeURL: _propTypes.default.string,\n  images: _propTypes.default.array,\n  imagesPos: _propTypes.default.number,\n  mediaFormats: _propTypes.default.object,\n  mode: _propTypes.default.oneOf([\"html\", \"iframe\", \"images\", \"native-images\"]),\n  nativeFullscreen: _propTypes.default.bool,\n  noPadding: _propTypes.default.bool,\n  resourceURL: _propTypes.default.string,\n  setOpen: _propTypes.default.func.isRequired,\n  showClose: _propTypes.default.bool,\n  showToolbar: _propTypes.default.bool,\n  size: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.oneOf([\"xsmall\", \"small\", \"medium\", \"large\", \"xlarge\"])]),\n  title: _propTypes.default.any,\n  toolbarInside: _propTypes.default.bool,\n  toolbarColor: _propTypes.default.oneOf([\"primary\", \"secondary\"])\n};\nvar _default = ReactOverlay;\nexports.default = _default;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _react = _interopRequireWildcard(require(\"react\"));\nvar _reactDom = require(\"react-dom\");\nvar _clsx = _interopRequireDefault(require(\"clsx\"));\nvar _bodyScrollLock = require(\"body-scroll-lock\");\nvar _overlayContext = _interopRequireDefault(require(\"./context/overlayContext\"));\nvar _backdrop = _interopRequireDefault(require(\"./backdrop\"));\nvar _content = _interopRequireDefault(require(\"./content\"));\nvar _container = _interopRequireDefault(require(\"./container\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\nfunction _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nvar Portals = function Portals(props) {\n  var _useContext = (0, _react.useContext)(_overlayContext.default),\n    _useContext2 = _slicedToArray(_useContext, 1),\n    overlayProps = _useContext2[0];\n  (0, _react.useEffect)(function () {\n    document.body.appendChild(el.current);\n    return function () {\n      if (el.current.parentElement) {\n        el.current.parentElement.removeChild(el.current);\n        (0, _bodyScrollLock.clearAllBodyScrollLocks)();\n      }\n    };\n  }, [overlayProps.setOpen]);\n  var el = (0, _react.useRef)(document.createElement(\"div\"));\n  el.current.className = (0, _clsx.default)(\"mco-overlay\", overlayProps.className);\n  return /*#__PURE__*/(0, _reactDom.createPortal)( /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_container.default, null, /*#__PURE__*/_react.default.createElement(_content.default, null, props.children)), /*#__PURE__*/_react.default.createElement(_backdrop.default, null)), el.current);\n};\nvar _default = Portals;\nexports.default = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nfunction getImagePos(images, currentPos, move) {\n  if (move === \"next\") {\n    var newIndex = currentPos + 1;\n    if (currentPos === images.length - 1) {\n      newIndex = 0;\n    }\n    return newIndex;\n  } else if (move === \"prev\") {\n    var _newIndex = currentPos - 1;\n    if (_newIndex <= -1) {\n      _newIndex = images.length - 1;\n    }\n    return _newIndex;\n  }\n  return 0;\n}\nvar _default = getImagePos;\nexports.default = _default;","/**\n * The MotionValue tracks the state of a single animatable\n * value. Currently, updatedAt and current are unused. The\n * long term idea is to use this to minimise the number\n * of DOM reads, and to abstract the DOM interactions here.\n */\nclass MotionValue {\n    setAnimation(animation) {\n        this.animation = animation;\n        animation === null || animation === void 0 ? void 0 : animation.finished.then(() => this.clearAnimation()).catch(() => { });\n    }\n    clearAnimation() {\n        this.animation = this.generator = undefined;\n    }\n}\n\nexport { MotionValue };\n","import { MotionValue } from '@motionone/types';\n\nconst data = new WeakMap();\nfunction getAnimationData(element) {\n    if (!data.has(element)) {\n        data.set(element, {\n            transforms: [],\n            values: new Map(),\n        });\n    }\n    return data.get(element);\n}\nfunction getMotionValue(motionValues, name) {\n    if (!motionValues.has(name)) {\n        motionValues.set(name, new MotionValue());\n    }\n    return motionValues.get(name);\n}\n\nexport { getAnimationData, getMotionValue };\n","const noop = () => { };\nconst noopReturn = (v) => v;\n\nexport { noop, noopReturn };\n","function addUniqueItem(array, item) {\n    array.indexOf(item) === -1 && array.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n\nexport { addUniqueItem, removeItem };\n","import { noopReturn, addUniqueItem } from '@motionone/utils';\nimport { getAnimationData } from '../data.es.js';\n\n/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nconst axes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nconst order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\nconst transformAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n};\nconst rotation = {\n    syntax: \"<angle>\",\n    initialValue: \"0deg\",\n    toDefaultUnit: (v) => v + \"deg\",\n};\nconst baseTransformProperties = {\n    translate: {\n        syntax: \"<length-percentage>\",\n        initialValue: \"0px\",\n        toDefaultUnit: (v) => v + \"px\",\n    },\n    rotate: rotation,\n    scale: {\n        syntax: \"<number>\",\n        initialValue: 1,\n        toDefaultUnit: noopReturn,\n    },\n    skew: rotation,\n};\nconst transformDefinitions = new Map();\nconst asTransformCssVar = (name) => `--motion-${name}`;\n/**\n * Generate a list of every possible transform key\n */\nconst transforms = [\"x\", \"y\", \"z\"];\norder.forEach((name) => {\n    axes.forEach((axis) => {\n        transforms.push(name + axis);\n        transformDefinitions.set(asTransformCssVar(name + axis), baseTransformProperties[name]);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nconst compareTransformOrder = (a, b) => transforms.indexOf(a) - transforms.indexOf(b);\n/**\n * Provide a quick way to check if a string is the name of a transform\n */\nconst transformLookup = new Set(transforms);\nconst isTransform = (name) => transformLookup.has(name);\nconst addTransformToElement = (element, name) => {\n    // Map x to translateX etc\n    if (transformAlias[name])\n        name = transformAlias[name];\n    const { transforms } = getAnimationData(element);\n    addUniqueItem(transforms, name);\n    /**\n     * TODO: An optimisation here could be to cache the transform in element data\n     * and only update if this has changed.\n     */\n    element.style.transform = buildTransformTemplate(transforms);\n};\nconst buildTransformTemplate = (transforms) => transforms\n    .sort(compareTransformOrder)\n    .reduce(transformListToString, \"\")\n    .trim();\nconst transformListToString = (template, name) => `${template} ${name}(var(${asTransformCssVar(name)}))`;\n\nexport { addTransformToElement, asTransformCssVar, axes, buildTransformTemplate, compareTransformOrder, isTransform, transformAlias, transformDefinitions };\n","import { transformDefinitions } from './transforms.es.js';\n\nconst isCssVar = (name) => name.startsWith(\"--\");\nconst registeredProperties = new Set();\nfunction registerCssVariable(name) {\n    if (registeredProperties.has(name))\n        return;\n    registeredProperties.add(name);\n    try {\n        const { syntax, initialValue } = transformDefinitions.has(name)\n            ? transformDefinitions.get(name)\n            : {};\n        CSS.registerProperty({\n            name,\n            inherits: false,\n            syntax,\n            initialValue,\n        });\n    }\n    catch (e) { }\n}\n\nexport { isCssVar, registerCssVariable, registeredProperties };\n","const defaults = {\n    duration: 0.3,\n    delay: 0,\n    endDelay: 0,\n    repeat: 0,\n    easing: \"ease\",\n};\n\nexport { defaults };\n","const isEasingGenerator = (easing) => typeof easing === \"object\" &&\n    Boolean(easing.createAnimation);\n\nexport { isEasingGenerator };\n","const isNumber = (value) => typeof value === \"number\";\n\nexport { isNumber };\n","import { isNumber } from './is-number.es.js';\n\nconst isEasingList = (easing) => Array.isArray(easing) && !isNumber(easing[0]);\n\nexport { isEasingList };\n","const mix = (min, max, progress) => -progress * min + progress * max + min;\n\nexport { mix };\n","const progress = (min, max, value) => max - min === 0 ? 1 : (value - min) / (max - min);\n\nexport { progress };\n","import { mix } from './mix.es.js';\nimport { progress } from './progress.es.js';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mix(min, 1, offsetProgress));\n    }\n}\nfunction defaultOffset(length) {\n    const offset = [0];\n    fillOffset(offset, length - 1);\n    return offset;\n}\n\nexport { defaultOffset, fillOffset };\n","const wrap = (min, max, v) => {\n    const rangeSize = max - min;\n    return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;\n};\n\nexport { wrap };\n","import { isEasingList } from './is-easing-list.es.js';\nimport { wrap } from './wrap.es.js';\n\nfunction getEasingForSegment(easing, i) {\n    return isEasingList(easing)\n        ? easing[wrap(0, easing.length, i)]\n        : easing;\n}\n\nexport { getEasingForSegment };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","import { mix } from './mix.es.js';\nimport { noopReturn } from './noop.es.js';\nimport { fillOffset, defaultOffset } from './offset.es.js';\nimport { progress } from './progress.es.js';\nimport { getEasingForSegment } from './easing.es.js';\nimport { clamp } from './clamp.es.js';\n\nfunction interpolate(output, input = defaultOffset(output.length), easing = noopReturn) {\n    const length = output.length;\n    /**\n     * If the input length is lower than the output we\n     * fill the input to match. This currently assumes the input\n     * is an animation progress value so is a good candidate for\n     * moving outside the function.\n     */\n    const remainder = length - input.length;\n    remainder > 0 && fillOffset(input, remainder);\n    return (t) => {\n        let i = 0;\n        for (; i < length - 2; i++) {\n            if (t < input[i + 1])\n                break;\n        }\n        let progressInRange = clamp(0, 1, progress(input[i], input[i + 1], t));\n        const segmentEasing = getEasingForSegment(easing, i);\n        progressInRange = segmentEasing(progressInRange);\n        return mix(output[i], output[i + 1], progressInRange);\n    };\n}\n\nexport { interpolate };\n","import { noopReturn } from '@motionone/utils';\n\n/*\n  Bezier function generator\n\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) * t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noopReturn;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { clamp } from '@motionone/utils';\n\nconst steps = (steps, direction = \"end\") => (progress) => {\n    progress =\n        direction === \"end\"\n            ? Math.min(progress, 0.999)\n            : Math.max(progress, 0.001);\n    const expanded = progress * steps;\n    const rounded = direction === \"end\" ? Math.floor(expanded) : Math.ceil(expanded);\n    return clamp(0, 1, rounded / steps);\n};\n\nexport { steps };\n","const isFunction = (value) => typeof value === \"function\";\n\nexport { isFunction };\n","import { isNumber } from './is-number.es.js';\n\nconst isCubicBezier = (easing) => Array.isArray(easing) && isNumber(easing[0]);\n\nexport { isCubicBezier };\n","import { cubicBezier, steps } from '@motionone/easing';\nimport { isFunction, isCubicBezier, noopReturn } from '@motionone/utils';\n\nconst namedEasings = {\n    ease: cubicBezier(0.25, 0.1, 0.25, 1.0),\n    \"ease-in\": cubicBezier(0.42, 0.0, 1.0, 1.0),\n    \"ease-in-out\": cubicBezier(0.42, 0.0, 0.58, 1.0),\n    \"ease-out\": cubicBezier(0.0, 0.0, 0.58, 1.0),\n};\nconst functionArgsRegex = /\\((.*?)\\)/;\nfunction getEasingFunction(definition) {\n    // If already an easing function, return\n    if (isFunction(definition))\n        return definition;\n    // If an easing curve definition, return bezier function\n    if (isCubicBezier(definition))\n        return cubicBezier(...definition);\n    // If we have a predefined easing function, return\n    if (namedEasings[definition])\n        return namedEasings[definition];\n    // If this is a steps function, attempt to create easing curve\n    if (definition.startsWith(\"steps\")) {\n        const args = functionArgsRegex.exec(definition);\n        if (args) {\n            const argsArray = args[1].split(\",\");\n            return steps(parseFloat(argsArray[0]), argsArray[1].trim());\n        }\n    }\n    return noopReturn;\n}\n\nexport { getEasingFunction };\n","import { noopReturn, defaults, isEasingGenerator, isEasingList, interpolate } from '@motionone/utils';\nimport { getEasingFunction } from './utils/easing.es.js';\n\nclass Animation {\n    constructor(output, keyframes = [0, 1], { easing, duration: initialDuration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, offset, direction = \"normal\", } = {}) {\n        this.startTime = null;\n        this.rate = 1;\n        this.t = 0;\n        this.cancelTimestamp = null;\n        this.easing = noopReturn;\n        this.duration = 0;\n        this.totalDuration = 0;\n        this.repeat = 0;\n        this.playState = \"idle\";\n        this.finished = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n        easing = easing || defaults.easing;\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes);\n            easing = custom.easing;\n            keyframes = custom.keyframes || keyframes;\n            initialDuration = custom.duration || initialDuration;\n        }\n        this.repeat = repeat;\n        this.easing = isEasingList(easing) ? noopReturn : getEasingFunction(easing);\n        this.updateDuration(initialDuration);\n        const interpolate$1 = interpolate(keyframes, offset, isEasingList(easing) ? easing.map(getEasingFunction) : noopReturn);\n        this.tick = (timestamp) => {\n            var _a;\n            // TODO: Temporary fix for OptionsResolver typing\n            delay = delay;\n            let t = 0;\n            if (this.pauseTime !== undefined) {\n                t = this.pauseTime;\n            }\n            else {\n                t = (timestamp - this.startTime) * this.rate;\n            }\n            this.t = t;\n            // Convert to seconds\n            t /= 1000;\n            // Rebase on delay\n            t = Math.max(t - delay, 0);\n            /**\n             * If this animation has finished, set the current time\n             * to the total duration.\n             */\n            if (this.playState === \"finished\" && this.pauseTime === undefined) {\n                t = this.totalDuration;\n            }\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = t / this.duration;\n            // TODO progress += iterationStart\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            iterationProgress === 1 && currentIteration--;\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const iterationIsOdd = currentIteration % 2;\n            if (direction === \"reverse\" ||\n                (direction === \"alternate\" && iterationIsOdd) ||\n                (direction === \"alternate-reverse\" && !iterationIsOdd)) {\n                iterationProgress = 1 - iterationProgress;\n            }\n            const p = t >= this.totalDuration ? 1 : Math.min(iterationProgress, 1);\n            const latest = interpolate$1(this.easing(p));\n            output(latest);\n            const isAnimationFinished = this.pauseTime === undefined &&\n                (this.playState === \"finished\" || t >= this.totalDuration + endDelay);\n            if (isAnimationFinished) {\n                this.playState = \"finished\";\n                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, latest);\n            }\n            else if (this.playState !== \"idle\") {\n                this.frameRequestId = requestAnimationFrame(this.tick);\n            }\n        };\n        this.play();\n    }\n    play() {\n        const now = performance.now();\n        this.playState = \"running\";\n        if (this.pauseTime !== undefined) {\n            this.startTime = now - this.pauseTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = now;\n        }\n        this.cancelTimestamp = this.startTime;\n        this.pauseTime = undefined;\n        this.frameRequestId = requestAnimationFrame(this.tick);\n    }\n    pause() {\n        this.playState = \"paused\";\n        this.pauseTime = this.t;\n    }\n    finish() {\n        this.playState = \"finished\";\n        this.tick(0);\n    }\n    stop() {\n        var _a;\n        this.playState = \"idle\";\n        if (this.frameRequestId !== undefined) {\n            cancelAnimationFrame(this.frameRequestId);\n        }\n        (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, false);\n    }\n    cancel() {\n        this.stop();\n        this.tick(this.cancelTimestamp);\n    }\n    reverse() {\n        this.rate *= -1;\n    }\n    commitStyles() { }\n    updateDuration(duration) {\n        this.duration = duration;\n        this.totalDuration = duration * (this.repeat + 1);\n    }\n    get currentTime() {\n        return this.t;\n    }\n    set currentTime(t) {\n        if (this.pauseTime !== undefined || this.rate === 0) {\n            this.pauseTime = t;\n        }\n        else {\n            this.startTime = performance.now() - t / this.rate;\n        }\n    }\n    get playbackRate() {\n        return this.rate;\n    }\n    set playbackRate(rate) {\n        this.rate = rate;\n    }\n}\n\nexport { Animation };\n","const time = {\n    ms: (seconds) => seconds * 1000,\n    s: (milliseconds) => milliseconds / 1000,\n};\n\nexport { time };\n","import { isCubicBezier } from '@motionone/utils';\n\nconst convertEasing = (easing) => isCubicBezier(easing) ? cubicBezierAsString(easing) : easing;\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\n\nexport { convertEasing, cubicBezierAsString };\n","const testAnimation = (keyframes) => document.createElement(\"div\").animate(keyframes, { duration: 0.001 });\nconst featureTests = {\n    cssRegisterProperty: () => typeof CSS !== \"undefined\" &&\n        Object.hasOwnProperty.call(CSS, \"registerProperty\"),\n    waapi: () => Object.hasOwnProperty.call(Element.prototype, \"animate\"),\n    partialKeyframes: () => {\n        try {\n            testAnimation({ opacity: [1] });\n        }\n        catch (e) {\n            return false;\n        }\n        return true;\n    },\n    finished: () => Boolean(testAnimation({ opacity: [0, 1] }).finished),\n};\nconst results = {};\nconst supports = {};\nfor (const key in featureTests) {\n    supports[key] = () => {\n        if (results[key] === undefined)\n            results[key] = featureTests[key]();\n        return results[key];\n    };\n}\n\nexport { supports };\n","function hydrateKeyframes(keyframes, readInitialValue) {\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] === null) {\n            keyframes[i] = i ? keyframes[i - 1] : readInitialValue();\n        }\n    }\n    return keyframes;\n}\nconst keyframesList = (keyframes) => Array.isArray(keyframes) ? keyframes : [keyframes];\n\nexport { hydrateKeyframes, keyframesList };\n","import { isTransform, asTransformCssVar, transformAlias } from './transforms.es.js';\n\nfunction getStyleName(key) {\n    if (transformAlias[key])\n        key = transformAlias[key];\n    return isTransform(key) ? asTransformCssVar(key) : key;\n}\n\nexport { getStyleName };\n","import { isCssVar } from './utils/css-var.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { transformDefinitions } from './utils/transforms.es.js';\n\nconst style = {\n    get: (element, name) => {\n        name = getStyleName(name);\n        let value = isCssVar(name)\n            ? element.style.getPropertyValue(name)\n            : getComputedStyle(element)[name];\n        if (!value && value !== 0) {\n            const definition = transformDefinitions.get(name);\n            if (definition)\n                value = definition.initialValue;\n        }\n        return value;\n    },\n    set: (element, name, value) => {\n        name = getStyleName(name);\n        if (isCssVar(name)) {\n            element.style.setProperty(name, value);\n        }\n        else {\n            element.style[name] = value;\n        }\n    },\n};\n\nexport { style };\n","function stopAnimation(animation, needsCommit = true) {\n    if (!animation || animation.playState === \"finished\")\n        return;\n    // Suppress error thrown by WAAPI\n    try {\n        if (animation.stop) {\n            animation.stop();\n        }\n        else {\n            needsCommit && animation.commitStyles();\n            animation.cancel();\n        }\n    }\n    catch (e) { }\n}\n\nexport { stopAnimation };\n","import { getAnimationData, getMotionValue } from './data.es.js';\nimport { isCssVar, registerCssVariable } from './utils/css-var.es.js';\nimport { Animation } from '@motionone/animation';\nimport { defaults, isEasingGenerator, isNumber, time, isEasingList, noop } from '@motionone/utils';\nimport { isTransform, addTransformToElement, transformDefinitions } from './utils/transforms.es.js';\nimport { convertEasing } from './utils/easing.es.js';\nimport { supports } from './utils/feature-detection.es.js';\nimport { hydrateKeyframes, keyframesList } from './utils/keyframes.es.js';\nimport { style } from './style.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { stopAnimation } from './utils/stop-animation.es.js';\n\nfunction getDevToolsRecord() {\n    return window.__MOTION_DEV_TOOLS_RECORD;\n}\nfunction animateStyle(element, key, keyframesDefinition, options = {}) {\n    const record = getDevToolsRecord();\n    const isRecording = options.record !== false && record;\n    let animation;\n    let { duration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, easing = defaults.easing, direction, offset, allowWebkitAcceleration = false, } = options;\n    const data = getAnimationData(element);\n    let canAnimateNatively = supports.waapi();\n    const valueIsTransform = isTransform(key);\n    /**\n     * If this is an individual transform, we need to map its\n     * key to a CSS variable and update the element's transform style\n     */\n    valueIsTransform && addTransformToElement(element, key);\n    const name = getStyleName(key);\n    const motionValue = getMotionValue(data.values, name);\n    /**\n     * Get definition of value, this will be used to convert numerical\n     * keyframes into the default value type.\n     */\n    const definition = transformDefinitions.get(name);\n    /**\n     * Stop the current animation, if any. Because this will trigger\n     * commitStyles (DOM writes) and we might later trigger DOM reads,\n     * this is fired now and we return a factory function to create\n     * the actual animation that can get called in batch,\n     */\n    stopAnimation(motionValue.animation, !(isEasingGenerator(easing) && motionValue.generator) &&\n        options.record !== false);\n    /**\n     * Batchable factory function containing all DOM reads.\n     */\n    return () => {\n        const readInitialValue = () => { var _a, _b; return (_b = (_a = style.get(element, name)) !== null && _a !== void 0 ? _a : definition === null || definition === void 0 ? void 0 : definition.initialValue) !== null && _b !== void 0 ? _b : 0; };\n        /**\n         * Replace null values with the previous keyframe value, or read\n         * it from the DOM if it's the first keyframe.\n         */\n        let keyframes = hydrateKeyframes(keyframesList(keyframesDefinition), readInitialValue);\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes, readInitialValue, valueIsTransform, name, motionValue);\n            easing = custom.easing;\n            if (custom.keyframes !== undefined)\n                keyframes = custom.keyframes;\n            if (custom.duration !== undefined)\n                duration = custom.duration;\n        }\n        /**\n         * If this is a CSS variable we need to register it with the browser\n         * before it can be animated natively. We also set it with setProperty\n         * rather than directly onto the element.style object.\n         */\n        if (isCssVar(name)) {\n            if (supports.cssRegisterProperty()) {\n                registerCssVariable(name);\n            }\n            else {\n                canAnimateNatively = false;\n            }\n        }\n        /**\n         * If we can animate this value with WAAPI, do so. Currently this only\n         * feature detects CSS.registerProperty but could check WAAPI too.\n         */\n        if (canAnimateNatively) {\n            /**\n             * Convert numbers to default value types. Currently this only supports\n             * transforms but it could also support other value types.\n             */\n            if (definition) {\n                keyframes = keyframes.map((value) => isNumber(value) ? definition.toDefaultUnit(value) : value);\n            }\n            /**\n             * If this browser doesn't support partial/implicit keyframes we need to\n             * explicitly provide one.\n             */\n            if (keyframes.length === 1 &&\n                (!supports.partialKeyframes() || isRecording)) {\n                keyframes.unshift(readInitialValue());\n            }\n            const animationOptions = {\n                delay: time.ms(delay),\n                duration: time.ms(duration),\n                endDelay: time.ms(endDelay),\n                easing: !isEasingList(easing) ? convertEasing(easing) : undefined,\n                direction,\n                iterations: repeat + 1,\n                fill: \"both\",\n            };\n            animation = element.animate({\n                [name]: keyframes,\n                offset,\n                easing: isEasingList(easing) ? easing.map(convertEasing) : undefined,\n            }, animationOptions);\n            /**\n             * Polyfill finished Promise in browsers that don't support it\n             */\n            if (!animation.finished) {\n                animation.finished = new Promise((resolve, reject) => {\n                    animation.onfinish = resolve;\n                    animation.oncancel = reject;\n                });\n            }\n            const target = keyframes[keyframes.length - 1];\n            animation.finished\n                .then(() => {\n                // Apply styles to target\n                style.set(element, name, target);\n                // Ensure fill modes don't persist\n                animation.cancel();\n            })\n                .catch(noop);\n            /**\n             * This forces Webkit to run animations on the main thread by exploiting\n             * this condition:\n             * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp?rev=281238#L1099\n             *\n             * This fixes Webkit's timing bugs, like accelerated animations falling\n             * out of sync with main thread animations and massive delays in starting\n             * accelerated animations in WKWebView.\n             */\n            if (!allowWebkitAcceleration)\n                animation.playbackRate = 1.000001;\n            /**\n             * If we can't animate the value natively then we can fallback to the numbers-only\n             * polyfill for transforms.\n             */\n        }\n        else if (valueIsTransform) {\n            /**\n             * If any keyframe is a string (because we measured it from the DOM), we need to convert\n             * it into a number before passing to the Animation polyfill.\n             */\n            keyframes = keyframes.map((value) => typeof value === \"string\" ? parseFloat(value) : value);\n            /**\n             * If we only have a single keyframe, we need to create an initial keyframe by reading\n             * the current value from the DOM.\n             */\n            if (keyframes.length === 1) {\n                keyframes.unshift(parseFloat(readInitialValue()));\n            }\n            const render = (latest) => {\n                if (definition)\n                    latest = definition.toDefaultUnit(latest);\n                style.set(element, name, latest);\n            };\n            animation = new Animation(render, keyframes, Object.assign(Object.assign({}, options), { duration,\n                easing }));\n        }\n        else {\n            const target = keyframes[keyframes.length - 1];\n            style.set(element, name, definition && isNumber(target)\n                ? definition.toDefaultUnit(target)\n                : target);\n        }\n        if (isRecording) {\n            record(element, key, keyframes, {\n                duration,\n                delay: delay,\n                easing,\n                repeat,\n                offset,\n            }, \"motion-one\");\n        }\n        motionValue.setAnimation(animation);\n        return animation;\n    };\n}\n\nexport { animateStyle };\n","const getOptions = (options, key) => \n/**\n * TODO: Make test for this\n * Always return a new object otherwise delay is overwritten by results of stagger\n * and this results in no stagger\n */\noptions[key] ? Object.assign(Object.assign({}, options), options[key]) : Object.assign({}, options);\n\nexport { getOptions };\n","function resolveElements(elements, selectorCache) {\n    var _a;\n    if (typeof elements === \"string\") {\n        if (selectorCache) {\n            (_a = selectorCache[elements]) !== null && _a !== void 0 ? _a : (selectorCache[elements] = document.querySelectorAll(elements));\n            elements = selectorCache[elements];\n        }\n        else {\n            elements = document.querySelectorAll(elements);\n        }\n    }\n    else if (elements instanceof Element) {\n        elements = [elements];\n    }\n    /**\n     * Return an empty array\n     */\n    return Array.from(elements || []);\n}\n\nexport { resolveElements };\n","import { defaults, noop, time } from '@motionone/utils';\nimport { stopAnimation } from './stop-animation.es.js';\n\nconst createAnimation = (factory) => factory();\nconst withControls = (animationFactory, options, duration = defaults.duration) => {\n    return new Proxy({\n        animations: animationFactory.map(createAnimation).filter(Boolean),\n        duration,\n        options,\n    }, controls);\n};\n/**\n * TODO:\n * Currently this returns the first animation, ideally it would return\n * the first active animation.\n */\nconst getActiveAnimation = (state) => state.animations[0];\nconst controls = {\n    get: (target, key) => {\n        const activeAnimation = getActiveAnimation(target);\n        switch (key) {\n            case \"duration\":\n                return target.duration;\n            case \"currentTime\":\n                return time.s((activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) || 0);\n            case \"playbackRate\":\n            case \"playState\":\n                return activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key];\n            case \"finished\":\n                if (!target.finished) {\n                    target.finished = Promise.all(target.animations.map(selectFinished)).catch(noop);\n                }\n                return target.finished;\n            case \"stop\":\n                return () => {\n                    target.animations.forEach((animation) => stopAnimation(animation));\n                };\n            case \"forEachNative\":\n                /**\n                 * This is for internal use only, fire a callback for each\n                 * underlying animation.\n                 */\n                return (callback) => {\n                    target.animations.forEach((animation) => callback(animation, target));\n                };\n            default:\n                return typeof (activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) === \"undefined\"\n                    ? undefined\n                    : () => target.animations.forEach((animation) => animation[key]());\n        }\n    },\n    set: (target, key, value) => {\n        switch (key) {\n            case \"currentTime\":\n                value = time.ms(value);\n            case \"currentTime\":\n            case \"playbackRate\":\n                for (let i = 0; i < target.animations.length; i++) {\n                    target.animations[i][key] = value;\n                }\n                return true;\n        }\n        return false;\n    },\n};\nconst selectFinished = (animation) => animation.finished;\n\nexport { controls, withControls };\n","import { isNumber } from '@motionone/utils';\nimport { getEasingFunction } from '@motionone/animation';\n\nfunction stagger(duration = 0.1, { start = 0, from = 0, easing } = {}) {\n    return (i, total) => {\n        const fromIndex = isNumber(from) ? from : getFromIndex(from, total);\n        const distance = Math.abs(fromIndex - i);\n        let delay = duration * distance;\n        if (easing) {\n            const maxDelay = total * duration;\n            const easingFunction = getEasingFunction(easing);\n            delay = easingFunction(delay / maxDelay) * maxDelay;\n        }\n        return start + delay;\n    };\n}\nfunction getFromIndex(from, total) {\n    if (from === \"first\") {\n        return 0;\n    }\n    else {\n        const lastIndex = total - 1;\n        return from === \"last\" ? lastIndex : lastIndex / 2;\n    }\n}\nfunction resolveOption(option, i, total) {\n    return typeof option === \"function\"\n        ? option(i, total)\n        : option;\n}\n\nexport { getFromIndex, resolveOption, stagger };\n","import { animateStyle } from './animate-style.es.js';\nimport { getOptions } from './utils/options.es.js';\nimport { resolveElements } from '../utils/resolve-elements.es.js';\nimport { withControls } from './utils/controls.es.js';\nimport { resolveOption } from '../utils/stagger.es.js';\n\nfunction animate(elements, keyframes, options = {}) {\n    elements = resolveElements(elements);\n    const numElements = elements.length;\n    /**\n     * Create and start new animations\n     */\n    const animationFactories = [];\n    for (let i = 0; i < numElements; i++) {\n        const element = elements[i];\n        for (const key in keyframes) {\n            const valueOptions = getOptions(options, key);\n            valueOptions.delay = resolveOption(valueOptions.delay, i, numElements);\n            const animation = animateStyle(element, key, keyframes[key], valueOptions);\n            animationFactories.push(animation);\n        }\n    }\n    return withControls(animationFactories, options, \n    /**\n     * TODO:\n     * If easing is set to spring or glide, duration will be dynamically\n     * generated. Ideally we would dynamically generate this from\n     * animation.effect.getComputedTiming().duration but this isn't\n     * supported in iOS13 or our number polyfill. Perhaps it's possible\n     * to Proxy animations returned from animateStyle that has duration\n     * as a getter.\n     */\n    options.duration);\n}\n\nexport { animate };\n","const isString = (value) => typeof value === \"string\";\n\nexport { isString };\n","import { isNumber } from '@motionone/utils';\n\nfunction calcNextTime(current, next, prev, labels) {\n    var _a;\n    if (isNumber(next)) {\n        return next;\n    }\n    else if (next.startsWith(\"-\") || next.startsWith(\"+\")) {\n        return Math.max(0, current + parseFloat(next));\n    }\n    else if (next === \"<\") {\n        return prev;\n    }\n    else {\n        return (_a = labels.get(next)) !== null && _a !== void 0 ? _a : current;\n    }\n}\n\nexport { calcNextTime };\n","import { mix, getEasingForSegment, removeItem } from '@motionone/utils';\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}\n\nexport { addKeyframes, eraseKeyframes };\n","function compareByTime(a, b) {\n    if (a.at === b.at) {\n        return a.value === null ? 1 : -1;\n    }\n    else {\n        return a.at - b.at;\n    }\n}\n\nexport { compareByTime };\n","import { __rest } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { isString, defaults, isEasingGenerator, defaultOffset, fillOffset, progress } from '@motionone/utils';\nimport { resolveOption } from '../utils/stagger.es.js';\nimport { animateStyle } from '../animate/animate-style.es.js';\nimport { withControls } from '../animate/utils/controls.es.js';\nimport { keyframesList } from '../animate/utils/keyframes.es.js';\nimport { getOptions } from '../animate/utils/options.es.js';\nimport { resolveElements } from '../utils/resolve-elements.es.js';\nimport { isTransform } from '../animate/utils/transforms.es.js';\nimport { calcNextTime } from './utils/calc-time.es.js';\nimport { addKeyframes } from './utils/edit.es.js';\nimport { compareByTime } from './utils/sort.es.js';\n\nfunction timeline(definition, options = {}) {\n    var _a;\n    const animationDefinitions = createAnimationsFromTimeline(definition, options);\n    /**\n     * Create and start animations\n     */\n    const animationFactories = animationDefinitions\n        .map((definition) => animateStyle(...definition))\n        .filter(Boolean);\n    return withControls(animationFactories, options, \n    // Get the duration from the first animation definition\n    (_a = animationDefinitions[0]) === null || _a === void 0 ? void 0 : _a[3].duration);\n}\nfunction createAnimationsFromTimeline(definition, _a = {}) {\n    var { defaultOptions = {} } = _a, timelineOptions = __rest(_a, [\"defaultOptions\"]);\n    const animationDefinitions = [];\n    const elementSequences = 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 definition 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 < definition.length; i++) {\n        const segment = definition[i];\n        /**\n         * If this is a timeline label, mark it and skip the rest of this iteration.\n         */\n        if (isString(segment)) {\n            timeLabels.set(segment, currentTime);\n            continue;\n        }\n        else if (!Array.isArray(segment)) {\n            timeLabels.set(segment.name, calcNextTime(currentTime, segment.at, prevTime, timeLabels));\n            continue;\n        }\n        const [elementDefinition, keyframes, options = {}] = 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 (options.at !== undefined) {\n            currentTime = calcNextTime(currentTime, options.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        /**\n         * Find all the elements specified in the definition and parse value\n         * keyframes from their timeline definitions.\n         */\n        const elements = resolveElements(elementDefinition, elementCache);\n        const numElements = elements.length;\n        for (let elementIndex = 0; elementIndex < numElements; elementIndex++) {\n            const element = elements[elementIndex];\n            const elementSequence = getElementSequence(element, elementSequences);\n            for (const key in keyframes) {\n                const valueSequence = getValueSequence(key, elementSequence);\n                let valueKeyframes = keyframesList(keyframes[key]);\n                const valueOptions = getOptions(options, key);\n                let { duration = defaultOptions.duration || defaults.duration, easing = defaultOptions.easing || defaults.easing, } = valueOptions;\n                if (isEasingGenerator(easing)) {\n                    const valueIsTransform = isTransform(key);\n                    invariant(valueKeyframes.length === 2 || !valueIsTransform, \"spring must be provided 2 keyframes within timeline\");\n                    const custom = easing.createAnimation(valueKeyframes, \n                    // TODO We currently only support explicit keyframes\n                    // so this doesn't currently read from the DOM\n                    () => \"0\", valueIsTransform);\n                    easing = custom.easing;\n                    if (custom.keyframes !== undefined)\n                        valueKeyframes = custom.keyframes;\n                    if (custom.duration !== undefined)\n                        duration = custom.duration;\n                }\n                const delay = resolveOption(options.delay, elementIndex, numElements) || 0;\n                const startTime = currentTime + delay;\n                const targetTime = startTime + duration;\n                /**\n                 *\n                 */\n                let { offset = defaultOffset(valueKeyframes.length) } = valueOptions;\n                /**\n                 * If there's only one offset of 0, fill in a second with length 1\n                 *\n                 * TODO: Ensure there's a test that covers this removal\n                 */\n                if (offset.length === 1 && offset[0] === 0) {\n                    offset[1] = 1;\n                }\n                /**\n                 * Fill out if offset if fewer offsets than keyframes\n                 */\n                const remainder = length - valueKeyframes.length;\n                remainder > 0 && fillOffset(offset, 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                valueKeyframes.length === 1 && valueKeyframes.unshift(null);\n                /**\n                 * Add keyframes, mapping offsets to absolute time.\n                 */\n                addKeyframes(valueSequence, valueKeyframes, easing, offset, startTime, targetTime);\n                maxDuration = Math.max(delay + duration, maxDuration);\n                totalDuration = Math.max(targetTime, totalDuration);\n            }\n        }\n        prevTime = currentTime;\n        currentTime += maxDuration;\n    }\n    /**\n     * For every element and value combination create a new animation.\n     */\n    elementSequences.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 { at, value, easing } = valueSequence[i];\n                keyframes.push(value);\n                valueOffset.push(progress(0, totalDuration, at));\n                valueEasing.push(easing || defaults.easing);\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(\"linear\");\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            animationDefinitions.push([\n                element,\n                key,\n                keyframes,\n                Object.assign(Object.assign(Object.assign({}, defaultOptions), { duration: totalDuration, easing: valueEasing, offset: valueOffset }), timelineOptions),\n            ]);\n        }\n    });\n    return animationDefinitions;\n}\nfunction getElementSequence(element, sequences) {\n    !sequences.has(element) && sequences.set(element, {});\n    return sequences.get(element);\n}\nfunction getValueSequence(name, sequences) {\n    if (!sequences[name])\n        sequences[name] = [];\n    return sequences[name];\n}\n\nexport { createAnimationsFromTimeline, timeline };\n","const defaults = {\n    stiffness: 100.0,\n    damping: 10.0,\n    mass: 1.0,\n};\n\nexport { defaults };\n","import { defaults } from './defaults.es.js';\n\nconst calcDampingRatio = (stiffness = defaults.stiffness, damping = defaults.damping, mass = defaults.mass) => damping / (2 * Math.sqrt(stiffness * mass));\n\nexport { calcDampingRatio };\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}\n\nexport { velocityPerSecond };\n","import { velocityPerSecond } from '@motionone/utils';\n\nconst sampleT = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - sampleT, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { calcGeneratorVelocity };\n","import { time } from '@motionone/utils';\nimport { defaults } from './defaults.es.js';\nimport { calcDampingRatio } from './utils.es.js';\nimport { hasReachedTarget } from '../utils/has-reached-target.es.js';\nimport { calcGeneratorVelocity } from '../utils/velocity.es.js';\n\nconst spring = ({ stiffness = defaults.stiffness, damping = defaults.damping, mass = defaults.mass, from = 0, to = 1, velocity = 0.0, restSpeed = 2, restDistance = 0.5, } = {}) => {\n    velocity = velocity ? time.s(velocity) : 0.0;\n    const state = {\n        done: false,\n        hasReachedTarget: false,\n        current: from,\n        target: to,\n    };\n    const initialDelta = to - from;\n    const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n    const dampingRatio = calcDampingRatio(stiffness, damping, mass);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = undampedAngularFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n        // Underdamped spring (bouncy)\n        resolveSpring = (t) => to -\n            Math.exp(-dampingRatio * undampedAngularFreq * t) *\n                (((-velocity + dampingRatio * undampedAngularFreq * initialDelta) /\n                    angularFreq) *\n                    Math.sin(angularFreq * t) +\n                    initialDelta * Math.cos(angularFreq * t));\n    }\n    else {\n        // Critically damped spring\n        resolveSpring = (t) => {\n            return (to -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta + (-velocity + undampedAngularFreq * initialDelta) * t));\n        };\n    }\n    return (t) => {\n        state.current = resolveSpring(t);\n        const currentVelocity = t === 0\n            ? velocity\n            : calcGeneratorVelocity(resolveSpring, t, state.current);\n        const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n        const isBelowDisplacementThreshold = Math.abs(to - state.current) <= restDistance;\n        state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;\n        state.hasReachedTarget = hasReachedTarget(from, to, state.current);\n        return state;\n    };\n};\n\nexport { spring };\n","function hasReachedTarget(origin, target, current) {\n    return ((origin < target && current >= target) ||\n        (origin > target && current <= target));\n}\n\nexport { hasReachedTarget };\n","import { noopReturn } from '@motionone/utils';\n\nconst timeStep = 10;\nconst maxDuration = 10000;\nfunction pregenerateKeyframes(generator, toUnit = noopReturn) {\n    let overshootDuration = undefined;\n    let timestamp = timeStep;\n    let state = generator(0);\n    const keyframes = [toUnit(state.current)];\n    while (!state.done && timestamp < maxDuration) {\n        state = generator(timestamp);\n        keyframes.push(toUnit(state.done ? state.target : state.current));\n        if (overshootDuration === undefined && state.hasReachedTarget) {\n            overshootDuration = timestamp;\n        }\n        timestamp += timeStep;\n    }\n    const duration = timestamp - timeStep;\n    /**\n     * If generating an animation that didn't actually move,\n     * generate a second keyframe so we have an origin and target.\n     */\n    if (keyframes.length === 1)\n        keyframes.push(state.current);\n    return {\n        keyframes,\n        duration: duration / 1000,\n        overshootDuration: (overshootDuration !== null && overshootDuration !== void 0 ? overshootDuration : duration) / 1000,\n    };\n}\n\nexport { pregenerateKeyframes };\n","import { calcGeneratorVelocity, pregenerateKeyframes } from '@motionone/generators';\n\nfunction createGeneratorEasing(createGenerator) {\n    const keyframesCache = new WeakMap();\n    return (options = {}) => {\n        const generatorCache = new Map();\n        const getGenerator = (from = 0, to = 100, velocity = 0, isScale = false) => {\n            const key = `${from}-${to}-${velocity}-${isScale}`;\n            if (!generatorCache.has(key)) {\n                generatorCache.set(key, createGenerator(Object.assign({ from,\n                    to,\n                    velocity, restSpeed: isScale ? 0.05 : 2, restDistance: isScale ? 0.01 : 0.5 }, options)));\n            }\n            return generatorCache.get(key);\n        };\n        const getKeyframes = (generator) => {\n            if (!keyframesCache.has(generator)) {\n                keyframesCache.set(generator, pregenerateKeyframes(generator));\n            }\n            return keyframesCache.get(generator);\n        };\n        return {\n            createAnimation: (keyframes, getOrigin, canUseGenerator, name, motionValue) => {\n                var _a, _b;\n                let settings;\n                const numKeyframes = keyframes.length;\n                let shouldUseGenerator = canUseGenerator &&\n                    numKeyframes <= 2 &&\n                    keyframes.every(isNumberOrNull);\n                if (shouldUseGenerator) {\n                    const target = keyframes[numKeyframes - 1];\n                    const unresolvedOrigin = numKeyframes === 1 ? null : keyframes[0];\n                    let velocity = 0;\n                    let origin = 0;\n                    const prevGenerator = motionValue === null || motionValue === void 0 ? void 0 : motionValue.generator;\n                    if (prevGenerator) {\n                        /**\n                         * If we have a generator for this value we can use it to resolve\n                         * the animations's current value and velocity.\n                         */\n                        const { animation, generatorStartTime } = motionValue;\n                        const startTime = (animation === null || animation === void 0 ? void 0 : animation.startTime) || generatorStartTime || 0;\n                        const currentTime = (animation === null || animation === void 0 ? void 0 : animation.currentTime) || performance.now() - startTime;\n                        const prevGeneratorCurrent = prevGenerator(currentTime).current;\n                        origin = (_a = unresolvedOrigin) !== null && _a !== void 0 ? _a : prevGeneratorCurrent;\n                        if (numKeyframes === 1 ||\n                            (numKeyframes === 2 && keyframes[0] === null)) {\n                            velocity = calcGeneratorVelocity((t) => prevGenerator(t).current, currentTime, prevGeneratorCurrent);\n                        }\n                    }\n                    else {\n                        origin = (_b = unresolvedOrigin) !== null && _b !== void 0 ? _b : parseFloat(getOrigin());\n                    }\n                    const generator = getGenerator(origin, target, velocity, name === null || name === void 0 ? void 0 : name.includes(\"scale\"));\n                    const keyframesMetadata = getKeyframes(generator);\n                    settings = Object.assign(Object.assign({}, keyframesMetadata), { easing: \"linear\" });\n                    // TODO Add test for this\n                    if (motionValue) {\n                        motionValue.generator = generator;\n                        motionValue.generatorStartTime = performance.now();\n                    }\n                }\n                else {\n                    const keyframesMetadata = getKeyframes(getGenerator(0, 100));\n                    settings = {\n                        easing: \"ease\",\n                        duration: keyframesMetadata.overshootDuration,\n                    };\n                }\n                return settings;\n            },\n        };\n    };\n}\nconst isNumberOrNull = (value) => typeof value !== \"string\";\n\nexport { createGeneratorEasing };\n","import { spring as spring$1 } from '@motionone/generators';\nimport { createGeneratorEasing } from '../create-generator-easing.es.js';\n\nconst spring = createGeneratorEasing(spring$1);\n\nexport { spring };\n","import { glide as glide$1 } from '@motionone/generators';\nimport { createGeneratorEasing } from '../create-generator-easing.es.js';\n\nconst glide = createGeneratorEasing(glide$1);\n\nexport { glide };\n","import { time } from '@motionone/utils';\nimport { calcGeneratorVelocity } from '../utils/velocity.es.js';\nimport { spring } from '../spring/index.es.js';\n\nconst glide = ({ from = 0, velocity = 0.0, power = 0.8, decay = 0.325, bounceDamping, bounceStiffness, changeTarget, min, max, restDistance = 0.5, restSpeed, }) => {\n    decay = time.ms(decay);\n    const state = {\n        hasReachedTarget: false,\n        done: false,\n        current: from,\n        target: from,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (v) => {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    };\n    let amplitude = power * velocity;\n    const ideal = from + amplitude;\n    const target = changeTarget === undefined ? ideal : changeTarget(ideal);\n    state.target = target;\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)\n        amplitude = target - from;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / decay);\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) <= restDistance;\n        state.current = 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.current))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            from: state.current,\n            to: nearestBoundary(state.current),\n            velocity: calcGeneratorVelocity(calcLatest, t, state.current),\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDistance,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return (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            state.hasReachedTarget = true;\n            return spring$1(t - timeReachedBoundary);\n        }\n        else {\n            state.hasReachedTarget = false;\n            !hasUpdatedFrame && applyFriction(t);\n            return state;\n        }\n    };\n};\n\nexport { glide };\n","import { resolveElements } from '../utils/resolve-elements.es.js';\n\nconst thresholds = {\n    any: 0,\n    all: 1,\n};\nfunction inView(elementOrSelector, onStart, { root, margin: rootMargin, amount = \"any\" } = {}) {\n    /**\n     * If this browser doesn't support IntersectionObserver, return a dummy stop function.\n     * Default triggering of onStart is tricky - it could be used for starting/stopping\n     * videos, lazy loading content etc. We could provide an option to enable a fallback, or\n     * provide a fallback callback option.\n     */\n    if (typeof IntersectionObserver === \"undefined\") {\n        return () => { };\n    }\n    const elements = resolveElements(elementOrSelector);\n    const activeIntersections = new WeakMap();\n    const onIntersectionChange = (entries) => {\n        entries.forEach((entry) => {\n            const onEnd = activeIntersections.get(entry.target);\n            /**\n             * If there's no change to the intersection, we don't need to\n             * do anything here.\n             */\n            if (entry.isIntersecting === Boolean(onEnd))\n                return;\n            if (entry.isIntersecting) {\n                const newOnEnd = onStart(entry);\n                if (typeof newOnEnd === \"function\") {\n                    activeIntersections.set(entry.target, newOnEnd);\n                }\n                else {\n                    observer.unobserve(entry.target);\n                }\n            }\n            else if (onEnd) {\n                onEnd(entry);\n                activeIntersections.delete(entry.target);\n            }\n        });\n    };\n    const observer = new IntersectionObserver(onIntersectionChange, {\n        root,\n        rootMargin,\n        threshold: typeof amount === \"number\" ? amount : thresholds[amount],\n    });\n    elements.forEach((element) => observer.observe(element));\n    return () => observer.disconnect();\n}\n\nexport { inView };\n","import { resolveElements } from '../../utils/resolve-elements.es.js';\n\nconst resizeHandlers = new WeakMap();\nlet observer;\nfunction getElementSize(target, borderBoxSize) {\n    if (borderBoxSize) {\n        const { inlineSize, blockSize } = borderBoxSize[0];\n        return { width: inlineSize, height: blockSize };\n    }\n    else if (target instanceof SVGElement && \"getBBox\" in target) {\n        return target.getBBox();\n    }\n    else {\n        return {\n            width: target.offsetWidth,\n            height: target.offsetHeight,\n        };\n    }\n}\nfunction notifyTarget({ target, contentRect, borderBoxSize, }) {\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\")\n        return;\n    observer = new ResizeObserver(notifyAll);\n}\nfunction resizeElement(target, handler) {\n    if (!observer)\n        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}\n\nexport { resizeElement };\n","const 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)\n        createWindowResizeHandler();\n    return () => {\n        windowCallbacks.delete(callback);\n        if (!windowCallbacks.size && windowResizeHandler) {\n            windowResizeHandler = undefined;\n        }\n    };\n}\n\nexport { resizeWindow };\n","import { resizeElement } from './handle-element.es.js';\nimport { resizeWindow } from './handle-window.es.js';\n\nfunction resize(a, b) {\n    return typeof a === \"function\" ? resizeWindow(a) : resizeElement(a, b);\n}\n\nexport { resize };\n","import { progress, velocityPerSecond } from '@motionone/utils';\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 { length, position } = 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 =\n        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}\n\nexport { createScrollInfo, updateScrollInfo };\n","const ScrollOffset = {\n    Enter: [\n        [0, 1],\n        [1, 1],\n    ],\n    Exit: [\n        [0, 0],\n        [1, 0],\n    ],\n    Any: [\n        [1, 0],\n        [0, 1],\n    ],\n    All: [\n        [0, 0],\n        [1, 1],\n    ],\n};\n\nexport { ScrollOffset };\n","import { isString, isNumber } from '@motionone/utils';\n\nconst namedEdges = {\n    start: 0,\n    center: 0.5,\n    end: 1,\n};\nfunction resolveEdge(edge, length, inset = 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 (isString(edge)) {\n        const asNumber = parseFloat(edge);\n        if (edge.endsWith(\"px\")) {\n            delta = asNumber;\n        }\n        else if (edge.endsWith(\"%\")) {\n            edge = asNumber / 100;\n        }\n        else if (edge.endsWith(\"vw\")) {\n            delta = (asNumber / 100) * document.documentElement.clientWidth;\n        }\n        else if (edge.endsWith(\"vh\")) {\n            delta = (asNumber / 100) * document.documentElement.clientHeight;\n        }\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 (isNumber(edge)) {\n        delta = length * edge;\n    }\n    return inset + delta;\n}\n\nexport { namedEdges, resolveEdge };\n","import { isNumber, isString } from '@motionone/utils';\nimport { resolveEdge, namedEdges } from './edge.es.js';\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 (isNumber(offset)) {\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    }\n    else if (isString(offset)) {\n        offset = offset.trim();\n        if (offset.includes(\" \")) {\n            offsetDefinition = offset.split(\" \");\n        }\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}\n\nexport { resolveOffset };\n","import { interpolate, defaultOffset } from '@motionone/utils';\nimport { calcInset } from './inset.es.js';\nimport { ScrollOffset } from './presets.es.js';\nimport { resolveOffset } from './offset.es.js';\n\nconst point = { x: 0, y: 0 };\nfunction resolveOffsets(container, info, options) {\n    let { offset: offsetDefinition = ScrollOffset.All } = options;\n    const { target = container, axis = \"y\" } = 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, height: container.scrollHeight }\n        : { width: target.clientWidth, height: target.clientHeight };\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(defaultOffset(numOffsets), info[axis].offset);\n        info[axis].interpolatorOffsets = [...info[axis].offset];\n    }\n    info[axis].progress = info[axis].interpolate(info[axis].current);\n}\n\nexport { resolveOffsets };\n","function calcInset(element, container) {\n    let inset = { x: 0, y: 0 };\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        }\n        else if (current instanceof SVGGraphicsElement && \"getBBox\" in current) {\n            const { top, left } = current.getBBox();\n            inset.x += left;\n            inset.y += top;\n            /**\n             * Assign the next parent element as the <svg /> tag.\n             */\n            while (current && current.tagName !== \"svg\") {\n                current = current.parentNode;\n            }\n        }\n    }\n    return inset;\n}\n\nexport { calcInset };\n","import { noopReturn } from '@motionone/utils';\nimport { updateScrollInfo } from './info.es.js';\nimport { resolveOffsets } from './offsets/index.es.js';\n\nfunction measure(container, target = container, info) {\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 =\n        target === container ? target.scrollWidth : target.clientWidth;\n    info.y.targetLength =\n        target === container ? target.scrollHeight : target.clientHeight;\n    info.x.containerLength = container.clientWidth;\n    info.y.containerLength = container.clientHeight;\n}\nfunction createOnScrollHandler(element, onScroll, info, options = {}) {\n    const axis = options.axis || \"y\";\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: typeof onScroll === \"function\"\n            ? () => onScroll(info)\n            : scrubAnimation(onScroll, info[axis]),\n    };\n}\nfunction scrubAnimation(controls, axisInfo) {\n    controls.pause();\n    controls.forEachNative((animation, { easing }) => {\n        var _a, _b;\n        if (animation.updateDuration) {\n            if (!easing)\n                animation.easing = noopReturn;\n            animation.updateDuration(1);\n        }\n        else {\n            const timingOptions = { duration: 1000 };\n            if (!easing)\n                timingOptions.easing = \"linear\";\n            (_b = (_a = animation.effect) === null || _a === void 0 ? void 0 : _a.updateTiming) === null || _b === void 0 ? void 0 : _b.call(_a, timingOptions);\n        }\n    });\n    return () => {\n        controls.currentTime = axisInfo.progress;\n    };\n}\n\nexport { createOnScrollHandler };\n","import { __rest } from 'tslib';\nimport { resize } from '../resize/index.es.js';\nimport { createScrollInfo } from './info.es.js';\nimport { createOnScrollHandler } from './on-scroll-handler.es.js';\n\nconst scrollListeners = new WeakMap();\nconst resizeListeners = new WeakMap();\nconst onScrollHandlers = new WeakMap();\nconst getEventTarget = (element) => element === document.documentElement ? window : element;\nfunction scroll(onScroll, _a = {}) {\n    var { container = document.documentElement } = _a, options = __rest(_a, [\"container\"]);\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 listener = () => {\n            const time = performance.now();\n            for (const handler of containerHandlers)\n                handler.measure();\n            for (const handler of containerHandlers)\n                handler.update(time);\n            for (const handler of containerHandlers)\n                handler.notify();\n        };\n        scrollListeners.set(container, listener);\n        const target = getEventTarget(container);\n        window.addEventListener(\"resize\", listener, { passive: true });\n        if (container !== document.documentElement) {\n            resizeListeners.set(container, resize(container, listener));\n        }\n        target.addEventListener(\"scroll\", listener, { passive: true });\n    }\n    const listener = scrollListeners.get(container);\n    const onLoadProcesss = requestAnimationFrame(listener);\n    return () => {\n        var _a;\n        if (typeof onScroll !== \"function\")\n            onScroll.stop();\n        cancelAnimationFrame(onLoadProcesss);\n        /**\n         * Check if we even have any handlers for this container.\n         */\n        const containerHandlers = onScrollHandlers.get(container);\n        if (!containerHandlers)\n            return;\n        containerHandlers.delete(containerHandler);\n        if (containerHandlers.size)\n            return;\n        /**\n         * If no more handlers, remove the scroll listener too.\n         */\n        const listener = scrollListeners.get(container);\n        scrollListeners.delete(container);\n        if (listener) {\n            getEventTarget(container).removeEventListener(\"scroll\", listener);\n            (_a = resizeListeners.get(container)) === null || _a === void 0 ? void 0 : _a();\n            window.removeEventListener(\"resize\", listener);\n        }\n    };\n}\n\nexport { scroll };\n","import { isVariant } from './is-variant.es.js';\n\nfunction resolveVariant(definition, variants) {\n    if (isVariant(definition)) {\n        return definition;\n    }\n    else if (definition && variants) {\n        return variants[definition];\n    }\n}\n\nexport { resolveVariant };\n","function isVariant(definition) {\n    return typeof definition === \"object\";\n}\n\nexport { isVariant };\n","import { addUniqueItem, removeItem } from '@motionone/utils';\n\nlet scheduled = undefined;\nfunction processScheduledAnimations() {\n    if (!scheduled)\n        return;\n    const generators = scheduled.sort(compareByDepth).map(fireAnimateUpdates);\n    generators.forEach(fireNext);\n    generators.forEach(fireNext);\n    scheduled = undefined;\n}\nfunction scheduleAnimation(state) {\n    if (!scheduled) {\n        scheduled = [state];\n        requestAnimationFrame(processScheduledAnimations);\n    }\n    else {\n        addUniqueItem(scheduled, state);\n    }\n}\nfunction unscheduleAnimation(state) {\n    scheduled && removeItem(scheduled, state);\n}\nconst compareByDepth = (a, b) => a.getDepth() - b.getDepth();\nconst fireAnimateUpdates = (state) => state.animateUpdates();\nconst fireNext = (iterator) => iterator.next();\n\nexport { scheduleAnimation, unscheduleAnimation };\n","const motionEvent = (name, target) => new CustomEvent(name, { detail: { target } });\nfunction dispatchPointerEvent(element, name, event) {\n    element.dispatchEvent(new CustomEvent(name, { detail: { originalEvent: event } }));\n}\nfunction dispatchViewEvent(element, name, entry) {\n    element.dispatchEvent(new CustomEvent(name, { detail: { originalEntry: entry } }));\n}\n\nexport { dispatchPointerEvent, dispatchViewEvent, motionEvent };\n","import { __rest } from 'tslib';\nimport { dispatchViewEvent } from '../utils/events.es.js';\nimport { inView as inView$1 } from '../../gestures/in-view.es.js';\n\nconst inView = {\n    isActive: (options) => Boolean(options.inView),\n    subscribe: (element, { enable, disable }, { inViewOptions = {} }) => {\n        const { once } = inViewOptions, viewOptions = __rest(inViewOptions, [\"once\"]);\n        return inView$1(element, (enterEntry) => {\n            enable();\n            dispatchViewEvent(element, \"viewenter\", enterEntry);\n            if (!once) {\n                return (leaveEntry) => {\n                    disable();\n                    dispatchViewEvent(element, \"viewleave\", leaveEntry);\n                };\n            }\n        }, viewOptions);\n    },\n};\n\nexport { inView };\n","import { dispatchPointerEvent } from '../utils/events.es.js';\n\nconst mouseEvent = (element, name, action) => (event) => {\n    if (event.pointerType && event.pointerType !== \"mouse\")\n        return;\n    action();\n    dispatchPointerEvent(element, name, event);\n};\nconst hover = {\n    isActive: (options) => Boolean(options.hover),\n    subscribe: (element, { enable, disable }) => {\n        const onEnter = mouseEvent(element, \"hoverstart\", enable);\n        const onLeave = mouseEvent(element, \"hoverend\", disable);\n        element.addEventListener(\"pointerenter\", onEnter);\n        element.addEventListener(\"pointerleave\", onLeave);\n        return () => {\n            element.removeEventListener(\"pointerenter\", onEnter);\n            element.removeEventListener(\"pointerleave\", onLeave);\n        };\n    },\n};\n\nexport { hover };\n","import { __rest } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { noop } from '@motionone/utils';\nimport { animateStyle } from '../animate/animate-style.es.js';\nimport { style } from '../animate/style.es.js';\nimport { getOptions } from '../animate/utils/options.es.js';\nimport { hasChanged } from './utils/has-changed.es.js';\nimport { resolveVariant } from './utils/resolve-variant.es.js';\nimport { scheduleAnimation, unscheduleAnimation } from './utils/schedule.es.js';\nimport { inView } from './gestures/in-view.es.js';\nimport { hover } from './gestures/hover.es.js';\nimport { press } from './gestures/press.es.js';\nimport { motionEvent } from './utils/events.es.js';\n\nconst gestures = { inView, hover, press };\n/**\n * A list of state types, in priority order. If a value is defined in\n * a righter-most type, it will override any definition in a lefter-most.\n */\nconst stateTypes = [\"initial\", \"animate\", ...Object.keys(gestures), \"exit\"];\n/**\n * A global store of all generated motion states. This can be used to lookup\n * a motion state for a given Element.\n */\nconst mountedStates = new WeakMap();\nfunction createMotionState(options = {}, parent) {\n    /**\n     * The element represented by the motion state. This is an empty reference\n     * when we create the state to support SSR and allow for later mounting\n     * in view libraries.\n     *\n     * @ts-ignore\n     */\n    let element;\n    /**\n     * Calculate a depth that we can use to order motion states by tree depth.\n     */\n    let depth = parent ? parent.getDepth() + 1 : 0;\n    /**\n     * Track which states are currently active.\n     */\n    const activeStates = { initial: true, animate: true };\n    /**\n     * A map of functions that, when called, will remove event listeners for\n     * a given gesture.\n     */\n    const gestureSubscriptions = {};\n    /**\n     * Initialise a context to share through motion states. This\n     * will be populated by variant names (if any).\n     */\n    const context = {};\n    for (const name of stateTypes) {\n        context[name] =\n            typeof options[name] === \"string\"\n                ? options[name]\n                : parent === null || parent === void 0 ? void 0 : parent.getContext()[name];\n    }\n    /**\n     * If initial is set to false we use the animate prop as the initial\n     * animation state.\n     */\n    const initialVariantSource = options.initial === false ? \"animate\" : \"initial\";\n    /**\n     * Destructure an initial target out from the resolved initial variant.\n     */\n    let _a = resolveVariant(options[initialVariantSource] || context[initialVariantSource], options.variants) || {}, target = __rest(_a, [\"transition\"]);\n    /**\n     * The base target is a cached map of values that we'll use to animate\n     * back to if a value is removed from all active state types. This\n     * is usually the initial value as read from the DOM, for instance if\n     * it hasn't been defined in initial.\n     */\n    const baseTarget = Object.assign({}, target);\n    /**\n     * A generator that will be processed by the global animation scheduler.\n     * This yeilds when it switches from reading the DOM to writing to it\n     * to prevent layout thrashing.\n     */\n    function* animateUpdates() {\n        var _a, _b;\n        const prevTarget = target;\n        target = {};\n        const animationOptions = {};\n        for (const name of stateTypes) {\n            if (!activeStates[name])\n                continue;\n            const variant = resolveVariant(options[name]);\n            if (!variant)\n                continue;\n            for (const key in variant) {\n                if (key === \"transition\")\n                    continue;\n                target[key] = variant[key];\n                animationOptions[key] = getOptions((_b = (_a = variant.transition) !== null && _a !== void 0 ? _a : options.transition) !== null && _b !== void 0 ? _b : {}, key);\n            }\n        }\n        const allTargetKeys = new Set([\n            ...Object.keys(target),\n            ...Object.keys(prevTarget),\n        ]);\n        const animationFactories = [];\n        allTargetKeys.forEach((key) => {\n            var _a;\n            if (target[key] === undefined) {\n                target[key] = baseTarget[key];\n            }\n            if (hasChanged(prevTarget[key], target[key])) {\n                (_a = baseTarget[key]) !== null && _a !== void 0 ? _a : (baseTarget[key] = style.get(element, key));\n                animationFactories.push(animateStyle(element, key, target[key], animationOptions[key]));\n            }\n        });\n        // Wait for all animation states to read from the DOM\n        yield;\n        const animations = animationFactories\n            .map((factory) => factory())\n            .filter(Boolean);\n        if (!animations.length)\n            return;\n        const animationTarget = target;\n        element.dispatchEvent(motionEvent(\"motionstart\", animationTarget));\n        Promise.all(animations.map((animation) => animation.finished))\n            .then(() => {\n            element.dispatchEvent(motionEvent(\"motioncomplete\", animationTarget));\n        })\n            .catch(noop);\n    }\n    const setGesture = (name, isActive) => () => {\n        activeStates[name] = isActive;\n        scheduleAnimation(state);\n    };\n    const updateGestureSubscriptions = () => {\n        for (const name in gestures) {\n            const isGestureActive = gestures[name].isActive(options);\n            const remove = gestureSubscriptions[name];\n            if (isGestureActive && !remove) {\n                gestureSubscriptions[name] = gestures[name].subscribe(element, {\n                    enable: setGesture(name, true),\n                    disable: setGesture(name, false),\n                }, options);\n            }\n            else if (!isGestureActive && remove) {\n                remove();\n                delete gestureSubscriptions[name];\n            }\n        }\n    };\n    const state = {\n        update: (newOptions) => {\n            if (!element)\n                return;\n            options = newOptions;\n            updateGestureSubscriptions();\n            scheduleAnimation(state);\n        },\n        setActive: (name, isActive) => {\n            if (!element)\n                return;\n            activeStates[name] = isActive;\n            scheduleAnimation(state);\n        },\n        animateUpdates,\n        getDepth: () => depth,\n        getTarget: () => target,\n        getOptions: () => options,\n        getContext: () => context,\n        mount: (newElement) => {\n            invariant(Boolean(newElement), \"Animation state must be mounted with valid Element\");\n            element = newElement;\n            mountedStates.set(element, state);\n            updateGestureSubscriptions();\n            return () => {\n                mountedStates.delete(element);\n                unscheduleAnimation(state);\n                for (const key in gestureSubscriptions) {\n                    gestureSubscriptions[key]();\n                }\n            };\n        },\n        isMounted: () => Boolean(element),\n    };\n    return state;\n}\n\nexport { createMotionState, mountedStates };\n","import { dispatchPointerEvent } from '../utils/events.es.js';\n\nconst press = {\n    isActive: (options) => Boolean(options.press),\n    subscribe: (element, { enable, disable }) => {\n        const onPointerUp = (event) => {\n            disable();\n            dispatchPointerEvent(element, \"pressend\", event);\n            window.removeEventListener(\"pointerup\", onPointerUp);\n        };\n        const onPointerDown = (event) => {\n            enable();\n            dispatchPointerEvent(element, \"pressstart\", event);\n            window.addEventListener(\"pointerup\", onPointerUp);\n        };\n        element.addEventListener(\"pointerdown\", onPointerDown);\n        return () => {\n            element.removeEventListener(\"pointerdown\", onPointerDown);\n            window.removeEventListener(\"pointerup\", onPointerUp);\n        };\n    },\n};\n\nexport { press };\n","function hasChanged(a, b) {\n    if (typeof a !== typeof b)\n        return true;\n    if (Array.isArray(a) && Array.isArray(b))\n        return !shallowCompare(a, b);\n    return a !== b;\n}\nfunction shallowCompare(next, prev) {\n    const prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (let i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { hasChanged, shallowCompare };\n","import { isNumber } from '@motionone/utils';\nimport { isTransform, transformAlias, asTransformCssVar, transformDefinitions, buildTransformTemplate } from './transforms.es.js';\n\nfunction createStyles(keyframes) {\n    const initialKeyframes = {};\n    const transformKeys = [];\n    for (let key in keyframes) {\n        const value = keyframes[key];\n        if (isTransform(key)) {\n            if (transformAlias[key])\n                key = transformAlias[key];\n            transformKeys.push(key);\n            key = asTransformCssVar(key);\n        }\n        let initialKeyframe = Array.isArray(value) ? value[0] : value;\n        /**\n         * If this is a number and we have a default value type, convert the number\n         * to this type.\n         */\n        const definition = transformDefinitions.get(key);\n        if (definition) {\n            initialKeyframe = isNumber(value)\n                ? definition.toDefaultUnit(value)\n                : value;\n        }\n        initialKeyframes[key] = initialKeyframe;\n    }\n    if (transformKeys.length) {\n        initialKeyframes.transform = buildTransformTemplate(transformKeys);\n    }\n    return initialKeyframes;\n}\n\nexport { createStyles };\n","import { createStyles } from './style-object.es.js';\n\nconst camelLetterToPipeLetter = (letter) => `-${letter.toLowerCase()}`;\nconst camelToPipeCase = (str) => str.replace(/[A-Z]/g, camelLetterToPipeLetter);\nfunction createStyleString(target = {}) {\n    const styles = createStyles(target);\n    let style = \"\";\n    for (const key in styles) {\n        style += key.startsWith(\"--\") ? key : camelToPipeCase(key);\n        style += `: ${styles[key]}; `;\n    }\n    return style;\n}\n\nexport { createStyleString };\n","function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\n// Older browsers don't support event options, feature detect it.\n\n// Adopted and modified solution from Bohdan Didukh (2017)\n// https://stackoverflow.com/questions/41594997/ios-10-safari-prevent-scrolling-behind-a-fixed-overlay-and-maintain-scroll-posi\n\nvar hasPassiveEvents = false;\nif (typeof window !== 'undefined') {\n  var passiveTestOptions = {\n    get passive() {\n      hasPassiveEvents = true;\n      return undefined;\n    }\n  };\n  window.addEventListener('testPassive', null, passiveTestOptions);\n  window.removeEventListener('testPassive', null, passiveTestOptions);\n}\n\nvar isIosDevice = typeof window !== 'undefined' && window.navigator && window.navigator.platform && (/iP(ad|hone|od)/.test(window.navigator.platform) || window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1);\n\n\nvar locks = [];\nvar documentListenerAdded = false;\nvar initialClientY = -1;\nvar previousBodyOverflowSetting = void 0;\nvar previousBodyPaddingRight = void 0;\n\n// returns true if `el` should be allowed to receive touchmove events.\nvar allowTouchMove = function allowTouchMove(el) {\n  return locks.some(function (lock) {\n    if (lock.options.allowTouchMove && lock.options.allowTouchMove(el)) {\n      return true;\n    }\n\n    return false;\n  });\n};\n\nvar preventDefault = function preventDefault(rawEvent) {\n  var e = rawEvent || window.event;\n\n  // For the case whereby consumers adds a touchmove event listener to document.\n  // Recall that we do document.addEventListener('touchmove', preventDefault, { passive: false })\n  // in disableBodyScroll - so if we provide this opportunity to allowTouchMove, then\n  // the touchmove event on document will break.\n  if (allowTouchMove(e.target)) {\n    return true;\n  }\n\n  // Do not prevent if the event has more than one touch (usually meaning this is a multi touch gesture like pinch to zoom).\n  if (e.touches.length > 1) return true;\n\n  if (e.preventDefault) e.preventDefault();\n\n  return false;\n};\n\nvar setOverflowHidden = function setOverflowHidden(options) {\n  // If previousBodyPaddingRight is already set, don't set it again.\n  if (previousBodyPaddingRight === undefined) {\n    var _reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;\n    var scrollBarGap = window.innerWidth - document.documentElement.clientWidth;\n\n    if (_reserveScrollBarGap && scrollBarGap > 0) {\n      previousBodyPaddingRight = document.body.style.paddingRight;\n      document.body.style.paddingRight = scrollBarGap + 'px';\n    }\n  }\n\n  // If previousBodyOverflowSetting is already set, don't set it again.\n  if (previousBodyOverflowSetting === undefined) {\n    previousBodyOverflowSetting = document.body.style.overflow;\n    document.body.style.overflow = 'hidden';\n  }\n};\n\nvar restoreOverflowSetting = function restoreOverflowSetting() {\n  if (previousBodyPaddingRight !== undefined) {\n    document.body.style.paddingRight = previousBodyPaddingRight;\n\n    // Restore previousBodyPaddingRight to undefined so setOverflowHidden knows it\n    // can be set again.\n    previousBodyPaddingRight = undefined;\n  }\n\n  if (previousBodyOverflowSetting !== undefined) {\n    document.body.style.overflow = previousBodyOverflowSetting;\n\n    // Restore previousBodyOverflowSetting to undefined\n    // so setOverflowHidden knows it can be set again.\n    previousBodyOverflowSetting = undefined;\n  }\n};\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions\nvar isTargetElementTotallyScrolled = function isTargetElementTotallyScrolled(targetElement) {\n  return targetElement ? targetElement.scrollHeight - targetElement.scrollTop <= targetElement.clientHeight : false;\n};\n\nvar handleScroll = function handleScroll(event, targetElement) {\n  var clientY = event.targetTouches[0].clientY - initialClientY;\n\n  if (allowTouchMove(event.target)) {\n    return false;\n  }\n\n  if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {\n    // element is at the top of its scroll.\n    return preventDefault(event);\n  }\n\n  if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) {\n    // element is at the bottom of its scroll.\n    return preventDefault(event);\n  }\n\n  event.stopPropagation();\n  return true;\n};\n\nexport var disableBodyScroll = function disableBodyScroll(targetElement, options) {\n  // targetElement must be provided\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.');\n    return;\n  }\n\n  // disableBodyScroll must not have been called on this targetElement before\n  if (locks.some(function (lock) {\n    return lock.targetElement === targetElement;\n  })) {\n    return;\n  }\n\n  var lock = {\n    targetElement: targetElement,\n    options: options || {}\n  };\n\n  locks = [].concat(_toConsumableArray(locks), [lock]);\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        initialClientY = event.targetTouches[0].clientY;\n      }\n    };\n    targetElement.ontouchmove = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        handleScroll(event, targetElement);\n      }\n    };\n\n    if (!documentListenerAdded) {\n      document.addEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = true;\n    }\n  } else {\n    setOverflowHidden(options);\n  }\n};\n\nexport var clearAllBodyScrollLocks = function clearAllBodyScrollLocks() {\n  if (isIosDevice) {\n    // Clear all locks ontouchstart/ontouchmove handlers, and the references.\n    locks.forEach(function (lock) {\n      lock.targetElement.ontouchstart = null;\n      lock.targetElement.ontouchmove = null;\n    });\n\n    if (documentListenerAdded) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n\n    // Reset initial clientY.\n    initialClientY = -1;\n  } else {\n    restoreOverflowSetting();\n  }\n\n  locks = [];\n};\n\nexport var enableBodyScroll = function enableBodyScroll(targetElement) {\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.');\n    return;\n  }\n\n  locks = locks.filter(function (lock) {\n    return lock.targetElement !== targetElement;\n  });\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = null;\n    targetElement.ontouchmove = null;\n\n    if (documentListenerAdded && locks.length === 0) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n  } else if (!locks.length) {\n    restoreOverflowSetting();\n  }\n};\n\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nvar React = require('react');\nvar heyListen = require('hey-listen');\nvar styleValueTypes = require('style-value-types');\nvar popmotion = require('popmotion');\nvar sync = require('framesync');\nvar dom = require('@motionone/dom');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nfunction _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n        Object.keys(e).forEach(function (k) {\n            if (k !== 'default') {\n                var d = Object.getOwnPropertyDescriptor(e, k);\n                Object.defineProperty(n, k, d.get ? d : {\n                    enumerable: true,\n                    get: function () { return e[k]; }\n                });\n            }\n        });\n    }\n    n[\"default\"] = e;\n    return Object.freeze(n);\n}\n\nvar React__namespace = /*#__PURE__*/_interopNamespace(React);\nvar React__default = /*#__PURE__*/_interopDefaultLegacy(React);\nvar sync__default = /*#__PURE__*/_interopDefaultLegacy(sync);\n\n/**\n * Browser-safe usage of process\n */\nvar defaultEnvironment = \"production\";\nvar env = typeof process === \"undefined\" || process.env === undefined\n    ? defaultEnvironment\n    : process.env.NODE_ENV || defaultEnvironment;\n\nvar createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\nvar LazyContext = React.createContext({ strict: false });\n\nvar featureNames = Object.keys(featureDefinitions);\nvar numFeatures = featureNames.length;\n/**\n * Load features via renderless components based on the provided MotionProps.\n */\nfunction useFeatures(props, visualElement, preloadedFeatures) {\n    var features = [];\n    var lazyContext = React.useContext(LazyContext);\n    if (!visualElement)\n        return null;\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 (env !== \"production\" && preloadedFeatures && lazyContext.strict) {\n        heyListen.invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n    }\n    for (var i = 0; i < numFeatures; i++) {\n        var name_1 = featureNames[i];\n        var _a = featureDefinitions[name_1], isEnabled = _a.isEnabled, Component = _a.Component;\n        /**\n         * It might be possible in the future to use this moment to\n         * dynamically request functionality. In initial tests this\n         * was producing a lot of duplication amongst bundles.\n         */\n        if (isEnabled(props) && Component) {\n            features.push(React__namespace.createElement(Component, tslib.__assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\n/**\n * @public\n */\nvar MotionConfigContext = React.createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nvar MotionContext = React.createContext({});\nfunction useVisualElementContext() {\n    return React.useContext(MotionContext).visualElement;\n}\n\n/**\n * @public\n */\nvar PresenceContext = React.createContext(null);\n\nvar isBrowser = typeof document !== \"undefined\";\n\nvar useIsomorphicLayoutEffect = isBrowser ? React.useLayoutEffect : React.useEffect;\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = { current: null };\nvar hasDetected = false;\nfunction initPrefersReducedMotion() {\n    hasDetected = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return (prefersReducedMotion.current = motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n/**\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\n *\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\n *\n * It will actively respond to changes and re-render your components with the latest setting.\n *\n * ```jsx\n * export function Sidebar({ isOpen }) {\n *   const shouldReduceMotion = useReducedMotion()\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\n *\n *   return (\n *     <motion.div animate={{\n *       opacity: isOpen ? 1 : 0,\n *       x: isOpen ? 0 : closedX\n *     }} />\n *   )\n * }\n * ```\n *\n * @return boolean\n *\n * @public\n */\nfunction useReducedMotion() {\n    /**\n     * Lazy initialisation of prefersReducedMotion\n     */\n    !hasDetected && initPrefersReducedMotion();\n    var _a = tslib.__read(React.useState(prefersReducedMotion.current), 1), shouldReduceMotion = _a[0];\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\nfunction useReducedMotionConfig() {\n    var reducedMotionPreference = useReducedMotion();\n    var reducedMotion = React.useContext(MotionConfigContext).reducedMotion;\n    if (reducedMotion === \"never\") {\n        return false;\n    }\n    else if (reducedMotion === \"always\") {\n        return true;\n    }\n    else {\n        return reducedMotionPreference;\n    }\n}\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var lazyContext = React.useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = React.useContext(PresenceContext);\n    var shouldReduceMotion = useReducedMotionConfig();\n    var visualElementRef = React.useRef(undefined);\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    if (!createVisualElement)\n        createVisualElement = lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState: visualState,\n            parent: parent,\n            props: props,\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n            shouldReduceMotion: shouldReduceMotion,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n    });\n    React.useEffect(function () {\n        var _a;\n        (_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\nfunction isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return React.useCallback(function (instance) {\n        var _a;\n        instance && ((_a = visualState.mount) === null || _a === void 0 ? void 0 : _a.call(visualState, instance));\n        if (visualElement) {\n            instance\n                ? visualElement.mount(instance)\n                : visualElement.unmount();\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\n/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (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$1(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? 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 = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[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 !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity$1(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nfunction getCurrentTreeVariants(props, context) {\n    if (checkIfControllingVariants(props)) {\n        var initial = props.initial, animate = props.animate;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nfunction useCreateMotionContext(props) {\n    var _a = getCurrentTreeVariants(props, React.useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return React.useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = React.useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\n/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nvar id$1 = 1;\nfunction useProjectionId() {\n    return useConstant(function () {\n        if (globalProjectionState.hasEverUpdated) {\n            return id$1++;\n        }\n    });\n}\n\nvar LayoutGroupContext = React.createContext({});\n\n/**\n * Internal, exported only for usage in Framer\n */\nvar SwitchLayoutGroupContext = React.createContext({});\n\nfunction useProjection(projectionId, _a, visualElement, ProjectionNodeConstructor) {\n    var _b;\n    var layoutId = _a.layoutId, layout = _a.layout, drag = _a.drag, dragConstraints = _a.dragConstraints, layoutScroll = _a.layoutScroll;\n    var initialPromotionConfig = React.useContext(SwitchLayoutGroupContext);\n    if (!ProjectionNodeConstructor ||\n        !visualElement ||\n        (visualElement === null || visualElement === void 0 ? void 0 : visualElement.projection)) {\n        return;\n    }\n    visualElement.projection = new ProjectionNodeConstructor(projectionId, visualElement.getLatestValues(), (_b = visualElement.parent) === null || _b === void 0 ? void 0 : _b.projection);\n    visualElement.projection.setOptions({\n        layoutId: layoutId,\n        layout: layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement: visualElement,\n        scheduleRender: function () { return visualElement.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: initialPromotionConfig,\n        layoutScroll: layoutScroll,\n    });\n}\n\nvar VisualElementHandler = /** @class */ (function (_super) {\n    tslib.__extends(VisualElementHandler, _super);\n    function VisualElementHandler() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Update visual element props as soon as we know this update is going to be commited.\n     */\n    VisualElementHandler.prototype.getSnapshotBeforeUpdate = function () {\n        this.updateProps();\n        return null;\n    };\n    VisualElementHandler.prototype.componentDidUpdate = function () { };\n    VisualElementHandler.prototype.updateProps = function () {\n        var _a = this.props, visualElement = _a.visualElement, props = _a.props;\n        if (visualElement)\n            visualElement.setProps(props);\n    };\n    VisualElementHandler.prototype.render = function () {\n        return this.props.children;\n    };\n    return VisualElementHandler;\n}(React__default[\"default\"].Component));\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, projectionNodeConstructor = _a.projectionNodeConstructor, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        var layoutId = useLayoutId(props);\n        props = tslib.__assign(tslib.__assign({}, props), { layoutId: layoutId });\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var config = React.useContext(MotionConfigContext);\n        var features = null;\n        var context = useCreateMotionContext(props);\n        /**\n         * Create a unique projection ID for this component. If a new component is added\n         * during a layout animation we'll use this to query the DOM and hydrate its ref early, allowing\n         * us to measure it as soon as any layout effect flushes pending layout animations.\n         *\n         * Performance note: It'd be better not to have to search the DOM for these elements.\n         * For newly-entering components it could be enough to only correct treeScale, in which\n         * case we could mount in a scale-correction mode. This wouldn't be enough for\n         * shared element transitions however. Perhaps for those we could revert to a root node\n         * that gets forceRendered and layout animations are triggered on its layout effect.\n         */\n        var projectionId = config.isStatic ? undefined : useProjectionId();\n        /**\n         *\n         */\n        var visualState = useVisualState(props, config.isStatic);\n        if (!config.isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, tslib.__assign(tslib.__assign({}, config), props), createVisualElement);\n            useProjection(projectionId, props, context.visualElement, projectionNodeConstructor ||\n                featureDefinitions.projectionNodeConstructor);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React__namespace.createElement(VisualElementHandler, { visualElement: context.visualElement, props: tslib.__assign(tslib.__assign({}, config), props) },\n            features,\n            React__namespace.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, projectionId, useMotionRef(visualState, context.visualElement, externalRef), visualState, config.isStatic, context.visualElement))));\n    }\n    return React.forwardRef(MotionComponent);\n}\nfunction useLayoutId(_a) {\n    var _b;\n    var layoutId = _a.layoutId;\n    var layoutGroupId = (_b = React.useContext(LayoutGroupContext)) === null || _b === void 0 ? void 0 : _b.id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\n\n/**\n * Convert any React component into a `motion` component. The provided component\n * **must** use `React.forwardRef` to the underlying DOM component you want to animate.\n *\n * ```jsx\n * const Component = React.forwardRef((props, ref) => {\n *   return <div ref={ref} />\n * })\n *\n * const MotionComponent = motion(Component)\n * ```\n *\n * @public\n */\nfunction createMotionProxy(createConfig) {\n    function custom(Component, customMotionComponentConfig) {\n        if (customMotionComponentConfig === void 0) { customMotionComponentConfig = {}; }\n        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    var componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: function (_target, key) {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\n/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nvar scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\n/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nvar isMotionValue = function (value) {\n    return Boolean(value !== null && typeof value === \"object\" && value.getVelocity);\n};\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\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(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\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    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\n/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable$1(key) {\n    return key.startsWith(\"--\");\n}\n\n/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nvar int = tslib.__assign(tslib.__assign({}, styleValueTypes.number), { transform: Math.round });\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: styleValueTypes.px,\n    borderTopWidth: styleValueTypes.px,\n    borderRightWidth: styleValueTypes.px,\n    borderBottomWidth: styleValueTypes.px,\n    borderLeftWidth: styleValueTypes.px,\n    borderRadius: styleValueTypes.px,\n    radius: styleValueTypes.px,\n    borderTopLeftRadius: styleValueTypes.px,\n    borderTopRightRadius: styleValueTypes.px,\n    borderBottomRightRadius: styleValueTypes.px,\n    borderBottomLeftRadius: styleValueTypes.px,\n    // Positioning props\n    width: styleValueTypes.px,\n    maxWidth: styleValueTypes.px,\n    height: styleValueTypes.px,\n    maxHeight: styleValueTypes.px,\n    size: styleValueTypes.px,\n    top: styleValueTypes.px,\n    right: styleValueTypes.px,\n    bottom: styleValueTypes.px,\n    left: styleValueTypes.px,\n    // Spacing props\n    padding: styleValueTypes.px,\n    paddingTop: styleValueTypes.px,\n    paddingRight: styleValueTypes.px,\n    paddingBottom: styleValueTypes.px,\n    paddingLeft: styleValueTypes.px,\n    margin: styleValueTypes.px,\n    marginTop: styleValueTypes.px,\n    marginRight: styleValueTypes.px,\n    marginBottom: styleValueTypes.px,\n    marginLeft: styleValueTypes.px,\n    // Transform props\n    rotate: styleValueTypes.degrees,\n    rotateX: styleValueTypes.degrees,\n    rotateY: styleValueTypes.degrees,\n    rotateZ: styleValueTypes.degrees,\n    scale: styleValueTypes.scale,\n    scaleX: styleValueTypes.scale,\n    scaleY: styleValueTypes.scale,\n    scaleZ: styleValueTypes.scale,\n    skew: styleValueTypes.degrees,\n    skewX: styleValueTypes.degrees,\n    skewY: styleValueTypes.degrees,\n    distance: styleValueTypes.px,\n    translateX: styleValueTypes.px,\n    translateY: styleValueTypes.px,\n    translateZ: styleValueTypes.px,\n    x: styleValueTypes.px,\n    y: styleValueTypes.px,\n    z: styleValueTypes.px,\n    perspective: styleValueTypes.px,\n    transformPerspective: styleValueTypes.px,\n    opacity: styleValueTypes.alpha,\n    originX: styleValueTypes.progressPercentage,\n    originY: styleValueTypes.progressPercentage,\n    originZ: styleValueTypes.px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: styleValueTypes.alpha,\n    strokeOpacity: styleValueTypes.alpha,\n    numOctaves: int,\n};\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var 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 (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable$1(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nvar createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (var key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues(_a, visualState, isStatic) {\n    var transformTemplate = _a.transformTemplate;\n    return React.useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return tslib.__assign(tslib.__assign({}, vars), style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    var styleProp = props.style || {};\n    var style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));\n    if (props.transformValues) {\n        style = props.transformValues(style);\n    }\n    return style;\n}\nfunction useHTMLProps(props, visualState, isStatic) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    var htmlProps = {};\n    var style = useStyle(props, visualState, isStatic);\n    if (Boolean(props.drag) && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\".concat(props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\n/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"layoutDependency\",\n    \"onLayoutAnimationStart\",\n    \"onLayoutAnimationComplete\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"dragSnapToOrigin\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n    \"whileInView\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"viewport\",\n    \"layoutScroll\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = function (key) {\n        return key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n    };\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    var filteredProps = {};\n    for (var key in props) {\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nfunction calcOrigin$1(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : styleValueTypes.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    var pxOriginX = calcOrigin$1(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin$1(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar 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, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = 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    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = styleValueTypes.px.transform(-offset);\n    // Build the dash array\n    var pathLength = styleValueTypes.px.transform(length);\n    var pathSpacing = styleValueTypes.px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = tslib.__rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\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)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nvar createSvgRenderState = function () { return (tslib.__assign(tslib.__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = React.useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return tslib.__assign(tslib.__assign({}, state.attrs), { style: tslib.__assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = tslib.__assign(tslib.__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, projectionId, ref, _a, isStatic) {\n        var latestValues = _a.latestValues;\n        var useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        var visualProps = useVisualProps(props, latestValues, isStatic);\n        var filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        var elementProps = tslib.__assign(tslib.__assign(tslib.__assign({}, filteredProps), visualProps), { ref: ref });\n        if (projectionId) {\n            elementProps[\"data-projection-id\"] = projectionId;\n        }\n        return React.createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nvar CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nfunction renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var 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 */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nfunction scrapeMotionValuesFromProps$1(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nfunction isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nvar isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nfunction makeState(_a, props, context, presenceContext) {\n    var scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps, createRenderState = _a.createRenderState, onMount = _a.onMount;\n    var state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = function (instance) { return onMount(props, instance, state); };\n    }\n    return state;\n}\nvar makeUseVisualState = function (config) {\n    return function (props, isStatic) {\n        var context = React.useContext(MotionContext);\n        var presenceContext = React.useContext(PresenceContext);\n        return isStatic\n            ? makeState(config, props, context, presenceContext)\n            : useConstant(function () {\n                return makeState(config, props, context, presenceContext);\n            });\n    };\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var initialAnimationIsBlocked = blockInitialAnimation || initial === false;\n    var variantToSet = initialAnimationIsBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = tslib.__rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target) {\n                var valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    var index = initialAnimationIsBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nvar svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: function (props, instance, _a) {\n            var renderState = _a.renderState, latestValues = _a.latestValues;\n            try {\n                renderState.dimensions =\n                    typeof instance.getBBox ===\n                        \"function\"\n                        ? instance.getBBox()\n                        : instance.getBoundingClientRect();\n            }\n            catch (e) {\n                // Most likely trying to measure an unrendered element under Firefox\n                renderState.dimensions = {\n                    x: 0,\n                    y: 0,\n                    width: 0,\n                    height: 0,\n                };\n            }\n            buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, props.transformTemplate);\n            renderSVG(instance, renderState);\n        },\n    }),\n};\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement, projectionNodeConstructor) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return tslib.__assign(tslib.__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement, projectionNodeConstructor: projectionNodeConstructor, Component: Component });\n}\n\nexports.AnimationType = void 0;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(exports.AnimationType || (exports.AnimationType = {}));\n\nfunction addDomEvent(target, eventName, handler, options) {\n    if (options === void 0) { options = { passive: true }; }\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    React.useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n    var whileFocus = _a.whileFocus, visualElement = _a.visualElement;\n    var onFocus = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nfunction isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    var hasTouches = !!event.touches;\n    return hasTouches;\n}\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return function (event) {\n        var isMouseEvent = event instanceof MouseEvent;\n        var isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nvar defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    var primaryTouch = e.touches[0] || e.changedTouches[0];\n    var point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }\n    var listener = function (event) {\n        return handler(event, extractEventInfo(event));\n    };\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nvar mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nvar touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nfunction createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\n}\n\n/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nvar isNodeOrChild = function (parent, child) {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nfunction useUnmountEffect(callback) {\n    return React.useEffect(function () { return function () { return callback(); }; }, []);\n}\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n    var onTap = _a.onTap, onTapStart = _a.onTapStart, onTapCancel = _a.onTapCancel, whileTap = _a.whileTap, visualElement = _a.visualElement;\n    var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    var isPressing = React.useRef(false);\n    var cancelPointerEndListeners = React.useRef(null);\n    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    var eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.getInstance(), event.target)\n            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)\n            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        var _a;\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = popmotion.pipe(addPointerEvent(window, \"pointerup\", onPointerUp, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nvar warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\n/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nvar observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = tslib.__rest(_a, [\"root\"]);\n    var lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    var rootObservers = observers.get(lookupRoot);\n    var key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, tslib.__assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = React.useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    React.useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    React.useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nvar makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useId = function () { return useConstant(incrementId); };\n/**\n * Ideally we'd use the following code to support React 18 optionally.\n * But this fairly fails in Webpack (otherwise treeshaking wouldn't work at all).\n * Need to come up with a different way of figuring this out.\n */\n// export const useId = (React as any).useId\n//     ? (React as any).useId\n//     : () => useConstant(incrementId)\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    var context = React.useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    // Replace with useId when released in React\n    var id = useId();\n    React.useEffect(function () { return register(id); }, []);\n    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id); };\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(React.useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nfunction shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    var prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (var i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\n/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nvar secondsToMilliseconds = function (seconds) { return seconds * 1000; };\n\nvar easingLookup = {\n    linear: popmotion.linear,\n    easeIn: popmotion.easeIn,\n    easeInOut: popmotion.easeInOut,\n    easeOut: popmotion.easeOut,\n    circIn: popmotion.circIn,\n    circInOut: popmotion.circInOut,\n    circOut: popmotion.circOut,\n    backIn: popmotion.backIn,\n    backInOut: popmotion.backInOut,\n    backOut: popmotion.backOut,\n    anticipate: popmotion.anticipate,\n    bounceIn: popmotion.bounceIn,\n    bounceInOut: popmotion.bounceInOut,\n    bounceOut: popmotion.bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        heyListen.invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = tslib.__read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\n        return popmotion.cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        heyListen.invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\".concat(definition, \"'\"));\n        return easingLookup[definition];\n    }\n    return definition;\n};\nvar isEasingArray = function (ease) {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\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 */\nvar isAnimatable = function (key, value) {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"zIndex\")\n        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))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        styleValueTypes.complex.test(value) && // 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\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n}); };\nvar criticallyDampedSpring = function (to) { return ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n}); };\nvar linearTween = function () { return ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n}); };\nvar keyframes = function (values) { return ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values,\n}); };\nvar defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nvar getDefaultTransition = function (valueKey, to) {\n    var transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return tslib.__assign({ to: to }, transitionFactory(to));\n};\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = tslib.__assign(tslib.__assign({}, numberValueTypes), { \n    // Color props\n    color: styleValueTypes.color, backgroundColor: styleValueTypes.color, outlineColor: styleValueTypes.color, fill: styleValueTypes.color, stroke: styleValueTypes.color, \n    // Border props\n    borderColor: styleValueTypes.color, borderTopColor: styleValueTypes.color, borderRightColor: styleValueTypes.color, borderBottomColor: styleValueTypes.color, borderLeftColor: styleValueTypes.color, filter: styleValueTypes.filter, WebkitFilter: styleValueTypes.filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== styleValueTypes.filter)\n        defaultValueType = styleValueTypes.complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nvar instantAnimationState = {\n    current: false,\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(_a) {\n    _a.when; _a.delay; _a.delayChildren; _a.staggerChildren; _a.staggerDirection; _a.repeat; _a.repeatType; _a.repeatDelay; _a.from; var transition = tslib.__rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\", \"repeat\", \"repeatType\", \"repeatDelay\", \"from\"]);\n    return !!Object.keys(transition).length;\n}\nvar legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions(_a) {\n    var ease = _a.ease, times = _a.times, yoyo = _a.yoyo, flip = _a.flip, loop = _a.loop, transition = tslib.__rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = tslib.__assign({}, transition);\n    if (times)\n        options[\"offset\"] = times;\n    /**\n     * Convert any existing durations from seconds to milliseconds\n     */\n    if (transition.duration)\n        options[\"duration\"] = secondsToMilliseconds(transition.duration);\n    if (transition.repeatDelay)\n        options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n    /**\n     * Map easing names to Popmotion's easing functions\n     */\n    if (ease) {\n        options[\"ease\"] = isEasingArray(ease)\n            ? ease.map(easingDefinitionToFunction)\n            : easingDefinitionToFunction(ease);\n    }\n    /**\n     * Support legacy transition API\n     */\n    if (transition.type === \"tween\")\n        options.type = \"keyframes\";\n    /**\n     * TODO: These options are officially removed from the API.\n     */\n    if (yoyo || loop || flip) {\n        heyListen.warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n        legacyRepeatWarning = true;\n        if (yoyo) {\n            options.repeatType = \"reverse\";\n        }\n        else if (loop) {\n            options.repeatType = \"loop\";\n        }\n        else if (flip) {\n            options.repeatType = \"mirror\";\n        }\n        options.repeat = loop || yoyo || flip || transition.repeat;\n    }\n    /**\n     * TODO: Popmotion 9 has the ability to automatically detect whether to use\n     * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n     * It'd be good to introduce a similar thing here.\n     */\n    if (transition.type !== \"spring\")\n        options.type = \"keyframes\";\n    return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n    var _a, _b;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_b = (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : transition.delay) !== null && _b !== void 0 ? _b : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = tslib.__spreadArray([], tslib.__read(options.to), false);\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    var _a;\n    if (Array.isArray(options.to)) {\n        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = tslib.__assign(tslib.__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return tslib.__assign(tslib.__assign({}, options), convertTransitionToAnimationOptions(transition));\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n    var _a;\n    var valueTransition = getValueTransition(transition, key);\n    var origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();\n    var isTargetAnimatable = isAnimatable(key, target);\n    if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n        /**\n         * If we're trying to animate from \"none\", try and get an animatable version\n         * of the target. This could be improved to work both ways.\n         */\n        origin = getAnimatableNone(key, target);\n    }\n    else if (isZero(origin) && typeof target === \"string\") {\n        origin = getZeroUnit(target);\n    }\n    else if (!Array.isArray(target) &&\n        isZero(target) &&\n        typeof origin === \"string\") {\n        target = getZeroUnit(origin);\n    }\n    var isOriginAnimatable = isAnimatable(key, origin);\n    heyListen.warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \".concat(key, \" from \\\"\").concat(origin, \"\\\" to \\\"\").concat(target, \"\\\". \").concat(origin, \" is not an animatable value - to enable this animation set \").concat(origin, \" to a value animatable to \").concat(target, \" via the `style` property.\"));\n    function start() {\n        var options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete: onComplete,\n            onUpdate: function (v) { return value.set(v); },\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? popmotion.inertia(tslib.__assign(tslib.__assign({}, options), valueTransition))\n            : popmotion.animate(tslib.__assign(tslib.__assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), { onUpdate: function (v) {\n                    var _a;\n                    options.onUpdate(v);\n                    (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);\n                }, onComplete: function () {\n                    var _a;\n                    options.onComplete();\n                    (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n                } }));\n    }\n    function set() {\n        var _a, _b;\n        var finalTarget = resolveFinalValueInKeyframes(target);\n        value.set(finalTarget);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, finalTarget);\n        (_b = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _b === void 0 ? void 0 : _b.call(valueTransition);\n        return { stop: function () { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\n    if (instantAnimationState.current) {\n        transition = { type: false };\n    }\n    return value.start(function (onComplete) {\n        var delayTimer;\n        var controls;\n        var animation = getAnimation(key, value, target, transition, onComplete);\n        var delay = getDelayFromTransition(transition, key);\n        var start = function () { return (controls = animation()); };\n        if (delay) {\n            delayTimer = window.setTimeout(start, secondsToMilliseconds(delay));\n        }\n        else {\n            start();\n        }\n        return function () {\n            clearTimeout(delayTimer);\n            controls === null || controls === void 0 ? void 0 : controls.stop();\n        };\n    });\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 */\nvar isNumericalString = function (v) { return /^\\-?\\d*\\.?\\d+$/.test(v); };\n\n/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nfunction addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem(_a, fromIndex, toIndex) {\n    var _b = tslib.__read(_a), arr = _b.slice(0);\n    var startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        var endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        var _c = tslib.__read(arr.splice(fromIndex, 1), 1), item = _c[0];\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nvar SubscriptionManager = /** @class */ (function () {\n    function SubscriptionManager() {\n        this.subscriptions = [];\n    }\n    SubscriptionManager.prototype.add = function (handler) {\n        var _this = this;\n        addUniqueItem(this.subscriptions, handler);\n        return function () { return removeItem(_this.subscriptions, handler); };\n    };\n    SubscriptionManager.prototype.notify = function (a, b, c) {\n        var numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            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        }\n        else {\n            for (var 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                var handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    };\n    SubscriptionManager.prototype.getSize = function () {\n        return this.subscriptions.length;\n    };\n    SubscriptionManager.prototype.clear = function () {\n        this.subscriptions.length = 0;\n    };\n    return SubscriptionManager;\n}());\n\nvar isFloat = function (value) {\n    return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */ (function () {\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    function MotionValue(init) {\n        var _this = this;\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 = \"6.5.1\";\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         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\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        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = sync.getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync__default[\"default\"].postRender(_this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (_this.prev !== _this.current) {\n                _this.updateSubscribers.notify(_this.current);\n            }\n            // Update velocity subscribers\n            if (_this.velocityUpdateSubscribers.getSize()) {\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n            // Update render subscribers\n            if (render) {\n                _this.renderSubscribers.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 = function () { return sync__default[\"default\"].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 = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\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.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @privateRemarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\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     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\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    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\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    MotionValue.prototype.getVelocity = function () {\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                popmotion.velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 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    MotionValue.prototype.start = function (animation) {\n        var _this = this;\n        this.stop();\n        return new Promise(function (resolve) {\n            _this.hasAnimated = true;\n            _this.stopAnimation = animation(resolve);\n        }).then(function () { return _this.clearAnimation(); });\n    };\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    MotionValue.prototype.stop = function () {\n        if (this.stopAnimation)\n            this.stopAnimation();\n        this.clearAnimation();\n    };\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    MotionValue.prototype.isAnimating = function () {\n        return !!this.stopAnimation;\n    };\n    MotionValue.prototype.clearAnimation = function () {\n        this.stopAnimation = null;\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    MotionValue.prototype.destroy = function () {\n        this.updateSubscribers.clear();\n        this.renderSubscribers.clear();\n        this.stop();\n    };\n    return MotionValue;\n}());\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\n/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\n/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [styleValueTypes.number, styleValueTypes.px, styleValueTypes.percent, styleValueTypes.degrees, styleValueTypes.vw, styleValueTypes.vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n    return dimensionValueTypes.find(testValueType(v));\n};\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(dimensionValueTypes), false), [styleValueTypes.color, styleValueTypes.complex], false);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return 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    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    var resolved = resolveVariant(visualElement, definition);\n    var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = tslib.__rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = tslib.__assign(tslib.__assign({}, target), transitionEnd);\n    for (var key in target) {\n        var value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    var reversedLabels = tslib.__spreadArray([], tslib.__read(variantLabels), false).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var 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)\n            continue;\n        if (typeof value === \"string\" &&\n            (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        }\n        else if (!findValueType(value) && styleValueTypes.complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : (_d[key] = value);\n        visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    var valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a, _b;\n    var origin = {};\n    for (var key in target) {\n        origin[key] =\n            (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n    }\n    return origin;\n}\n\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return Promise.resolve(); };\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return Promise.resolve(); };\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    var when = transition.when;\n    if (when) {\n        var _c = tslib.__read(when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n    var _b;\n    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;\n    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = tslib.__rest(_e, [\"transition\", \"transitionEnd\"]);\n    if (transitionOverride)\n        transition = transitionOverride;\n    var animations = [];\n    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n    for (var key in target) {\n        var value = visualElement.getValue(key);\n        var valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        var valueTransition = tslib.__assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = tslib.__assign(tslib.__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, tslib.__assign(tslib.__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.forEachValue(function (value) { return value.stop(); });\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\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(_a, key) {\n    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;\n    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nvar variantPriorityOrder = [\n    exports.AnimationType.Animate,\n    exports.AnimationType.InView,\n    exports.AnimationType.Focus,\n    exports.AnimationType.Hover,\n    exports.AnimationType.Tap,\n    exports.AnimationType.Drag,\n    exports.AnimationType.Exit,\n];\nvar reversePriorityOrder = tslib.__spreadArray([], tslib.__read(variantPriorityOrder), false).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = tslib.__rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = tslib.__assign(tslib.__assign(tslib.__assign({}, acc), target), transitionEnd);\n        }\n        return acc;\n    };\n    function isAnimated(key) {\n        return allAnimatedKeys[key] !== undefined;\n    }\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        var _a;\n        var props = visualElement.getProps();\n        var context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        var animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        var removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        var encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        var removedVariantIndex = Infinity;\n        var _loop_1 = function (i) {\n            var type = reversePriorityOrder[i];\n            var typeState = state[type];\n            var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            var propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            var activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            var isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = tslib.__assign({}, encounteredKeys);\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                return \"continue\";\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            var variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            var definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = tslib.__assign(tslib.__assign({}, prevResolvedValues), resolvedValues);\n            var markToAnimate = function (key) {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (var key in allKeys) {\n                var next = resolvedValues[key];\n                var prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = tslib.__assign(tslib.__assign({}, encounteredKeys), resolvedValues);\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push.apply(animations, tslib.__spreadArray([], tslib.__read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: tslib.__assign({ type: type }, options),\n                }); })), false));\n            }\n        };\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = tslib.__assign({}, encounteredKeys);\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            var fallbackAnimation_1 = {};\n            removedKeys.forEach(function (key) {\n                var fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation_1[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation_1 });\n        }\n        var shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[exports.AnimationType.Animate] = createTypeState(true),\n        _a[exports.AnimationType.InView] = createTypeState(),\n        _a[exports.AnimationType.Hover] = createTypeState(),\n        _a[exports.AnimationType.Tap] = createTypeState(),\n        _a[exports.AnimationType.Drag] = createTypeState(),\n        _a[exports.AnimationType.Focus] = createTypeState(),\n        _a[exports.AnimationType.Exit] = createTypeState(),\n        _a;\n}\n\nvar animations = {\n    animation: makeRenderlessComponent(function (_a) {\n        var visualElement = _a.visualElement, animate = _a.animate;\n        /**\n         * We dynamically generate the AnimationState manager as it contains a reference\n         * to the underlying animation library. We only want to load that if we load this,\n         * so people can optionally code split it out using the `m` component.\n         */\n        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            React.useEffect(function () { return animate.subscribe(visualElement); }, [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent(function (props) {\n        var custom = props.custom, visualElement = props.visualElement;\n        var _a = tslib.__read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n        var presenceContext = React.useContext(PresenceContext);\n        React.useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = popmotion.distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = sync.getFrameData().timestamp;\n            _this.history.push(tslib.__assign(tslib.__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync__default[\"default\"].update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = sync.getFrameData().timestamp;\n        this.history = [tslib.__assign(tslib.__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = popmotion.pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        sync.cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return popmotion.distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = popmotion.mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        popmotion.mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, _a, elastic) {\n    var min = _a.min, max = _a.max;\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? popmotion.mix(min, point, elastic.min) : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic ? popmotion.mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, _a) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    return {\n        x: calcRelativeAxisConstraints(layoutBox.x, left, right),\n        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),\n    };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative axis\n */\nfunction calcViewportAxisConstraints(layoutAxis, constraintsAxis) {\n    var _a;\n    var min = constraintsAxis.min - layoutAxis.min;\n    var max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        _a = tslib.__read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = popmotion.progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = popmotion.progress(source.min, source.max - targetLength, target.min);\n    }\n    return popmotion.clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nvar createAxisDelta = function () { return ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n}); };\nvar createDelta = function () { return ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n}); };\nvar createAxis = function () { return ({ min: 0, max: 0 }); };\nvar createBox = function () { return ({\n    x: createAxis(),\n    y: createAxis(),\n}); };\n\nfunction eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\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(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\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)\n        return point;\n    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nfunction isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(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    var distanceFromOrigin = point - originPoint;\n    var 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, translate, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\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, _a) {\n    var x = _a.x, y = _a.y;\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, isSharedTransition) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\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}\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, _a) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = popmotion.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 */\nvar xKeys$1 = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys$1 = [\"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$1);\n    transformAxis(box.y, transform, yKeys$1);\n}\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (styleValueTypes.percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(exports.AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        heyListen.invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = tslib.__assign(tslib.__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - popmotion.mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(popmotion.mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            return _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return tslib.__assign(tslib.__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    React.useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    React.useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = React.useRef(null);\n    var transformPagePoint = React.useContext(MotionConfigContext).transformPagePoint;\n    var handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: function (event, info) {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    React.useEffect(function () {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint: transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(function () { return panSession.current && panSession.current.end(); });\n}\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"LayoutAnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, tslib.__spreadArray([], tslib.__read(args), false));\n        };\n    });\n    return lifecycles;\n}\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    var _a;\n    for (var key in next) {\n        var nextValue = next[key];\n        var 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            /**\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 === \"6.5.1\", \"Attempting to mix Framer Motion versions \".concat(nextValue.version, \" with 6.5.1 may not work as expected.\"));\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\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                var 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            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender\n         */\n        var lifecycles = createLifecycles();\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        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var 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        var prevMotionValues = {};\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = tslib.__assign({}, latestValues);\n        // Internal methods ========================\n        /**\n         * On mount, this will be hydrated with a callback to disconnect\n         * this visual element from its parent on unmount.\n         */\n        var removeFromVariantTree;\n        /**\n         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync__default[\"default\"].update(update, false, true);\n            });\n            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n            valueSubscriptions.set(key, function () {\n                removeOnChange();\n                removeOnRenderRequest();\n            });\n        }\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        var initialMotionValues = scrapeMotionValuesFromProps(props);\n        for (var key in initialMotionValues) {\n            var value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        var isControllingVariants = checkIfControllingVariants(props);\n        var isVariantNode = checkIfVariantNode(props);\n        var element = tslib.__assign(tslib.__assign({ treeType: treeType, \n            /**\n             * This is a mirror of the internal instance prop, which keeps\n             * VisualElement type-compatible with React's RefObject.\n             */\n            current: null, \n            /**\n             * The depth of this visual element within the visual element tree.\n             */\n            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), \n            /**\n             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by the projection tree, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                sync.cancelSync.update(update);\n                sync.cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\n            }, \n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () {\n                        return closestVariantNode.variantChildren.delete(child);\n                    };\n                }\n            }, sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\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: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\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: function () {\n                return measureViewportBox(instance, props);\n            }, \n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            }, \n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \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: function (key) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, 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: function (key, value) {\n                baseTarget[key] = value;\n            }, \n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            }, \n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync__default[\"default\"].render(render, false, true);\n            }, \n            /**\n             * Synchronously fire render. It's prefered that we batch renders but\n             * in many circumstances, like layout measurement, we need to run this\n             * synchronously. However in those instances other measures should be taken\n             * to batch reads/writes.\n             */\n            syncRender: render, \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            setProps: function (newProps) {\n                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            } });\n        return element;\n    };\n};\nvar variantProps = tslib.__spreadArray([\"initial\"], tslib.__read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\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 */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    var match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    var _a = tslib.__read(match, 3), token = _a[1], fallback = _a[2];\n    return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n    if (depth === void 0) { depth = 1; }\n    heyListen.invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\".concat(current, \"\\\". This may indicate a circular fallback dependency.\"));\n    var _a = tslib.__read(parseCSSVariable(current), 2), token = _a[0], fallback = _a[1];\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    var resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariable(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    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n    var _b;\n    var target = tslib.__rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof Element))\n        return { target: target, transitionEnd: transitionEnd };\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 = tslib.__assign({}, transitionEnd);\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.forEachValue(function (value) {\n        var current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        var resolved = getVariableValue(current, element);\n        if (resolved)\n            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 (var key in target) {\n        var current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        var resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\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)\n            (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : (transitionEnd[key] = current);\n    }\n    return { target: target, transitionEnd: transitionEnd };\n}\n\nvar positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nvar isPositionalKey = function (key) { return positionalKeys.has(key); };\nvar hasPositionalKey = function (target) {\n    return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nvar isNumOrPxType = function (v) {\n    return v === styleValueTypes.number || v === styleValueTypes.px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n    return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) {\n    return function (_bbox, _a) {\n        var transform = _a.transform;\n        if (transform === \"none\" || !transform)\n            return 0;\n        var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n        if (matrix3d) {\n            return getPosFromMatrix(matrix3d[1], pos3);\n        }\n        else {\n            var matrix = transform.match(/^matrix\\((.+)\\)$/);\n            if (matrix) {\n                return getPosFromMatrix(matrix[1], pos2);\n            }\n            else {\n                return 0;\n            }\n        }\n    };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var 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)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display;\n    var 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(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach(function (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        var value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = tslib.__assign({}, target);\n    transitionEnd = tslib.__assign({}, transitionEnd);\n    var 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    var removedTransformValues = [];\n    var hasAttemptedToRemoveTransformValues = false;\n    var changedValueTypeKeys = [];\n    targetPositionalKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        var from = origin[key];\n        var fromType = findDimensionValueType(from);\n        var to = target[key];\n        var 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            var numKeyframes = to.length;\n            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    heyListen.invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    heyListen.invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\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                var 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                }\n                else if (Array.isArray(to) && toType === styleValueTypes.px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (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                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\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 =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var scrollY_1 = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = tslib.__read(_a, 2), key = _b[0], value = _b[1];\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.syncRender();\n        // Restore scroll position\n        if (scrollY_1 !== null)\n            window.scrollTo({ top: scrollY_1 });\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\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)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\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 */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nfunction getComputedStyle$1(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle$1(domElement);\n            return ((isCSSVariable$1(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (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    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = tslib.__rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return tslib.__assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nvar svgVisualElement = visualElement(tslib.__assign(tslib.__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    }, readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (styleValueTypes.px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        var x = pixelsToPercent(latest, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = styleValueTypes.complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = styleValueTypes.complex.createTransformer(latest);\n        var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        var xScale = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = popmotion.mix(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        var output = template(shadow);\n        if (containsCSSVariables) {\n            var i_1 = 0;\n            output = output.replace(varToken, function () {\n                var cssVariable = cssVariables[i_1];\n                i_1++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    tslib.__extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(tslib.__assign(tslib.__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync__default[\"default\"].postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default[\"default\"].Component));\nfunction MeasureLayout(props) {\n    var _a = tslib.__read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = React.useContext(LayoutGroupContext);\n    return (React__default[\"default\"].createElement(MeasureLayoutWithContext, tslib.__assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: React.useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: tslib.__assign(tslib.__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\n/**\n * Animate a single value or a `MotionValue`.\n *\n * The first argument is either a `MotionValue` to animate, or an initial animation value.\n *\n * The second is either a value to animate to, or an array of keyframes to animate through.\n *\n * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.\n *\n * Returns `AnimationPlaybackControls`, currently just a `stop` method.\n *\n * ```javascript\n * const x = useMotionValue(0)\n *\n * useEffect(() => {\n *   const controls = animate(x, 100, {\n *     type: \"spring\",\n *     stiffness: 2000,\n *     onComplete: v => {}\n *   })\n *\n *   return controls.stop\n * })\n * ```\n *\n * @public\n */\nfunction animate(from, to, transition) {\n    if (transition === void 0) { transition = {}; }\n    var value = isMotionValue(from) ? from : motionValue(from);\n    startAnimation(\"\", value, to, transition);\n    return {\n        stop: function () { return value.stop(); },\n        isAnimating: function () { return value.isAnimating(); },\n    };\n}\n\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nvar asNumber = function (value) {\n    return typeof value === \"string\" ? parseFloat(value) : value;\n};\nvar isPx = function (value) {\n    return typeof value === \"number\" || styleValueTypes.px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = popmotion.mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = popmotion.mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = popmotion.mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\".concat(borders[i], \"Radius\");\n        var followRadius = getRadius(follow, borderLabel);\n        var leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        var canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(popmotion.mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (styleValueTypes.percent.test(leadRadius) || styleValueTypes.percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = popmotion.mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nvar easeCrossfadeIn = compress(0, 0.5, popmotion.circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, popmotion.linear);\nfunction compress(min, max, easing) {\n    return function (p) {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(popmotion.progress(min, max, p));\n    };\n}\n\n/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate, scale, origin, boxScale, originAxis, sourceAxis) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    if (originAxis === void 0) { originAxis = axis; }\n    if (sourceAxis === void 0) { sourceAxis = axis; }\n    if (styleValueTypes.percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = popmotion.mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var originPoint = popmotion.mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, _a, origin, sourceAxis) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nfunction isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\n\nvar NodeStack = /** @class */ (function () {\n    function NodeStack() {\n        this.members = [];\n    }\n    NodeStack.prototype.add = function (node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    };\n    NodeStack.prototype.remove = function (node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            var prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    };\n    NodeStack.prototype.relegate = function (node) {\n        var indexOfNode = this.members.findIndex(function (member) { return node === member; });\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        var prevLead;\n        for (var i = indexOfNode; i >= 0; i--) {\n            var member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    NodeStack.prototype.promote = function (node, preserveFollowOpacity) {\n        var _a;\n        var prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n                node.snapshot.isShared = true;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            var crossfade = node.options.crossfade;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    };\n    NodeStack.prototype.exitAnimationComplete = function () {\n        this.members.forEach(function (node) {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    };\n    NodeStack.prototype.scheduleRender = function () {\n        this.members.forEach(function (node) {\n            node.instance && node.scheduleRender(false);\n        });\n    };\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    NodeStack.prototype.removeLeadSnapshot = function () {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    };\n    return NodeStack;\n}());\n\nvar identityProjection = \"translate3d(0px, 0px, 0) scale(1, 1) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    transform += \"scale(\".concat(1 / treeScale.x, \", \").concat(1 / treeScale.y, \") \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    var elementScaleX = delta.x.scale * treeScale.x;\n    var elementScaleY = delta.y.scale * treeScale.y;\n    transform += \"scale(\".concat(elementScaleX, \", \").concat(elementScaleY, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\nvar compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nvar FlatTree = /** @class */ (function () {\n    function FlatTree() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    FlatTree.prototype.add = function (child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.remove = function (child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.forEach = function (callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    };\n    return FlatTree;\n}());\n\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nvar animationTarget = 1000;\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, checkIsScrollRoot = _a.checkIsScrollRoot, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(parent.path), false), [parent], false) : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            id && this.root.registerPotentialNode(id, this);\n            for (var i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        ProjectionNode.prototype.addEventListener = function (name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        };\n        ProjectionNode.prototype.notifyListeners = function (name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            var subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify.apply(subscriptionManager, tslib.__spreadArray([], tslib.__read(args), false));\n        };\n        ProjectionNode.prototype.hasListeners = function (name) {\n            return this.eventHandlers.has(name);\n        };\n        ProjectionNode.prototype.registerPotentialNode = function (id, node) {\n            this.potentialNodes.set(id, node);\n        };\n        /**\n         * Lifecycles\n         */\n        ProjectionNode.prototype.mount = function (instance, isLayoutDirty) {\n            var _this = this;\n            var _a;\n            if (isLayoutDirty === void 0) { isLayoutDirty = false; }\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            var _b = this.options, layoutId = _b.layoutId, layout = _b.layout, visualElement = _b.visualElement;\n            if (visualElement && !visualElement.getInstance()) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.id && this.root.potentialNodes.delete(this.id);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                var unblockTimeout_1;\n                var resizeUnblockUpdate_1 = function () {\n                    return (_this.root.updateBlockedByResize = false);\n                };\n                attachResizeListener(instance, function () {\n                    _this.root.updateBlockedByResize = true;\n                    clearTimeout(unblockTimeout_1);\n                    unblockTimeout_1 = window.setTimeout(resizeUnblockUpdate_1, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        _this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", function (_a) {\n                    var _b, _c, _d, _e, _f;\n                    var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged, hasRelativeTargetChanged = _a.hasRelativeTargetChanged, newLayout = _a.layout;\n                    if (_this.isTreeAnimationBlocked()) {\n                        _this.target = undefined;\n                        _this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    var layoutTransition = (_c = (_b = _this.options.transition) !== null && _b !== void 0 ? _b : visualElement.getDefaultTransition()) !== null && _c !== void 0 ? _c : defaultLayoutTransition;\n                    var _g = visualElement.getProps(), onLayoutAnimationStart = _g.onLayoutAnimationStart, onLayoutAnimationComplete = _g.onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = tslib.__assign(tslib.__assign({}, getValueTransition(layoutTransition, \"layout\")), { onPlay: onLayoutAnimationStart, onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            sync.cancelSync.preRender(this.updateProjection);\n        };\n        // only on the root\n        ProjectionNode.prototype.blockUpdate = function () {\n            this.updateManuallyBlocked = true;\n        };\n        ProjectionNode.prototype.unblockUpdate = function () {\n            this.updateManuallyBlocked = false;\n        };\n        ProjectionNode.prototype.isUpdateBlocked = function () {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        };\n        ProjectionNode.prototype.isTreeAnimationBlocked = function () {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        };\n        // Note: currently only running on root node\n        ProjectionNode.prototype.startUpdate = function () {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n        };\n        ProjectionNode.prototype.willUpdate = function (shouldNotifyListeners) {\n            var _a, _b, _c;\n            if (shouldNotifyListeners === void 0) { shouldNotifyListeners = true; }\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                node.shouldResetTransform = true;\n                /**\n                 * TODO: Check we haven't updated the scroll\n                 * since the last didUpdate\n                 */\n                node.updateScroll();\n            }\n            var _d = this.options, layoutId = _d.layoutId, layout = _d.layout;\n            if (layoutId === undefined && !layout)\n                return;\n            var transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        };\n        // Note: Currently only running on root node\n        ProjectionNode.prototype.didUpdate = function () {\n            var updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            sync.flushSync.update();\n            sync.flushSync.preRender();\n            sync.flushSync.render();\n        };\n        ProjectionNode.prototype.clearAllSnapshots = function () {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        };\n        ProjectionNode.prototype.scheduleUpdateProjection = function () {\n            sync__default[\"default\"].preRender(this.updateProjection, false, true);\n        };\n        ProjectionNode.prototype.scheduleCheckAfterUnmount = function () {\n            var _this = this;\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync__default[\"default\"].postRender(function () {\n                if (_this.isLayoutDirty) {\n                    _this.root.didUpdate();\n                }\n                else {\n                    _this.root.checkUpdateFailed();\n                }\n            });\n        };\n        /**\n         * Update measurements\n         */\n        ProjectionNode.prototype.updateSnapshot = function () {\n            if (this.snapshot || !this.instance)\n                return;\n            var measured = this.measure();\n            var layout = this.removeTransform(this.removeElementScroll(measured));\n            roundBox(layout);\n            this.snapshot = {\n                measured: measured,\n                layout: layout,\n                latestValues: {},\n            };\n        };\n        ProjectionNode.prototype.updateLayout = function () {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (var i = 0; i < this.path.length; i++) {\n                    var node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            var measured = this.measure();\n            roundBox(measured);\n            var prevLayout = this.layout;\n            this.layout = {\n                measured: measured,\n                actual: this.removeElementScroll(measured),\n            };\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.actual);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notifyLayoutMeasure(this.layout.actual, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.actual);\n        };\n        ProjectionNode.prototype.updateScroll = function () {\n            if (this.options.layoutScroll && this.instance) {\n                this.isScrollRoot = checkIsScrollRoot(this.instance);\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options, isScrollRoot = node.isScrollRoot;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (isScrollRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        var rootScroll = this.root.scroll;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = tslib.__assign(tslib.__assign(tslib.__assign({}, this.options), options), { crossfade: (_a = options.crossfade) !== null && _a !== void 0 ? _a : true });\n        };\n        ProjectionNode.prototype.clearMeasurements = function () {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        };\n        /**\n         * Frame calculations\n         */\n        ProjectionNode.prototype.resolveTargetDelta = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent && this.relativeParent.layout) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.actual, this.relativeParent.layout.actual);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.actual);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.actual);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.actual);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent &&\n                    Boolean(this.relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !this.relativeParent.options.layoutScroll &&\n                    this.relativeParent.target) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, this.relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n        };\n        ProjectionNode.prototype.getClosestProjectingParent = function () {\n            if (!this.parent || hasTransform(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        };\n        ProjectionNode.prototype.calcProjection = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            var lead = this.getLead();\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.actual);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, Boolean(this.resumingFrom) || this !== lead);\n            var target = lead.target;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            var prevTreeScaleX = this.treeScale.x;\n            var prevTreeScaleY = this.treeScale.y;\n            var prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        };\n        ProjectionNode.prototype.hide = function () {\n            this.isVisible = false;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.show = function () {\n            this.isVisible = true;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.scheduleRender = function (notifyAll) {\n            var _a, _b, _c;\n            if (notifyAll === void 0) { notifyAll = true; }\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        };\n        ProjectionNode.prototype.setAnimationOrigin = function (delta, hasOnlyRelativeTargetChanged) {\n            var _this = this;\n            var _a;\n            if (hasOnlyRelativeTargetChanged === void 0) { hasOnlyRelativeTargetChanged = false; }\n            var snapshot = this.snapshot;\n            var snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            var mixedValues = tslib.__assign({}, this.latestValues);\n            var targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            var relativeLayout = createBox();\n            var isSharedLayoutAnimation = snapshot === null || snapshot === void 0 ? void 0 : snapshot.isShared;\n            var isOnlyMember = (((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.members.length) || 0) <= 1;\n            var shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = function (latest) {\n                var _a;\n                var progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                _this.setTargetDelta(targetDelta);\n                if (_this.relativeTarget &&\n                    _this.relativeTargetOrigin &&\n                    _this.layout &&\n                    ((_a = _this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, _this.layout.actual, _this.relativeParent.layout.actual);\n                    mixBox(_this.relativeTarget, _this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    _this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, _this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                _this.root.scheduleUpdateProjection();\n                _this.scheduleRender();\n                _this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        };\n        ProjectionNode.prototype.startAnimation = function (options) {\n            var _this = this;\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                sync.cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync__default[\"default\"].update(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, tslib.__assign(tslib.__assign({}, options), { onUpdate: function (latest) {\n                        var _a;\n                        _this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    }, onComplete: function () {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        _this.completeAnimation();\n                    } }));\n                if (_this.resumingFrom) {\n                    _this.resumingFrom.currentAnimation = _this.currentAnimation;\n                }\n                _this.pendingAnimation = undefined;\n            });\n        };\n        ProjectionNode.prototype.completeAnimation = function () {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        };\n        ProjectionNode.prototype.finishAnimation = function () {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        };\n        ProjectionNode.prototype.applyTransformsToTarget = function () {\n            var _a = this.getLead(), targetWithTransforms = _a.targetWithTransforms, target = _a.target, layout = _a.layout, latestValues = _a.latestValues;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its actual layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        };\n        ProjectionNode.prototype.registerSharedNode = function (layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            var stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        };\n        ProjectionNode.prototype.isLead = function () {\n            var stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        };\n        ProjectionNode.prototype.getLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        };\n        ProjectionNode.prototype.getPrevLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        };\n        ProjectionNode.prototype.getStack = function () {\n            var layoutId = this.options.layoutId;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        };\n        ProjectionNode.prototype.promote = function (_a) {\n            var _b = _a === void 0 ? {} : _a, needsReset = _b.needsReset, transition = _b.transition, preserveFollowOpacity = _b.preserveFollowOpacity;\n            var stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition: transition });\n        };\n        ProjectionNode.prototype.relegate = function () {\n            var stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        };\n        ProjectionNode.prototype.resetRotation = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            var hasRotate = false;\n            // Keep a record of all the values we've reset\n            var resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (var i = 0; i < transformAxes.length; i++) {\n                var axis = transformAxes[i];\n                var key = \"rotate\" + axis;\n                // If this rotation doesn't exist as a motion value, then we don't\n                // need to reset it\n                if (!visualElement.getStaticValue(key)) {\n                    continue;\n                }\n                hasRotate = true;\n                // Record the rotation and then temporarily set it to 0\n                resetValues[key] = visualElement.getStaticValue(key);\n                visualElement.setStaticValue(key, 0);\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n            // Put back all the values we reset\n            for (var key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        };\n        ProjectionNode.prototype.getProjectionStyles = function (styleProp) {\n            var _a, _b, _c, _d, _e, _f;\n            if (styleProp === void 0) { styleProp = {}; }\n            // TODO: Return lifecycle-persistent object\n            var styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            var lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                var emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity = (_b = this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            var valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            var _g = this.projectionDelta, x = _g.x, y = _g.y;\n            styles.transformOrigin = \"\".concat(x.origin * 100, \"% \").concat(y.origin * 100, \"% 0\");\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_d = (_c = valuesToRender.opacity) !== null && _c !== void 0 ? _c : this.latestValues.opacity) !== null && _d !== void 0 ? _d : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its actual\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_e = valuesToRender.opacity) !== null && _e !== void 0 ? _e : \"\"\n                        : (_f = valuesToRender.opacityExit) !== null && _f !== void 0 ? _f : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (var key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                var _h = scaleCorrectors[key], correct = _h.correct, applyTo = _h.applyTo;\n                var corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        };\n        ProjectionNode.prototype.clearSnapshot = function () {\n            this.resumeFrom = this.snapshot = undefined;\n        };\n        // Only run on root\n        ProjectionNode.prototype.resetTree = function () {\n            this.root.nodes.forEach(function (node) { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        };\n        return ProjectionNode;\n    }());\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c, _d;\n    var snapshot = (_b = (_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) !== null && _b !== void 0 ? _b : node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        var _e = node.layout, layout_1 = _e.actual, measuredLayout = _e.measured;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (node.options.animationType === \"size\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout_1[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (node.options.animationType === \"position\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(layout_1[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        var layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout_1, snapshot.layout);\n        var visualDelta = createDelta();\n        if (snapshot.isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measured);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout_1, snapshot.layout);\n        }\n        var hasLayoutChanged = !isDeltaZero(layoutDelta);\n        var hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            node.relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (node.relativeParent && !node.relativeParent.resumeFrom) {\n                var _f = node.relativeParent, parentSnapshot = _f.snapshot, parentLayout = _f.layout;\n                if (parentSnapshot && parentLayout) {\n                    var relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layout, parentSnapshot.layout);\n                    var relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout_1, parentLayout.actual);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout: layout_1,\n            snapshot: snapshot,\n            delta: visualDelta,\n            layoutDelta: layoutDelta,\n            hasLayoutChanged: hasLayoutChanged,\n            hasRelativeTargetChanged: hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_d = (_c = node.options).onExitComplete) === null || _d === void 0 ? void 0 : _d.call(_c);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    var visualElement = node.options.visualElement;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notifyBeforeLayoutMeasure();\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = popmotion.mix(delta.translate, 0, p);\n    output.scale = popmotion.mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = popmotion.mix(from.min, to.min, p);\n    output.max = popmotion.mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, id) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    var searchNode = node.root;\n    for (var i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    var searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    var element = searchElement.querySelector(\"[data-projection-id=\\\"\".concat(id, \"\\\"]\"));\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) { return addDomEvent(ref, \"resize\", notify); },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n    checkIsScrollRoot: function () { return true; },\n});\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n    checkIsScrollRoot: function (instance) {\n        return Boolean(window.getComputedStyle(instance).position === \"fixed\");\n    },\n});\n\nvar featureBundle = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, animations), gestureAnimations), drag), layoutFeatures);\n/**\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\n *\n * @public\n */\nvar motion = /*@__PURE__*/ createMotionProxy(function (Component, config) {\n    return createDomMotionConfig(Component, config, featureBundle, createDomVisualElement, HTMLProjectionNode);\n});\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n    return createMotionComponent(createDomMotionConfig(key, { forwardMotionProps: false }, featureBundle, createDomVisualElement, HTMLProjectionNode));\n}\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nfunction useIsMounted() {\n    var isMounted = React.useRef(false);\n    useIsomorphicLayoutEffect(function () {\n        isMounted.current = true;\n        return function () {\n            isMounted.current = false;\n        };\n    }, []);\n    return isMounted;\n}\n\nfunction useForceUpdate() {\n    var isMounted = useIsMounted();\n    var _a = tslib.__read(React.useState(0), 2), forcedRenderCount = _a[0], setForcedRenderCount = _a[1];\n    var forceRender = React.useCallback(function () {\n        isMounted.current && setForcedRenderCount(forcedRenderCount + 1);\n    }, [forcedRenderCount]);\n    /**\n     * Defer this to the end of the next animation frame in case there are multiple\n     * synchronous calls.\n     */\n    var deferredForceRender = React.useCallback(function () { return sync__default[\"default\"].postRender(forceRender); }, [forceRender]);\n    return [deferredForceRender, forcedRenderCount];\n}\n\nvar PresenceChild = function (_a) {\n    var children = _a.children, initial = _a.initial, isPresent = _a.isPresent, onExitComplete = _a.onExitComplete, custom = _a.custom, presenceAffectsLayout = _a.presenceAffectsLayout;\n    var presenceChildren = useConstant(newChildrenMap);\n    var id = useId();\n    var context = React.useMemo(function () { return ({\n        id: id,\n        initial: initial,\n        isPresent: isPresent,\n        custom: custom,\n        onExitComplete: function (childId) {\n            var e_1, _a;\n            presenceChildren.set(childId, true);\n            try {\n                for (var _b = tslib.__values(presenceChildren.values()), _c = _b.next(); !_c.done; _c = _b.next()) {\n                    var isComplete = _c.value;\n                    if (!isComplete)\n                        return; // can stop searching when any is incomplete\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete();\n        },\n        register: function (childId) {\n            presenceChildren.set(childId, false);\n            return function () { return presenceChildren.delete(childId); };\n        },\n    }); }, \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout ? undefined : [isPresent]);\n    React.useMemo(function () {\n        presenceChildren.forEach(function (_, key) { return presenceChildren.set(key, false); });\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React__namespace.useEffect(function () {\n        !isPresent && !presenceChildren.size && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n    }, [isPresent]);\n    return (React__namespace.createElement(PresenceContext.Provider, { value: context }, children));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nvar getChildKey = function (child) { return child.key || \"\"; };\nfunction updateChildLookup(children, allChildren) {\n    children.forEach(function (child) {\n        var key = getChildKey(child);\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    var filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    React.Children.forEach(children, function (child) {\n        if (React.isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nvar AnimatePresence = function (_a) {\n    var children = _a.children, custom = _a.custom, _b = _a.initial, initial = _b === void 0 ? true : _b, onExitComplete = _a.onExitComplete, exitBeforeEnter = _a.exitBeforeEnter, _c = _a.presenceAffectsLayout, presenceAffectsLayout = _c === void 0 ? true : _c;\n    // We want to force a re-render once all exiting animations have finished. We\n    // either use a local forceRender function, or one from a parent context if it exists.\n    var _d = tslib.__read(useForceUpdate(), 1), forceRender = _d[0];\n    var forceRenderLayoutGroup = React.useContext(LayoutGroupContext).forceRender;\n    if (forceRenderLayoutGroup)\n        forceRender = forceRenderLayoutGroup;\n    var isMounted = useIsMounted();\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    var filteredChildren = onlyElements(children);\n    var childrenToRender = filteredChildren;\n    var exiting = new Set();\n    // Keep a living record of the children we're actually rendering so we\n    // can diff to figure out which are entering and exiting\n    var presentChildren = React.useRef(childrenToRender);\n    // A lookup table to quickly reference components by key\n    var allChildren = React.useRef(new Map()).current;\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    var isInitialRender = React.useRef(true);\n    useIsomorphicLayoutEffect(function () {\n        isInitialRender.current = false;\n        updateChildLookup(filteredChildren, allChildren);\n        presentChildren.current = childrenToRender;\n    });\n    useUnmountEffect(function () {\n        isInitialRender.current = true;\n        allChildren.clear();\n        exiting.clear();\n    });\n    if (isInitialRender.current) {\n        return (React__namespace.createElement(React__namespace.Fragment, null, childrenToRender.map(function (child) { return (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout }, child)); })));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    childrenToRender = tslib.__spreadArray([], tslib.__read(childrenToRender), false);\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    var presentKeys = presentChildren.current.map(getChildKey);\n    var targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    var numPresent = presentKeys.length;\n    for (var i = 0; i < numPresent; i++) {\n        var key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1) {\n            exiting.add(key);\n        }\n    }\n    // If we currently have exiting children, and we're deferring rendering incoming children\n    // until after all current children have exiting, empty the childrenToRender array\n    if (exitBeforeEnter && exiting.size) {\n        childrenToRender = [];\n    }\n    // Loop through all currently exiting components and clone them to overwrite `animate`\n    // with any `exit` prop they might have defined.\n    exiting.forEach(function (key) {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        var child = allChildren.get(key);\n        if (!child)\n            return;\n        var insertionIndex = presentKeys.indexOf(key);\n        var onExit = function () {\n            allChildren.delete(key);\n            exiting.delete(key);\n            // Remove this child from the present children\n            var removeIndex = presentChildren.current.findIndex(function (presentChild) { return presentChild.key === key; });\n            presentChildren.current.splice(removeIndex, 1);\n            // Defer re-rendering until all exiting children have indeed left\n            if (!exiting.size) {\n                presentChildren.current = filteredChildren;\n                if (isMounted.current === false)\n                    return;\n                forceRender();\n                onExitComplete && onExitComplete();\n            }\n        };\n        childrenToRender.splice(insertionIndex, 0, React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    // Add `MotionContext` even to children that don't need it to ensure we're rendering\n    // the same tree between renders\n    childrenToRender = childrenToRender.map(function (child) {\n        var key = child.key;\n        return exiting.has(key) ? (child) : (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    if (env !== \"production\" &&\n        exitBeforeEnter &&\n        childrenToRender.length > 1) {\n        console.warn(\"You're attempting to animate multiple children within AnimatePresence, but its exitBeforeEnter prop is set to true. This will lead to odd visual behaviour.\");\n    }\n    return (React__namespace.createElement(React__namespace.Fragment, null, exiting.size\n        ? childrenToRender\n        : childrenToRender.map(function (child) { return React.cloneElement(child); })));\n};\n\n/**\n * @deprecated\n */\nvar DeprecatedLayoutGroupContext = React.createContext(null);\n\nvar notify = function (node) {\n    return !node.isLayoutDirty && node.willUpdate(false);\n};\nfunction nodeGroup() {\n    var nodes = new Set();\n    var subscriptions = new WeakMap();\n    var dirtyAll = function () { return nodes.forEach(notify); };\n    return {\n        add: function (node) {\n            nodes.add(node);\n            subscriptions.set(node, node.addEventListener(\"willUpdate\", dirtyAll));\n        },\n        remove: function (node) {\n            var _a;\n            nodes.delete(node);\n            (_a = subscriptions.get(node)) === null || _a === void 0 ? void 0 : _a();\n            subscriptions.delete(node);\n            dirtyAll();\n        },\n        dirty: dirtyAll,\n    };\n}\n\nvar shouldInheritGroup = function (inherit) { return inherit === true; };\nvar shouldInheritId = function (inherit) {\n    return shouldInheritGroup(inherit === true) || inherit === \"id\";\n};\nvar LayoutGroup = function (_a) {\n    var _b, _c;\n    var children = _a.children, id = _a.id, inheritId = _a.inheritId, _d = _a.inherit, inherit = _d === void 0 ? true : _d;\n    // Maintain backwards-compatibility with inheritId until 7.0\n    if (inheritId !== undefined)\n        inherit = inheritId;\n    var layoutGroupContext = React.useContext(LayoutGroupContext);\n    var deprecatedLayoutGroupContext = React.useContext(DeprecatedLayoutGroupContext);\n    var _e = tslib.__read(useForceUpdate(), 2), forceRender = _e[0], key = _e[1];\n    var context = React.useRef(null);\n    var upstreamId = (_b = layoutGroupContext.id) !== null && _b !== void 0 ? _b : deprecatedLayoutGroupContext;\n    if (context.current === null) {\n        if (shouldInheritId(inherit) && upstreamId) {\n            id = id ? upstreamId + \"-\" + id : upstreamId;\n        }\n        context.current = {\n            id: id,\n            group: shouldInheritGroup(inherit)\n                ? (_c = layoutGroupContext === null || layoutGroupContext === void 0 ? void 0 : layoutGroupContext.group) !== null && _c !== void 0 ? _c : nodeGroup()\n                : nodeGroup(),\n        };\n    }\n    var memoizedContext = React.useMemo(function () { return (tslib.__assign(tslib.__assign({}, context.current), { forceRender: forceRender })); }, [key]);\n    return (React__namespace.createElement(LayoutGroupContext.Provider, { value: memoizedContext }, children));\n};\n\nvar id = 0;\nvar AnimateSharedLayout = function (_a) {\n    var children = _a.children;\n    React__namespace.useEffect(function () {\n        heyListen.warning(false, \"AnimateSharedLayout is deprecated: https://www.framer.com/docs/guide-upgrade/##shared-layout-animations\");\n    }, []);\n    return (React__namespace.createElement(LayoutGroup, { id: useConstant(function () { return \"asl-\".concat(id++); }) }, children));\n};\n\n/**\n * `MotionConfig` is used to set configuration options for all children `motion` components.\n *\n * ```jsx\n * import { motion, MotionConfig } from \"framer-motion\"\n *\n * export function App() {\n *   return (\n *     <MotionConfig transition={{ type: \"spring\" }}>\n *       <motion.div animate={{ x: 100 }} />\n *     </MotionConfig>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction MotionConfig(_a) {\n    var children = _a.children, isValidProp = _a.isValidProp, config = tslib.__rest(_a, [\"children\", \"isValidProp\"]);\n    isValidProp && loadExternalIsValidProp(isValidProp);\n    /**\n     * Inherit props from any parent MotionConfig components\n     */\n    config = tslib.__assign(tslib.__assign({}, React.useContext(MotionConfigContext)), config);\n    /**\n     * Don't allow isStatic to change between renders as it affects how many hooks\n     * motion components fire.\n     */\n    config.isStatic = useConstant(function () { return config.isStatic; });\n    /**\n     * Creating a new config context object will re-render every `motion` component\n     * every time it renders. So we only want to create a new one sparingly.\n     */\n    var context = React.useMemo(function () { return config; }, [JSON.stringify(config.transition), config.transformPagePoint, config.reducedMotion]);\n    return (React__namespace.createElement(MotionConfigContext.Provider, { value: context }, children));\n}\n\n/**\n * Used in conjunction with the `m` component to reduce bundle size.\n *\n * `m` is a version of the `motion` component that only loads functionality\n * critical for the initial render.\n *\n * `LazyMotion` can then be used to either synchronously or asynchronously\n * load animation and gesture support.\n *\n * ```jsx\n * // Synchronous loading\n * import { LazyMotion, m, domAnimations } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimations}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n *\n * // Asynchronous loading\n * import { LazyMotion, m } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={() => import('./path/to/domAnimations')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion(_a) {\n    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;\n    var _c = tslib.__read(React.useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];\n    var loadedRenderer = React.useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        var renderer = features.renderer, loadedFeatures = tslib.__rest(features, [\"renderer\"]);\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    React.useEffect(function () {\n        if (isLazyBundle(features)) {\n            features().then(function (_a) {\n                var renderer = _a.renderer, loadedFeatures = tslib.__rest(_a, [\"renderer\"]);\n                loadFeatures(loadedFeatures);\n                loadedRenderer.current = renderer;\n                setIsLoaded(true);\n            });\n        }\n    }, []);\n    return (React__namespace.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\nvar ReorderContext = React.createContext(null);\n\nfunction checkReorder(order, value, offset, velocity) {\n    if (!velocity)\n        return order;\n    var index = order.findIndex(function (item) { return item.value === value; });\n    if (index === -1)\n        return order;\n    var nextOffset = velocity > 0 ? 1 : -1;\n    var nextItem = order[index + nextOffset];\n    if (!nextItem)\n        return order;\n    var item = order[index];\n    var nextLayout = nextItem.layout;\n    var nextItemCenter = popmotion.mix(nextLayout.min, nextLayout.max, 0.5);\n    if ((nextOffset === 1 && item.layout.max + offset > nextItemCenter) ||\n        (nextOffset === -1 && item.layout.min + offset < nextItemCenter)) {\n        return moveItem(order, index, index + nextOffset);\n    }\n    return order;\n}\n\nfunction ReorderGroup(_a, externalRef) {\n    var children = _a.children, _b = _a.as, as = _b === void 0 ? \"ul\" : _b, _c = _a.axis, axis = _c === void 0 ? \"y\" : _c, onReorder = _a.onReorder, values = _a.values, props = tslib.__rest(_a, [\"children\", \"as\", \"axis\", \"onReorder\", \"values\"]);\n    var Component = useConstant(function () { return motion(as); });\n    var order = [];\n    var isReordering = React.useRef(false);\n    heyListen.invariant(Boolean(values), \"Reorder.Group must be provided a values prop\");\n    var context = {\n        axis: axis,\n        registerItem: function (value, layout) {\n            /**\n             * Ensure entries can't add themselves more than once\n             */\n            if (layout &&\n                order.findIndex(function (entry) { return value === entry.value; }) === -1) {\n                order.push({ value: value, layout: layout[axis] });\n                order.sort(compareMin);\n            }\n        },\n        updateOrder: function (id, offset, velocity) {\n            if (isReordering.current)\n                return;\n            var newOrder = checkReorder(order, id, offset, velocity);\n            if (order !== newOrder) {\n                isReordering.current = true;\n                onReorder(newOrder\n                    .map(getValue)\n                    .filter(function (value) { return values.indexOf(value) !== -1; }));\n            }\n        },\n    };\n    React.useEffect(function () {\n        isReordering.current = false;\n    });\n    return (React__namespace.createElement(Component, tslib.__assign({}, props, { ref: externalRef }),\n        React__namespace.createElement(ReorderContext.Provider, { value: context }, children)));\n}\nvar Group = React.forwardRef(ReorderGroup);\nfunction getValue(item) {\n    return item.value;\n}\nfunction compareMin(a, b) {\n    return a.layout.min - b.layout.min;\n}\n\n/**\n * Creates a `MotionValue` to track the state and velocity of a value.\n *\n * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const scale = useMotionValue(1)\n *\n *   return <motion.div style={{ scale }} />\n * }\n * ```\n *\n * @param initial - The initial state.\n *\n * @public\n */\nfunction useMotionValue(initial) {\n    var value = useConstant(function () { return motionValue(initial); });\n    /**\n     * If this motion value is being used in static mode, like on\n     * the Framer canvas, force components to rerender when the motion\n     * value is updated.\n     */\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    if (isStatic) {\n        var _a = tslib.__read(React.useState(initial), 2), setLatest_1 = _a[1];\n        React.useEffect(function () { return value.onChange(setLatest_1); }, []);\n    }\n    return value;\n}\n\nvar isCustomValueType = function (v) {\n    return typeof v === \"object\" && v.mix;\n};\nvar getMixer = function (v) { return (isCustomValueType(v) ? v.mix : undefined); };\nfunction transform() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var useImmediate = !Array.isArray(args[0]);\n    var argOffset = useImmediate ? 0 : -1;\n    var inputValue = args[0 + argOffset];\n    var inputRange = args[1 + argOffset];\n    var outputRange = args[2 + argOffset];\n    var options = args[3 + argOffset];\n    var interpolator = popmotion.interpolate(inputRange, outputRange, tslib.__assign({ mixer: getMixer(outputRange[0]) }, options));\n    return useImmediate ? interpolator(inputValue) : interpolator;\n}\n\nfunction useOnChange(value, callback) {\n    useIsomorphicLayoutEffect(function () {\n        if (isMotionValue(value))\n            return value.onChange(callback);\n    }, [callback]);\n}\nfunction useMultiOnChange(values, handler) {\n    useIsomorphicLayoutEffect(function () {\n        var subscriptions = values.map(function (value) { return value.onChange(handler); });\n        return function () { return subscriptions.forEach(function (unsubscribe) { return unsubscribe(); }); };\n    });\n}\n\nfunction useCombineMotionValues(values, combineValues) {\n    /**\n     * Initialise the returned motion value. This remains the same between renders.\n     */\n    var value = useMotionValue(combineValues());\n    /**\n     * Create a function that will update the template motion value with the latest values.\n     * This is pre-bound so whenever a motion value updates it can schedule its\n     * execution in Framesync. If it's already been scheduled it won't be fired twice\n     * in a single frame.\n     */\n    var updateValue = function () { return value.set(combineValues()); };\n    /**\n     * Synchronously update the motion value with the latest values during the render.\n     * This ensures that within a React render, the styles applied to the DOM are up-to-date.\n     */\n    updateValue();\n    /**\n     * Subscribe to all motion values found within the template. Whenever any of them change,\n     * schedule an update.\n     */\n    useMultiOnChange(values, function () { return sync__default[\"default\"].update(updateValue, false, true); });\n    return value;\n}\n\nfunction useTransform(input, inputRangeOrTransformer, outputRange, options) {\n    var transformer = typeof inputRangeOrTransformer === \"function\"\n        ? inputRangeOrTransformer\n        : transform(inputRangeOrTransformer, outputRange, options);\n    return Array.isArray(input)\n        ? useListTransform(input, transformer)\n        : useListTransform([input], function (_a) {\n            var _b = tslib.__read(_a, 1), latest = _b[0];\n            return transformer(latest);\n        });\n}\nfunction useListTransform(values, transformer) {\n    var latest = useConstant(function () { return []; });\n    return useCombineMotionValues(values, function () {\n        latest.length = 0;\n        var numValues = values.length;\n        for (var i = 0; i < numValues; i++) {\n            latest[i] = values[i].get();\n        }\n        return transformer(latest);\n    });\n}\n\nfunction useDefaultMotionValue(value, defaultValue) {\n    if (defaultValue === void 0) { defaultValue = 0; }\n    return isMotionValue(value) ? value : useMotionValue(defaultValue);\n}\nfunction ReorderItem(_a, externalRef) {\n    var children = _a.children, style = _a.style, value = _a.value, _b = _a.as, as = _b === void 0 ? \"li\" : _b, onDrag = _a.onDrag, _c = _a.layout, layout = _c === void 0 ? true : _c, props = tslib.__rest(_a, [\"children\", \"style\", \"value\", \"as\", \"onDrag\", \"layout\"]);\n    var Component = useConstant(function () { return motion(as); });\n    var context = React.useContext(ReorderContext);\n    var point = {\n        x: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.x),\n        y: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.y),\n    };\n    var zIndex = useTransform([point.x, point.y], function (_a) {\n        var _b = tslib.__read(_a, 2), latestX = _b[0], latestY = _b[1];\n        return latestX || latestY ? 1 : \"unset\";\n    });\n    var measuredLayout = React.useRef(null);\n    heyListen.invariant(Boolean(context), \"Reorder.Item must be a child of Reorder.Group\");\n    var _d = context, axis = _d.axis, registerItem = _d.registerItem, updateOrder = _d.updateOrder;\n    React.useEffect(function () {\n        registerItem(value, measuredLayout.current);\n    }, [context]);\n    return (React__namespace.createElement(Component, tslib.__assign({ drag: axis }, props, { dragSnapToOrigin: true, style: tslib.__assign(tslib.__assign({}, style), { x: point.x, y: point.y, zIndex: zIndex }), layout: layout, onDrag: function (event, gesturePoint) {\n            var velocity = gesturePoint.velocity;\n            velocity[axis] &&\n                updateOrder(value, point[axis].get(), velocity[axis]);\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, gesturePoint);\n        }, onLayoutMeasure: function (measured) {\n            measuredLayout.current = measured;\n        }, ref: externalRef }), children));\n}\nvar Item = React.forwardRef(ReorderItem);\n\nvar Reorder = {\n    Group: Group,\n    Item: Item,\n};\n\n/**\n * @public\n */\nvar domAnimation = tslib.__assign(tslib.__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\n/**\n * @public\n */\nvar domMax = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\n/**\n * Combine multiple motion values into a new one using a string template literal.\n *\n * ```jsx\n * import {\n *   motion,\n *   useSpring,\n *   useMotionValue,\n *   useMotionTemplate\n * } from \"framer-motion\"\n *\n * function Component() {\n *   const shadowX = useSpring(0)\n *   const shadowY = useMotionValue(0)\n *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`\n *\n *   return <motion.div style={{ filter: shadow }} />\n * }\n * ```\n *\n * @public\n */\nfunction useMotionTemplate(fragments) {\n    var values = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        values[_i - 1] = arguments[_i];\n    }\n    /**\n     * Create a function that will build a string from the latest motion values.\n     */\n    var numFragments = fragments.length;\n    function buildValue() {\n        var output = \"\";\n        for (var i = 0; i < numFragments; i++) {\n            output += fragments[i];\n            var value = values[i];\n            if (value)\n                output += values[i].get();\n        }\n        return output;\n    }\n    return useCombineMotionValues(values, buildValue);\n}\n\n/**\n * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.\n *\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\n * to another `MotionValue`.\n *\n * @remarks\n *\n * ```jsx\n * const x = useSpring(0, { stiffness: 300 })\n * const y = useSpring(x, { damping: 10 })\n * ```\n *\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.\n * @param springConfig - Configuration options for the spring.\n * @returns `MotionValue`\n *\n * @public\n */\nfunction useSpring(source, config) {\n    if (config === void 0) { config = {}; }\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    var activeSpringAnimation = React.useRef(null);\n    var value = useMotionValue(isMotionValue(source) ? source.get() : source);\n    React.useMemo(function () {\n        return value.attach(function (v, set) {\n            /**\n             * A more hollistic approach to this might be to use isStatic to fix VisualElement animations\n             * at that level, but this will work for now\n             */\n            if (isStatic)\n                return set(v);\n            if (activeSpringAnimation.current) {\n                activeSpringAnimation.current.stop();\n            }\n            activeSpringAnimation.current = popmotion.animate(tslib.__assign(tslib.__assign({ from: value.get(), to: v, velocity: value.getVelocity() }, config), { onUpdate: set }));\n            return value.get();\n        });\n    }, [JSON.stringify(config)]);\n    useOnChange(source, function (v) { return value.set(parseFloat(v)); });\n    return value;\n}\n\n/**\n * Creates a `MotionValue` that updates when the velocity of the provided `MotionValue` changes.\n *\n * ```javascript\n * const x = useMotionValue(0)\n * const xVelocity = useVelocity(x)\n * const xAcceleration = useVelocity(xVelocity)\n * ```\n *\n * @public\n */\nfunction useVelocity(value) {\n    var velocity = useMotionValue(value.getVelocity());\n    React.useEffect(function () {\n        return value.velocityUpdateSubscribers.add(function (newVelocity) {\n            velocity.set(newVelocity);\n        });\n    }, [value]);\n    return velocity;\n}\n\nvar createScrollMotionValues = function () { return ({\n    scrollX: motionValue(0),\n    scrollY: motionValue(0),\n    scrollXProgress: motionValue(0),\n    scrollYProgress: motionValue(0),\n}); };\nfunction useScroll(_a) {\n    if (_a === void 0) { _a = {}; }\n    var container = _a.container, target = _a.target, options = tslib.__rest(_a, [\"container\", \"target\"]);\n    var values = useConstant(createScrollMotionValues);\n    useIsomorphicLayoutEffect(function () {\n        return dom.scroll(function (_a) {\n            var x = _a.x, y = _a.y;\n            values.scrollX.set(x.current);\n            values.scrollXProgress.set(x.progress);\n            values.scrollY.set(y.current);\n            values.scrollYProgress.set(y.progress);\n        }, tslib.__assign(tslib.__assign({}, options), { container: (container === null || container === void 0 ? void 0 : container.current) || undefined, target: (target === null || target === void 0 ? void 0 : target.current) || undefined }));\n    }, []);\n    return values;\n}\n\nfunction useElementScroll(ref) {\n    warnOnce(false, \"useElementScroll is deprecated. Convert to useScroll({ container: ref }).\");\n    return useScroll({ container: ref });\n}\n\nfunction useViewportScroll() {\n    warnOnce(false, \"useViewportScroll is deprecated. Convert to useScroll().\");\n    return useScroll();\n}\n\nvar getCurrentTime = typeof performance !== \"undefined\"\n    ? function () { return performance.now(); }\n    : function () { return Date.now(); };\nfunction useAnimationFrame(callback) {\n    var initialTimestamp = useConstant(getCurrentTime);\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    React.useEffect(function () {\n        if (isStatic)\n            return;\n        var provideTimeSinceStart = function (_a) {\n            var timestamp = _a.timestamp;\n            callback(timestamp - initialTimestamp);\n        };\n        sync__default[\"default\"].update(provideTimeSinceStart, true);\n        return function () { return sync.cancelSync.update(provideTimeSinceStart); };\n    }, [callback]);\n}\n\nfunction useTime() {\n    var time = useMotionValue(0);\n    useAnimationFrame(function (t) { return time.set(t); });\n    return time;\n}\n\n/**\n * @public\n */\nfunction animationControls() {\n    /**\n     * Track whether the host component has mounted.\n     */\n    var hasMounted = false;\n    /**\n     * Pending animations that are started before a component is mounted.\n     * TODO: Remove this as animations should only run in effects\n     */\n    var pendingAnimations = [];\n    /**\n     * A collection of linked component animation controls.\n     */\n    var subscribers = new Set();\n    var controls = {\n        subscribe: function (visualElement) {\n            subscribers.add(visualElement);\n            return function () { return void subscribers.delete(visualElement); };\n        },\n        start: function (definition, transitionOverride) {\n            /**\n             * TODO: We only perform this hasMounted check because in Framer we used to\n             * encourage the ability to start an animation within the render phase. This\n             * isn't behaviour concurrent-safe so when we make Framer concurrent-safe\n             * we can ditch this.\n             */\n            if (hasMounted) {\n                var animations_1 = [];\n                subscribers.forEach(function (visualElement) {\n                    animations_1.push(animateVisualElement(visualElement, definition, {\n                        transitionOverride: transitionOverride,\n                    }));\n                });\n                return Promise.all(animations_1);\n            }\n            else {\n                return new Promise(function (resolve) {\n                    pendingAnimations.push({\n                        animation: [definition, transitionOverride],\n                        resolve: resolve,\n                    });\n                });\n            }\n        },\n        set: function (definition) {\n            heyListen.invariant(hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            return subscribers.forEach(function (visualElement) {\n                setValues(visualElement, definition);\n            });\n        },\n        stop: function () {\n            subscribers.forEach(function (visualElement) {\n                stopAnimation(visualElement);\n            });\n        },\n        mount: function () {\n            hasMounted = true;\n            pendingAnimations.forEach(function (_a) {\n                var animation = _a.animation, resolve = _a.resolve;\n                controls.start.apply(controls, tslib.__spreadArray([], tslib.__read(animation), false)).then(resolve);\n            });\n            return function () {\n                hasMounted = false;\n                controls.stop();\n            };\n        },\n    };\n    return controls;\n}\n\n/**\n * Creates `AnimationControls`, which can be used to manually start, stop\n * and sequence animations on one or more components.\n *\n * The returned `AnimationControls` should be passed to the `animate` property\n * of the components you want to animate.\n *\n * These components can then be animated with the `start` method.\n *\n * ```jsx\n * import * as React from 'react'\n * import { motion, useAnimation } from 'framer-motion'\n *\n * export function MyComponent(props) {\n *    const controls = useAnimation()\n *\n *    controls.start({\n *        x: 100,\n *        transition: { duration: 0.5 },\n *    })\n *\n *    return <motion.div animate={controls} />\n * }\n * ```\n *\n * @returns Animation controller with `start` and `stop` methods\n *\n * @public\n */\nfunction useAnimationControls() {\n    var controls = useConstant(animationControls);\n    React.useEffect(controls.mount, []);\n    return controls;\n}\nvar useAnimation = useAnimationControls;\n\n/**\n * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.\n *\n * An index value can be passed to the returned `cycle` function to cycle to a specific index.\n *\n * ```jsx\n * import * as React from \"react\"\n * import { motion, useCycle } from \"framer-motion\"\n *\n * export const MyComponent = () => {\n *   const [x, cycleX] = useCycle(0, 50, 100)\n *\n *   return (\n *     <motion.div\n *       animate={{ x: x }}\n *       onTap={() => cycleX()}\n *      />\n *    )\n * }\n * ```\n *\n * @param items - items to cycle through\n * @returns [currentState, cycleState]\n *\n * @public\n */\nfunction useCycle() {\n    var items = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        items[_i] = arguments[_i];\n    }\n    var index = React.useRef(0);\n    var _a = tslib.__read(React.useState(items[index.current]), 2), item = _a[0], setItem = _a[1];\n    var runCycle = React.useCallback(function (next) {\n        index.current =\n            typeof next !== \"number\"\n                ? popmotion.wrap(0, items.length, index.current + 1)\n                : next;\n        setItem(items[index.current]);\n    }, tslib.__spreadArray([items.length], tslib.__read(items), false));\n    return [item, runCycle];\n}\n\nfunction useInView(ref, _a) {\n    var _b = _a === void 0 ? {} : _a, root = _b.root, margin = _b.margin, amount = _b.amount, _c = _b.once, once = _c === void 0 ? false : _c;\n    var _d = tslib.__read(React.useState(false), 2), isInView = _d[0], setInView = _d[1];\n    React.useEffect(function () {\n        var _a;\n        if (!ref.current || (once && isInView))\n            return;\n        var onEnter = function () {\n            setInView(true);\n            return once ? undefined : function () { return setInView(false); };\n        };\n        var options = {\n            root: (_a = root === null || root === void 0 ? void 0 : root.current) !== null && _a !== void 0 ? _a : undefined,\n            margin: margin,\n            amount: amount === \"some\" ? \"any\" : amount,\n        };\n        return dom.inView(ref.current, onEnter, options);\n    }, [root, ref, margin, once]);\n    return isInView;\n}\n\n/**\n * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nvar DragControls = /** @class */ (function () {\n    function DragControls() {\n        this.componentControls = new Set();\n    }\n    /**\n     * Subscribe a component's internal `VisualElementDragControls` to the user-facing API.\n     *\n     * @internal\n     */\n    DragControls.prototype.subscribe = function (controls) {\n        var _this = this;\n        this.componentControls.add(controls);\n        return function () { return _this.componentControls.delete(controls); };\n    };\n    /**\n     * Start a drag gesture on every `motion` component that has this set of drag controls\n     * passed into it via the `dragControls` prop.\n     *\n     * ```jsx\n     * dragControls.start(e, {\n     *   snapToCursor: true\n     * })\n     * ```\n     *\n     * @param event - PointerEvent\n     * @param options - Options\n     *\n     * @public\n     */\n    DragControls.prototype.start = function (event, options) {\n        this.componentControls.forEach(function (controls) {\n            controls.start(event.nativeEvent || event, options);\n        });\n    };\n    return DragControls;\n}());\nvar createDragControls = function () { return new DragControls(); };\n/**\n * Usually, dragging is initiated by pressing down on a `motion` component with a `drag` prop\n * and moving it. For some use-cases, for instance clicking at an arbitrary point on a video scrubber, we\n * might want to initiate that dragging from a different component than the draggable one.\n *\n * By creating a `dragControls` using the `useDragControls` hook, we can pass this into\n * the draggable component's `dragControls` prop. It exposes a `start` method\n * that can start dragging from pointer events on other components.\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nfunction useDragControls() {\n    return useConstant(createDragControls);\n}\n\nfunction useInstantLayoutTransition() {\n    return startTransition;\n}\nfunction startTransition(cb) {\n    if (!rootProjectionNode.current)\n        return;\n    rootProjectionNode.current.isUpdating = false;\n    rootProjectionNode.current.blockUpdate();\n    cb === null || cb === void 0 ? void 0 : cb();\n}\n\nfunction useInstantTransition() {\n    var _a = tslib.__read(useForceUpdate(), 2), forceUpdate = _a[0], forcedRenderCount = _a[1];\n    var startInstantLayoutTransition = useInstantLayoutTransition();\n    React.useEffect(function () {\n        /**\n         * Unblock after two animation frames, otherwise this will unblock too soon.\n         */\n        sync__default[\"default\"].postRender(function () {\n            return sync__default[\"default\"].postRender(function () { return (instantAnimationState.current = false); });\n        });\n    }, [forcedRenderCount]);\n    return function (callback) {\n        startInstantLayoutTransition(function () {\n            instantAnimationState.current = true;\n            forceUpdate();\n            callback();\n        });\n    };\n}\n\nfunction useResetProjection() {\n    var reset = React__namespace.useCallback(function () {\n        var root = rootProjectionNode.current;\n        if (!root)\n            return;\n        root.resetTree();\n    }, []);\n    return reset;\n}\n\nvar createObject = function () { return ({}); };\nvar stateVisualElement = visualElement({\n    build: function () { },\n    measureViewportBox: createBox,\n    resetTransform: function () { },\n    restoreTransform: function () { },\n    removeValueFromRenderState: function () { },\n    render: function () { },\n    scrapeMotionValuesFromProps: createObject,\n    readValueFromInstance: function (_state, key, options) {\n        return options.initialState[key] || 0;\n    },\n    makeTargetAnimatable: function (element, _a) {\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = tslib.__rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        checkTargetForNewValues(element, target, origin);\n        return tslib.__assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n});\nvar useVisualState = makeUseVisualState({\n    scrapeMotionValuesFromProps: createObject,\n    createRenderState: createObject,\n});\n/**\n * This is not an officially supported API and may be removed\n * on any version.\n */\nfunction useAnimatedState(initialState) {\n    var _a = tslib.__read(React.useState(initialState), 2), animationState = _a[0], setAnimationState = _a[1];\n    var visualState = useVisualState({}, false);\n    var element = useConstant(function () {\n        return stateVisualElement({ props: {}, visualState: visualState }, { initialState: initialState });\n    });\n    React.useEffect(function () {\n        element.mount({});\n        return element.unmount;\n    }, [element]);\n    React.useEffect(function () {\n        element.setProps({\n            onUpdate: function (v) {\n                setAnimationState(tslib.__assign({}, v));\n            },\n        });\n    }, [setAnimationState, element]);\n    var startAnimation = useConstant(function () { return function (animationDefinition) {\n        return animateVisualElement(element, animationDefinition);\n    }; });\n    return [animationState, startAnimation];\n}\n\n// Keep things reasonable and avoid scale: Infinity. In practise we might need\n// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]\n// to simply hide content at unreasonable scales.\nvar maxScale = 100000;\nvar invertScale = function (scale) {\n    return scale > 0.001 ? 1 / scale : maxScale;\n};\nvar hasWarned = false;\n/**\n * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse\n * of their respective parent scales.\n *\n * This is useful for undoing the distortion of content when scaling a parent component.\n *\n * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.\n * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output\n * of those instead.\n *\n * ```jsx\n * const MyComponent = () => {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <motion.div style={{ scaleX, scaleY }} />\n * }\n * ```\n *\n * @deprecated\n */\nfunction useInvertedScale(scale) {\n    var parentScaleX = useMotionValue(1);\n    var parentScaleY = useMotionValue(1);\n    var visualElement = useVisualElementContext();\n    heyListen.invariant(!!(scale || visualElement), \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\");\n    heyListen.warning(hasWarned, \"useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead.\");\n    hasWarned = true;\n    if (scale) {\n        parentScaleX = scale.scaleX || parentScaleX;\n        parentScaleY = scale.scaleY || parentScaleY;\n    }\n    else if (visualElement) {\n        parentScaleX = visualElement.getValue(\"scaleX\", 1);\n        parentScaleY = visualElement.getValue(\"scaleY\", 1);\n    }\n    var scaleX = useTransform(parentScaleX, invertScale);\n    var scaleY = useTransform(parentScaleY, invertScale);\n    return { scaleX: scaleX, scaleY: scaleY };\n}\n\nexports.AnimatePresence = AnimatePresence;\nexports.AnimateSharedLayout = AnimateSharedLayout;\nexports.DeprecatedLayoutGroupContext = DeprecatedLayoutGroupContext;\nexports.DragControls = DragControls;\nexports.FlatTree = FlatTree;\nexports.LayoutGroup = LayoutGroup;\nexports.LayoutGroupContext = LayoutGroupContext;\nexports.LazyMotion = LazyMotion;\nexports.MotionConfig = MotionConfig;\nexports.MotionConfigContext = MotionConfigContext;\nexports.MotionContext = MotionContext;\nexports.MotionValue = MotionValue;\nexports.PresenceContext = PresenceContext;\nexports.Reorder = Reorder;\nexports.SwitchLayoutGroupContext = SwitchLayoutGroupContext;\nexports.addPointerEvent = addPointerEvent;\nexports.addScaleCorrector = addScaleCorrector;\nexports.animate = animate;\nexports.animateVisualElement = animateVisualElement;\nexports.animationControls = animationControls;\nexports.animations = animations;\nexports.calcLength = calcLength;\nexports.checkTargetForNewValues = checkTargetForNewValues;\nexports.createBox = createBox;\nexports.createDomMotionComponent = createDomMotionComponent;\nexports.createMotionComponent = createMotionComponent;\nexports.domAnimation = domAnimation;\nexports.domMax = domMax;\nexports.filterProps = filterProps;\nexports.isBrowser = isBrowser;\nexports.isDragActive = isDragActive;\nexports.isMotionValue = isMotionValue;\nexports.isValidMotionProp = isValidMotionProp;\nexports.m = m;\nexports.makeUseVisualState = makeUseVisualState;\nexports.motion = motion;\nexports.motionValue = motionValue;\nexports.resolveMotionValue = resolveMotionValue;\nexports.transform = transform;\nexports.useAnimation = useAnimation;\nexports.useAnimationControls = useAnimationControls;\nexports.useAnimationFrame = useAnimationFrame;\nexports.useCycle = useCycle;\nexports.useDeprecatedAnimatedState = useAnimatedState;\nexports.useDeprecatedInvertedScale = useInvertedScale;\nexports.useDomEvent = useDomEvent;\nexports.useDragControls = useDragControls;\nexports.useElementScroll = useElementScroll;\nexports.useForceUpdate = useForceUpdate;\nexports.useInView = useInView;\nexports.useInstantLayoutTransition = useInstantLayoutTransition;\nexports.useInstantTransition = useInstantTransition;\nexports.useIsPresent = useIsPresent;\nexports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;\nexports.useMotionTemplate = useMotionTemplate;\nexports.useMotionValue = useMotionValue;\nexports.usePresence = usePresence;\nexports.useReducedMotion = useReducedMotion;\nexports.useReducedMotionConfig = useReducedMotionConfig;\nexports.useResetProjection = useResetProjection;\nexports.useScroll = useScroll;\nexports.useSpring = useSpring;\nexports.useTime = useTime;\nexports.useTransform = useTransform;\nexports.useUnmountEffect = useUnmountEffect;\nexports.useVelocity = useVelocity;\nexports.useViewportScroll = useViewportScroll;\nexports.useVisualElementContext = useVisualElementContext;\nexports.visualElement = visualElement;\nexports.wrapHandler = wrapHandler;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst defaultTimestep = (1 / 60) * 1000;\nconst getCurrentTime = typeof performance !== \"undefined\"\n    ? () => performance.now()\n    : () => Date.now();\nconst onNextFrame = typeof window !== \"undefined\"\n    ? (callback) => window.requestAnimationFrame(callback)\n    : (callback) => setTimeout(() => callback(getCurrentTime()), defaultTimestep);\n\nfunction createRenderStep(runNextFrame) {\n    let toRun = [];\n    let toRunNextFrame = [];\n    let numToRun = 0;\n    let isProcessing = false;\n    let flushNextFrame = false;\n    const toKeepAlive = new WeakSet();\n    const step = {\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        cancel: (callback) => {\n            const index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        process: (frameData) => {\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [toRun, toRunNextFrame] = [toRunNextFrame, toRun];\n            toRunNextFrame.length = 0;\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (let i = 0; i < numToRun; i++) {\n                    const callback = toRun[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}\n\nconst maxElapsed = 40;\nlet useDefaultElapsed = true;\nlet runNextFrame = false;\nlet isProcessing = false;\nconst frame = {\n    delta: 0,\n    timestamp: 0,\n};\nconst stepsOrder = [\n    \"read\",\n    \"update\",\n    \"preRender\",\n    \"render\",\n    \"postRender\",\n];\nconst steps = stepsOrder.reduce((acc, key) => {\n    acc[key] = createRenderStep(() => (runNextFrame = true));\n    return acc;\n}, {});\nconst sync = stepsOrder.reduce((acc, key) => {\n    const step = steps[key];\n    acc[key] = (process, keepAlive = false, immediate = false) => {\n        if (!runNextFrame)\n            startLoop();\n        return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n}, {});\nconst cancelSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = steps[key].cancel;\n    return acc;\n}, {});\nconst flushSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = () => steps[key].process(frame);\n    return acc;\n}, {});\nconst processStep = (stepId) => steps[stepId].process(frame);\nconst processFrame = (timestamp) => {\n    runNextFrame = false;\n    frame.delta = useDefaultElapsed\n        ? defaultTimestep\n        : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n    frame.timestamp = timestamp;\n    isProcessing = true;\n    stepsOrder.forEach(processStep);\n    isProcessing = false;\n    if (runNextFrame) {\n        useDefaultElapsed = false;\n        onNextFrame(processFrame);\n    }\n};\nconst startLoop = () => {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!isProcessing)\n        onNextFrame(processFrame);\n};\nconst getFrameData = () => frame;\n\nexports.cancelSync = cancelSync;\nexports.default = sync;\nexports.flushSync = flushSync;\nexports.getFrameData = getFrameData;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nvar heyListen = require('hey-listen');\nvar styleValueTypes = require('style-value-types');\nvar sync = require('framesync');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nvar sync__default = /*#__PURE__*/_interopDefaultLegacy(sync);\n\nconst clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nconst safeMin = 0.001;\nconst minDuration = 0.01;\nconst maxDuration = 10.0;\nconst minDamping = 0.05;\nconst maxDamping = 1;\nfunction findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1, }) {\n    let envelope;\n    let derivative;\n    heyListen.warning(duration <= maxDuration * 1000, \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\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    }\n    else {\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 = duration * 1000;\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: 100,\n            damping: 10,\n            duration,\n        };\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}\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 = Object.assign({ velocity: 0.0, stiffness: 100, damping: 10, mass: 1.0, isResolvedFromDuration: false }, options);\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = Object.assign(Object.assign(Object.assign({}, springOptions), derived), { velocity: 0.0, mass: 1.0 });\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring(_a) {\n    var { from = 0.0, to = 1.0, restSpeed = 2, restDelta } = _a, options = tslib.__rest(_a, [\"from\", \"to\", \"restSpeed\", \"restDelta\"]);\n    const state = { done: false, value: from };\n    let { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    let resolveSpring = zero;\n    let resolveVelocity = zero;\n    function createSpring() {\n        const initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n        const initialDelta = to - from;\n        const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n        const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        if (restDelta === undefined) {\n            restDelta = Math.min(Math.abs(to - from) / 100, 0.4);\n        }\n        if (dampingRatio < 1) {\n            const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (to -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq) *\n                            Math.sin(angularFreq * t) +\n                            initialDelta * Math.cos(angularFreq * t)));\n            };\n            resolveVelocity = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (dampingRatio *\n                    undampedAngularFreq *\n                    envelope *\n                    ((Math.sin(angularFreq * t) *\n                        (initialVelocity +\n                            dampingRatio *\n                                undampedAngularFreq *\n                                initialDelta)) /\n                        angularFreq +\n                        initialDelta * Math.cos(angularFreq * t)) -\n                    envelope *\n                        (Math.cos(angularFreq * t) *\n                            (initialVelocity +\n                                dampingRatio *\n                                    undampedAngularFreq *\n                                    initialDelta) -\n                            angularFreq *\n                                initialDelta *\n                                Math.sin(angularFreq * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            resolveSpring = (t) => to -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta +\n                        (initialVelocity + undampedAngularFreq * initialDelta) *\n                            t);\n        }\n        else {\n            const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const freqForT = Math.min(dampedAngularFreq * t, 300);\n                return (to -\n                    (envelope *\n                        ((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) *\n                            Math.sinh(freqForT) +\n                            dampedAngularFreq *\n                                initialDelta *\n                                Math.cosh(freqForT))) /\n                        dampedAngularFreq);\n            };\n        }\n    }\n    createSpring();\n    return {\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                const currentVelocity = resolveVelocity(t) * 1000;\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(to - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? to : current;\n            return state;\n        },\n        flipTarget: () => {\n            velocity = -velocity;\n            [from, to] = [to, from];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = (a, b) => typeof a === \"string\" || typeof b === \"string\";\nconst zero = (_t) => 0;\n\nconst progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nconst mix = (from, to, progress) => -progress * from + progress * to + from;\n\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\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    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : 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\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const toExpo = to * to;\n    return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\nconst colorTypes = [styleValueTypes.hex, styleValueTypes.rgba, styleValueTypes.hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nconst notAnimatable = (color) => `'${color}' is not an animatable color. Use the equivalent color code instead.`;\nconst mixColor = (from, to) => {\n    let fromColorType = getColorType(from);\n    let toColorType = getColorType(to);\n    heyListen.invariant(!!fromColorType, notAnimatable(from));\n    heyListen.invariant(!!toColorType, notAnimatable(to));\n    let fromColor = fromColorType.parse(from);\n    let toColor = toColorType.parse(to);\n    if (fromColorType === styleValueTypes.hsla) {\n        fromColor = hslaToRgba(fromColor);\n        fromColorType = styleValueTypes.rgba;\n    }\n    if (toColorType === styleValueTypes.hsla) {\n        toColor = hslaToRgba(toColor);\n        toColorType = styleValueTypes.rgba;\n    }\n    const blended = Object.assign({}, fromColor);\n    return (v) => {\n        for (const key in blended) {\n            if (key !== \"alpha\") {\n                blended[key] = mixLinearColor(fromColor[key], toColor[key], v);\n            }\n        }\n        blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n        return fromColorType.transform(blended);\n    };\n};\n\nconst zeroPoint = {\n    x: 0,\n    y: 0,\n    z: 0\n};\nconst isNum = (v) => typeof v === 'number';\n\nconst combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nfunction getMixer(origin, target) {\n    if (isNum(origin)) {\n        return (v) => mix(origin, target, v);\n    }\n    else if (styleValueTypes.color.test(origin)) {\n        return mixColor(origin, target);\n    }\n    else {\n        return 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(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 = Object.assign(Object.assign({}, origin), target);\n    const blendValue = {};\n    for (const key in output) {\n        if (origin[key] !== undefined && target[key] !== undefined) {\n            blendValue[key] = getMixer(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};\nfunction analyse(value) {\n    const parsed = styleValueTypes.complex.parse(value);\n    const numValues = parsed.length;\n    let numNumbers = 0;\n    let numRGB = 0;\n    let numHSL = 0;\n    for (let i = 0; i < numValues; i++) {\n        if (numNumbers || typeof parsed[i] === \"number\") {\n            numNumbers++;\n        }\n        else {\n            if (parsed[i].hue !== undefined) {\n                numHSL++;\n            }\n            else {\n                numRGB++;\n            }\n        }\n    }\n    return { parsed, numNumbers, numRGB, numHSL };\n}\nconst mixComplex = (origin, target) => {\n    const template = styleValueTypes.complex.createTransformer(target);\n    const originStats = analyse(origin);\n    const targetStats = analyse(target);\n    const canInterpolate = originStats.numHSL === targetStats.numHSL &&\n        originStats.numRGB === targetStats.numRGB &&\n        originStats.numNumbers >= targetStats.numNumbers;\n    if (canInterpolate) {\n        return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n    }\n    else {\n        heyListen.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 (p) => `${p > 0 ? target : origin}`;\n    }\n};\n\nconst mixNumber = (from, to) => (p) => mix(from, to, p);\nfunction detectMixerFactory(v) {\n    if (typeof v === 'number') {\n        return mixNumber;\n    }\n    else if (typeof v === 'string') {\n        if (styleValueTypes.color.test(v)) {\n            return mixColor;\n        }\n        else {\n            return mixComplex;\n        }\n    }\n    else if (Array.isArray(v)) {\n        return mixArray;\n    }\n    else if (typeof v === 'object') {\n        return mixObject;\n    }\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] : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\nfunction fastInterpolate([from, to], [mixer]) {\n    return (v) => mixer(progress(from, to, v));\n}\nfunction slowInterpolate(input, mixers) {\n    const inputLength = input.length;\n    const lastInputIndex = inputLength - 1;\n    return (v) => {\n        let mixerIndex = 0;\n        let foundMixerIndex = false;\n        if (v <= input[0]) {\n            foundMixerIndex = true;\n        }\n        else if (v >= input[lastInputIndex]) {\n            mixerIndex = lastInputIndex - 1;\n            foundMixerIndex = true;\n        }\n        if (!foundMixerIndex) {\n            let i = 1;\n            for (; i < inputLength; i++) {\n                if (input[i] > v || i === lastInputIndex) {\n                    break;\n                }\n            }\n            mixerIndex = i - 1;\n        }\n        const progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n        return mixers[mixerIndex](progressInRange);\n    };\n}\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    heyListen.invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n    heyListen.invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n    if (input[0] > input[inputLength - 1]) {\n        input = [].concat(input);\n        output = [].concat(output);\n        input.reverse();\n        output.reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const interpolator = inputLength === 2\n        ? fastInterpolate(input, mixers)\n        : slowInterpolate(input, mixers);\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nconst reverseEasing = easing => p => 1 - easing(1 - p);\nconst mirrorEasing = easing => p => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\nconst createExpoIn = (power) => p => Math.pow(p, power);\nconst createBackIn = (power) => p => p * p * ((power + 1) * p - power);\nconst createAnticipate = (power) => {\n    const backEasing = createBackIn(power);\n    return p => (p *= 2) < 1\n        ? 0.5 * backEasing(p)\n        : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n};\n\nconst DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nconst BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nconst BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nconst BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nconst linear = p => p;\nconst easeIn = createExpoIn(2);\nconst easeOut = reverseEasing(easeIn);\nconst easeInOut = mirrorEasing(easeIn);\nconst circIn = p => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\nconst backIn = createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nconst backOut = reverseEasing(backIn);\nconst backInOut = mirrorEasing(backIn);\nconst anticipate = createAnticipate(DEFAULT_OVERSHOOT_STRENGTH);\nconst ca = 4356.0 / 361.0;\nconst cb = 35442.0 / 1805.0;\nconst cc = 16061.0 / 1805.0;\nconst bounceOut = (p) => {\n    if (p === 1 || p === 0)\n        return p;\n    const p2 = p * p;\n    return p < BOUNCE_FIRST_THRESHOLD\n        ? 7.5625 * p2\n        : p < BOUNCE_SECOND_THRESHOLD\n            ? 9.075 * p2 - 9.9 * p + 3.4\n            : p < BOUNCE_THIRD_THRESHOLD\n                ? ca * p2 - cb * p + cc\n                : 10.8 * p * p - 20.52 * p + 10.72;\n};\nconst bounceIn = reverseEasing(bounceOut);\nconst bounceInOut = (p) => p < 0.5\n    ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0))\n    : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction defaultOffset(values) {\n    const numValues = values.length;\n    return values.map((_value, i) => i !== 0 ? i / (numValues - 1) : 0);\n}\nfunction convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\nfunction keyframes({ from = 0, to = 1, ease, offset, duration = 300, }) {\n    const state = { done: false, value: from };\n    const values = Array.isArray(to) ? to : [from, to];\n    const times = convertOffsetToTimes(offset && offset.length === values.length\n        ? offset\n        : defaultOffset(values), duration);\n    function createInterpolator() {\n        return interpolate(times, values, {\n            ease: Array.isArray(ease) ? ease : defaultEasing(values, ease),\n        });\n    }\n    let interpolator = createInterpolator();\n    return {\n        next: (t) => {\n            state.value = interpolator(t);\n            state.done = t >= duration;\n            return state;\n        },\n        flipTarget: () => {\n            values.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nfunction decay({ velocity = 0, from = 0, power = 0.8, timeConstant = 350, restDelta = 0.5, modifyTarget, }) {\n    const state = { done: false, value: from };\n    let amplitude = power * velocity;\n    const ideal = from + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    if (target !== ideal)\n        amplitude = target - from;\n    return {\n        next: (t) => {\n            const delta = -amplitude * Math.exp(-t / timeConstant);\n            state.done = !(delta > restDelta || delta < -restDelta);\n            state.value = state.done ? target : target + delta;\n            return state;\n        },\n        flipTarget: () => { },\n    };\n}\n\nconst types = { keyframes, spring, decay };\nfunction detectAnimationFromOptions(config) {\n    if (Array.isArray(config.to)) {\n        return keyframes;\n    }\n    else if (types[config.type]) {\n        return types[config.type];\n    }\n    const keys = new Set(Object.keys(config));\n    if (keys.has(\"ease\") ||\n        (keys.has(\"duration\") && !keys.has(\"dampingRatio\"))) {\n        return keyframes;\n    }\n    else if (keys.has(\"dampingRatio\") ||\n        keys.has(\"stiffness\") ||\n        keys.has(\"mass\") ||\n        keys.has(\"damping\") ||\n        keys.has(\"restSpeed\") ||\n        keys.has(\"restDelta\")) {\n        return spring;\n    }\n    return keyframes;\n}\n\nfunction loopElapsed(elapsed, duration, delay = 0) {\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration, delay = 0, isForwardPlayback = true) {\n    return isForwardPlayback\n        ? loopElapsed(duration + -elapsed, duration, delay)\n        : duration - (elapsed - duration) + delay;\n}\nfunction hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {\n    return isForwardPlayback ? elapsed >= duration + delay : elapsed <= -delay;\n}\n\nconst framesync = (update) => {\n    const passTimestamp = ({ delta }) => update(delta);\n    return {\n        start: () => sync__default[\"default\"].update(passTimestamp, true),\n        stop: () => sync.cancelSync.update(passTimestamp),\n    };\n};\nfunction animate(_a) {\n    var _b, _c;\n    var { from, autoplay = true, driver = framesync, elapsed = 0, repeat: repeatMax = 0, repeatType = \"loop\", repeatDelay = 0, onPlay, onStop, onComplete, onRepeat, onUpdate } = _a, options = tslib.__rest(_a, [\"from\", \"autoplay\", \"driver\", \"elapsed\", \"repeat\", \"repeatType\", \"repeatDelay\", \"onPlay\", \"onStop\", \"onComplete\", \"onRepeat\", \"onUpdate\"]);\n    let { to } = options;\n    let driverControls;\n    let repeatCount = 0;\n    let computedDuration = options.duration;\n    let latest;\n    let isComplete = false;\n    let isForwardPlayback = true;\n    let interpolateFromNumber;\n    const animator = detectAnimationFromOptions(options);\n    if ((_c = (_b = animator).needsInterpolation) === null || _c === void 0 ? void 0 : _c.call(_b, from, to)) {\n        interpolateFromNumber = interpolate([0, 100], [from, to], {\n            clamp: false,\n        });\n        from = 0;\n        to = 100;\n    }\n    const animation = animator(Object.assign(Object.assign({}, options), { from, to }));\n    function repeat() {\n        repeatCount++;\n        if (repeatType === \"reverse\") {\n            isForwardPlayback = repeatCount % 2 === 0;\n            elapsed = reverseElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback);\n        }\n        else {\n            elapsed = loopElapsed(elapsed, computedDuration, repeatDelay);\n            if (repeatType === \"mirror\")\n                animation.flipTarget();\n        }\n        isComplete = false;\n        onRepeat && onRepeat();\n    }\n    function complete() {\n        driverControls.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            const state = animation.next(Math.max(0, elapsed));\n            latest = state.value;\n            if (interpolateFromNumber)\n                latest = interpolateFromNumber(latest);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(latest);\n        if (isComplete) {\n            if (repeatCount === 0)\n                computedDuration !== null && computedDuration !== void 0 ? computedDuration : (computedDuration = elapsed);\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay === null || onPlay === void 0 ? void 0 : onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: () => {\n            onStop === null || onStop === void 0 ? void 0 : onStop();\n            driverControls.stop();\n        },\n    };\n}\n\nfunction velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nfunction inertia({ from = 0, velocity = 0, min, max, power = 0.8, timeConstant = 750, bounceStiffness = 500, bounceDamping = 10, restDelta = 1, modifyTarget, driver, onUpdate, onComplete, onStop, }) {\n    let currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function boundaryNearest(v) {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    }\n    function startAnimation(options) {\n        currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n        currentAnimation = animate(Object.assign(Object.assign({}, options), { driver, onUpdate: (v) => {\n                var _a;\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n                (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n            }, onComplete,\n            onStop }));\n    }\n    function startSpring(options) {\n        startAnimation(Object.assign({ type: \"spring\", stiffness: bounceStiffness, damping: bounceDamping, restDelta }, options));\n    }\n    if (isOutOfBounds(from)) {\n        startSpring({ from, velocity, to: boundaryNearest(from) });\n    }\n    else {\n        let target = power * velocity + from;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        const boundary = boundaryNearest(target);\n        const heading = boundary === min ? -1 : 1;\n        let prev;\n        let current;\n        const checkBoundary = (v) => {\n            prev = current;\n            current = v;\n            velocity = velocityPerSecond(v - prev, sync.getFrameData().delta);\n            if ((heading === 1 && v > boundary) ||\n                (heading === -1 && v < boundary)) {\n                startSpring({ from: v, to: boundary, velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            from,\n            velocity,\n            timeConstant,\n            power,\n            restDelta,\n            modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: () => currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop(),\n    };\n}\n\nconst radiansToDegrees = (radians) => (radians * 180) / Math.PI;\n\nconst angle = (a, b = zeroPoint) => radiansToDegrees(Math.atan2(b.y - a.y, b.x - a.x));\n\nconst applyOffset = (from, to) => {\n    let hasReceivedFrom = true;\n    if (to === undefined) {\n        to = from;\n        hasReceivedFrom = false;\n    }\n    return (v) => {\n        if (hasReceivedFrom) {\n            return v - from + to;\n        }\n        else {\n            from = v;\n            hasReceivedFrom = true;\n            return to;\n        }\n    };\n};\n\nconst identity = (v) => v;\nconst createAttractor = (alterDisplacement = identity) => (constant, origin, v) => {\n    const displacement = origin - v;\n    const springModifiedDisplacement = -(0 - constant + 1) * (0 - alterDisplacement(Math.abs(displacement)));\n    return displacement <= 0\n        ? origin + springModifiedDisplacement\n        : origin - springModifiedDisplacement;\n};\nconst attract = createAttractor();\nconst attractExpo = createAttractor(Math.sqrt);\n\nconst degreesToRadians = (degrees) => (degrees * Math.PI) / 180;\n\nconst isPoint = (point) => point.hasOwnProperty('x') && point.hasOwnProperty('y');\n\nconst isPoint3D = (point) => isPoint(point) && point.hasOwnProperty('z');\n\nconst distance1D = (a, b) => Math.abs(a - b);\nfunction distance(a, b) {\n    if (isNum(a) && isNum(b)) {\n        return distance1D(a, b);\n    }\n    else if (isPoint(a) && isPoint(b)) {\n        const xDelta = distance1D(a.x, b.x);\n        const yDelta = distance1D(a.y, b.y);\n        const zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n    }\n}\n\nconst pointFromVector = (origin, angle, distance) => {\n    angle = degreesToRadians(angle);\n    return {\n        x: distance * Math.cos(angle) + origin.x,\n        y: distance * Math.sin(angle) + origin.y\n    };\n};\n\nconst toDecimal = (num, precision = 2) => {\n    precision = Math.pow(10, precision);\n    return Math.round(num * precision) / precision;\n};\n\nconst smoothFrame = (prevValue, nextValue, duration, smoothing = 0) => toDecimal(prevValue +\n    (duration * (nextValue - prevValue)) / Math.max(smoothing, duration));\n\nconst smooth = (strength = 50) => {\n    let previousValue = 0;\n    let lastUpdated = 0;\n    return (v) => {\n        const currentFramestamp = sync.getFrameData().timestamp;\n        const timeDelta = currentFramestamp !== lastUpdated ? currentFramestamp - lastUpdated : 0;\n        const newValue = timeDelta\n            ? smoothFrame(previousValue, v, timeDelta, strength)\n            : previousValue;\n        lastUpdated = currentFramestamp;\n        previousValue = newValue;\n        return newValue;\n    };\n};\n\nconst snap = (points) => {\n    if (typeof points === 'number') {\n        return (v) => Math.round(v / points) * points;\n    }\n    else {\n        let i = 0;\n        const numPoints = points.length;\n        return (v) => {\n            let lastDistance = Math.abs(points[0] - v);\n            for (i = 1; i < numPoints; i++) {\n                const point = points[i];\n                const distance = Math.abs(point - v);\n                if (distance === 0)\n                    return point;\n                if (distance > lastDistance)\n                    return points[i - 1];\n                if (i === numPoints - 1)\n                    return point;\n                lastDistance = distance;\n            }\n        };\n    }\n};\n\nfunction velocityPerFrame(xps, frameDuration) {\n    return xps / (1000 / frameDuration);\n}\n\nconst wrap = (min, max, v) => {\n    const rangeSize = max - min;\n    return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;\n};\n\nconst a = (a1, a2) => 1.0 - 3.0 * a2 + 3.0 * a1;\nconst b = (a1, a2) => 3.0 * a2 - 6.0 * a1;\nconst c = (a1) => 3.0 * a1;\nconst calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\nconst getSlope = (t, a1, a2) => 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 10;\nfunction binarySubdivide(aX, aA, aB, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = aA + (aB - aA) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - aX;\n        if (currentX > 0.0) {\n            aB = currentT;\n        }\n        else {\n            aA = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nconst newtonIterations = 8;\nconst newtonMinSlope = 0.001;\nfunction newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {\n    for (let i = 0; i < newtonIterations; ++i) {\n        const currentSlope = getSlope(aGuessT, mX1, mX2);\n        if (currentSlope === 0.0) {\n            return aGuessT;\n        }\n        const currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n        aGuessT -= currentX / currentSlope;\n    }\n    return aGuessT;\n}\nconst kSplineTableSize = 11;\nconst kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    if (mX1 === mY1 && mX2 === mY2)\n        return linear;\n    const sampleValues = new Float32Array(kSplineTableSize);\n    for (let i = 0; i < kSplineTableSize; ++i) {\n        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n    }\n    function getTForX(aX) {\n        let intervalStart = 0.0;\n        let currentSample = 1;\n        const lastSample = kSplineTableSize - 1;\n        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += kSampleStepSize;\n        }\n        --currentSample;\n        const dist = (aX - sampleValues[currentSample]) /\n            (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n        const guessForT = intervalStart + dist * kSampleStepSize;\n        const initialSlope = getSlope(guessForT, mX1, mX2);\n        if (initialSlope >= newtonMinSlope) {\n            return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n        }\n        else if (initialSlope === 0.0) {\n            return guessForT;\n        }\n        else {\n            return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n        }\n    }\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nconst steps = (steps, direction = 'end') => (progress) => {\n    progress =\n        direction === 'end' ? Math.min(progress, 0.999) : Math.max(progress, 0.001);\n    const expanded = progress * steps;\n    const rounded = direction === 'end' ? Math.floor(expanded) : Math.ceil(expanded);\n    return clamp(0, 1, rounded / steps);\n};\n\nexports.angle = angle;\nexports.animate = animate;\nexports.anticipate = anticipate;\nexports.applyOffset = applyOffset;\nexports.attract = attract;\nexports.attractExpo = attractExpo;\nexports.backIn = backIn;\nexports.backInOut = backInOut;\nexports.backOut = backOut;\nexports.bounceIn = bounceIn;\nexports.bounceInOut = bounceInOut;\nexports.bounceOut = bounceOut;\nexports.circIn = circIn;\nexports.circInOut = circInOut;\nexports.circOut = circOut;\nexports.clamp = clamp;\nexports.createAnticipate = createAnticipate;\nexports.createAttractor = createAttractor;\nexports.createBackIn = createBackIn;\nexports.createExpoIn = createExpoIn;\nexports.cubicBezier = cubicBezier;\nexports.decay = decay;\nexports.degreesToRadians = degreesToRadians;\nexports.distance = distance;\nexports.easeIn = easeIn;\nexports.easeInOut = easeInOut;\nexports.easeOut = easeOut;\nexports.inertia = inertia;\nexports.interpolate = interpolate;\nexports.isPoint = isPoint;\nexports.isPoint3D = isPoint3D;\nexports.keyframes = keyframes;\nexports.linear = linear;\nexports.mirrorEasing = mirrorEasing;\nexports.mix = mix;\nexports.mixColor = mixColor;\nexports.mixComplex = mixComplex;\nexports.pipe = pipe;\nexports.pointFromVector = pointFromVector;\nexports.progress = progress;\nexports.radiansToDegrees = radiansToDegrees;\nexports.reverseEasing = reverseEasing;\nexports.smooth = smooth;\nexports.smoothFrame = smoothFrame;\nexports.snap = snap;\nexports.spring = spring;\nexports.steps = steps;\nexports.toDecimal = toDecimal;\nexports.velocityPerFrame = velocityPerFrame;\nexports.velocityPerSecond = velocityPerSecond;\nexports.wrap = wrap;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst clamp = (min, max) => (v) => Math.max(Math.min(v, max), min);\nconst sanitize = (v) => (v % 1 ? Number(v.toFixed(5)) : v);\nconst floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nconst colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))/gi;\nconst singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))$/i;\nfunction isString(v) {\n    return typeof v === 'string';\n}\n\nconst number = {\n    test: (v) => typeof v === 'number',\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = Object.assign(Object.assign({}, number), { transform: clamp(0, 1) });\nconst scale = Object.assign(Object.assign({}, number), { default: 1 });\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 = Object.assign(Object.assign({}, percent), { parse: (v) => percent.parse(v) / 100, transform: (v) => percent.transform(v * 100) });\n\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nconst hsla = {\n    test: isColorString('hsl', 'hue'),\n    parse: splitColor('hue', 'saturation', 'lightness'),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return ('hsla(' +\n            Math.round(hue) +\n            ', ' +\n            percent.transform(sanitize(saturation)) +\n            ', ' +\n            percent.transform(sanitize(lightness)) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')');\n    },\n};\n\nconst clampRgbUnit = clamp(0, 255);\nconst rgbUnit = Object.assign(Object.assign({}, number), { transform: (v) => Math.round(clampRgbUnit(v)) });\nconst rgba = {\n    test: isColorString('rgb', 'red'),\n    parse: splitColor('red', 'green', 'blue'),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => 'rgba(' +\n        rgbUnit.transform(red) +\n        ', ' +\n        rgbUnit.transform(green) +\n        ', ' +\n        rgbUnit.transform(blue) +\n        ', ' +\n        sanitize(alpha.transform(alpha$1)) +\n        ')',\n};\n\nfunction parseHex(v) {\n    let r = '';\n    let g = '';\n    let b = '';\n    let a = '';\n    if (v.length > 5) {\n        r = v.substr(1, 2);\n        g = v.substr(3, 2);\n        b = v.substr(5, 2);\n        a = v.substr(7, 2);\n    }\n    else {\n        r = v.substr(1, 1);\n        g = v.substr(2, 1);\n        b = v.substr(3, 1);\n        a = v.substr(4, 1);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString('#'),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty('red')\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nconst colorToken = '${c}';\nconst numberToken = '${n}';\nfunction test(v) {\n    var _a, _b, _c, _d;\n    return (isNaN(v) &&\n        isString(v) &&\n        ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0);\n}\nfunction analyse(v) {\n    if (typeof v === 'number')\n        v = `${v}`;\n    const values = [];\n    let numColors = 0;\n    const colors = v.match(colorRegex);\n    if (colors) {\n        numColors = colors.length;\n        v = v.replace(colorRegex, colorToken);\n        values.push(...colors.map(color.parse));\n    }\n    const numbers = v.match(floatRegex);\n    if (numbers) {\n        v = v.replace(floatRegex, numberToken);\n        values.push(...numbers.map(number.parse));\n    }\n    return { values, numColors, tokenised: v };\n}\nfunction parse(v) {\n    return analyse(v).values;\n}\nfunction createTransformer(v) {\n    const { values, numColors, tokenised } = analyse(v);\n    const numValues = values.length;\n    return (v) => {\n        let output = tokenised;\n        for (let i = 0; i < numValues; i++) {\n            output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === 'number' ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parse(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = { test, parse, createTransformer, getAnimatableNone };\n\nconst maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n    let [name, value] = v.slice(0, -1).split('(');\n    if (name === 'drop-shadow')\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, '');\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + '(' + defaultValue + unit + ')';\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = Object.assign(Object.assign({}, complex), { getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n    } });\n\nexports.alpha = alpha;\nexports.color = color;\nexports.complex = complex;\nexports.degrees = degrees;\nexports.filter = filter;\nexports.hex = hex;\nexports.hsla = hsla;\nexports.number = number;\nexports.percent = percent;\nexports.progressPercentage = progressPercentage;\nexports.px = px;\nexports.rgbUnit = rgbUnit;\nexports.rgba = rgba;\nexports.scale = scale;\nexports.vh = vh;\nexports.vw = vw;\n","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArrayLimit(arr, i) {\n  var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (null != _i) {\n    var _s,\n      _e,\n      _x,\n      _r,\n      _arr = [],\n      _n = !0,\n      _d = !1;\n    try {\n      if (_x = (_i = _i.call(arr)).next, 0 === i) {\n        if (Object(_i) !== _i) return;\n        _n = !1;\n      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);\n    } catch (err) {\n      _d = !0, _e = err;\n    } finally {\n      try {\n        if (!_n && null != _i[\"return\"] && (_r = _i[\"return\"](), Object(_r) !== _r)) return;\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n    return _arr;\n  }\n}\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableRest = require(\"./nonIterableRest.js\");\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\nvar iterableToArray = require(\"./iterableToArray.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\nmodule.exports = _toConsumableArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;"],"names":["reactPropsRegex","fn","cache","arg","undefined","memoize","prop","test","charCodeAt","mapEventPropToEvent","eventProp","substring","toLowerCase","props","children","_props$disableReactTr","disableReactTree","_props$mouseEvent","mouseEvent","onClickAway","_props$touchEvent","touchEvent","movedRef","React","nodeRef","activatedRef","syntheticEventRef","setTimeout","current","handleOwnRef","instance","ReactDOM","handleRef","useForkRef","ref","handleClickAway","useEventCallback","event","insideReactTree","document","documentElement","clientWidth","clientX","clientHeight","clientY","clickedRootScrollbar","insideDOM","composedPath","indexOf","ownerDocument","contains","target","createHandleSynthetic","handlerName","childrenPropsHandler","childrenProps","mappedTouchEvent","doc","handleTouchMove","addEventListener","removeEventListener","mappedMouseEvent","node","_typeof","obj","Symbol","iterator","constructor","prototype","Object","defineProperty","exports","value","_react","nodeInterop","__esModule","default","_getRequireWildcardCache","has","get","newObj","hasPropertyDescriptor","getOwnPropertyDescriptor","key","hasOwnProperty","call","desc","set","_interopRequireWildcard","require","_clsx","_interopRequireDefault","_makeStyles","_overlayContext","WeakMap","cacheBabelInterop","cacheNodeInterop","_slicedToArray","arr","i","Array","isArray","_arrayWithHoles","_i","_s","_e","_x","_r","_arr","_n","_d","next","done","push","length","err","return","_iterableToArrayLimit","o","minLen","_arrayLikeToArray","n","toString","slice","name","from","_unsupportedIterableToArray","TypeError","_nonIterableRest","len","arr2","_default","overlayProps","useContext","classes","css","background","theme","_theme$palette$backgr","_theme$palette","_theme$palette$backgr2","_theme$zIndex","backdrop","palette","bottom","left","right","top","position","zIndex","modal","useStyles","createElement","className","_framerMotion","fullscreen","isMobile","nativeFullscreen","setOpen","_ref","container","alignItems","display","height","justifyContent","maxHeight","_theme$zIndex2","padding","spacing","useEffect","window","innerWidth","exitHandler","webkitIsFullScreen","mozFullScreen","msFullscreenElement","elem","requestFullscreen","webkitRequestFullscreen","msRequestFullscreen","motion","div","initial","y","innerHeight","opacity","animate","transition","type","bounce","_clsx3","_ClickAwayListener","_getImagePos","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","enumerable","apply","_objectSpread","arguments","source","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","input","hint","prim","toPrimitive","res","String","Number","_toPrimitive","_toPropertyKey","configurable","writable","ContentHtml","lazy","ContentIframe","ContentImages","ContentPrev","ContentNext","_useContext2","setOverlayProps","avoidCloseOnOutsideClickAndESC","images","mode","noPadding","_overlayProps$showNex","showNext","_overlayProps$showPre","showPrev","size","onNext","onPrev","maxWidth","content","flexDirection","overflow","width","contentImages","scroll","onKeyup","keyCode","element","handleNextClick","newIndex","imagesPos","handlePrevClick","Suspense","fallback","Fragment","onClick","OverlayContext","createContext","displayName","_propTypes","_portals","ReactOverlay","_useState2","useState","newProps","useMemo","showClose","showToolbar","Provider","propTypes","absoluteMediaURLs","bool","aspectRatio","string","footer","iframeURL","array","number","mediaFormats","oneOf","resourceURL","func","isRequired","oneOfType","title","any","toolbarInside","toolbarColor","_reactDom","_bodyScrollLock","_backdrop","_content","_container","body","appendChild","el","parentElement","removeChild","clearAllBodyScrollLocks","useRef","createPortal","currentPos","move","_newIndex","MotionValue","animation","this","finished","then","clearAnimation","catch","generator","data","getAnimationData","transforms","values","Map","noop","noopReturn","v","addUniqueItem","item","removeItem","index","splice","axes","transformAlias","x","z","rotation","syntax","initialValue","toDefaultUnit","baseTransformProperties","translate","rotate","scale","skew","transformDefinitions","asTransformCssVar","axis","compareTransformOrder","a","b","transformLookup","Set","isTransform","addTransformToElement","style","transform","buildTransformTemplate","sort","reduce","transformListToString","trim","template","isCssVar","startsWith","registeredProperties","defaults","duration","delay","endDelay","repeat","easing","isEasingGenerator","Boolean","createAnimation","isNumber","isEasingList","mix","min","max","progress","fillOffset","offset","remaining","offsetProgress","defaultOffset","wrap","rangeSize","getEasingForSegment","clamp","Math","interpolate","output","remainder","t","progressInRange","segmentEasing","calcBezier","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","getTForX","aX","lowerBound","upperBound","currentX","currentT","abs","binarySubdivide","steps","direction","expanded","rounded","floor","ceil","isFunction","isCubicBezier","namedEasings","ease","functionArgsRegex","getEasingFunction","definition","args","exec","argsArray","split","parseFloat","Animation","keyframes","initialDuration","startTime","rate","cancelTimestamp","totalDuration","playState","Promise","resolve","reject","custom","updateDuration","interpolate$1","map","tick","timestamp","_a","pauseTime","currentIteration","iterationProgress","iterationIsOdd","p","latest","frameRequestId","requestAnimationFrame","play","now","performance","cancelAnimationFrame","stop","time","ms","seconds","s","milliseconds","convertEasing","cubicBezierAsString","c","d","testAnimation","featureTests","cssRegisterProperty","CSS","waapi","Element","partialKeyframes","e","results","supports","keyframesList","getStyleName","getPropertyValue","getComputedStyle","setProperty","stopAnimation","needsCommit","commitStyles","cancel","animateStyle","keyframesDefinition","options","record","__MOTION_DEV_TOOLS_RECORD","isRecording","allowWebkitAcceleration","canAnimateNatively","valueIsTransform","motionValue","motionValues","getMotionValue","readInitialValue","_b","hydrateKeyframes","add","registerProperty","inherits","registerCssVariable","unshift","animationOptions","iterations","fill","onfinish","oncancel","playbackRate","assign","setAnimation","getOptions","resolveElements","elements","selectorCache","querySelectorAll","factory","withControls","animationFactory","Proxy","animations","controls","activeAnimation","all","selectFinished","callback","stagger","start","total","fromIndex","lastIndex","getFromIndex","distance","maxDelay","easingFunction","resolveOption","option","numElements","animationFactories","valueOptions","isString","calcNextTime","prev","labels","addKeyframes","sequence","endTime","keyframe","at","eraseKeyframes","compareByTime","timeline","animationDefinitions","defaultOptions","timelineOptions","__rest","elementSequences","elementCache","timeLabels","prevTime","currentTime","segment","elementDefinition","maxDuration","elementIndex","elementSequence","getElementSequence","valueSequence","getValueSequence","valueKeyframes","invariant","targetTime","valueSequences","valueOffset","valueEasing","createAnimationsFromTimeline","sequences","stiffness","damping","mass","calcDampingRatio","sqrt","velocityPerSecond","velocity","frameDuration","sampleT","calcGeneratorVelocity","resolveValue","prevT","spring","to","restSpeed","restDistance","resolveSpring","state","hasReachedTarget","initialDelta","undampedAngularFreq","dampingRatio","angularFreq","exp","sin","cos","origin","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","timeStep","createGeneratorEasing","createGenerator","keyframesCache","generatorCache","getGenerator","isScale","getKeyframes","toUnit","overshootDuration","pregenerateKeyframes","getOrigin","canUseGenerator","settings","numKeyframes","every","isNumberOrNull","unresolvedOrigin","prevGenerator","generatorStartTime","prevGeneratorCurrent","includes","keyframesMetadata","spring$1","glide","power","decay","bounceDamping","bounceStiffness","changeTarget","nearestBoundary","amplitude","ideal","timeReachedBoundary","calcDelta","calcLatest","applyFriction","delta","checkCatchBoundary","hasUpdatedFrame","thresholds","inView","elementOrSelector","onStart","root","rootMargin","margin","amount","IntersectionObserver","activeIntersections","observer","entries","entry","onEnd","isIntersecting","newOnEnd","unobserve","delete","threshold","observe","disconnect","resizeHandlers","notifyTarget","contentRect","borderBoxSize","handler","contentSize","inlineSize","blockSize","SVGElement","getBBox","offsetWidth","offsetHeight","getElementSize","notifyAll","resizeElement","ResizeObserver","elementHandlers","windowResizeHandler","windowCallbacks","resizeWindow","info","resize","maxElapsed","createScrollInfo","scrollLength","targetOffset","targetLength","containerLength","updateAxisInfo","axisName","elapsed","ScrollOffset","Enter","Exit","Any","All","namedEdges","center","end","resolveEdge","edge","inset","asNumber","endsWith","resolveOffset","targetInset","offsetDefinition","point","resolveOffsets","lengthLabel","HTMLElement","offsetLeft","offsetTop","offsetParent","SVGGraphicsElement","tagName","parentNode","calcInset","targetSize","scrollWidth","scrollHeight","containerSize","hasChanged","numOffsets","interpolatorOffsets","createOnScrollHandler","onScroll","measure","update","updateScrollInfo","notify","scrubAnimation","axisInfo","pause","forEachNative","timingOptions","effect","updateTiming","scrollListeners","resizeListeners","onScrollHandlers","getEventTarget","containerHandlers","containerHandler","listener","passive","onLoadProcesss","resolveVariant","variants","isVariant","scheduled","processScheduledAnimations","generators","compareByDepth","fireAnimateUpdates","fireNext","scheduleAnimation","getDepth","animateUpdates","motionEvent","CustomEvent","detail","dispatchPointerEvent","dispatchEvent","originalEvent","dispatchViewEvent","originalEntry","action","pointerType","gestures","isActive","subscribe","enable","disable","inViewOptions","once","viewOptions","inView$1","enterEntry","leaveEntry","hover","onEnter","onLeave","press","onPointerUp","onPointerDown","stateTypes","mountedStates","createMotionState","parent","depth","activeStates","gestureSubscriptions","context","getContext","initialVariantSource","baseTarget","prevTarget","variant","allTargetKeys","prevLength","shallowCompare","animationTarget","setGesture","updateGestureSubscriptions","isGestureActive","remove","newOptions","setActive","getTarget","mount","newElement","unscheduleAnimation","isMounted","createStyles","initialKeyframes","transformKeys","initialKeyframe","camelLetterToPipeLetter","letter","camelToPipeCase","str","replace","createStyleString","styles","hasPassiveEvents","passiveTestOptions","isIosDevice","navigator","platform","maxTouchPoints","locks","documentListenerAdded","initialClientY","previousBodyOverflowSetting","previousBodyPaddingRight","allowTouchMove","some","lock","preventDefault","rawEvent","touches","restoreOverflowSetting","paddingRight","disableBodyScroll","targetElement","concat","_toConsumableArray","ontouchstart","targetTouches","ontouchmove","scrollTop","isTargetElementTotallyScrolled","stopPropagation","handleScroll","_reserveScrollBarGap","reserveScrollBarGap","scrollBarGap","setOverflowHidden","console","error","enableBodyScroll","tslib","heyListen","styleValueTypes","popmotion","sync","dom","_interopDefaultLegacy","_interopNamespace","create","k","freeze","React__namespace","React__default","sync__default","env","createDefinition","propNames","isEnabled","featureDefinitions","measureLayout","exit","drag","focus","tap","pan","loadFeatures","features","projectionNodeConstructor","Component","LazyContext","strict","featureNames","numFeatures","MotionConfigContext","transformPagePoint","isStatic","reducedMotion","MotionContext","useVisualElementContext","visualElement","PresenceContext","isBrowser","useIsomorphicLayoutEffect","useLayoutEffect","prefersReducedMotion","hasDetected","useReducedMotion","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","__read","useReducedMotionConfig","reducedMotionPreference","isRefObject","isVariantLabels","isVariantLabel","resolveVariantFromProps","currentValues","getProps","forEachValue","getCurrent","getVelocity","getVelocity$1","checkIfControllingVariants","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","useCreateMotionContext","inherit","getCurrentTreeVariants","variantLabelsAsDependency","join","useConstant","init","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","id$1","LayoutGroupContext","SwitchLayoutGroupContext","VisualElementHandler","_super","__extends","getSnapshotBeforeUpdate","updateProps","componentDidUpdate","setProps","render","createMotionComponent","preloadedFeatures","createVisualElement","useRender","useVisualState","forwardRef","externalRef","layoutId","layoutGroupId","id","useLayoutId","__assign","config","projectionId","visualState","lazyContext","presenceContext","shouldReduceMotion","visualElementRef","renderer","presenceId","blockInitialAnimation","syncRender","animationState","animateChanges","notifyUnmount","useVisualElement","ProjectionNodeConstructor","layout","dragConstraints","layoutScroll","initialPromotionConfig","projection","getLatestValues","setOptions","alwaysMeasureLayout","scheduleRender","animationType","useProjection","name_1","useFeatures","useCallback","unmount","useMotionRef","createMotionProxy","createConfig","customMotionComponentConfig","componentCache","_target","lowercaseSVGElements","isSVGComponent","scaleCorrectors","addScaleCorrector","correctors","transformAxes","transformProps","sortTransformProps","operationKey","axesKey","transformPropSet","isTransformProp","transformOriginProps","isTransformOriginProp","isForcedMotionValue","isMotionValue","translateAlias","transformPerspective","isCSSVariable$1","getValueAsType","int","round","numberValueTypes","borderWidth","px","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","paddingTop","paddingBottom","paddingLeft","marginTop","marginRight","marginBottom","marginLeft","degrees","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skewX","skewY","translateX","translateY","translateZ","perspective","alpha","originX","progressPercentage","originY","originZ","fillOpacity","strokeOpacity","numOctaves","buildHTMLStyles","latestValues","transformTemplate","vars","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","valueAsType","transformIsDefault","_c","enableHardwareAcceleration","allowTransformNone","transformString","transformHasZ","numTransformKeys","buildTransform","buildTransformOrigin","createHtmlRenderState","copyRawValuesOnly","useStyle","useInitialMotionValues","transformValues","useHTMLProps","htmlProps","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","validMotionProps","isValidMotionProp","shouldForward","loadExternalIsValidProp","isValidProp","filterProps","isDom","forwardMotionProps","filteredProps","calcOrigin$1","dashKeys","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","attrs","dimensions","pxOriginX","pxOriginY","calcSVGTransformOrigin","useDashCase","buildSVGPath","createSvgRenderState","useSVGProps","visualProps","rawStyles","createUseRender","elementProps","CAMEL_CASE_PATTERN","camelToDash","renderHTML","styleProp","getProjectionStyles","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","scrapeMotionValuesFromProps$1","newValues","scrapeMotionValuesFromProps","toUpperCase","isAnimationControls","isKeyframesTarget","isCustomValue","toValue","resolveFinalValueInKeyframes","resolveMotionValue","unwrappedValue","makeState","createRenderState","onMount","makeLatestValues","makeUseVisualState","scrapeMotionValues","isControllingVariants","isVariantNode","initialAnimationIsBlocked","variantToSet","resolved","transitionEnd","valueTarget","AnimationType","svgMotionConfig","getBoundingClientRect","htmlMotionConfig","createDomMotionConfig","baseConfig","addDomEvent","eventName","useDomEvent","isMouseEvent","PointerEvent","MouseEvent","isTouchEvent","defaultPagePoint","pageX","pageY","pointFromTouch","pointType","changedTouches","pointFromMouse","extractEventInfo","wrapHandler","shouldFilterPrimaryPointer","eventHandler","button","supportsPointerEvents","onpointerdown","supportsTouchEvents","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","addPointerEvent","usePointerEvent","createLock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","createHoverEvent","Hover","isNodeOrChild","child","useUnmountEffect","warned","warnOnce","condition","message","warn","observerCallbacks","observers","fireObserverCallback","fireAllObserverCallbacks","observeIntersection","rootInteresectionObserver","lookupRoot","rootObservers","JSON","stringify","initIntersectionObserver","thresholdNames","useIntersectionObserver","shouldObserve","getInstance","isInView","hasEnteredView","InView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","makeRenderlessComponent","hook","gestureAnimations","whileInView","viewport","onTap","onTapStart","onTapCancel","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","removePointerEndListener","checkPointerEnd","Tap","onPointerCancel","pipe","Focus","onHoverStart","onHoverEnd","counter","incrementId","useId","usePresence","isPresent","onExitComplete","register","secondsToMilliseconds","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","x1","y1","x2","y2","isEasingArray","isAnimatable","complex","underDampedSpring","criticallyDampedSpring","linearTween","defaultTransitions","backgroundColor","color","getDefaultTransition","valueKey","transitionFactory","defaultValueTypes","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","getAnimatableNone","defaultValueType","instantAnimationState","legacyRepeatWarning","getPopmotionAnimationOptions","__spreadArray","when","delayChildren","staggerChildren","staggerDirection","repeatType","repeatDelay","isTransitionDefined","times","yoyo","flip","loop","warning","convertTransitionToAnimationOptions","isZero","getZeroUnit","potentialUnitType","getValueTransition","startAnimation","onComplete","delayTimer","valueTransition","isTargetAnimatable","isOriginAnimatable","onUpdate","inertia","finalTarget","getAnimation","getDelayFromTransition","clearTimeout","isNumericalString","isZeroValueString","SubscriptionManager","subscriptions","_this","numSubscriptions","getSize","clear","isFloat","isNaN","version","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","getFrameData","postRender","scheduleVelocityCheck","velocityCheck","hasAnimated","onChange","subscription","clearListeners","onRenderRequest","attach","passiveEffect","getPrevious","isAnimating","destroy","testValueType","dimensionValueTypes","percent","vw","vh","parse","findDimensionValueType","find","valueTypes","findValueType","setMotionValue","hasValue","getValue","addValue","setTarget","makeTargetAnimatable","setVariants","variantLabels","reverse","getVariant","variantChildren","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","getOriginFromTransition","animateVisualElement","notifyAnimationStart","animateVariant","resolvedDefinition","animateTarget","notifyAnimationComplete","transitionOverride","getChildAnimations","forwardDelay","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","animateChildren","first","last","_f","animationTypeState","getState","shouldBlockAnimation","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","variantPriorityOrder","Animate","Drag","reversePriorityOrder","numAnimationTypes","createAnimationState","animateList","createTypeState","createState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","isAnimated","setAnimateFunction","makeAnimator","safeToRemove","PanSession","handlers","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","getPanInfo","history","isPanStarted","isDistancePastThreshold","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","updateHandlers","cancelSync","subtractPoint","lastDevicePoint","startDevicePoint","timestampedPoint","lastPoint","calcLength","isNear","maxDistance","calcAxisDelta","originPoint","calcBoxDelta","calcRelativeAxis","relative","calcRelativeAxisPosition","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createDelta","createBox","eachAxis","convertBoundingBoxToBox","isIdentityScale","hasScale","hasTranslate","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","translateAxis","transformAxis","scaleKey","originKey","axisOrigin","xKeys$1","yKeys$1","transformBox","measureViewportBox","topLeft","bottomRight","transformBoxPoints","elementDragControls","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","snapToCursor","panSession","dragPropagation","onDragStart","resolveConstraints","isAnimationBlocked","getAxisMotionValue","measuredAxis","actual","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","getCurrentDirection","updateAxis","getTransformPagePoint","onDragEnd","_point","shouldDrag","axisValue","applyConstraints","prevConstraints","resolveRefConstraints","layoutBox","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","measurePageBox","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","timeConstant","restDelta","startAxisValueAnimation","dragKey","externalMotionValue","scalePositionWithinConstraints","boxProgress","sourceLength","calcOrigin","updateScroll","updateLayout","addListeners","stopPointerListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","hasLayoutChanged","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","groupDragControls","dragControls","names","treeType","build","renderInstance","readValueFromInstance","removeValueFromRenderState","removeFromVariantTree","lifecycles","managers","propSubscriptions","clearAllListeners","manager","updatePropListeners","on","propListener","createLifecycles","valueSubscriptions","prevMotionValues","triggerBuild","notifyUpdate","bindToMotionValue","removeOnChange","latestValue","removeOnRenderRequest","initialMotionValues","isVisible","newInstance","addVariantChild","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","setVisibility","visibility","canMutate","removeValue","defaultValue","nextValue","prevValue","existingValue","updateMotionValuesFromProps","startAtParent","context_1","numVariantProps","variantProps","isCSSVariable","cssVariableRegex","maxDepth","getVariableValue","match","parseCSSVariable","token","BoundingBoxDimension","positionalKeys","isPositionalKey","hasPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","nonTranslationalTransformKeys","positionalValues","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","removedTransforms","removeNonTranslationalTransform","scrollY_1","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","targetBbox","convertChangedValueTypes","scrollTo","parseDomVariant","resolveCSSVariables","unitConversion","htmlConfig","domElement","defaultType","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","parsed","htmlVisualElement","svgVisualElement","getAttribute","_element","createDomVisualElement","pixelsToPercent","pixels","correctBorderRadius","correct","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","cssVariables","shadow","createTransformer","xScale","yScale","averageScale","i_1","cssVariable","MeasureLayoutWithContext","componentDidMount","layoutGroup","switchLayoutGroup","defaultScaleCorrectors","group","didUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","deregister","applyTo","boxShadow","layoutFeatures","borders","numBorders","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","identityProjection","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","FlatTree","isDirty","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","ProjectionNode","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","animationProgress","sharedNodes","path","registerPotentialNode","notifyListeners","subscriptionManager","hasListeners","unblockTimeout_1","resizeUnblockUpdate_1","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","onPlay","preRender","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","mountNodeEarly","resetTransformStyle","notifyLayoutUpdate","flushSync","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","removeTransform","removeElementScroll","roundBox","prevLayout","layoutCorrected","notifyLayoutMeasure","isScrollRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","attemptToResolveRelativeTarget","pendingAnimation","getLead","treePath","isSharedTransition","treeLength","applyTreeDeltas","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","follow","opacityExit","borderLabel","followRadius","leadRadius","mixValues","completeAnimation","applyTransformsToTarget","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","pointerEvents","emptyStyles","valuesToRender","_h","corrected","num","resetTree","layout_1","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","searchNode","querySelector","roundAxis","DocumentProjectionNode","scrollLeft","HTMLProjectionNode","documentNode","featureBundle","m","useIsMounted","useForceUpdate","forcedRenderCount","setForcedRenderCount","forceRender","PresenceChild","presenceAffectsLayout","presenceChildren","newChildrenMap","childId","e_1","__values","e_1_1","_","getChildKey","DeprecatedLayoutGroupContext","nodeGroup","dirtyAll","dirty","shouldInheritGroup","LayoutGroup","inheritId","layoutGroupContext","deprecatedLayoutGroupContext","upstreamId","shouldInheritId","memoizedContext","isLazyBundle","ReorderContext","checkReorder","order","nextOffset","nextItem","nextLayout","nextItemCenter","toIndex","startIndex","endIndex","moveItem","Group","as","onReorder","isReordering","registerItem","compareMin","updateOrder","newOrder","useMotionValue","setLatest_1","getMixer","isCustomValueType","useImmediate","argOffset","inputValue","inputRange","outputRange","interpolator","mixer","useCombineMotionValues","combineValues","updateValue","unsubscribe","useMultiOnChange","useTransform","inputRangeOrTransformer","transformer","useListTransform","numValues","useDefaultMotionValue","Reorder","Item","latestX","latestY","gesturePoint","onLayoutMeasure","domAnimation","domMax","createScrollMotionValues","scrollX","scrollY","scrollXProgress","scrollYProgress","useScroll","getCurrentTime","Date","useAnimationFrame","initialTimestamp","provideTimeSinceStart","animationControls","hasMounted","pendingAnimations","subscribers","animations_1","setValues","useAnimationControls","useAnimation","DragControls","componentControls","nativeEvent","createDragControls","useInstantLayoutTransition","startTransition","cb","createObject","stateVisualElement","_state","initialState","invertScale","hasWarned","AnimatePresence","exitBeforeEnter","forceRenderLayoutGroup","filteredChildren","filtered","Children","isValidElement","onlyElements","childrenToRender","exiting","presentChildren","allChildren","updateChildLookup","presentKeys","targetKeys","numPresent","insertionIndex","removeIndex","presentChild","cloneElement","AnimateSharedLayout","LazyMotion","setIsLoaded","loadedRenderer","loadedFeatures","MotionConfig","createDomMotionComponent","useCycle","items","setItem","useDeprecatedAnimatedState","setAnimationState","animationDefinition","useDeprecatedInvertedScale","parentScaleX","parentScaleY","useDragControls","useElementScroll","useInView","setInView","useInstantTransition","forceUpdate","startInstantLayoutTransition","useIsPresent","useMotionTemplate","fragments","numFragments","useResetProjection","useSpring","activeSpringAnimation","useOnChange","useTime","useVelocity","newVelocity","useViewportScroll","defaultTimestep","onNextFrame","useDefaultElapsed","runNextFrame","isProcessing","frame","stepsOrder","toRun","toRunNextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","addToCurrentFrame","buffer","process","frameData","createRenderStep","keepAlive","immediate","startLoop","processStep","stepId","processFrame","safeMin","minDuration","minDamping","maxDamping","findSpring","envelope","derivative","undampedFreq","exponentialDecay","calcAngularFreq","pow","f","g","initialGuess","result","rootIterations","approximateRoot","durationKeys","physicsKeys","isSpringType","springOptions","isResolvedFromDuration","derived","getSpringOptions","zero","resolveVelocity","createSpring","initialVelocity","dampedAngularFreq","freqForT","sinh","cosh","flipTarget","needsInterpolation","_t","toFromDifference","hueToRgb","q","hslaToRgba","hue","saturation","lightness","red","green","blue","mixLinearColor","fromExpo","toExpo","colorTypes","hex","rgba","hsla","getColorType","notAnimatable","mixColor","fromColorType","toColorType","fromColor","toColor","blended","zeroPoint","isNum","combineFunctions","transformers","mixComplex","mixArray","blendValue","fromThis","mixObject","analyse","numNumbers","numRGB","numHSL","originStats","targetStats","mixNumber","createMixers","customMixer","mixers","mixerFactory","numMixers","isClamp","inputLength","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","slowInterpolate","reverseEasing","mirrorEasing","createExpoIn","createBackIn","createAnticipate","backEasing","acos","p2","defaultEasing","convertOffsetToTimes","_value","createInterpolator","modifyTarget","types","loopElapsed","framesync","passTimestamp","driverControls","interpolateFromNumber","autoplay","driver","repeatMax","onStop","onRepeat","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","detectAnimationFromOptions","reverseElapsed","hasRepeatDelayElapsed","radiansToDegrees","radians","PI","identity","createAttractor","alterDisplacement","constant","displacement","springModifiedDisplacement","attract","attractExpo","degreesToRadians","isPoint","isPoint3D","distance1D","toDecimal","precision","smoothFrame","smoothing","getSlope","newtonIterations","newtonMinSlope","kSplineTableSize","kSampleStepSize","angle","atan2","applyOffset","hasReceivedFrom","sampleValues","Float32Array","intervalStart","currentSample","lastSample","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","xDelta","yDelta","zDelta","isOutOfBounds","boundaryNearest","startSpring","boundary","heading","pointFromVector","smooth","strength","previousValue","currentFramestamp","newValue","snap","points","numPoints","lastDistance","velocityPerFrame","xps","sanitize","toFixed","floatRegex","colorRegex","singleColorRegex","createUnitType","unit","isColorString","testProp","splitColor","aName","bName","cName","alpha$1","clampRgbUnit","rgbUnit","r","substr","parseInt","colorToken","numberToken","numColors","colors","numbers","tokenised","convertNumbersToZero","maxDefaults","applyDefaultFilter","functionRegex","functions","module","arrayLikeToArray","iter","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","arrayWithoutHoles","iterableToArray","nonIterableSpread"],"sourceRoot":""}