{"version":3,"file":"191-9d9eebef9619ccb5e1e7.js","mappings":"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","sources":["webpack://royal-geographical-society/./node_modules/lodash/_Symbol.js","webpack://royal-geographical-society/./node_modules/lodash/_baseGetTag.js","webpack://royal-geographical-society/./node_modules/lodash/_baseTrim.js","webpack://royal-geographical-society/./node_modules/lodash/_freeGlobal.js","webpack://royal-geographical-society/./node_modules/lodash/_getRawTag.js","webpack://royal-geographical-society/./node_modules/lodash/_objectToString.js","webpack://royal-geographical-society/./node_modules/lodash/_root.js","webpack://royal-geographical-society/./node_modules/lodash/_trimmedEndIndex.js","webpack://royal-geographical-society/./node_modules/lodash/debounce.js","webpack://royal-geographical-society/./node_modules/lodash/isObject.js","webpack://royal-geographical-society/./node_modules/lodash/isObjectLike.js","webpack://royal-geographical-society/./node_modules/lodash/isSymbol.js","webpack://royal-geographical-society/./node_modules/lodash/noop.js","webpack://royal-geographical-society/./node_modules/lodash/now.js","webpack://royal-geographical-society/./node_modules/lodash/toNumber.js","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/animation/animation-controls.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/animation/use-animation.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/components/MotionConfig/index.mjs","webpack://royal-geographical-society/./node_modules/popmotion/dist/es/utils/is-point.mjs","webpack://royal-geographical-society/./node_modules/popmotion/dist/es/utils/is-point-3d.mjs","webpack://royal-geographical-society/./node_modules/popmotion/dist/es/utils/distance.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/gestures/PanSession.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/animation/animate.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://royal-geographical-society/./node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nmodule.exports = baseTrim;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","/**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\nfunction noop() {\n  // No operation performed.\n}\n\nmodule.exports = noop;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","var baseTrim = require('./_baseTrim'),\n    isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","import { __spreadArray, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { stopAnimation, animateVisualElement } from '../render/utils/animation.mjs';\nimport { setValues } from '../render/utils/setters.mjs';\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            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, __spreadArray([], __read(animation), false)).then(resolve);\n            });\n            return function () {\n                hasMounted = false;\n                controls.stop();\n            };\n        },\n    };\n    return controls;\n}\n\nexport { animationControls };\n","import { animationControls } from './animation-controls.mjs';\nimport { useEffect } from 'react';\nimport { useConstant } from '../utils/use-constant.mjs';\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    useEffect(controls.mount, []);\n    return controls;\n}\nvar useAnimation = useAnimationControls;\n\nexport { useAnimation, useAnimationControls };\n","import { __rest, __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext, useMemo } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\nimport { loadExternalIsValidProp } from '../../render/dom/utils/filter-props.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\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 = __rest(_a, [\"children\", \"isValidProp\"]);\n    isValidProp && loadExternalIsValidProp(isValidProp);\n    /**\n     * Inherit props from any parent MotionConfig components\n     */\n    config = __assign(__assign({}, 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 = useMemo(function () { return config; }, [JSON.stringify(config.transition), config.transformPagePoint, config.reducedMotion]);\n    return (React.createElement(MotionConfigContext.Provider, { value: context }, children));\n}\n\nexport { MotionConfig };\n","const isPoint = (point) => point.hasOwnProperty('x') && point.hasOwnProperty('y');\n\nexport { isPoint };\n","import { isPoint } from './is-point.mjs';\n\nconst isPoint3D = (point) => isPoint(point) && point.hasOwnProperty('z');\n\nexport { isPoint3D };\n","import { isPoint } from './is-point.mjs';\nimport { isPoint3D } from './is-point-3d.mjs';\nimport { isNum } from './inc.mjs';\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\nexport { distance };\n","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { distance, pipe } from 'popmotion';\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 = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = getFrameData().timestamp;\n            _this.history.push(__assign(__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.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 = getFrameData().timestamp;\n        this.history = [__assign(__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = 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        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\nexport { PanSession };\n","import { mix, distance } from 'popmotion';\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 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 = 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        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\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","import { __read } from 'tslib';\nimport { clamp, mix, progress } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\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 ? 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 ? 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 = __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 = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return 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\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\n","import { __assign } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\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 (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(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(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        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 = __assign(__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] - 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(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 __assign(__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\nexport { VisualElementDragControls, elementDragControls };\n","var 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\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","import { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\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 = useRef(null);\n    var transformPagePoint = 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    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\nexport { usePanGesture };\n","import { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\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    useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\nexport { useDrag };\n","import { px } from 'style-value-types';\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 (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\nexport { correctBorderRadius, pixelsToPercent };\n","import { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\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 = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = 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 = 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\nexport { correctBoxShadow };\n","import { __extends, __assign, __read } from 'tslib';\nimport sync from 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    __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(__assign(__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.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.Component));\nfunction MeasureLayout(props) {\n    var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, __assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__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\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\n","import { mix, progress, linear, circOut } from 'popmotion';\nimport { px, percent } from 'style-value-types';\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\" || px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = 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 = mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = 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(mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (percent.test(leadRadius) || 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 = 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, circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, 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(progress(min, max, p));\n    };\n}\n\nexport { mixValues };\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\nexport { copyAxisInto, copyBoxInto };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { scalePoint } from './delta-apply.mjs';\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 (percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var originPoint = 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 = __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\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","function 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\nexport { boxEquals, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\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\nexport { NodeStack };\n","var 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\nexport { buildProjectionTransform, identityProjection };\n","var compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\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\nexport { FlatTree };\n","import { __spreadArray, __read, __assign } from 'tslib';\nimport sync, { cancelSync, flushSync } from 'framesync';\nimport { mix } from 'popmotion';\nimport { animate } from '../../animation/animate.mjs';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\nimport { mixValues } from '../animation/mix-values.mjs';\nimport { copyBoxInto } from '../geometry/copy.mjs';\nimport { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from '../geometry/delta-apply.mjs';\nimport { calcRelativePosition, calcRelativeBox, calcBoxDelta, calcLength } from '../geometry/delta-calc.mjs';\nimport { removeBoxTransforms } from '../geometry/delta-remove.mjs';\nimport { createBox, createDelta } from '../geometry/models.mjs';\nimport { getValueTransition } from '../../animation/utils/transitions.mjs';\nimport { boxEquals, isDeltaZero } from '../geometry/utils.mjs';\nimport { NodeStack } from '../shared/stack.mjs';\nimport { scaleCorrectors } from '../styles/scale-correction.mjs';\nimport { buildProjectionTransform } from '../styles/transform.mjs';\nimport { eachAxis } from '../utils/each-axis.mjs';\nimport { hasTransform, hasScale } from '../utils/has-transform.mjs';\nimport { transformAxes } from '../../render/html/utils/transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { globalProjectionState } from './state.mjs';\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 ? __spreadArray(__spreadArray([], __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, __spreadArray([], __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 = __assign(__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            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            flushSync.update();\n            flushSync.preRender();\n            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.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.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 = __assign(__assign(__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 = __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                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.update(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, __assign(__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 = mix(delta.translate, 0, p);\n    output.scale = 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 = mix(from.min, to.min, p);\n    output.max = 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\nexport { createProjectionNode, mixAxis, mixAxisDelta, mixBox };\n","import { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { startAnimation } from './utils/transitions.mjs';\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\nexport { animate };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\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\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\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\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { __assign } from 'tslib';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { layoutFeatures } from '../../motion/features/layout/index.mjs';\nimport { domAnimation } from './features-animation.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\n/**\n * @public\n */\nvar domMax = __assign(__assign(__assign(__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\nexport { domMax };\n"],"names":["Symbol","module","exports","getRawTag","objectToString","symToStringTag","toStringTag","undefined","value","Object","trimmedEndIndex","reTrimStart","string","slice","replace","freeGlobal","g","objectProto","prototype","hasOwnProperty","nativeObjectToString","toString","isOwn","call","tag","unmasked","e","result","freeSelf","self","root","Function","reWhitespace","index","length","test","charAt","isObject","now","toNumber","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","apply","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","arguments","this","clearTimeout","cancel","flush","type","baseGetTag","isObjectLike","Date","baseTrim","isSymbol","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","isBinary","animationControls","hasMounted","pendingAnimations","subscribers","Set","controls","subscribe","visualElement","add","delete","start","definition","transitionOverride","animations_1","forEach","push","Promise","all","resolve","animation","set","stop","mount","_a","then","useAnimation","useEffect","MotionConfig","children","isValidProp","config","useContext","isStatic","context","useMemo","JSON","stringify","transition","transformPagePoint","reducedMotion","isPoint","point","isPoint3D","distance1D","a","b","abs","distance","xDelta","x","yDelta","y","zDelta","z","sqrt","pow","PanSession","event","handlers","_this","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","offset","timestamp","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","end","onEnd","onSessionEnd","panInfo","touches","initialInfo","onSessionStart","removeListeners","pipe","window","updateHandlers","subtractPoint","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","i","timestampedPoint","lastPoint","currentVelocity","Infinity","calcLength","axis","isNear","target","maxDistance","calcAxisDelta","source","origin","originPoint","mix","scale","isNaN","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","eachAxis","callback","elementDragControls","WeakMap","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","_c","snapToCursor","isPresent","panSession","stopAnimation","_b","getProps","drag","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","current","getAxisMotionValue","get","measuredAxis","actual","parseFloat","animationState","setActive","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","getCurrentDirection","updateAxis","syncRender","getTransformPagePoint","startAnimation","onDragEnd","_point","shouldDrag","axisValue","next","dragConstraints","prevConstraints","resolveRefConstraints","layoutBox","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","measure","measuredConstraints","calcViewportConstraints","userConstraints","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","bounceStiffness","bounceDamping","inertia","timeConstant","restDelta","restSpeed","startAxisValueAnimation","dragKey","toUpperCase","getValue","initial","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","latest","progress","clamp","transformTemplate","getInstance","style","transform","updateScroll","updateLayout","addListeners","element","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","addEventListener","stopResizeListener","hasLayoutChanged","motionValue","props","_d","_e","_f","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","MotionConfigContext","groupDragControls","dragControls","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","concat","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","match","shadow","complex","template","xScale","yScale","averageScale","output","i_1","cssVariable","MeasureLayoutWithContext","_super","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","defaultScaleCorrectors","group","register","didUpdate","safeToRemove","setOptions","onExitComplete","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","componentDidUpdate","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","render","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","SwitchLayoutGroupContext","borders","numBorders","asNumber","isPx","getRadius","values","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","easing","p","copyAxisInto","originAxis","copyBoxInto","box","originBox","removePointDelta","boxScale","removeAxisTransforms","transforms","sourceAxis","key","scaleKey","originKey","removeAxisDelta","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","scheduleRender","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","instance","resumeFrom","preserveOpacity","snapshot","latestValues","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","buildProjectionTransform","latestTransform","xTranslate","yTranslate","rotate","rotateX","rotateY","elementScaleX","elementScaleY","compareByDepth","depth","FlatTree","isDirty","child","sort","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","ProjectionNode","id","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","Map","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","name","handler","has","notifyListeners","_i","subscriptionManager","notify","hasListeners","SVGElement","tagName","unblockTimeout_1","resizeUnblockUpdate_1","finishAnimation","registerSharedNode","animate","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","getDefaultTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","onComplete","shouldReduceMotion","delay","unmount","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","size","mountNodeEarly","clear","resetTransformStyle","notifyLayoutUpdate","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","removeTransform","removeElementScroll","roundBox","alwaysMeasureLayout","prevLayout","layoutCorrected","notifyLayoutMeasure","layoutScroll","isScrollRoot","scroll","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","measureViewportBox","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","Boolean","attemptToResolveRelativeTarget","pendingAnimation","getLead","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","some","hasOpacityCrossfade","mixTargetDelta","from","to","mixAxisDelta","mixAxis","follow","opacity","opacityExit","borderLabel","followRadius","leadRadius","mixValues","isAnimating","onUpdate","completeAnimation","applyTransformsToTarget","initialPromotionConfig","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","getStaticValue","setStaticValue","getProjectionStyles","styleProp","styles","visibility","pointerEvents","emptyStyles","valuesToRender","transformOrigin","_h","corrected","num","resetTree","layout_1","measuredLayout","animationType","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","duration","ease","searchNode","document","querySelector","roundAxis","round","DocumentProjectionNode","ref","documentElement","scrollLeft","body","scrollTop","rootProjectionNode","HTMLProjectionNode","documentNode","getComputedStyle","position","domMax","projectionNodeConstructor"],"sourceRoot":""}