{"version":3,"file":"commons-ef10d88f2f6cfd69790a.js","mappings":"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","sources":["webpack://safe-space/./node_modules/@contentful/rich-text-react-renderer/dist/rich-text-react-renderer.es5.js","webpack://safe-space/./node_modules/@contentful/rich-text-types/dist/rich-text-types.es5.js","webpack://safe-space/./node_modules/@fortawesome/react-fontawesome/index.es.js","webpack://safe-space/./node_modules/contentful-resolve-response/dist/esm/index.js","webpack://safe-space/./node_modules/fast-copy/dist/fast-copy.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/utils/find-spring.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/generators/spring.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/mix-color.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/mix-complex.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/interpolate.js","webpack://safe-space/./node_modules/popmotion/dist/es/easing/utils.js","webpack://safe-space/./node_modules/popmotion/dist/es/easing/index.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/generators/keyframes.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/generators/decay.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/utils/elapsed.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/index.js","webpack://safe-space/./node_modules/popmotion/dist/es/easing/cubic-bezier.js","webpack://safe-space/./node_modules/framer-motion/dist/es/animation/utils/easing.js","webpack://safe-space/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.js","webpack://safe-space/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.js","webpack://safe-space/./node_modules/framer-motion/dist/es/animation/utils/transitions.js","webpack://safe-space/./node_modules/popmotion/dist/es/animations/inertia.js","webpack://safe-space/./node_modules/framer-motion/dist/es/components/AnimateSharedLayout/types.js","webpack://safe-space/./node_modules/framer-motion/dist/es/events/event-info.js","webpack://safe-space/./node_modules/framer-motion/dist/es/events/use-dom-event.js","webpack://safe-space/./node_modules/framer-motion/dist/es/events/utils.js","webpack://safe-space/./node_modules/framer-motion/dist/es/events/use-pointer-event.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/utils/event-type.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/features/animations.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/PanSession.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/projection/convert-to-relative.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/features/drag.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/drag/use-drag.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/use-hover-gesture.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/features/gestures.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/use-tap-gesture.js","webpack://safe-space/./node_modules/framer-motion/dist/es/gestures/use-focus-gesture.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/projection/default-scale-correctors.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/features/layout/Animate.js","webpack://safe-space/./node_modules/framer-motion/dist/es/components/AnimateSharedLayout/utils/batcher.js","webpack://safe-space/./node_modules/framer-motion/dist/es/context/SharedLayoutContext.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/features/layout/Measure.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/features/layout/index.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/features/layout/utils.js","webpack://safe-space/./node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/state.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/html/utils/build-projection-transform.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/lifecycles.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/flat-tree.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/index.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/motion-values.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/projection/relative-set.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/projection.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/html/visual-element.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/svg/visual-element.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/motion.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/projection/measure.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/projection/utils.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/utils/batch-layout.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/value-types/test.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/shallow-compare.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/animation-state.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/animation.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/is-draggable.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/is-numerical-string.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/dom/value-types/find.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/setters.js","webpack://safe-space/./node_modules/framer-motion/dist/es/render/utils/types.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/array.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/each-axis.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/geometry/delta-apply.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/geometry/delta-calc.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/noop.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/geometry/index.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/subscription-manager.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/time-conversion.js","webpack://safe-space/./node_modules/framer-motion/dist/es/utils/use-unmount-effect.js","webpack://safe-space/./node_modules/framer-motion/dist/es/value/index.js","webpack://safe-space/./node_modules/framesync/dist/es/on-next-frame.js","webpack://safe-space/./node_modules/framesync/dist/es/index.js","webpack://safe-space/./node_modules/framesync/dist/es/create-render-step.js","webpack://safe-space/./node_modules/hey-listen/dist/hey-listen.es.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/clamp.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/is-point.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/is-point-3d.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/distance.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/inc.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/mix.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/pipe.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/progress.js","webpack://safe-space/./node_modules/popmotion/dist/es/utils/velocity-per-second.js","webpack://safe-space/./node_modules/react-fast-compare/index.js","webpack://safe-space/./node_modules/react-helmet/es/Helmet.js","webpack://safe-space/./node_modules/react-side-effect/lib/index.js","webpack://safe-space/./node_modules/style-value-types/dist/es/color/hex.js","webpack://safe-space/./node_modules/style-value-types/dist/es/color/hsla.js","webpack://safe-space/./node_modules/style-value-types/dist/es/color/index.js","webpack://safe-space/./node_modules/style-value-types/dist/es/color/rgba.js","webpack://safe-space/./node_modules/style-value-types/dist/es/color/utils.js","webpack://safe-space/./node_modules/style-value-types/dist/es/complex/filter.js","webpack://safe-space/./node_modules/style-value-types/dist/es/complex/index.js","webpack://safe-space/./node_modules/gatsby-plugin-intl/index.js","webpack://safe-space/./node_modules/gatsby-plugin-intl/link.js","webpack://safe-space/./node_modules/gatsby-plugin-intl/with-intl.js","webpack://safe-space/../components/TransitionLink.js","webpack://safe-space/../components/TransitionObserver.js","webpack://safe-space/../components/TransitionPortal.js","webpack://safe-space/../hooks/index.js","webpack://safe-space/../hooks/useTransitionState.js","webpack://safe-space/../hooks/useTriggerTransition.js","webpack://safe-space/../src/index.js","webpack://safe-space/../utils/shouldNavigate.js","webpack://safe-space/../utils/triggerTransition.js","webpack://safe-space/./node_modules/gatsby-source-contentful/rich-text.js","webpack://safe-space/./src/components/dynamic-components/bottom-navigation.js","webpack://safe-space/./src/components/dynamic-components/feedback-comment.js","webpack://safe-space/./src/components/dynamic-components/feedback-rating.js","webpack://safe-space/./src/components/dynamic-components/footer.js","webpack://safe-space/./src/components/dynamic-components/general-feedback.js","webpack://safe-space/./src/components/dynamic-components/header.js","webpack://safe-space/./src/components/feedback/index.js","webpack://safe-space/./src/components/site-metadata.js","webpack://safe-space/./src/store/actions/feedback.js"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nfunction _interopDefault(ex) {\n  return ex && typeof ex === 'object' && 'default' in ex ? ex['default'] : ex;\n}\nvar React = require('react');\nvar React__default = _interopDefault(React);\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\n\nvar __assign = function () {\n  __assign = Object.assign || function __assign(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n      s = arguments[i];\n      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n    }\n    return t;\n  };\n  return __assign.apply(this, arguments);\n};\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\nfunction unwrapExports(x) {\n  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\nfunction createCommonjsModule(fn, module) {\n  return module = {\n    exports: {}\n  }, fn(module, module.exports), module.exports;\n}\nvar richTextTypes_es5 = createCommonjsModule(function (module, exports) {\n  Object.defineProperty(exports, '__esModule', {\n    value: true\n  });\n  var commonjsGlobal$1 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : typeof self !== 'undefined' ? self : {};\n  function createCommonjsModule(fn, module) {\n    return module = {\n      exports: {}\n    }, fn(module, module.exports), module.exports;\n  }\n  var check = function (it) {\n    return it && it.Math == Math && it;\n  };\n\n  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\n  var global_1 =\n  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) || check(typeof commonjsGlobal$1 == 'object' && commonjsGlobal$1) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  function () {\n    return this;\n  }() || Function('return this')();\n  var fails = function (exec) {\n    try {\n      return !!exec();\n    } catch (error) {\n      return true;\n    }\n  };\n\n  // Detect IE8's incomplete defineProperty implementation\n  var descriptors = !fails(function () {\n    // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n    return Object.defineProperty({}, 1, {\n      get: function () {\n        return 7;\n      }\n    })[1] != 7;\n  });\n  var $propertyIsEnumerable = {}.propertyIsEnumerable;\n  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n  // Nashorn ~ JDK8 bug\n  var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({\n    1: 2\n  }, 1);\n\n  // `Object.prototype.propertyIsEnumerable` method implementation\n  // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\n  var f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n    var descriptor = getOwnPropertyDescriptor(this, V);\n    return !!descriptor && descriptor.enumerable;\n  } : $propertyIsEnumerable;\n  var objectPropertyIsEnumerable = {\n    f: f\n  };\n  var createPropertyDescriptor = function (bitmap, value) {\n    return {\n      enumerable: !(bitmap & 1),\n      configurable: !(bitmap & 2),\n      writable: !(bitmap & 4),\n      value: value\n    };\n  };\n  var toString = {}.toString;\n  var classofRaw = function (it) {\n    return toString.call(it).slice(8, -1);\n  };\n  var split = ''.split;\n\n  // fallback for non-array-like ES3 and non-enumerable old V8 strings\n  var indexedObject = fails(function () {\n    // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n    // eslint-disable-next-line no-prototype-builtins -- safe\n    return !Object('z').propertyIsEnumerable(0);\n  }) ? function (it) {\n    return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);\n  } : Object;\n\n  // `RequireObjectCoercible` abstract operation\n  // https://tc39.es/ecma262/#sec-requireobjectcoercible\n  var requireObjectCoercible = function (it) {\n    if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n    return it;\n  };\n\n  // toObject with fallback for non-array-like ES3 strings\n\n  var toIndexedObject = function (it) {\n    return indexedObject(requireObjectCoercible(it));\n  };\n  var isObject = function (it) {\n    return typeof it === 'object' ? it !== null : typeof it === 'function';\n  };\n\n  // `ToPrimitive` abstract operation\n  // https://tc39.es/ecma262/#sec-toprimitive\n  // instead of the ES6 spec version, we didn't implement @@toPrimitive case\n  // and the second argument - flag - preferred type is a string\n  var toPrimitive = function (input, PREFERRED_STRING) {\n    if (!isObject(input)) return input;\n    var fn, val;\n    if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n    if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n    if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n    throw TypeError(\"Can't convert object to primitive value\");\n  };\n  var hasOwnProperty = {}.hasOwnProperty;\n  var has = function (it, key) {\n    return hasOwnProperty.call(it, key);\n  };\n  var document$1 = global_1.document;\n  // typeof document.createElement is 'object' in old IE\n  var EXISTS = isObject(document$1) && isObject(document$1.createElement);\n  var documentCreateElement = function (it) {\n    return EXISTS ? document$1.createElement(it) : {};\n  };\n\n  // Thank's IE8 for his funny defineProperty\n  var ie8DomDefine = !descriptors && !fails(function () {\n    // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n    return Object.defineProperty(documentCreateElement('div'), 'a', {\n      get: function () {\n        return 7;\n      }\n    }).a != 7;\n  });\n\n  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n  var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n  // `Object.getOwnPropertyDescriptor` method\n  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\n  var f$1 = descriptors ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n    O = toIndexedObject(O);\n    P = toPrimitive(P, true);\n    if (ie8DomDefine) try {\n      return $getOwnPropertyDescriptor(O, P);\n    } catch (error) {/* empty */}\n    if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);\n  };\n  var objectGetOwnPropertyDescriptor = {\n    f: f$1\n  };\n  var anObject = function (it) {\n    if (!isObject(it)) {\n      throw TypeError(String(it) + ' is not an object');\n    }\n    return it;\n  };\n\n  // eslint-disable-next-line es/no-object-defineproperty -- safe\n  var $defineProperty = Object.defineProperty;\n\n  // `Object.defineProperty` method\n  // https://tc39.es/ecma262/#sec-object.defineproperty\n  var f$2 = descriptors ? $defineProperty : function defineProperty(O, P, Attributes) {\n    anObject(O);\n    P = toPrimitive(P, true);\n    anObject(Attributes);\n    if (ie8DomDefine) try {\n      return $defineProperty(O, P, Attributes);\n    } catch (error) {/* empty */}\n    if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n    if ('value' in Attributes) O[P] = Attributes.value;\n    return O;\n  };\n  var objectDefineProperty = {\n    f: f$2\n  };\n  var createNonEnumerableProperty = descriptors ? function (object, key, value) {\n    return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));\n  } : function (object, key, value) {\n    object[key] = value;\n    return object;\n  };\n  var setGlobal = function (key, value) {\n    try {\n      createNonEnumerableProperty(global_1, key, value);\n    } catch (error) {\n      global_1[key] = value;\n    }\n    return value;\n  };\n  var SHARED = '__core-js_shared__';\n  var store = global_1[SHARED] || setGlobal(SHARED, {});\n  var sharedStore = store;\n  var functionToString = Function.toString;\n\n  // this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper\n  if (typeof sharedStore.inspectSource != 'function') {\n    sharedStore.inspectSource = function (it) {\n      return functionToString.call(it);\n    };\n  }\n  var inspectSource = sharedStore.inspectSource;\n  var WeakMap = global_1.WeakMap;\n  var nativeWeakMap = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n  var shared = createCommonjsModule(function (module) {\n    (module.exports = function (key, value) {\n      return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});\n    })('versions', []).push({\n      version: '3.10.1',\n      mode: 'global',\n      copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n    });\n  });\n  var id = 0;\n  var postfix = Math.random();\n  var uid = function (key) {\n    return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n  };\n  var keys = shared('keys');\n  var sharedKey = function (key) {\n    return keys[key] || (keys[key] = uid(key));\n  };\n  var hiddenKeys = {};\n  var WeakMap$1 = global_1.WeakMap;\n  var set, get, has$1;\n  var enforce = function (it) {\n    return has$1(it) ? get(it) : set(it, {});\n  };\n  var getterFor = function (TYPE) {\n    return function (it) {\n      var state;\n      if (!isObject(it) || (state = get(it)).type !== TYPE) {\n        throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n      }\n      return state;\n    };\n  };\n  if (nativeWeakMap) {\n    var store$1 = sharedStore.state || (sharedStore.state = new WeakMap$1());\n    var wmget = store$1.get;\n    var wmhas = store$1.has;\n    var wmset = store$1.set;\n    set = function (it, metadata) {\n      metadata.facade = it;\n      wmset.call(store$1, it, metadata);\n      return metadata;\n    };\n    get = function (it) {\n      return wmget.call(store$1, it) || {};\n    };\n    has$1 = function (it) {\n      return wmhas.call(store$1, it);\n    };\n  } else {\n    var STATE = sharedKey('state');\n    hiddenKeys[STATE] = true;\n    set = function (it, metadata) {\n      metadata.facade = it;\n      createNonEnumerableProperty(it, STATE, metadata);\n      return metadata;\n    };\n    get = function (it) {\n      return has(it, STATE) ? it[STATE] : {};\n    };\n    has$1 = function (it) {\n      return has(it, STATE);\n    };\n  }\n  var internalState = {\n    set: set,\n    get: get,\n    has: has$1,\n    enforce: enforce,\n    getterFor: getterFor\n  };\n  var redefine = createCommonjsModule(function (module) {\n    var getInternalState = internalState.get;\n    var enforceInternalState = internalState.enforce;\n    var TEMPLATE = String(String).split('String');\n    (module.exports = function (O, key, value, options) {\n      var unsafe = options ? !!options.unsafe : false;\n      var simple = options ? !!options.enumerable : false;\n      var noTargetGet = options ? !!options.noTargetGet : false;\n      var state;\n      if (typeof value == 'function') {\n        if (typeof key == 'string' && !has(value, 'name')) {\n          createNonEnumerableProperty(value, 'name', key);\n        }\n        state = enforceInternalState(value);\n        if (!state.source) {\n          state.source = TEMPLATE.join(typeof key == 'string' ? key : '');\n        }\n      }\n      if (O === global_1) {\n        if (simple) O[key] = value;else setGlobal(key, value);\n        return;\n      } else if (!unsafe) {\n        delete O[key];\n      } else if (!noTargetGet && O[key]) {\n        simple = true;\n      }\n      if (simple) O[key] = value;else createNonEnumerableProperty(O, key, value);\n      // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n    })(Function.prototype, 'toString', function toString() {\n      return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n    });\n  });\n  var path = global_1;\n  var aFunction = function (variable) {\n    return typeof variable == 'function' ? variable : undefined;\n  };\n  var getBuiltIn = function (namespace, method) {\n    return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global_1[namespace]) : path[namespace] && path[namespace][method] || global_1[namespace] && global_1[namespace][method];\n  };\n  var ceil = Math.ceil;\n  var floor = Math.floor;\n\n  // `ToInteger` abstract operation\n  // https://tc39.es/ecma262/#sec-tointeger\n  var toInteger = function (argument) {\n    return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n  };\n  var min = Math.min;\n\n  // `ToLength` abstract operation\n  // https://tc39.es/ecma262/#sec-tolength\n  var toLength = function (argument) {\n    return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n  };\n  var max = Math.max;\n  var min$1 = Math.min;\n\n  // Helper for a popular repeating case of the spec:\n  // Let integer be ? ToInteger(index).\n  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\n  var toAbsoluteIndex = function (index, length) {\n    var integer = toInteger(index);\n    return integer < 0 ? max(integer + length, 0) : min$1(integer, length);\n  };\n\n  // `Array.prototype.{ indexOf, includes }` methods implementation\n  var createMethod = function (IS_INCLUDES) {\n    return function ($this, el, fromIndex) {\n      var O = toIndexedObject($this);\n      var length = toLength(O.length);\n      var index = toAbsoluteIndex(fromIndex, length);\n      var value;\n      // Array#includes uses SameValueZero equality algorithm\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (IS_INCLUDES && el != el) while (length > index) {\n        value = O[index++];\n        // eslint-disable-next-line no-self-compare -- NaN check\n        if (value != value) return true;\n        // Array#indexOf ignores holes, Array#includes - not\n      } else for (; length > index; index++) {\n        if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n      }\n      return !IS_INCLUDES && -1;\n    };\n  };\n  var arrayIncludes = {\n    // `Array.prototype.includes` method\n    // https://tc39.es/ecma262/#sec-array.prototype.includes\n    includes: createMethod(true),\n    // `Array.prototype.indexOf` method\n    // https://tc39.es/ecma262/#sec-array.prototype.indexof\n    indexOf: createMethod(false)\n  };\n  var indexOf = arrayIncludes.indexOf;\n  var objectKeysInternal = function (object, names) {\n    var O = toIndexedObject(object);\n    var i = 0;\n    var result = [];\n    var key;\n    for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n    // Don't enum bug & hidden keys\n    while (names.length > i) if (has(O, key = names[i++])) {\n      ~indexOf(result, key) || result.push(key);\n    }\n    return result;\n  };\n\n  // IE8- don't enum bug keys\n  var enumBugKeys = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];\n  var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype');\n\n  // `Object.getOwnPropertyNames` method\n  // https://tc39.es/ecma262/#sec-object.getownpropertynames\n  // eslint-disable-next-line es/no-object-getownpropertynames -- safe\n  var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n    return objectKeysInternal(O, hiddenKeys$1);\n  };\n  var objectGetOwnPropertyNames = {\n    f: f$3\n  };\n\n  // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\n  var f$4 = Object.getOwnPropertySymbols;\n  var objectGetOwnPropertySymbols = {\n    f: f$4\n  };\n\n  // all object keys, includes non-enumerable and symbols\n  var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n    var keys = objectGetOwnPropertyNames.f(anObject(it));\n    var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;\n    return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n  };\n  var copyConstructorProperties = function (target, source) {\n    var keys = ownKeys(source);\n    var defineProperty = objectDefineProperty.f;\n    var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n    }\n  };\n  var replacement = /#|\\.prototype\\./;\n  var isForced = function (feature, detection) {\n    var value = data[normalize(feature)];\n    return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection;\n  };\n  var normalize = isForced.normalize = function (string) {\n    return String(string).replace(replacement, '.').toLowerCase();\n  };\n  var data = isForced.data = {};\n  var NATIVE = isForced.NATIVE = 'N';\n  var POLYFILL = isForced.POLYFILL = 'P';\n  var isForced_1 = isForced;\n  var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;\n\n  /*\n    options.target      - name of the target object\n    options.global      - target is the global object\n    options.stat        - export as static methods of target\n    options.proto       - export as prototype methods of target\n    options.real        - real prototype method for the `pure` version\n    options.forced      - export even if the native feature is available\n    options.bind        - bind methods to the target, required for the `pure` version\n    options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n    options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n    options.sham        - add a flag to not completely full polyfills\n    options.enumerable  - export as enumerable property\n    options.noTargetGet - prevent calling a getter on target\n  */\n  var _export = function (options, source) {\n    var TARGET = options.target;\n    var GLOBAL = options.global;\n    var STATIC = options.stat;\n    var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n    if (GLOBAL) {\n      target = global_1;\n    } else if (STATIC) {\n      target = global_1[TARGET] || setGlobal(TARGET, {});\n    } else {\n      target = (global_1[TARGET] || {}).prototype;\n    }\n    if (target) for (key in source) {\n      sourceProperty = source[key];\n      if (options.noTargetGet) {\n        descriptor = getOwnPropertyDescriptor$1(target, key);\n        targetProperty = descriptor && descriptor.value;\n      } else targetProperty = target[key];\n      FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n      // contained in target\n      if (!FORCED && targetProperty !== undefined) {\n        if (typeof sourceProperty === typeof targetProperty) continue;\n        copyConstructorProperties(sourceProperty, targetProperty);\n      }\n      // add a flag to not completely full polyfills\n      if (options.sham || targetProperty && targetProperty.sham) {\n        createNonEnumerableProperty(sourceProperty, 'sham', true);\n      }\n      // extend global\n      redefine(target, key, sourceProperty, options);\n    }\n  };\n\n  // `Object.keys` method\n  // https://tc39.es/ecma262/#sec-object.keys\n  // eslint-disable-next-line es/no-object-keys -- safe\n  var objectKeys = Object.keys || function keys(O) {\n    return objectKeysInternal(O, enumBugKeys);\n  };\n  var propertyIsEnumerable = objectPropertyIsEnumerable.f;\n\n  // `Object.{ entries, values }` methods implementation\n  var createMethod$1 = function (TO_ENTRIES) {\n    return function (it) {\n      var O = toIndexedObject(it);\n      var keys = objectKeys(O);\n      var length = keys.length;\n      var i = 0;\n      var result = [];\n      var key;\n      while (length > i) {\n        key = keys[i++];\n        if (!descriptors || propertyIsEnumerable.call(O, key)) {\n          result.push(TO_ENTRIES ? [key, O[key]] : O[key]);\n        }\n      }\n      return result;\n    };\n  };\n  var objectToArray = {\n    // `Object.entries` method\n    // https://tc39.es/ecma262/#sec-object.entries\n    entries: createMethod$1(true),\n    // `Object.values` method\n    // https://tc39.es/ecma262/#sec-object.values\n    values: createMethod$1(false)\n  };\n  var $values = objectToArray.values;\n\n  // `Object.values` method\n  // https://tc39.es/ecma262/#sec-object.values\n  _export({\n    target: 'Object',\n    stat: true\n  }, {\n    values: function values(O) {\n      return $values(O);\n    }\n  });\n  var values = path.Object.values;\n  var engineIsNode = classofRaw(global_1.process) == 'process';\n  var engineUserAgent = getBuiltIn('navigator', 'userAgent') || '';\n  var process = global_1.process;\n  var versions = process && process.versions;\n  var v8 = versions && versions.v8;\n  var match, version;\n  if (v8) {\n    match = v8.split('.');\n    version = match[0] + match[1];\n  } else if (engineUserAgent) {\n    match = engineUserAgent.match(/Edge\\/(\\d+)/);\n    if (!match || match[1] >= 74) {\n      match = engineUserAgent.match(/Chrome\\/(\\d+)/);\n      if (match) version = match[1];\n    }\n  }\n  var engineV8Version = version && +version;\n\n  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\n  var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {\n    // eslint-disable-next-line es/no-symbol -- required for testing\n    return !Symbol.sham && (\n    // Chrome 38 Symbol has incorrect toString conversion\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    engineIsNode ? engineV8Version === 38 : engineV8Version > 37 && engineV8Version < 41);\n  });\n\n  /* eslint-disable es/no-symbol -- required for testing */\n\n  var useSymbolAsUid = nativeSymbol && !Symbol.sham && typeof Symbol.iterator == 'symbol';\n  var WellKnownSymbolsStore = shared('wks');\n  var Symbol$1 = global_1.Symbol;\n  var createWellKnownSymbol = useSymbolAsUid ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid;\n  var wellKnownSymbol = function (name) {\n    if (!has(WellKnownSymbolsStore, name) || !(nativeSymbol || typeof WellKnownSymbolsStore[name] == 'string')) {\n      if (nativeSymbol && has(Symbol$1, name)) {\n        WellKnownSymbolsStore[name] = Symbol$1[name];\n      } else {\n        WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n      }\n    }\n    return WellKnownSymbolsStore[name];\n  };\n\n  // `Object.defineProperties` method\n  // https://tc39.es/ecma262/#sec-object.defineproperties\n  // eslint-disable-next-line es/no-object-defineproperties -- safe\n  var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) {\n    anObject(O);\n    var keys = objectKeys(Properties);\n    var length = keys.length;\n    var index = 0;\n    var key;\n    while (length > index) objectDefineProperty.f(O, key = keys[index++], Properties[key]);\n    return O;\n  };\n  var html = getBuiltIn('document', 'documentElement');\n  var GT = '>';\n  var LT = '<';\n  var PROTOTYPE = 'prototype';\n  var SCRIPT = 'script';\n  var IE_PROTO = sharedKey('IE_PROTO');\n  var EmptyConstructor = function () {/* empty */};\n  var scriptTag = function (content) {\n    return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n  };\n\n  // Create object with fake `null` prototype: use ActiveX Object with cleared prototype\n  var NullProtoObjectViaActiveX = function (activeXDocument) {\n    activeXDocument.write(scriptTag(''));\n    activeXDocument.close();\n    var temp = activeXDocument.parentWindow.Object;\n    activeXDocument = null; // avoid memory leak\n    return temp;\n  };\n\n  // Create object with fake `null` prototype: use iframe Object with cleared prototype\n  var NullProtoObjectViaIFrame = function () {\n    // Thrash, waste and sodomy: IE GC bug\n    var iframe = documentCreateElement('iframe');\n    var JS = 'java' + SCRIPT + ':';\n    var iframeDocument;\n    iframe.style.display = 'none';\n    html.appendChild(iframe);\n    // https://github.com/zloirock/core-js/issues/475\n    iframe.src = String(JS);\n    iframeDocument = iframe.contentWindow.document;\n    iframeDocument.open();\n    iframeDocument.write(scriptTag('document.F=Object'));\n    iframeDocument.close();\n    return iframeDocument.F;\n  };\n\n  // Check for document.domain and active x support\n  // No need to use active x approach when document.domain is not set\n  // see https://github.com/es-shims/es5-shim/issues/150\n  // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n  // avoid IE GC bug\n  var activeXDocument;\n  var NullProtoObject = function () {\n    try {\n      /* global ActiveXObject -- old IE */\n      activeXDocument = document.domain && new ActiveXObject('htmlfile');\n    } catch (error) {/* ignore */}\n    NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n    var length = enumBugKeys.length;\n    while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n    return NullProtoObject();\n  };\n  hiddenKeys[IE_PROTO] = true;\n\n  // `Object.create` method\n  // https://tc39.es/ecma262/#sec-object.create\n  var objectCreate = Object.create || function create(O, Properties) {\n    var result;\n    if (O !== null) {\n      EmptyConstructor[PROTOTYPE] = anObject(O);\n      result = new EmptyConstructor();\n      EmptyConstructor[PROTOTYPE] = null;\n      // add \"__proto__\" for Object.getPrototypeOf polyfill\n      result[IE_PROTO] = O;\n    } else result = NullProtoObject();\n    return Properties === undefined ? result : objectDefineProperties(result, Properties);\n  };\n  var UNSCOPABLES = wellKnownSymbol('unscopables');\n  var ArrayPrototype = Array.prototype;\n\n  // Array.prototype[@@unscopables]\n  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\n  if (ArrayPrototype[UNSCOPABLES] == undefined) {\n    objectDefineProperty.f(ArrayPrototype, UNSCOPABLES, {\n      configurable: true,\n      value: objectCreate(null)\n    });\n  }\n\n  // add a key to Array.prototype[@@unscopables]\n  var addToUnscopables = function (key) {\n    ArrayPrototype[UNSCOPABLES][key] = true;\n  };\n  var $includes = arrayIncludes.includes;\n\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  _export({\n    target: 'Array',\n    proto: true\n  }, {\n    includes: function includes(el /* , fromIndex = 0 */) {\n      return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n    }\n  });\n\n  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\n  addToUnscopables('includes');\n  var aFunction$1 = function (it) {\n    if (typeof it != 'function') {\n      throw TypeError(String(it) + ' is not a function');\n    }\n    return it;\n  };\n\n  // optional / simple context binding\n  var functionBindContext = function (fn, that, length) {\n    aFunction$1(fn);\n    if (that === undefined) return fn;\n    switch (length) {\n      case 0:\n        return function () {\n          return fn.call(that);\n        };\n      case 1:\n        return function (a) {\n          return fn.call(that, a);\n        };\n      case 2:\n        return function (a, b) {\n          return fn.call(that, a, b);\n        };\n      case 3:\n        return function (a, b, c) {\n          return fn.call(that, a, b, c);\n        };\n    }\n    return function /* ...args */\n    () {\n      return fn.apply(that, arguments);\n    };\n  };\n  var call = Function.call;\n  var entryUnbind = function (CONSTRUCTOR, METHOD, length) {\n    return functionBindContext(call, global_1[CONSTRUCTOR].prototype[METHOD], length);\n  };\n  var includes = entryUnbind('Array', 'includes');\n\n  /**\r\n   * Map of all Contentful block types. Blocks contain inline or block nodes.\r\n   */\n  var BLOCKS;\n  (function (BLOCKS) {\n    BLOCKS[\"DOCUMENT\"] = \"document\";\n    BLOCKS[\"PARAGRAPH\"] = \"paragraph\";\n    BLOCKS[\"HEADING_1\"] = \"heading-1\";\n    BLOCKS[\"HEADING_2\"] = \"heading-2\";\n    BLOCKS[\"HEADING_3\"] = \"heading-3\";\n    BLOCKS[\"HEADING_4\"] = \"heading-4\";\n    BLOCKS[\"HEADING_5\"] = \"heading-5\";\n    BLOCKS[\"HEADING_6\"] = \"heading-6\";\n    BLOCKS[\"OL_LIST\"] = \"ordered-list\";\n    BLOCKS[\"UL_LIST\"] = \"unordered-list\";\n    BLOCKS[\"LIST_ITEM\"] = \"list-item\";\n    BLOCKS[\"HR\"] = \"hr\";\n    BLOCKS[\"QUOTE\"] = \"blockquote\";\n    BLOCKS[\"EMBEDDED_ENTRY\"] = \"embedded-entry-block\";\n    BLOCKS[\"EMBEDDED_ASSET\"] = \"embedded-asset-block\";\n  })(BLOCKS || (BLOCKS = {}));\n  var BLOCKS$1 = BLOCKS;\n\n  /**\r\n   * Map of all Contentful inline types. Inline contain inline or text nodes.\r\n   */\n  var INLINES;\n  (function (INLINES) {\n    INLINES[\"HYPERLINK\"] = \"hyperlink\";\n    INLINES[\"ENTRY_HYPERLINK\"] = \"entry-hyperlink\";\n    INLINES[\"ASSET_HYPERLINK\"] = \"asset-hyperlink\";\n    INLINES[\"EMBEDDED_ENTRY\"] = \"embedded-entry-inline\";\n  })(INLINES || (INLINES = {}));\n  var INLINES$1 = INLINES;\n\n  /**\r\n   * Map of all Contentful marks.\r\n   */\n  var marks = {\n    BOLD: 'bold',\n    ITALIC: 'italic',\n    UNDERLINE: 'underline',\n    CODE: 'code'\n  };\n  var _a;\n  /**\r\n   * Array of all top level block types.\r\n   * Only these block types can be the direct children of the document.\r\n   */\n  var TOP_LEVEL_BLOCKS = [BLOCKS$1.PARAGRAPH, BLOCKS$1.HEADING_1, BLOCKS$1.HEADING_2, BLOCKS$1.HEADING_3, BLOCKS$1.HEADING_4, BLOCKS$1.HEADING_5, BLOCKS$1.HEADING_6, BLOCKS$1.OL_LIST, BLOCKS$1.UL_LIST, BLOCKS$1.HR, BLOCKS$1.QUOTE, BLOCKS$1.EMBEDDED_ENTRY, BLOCKS$1.EMBEDDED_ASSET];\n  /**\r\n   * Array of all void block types\r\n   */\n  var VOID_BLOCKS = [BLOCKS$1.HR, BLOCKS$1.EMBEDDED_ENTRY, BLOCKS$1.EMBEDDED_ASSET];\n  /**\r\n   * Dictionary of all container block types, and the set block types they accept as children.\r\n   */\n  var CONTAINERS = (_a = {}, _a[BLOCKS$1.OL_LIST] = [BLOCKS$1.LIST_ITEM], _a[BLOCKS$1.UL_LIST] = [BLOCKS$1.LIST_ITEM], _a[BLOCKS$1.LIST_ITEM] = TOP_LEVEL_BLOCKS.slice(), _a[BLOCKS$1.QUOTE] = [BLOCKS$1.PARAGRAPH], _a);\n\n  /**\r\n   * A rich text document considered to be empty.\r\n   * Any other document structure than this is not considered empty.\r\n   */\n  var EMPTY_DOCUMENT = {\n    nodeType: BLOCKS$1.DOCUMENT,\n    data: {},\n    content: [{\n      nodeType: BLOCKS$1.PARAGRAPH,\n      data: {},\n      content: [{\n        nodeType: 'text',\n        value: '',\n        marks: [],\n        data: {}\n      }]\n    }]\n  };\n\n  /**\r\n   * Checks if the node is an instance of Inline.\r\n   */\n  function isInline(node) {\n    return Object.values(INLINES$1).includes(node.nodeType);\n  }\n  /**\r\n   * Checks if the node is an instance of Block.\r\n   */\n  function isBlock(node) {\n    return Object.values(BLOCKS$1).includes(node.nodeType);\n  }\n  /**\r\n   * Checks if the node is an instance of Text.\r\n   */\n  function isText(node) {\n    return node.nodeType === 'text';\n  }\n  var helpers = /*#__PURE__*/Object.freeze({\n    isInline: isInline,\n    isBlock: isBlock,\n    isText: isText\n  });\n  exports.BLOCKS = BLOCKS$1;\n  exports.CONTAINERS = CONTAINERS;\n  exports.EMPTY_DOCUMENT = EMPTY_DOCUMENT;\n  exports.INLINES = INLINES$1;\n  exports.MARKS = marks;\n  exports.TOP_LEVEL_BLOCKS = TOP_LEVEL_BLOCKS;\n  exports.VOID_BLOCKS = VOID_BLOCKS;\n  exports.helpers = helpers;\n});\nunwrapExports(richTextTypes_es5);\nvar richTextTypes_es5_1 = richTextTypes_es5.BLOCKS;\nvar richTextTypes_es5_2 = richTextTypes_es5.CONTAINERS;\nvar richTextTypes_es5_3 = richTextTypes_es5.EMPTY_DOCUMENT;\nvar richTextTypes_es5_4 = richTextTypes_es5.INLINES;\nvar richTextTypes_es5_5 = richTextTypes_es5.MARKS;\nvar richTextTypes_es5_6 = richTextTypes_es5.TOP_LEVEL_BLOCKS;\nvar richTextTypes_es5_7 = richTextTypes_es5.VOID_BLOCKS;\nvar richTextTypes_es5_8 = richTextTypes_es5.helpers;\nfunction appendKeyToValidElement(element, key) {\n  if (React.isValidElement(element) && element.key === null) {\n    return React.cloneElement(element, {\n      key: key\n    });\n  }\n  return element;\n}\nfunction nodeListToReactComponents(nodes, options) {\n  return nodes.map(function (node, index) {\n    return appendKeyToValidElement(nodeToReactComponent(node, options), index);\n  });\n}\nfunction nodeToReactComponent(node, options) {\n  var renderNode = options.renderNode,\n    renderMark = options.renderMark,\n    renderText = options.renderText;\n  if (richTextTypes_es5_8.isText(node)) {\n    return node.marks.reduce(function (value, mark) {\n      if (!renderMark[mark.type]) {\n        return value;\n      }\n      return renderMark[mark.type](value);\n    }, renderText ? renderText(node.value) : node.value);\n  } else {\n    var children = nodeListToReactComponents(node.content, options);\n    if (!node.nodeType || !renderNode[node.nodeType]) {\n      return React__default.createElement(React__default.Fragment, null, children);\n    }\n    return renderNode[node.nodeType](node, children);\n  }\n}\nvar _a, _b;\nvar defaultNodeRenderers = (_a = {}, _a[richTextTypes_es5_1.DOCUMENT] = function (node, children) {\n  return children;\n}, _a[richTextTypes_es5_1.PARAGRAPH] = function (node, children) {\n  return React__default.createElement(\"p\", null, children);\n}, _a[richTextTypes_es5_1.HEADING_1] = function (node, children) {\n  return React__default.createElement(\"h1\", null, children);\n}, _a[richTextTypes_es5_1.HEADING_2] = function (node, children) {\n  return React__default.createElement(\"h2\", null, children);\n}, _a[richTextTypes_es5_1.HEADING_3] = function (node, children) {\n  return React__default.createElement(\"h3\", null, children);\n}, _a[richTextTypes_es5_1.HEADING_4] = function (node, children) {\n  return React__default.createElement(\"h4\", null, children);\n}, _a[richTextTypes_es5_1.HEADING_5] = function (node, children) {\n  return React__default.createElement(\"h5\", null, children);\n}, _a[richTextTypes_es5_1.HEADING_6] = function (node, children) {\n  return React__default.createElement(\"h6\", null, children);\n}, _a[richTextTypes_es5_1.EMBEDDED_ENTRY] = function (node, children) {\n  return React__default.createElement(\"div\", null, children);\n}, _a[richTextTypes_es5_1.UL_LIST] = function (node, children) {\n  return React__default.createElement(\"ul\", null, children);\n}, _a[richTextTypes_es5_1.OL_LIST] = function (node, children) {\n  return React__default.createElement(\"ol\", null, children);\n}, _a[richTextTypes_es5_1.LIST_ITEM] = function (node, children) {\n  return React__default.createElement(\"li\", null, children);\n}, _a[richTextTypes_es5_1.QUOTE] = function (node, children) {\n  return React__default.createElement(\"blockquote\", null, children);\n}, _a[richTextTypes_es5_1.HR] = function () {\n  return React__default.createElement(\"hr\", null);\n}, _a[richTextTypes_es5_4.ASSET_HYPERLINK] = function (node) {\n  return defaultInline(richTextTypes_es5_4.ASSET_HYPERLINK, node);\n}, _a[richTextTypes_es5_4.ENTRY_HYPERLINK] = function (node) {\n  return defaultInline(richTextTypes_es5_4.ENTRY_HYPERLINK, node);\n}, _a[richTextTypes_es5_4.EMBEDDED_ENTRY] = function (node) {\n  return defaultInline(richTextTypes_es5_4.EMBEDDED_ENTRY, node);\n}, _a[richTextTypes_es5_4.HYPERLINK] = function (node, children) {\n  return React__default.createElement(\"a\", {\n    href: node.data.uri\n  }, children);\n}, _a);\nvar defaultMarkRenderers = (_b = {}, _b[richTextTypes_es5_5.BOLD] = function (text) {\n  return React__default.createElement(\"b\", null, text);\n}, _b[richTextTypes_es5_5.ITALIC] = function (text) {\n  return React__default.createElement(\"i\", null, text);\n}, _b[richTextTypes_es5_5.UNDERLINE] = function (text) {\n  return React__default.createElement(\"u\", null, text);\n}, _b[richTextTypes_es5_5.CODE] = function (text) {\n  return React__default.createElement(\"code\", null, text);\n}, _b);\nfunction defaultInline(type, node) {\n  return React__default.createElement(\"span\", {\n    key: node.data.target.sys.id\n  }, \"type: \", node.nodeType, \" id: \", node.data.target.sys.id);\n}\n/**\r\n * Serialize a Contentful Rich Text `document` to React tree\r\n */\nfunction documentToReactComponents(richTextDocument, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  if (!richTextDocument) {\n    return null;\n  }\n  return nodeToReactComponent(richTextDocument, {\n    renderNode: __assign({}, defaultNodeRenderers, options.renderNode),\n    renderMark: __assign({}, defaultMarkRenderers, options.renderMark),\n    renderText: options.renderText\n  });\n}\nexports.documentToReactComponents = documentToReactComponents;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\nfunction createCommonjsModule(fn, module) {\n  return module = {\n    exports: {}\n  }, fn(module, module.exports), module.exports;\n}\nvar check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global_1 =\n// eslint-disable-next-line no-undef\ncheck(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || check(typeof self == 'object' && self) || check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||\n// eslint-disable-next-line no-new-func\nFunction('return this')();\nvar fails = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n\n// Thank's IE8 for his funny defineProperty\nvar descriptors = !fails(function () {\n  return Object.defineProperty({}, 1, {\n    get: function () {\n      return 7;\n    }\n  })[1] != 7;\n});\nvar nativePropertyIsEnumerable = {}.propertyIsEnumerable;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({\n  1: 2\n}, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable\nvar f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : nativePropertyIsEnumerable;\nvar objectPropertyIsEnumerable = {\n  f: f\n};\nvar createPropertyDescriptor = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\nvar toString = {}.toString;\nvar classofRaw = function (it) {\n  return toString.call(it).slice(8, -1);\n};\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar indexedObject = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.github.io/ecma262/#sec-requireobjectcoercible\nvar requireObjectCoercible = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n\n// toObject with fallback for non-array-like ES3 strings\n\nvar toIndexedObject = function (it) {\n  return indexedObject(requireObjectCoercible(it));\n};\nvar isObject = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n// `ToPrimitive` abstract operation\n// https://tc39.github.io/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nvar toPrimitive = function (input, PREFERRED_STRING) {\n  if (!isObject(input)) return input;\n  var fn, val;\n  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\nvar hasOwnProperty = {}.hasOwnProperty;\nvar has = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\nvar document$1 = global_1.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document$1) && isObject(document$1.createElement);\nvar documentCreateElement = function (it) {\n  return EXISTS ? document$1.createElement(it) : {};\n};\n\n// Thank's IE8 for his funny defineProperty\nvar ie8DomDefine = !descriptors && !fails(function () {\n  return Object.defineProperty(documentCreateElement('div'), 'a', {\n    get: function () {\n      return 7;\n    }\n  }).a != 7;\n});\nvar nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor\nvar f$1 = descriptors ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (ie8DomDefine) try {\n    return nativeGetOwnPropertyDescriptor(O, P);\n  } catch (error) {/* empty */}\n  if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);\n};\nvar objectGetOwnPropertyDescriptor = {\n  f: f$1\n};\nvar anObject = function (it) {\n  if (!isObject(it)) {\n    throw TypeError(String(it) + ' is not an object');\n  }\n  return it;\n};\nvar nativeDefineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.github.io/ecma262/#sec-object.defineproperty\nvar f$2 = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (ie8DomDefine) try {\n    return nativeDefineProperty(O, P, Attributes);\n  } catch (error) {/* empty */}\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\nvar objectDefineProperty = {\n  f: f$2\n};\nvar createNonEnumerableProperty = descriptors ? function (object, key, value) {\n  return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\nvar setGlobal = function (key, value) {\n  try {\n    createNonEnumerableProperty(global_1, key, value);\n  } catch (error) {\n    global_1[key] = value;\n  }\n  return value;\n};\nvar SHARED = '__core-js_shared__';\nvar store = global_1[SHARED] || setGlobal(SHARED, {});\nvar sharedStore = store;\nvar functionToString = Function.toString;\n\n// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof sharedStore.inspectSource != 'function') {\n  sharedStore.inspectSource = function (it) {\n    return functionToString.call(it);\n  };\n}\nvar inspectSource = sharedStore.inspectSource;\nvar WeakMap = global_1.WeakMap;\nvar nativeWeakMap = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\nvar shared = createCommonjsModule(function (module) {\n  (module.exports = function (key, value) {\n    return sharedStore[key] || (sharedStore[key] = value !== undefined ? value : {});\n  })('versions', []).push({\n    version: '3.6.5',\n    mode: 'global',\n    copyright: '© 2020 Denis Pushkarev (zloirock.ru)'\n  });\n});\nvar id = 0;\nvar postfix = Math.random();\nvar uid = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\nvar keys = shared('keys');\nvar sharedKey = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\nvar hiddenKeys = {};\nvar WeakMap$1 = global_1.WeakMap;\nvar set, get, has$1;\nvar enforce = function (it) {\n  return has$1(it) ? get(it) : set(it, {});\n};\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    }\n    return state;\n  };\n};\nif (nativeWeakMap) {\n  var store$1 = new WeakMap$1();\n  var wmget = store$1.get;\n  var wmhas = store$1.has;\n  var wmset = store$1.set;\n  set = function (it, metadata) {\n    wmset.call(store$1, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget.call(store$1, it) || {};\n  };\n  has$1 = function (it) {\n    return wmhas.call(store$1, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return has(it, STATE) ? it[STATE] : {};\n  };\n  has$1 = function (it) {\n    return has(it, STATE);\n  };\n}\nvar internalState = {\n  set: set,\n  get: get,\n  has: has$1,\n  enforce: enforce,\n  getterFor: getterFor\n};\nvar redefine = createCommonjsModule(function (module) {\n  var getInternalState = internalState.get;\n  var enforceInternalState = internalState.enforce;\n  var TEMPLATE = String(String).split('String');\n  (module.exports = function (O, key, value, options) {\n    var unsafe = options ? !!options.unsafe : false;\n    var simple = options ? !!options.enumerable : false;\n    var noTargetGet = options ? !!options.noTargetGet : false;\n    if (typeof value == 'function') {\n      if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key);\n      enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');\n    }\n    if (O === global_1) {\n      if (simple) O[key] = value;else setGlobal(key, value);\n      return;\n    } else if (!unsafe) {\n      delete O[key];\n    } else if (!noTargetGet && O[key]) {\n      simple = true;\n    }\n    if (simple) O[key] = value;else createNonEnumerableProperty(O, key, value);\n    // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n  })(Function.prototype, 'toString', function toString() {\n    return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n  });\n});\nvar path = global_1;\nvar aFunction = function (variable) {\n  return typeof variable == 'function' ? variable : undefined;\n};\nvar getBuiltIn = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global_1[namespace]) : path[namespace] && path[namespace][method] || global_1[namespace] && global_1[namespace][method];\n};\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.github.io/ecma262/#sec-tointeger\nvar toInteger = function (argument) {\n  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.github.io/ecma262/#sec-tolength\nvar toLength = function (argument) {\n  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\nvar max = Math.max;\nvar min$1 = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nvar toAbsoluteIndex = function (index, length) {\n  var integer = toInteger(index);\n  return integer < 0 ? max(integer + length, 0) : min$1(integer, length);\n};\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n      // Array#indexOf ignores holes, Array#includes - not\n    } else for (; length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    }\n    return !IS_INCLUDES && -1;\n  };\n};\nvar arrayIncludes = {\n  // `Array.prototype.includes` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\nvar indexOf = arrayIncludes.indexOf;\nvar objectKeysInternal = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~indexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n\n// IE8- don't enum bug keys\nvar enumBugKeys = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];\nvar hiddenKeys$1 = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.github.io/ecma262/#sec-object.getownpropertynames\nvar f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return objectKeysInternal(O, hiddenKeys$1);\n};\nvar objectGetOwnPropertyNames = {\n  f: f$3\n};\nvar f$4 = Object.getOwnPropertySymbols;\nvar objectGetOwnPropertySymbols = {\n  f: f$4\n};\n\n// all object keys, includes non-enumerable and symbols\nvar ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = objectGetOwnPropertyNames.f(anObject(it));\n  var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;\n  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\nvar copyConstructorProperties = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = objectDefineProperty.f;\n  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\nvar replacement = /#|\\.prototype\\./;\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection;\n};\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\nvar isForced_1 = isForced;\nvar getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n*/\nvar _export = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global_1;\n  } else if (STATIC) {\n    target = global_1[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global_1[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor$1(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty === typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || targetProperty && targetProperty.sham) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n\n// `Object.keys` method\n// https://tc39.github.io/ecma262/#sec-object.keys\nvar objectKeys = Object.keys || function keys(O) {\n  return objectKeysInternal(O, enumBugKeys);\n};\nvar propertyIsEnumerable = objectPropertyIsEnumerable.f;\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod$1 = function (TO_ENTRIES) {\n  return function (it) {\n    var O = toIndexedObject(it);\n    var keys = objectKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!descriptors || propertyIsEnumerable.call(O, key)) {\n        result.push(TO_ENTRIES ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\nvar objectToArray = {\n  // `Object.entries` method\n  // https://tc39.github.io/ecma262/#sec-object.entries\n  entries: createMethod$1(true),\n  // `Object.values` method\n  // https://tc39.github.io/ecma262/#sec-object.values\n  values: createMethod$1(false)\n};\nvar $values = objectToArray.values;\n\n// `Object.values` method\n// https://tc39.github.io/ecma262/#sec-object.values\n_export({\n  target: 'Object',\n  stat: true\n}, {\n  values: function values(O) {\n    return $values(O);\n  }\n});\nvar values = path.Object.values;\nvar nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {\n  // Chrome 38 Symbol has incorrect toString conversion\n  // eslint-disable-next-line no-undef\n  return !String(Symbol());\n});\nvar useSymbolAsUid = nativeSymbol\n// eslint-disable-next-line no-undef\n&& !Symbol.sham\n// eslint-disable-next-line no-undef\n&& typeof Symbol.iterator == 'symbol';\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol$1 = global_1.Symbol;\nvar createWellKnownSymbol = useSymbolAsUid ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid;\nvar wellKnownSymbol = function (name) {\n  if (!has(WellKnownSymbolsStore, name)) {\n    if (nativeSymbol && has(Symbol$1, name)) WellKnownSymbolsStore[name] = Symbol$1[name];else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n  }\n  return WellKnownSymbolsStore[name];\n};\n\n// `Object.defineProperties` method\n// https://tc39.github.io/ecma262/#sec-object.defineproperties\nvar objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) objectDefineProperty.f(O, key = keys[index++], Properties[key]);\n  return O;\n};\nvar html = getBuiltIn('document', 'documentElement');\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar EmptyConstructor = function () {/* empty */};\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    /* global ActiveXObject */\n    activeXDocument = document.domain && new ActiveXObject('htmlfile');\n  } catch (error) {/* ignore */}\n  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.github.io/ecma262/#sec-object.create\nvar objectCreate = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : objectDefineProperties(result, Properties);\n};\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  objectDefineProperty.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: objectCreate(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nvar addToUnscopables = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\nvar defineProperty = Object.defineProperty;\nvar cache = {};\nvar thrower = function (it) {\n  throw it;\n};\nvar arrayMethodUsesToLength = function (METHOD_NAME, options) {\n  if (has(cache, METHOD_NAME)) return cache[METHOD_NAME];\n  if (!options) options = {};\n  var method = [][METHOD_NAME];\n  var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;\n  var argument0 = has(options, 0) ? options[0] : thrower;\n  var argument1 = has(options, 1) ? options[1] : undefined;\n  return cache[METHOD_NAME] = !!method && !fails(function () {\n    if (ACCESSORS && !descriptors) return true;\n    var O = {\n      length: -1\n    };\n    if (ACCESSORS) defineProperty(O, 1, {\n      enumerable: true,\n      get: thrower\n    });else O[1] = 1;\n    method.call(O, argument0, argument1);\n  });\n};\nvar $includes = arrayIncludes.includes;\nvar USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', {\n  ACCESSORS: true,\n  1: 0\n});\n\n// `Array.prototype.includes` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.includes\n_export({\n  target: 'Array',\n  proto: true,\n  forced: !USES_TO_LENGTH\n}, {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\nvar aFunction$1 = function (it) {\n  if (typeof it != 'function') {\n    throw TypeError(String(it) + ' is not a function');\n  }\n  return it;\n};\n\n// optional / simple context binding\nvar functionBindContext = function (fn, that, length) {\n  aFunction$1(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 0:\n      return function () {\n        return fn.call(that);\n      };\n    case 1:\n      return function (a) {\n        return fn.call(that, a);\n      };\n    case 2:\n      return function (a, b) {\n        return fn.call(that, a, b);\n      };\n    case 3:\n      return function (a, b, c) {\n        return fn.call(that, a, b, c);\n      };\n  }\n  return function /* ...args */\n  () {\n    return fn.apply(that, arguments);\n  };\n};\nvar call = Function.call;\nvar entryUnbind = function (CONSTRUCTOR, METHOD, length) {\n  return functionBindContext(call, global_1[CONSTRUCTOR].prototype[METHOD], length);\n};\nvar includes = entryUnbind('Array', 'includes');\n\n/**\r\n * Map of all Contentful block types. Blocks contain inline or block nodes.\r\n */\nvar BLOCKS;\n(function (BLOCKS) {\n  BLOCKS[\"DOCUMENT\"] = \"document\";\n  BLOCKS[\"PARAGRAPH\"] = \"paragraph\";\n  BLOCKS[\"HEADING_1\"] = \"heading-1\";\n  BLOCKS[\"HEADING_2\"] = \"heading-2\";\n  BLOCKS[\"HEADING_3\"] = \"heading-3\";\n  BLOCKS[\"HEADING_4\"] = \"heading-4\";\n  BLOCKS[\"HEADING_5\"] = \"heading-5\";\n  BLOCKS[\"HEADING_6\"] = \"heading-6\";\n  BLOCKS[\"OL_LIST\"] = \"ordered-list\";\n  BLOCKS[\"UL_LIST\"] = \"unordered-list\";\n  BLOCKS[\"LIST_ITEM\"] = \"list-item\";\n  BLOCKS[\"HR\"] = \"hr\";\n  BLOCKS[\"QUOTE\"] = \"blockquote\";\n  BLOCKS[\"EMBEDDED_ENTRY\"] = \"embedded-entry-block\";\n  BLOCKS[\"EMBEDDED_ASSET\"] = \"embedded-asset-block\";\n})(BLOCKS || (BLOCKS = {}));\nvar BLOCKS$1 = BLOCKS;\n\n/**\r\n * Map of all Contentful inline types. Inline contain inline or text nodes.\r\n */\nvar INLINES;\n(function (INLINES) {\n  INLINES[\"HYPERLINK\"] = \"hyperlink\";\n  INLINES[\"ENTRY_HYPERLINK\"] = \"entry-hyperlink\";\n  INLINES[\"ASSET_HYPERLINK\"] = \"asset-hyperlink\";\n  INLINES[\"EMBEDDED_ENTRY\"] = \"embedded-entry-inline\";\n})(INLINES || (INLINES = {}));\nvar INLINES$1 = INLINES;\n\n/**\r\n * Map of all Contentful marks.\r\n */\nvar marks = {\n  BOLD: 'bold',\n  ITALIC: 'italic',\n  UNDERLINE: 'underline',\n  CODE: 'code'\n};\nvar _a;\n/**\r\n * Array of all top level block types.\r\n * Only these block types can be the direct children of the document.\r\n */\nvar TOP_LEVEL_BLOCKS = [BLOCKS$1.PARAGRAPH, BLOCKS$1.HEADING_1, BLOCKS$1.HEADING_2, BLOCKS$1.HEADING_3, BLOCKS$1.HEADING_4, BLOCKS$1.HEADING_5, BLOCKS$1.HEADING_6, BLOCKS$1.OL_LIST, BLOCKS$1.UL_LIST, BLOCKS$1.HR, BLOCKS$1.QUOTE, BLOCKS$1.EMBEDDED_ENTRY, BLOCKS$1.EMBEDDED_ASSET];\n/**\r\n * Array of all void block types\r\n */\nvar VOID_BLOCKS = [BLOCKS$1.HR, BLOCKS$1.EMBEDDED_ENTRY, BLOCKS$1.EMBEDDED_ASSET];\n/**\r\n * Dictionary of all container block types, and the set block types they accept as children.\r\n */\nvar CONTAINERS = (_a = {}, _a[BLOCKS$1.OL_LIST] = [BLOCKS$1.LIST_ITEM], _a[BLOCKS$1.UL_LIST] = [BLOCKS$1.LIST_ITEM], _a[BLOCKS$1.LIST_ITEM] = TOP_LEVEL_BLOCKS.slice(), _a[BLOCKS$1.QUOTE] = [BLOCKS$1.PARAGRAPH], _a);\n\n/**\r\n * A rich text document considered to be empty.\r\n * Any other document structure than this is not considered empty.\r\n */\nvar EMPTY_DOCUMENT = {\n  nodeType: BLOCKS$1.DOCUMENT,\n  data: {},\n  content: [{\n    nodeType: BLOCKS$1.PARAGRAPH,\n    data: {},\n    content: [{\n      nodeType: 'text',\n      value: '',\n      marks: [],\n      data: {}\n    }]\n  }]\n};\n\n/**\r\n * Checks if the node is an instance of Inline.\r\n */\nfunction isInline(node) {\n  return Object.values(INLINES$1).includes(node.nodeType);\n}\n/**\r\n * Checks if the node is an instance of Block.\r\n */\nfunction isBlock(node) {\n  return Object.values(BLOCKS$1).includes(node.nodeType);\n}\n/**\r\n * Checks if the node is an instance of Text.\r\n */\nfunction isText(node) {\n  return node.nodeType === 'text';\n}\nvar helpers = /*#__PURE__*/Object.freeze({\n  isInline: isInline,\n  isBlock: isBlock,\n  isText: isText\n});\nexports.BLOCKS = BLOCKS$1;\nexports.CONTAINERS = CONTAINERS;\nexports.EMPTY_DOCUMENT = EMPTY_DOCUMENT;\nexports.INLINES = INLINES$1;\nexports.MARKS = marks;\nexports.TOP_LEVEL_BLOCKS = TOP_LEVEL_BLOCKS;\nexports.VOID_BLOCKS = VOID_BLOCKS;\nexports.helpers = helpers;","import { parse, icon } from '@fortawesome/fontawesome-svg-core';\nimport PropTypes from 'prop-types';\nimport React from 'react';\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}\nfunction _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n}\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n}\nfunction _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\n// Get CSS class list from a props object\nfunction classList(props) {\n  var _classes;\n  var beat = props.beat,\n    fade = props.fade,\n    beatFade = props.beatFade,\n    bounce = props.bounce,\n    shake = props.shake,\n    flash = props.flash,\n    spin = props.spin,\n    spinPulse = props.spinPulse,\n    spinReverse = props.spinReverse,\n    pulse = props.pulse,\n    fixedWidth = props.fixedWidth,\n    inverse = props.inverse,\n    border = props.border,\n    listItem = props.listItem,\n    flip = props.flip,\n    size = props.size,\n    rotation = props.rotation,\n    pull = props.pull; // map of CSS class names to properties\n\n  var classes = (_classes = {\n    'fa-beat': beat,\n    'fa-fade': fade,\n    'fa-beat-fade': beatFade,\n    'fa-bounce': bounce,\n    'fa-shake': shake,\n    'fa-flash': flash,\n    'fa-spin': spin,\n    'fa-spin-reverse': spinReverse,\n    'fa-spin-pulse': spinPulse,\n    'fa-pulse': pulse,\n    'fa-fw': fixedWidth,\n    'fa-inverse': inverse,\n    'fa-border': border,\n    'fa-li': listItem,\n    'fa-flip': flip === true,\n    'fa-flip-horizontal': flip === 'horizontal' || flip === 'both',\n    'fa-flip-vertical': flip === 'vertical' || flip === 'both'\n  }, _defineProperty(_classes, \"fa-\".concat(size), typeof size !== 'undefined' && size !== null), _defineProperty(_classes, \"fa-rotate-\".concat(rotation), typeof rotation !== 'undefined' && rotation !== null && rotation !== 0), _defineProperty(_classes, \"fa-pull-\".concat(pull), typeof pull !== 'undefined' && pull !== null), _defineProperty(_classes, 'fa-swap-opacity', props.swapOpacity), _classes); // map over all the keys in the classes object\n  // return an array of the keys where the value for the key is not null\n\n  return Object.keys(classes).map(function (key) {\n    return classes[key] ? key : null;\n  }).filter(function (key) {\n    return key;\n  });\n}\n\n// Camelize taken from humps\n// humps is copyright © 2012+ Dom Christie\n// Released under the MIT license.\n// Performant way to determine if object coerces to a number\nfunction _isNumerical(obj) {\n  obj = obj - 0; // eslint-disable-next-line no-self-compare\n\n  return obj === obj;\n}\nfunction camelize(string) {\n  if (_isNumerical(string)) {\n    return string;\n  } // eslint-disable-next-line no-useless-escape\n\n  string = string.replace(/[\\-_\\s]+(.)?/g, function (match, chr) {\n    return chr ? chr.toUpperCase() : '';\n  }); // Ensure 1st char is always lowercase\n\n  return string.substr(0, 1).toLowerCase() + string.substr(1);\n}\nvar _excluded$1 = [\"style\"];\nfunction capitalize(val) {\n  return val.charAt(0).toUpperCase() + val.slice(1);\n}\nfunction styleToObject(style) {\n  return style.split(';').map(function (s) {\n    return s.trim();\n  }).filter(function (s) {\n    return s;\n  }).reduce(function (acc, pair) {\n    var i = pair.indexOf(':');\n    var prop = camelize(pair.slice(0, i));\n    var value = pair.slice(i + 1).trim();\n    prop.startsWith('webkit') ? acc[capitalize(prop)] = value : acc[prop] = value;\n    return acc;\n  }, {});\n}\nfunction convert(createElement, element) {\n  var extraProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  if (typeof element === 'string') {\n    return element;\n  }\n  var children = (element.children || []).map(function (child) {\n    return convert(createElement, child);\n  });\n  /* eslint-disable dot-notation */\n\n  var mixins = Object.keys(element.attributes || {}).reduce(function (acc, key) {\n    var val = element.attributes[key];\n    switch (key) {\n      case 'class':\n        acc.attrs['className'] = val;\n        delete element.attributes['class'];\n        break;\n      case 'style':\n        acc.attrs['style'] = styleToObject(val);\n        break;\n      default:\n        if (key.indexOf('aria-') === 0 || key.indexOf('data-') === 0) {\n          acc.attrs[key.toLowerCase()] = val;\n        } else {\n          acc.attrs[camelize(key)] = val;\n        }\n    }\n    return acc;\n  }, {\n    attrs: {}\n  });\n  var _extraProps$style = extraProps.style,\n    existingStyle = _extraProps$style === void 0 ? {} : _extraProps$style,\n    remaining = _objectWithoutProperties(extraProps, _excluded$1);\n  mixins.attrs['style'] = _objectSpread2(_objectSpread2({}, mixins.attrs['style']), existingStyle);\n  /* eslint-enable */\n\n  return createElement.apply(void 0, [element.tag, _objectSpread2(_objectSpread2({}, mixins.attrs), remaining)].concat(_toConsumableArray(children)));\n}\nvar PRODUCTION = false;\ntry {\n  PRODUCTION = process.env.NODE_ENV === 'production';\n} catch (e) {}\nfunction log() {\n  if (!PRODUCTION && console && typeof console.error === 'function') {\n    var _console;\n    (_console = console).error.apply(_console, arguments);\n  }\n}\nfunction normalizeIconArgs(icon) {\n  // this has everything that it needs to be rendered which means it was probably imported\n  // directly from an icon svg package\n  if (icon && _typeof(icon) === 'object' && icon.prefix && icon.iconName && icon.icon) {\n    return icon;\n  }\n  if (parse.icon) {\n    return parse.icon(icon);\n  } // if the icon is null, there's nothing to do\n\n  if (icon === null) {\n    return null;\n  } // if the icon is an object and has a prefix and an icon name, return it\n\n  if (icon && _typeof(icon) === 'object' && icon.prefix && icon.iconName) {\n    return icon;\n  } // if it's an array with length of two\n\n  if (Array.isArray(icon) && icon.length === 2) {\n    // use the first item as prefix, second as icon name\n    return {\n      prefix: icon[0],\n      iconName: icon[1]\n    };\n  } // if it's a string, use it as the icon name\n\n  if (typeof icon === 'string') {\n    return {\n      prefix: 'fas',\n      iconName: icon\n    };\n  }\n}\n\n// creates an object with a key of key\n// and a value of value\n// if certain conditions are met\nfunction objectWithKey(key, value) {\n  // if the value is a non-empty array\n  // or it's not an array but it is truthy\n  // then create the object with the key and the value\n  // if not, return an empty array\n  return Array.isArray(value) && value.length > 0 || !Array.isArray(value) && value ? _defineProperty({}, key, value) : {};\n}\nvar _excluded = [\"forwardedRef\"];\nfunction FontAwesomeIcon(_ref) {\n  var forwardedRef = _ref.forwardedRef,\n    props = _objectWithoutProperties(_ref, _excluded);\n  var iconArgs = props.icon,\n    maskArgs = props.mask,\n    symbol = props.symbol,\n    className = props.className,\n    title = props.title,\n    titleId = props.titleId,\n    maskId = props.maskId;\n  var iconLookup = normalizeIconArgs(iconArgs);\n  var classes = objectWithKey('classes', [].concat(_toConsumableArray(classList(props)), _toConsumableArray(className.split(' '))));\n  var transform = objectWithKey('transform', typeof props.transform === 'string' ? parse.transform(props.transform) : props.transform);\n  var mask = objectWithKey('mask', normalizeIconArgs(maskArgs));\n  var renderedIcon = icon(iconLookup, _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, classes), transform), mask), {}, {\n    symbol: symbol,\n    title: title,\n    titleId: titleId,\n    maskId: maskId\n  }));\n  if (!renderedIcon) {\n    log('Could not find icon', iconLookup);\n    return null;\n  }\n  var abstract = renderedIcon.abstract;\n  var extraProps = {\n    ref: forwardedRef\n  };\n  Object.keys(props).forEach(function (key) {\n    // eslint-disable-next-line no-prototype-builtins\n    if (!FontAwesomeIcon.defaultProps.hasOwnProperty(key)) {\n      extraProps[key] = props[key];\n    }\n  });\n  return convertCurry(abstract[0], extraProps);\n}\nFontAwesomeIcon.displayName = 'FontAwesomeIcon';\nFontAwesomeIcon.propTypes = {\n  beat: PropTypes.bool,\n  border: PropTypes.bool,\n  beatFade: PropTypes.bool,\n  bounce: PropTypes.bool,\n  className: PropTypes.string,\n  fade: PropTypes.bool,\n  flash: PropTypes.bool,\n  mask: PropTypes.oneOfType([PropTypes.object, PropTypes.array, PropTypes.string]),\n  maskId: PropTypes.string,\n  fixedWidth: PropTypes.bool,\n  inverse: PropTypes.bool,\n  flip: PropTypes.oneOf([true, false, 'horizontal', 'vertical', 'both']),\n  icon: PropTypes.oneOfType([PropTypes.object, PropTypes.array, PropTypes.string]),\n  listItem: PropTypes.bool,\n  pull: PropTypes.oneOf(['right', 'left']),\n  pulse: PropTypes.bool,\n  rotation: PropTypes.oneOf([0, 90, 180, 270]),\n  shake: PropTypes.bool,\n  size: PropTypes.oneOf(['2xs', 'xs', 'sm', 'lg', 'xl', '2xl', '1x', '2x', '3x', '4x', '5x', '6x', '7x', '8x', '9x', '10x']),\n  spin: PropTypes.bool,\n  spinPulse: PropTypes.bool,\n  spinReverse: PropTypes.bool,\n  symbol: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),\n  title: PropTypes.string,\n  titleId: PropTypes.string,\n  transform: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),\n  swapOpacity: PropTypes.bool\n};\nFontAwesomeIcon.defaultProps = {\n  border: false,\n  className: '',\n  mask: null,\n  maskId: null,\n  fixedWidth: false,\n  inverse: false,\n  flip: false,\n  icon: null,\n  listItem: false,\n  pull: null,\n  pulse: false,\n  rotation: null,\n  size: null,\n  spin: false,\n  spinPulse: false,\n  spinReverse: false,\n  beat: false,\n  fade: false,\n  beatFade: false,\n  bounce: false,\n  shake: false,\n  symbol: false,\n  title: '',\n  titleId: null,\n  transform: null,\n  swapOpacity: false\n};\nvar convertCurry = convert.bind(null, React.createElement);\nexport { FontAwesomeIcon };","var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\nvar _slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n    return _arr;\n  }\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\nfunction _toConsumableArray(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n}\nimport copy from 'fast-copy';\nvar UNRESOLVED_LINK = {}; // unique object to avoid polyfill bloat using Symbol()\n\n/**\n * isLink Function\n * Checks if the object has sys.type \"Link\"\n * @param object\n */\nvar isLink = function isLink(object) {\n  return object && object.sys && object.sys.type === 'Link';\n};\n\n/**\n * isResourceLink Function\n * Checks if the object has sys.type \"ResourceLink\"\n * @param object\n */\nvar isResourceLink = function isResourceLink(object) {\n  return object && object.sys && object.sys.type === 'ResourceLink';\n};\n\n/**\n * Creates a key with spaceId and a key without for entityMap\n *\n * @param {*} sys\n * @param {String} sys.type\n * @param {String} sys.id\n * @param {*} sys.space\n * @param {*} sys.space.sys\n * @param {String} sys.space.id\n * @return {string[]}\n */\nvar makeEntityMapKeys = function makeEntityMapKeys(sys) {\n  if (sys.space && sys.environment) {\n    return [sys.type + '!' + sys.id, sys.space.sys.id + '!' + sys.environment.sys.id + '!' + sys.type + '!' + sys.id];\n  }\n  return [sys.type + '!' + sys.id];\n};\n\n/**\n * Looks up in entityMap\n *\n * @param entityMap\n * @param {*} linkData\n * @param {String} linkData.type\n * @param {String} linkData.linkType\n * @param {String} linkData.id\n * @param {String} linkData.urn\n * @return {String}\n */\nvar lookupInEntityMap = function lookupInEntityMap(entityMap, linkData) {\n  var entryId = linkData.entryId,\n    linkType = linkData.linkType,\n    spaceId = linkData.spaceId,\n    environmentId = linkData.environmentId;\n  if (spaceId && environmentId) {\n    return entityMap.get(spaceId + '!' + environmentId + '!' + linkType + '!' + entryId);\n  }\n  return entityMap.get(linkType + '!' + entryId);\n};\nvar getIdsFromUrn = function getIdsFromUrn(urn) {\n  var regExp = /.*:spaces\\/([^/]+)(?:\\/environments\\/([^/]+))?\\/entries\\/([^/]+)$/;\n  if (!regExp.test(urn)) {\n    return undefined;\n  }\n  var _urn$match = urn.match(regExp),\n    _urn$match2 = _slicedToArray(_urn$match, 4),\n    _ = _urn$match2[0],\n    spaceId = _urn$match2[1],\n    _urn$match2$ = _urn$match2[2],\n    environmentId = _urn$match2$ === undefined ? 'master' : _urn$match2$,\n    entryId = _urn$match2[3];\n  return {\n    spaceId: spaceId,\n    environmentId: environmentId,\n    entryId: entryId\n  };\n};\n\n/**\n * getResolvedLink Function\n *\n * @param entityMap\n * @param link\n * @return {undefined}\n */\nvar getResolvedLink = function getResolvedLink(entityMap, link) {\n  var _link$sys = link.sys,\n    type = _link$sys.type,\n    linkType = _link$sys.linkType;\n  if (type === 'ResourceLink') {\n    var urn = link.sys.urn;\n    var _getIdsFromUrn = getIdsFromUrn(urn),\n      spaceId = _getIdsFromUrn.spaceId,\n      environmentId = _getIdsFromUrn.environmentId,\n      _entryId = _getIdsFromUrn.entryId;\n    var extractedLinkType = linkType.split(':')[1];\n    return lookupInEntityMap(entityMap, {\n      linkType: extractedLinkType,\n      entryId: _entryId,\n      spaceId: spaceId,\n      environmentId: environmentId\n    }) || UNRESOLVED_LINK;\n  }\n  var entryId = link.sys.id;\n  return lookupInEntityMap(entityMap, {\n    linkType: linkType,\n    entryId: entryId\n  }) || UNRESOLVED_LINK;\n};\n\n/**\n * cleanUpLinks Function\n * - Removes unresolvable links from Arrays and Objects\n *\n * @param {Object[]|Object} input\n */\nvar cleanUpLinks = function cleanUpLinks(input) {\n  if (Array.isArray(input)) {\n    return input.filter(function (val) {\n      return val !== UNRESOLVED_LINK;\n    });\n  }\n  for (var key in input) {\n    if (input[key] === UNRESOLVED_LINK) {\n      delete input[key];\n    }\n  }\n  return input;\n};\n\n/**\n * walkMutate Function\n * @param input\n * @param predicate\n * @param mutator\n * @param removeUnresolved\n * @return {*}\n */\nvar walkMutate = function walkMutate(input, predicate, mutator, removeUnresolved) {\n  if (predicate(input)) {\n    return mutator(input);\n  }\n  if (input && (typeof input === 'undefined' ? 'undefined' : _typeof(input)) === 'object') {\n    for (var key in input) {\n      // eslint-disable-next-line no-prototype-builtins\n      if (input.hasOwnProperty(key)) {\n        input[key] = walkMutate(input[key], predicate, mutator, removeUnresolved);\n      }\n    }\n    if (removeUnresolved) {\n      input = cleanUpLinks(input);\n    }\n  }\n  return input;\n};\nvar normalizeLink = function normalizeLink(entityMap, link, removeUnresolved) {\n  var resolvedLink = getResolvedLink(entityMap, link);\n  if (resolvedLink === UNRESOLVED_LINK) {\n    return removeUnresolved ? resolvedLink : link;\n  }\n  return resolvedLink;\n};\nvar makeEntryObject = function makeEntryObject(item, itemEntryPoints) {\n  if (!Array.isArray(itemEntryPoints)) {\n    return item;\n  }\n  var entryPoints = Object.keys(item).filter(function (ownKey) {\n    return itemEntryPoints.indexOf(ownKey) !== -1;\n  });\n  return entryPoints.reduce(function (entryObj, entryPoint) {\n    entryObj[entryPoint] = item[entryPoint];\n    return entryObj;\n  }, {});\n};\n\n/**\n * resolveResponse Function\n * Resolves contentful response to normalized form.\n * @param {Object} response Contentful response\n * @param {{removeUnresolved: Boolean, itemEntryPoints: Array<String>}|{}} options\n * @param {Boolean} options.removeUnresolved - Remove unresolved links default:false\n * @param {Array<String>} options.itemEntryPoints - Resolve links only in those item properties\n * @return {Object}\n */\nvar resolveResponse = function resolveResponse(response, options) {\n  options = options || {};\n  if (!response.items) {\n    return [];\n  }\n  var responseClone = copy(response);\n  var allIncludes = Object.keys(responseClone.includes || {}).reduce(function (all, type) {\n    return [].concat(_toConsumableArray(all), _toConsumableArray(response.includes[type]));\n  }, []);\n  var allEntries = [].concat(_toConsumableArray(responseClone.items), _toConsumableArray(allIncludes)).filter(function (entity) {\n    return Boolean(entity.sys);\n  });\n  var entityMap = new Map(allEntries.reduce(function (acc, entity) {\n    var entries = makeEntityMapKeys(entity.sys).map(function (key) {\n      return [key, entity];\n    });\n    acc.push.apply(acc, _toConsumableArray(entries));\n    return acc;\n  }, []));\n  allEntries.forEach(function (item) {\n    var entryObject = makeEntryObject(item, options.itemEntryPoints);\n    Object.assign(item, walkMutate(entryObject, function (x) {\n      return isLink(x) || isResourceLink(x);\n    }, function (link) {\n      return normalizeLink(entityMap, link, options.removeUnresolved);\n    }, options.removeUnresolved));\n  });\n  return responseClone.items;\n};\nexport default resolveResponse;","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global[\"fast-copy\"] = factory());\n})(this, function () {\n  'use strict';\n\n  var toStringFunction = Function.prototype.toString;\n  var create = Object.create,\n    defineProperty = Object.defineProperty,\n    getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,\n    getOwnPropertyNames = Object.getOwnPropertyNames,\n    getOwnPropertySymbols = Object.getOwnPropertySymbols,\n    getPrototypeOf$1 = Object.getPrototypeOf;\n  var _a = Object.prototype,\n    hasOwnProperty = _a.hasOwnProperty,\n    propertyIsEnumerable = _a.propertyIsEnumerable;\n  var SYMBOL_PROPERTIES = typeof getOwnPropertySymbols === 'function';\n  var WEAK_MAP = typeof WeakMap === 'function';\n  /**\n   * @function createCache\n   *\n   * @description\n   * get a new cache object to prevent circular references\n   *\n   * @returns the new cache object\n   */\n  var createCache = function () {\n    if (WEAK_MAP) {\n      return function () {\n        return new WeakMap();\n      };\n    }\n    var Cache = /** @class */function () {\n      function Cache() {\n        this._keys = [];\n        this._values = [];\n      }\n      Cache.prototype.has = function (key) {\n        return !!~this._keys.indexOf(key);\n      };\n      Cache.prototype.get = function (key) {\n        return this._values[this._keys.indexOf(key)];\n      };\n      Cache.prototype.set = function (key, value) {\n        this._keys.push(key);\n        this._values.push(value);\n      };\n      return Cache;\n    }();\n    return function () {\n      return new Cache();\n    };\n  }();\n  /**\n   * @function getCleanClone\n   *\n   * @description\n   * get an empty version of the object with the same prototype it has\n   *\n   * @param object the object to build a clean clone from\n   * @param realm the realm the object resides in\n   * @returns the empty cloned object\n   */\n  var getCleanClone = function (object, realm) {\n    var prototype = object.__proto__ || getPrototypeOf$1(object);\n    if (!prototype) {\n      return create(null);\n    }\n    var Constructor = prototype.constructor;\n    if (Constructor === realm.Object) {\n      return prototype === realm.Object.prototype ? {} : create(prototype);\n    }\n    if (~toStringFunction.call(Constructor).indexOf('[native code]')) {\n      try {\n        return new Constructor();\n      } catch (_a) {}\n    }\n    return create(prototype);\n  };\n  /**\n   * @function getObjectCloneLoose\n   *\n   * @description\n   * get a copy of the object based on loose rules, meaning all enumerable keys\n   * and symbols are copied, but property descriptors are not considered\n   *\n   * @param object the object to clone\n   * @param realm the realm the object resides in\n   * @param handleCopy the function that handles copying the object\n   * @returns the copied object\n   */\n  var getObjectCloneLoose = function (object, realm, handleCopy, cache) {\n    var clone = getCleanClone(object, realm);\n    // set in the cache immediately to be able to reuse the object recursively\n    cache.set(object, clone);\n    for (var key in object) {\n      if (hasOwnProperty.call(object, key)) {\n        clone[key] = handleCopy(object[key], cache);\n      }\n    }\n    if (SYMBOL_PROPERTIES) {\n      var symbols = getOwnPropertySymbols(object);\n      for (var index = 0, length_1 = symbols.length, symbol = void 0; index < length_1; ++index) {\n        symbol = symbols[index];\n        if (propertyIsEnumerable.call(object, symbol)) {\n          clone[symbol] = handleCopy(object[symbol], cache);\n        }\n      }\n    }\n    return clone;\n  };\n  /**\n   * @function getObjectCloneStrict\n   *\n   * @description\n   * get a copy of the object based on strict rules, meaning all keys and symbols\n   * are copied based on the original property descriptors\n   *\n   * @param object the object to clone\n   * @param realm the realm the object resides in\n   * @param handleCopy the function that handles copying the object\n   * @returns the copied object\n   */\n  var getObjectCloneStrict = function (object, realm, handleCopy, cache) {\n    var clone = getCleanClone(object, realm);\n    // set in the cache immediately to be able to reuse the object recursively\n    cache.set(object, clone);\n    var properties = SYMBOL_PROPERTIES ? getOwnPropertyNames(object).concat(getOwnPropertySymbols(object)) : getOwnPropertyNames(object);\n    for (var index = 0, length_2 = properties.length, property = void 0, descriptor = void 0; index < length_2; ++index) {\n      property = properties[index];\n      if (property !== 'callee' && property !== 'caller') {\n        descriptor = getOwnPropertyDescriptor(object, property);\n        if (descriptor) {\n          // Only clone the value if actually a value, not a getter / setter.\n          if (!descriptor.get && !descriptor.set) {\n            descriptor.value = handleCopy(object[property], cache);\n          }\n          try {\n            defineProperty(clone, property, descriptor);\n          } catch (error) {\n            // Tee above can fail on node in edge cases, so fall back to the loose assignment.\n            clone[property] = descriptor.value;\n          }\n        } else {\n          // In extra edge cases where the property descriptor cannot be retrived, fall back to\n          // the loose assignment.\n          clone[property] = handleCopy(object[property], cache);\n        }\n      }\n    }\n    return clone;\n  };\n  /**\n   * @function getRegExpFlags\n   *\n   * @description\n   * get the flags to apply to the copied regexp\n   *\n   * @param regExp the regexp to get the flags of\n   * @returns the flags for the regexp\n   */\n  var getRegExpFlags = function (regExp) {\n    var flags = '';\n    if (regExp.global) {\n      flags += 'g';\n    }\n    if (regExp.ignoreCase) {\n      flags += 'i';\n    }\n    if (regExp.multiline) {\n      flags += 'm';\n    }\n    if (regExp.unicode) {\n      flags += 'u';\n    }\n    if (regExp.sticky) {\n      flags += 'y';\n    }\n    return flags;\n  };\n\n  // utils\n  var isArray = Array.isArray;\n  var getPrototypeOf = Object.getPrototypeOf;\n  var GLOBAL_THIS = function () {\n    if (typeof globalThis !== 'undefined') {\n      return globalThis;\n    }\n    if (typeof self !== 'undefined') {\n      return self;\n    }\n    if (typeof window !== 'undefined') {\n      return window;\n    }\n    if (typeof global !== 'undefined') {\n      return global;\n    }\n    if (console && console.error) {\n      console.error('Unable to locate global object, returning \"this\".');\n    }\n    return this;\n  }();\n  /**\n   * @function copy\n   *\n   * @description\n   * copy an value deeply as much as possible\n   *\n   * If `strict` is applied, then all properties (including non-enumerable ones)\n   * are copied with their original property descriptors on both objects and arrays.\n   *\n   * The value is compared to the global constructors in the `realm` provided,\n   * and the native constructor is always used to ensure that extensions of native\n   * objects (allows in ES2015+) are maintained.\n   *\n   * @param value the value to copy\n   * @param [options] the options for copying with\n   * @param [options.isStrict] should the copy be strict\n   * @param [options.realm] the realm (this) value the value is copied from\n   * @returns the copied value\n   */\n  function copy(value, options) {\n    // manually coalesced instead of default parameters for performance\n    var isStrict = !!(options && options.isStrict);\n    var realm = options && options.realm || GLOBAL_THIS;\n    var getObjectClone = isStrict ? getObjectCloneStrict : getObjectCloneLoose;\n    /**\n     * @function handleCopy\n     *\n     * @description\n     * copy the value recursively based on its type\n     *\n     * @param value the value to copy\n     * @returns the copied value\n     */\n    var handleCopy = function (value, cache) {\n      if (!value || typeof value !== 'object') {\n        return value;\n      }\n      if (cache.has(value)) {\n        return cache.get(value);\n      }\n      var prototype = value.__proto__ || getPrototypeOf(value);\n      var Constructor = prototype && prototype.constructor;\n      // plain objects\n      if (!Constructor || Constructor === realm.Object) {\n        return getObjectClone(value, realm, handleCopy, cache);\n      }\n      var clone;\n      // arrays\n      if (isArray(value)) {\n        // if strict, include non-standard properties\n        if (isStrict) {\n          return getObjectCloneStrict(value, realm, handleCopy, cache);\n        }\n        clone = new Constructor();\n        cache.set(value, clone);\n        for (var index = 0, length_1 = value.length; index < length_1; ++index) {\n          clone[index] = handleCopy(value[index], cache);\n        }\n        return clone;\n      }\n      // dates\n      if (value instanceof realm.Date) {\n        return new Constructor(value.getTime());\n      }\n      // regexps\n      if (value instanceof realm.RegExp) {\n        clone = new Constructor(value.source, value.flags || getRegExpFlags(value));\n        clone.lastIndex = value.lastIndex;\n        return clone;\n      }\n      // maps\n      if (realm.Map && value instanceof realm.Map) {\n        clone = new Constructor();\n        cache.set(value, clone);\n        value.forEach(function (value, key) {\n          clone.set(key, handleCopy(value, cache));\n        });\n        return clone;\n      }\n      // sets\n      if (realm.Set && value instanceof realm.Set) {\n        clone = new Constructor();\n        cache.set(value, clone);\n        value.forEach(function (value) {\n          clone.add(handleCopy(value, cache));\n        });\n        return clone;\n      }\n      // blobs\n      if (realm.Blob && value instanceof realm.Blob) {\n        return value.slice(0, value.size, value.type);\n      }\n      // buffers (node-only)\n      if (realm.Buffer && realm.Buffer.isBuffer(value)) {\n        clone = realm.Buffer.allocUnsafe ? realm.Buffer.allocUnsafe(value.length) : new Constructor(value.length);\n        cache.set(value, clone);\n        value.copy(clone);\n        return clone;\n      }\n      // arraybuffers / dataviews\n      if (realm.ArrayBuffer) {\n        // dataviews\n        if (realm.ArrayBuffer.isView(value)) {\n          clone = new Constructor(value.buffer.slice(0));\n          cache.set(value, clone);\n          return clone;\n        }\n        // arraybuffers\n        if (value instanceof realm.ArrayBuffer) {\n          clone = value.slice(0);\n          cache.set(value, clone);\n          return clone;\n        }\n      }\n      // if the value cannot / should not be cloned, don't\n      if (\n      // promise-like\n      typeof value.then === 'function' ||\n      // errors\n      value instanceof Error ||\n      // weakmaps\n      realm.WeakMap && value instanceof realm.WeakMap ||\n      // weaksets\n      realm.WeakSet && value instanceof realm.WeakSet) {\n        return value;\n      }\n      // assume anything left is a custom constructor\n      return getObjectClone(value, realm, handleCopy, cache);\n    };\n    return handleCopy(value, createCache());\n  }\n  // Adding reference to allow usage in CommonJS libraries compiled using TSC, which\n  // expects there to be a default property on the exported value. See\n  // [#37](https://github.com/planttheidea/fast-copy/issues/37) for details.\n  copy.default = copy;\n  /**\n   * @function strictCopy\n   *\n   * @description\n   * copy the value with `strict` option pre-applied\n   *\n   * @param value the value to copy\n   * @param [options] the options for copying with\n   * @param [options.realm] the realm (this) value the value is copied from\n   * @returns the copied value\n   */\n  copy.strict = function strictCopy(value, options) {\n    return copy(value, {\n      isStrict: true,\n      realm: options ? options.realm : void 0\n    });\n  };\n  return copy;\n});","import { warning } from 'hey-listen';\nimport { clamp } from '../../utils/clamp.js';\nvar safeMin = 0.001;\nvar minDuration = 0.01;\nvar maxDuration = 10.0;\nvar minDamping = 0.05;\nvar maxDamping = 1;\nfunction findSpring(_a) {\n  var _b = _a.duration,\n    duration = _b === void 0 ? 800 : _b,\n    _c = _a.bounce,\n    bounce = _c === void 0 ? 0.25 : _c,\n    _d = _a.velocity,\n    velocity = _d === void 0 ? 0 : _d,\n    _e = _a.mass,\n    mass = _e === void 0 ? 1 : _e;\n  var envelope;\n  var derivative;\n  warning(duration <= maxDuration * 1000, \"Spring duration must be 10 seconds or less\");\n  var dampingRatio = 1 - bounce;\n  dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n  duration = clamp(minDuration, maxDuration, duration / 1000);\n  if (dampingRatio < 1) {\n    envelope = function (undampedFreq) {\n      var exponentialDecay = undampedFreq * dampingRatio;\n      var delta = exponentialDecay * duration;\n      var a = exponentialDecay - velocity;\n      var b = calcAngularFreq(undampedFreq, dampingRatio);\n      var c = Math.exp(-delta);\n      return safeMin - a / b * c;\n    };\n    derivative = function (undampedFreq) {\n      var exponentialDecay = undampedFreq * dampingRatio;\n      var delta = exponentialDecay * duration;\n      var d = delta * velocity + velocity;\n      var e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n      var f = Math.exp(-delta);\n      var g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n      var factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n      return factor * ((d - e) * f) / g;\n    };\n  } else {\n    envelope = function (undampedFreq) {\n      var a = Math.exp(-undampedFreq * duration);\n      var b = (undampedFreq - velocity) * duration + 1;\n      return -safeMin + a * b;\n    };\n    derivative = function (undampedFreq) {\n      var a = Math.exp(-undampedFreq * duration);\n      var b = (velocity - undampedFreq) * (duration * duration);\n      return a * b;\n    };\n  }\n  var initialGuess = 5 / duration;\n  var undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n  duration = duration * 1000;\n  if (isNaN(undampedFreq)) {\n    return {\n      stiffness: 100,\n      damping: 10,\n      duration: duration\n    };\n  } else {\n    var stiffness = Math.pow(undampedFreq, 2) * mass;\n    return {\n      stiffness: stiffness,\n      damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n      duration: duration\n    };\n  }\n}\nvar rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n  var result = initialGuess;\n  for (var i = 1; i < rootIterations; i++) {\n    result = result - envelope(result) / derivative(result);\n  }\n  return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n  return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\nexport { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };","import { __rest, __assign } from 'tslib';\nimport { findSpring, calcAngularFreq } from '../utils/find-spring.js';\nvar durationKeys = [\"duration\", \"bounce\"];\nvar physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n  return keys.some(function (key) {\n    return options[key] !== undefined;\n  });\n}\nfunction getSpringOptions(options) {\n  var springOptions = __assign({\n    velocity: 0.0,\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    isResolvedFromDuration: false\n  }, options);\n  if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {\n    var derived = findSpring(options);\n    springOptions = __assign(__assign(__assign({}, springOptions), derived), {\n      velocity: 0.0,\n      mass: 1.0\n    });\n    springOptions.isResolvedFromDuration = true;\n  }\n  return springOptions;\n}\nfunction spring(_a) {\n  var _b = _a.from,\n    from = _b === void 0 ? 0.0 : _b,\n    _c = _a.to,\n    to = _c === void 0 ? 1.0 : _c,\n    _d = _a.restSpeed,\n    restSpeed = _d === void 0 ? 2 : _d,\n    restDelta = _a.restDelta,\n    options = __rest(_a, [\"from\", \"to\", \"restSpeed\", \"restDelta\"]);\n  var state = {\n    done: false,\n    value: from\n  };\n  var _e = getSpringOptions(options),\n    stiffness = _e.stiffness,\n    damping = _e.damping,\n    mass = _e.mass,\n    velocity = _e.velocity,\n    duration = _e.duration,\n    isResolvedFromDuration = _e.isResolvedFromDuration;\n  var resolveSpring = zero;\n  var resolveVelocity = zero;\n  function createSpring() {\n    var initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n    var initialDelta = to - from;\n    var dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    var undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n    restDelta !== null && restDelta !== void 0 ? restDelta : restDelta = Math.abs(to - from) <= 1 ? 0.01 : 0.4;\n    if (dampingRatio < 1) {\n      var angularFreq_1 = calcAngularFreq(undampedAngularFreq, dampingRatio);\n      resolveSpring = function (t) {\n        var envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n        return to - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq_1 * Math.sin(angularFreq_1 * t) + initialDelta * Math.cos(angularFreq_1 * t));\n      };\n      resolveVelocity = function (t) {\n        var envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n        return dampingRatio * undampedAngularFreq * envelope * (Math.sin(angularFreq_1 * t) * (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq_1 + initialDelta * Math.cos(angularFreq_1 * t)) - envelope * (Math.cos(angularFreq_1 * t) * (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) - angularFreq_1 * initialDelta * Math.sin(angularFreq_1 * t));\n      };\n    } else if (dampingRatio === 1) {\n      resolveSpring = function (t) {\n        return to - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);\n      };\n    } else {\n      var dampedAngularFreq_1 = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n      resolveSpring = function (t) {\n        var envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n        var freqForT = Math.min(dampedAngularFreq_1 * t, 300);\n        return to - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq_1 * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq_1;\n      };\n    }\n  }\n  createSpring();\n  return {\n    next: function (t) {\n      var current = resolveSpring(t);\n      if (!isResolvedFromDuration) {\n        var currentVelocity = resolveVelocity(t) * 1000;\n        var isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n        var isBelowDisplacementThreshold = Math.abs(to - current) <= restDelta;\n        state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;\n      } else {\n        state.done = t >= duration;\n      }\n      state.value = state.done ? to : current;\n      return state;\n    },\n    flipTarget: function () {\n      var _a;\n      velocity = -velocity;\n      _a = [to, from], from = _a[0], to = _a[1];\n      createSpring();\n    }\n  };\n}\nspring.needsInterpolation = function (a, b) {\n  return typeof a === \"string\" || typeof b === \"string\";\n};\nvar zero = function (_t) {\n  return 0;\n};\nexport { spring };","import { __assign } from 'tslib';\nimport { mix } from './mix.js';\nimport { hex, rgba, hsla } from 'style-value-types';\nimport { invariant } from 'hey-listen';\nvar mixLinearColor = function (from, to, v) {\n  var fromExpo = from * from;\n  var toExpo = to * to;\n  return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\nvar colorTypes = [hex, rgba, hsla];\nvar getColorType = function (v) {\n  return colorTypes.find(function (type) {\n    return type.test(v);\n  });\n};\nvar notAnimatable = function (color) {\n  return \"'\" + color + \"' is not an animatable color. Use the equivalent color code instead.\";\n};\nvar mixColor = function (from, to) {\n  var fromColorType = getColorType(from);\n  var toColorType = getColorType(to);\n  invariant(!!fromColorType, notAnimatable(from));\n  invariant(!!toColorType, notAnimatable(to));\n  invariant(fromColorType.transform === toColorType.transform, \"Both colors must be hex/RGBA, OR both must be HSLA.\");\n  var fromColor = fromColorType.parse(from);\n  var toColor = toColorType.parse(to);\n  var blended = __assign({}, fromColor);\n  var mixFunc = fromColorType === hsla ? mix : mixLinearColor;\n  return function (v) {\n    for (var key in blended) {\n      if (key !== \"alpha\") {\n        blended[key] = mixFunc(fromColor[key], toColor[key], v);\n      }\n    }\n    blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n    return fromColorType.transform(blended);\n  };\n};\nexport { mixColor, mixLinearColor };","import { __spreadArray, __assign } from 'tslib';\nimport { complex, color } from 'style-value-types';\nimport { mix } from './mix.js';\nimport { mixColor } from './mix-color.js';\nimport { isNum } from './inc.js';\nimport { pipe } from './pipe.js';\nimport { invariant } from 'hey-listen';\nfunction getMixer(origin, target) {\n  if (isNum(origin)) {\n    return function (v) {\n      return mix(origin, target, v);\n    };\n  } else if (color.test(origin)) {\n    return mixColor(origin, target);\n  } else {\n    return mixComplex(origin, target);\n  }\n}\nvar mixArray = function (from, to) {\n  var output = __spreadArray([], from);\n  var numValues = output.length;\n  var blendValue = from.map(function (fromThis, i) {\n    return getMixer(fromThis, to[i]);\n  });\n  return function (v) {\n    for (var i = 0; i < numValues; i++) {\n      output[i] = blendValue[i](v);\n    }\n    return output;\n  };\n};\nvar mixObject = function (origin, target) {\n  var output = __assign(__assign({}, origin), target);\n  var blendValue = {};\n  for (var key in output) {\n    if (origin[key] !== undefined && target[key] !== undefined) {\n      blendValue[key] = getMixer(origin[key], target[key]);\n    }\n  }\n  return function (v) {\n    for (var key in blendValue) {\n      output[key] = blendValue[key](v);\n    }\n    return output;\n  };\n};\nfunction analyse(value) {\n  var parsed = complex.parse(value);\n  var numValues = parsed.length;\n  var numNumbers = 0;\n  var numRGB = 0;\n  var numHSL = 0;\n  for (var i = 0; i < numValues; i++) {\n    if (numNumbers || typeof parsed[i] === \"number\") {\n      numNumbers++;\n    } else {\n      if (parsed[i].hue !== undefined) {\n        numHSL++;\n      } else {\n        numRGB++;\n      }\n    }\n  }\n  return {\n    parsed: parsed,\n    numNumbers: numNumbers,\n    numRGB: numRGB,\n    numHSL: numHSL\n  };\n}\nvar mixComplex = function (origin, target) {\n  var template = complex.createTransformer(target);\n  var originStats = analyse(origin);\n  var targetStats = analyse(target);\n  invariant(originStats.numHSL === targetStats.numHSL && originStats.numRGB === targetStats.numRGB && originStats.numNumbers >= targetStats.numNumbers, \"Complex values '\" + origin + \"' and '\" + target + \"' too different to mix. Ensure all colors are of the same type.\");\n  return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n};\nexport { mixArray, mixComplex, mixObject };","import { progress } from './progress.js';\nimport { mix } from './mix.js';\nimport { mixColor } from './mix-color.js';\nimport { mixComplex, mixArray, mixObject } from './mix-complex.js';\nimport { color } from 'style-value-types';\nimport { clamp } from './clamp.js';\nimport { pipe } from './pipe.js';\nimport { invariant } from 'hey-listen';\nvar mixNumber = function (from, to) {\n  return function (p) {\n    return mix(from, to, p);\n  };\n};\nfunction detectMixerFactory(v) {\n  if (typeof v === 'number') {\n    return mixNumber;\n  } else if (typeof v === 'string') {\n    if (color.test(v)) {\n      return mixColor;\n    } else {\n      return mixComplex;\n    }\n  } else if (Array.isArray(v)) {\n    return mixArray;\n  } else if (typeof v === 'object') {\n    return mixObject;\n  }\n}\nfunction createMixers(output, ease, customMixer) {\n  var mixers = [];\n  var mixerFactory = customMixer || detectMixerFactory(output[0]);\n  var numMixers = output.length - 1;\n  for (var i = 0; i < numMixers; i++) {\n    var mixer = mixerFactory(output[i], output[i + 1]);\n    if (ease) {\n      var easingFunction = Array.isArray(ease) ? ease[i] : ease;\n      mixer = pipe(easingFunction, mixer);\n    }\n    mixers.push(mixer);\n  }\n  return mixers;\n}\nfunction fastInterpolate(_a, _b) {\n  var from = _a[0],\n    to = _a[1];\n  var mixer = _b[0];\n  return function (v) {\n    return mixer(progress(from, to, v));\n  };\n}\nfunction slowInterpolate(input, mixers) {\n  var inputLength = input.length;\n  var lastInputIndex = inputLength - 1;\n  return function (v) {\n    var mixerIndex = 0;\n    var foundMixerIndex = false;\n    if (v <= input[0]) {\n      foundMixerIndex = true;\n    } else if (v >= input[lastInputIndex]) {\n      mixerIndex = lastInputIndex - 1;\n      foundMixerIndex = true;\n    }\n    if (!foundMixerIndex) {\n      var i = 1;\n      for (; i < inputLength; i++) {\n        if (input[i] > v || i === lastInputIndex) {\n          break;\n        }\n      }\n      mixerIndex = i - 1;\n    }\n    var progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n    return mixers[mixerIndex](progressInRange);\n  };\n}\nfunction interpolate(input, output, _a) {\n  var _b = _a === void 0 ? {} : _a,\n    _c = _b.clamp,\n    isClamp = _c === void 0 ? true : _c,\n    ease = _b.ease,\n    mixer = _b.mixer;\n  var inputLength = input.length;\n  invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n  invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n  if (input[0] > input[inputLength - 1]) {\n    input = [].concat(input);\n    output = [].concat(output);\n    input.reverse();\n    output.reverse();\n  }\n  var mixers = createMixers(output, ease, mixer);\n  var interpolator = inputLength === 2 ? fastInterpolate(input, mixers) : slowInterpolate(input, mixers);\n  return isClamp ? function (v) {\n    return interpolator(clamp(input[0], input[inputLength - 1], v));\n  } : interpolator;\n}\nexport { interpolate };","var reverseEasing = function (easing) {\n  return function (p) {\n    return 1 - easing(1 - p);\n  };\n};\nvar mirrorEasing = function (easing) {\n  return function (p) {\n    return p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n  };\n};\nvar createExpoIn = function (power) {\n  return function (p) {\n    return Math.pow(p, power);\n  };\n};\nvar createBackIn = function (power) {\n  return function (p) {\n    return p * p * ((power + 1) * p - power);\n  };\n};\nvar createAnticipate = function (power) {\n  var backEasing = createBackIn(power);\n  return function (p) {\n    return (p *= 2) < 1 ? 0.5 * backEasing(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n  };\n};\nexport { createAnticipate, createBackIn, createExpoIn, mirrorEasing, reverseEasing };","import { createExpoIn, reverseEasing, mirrorEasing, createBackIn, createAnticipate } from './utils.js';\nvar DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nvar BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nvar BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nvar BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nvar linear = function (p) {\n  return p;\n};\nvar easeIn = createExpoIn(2);\nvar easeOut = reverseEasing(easeIn);\nvar easeInOut = mirrorEasing(easeIn);\nvar circIn = function (p) {\n  return 1 - Math.sin(Math.acos(p));\n};\nvar circOut = reverseEasing(circIn);\nvar circInOut = mirrorEasing(circOut);\nvar backIn = createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nvar backOut = reverseEasing(backIn);\nvar backInOut = mirrorEasing(backIn);\nvar anticipate = createAnticipate(DEFAULT_OVERSHOOT_STRENGTH);\nvar ca = 4356.0 / 361.0;\nvar cb = 35442.0 / 1805.0;\nvar cc = 16061.0 / 1805.0;\nvar bounceOut = function (p) {\n  if (p === 1 || p === 0) return p;\n  var p2 = p * p;\n  return p < BOUNCE_FIRST_THRESHOLD ? 7.5625 * p2 : p < BOUNCE_SECOND_THRESHOLD ? 9.075 * p2 - 9.9 * p + 3.4 : p < BOUNCE_THIRD_THRESHOLD ? ca * p2 - cb * p + cc : 10.8 * p * p - 20.52 * p + 10.72;\n};\nvar bounceIn = reverseEasing(bounceOut);\nvar bounceInOut = function (p) {\n  return p < 0.5 ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0)) : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n};\nexport { anticipate, backIn, backInOut, backOut, bounceIn, bounceInOut, bounceOut, circIn, circInOut, circOut, easeIn, easeInOut, easeOut, linear };","import { interpolate } from '../../utils/interpolate.js';\nimport { easeInOut } from '../../easing/index.js';\nfunction defaultEasing(values, easing) {\n  return values.map(function () {\n    return easing || easeInOut;\n  }).splice(0, values.length - 1);\n}\nfunction defaultOffset(values) {\n  var numValues = values.length;\n  return values.map(function (_value, i) {\n    return i !== 0 ? i / (numValues - 1) : 0;\n  });\n}\nfunction convertOffsetToTimes(offset, duration) {\n  return offset.map(function (o) {\n    return o * duration;\n  });\n}\nfunction keyframes(_a) {\n  var _b = _a.from,\n    from = _b === void 0 ? 0 : _b,\n    _c = _a.to,\n    to = _c === void 0 ? 1 : _c,\n    ease = _a.ease,\n    offset = _a.offset,\n    _d = _a.duration,\n    duration = _d === void 0 ? 300 : _d;\n  var state = {\n    done: false,\n    value: from\n  };\n  var values = Array.isArray(to) ? to : [from, to];\n  var times = convertOffsetToTimes(offset && offset.length === values.length ? offset : defaultOffset(values), duration);\n  function createInterpolator() {\n    return interpolate(times, values, {\n      ease: Array.isArray(ease) ? ease : defaultEasing(values, ease)\n    });\n  }\n  var interpolator = createInterpolator();\n  return {\n    next: function (t) {\n      state.value = interpolator(t);\n      state.done = t >= duration;\n      return state;\n    },\n    flipTarget: function () {\n      values.reverse();\n      interpolator = createInterpolator();\n    }\n  };\n}\nexport { convertOffsetToTimes, defaultEasing, defaultOffset, keyframes };","import { spring } from '../generators/spring.js';\nimport { keyframes } from '../generators/keyframes.js';\nimport { decay } from '../generators/decay.js';\nvar types = {\n  keyframes: keyframes,\n  spring: spring,\n  decay: decay\n};\nfunction detectAnimationFromOptions(config) {\n  if (Array.isArray(config.to)) {\n    return keyframes;\n  } else if (types[config.type]) {\n    return types[config.type];\n  }\n  var keys = new Set(Object.keys(config));\n  if (keys.has(\"ease\") || keys.has(\"duration\") && !keys.has(\"dampingRatio\")) {\n    return keyframes;\n  } else if (keys.has(\"dampingRatio\") || keys.has(\"stiffness\") || keys.has(\"mass\") || keys.has(\"damping\") || keys.has(\"restSpeed\") || keys.has(\"restDelta\")) {\n    return spring;\n  }\n  return keyframes;\n}\nexport { detectAnimationFromOptions };","function decay(_a) {\n  var _b = _a.velocity,\n    velocity = _b === void 0 ? 0 : _b,\n    _c = _a.from,\n    from = _c === void 0 ? 0 : _c,\n    _d = _a.power,\n    power = _d === void 0 ? 0.8 : _d,\n    _e = _a.timeConstant,\n    timeConstant = _e === void 0 ? 350 : _e,\n    _f = _a.restDelta,\n    restDelta = _f === void 0 ? 0.5 : _f,\n    modifyTarget = _a.modifyTarget;\n  var state = {\n    done: false,\n    value: from\n  };\n  var amplitude = power * velocity;\n  var ideal = from + amplitude;\n  var target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n  if (target !== ideal) amplitude = target - from;\n  return {\n    next: function (t) {\n      var delta = -amplitude * Math.exp(-t / timeConstant);\n      state.done = !(delta > restDelta || delta < -restDelta);\n      state.value = state.done ? target : target + delta;\n      return state;\n    },\n    flipTarget: function () {}\n  };\n}\nexport { decay };","function loopElapsed(elapsed, duration, delay) {\n  if (delay === void 0) {\n    delay = 0;\n  }\n  return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration, delay, isForwardPlayback) {\n  if (delay === void 0) {\n    delay = 0;\n  }\n  if (isForwardPlayback === void 0) {\n    isForwardPlayback = true;\n  }\n  return isForwardPlayback ? loopElapsed(duration + -elapsed, duration, delay) : duration - (elapsed - duration) + delay;\n}\nfunction hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {\n  return isForwardPlayback ? elapsed >= duration + delay : elapsed <= -delay;\n}\nexport { hasRepeatDelayElapsed, loopElapsed, reverseElapsed };","import { __rest, __assign } from 'tslib';\nimport { detectAnimationFromOptions } from './utils/detect-animation-from-options.js';\nimport sync, { cancelSync } from 'framesync';\nimport { interpolate } from '../utils/interpolate.js';\nimport { hasRepeatDelayElapsed, reverseElapsed, loopElapsed } from './utils/elapsed.js';\nvar framesync = function (update) {\n  var passTimestamp = function (_a) {\n    var delta = _a.delta;\n    return update(delta);\n  };\n  return {\n    start: function () {\n      return sync.update(passTimestamp, true);\n    },\n    stop: function () {\n      return cancelSync.update(passTimestamp);\n    }\n  };\n};\nfunction animate(_a) {\n  var _b, _c;\n  var from = _a.from,\n    _d = _a.autoplay,\n    autoplay = _d === void 0 ? true : _d,\n    _e = _a.driver,\n    driver = _e === void 0 ? framesync : _e,\n    _f = _a.elapsed,\n    elapsed = _f === void 0 ? 0 : _f,\n    _g = _a.repeat,\n    repeatMax = _g === void 0 ? 0 : _g,\n    _h = _a.repeatType,\n    repeatType = _h === void 0 ? \"loop\" : _h,\n    _j = _a.repeatDelay,\n    repeatDelay = _j === void 0 ? 0 : _j,\n    onPlay = _a.onPlay,\n    onStop = _a.onStop,\n    onComplete = _a.onComplete,\n    onRepeat = _a.onRepeat,\n    onUpdate = _a.onUpdate,\n    options = __rest(_a, [\"from\", \"autoplay\", \"driver\", \"elapsed\", \"repeat\", \"repeatType\", \"repeatDelay\", \"onPlay\", \"onStop\", \"onComplete\", \"onRepeat\", \"onUpdate\"]);\n  var to = options.to;\n  var driverControls;\n  var repeatCount = 0;\n  var computedDuration = options.duration;\n  var latest;\n  var isComplete = false;\n  var isForwardPlayback = true;\n  var interpolateFromNumber;\n  var animator = detectAnimationFromOptions(options);\n  if ((_c = (_b = animator).needsInterpolation) === null || _c === void 0 ? void 0 : _c.call(_b, from, to)) {\n    interpolateFromNumber = interpolate([0, 100], [from, to], {\n      clamp: false\n    });\n    from = 0;\n    to = 100;\n  }\n  var animation = animator(__assign(__assign({}, options), {\n    from: from,\n    to: to\n  }));\n  function repeat() {\n    repeatCount++;\n    if (repeatType === \"reverse\") {\n      isForwardPlayback = repeatCount % 2 === 0;\n      elapsed = reverseElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback);\n    } else {\n      elapsed = loopElapsed(elapsed, computedDuration, repeatDelay);\n      if (repeatType === \"mirror\") animation.flipTarget();\n    }\n    isComplete = false;\n    onRepeat && onRepeat();\n  }\n  function complete() {\n    driverControls.stop();\n    onComplete && onComplete();\n  }\n  function update(delta) {\n    if (!isForwardPlayback) delta = -delta;\n    elapsed += delta;\n    if (!isComplete) {\n      var state = animation.next(Math.max(0, elapsed));\n      latest = state.value;\n      if (interpolateFromNumber) latest = interpolateFromNumber(latest);\n      isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n    }\n    onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(latest);\n    if (isComplete) {\n      if (repeatCount === 0) computedDuration !== null && computedDuration !== void 0 ? computedDuration : computedDuration = elapsed;\n      if (repeatCount < repeatMax) {\n        hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n      } else {\n        complete();\n      }\n    }\n  }\n  function play() {\n    onPlay === null || onPlay === void 0 ? void 0 : onPlay();\n    driverControls = driver(update);\n    driverControls.start();\n  }\n  autoplay && play();\n  return {\n    stop: function () {\n      onStop === null || onStop === void 0 ? void 0 : onStop();\n      driverControls.stop();\n    }\n  };\n}\nexport { animate };","import { linear } from './index.js';\nvar a = function (a1, a2) {\n  return 1.0 - 3.0 * a2 + 3.0 * a1;\n};\nvar b = function (a1, a2) {\n  return 3.0 * a2 - 6.0 * a1;\n};\nvar c = function (a1) {\n  return 3.0 * a1;\n};\nvar calcBezier = function (t, a1, a2) {\n  return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\n};\nvar getSlope = function (t, a1, a2) {\n  return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\n};\nvar subdivisionPrecision = 0.0000001;\nvar subdivisionMaxIterations = 10;\nfunction binarySubdivide(aX, aA, aB, mX1, mX2) {\n  var currentX;\n  var currentT;\n  var i = 0;\n  do {\n    currentT = aA + (aB - aA) / 2.0;\n    currentX = calcBezier(currentT, mX1, mX2) - aX;\n    if (currentX > 0.0) {\n      aB = currentT;\n    } else {\n      aA = currentT;\n    }\n  } while (Math.abs(currentX) > subdivisionPrecision && ++i < subdivisionMaxIterations);\n  return currentT;\n}\nvar newtonIterations = 8;\nvar newtonMinSlope = 0.001;\nfunction newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {\n  for (var i = 0; i < newtonIterations; ++i) {\n    var currentSlope = getSlope(aGuessT, mX1, mX2);\n    if (currentSlope === 0.0) {\n      return aGuessT;\n    }\n    var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n    aGuessT -= currentX / currentSlope;\n  }\n  return aGuessT;\n}\nvar kSplineTableSize = 11;\nvar kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n  if (mX1 === mY1 && mX2 === mY2) return linear;\n  var sampleValues = new Float32Array(kSplineTableSize);\n  for (var i = 0; i < kSplineTableSize; ++i) {\n    sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n  }\n  function getTForX(aX) {\n    var intervalStart = 0.0;\n    var currentSample = 1;\n    var lastSample = kSplineTableSize - 1;\n    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n      intervalStart += kSampleStepSize;\n    }\n    --currentSample;\n    var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n    var guessForT = intervalStart + dist * kSampleStepSize;\n    var initialSlope = getSlope(guessForT, mX1, mX2);\n    if (initialSlope >= newtonMinSlope) {\n      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n    } else if (initialSlope === 0.0) {\n      return guessForT;\n    } else {\n      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n    }\n  }\n  return function (t) {\n    return t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n  };\n}\nexport { cubicBezier };","import { __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { cubicBezier, linear, easeIn, easeInOut, easeOut, circIn, circInOut, circOut, backIn, backInOut, backOut, anticipate, bounceIn, bounceInOut, bounceOut } from 'popmotion';\nvar easingLookup = {\n  linear: linear,\n  easeIn: easeIn,\n  easeInOut: easeInOut,\n  easeOut: easeOut,\n  circIn: circIn,\n  circInOut: circInOut,\n  circOut: circOut,\n  backIn: backIn,\n  backInOut: backInOut,\n  backOut: backOut,\n  anticipate: anticipate,\n  bounceIn: bounceIn,\n  bounceInOut: bounceInOut,\n  bounceOut: bounceOut\n};\nvar easingDefinitionToFunction = function (definition) {\n  if (Array.isArray(definition)) {\n    // If cubic bezier definition, create bezier curve\n    invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n    var _a = __read(definition, 4),\n      x1 = _a[0],\n      y1 = _a[1],\n      x2 = _a[2],\n      y2 = _a[3];\n    return cubicBezier(x1, y1, x2, y2);\n  } else if (typeof definition === \"string\") {\n    // Else lookup from table\n    invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\" + definition + \"'\");\n    return easingLookup[definition];\n  }\n  return definition;\n};\nvar isEasingArray = function (ease) {\n  return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\nexport { easingDefinitionToFunction, isEasingArray };","import { complex } from 'style-value-types';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nvar isAnimatable = function (key, value) {\n  // If the list of keys tat might be non-animatable grows, replace with Set\n  if (key === \"zIndex\") return false;\n  // If it's a number or a keyframes array, we can animate it. We might at some point\n  // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n  // but for now lets leave it like this for performance reasons\n  if (typeof value === \"number\" || Array.isArray(value)) return true;\n  if (typeof value === \"string\" &&\n  // It's animatable if we have a string\n  complex.test(value) &&\n  // And it contains numbers and/or colors\n  !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n  ) {\n    return true;\n  }\n  return false;\n};\nexport { isAnimatable };","import { __assign } from 'tslib';\nimport { isKeyframesTarget } from './is-keyframes-target.js';\nvar underDampedSpring = function () {\n  return {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restDelta: 0.5,\n    restSpeed: 10\n  };\n};\nvar criticallyDampedSpring = function (to) {\n  return {\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restDelta: 0.01,\n    restSpeed: 10\n  };\n};\nvar linearTween = function () {\n  return {\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3\n  };\n};\nvar keyframes = function (values) {\n  return {\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values\n  };\n};\nvar defaultTransitions = {\n  x: underDampedSpring,\n  y: underDampedSpring,\n  z: underDampedSpring,\n  rotate: underDampedSpring,\n  rotateX: underDampedSpring,\n  rotateY: underDampedSpring,\n  rotateZ: underDampedSpring,\n  scaleX: criticallyDampedSpring,\n  scaleY: criticallyDampedSpring,\n  scale: criticallyDampedSpring,\n  opacity: linearTween,\n  backgroundColor: linearTween,\n  color: linearTween,\n  default: criticallyDampedSpring\n};\nvar getDefaultTransition = function (valueKey, to) {\n  var transitionFactory;\n  if (isKeyframesTarget(to)) {\n    transitionFactory = keyframes;\n  } else {\n    transitionFactory = defaultTransitions[valueKey] || defaultTransitions.default;\n  }\n  return __assign({\n    to: to\n  }, transitionFactory(to));\n};\nexport { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };","import { __assign, __rest, __spreadArray, __read } from 'tslib';\nimport { inertia, animate } from 'popmotion';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.js';\nimport { isEasingArray, easingDefinitionToFunction } from './easing.js';\nimport { isAnimatable } from './is-animatable.js';\nimport { getDefaultTransition } from './default-transitions.js';\nimport { warning } from 'hey-listen';\nimport { getAnimatableNone } from '../../render/dom/value-types/animatable-none.js';\n\n/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined(_a) {\n  _a.when;\n  _a.delay;\n  _a.delayChildren;\n  _a.staggerChildren;\n  _a.staggerDirection;\n  _a.repeat;\n  _a.repeatType;\n  _a.repeatDelay;\n  _a.from;\n  var transition = __rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\", \"repeat\", \"repeatType\", \"repeatDelay\", \"from\"]);\n  return !!Object.keys(transition).length;\n}\nvar legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions(_a) {\n  var ease = _a.ease,\n    times = _a.times,\n    yoyo = _a.yoyo,\n    flip = _a.flip,\n    loop = _a.loop,\n    transition = __rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n  var options = __assign({}, transition);\n  if (times) options[\"offset\"] = times;\n  /**\n   * Convert any existing durations from seconds to milliseconds\n   */\n  if (transition.duration) options[\"duration\"] = secondsToMilliseconds(transition.duration);\n  if (transition.repeatDelay) options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n  /**\n   * Map easing names to Popmotion's easing functions\n   */\n  if (ease) {\n    options[\"ease\"] = isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);\n  }\n  /**\n   * Support legacy transition API\n   */\n  if (transition.type === \"tween\") options.type = \"keyframes\";\n  /**\n   * TODO: These options are officially removed from the API.\n   */\n  if (yoyo || loop || flip) {\n    warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n    legacyRepeatWarning = true;\n    if (yoyo) {\n      options.repeatType = \"reverse\";\n    } else if (loop) {\n      options.repeatType = \"loop\";\n    } else if (flip) {\n      options.repeatType = \"mirror\";\n    }\n    options.repeat = loop || yoyo || flip || transition.repeat;\n  }\n  /**\n   * TODO: Popmotion 9 has the ability to automatically detect whether to use\n   * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n   * It'd be good to introduce a similar thing here.\n   */\n  if (transition.type !== \"spring\") options.type = \"keyframes\";\n  return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n  var _a;\n  var valueTransition = getValueTransition(transition, key) || {};\n  return (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : 0;\n}\nfunction hydrateKeyframes(options) {\n  if (Array.isArray(options.to) && options.to[0] === null) {\n    options.to = __spreadArray([], __read(options.to));\n    options.to[0] = options.from;\n  }\n  return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n  var _a;\n  if (Array.isArray(options.to)) {\n    (_a = transition.duration) !== null && _a !== void 0 ? _a : transition.duration = 0.8;\n  }\n  hydrateKeyframes(options);\n  /**\n   * Get a default transition if none is determined to be defined.\n   */\n  if (!isTransitionDefined(transition)) {\n    transition = __assign(__assign({}, transition), getDefaultTransition(key, options.to));\n  }\n  return __assign(__assign({}, options), convertTransitionToAnimationOptions(transition));\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n  var _a;\n  var valueTransition = getValueTransition(transition, key);\n  var origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();\n  var isTargetAnimatable = isAnimatable(key, target);\n  if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n    /**\n     * If we're trying to animate from \"none\", try and get an animatable version\n     * of the target. This could be improved to work both ways.\n     */\n    origin = getAnimatableNone(key, target);\n  } else if (isZero(origin) && typeof target === \"string\") {\n    origin = getZeroUnit(target);\n  } else if (!Array.isArray(target) && isZero(target) && typeof origin === \"string\") {\n    target = getZeroUnit(origin);\n  }\n  var isOriginAnimatable = isAnimatable(key, origin);\n  warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \" + key + \" from \\\"\" + origin + \"\\\" to \\\"\" + target + \"\\\". \" + origin + \" is not an animatable value - to enable this animation set \" + origin + \" to a value animatable to \" + target + \" via the `style` property.\");\n  function start() {\n    var options = {\n      from: origin,\n      to: target,\n      velocity: value.getVelocity(),\n      onComplete: onComplete,\n      onUpdate: function (v) {\n        return value.set(v);\n      }\n    };\n    return valueTransition.type === \"inertia\" || valueTransition.type === \"decay\" ? inertia(__assign(__assign({}, options), valueTransition)) : animate(__assign(__assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), {\n      onUpdate: function (v) {\n        var _a;\n        options.onUpdate(v);\n        (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);\n      },\n      onComplete: function () {\n        var _a;\n        options.onComplete();\n        (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n      }\n    }));\n  }\n  function set() {\n    var _a;\n    value.set(target);\n    onComplete();\n    (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n    return {\n      stop: function () {}\n    };\n  }\n  return !isOriginAnimatable || !isTargetAnimatable || valueTransition.type === false ? set : start;\n}\nfunction isZero(value) {\n  return value === 0 || typeof value === \"string\" && parseFloat(value) === 0 && value.indexOf(\" \") === -1;\n}\nfunction getZeroUnit(potentialUnitType) {\n  return typeof potentialUnitType === \"number\" ? 0 : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n  return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n *\n * @internal\n */\nfunction startAnimation(key, value, target, transition) {\n  if (transition === void 0) {\n    transition = {};\n  }\n  return value.start(function (onComplete) {\n    var delayTimer;\n    var controls;\n    var animation = getAnimation(key, value, target, transition, onComplete);\n    var delay = getDelayFromTransition(transition, key);\n    var start = function () {\n      return controls = animation();\n    };\n    if (delay) {\n      delayTimer = setTimeout(start, secondsToMilliseconds(delay));\n    } else {\n      start();\n    }\n    return function () {\n      clearTimeout(delayTimer);\n      controls === null || controls === void 0 ? void 0 : controls.stop();\n    };\n  });\n}\nexport { convertTransitionToAnimationOptions, getDelayFromTransition, getPopmotionAnimationOptions, getValueTransition, getZeroUnit, hydrateKeyframes, isTransitionDefined, isZero, startAnimation };","import { __assign } from 'tslib';\nimport { animate } from './index.js';\nimport { velocityPerSecond } from '../utils/velocity-per-second.js';\nimport { getFrameData } from 'framesync';\nfunction inertia(_a) {\n  var _b = _a.from,\n    from = _b === void 0 ? 0 : _b,\n    _c = _a.velocity,\n    velocity = _c === void 0 ? 0 : _c,\n    min = _a.min,\n    max = _a.max,\n    _d = _a.power,\n    power = _d === void 0 ? 0.8 : _d,\n    _e = _a.timeConstant,\n    timeConstant = _e === void 0 ? 750 : _e,\n    _f = _a.bounceStiffness,\n    bounceStiffness = _f === void 0 ? 500 : _f,\n    _g = _a.bounceDamping,\n    bounceDamping = _g === void 0 ? 10 : _g,\n    _h = _a.restDelta,\n    restDelta = _h === void 0 ? 1 : _h,\n    modifyTarget = _a.modifyTarget,\n    driver = _a.driver,\n    onUpdate = _a.onUpdate,\n    onComplete = _a.onComplete;\n  var currentAnimation;\n  function isOutOfBounds(v) {\n    return min !== undefined && v < min || max !== undefined && v > max;\n  }\n  function boundaryNearest(v) {\n    if (min === undefined) return max;\n    if (max === undefined) return min;\n    return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n  }\n  function startAnimation(options) {\n    currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n    currentAnimation = animate(__assign(__assign({}, options), {\n      driver: driver,\n      onUpdate: function (v) {\n        var _a;\n        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n      },\n      onComplete: onComplete\n    }));\n  }\n  function startSpring(options) {\n    startAnimation(__assign({\n      type: \"spring\",\n      stiffness: bounceStiffness,\n      damping: bounceDamping,\n      restDelta: restDelta\n    }, options));\n  }\n  if (isOutOfBounds(from)) {\n    startSpring({\n      from: from,\n      velocity: velocity,\n      to: boundaryNearest(from)\n    });\n  } else {\n    var target = power * velocity + from;\n    if (typeof modifyTarget !== \"undefined\") target = modifyTarget(target);\n    var boundary_1 = boundaryNearest(target);\n    var heading_1 = boundary_1 === min ? -1 : 1;\n    var prev_1;\n    var current_1;\n    var checkBoundary = function (v) {\n      prev_1 = current_1;\n      current_1 = v;\n      velocity = velocityPerSecond(v - prev_1, getFrameData().delta);\n      if (heading_1 === 1 && v > boundary_1 || heading_1 === -1 && v < boundary_1) {\n        startSpring({\n          from: v,\n          to: boundary_1,\n          velocity: velocity\n        });\n      }\n    };\n    startAnimation({\n      type: \"decay\",\n      from: from,\n      velocity: velocity,\n      timeConstant: timeConstant,\n      power: power,\n      restDelta: restDelta,\n      modifyTarget: modifyTarget,\n      onUpdate: isOutOfBounds(target) ? checkBoundary : undefined\n    });\n  }\n  return {\n    stop: function () {\n      return currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n    }\n  };\n}\nexport { inertia };","/**\n * @public\n */\nvar Presence;\n(function (Presence) {\n  Presence[Presence[\"Entering\"] = 0] = \"Entering\";\n  Presence[Presence[\"Present\"] = 1] = \"Present\";\n  Presence[Presence[\"Exiting\"] = 2] = \"Exiting\";\n})(Presence || (Presence = {}));\n/**\n * @public\n */\nvar VisibilityAction;\n(function (VisibilityAction) {\n  VisibilityAction[VisibilityAction[\"Hide\"] = 0] = \"Hide\";\n  VisibilityAction[VisibilityAction[\"Show\"] = 1] = \"Show\";\n})(VisibilityAction || (VisibilityAction = {}));\nexport { Presence, VisibilityAction };","import { isTouchEvent } from '../gestures/utils/event-type.js';\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n  return function (event) {\n    var isMouseEvent = event instanceof MouseEvent;\n    var isPrimaryPointer = !isMouseEvent || isMouseEvent && event.button === 0;\n    if (isPrimaryPointer) {\n      eventHandler(event);\n    }\n  };\n}\nvar defaultPagePoint = {\n  pageX: 0,\n  pageY: 0\n};\nfunction pointFromTouch(e, pointType) {\n  if (pointType === void 0) {\n    pointType = \"page\";\n  }\n  var primaryTouch = e.touches[0] || e.changedTouches[0];\n  var point = primaryTouch || defaultPagePoint;\n  return {\n    x: point[pointType + \"X\"],\n    y: point[pointType + \"Y\"]\n  };\n}\nfunction pointFromMouse(point, pointType) {\n  if (pointType === void 0) {\n    pointType = \"page\";\n  }\n  return {\n    x: point[pointType + \"X\"],\n    y: point[pointType + \"Y\"]\n  };\n}\nfunction extractEventInfo(event, pointType) {\n  if (pointType === void 0) {\n    pointType = \"page\";\n  }\n  return {\n    point: isTouchEvent(event) ? pointFromTouch(event, pointType) : pointFromMouse(event, pointType)\n  };\n}\nfunction getViewportPointFromEvent(event) {\n  return extractEventInfo(event, \"client\");\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n  if (shouldFilterPrimaryPointer === void 0) {\n    shouldFilterPrimaryPointer = false;\n  }\n  var listener = function (event) {\n    return handler(event, extractEventInfo(event));\n  };\n  return shouldFilterPrimaryPointer ? filterPrimaryPointer(listener) : listener;\n};\nexport { extractEventInfo, getViewportPointFromEvent, wrapHandler };","import { useEffect } from 'react';\nfunction addDomEvent(target, eventName, handler, options) {\n  target.addEventListener(eventName, handler, options);\n  return function () {\n    return target.removeEventListener(eventName, handler, options);\n  };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n  useEffect(function () {\n    var element = ref.current;\n    if (handler && element) {\n      return addDomEvent(element, eventName, handler, options);\n    }\n  }, [ref, eventName, handler, options]);\n}\nexport { addDomEvent, useDomEvent };","import { isBrowser } from '../utils/is-browser.js';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n  return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n  return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n  return isBrowser && window.onmousedown === null;\n};\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };","import { useDomEvent, addDomEvent } from './use-dom-event.js';\nimport { wrapHandler } from './event-info.js';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.js';\nvar mouseEventNames = {\n  pointerdown: \"mousedown\",\n  pointermove: \"mousemove\",\n  pointerup: \"mouseup\",\n  pointercancel: \"mousecancel\",\n  pointerover: \"mouseover\",\n  pointerout: \"mouseout\",\n  pointerenter: \"mouseenter\",\n  pointerleave: \"mouseleave\"\n};\nvar touchEventNames = {\n  pointerdown: \"touchstart\",\n  pointermove: \"touchmove\",\n  pointerup: \"touchend\",\n  pointercancel: \"touchcancel\"\n};\nfunction getPointerEventName(name) {\n  if (supportsPointerEvents()) {\n    return name;\n  } else if (supportsTouchEvents()) {\n    return touchEventNames[name];\n  } else if (supportsMouseEvents()) {\n    return mouseEventNames[name];\n  }\n  return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n  return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n  return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nexport { addPointerEvent, usePointerEvent };","function createLock(name) {\n  var lock = null;\n  return function () {\n    var openLock = function () {\n      lock = null;\n    };\n    if (lock === null) {\n      lock = name;\n      return openLock;\n    }\n    return false;\n  };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n  var lock = false;\n  if (drag === \"y\") {\n    lock = globalVerticalLock();\n  } else if (drag === \"x\") {\n    lock = globalHorizontalLock();\n  } else {\n    var openHorizontal_1 = globalHorizontalLock();\n    var openVertical_1 = globalVerticalLock();\n    if (openHorizontal_1 && openVertical_1) {\n      lock = function () {\n        openHorizontal_1();\n        openVertical_1();\n      };\n    } else {\n      // Release the locks because we don't use them\n      if (openHorizontal_1) openHorizontal_1();\n      if (openVertical_1) openVertical_1();\n    }\n  }\n  return lock;\n}\nfunction isDragActive() {\n  // Check the gesture lock - if we get it, it means no drag gesture is active\n  // and we can safely fire the tap gesture.\n  var openGestureLock = getGlobalLock(true);\n  if (!openGestureLock) return true;\n  openGestureLock();\n  return false;\n}\nexport { createLock, getGlobalLock, isDragActive };","function isMouseEvent(event) {\n  // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n  if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n    return !!(event.pointerType === \"mouse\");\n  }\n  return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n  var hasTouches = !!event.touches;\n  return hasTouches;\n}\nexport { isMouseEvent, isTouchEvent };","import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.js';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.js';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { createAnimationState } from '../../render/utils/animation-state.js';\nimport { AnimationType } from '../../render/utils/types.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\nvar animations = {\n  animation: makeRenderlessComponent(function (_a) {\n    var visualElement = _a.visualElement,\n      animate = _a.animate;\n    /**\n     * We dynamically generate the AnimationState manager as it contains a reference\n     * to the underlying animation library. We only want to load that if we load this,\n     * so people can optionally code split it out using the `m` component.\n     */\n    visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n    /**\n     * Subscribe any provided AnimationControls to the component's VisualElement\n     */\n    if (isAnimationControls(animate)) {\n      useEffect(function () {\n        return animate.subscribe(visualElement);\n      }, [animate]);\n    }\n  }),\n  exit: makeRenderlessComponent(function (props) {\n    var custom = props.custom,\n      visualElement = props.visualElement;\n    var _a = __read(usePresence(), 2),\n      isPresent = _a[0],\n      onExitComplete = _a[1];\n    var presenceContext = useContext(PresenceContext);\n    useEffect(function () {\n      var _a, _b;\n      var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Exit, !isPresent, {\n        custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom\n      });\n      !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(onExitComplete));\n    }, [isPresent]);\n  })\n};\nexport { animations };","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.js';\nimport { extractEventInfo } from '../events/event-info.js';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.js';\nimport { addPointerEvent } from '../events/use-pointer-event.js';\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,\n      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)) 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, {\n        x: 0,\n        y: 0\n      }) >= 3;\n      if (!isPanStarted && !isDistancePastThreshold) return;\n      var point = info.point;\n      var timestamp = getFrameData().timestamp;\n      _this.history.push(__assign(__assign({}, point), {\n        timestamp: timestamp\n      }));\n      var _a = _this.handlers,\n        onStart = _a.onStart,\n        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,\n        onEnd = _a.onEnd,\n        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) 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), {\n      timestamp: timestamp\n    })];\n    var onSessionStart = handlers.onSessionStart;\n    onSessionStart && 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 ? {\n    point: transformPagePoint(info.point)\n  } : info;\n}\nfunction subtractPoint(a, b) {\n  return {\n    x: a.x - b.x,\n    y: a.y - b.y\n  };\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 {\n      x: 0,\n      y: 0\n    };\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 > secondsToMilliseconds(timeDelta)) {\n      break;\n    }\n    i--;\n  }\n  if (!timestampedPoint) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n  var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n  if (time === 0) {\n    return {\n      x: 0,\n      y: 0\n    };\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}\nexport { PanSession };","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\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,\n    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  } 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 * Calculates a min projection point based on a pointer, pointer progress\n * within the drag target, and constraints.\n *\n * For instance if an element was 100px width, we were dragging from 0.25\n * along this axis, the pointer is at 200px, and there were no constraints,\n * we would calculate a min projection point of 175px.\n */\nfunction calcConstrainedMinPoint(point, length, progress, constraints, elastic) {\n  // Calculate a min point for this axis and apply it to the current pointer\n  var min = point - length * progress;\n  return constraints ? applyConstraints(min, constraints, elastic) : min;\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 ? axis.max + max - (axis.max - axis.min) : 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,\n    left = _a.left,\n    bottom = _a.bottom,\n    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 < layoutAxis.max - layoutAxis.min) {\n    _a = __read([max, min], 2), min = _a[0], max = _a[1];\n  }\n  return {\n    min: layoutAxis.min + min,\n    max: layoutAxis.min + max\n  };\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 the an axis position based on two axes and a progress value.\n */\nfunction calcPositionFromProgress(axis, constraints, progress) {\n  var axisLength = axis.max - axis.min;\n  var min = mix(constraints.min, constraints.max - axisLength, progress);\n  return {\n    min: min,\n    max: min + axisLength\n  };\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 === false) {\n    dragElastic = 0;\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\" ? dragElastic : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\nexport { applyConstraints, calcConstrainedMinPoint, calcPositionFromProgress, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };","import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.js';\nimport { getGlobalLock } from './utils/lock.js';\nimport { isRefObject } from '../../utils/is-ref-object.js';\nimport { addPointerEvent } from '../../events/use-pointer-event.js';\nimport { addDomEvent } from '../../events/use-dom-event.js';\nimport { getViewportPointFromEvent } from '../../events/event-info.js';\nimport { axisBox, convertAxisBoxToBoundingBox, convertBoundingBoxToAxisBox } from '../../utils/geometry/index.js';\nimport { eachAxis } from '../../utils/each-axis.js';\nimport { calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, applyConstraints, calcConstrainedMinPoint, calcPositionFromProgress, defaultElastic } from './utils/constraints.js';\nimport { getBoundingBox } from '../../render/dom/projection/measure.js';\nimport { calcOrigin } from '../../utils/geometry/delta-calc.js';\nimport { startAnimation } from '../../animation/utils/transitions.js';\nimport { AnimationType } from '../../render/utils/types.js';\nimport { collectProjectingAncestors, updateLayoutMeasurement, collectProjectingChildren } from '../../render/dom/projection/utils.js';\nimport { progress } from 'popmotion';\nimport { convertToRelativeProjection } from '../../render/dom/projection/convert-to-relative.js';\nimport { calcRelativeOffset } from '../../motion/features/layout/utils.js';\nimport { flushLayout, batchLayout } from '../../render/dom/utils/batch-layout.js';\nimport { flushSync } from 'framesync';\nvar elementDragControls = new WeakMap();\n/**\n *\n */\nvar lastPointerEvent;\nvar VisualElementDragControls = /** @class */function () {\n  function VisualElementDragControls(_a) {\n    var visualElement = _a.visualElement;\n    /**\n     * Track whether we're currently dragging.\n     *\n     * @internal\n     */\n    this.isDragging = false;\n    /**\n     * The current direction of drag, or `null` if both.\n     *\n     * @internal\n     */\n    this.currentDirection = null;\n    /**\n     * The permitted boundaries of travel, in pixels.\n     *\n     * @internal\n     */\n    this.constraints = false;\n    /**\n     * The per-axis resolved elastic values.\n     *\n     * @internal\n     */\n    this.elastic = axisBox();\n    /**\n     * A reference to the host component's latest props.\n     *\n     * @internal\n     */\n    this.props = {};\n    /**\n     * @internal\n     */\n    this.hasMutatedConstraints = false;\n    /**\n     * Track the initial position of the cursor relative to the dragging element\n     * when dragging starts as a value of 0-1 on each axis. We then use this to calculate\n     * an ideal bounding box for the VisualElement renderer to project into every frame.\n     *\n     * @internal\n     */\n    this.cursorProgress = {\n      x: 0.5,\n      y: 0.5\n    };\n    // When updating _dragX, or _dragY instead of the VisualElement,\n    // persist their values between drag gestures.\n    this.originPoint = {};\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    /**\n     * @internal\n     */\n    this.panSession = null;\n    this.visualElement = visualElement;\n    this.visualElement.enableLayoutProjection();\n    elementDragControls.set(visualElement, this);\n  }\n  /**\n   * Instantiate a PanSession for the drag gesture\n   *\n   * @public\n   */\n  VisualElementDragControls.prototype.start = function (originEvent, _a) {\n    var _this = this;\n    var _b = _a === void 0 ? {} : _a,\n      _c = _b.snapToCursor,\n      snapToCursor = _c === void 0 ? false : _c,\n      cursorProgress = _b.cursorProgress;\n    var onSessionStart = function (event) {\n      var _a;\n      // Stop any animations on both axis values immediately. This allows the user to throw and catch\n      // the component.\n      _this.stopMotion();\n      /**\n       * Save the initial point. We'll use this to calculate the pointer's position rather\n       * than the one we receive when the gesture actually starts. By then, the pointer will\n       * have already moved, and the perception will be of the pointer \"slipping\" across the element\n       */\n      var initialPoint = getViewportPointFromEvent(event).point;\n      (_a = _this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(_this);\n      _this.cancelLayout = batchLayout(function (read, write) {\n        var ancestors = collectProjectingAncestors(_this.visualElement);\n        var children = collectProjectingChildren(_this.visualElement);\n        var tree = __spreadArray(__spreadArray([], __read(ancestors)), __read(children));\n        var hasManuallySetCursorOrigin = false;\n        /**\n         * Apply a simple lock to the projection target. This ensures no animations\n         * can run on the projection box while this lock is active.\n         */\n        _this.isLayoutDrag() && _this.visualElement.lockProjectionTarget();\n        write(function () {\n          tree.forEach(function (element) {\n            return element.resetTransform();\n          });\n        });\n        read(function () {\n          updateLayoutMeasurement(_this.visualElement);\n          children.forEach(updateLayoutMeasurement);\n        });\n        write(function () {\n          tree.forEach(function (element) {\n            return element.restoreTransform();\n          });\n          if (snapToCursor) {\n            hasManuallySetCursorOrigin = _this.snapToCursor(initialPoint);\n          }\n        });\n        read(function () {\n          var isRelativeDrag = Boolean(_this.getAxisMotionValue(\"x\") && !_this.isExternalDrag());\n          if (!isRelativeDrag) {\n            _this.visualElement.rebaseProjectionTarget(true, _this.visualElement.measureViewportBox(false));\n          }\n          _this.visualElement.scheduleUpdateLayoutProjection();\n          /**\n           * When dragging starts, we want to find where the cursor is relative to the bounding box\n           * of the element. Every frame, we calculate a new bounding box using this relative position\n           * and let the visualElement renderer figure out how to reproject the element into this bounding\n           * box.\n           *\n           * By doing it this way, rather than applying an x/y transform directly to the element,\n           * we can ensure the component always visually sticks to the cursor as we'd expect, even\n           * if the DOM element itself changes layout as a result of React updates the user might\n           * make based on the drag position.\n           */\n          var projection = _this.visualElement.projection;\n          eachAxis(function (axis) {\n            if (!hasManuallySetCursorOrigin) {\n              var _a = projection.target[axis],\n                min = _a.min,\n                max = _a.max;\n              _this.cursorProgress[axis] = cursorProgress ? cursorProgress[axis] : progress(min, max, initialPoint[axis]);\n            }\n            /**\n             * If we have external drag MotionValues, record their origin point. On pointermove\n             * we'll apply the pan gesture offset directly to this value.\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n              _this.originPoint[axis] = axisValue.get();\n            }\n          });\n        });\n        write(function () {\n          flushSync.update();\n          flushSync.preRender();\n          flushSync.render();\n          flushSync.postRender();\n        });\n        read(function () {\n          return _this.resolveDragConstraints();\n        });\n      });\n    };\n    var onStart = function (event, info) {\n      var _a, _b, _c;\n      // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n      var _d = _this.props,\n        drag = _d.drag,\n        dragPropagation = _d.dragPropagation;\n      if (drag && !dragPropagation) {\n        if (_this.openGlobalLock) _this.openGlobalLock();\n        _this.openGlobalLock = getGlobalLock(drag);\n        // If we don 't have the lock, don't start dragging\n        if (!_this.openGlobalLock) return;\n      }\n      flushLayout();\n      // Set current drag status\n      _this.isDragging = true;\n      _this.currentDirection = null;\n      // Fire onDragStart event\n      (_b = (_a = _this.props).onDragStart) === null || _b === void 0 ? void 0 : _b.call(_a, event, info);\n      (_c = _this.visualElement.animationState) === null || _c === void 0 ? void 0 : _c.setActive(AnimationType.Drag, true);\n    };\n    var onMove = function (event, info) {\n      var _a, _b, _c, _d;\n      var _e = _this.props,\n        dragPropagation = _e.dragPropagation,\n        dragDirectionLock = _e.dragDirectionLock;\n      // If we didn't successfully receive the gesture lock, early return.\n      if (!dragPropagation && !_this.openGlobalLock) 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          (_b = (_a = _this.props).onDirectionLock) === null || _b === void 0 ? void 0 : _b.call(_a, _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      // Fire onDrag event\n      (_d = (_c = _this.props).onDrag) === null || _d === void 0 ? void 0 : _d.call(_c, event, info);\n      // Update the last pointer event\n      lastPointerEvent = event;\n    };\n    var onSessionEnd = function (event, info) {\n      return _this.stop(event, info);\n    };\n    var transformPagePoint = this.props.transformPagePoint;\n    this.panSession = new PanSession(originEvent, {\n      onSessionStart: onSessionStart,\n      onStart: onStart,\n      onMove: onMove,\n      onSessionEnd: onSessionEnd\n    }, {\n      transformPagePoint: transformPagePoint\n    });\n  };\n  VisualElementDragControls.prototype.resolveDragConstraints = function () {\n    var _this = this;\n    var _a = this.props,\n      dragConstraints = _a.dragConstraints,\n      dragElastic = _a.dragElastic;\n    var layout = this.visualElement.getLayoutState().layoutCorrected;\n    if (dragConstraints) {\n      this.constraints = isRefObject(dragConstraints) ? this.resolveRefConstraints(layout, dragConstraints) : calcRelativeConstraints(layout, dragConstraints);\n    } else {\n      this.constraints = false;\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 (this.constraints && !this.hasMutatedConstraints) {\n      eachAxis(function (axis) {\n        if (_this.getAxisMotionValue(axis)) {\n          _this.constraints[axis] = rebaseAxisConstraints(layout[axis], _this.constraints[axis]);\n        }\n      });\n    }\n  };\n  VisualElementDragControls.prototype.resolveRefConstraints = function (layoutBox, constraints) {\n    var _a = this.props,\n      onMeasureDragConstraints = _a.onMeasureDragConstraints,\n      transformPagePoint = _a.transformPagePoint;\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    this.constraintsBox = getBoundingBox(constraintsElement, transformPagePoint);\n    var measuredConstraints = calcViewportConstraints(layoutBox, this.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(convertAxisBoxToBoundingBox(measuredConstraints));\n      this.hasMutatedConstraints = !!userConstraints;\n      if (userConstraints) {\n        measuredConstraints = convertBoundingBoxToAxisBox(userConstraints);\n      }\n    }\n    return measuredConstraints;\n  };\n  VisualElementDragControls.prototype.cancelDrag = function () {\n    var _a, _b;\n    this.visualElement.unlockProjectionTarget();\n    (_a = this.cancelLayout) === null || _a === void 0 ? void 0 : _a.call(this);\n    this.isDragging = false;\n    this.panSession && this.panSession.end();\n    this.panSession = null;\n    if (!this.props.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.stop = function (event, info) {\n    var _a, _b, _c;\n    (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n    this.panSession = null;\n    var isDragging = this.isDragging;\n    this.cancelDrag();\n    if (!isDragging) return;\n    var velocity = info.velocity;\n    this.animateDragEnd(velocity);\n    (_c = (_b = this.props).onDragEnd) === null || _c === void 0 ? void 0 : _c.call(_b, event, info);\n  };\n  VisualElementDragControls.prototype.snapToCursor = function (point) {\n    var _this = this;\n    return eachAxis(function (axis) {\n      var drag = _this.props.drag;\n      // If we're not dragging this axis, do an early return.\n      if (!shouldDrag(axis, drag, _this.currentDirection)) return;\n      var axisValue = _this.getAxisMotionValue(axis);\n      if (axisValue) {\n        var box = _this.visualElement.getLayoutState().layout;\n        var length_1 = box[axis].max - box[axis].min;\n        var center = box[axis].min + length_1 / 2;\n        var offset = point[axis] - center;\n        _this.originPoint[axis] = point[axis];\n        axisValue.set(offset);\n      } else {\n        _this.cursorProgress[axis] = 0.5;\n        return true;\n      }\n    }).includes(true);\n  };\n  /**\n   * Update the specified axis with the latest pointer information.\n   */\n  VisualElementDragControls.prototype.updateAxis = function (axis, point, offset) {\n    var drag = this.props.drag;\n    // If we're not dragging this axis, do an early return.\n    if (!shouldDrag(axis, drag, this.currentDirection)) return;\n    return this.getAxisMotionValue(axis) ? this.updateAxisMotionValue(axis, offset) : this.updateVisualElementAxis(axis, point);\n  };\n  VisualElementDragControls.prototype.updateAxisMotionValue = function (axis, offset) {\n    var axisValue = this.getAxisMotionValue(axis);\n    if (!offset || !axisValue) return;\n    var nextValue = this.originPoint[axis] + offset[axis];\n    var update = this.constraints ? applyConstraints(nextValue, this.constraints[axis], this.elastic[axis]) : nextValue;\n    axisValue.set(update);\n  };\n  VisualElementDragControls.prototype.updateVisualElementAxis = function (axis, point) {\n    var _a;\n    // Get the actual layout bounding box of the element\n    var axisLayout = this.visualElement.getLayoutState().layout[axis];\n    // Calculate its current length. In the future we might want to lerp this to animate\n    // between lengths if the layout changes as we change the DOM\n    var axisLength = axisLayout.max - axisLayout.min;\n    // Get the initial progress that the pointer sat on this axis on gesture start.\n    var axisProgress = this.cursorProgress[axis];\n    // Calculate a new min point based on the latest pointer position, constraints and elastic\n    var min = calcConstrainedMinPoint(point[axis], axisLength, axisProgress, (_a = this.constraints) === null || _a === void 0 ? void 0 : _a[axis], this.elastic[axis]);\n    // Update the axis viewport target with this new min and the length\n    this.visualElement.setProjectionTargetAxis(axis, min, min + axisLength);\n  };\n  VisualElementDragControls.prototype.setProps = function (_a) {\n    var _b = _a.drag,\n      drag = _b === void 0 ? false : _b,\n      _c = _a.dragDirectionLock,\n      dragDirectionLock = _c === void 0 ? false : _c,\n      _d = _a.dragPropagation,\n      dragPropagation = _d === void 0 ? false : _d,\n      _e = _a.dragConstraints,\n      dragConstraints = _e === void 0 ? false : _e,\n      _f = _a.dragElastic,\n      dragElastic = _f === void 0 ? defaultElastic : _f,\n      _g = _a.dragMomentum,\n      dragMomentum = _g === void 0 ? true : _g,\n      remainingProps = __rest(_a, [\"drag\", \"dragDirectionLock\", \"dragPropagation\", \"dragConstraints\", \"dragElastic\", \"dragMomentum\"]);\n    this.props = __assign({\n      drag: drag,\n      dragDirectionLock: dragDirectionLock,\n      dragPropagation: dragPropagation,\n      dragConstraints: dragConstraints,\n      dragElastic: dragElastic,\n      dragMomentum: dragMomentum\n    }, remainingProps);\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   * - If the component will perform layout animations, we output the gesture to the component's\n   *      visual bounding box\n   * - Otherwise, we apply the delta to the x/y motion values.\n   */\n  VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n    var _a = this.props,\n      layout = _a.layout,\n      layoutId = _a.layoutId;\n    var dragKey = \"_drag\" + axis.toUpperCase();\n    if (this.props[dragKey]) {\n      return this.props[dragKey];\n    } else if (!layout && layoutId === undefined) {\n      return this.visualElement.getValue(axis, 0);\n    }\n  };\n  VisualElementDragControls.prototype.isLayoutDrag = function () {\n    return !this.getAxisMotionValue(\"x\");\n  };\n  VisualElementDragControls.prototype.isExternalDrag = function () {\n    var _a = this.props,\n      _dragX = _a._dragX,\n      _dragY = _a._dragY;\n    return _dragX || _dragY;\n  };\n  VisualElementDragControls.prototype.animateDragEnd = function (velocity) {\n    var _this = this;\n    var _a = this.props,\n      drag = _a.drag,\n      dragMomentum = _a.dragMomentum,\n      dragElastic = _a.dragElastic,\n      dragTransition = _a.dragTransition;\n    /**\n     * Everything beyond the drag gesture should be performed with\n     * relative projection so children stay in sync with their parent element.\n     */\n    var isRelative = convertToRelativeProjection(this.visualElement, this.isLayoutDrag() && !this.isExternalDrag());\n    /**\n     * If we had previously resolved constraints relative to the viewport,\n     * we need to also convert those to a relative coordinate space for the animation\n     */\n    var constraints = this.constraints || {};\n    if (isRelative && Object.keys(constraints).length && this.isLayoutDrag()) {\n      var projectionParent = this.visualElement.getProjectionParent();\n      if (projectionParent) {\n        var relativeConstraints_1 = calcRelativeOffset(projectionParent.projection.targetFinal, constraints);\n        eachAxis(function (axis) {\n          var _a = relativeConstraints_1[axis],\n            min = _a.min,\n            max = _a.max;\n          constraints[axis] = {\n            min: isNaN(min) ? undefined : min,\n            max: isNaN(max) ? undefined : max\n          };\n        });\n      }\n    }\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      /**\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({\n        type: \"inertia\",\n        velocity: dragMomentum ? velocity[axis] : 0,\n        bounceStiffness: bounceStiffness,\n        bounceDamping: bounceDamping,\n        timeConstant: 750,\n        restDelta: 1,\n        restSpeed: 10\n      }, 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.getAxisMotionValue(axis) ? _this.startAxisValueAnimation(axis, inertia) : _this.visualElement.startLayoutAnimation(axis, inertia, isRelative);\n    });\n    // Run all animations and then resolve the new drag constraints.\n    return Promise.all(momentumAnimations).then(function () {\n      var _a, _b;\n      (_b = (_a = _this.props).onDragTransitionEnd) === null || _b === void 0 ? void 0 : _b.call(_a);\n    });\n  };\n  VisualElementDragControls.prototype.stopMotion = function () {\n    var _this = this;\n    eachAxis(function (axis) {\n      var axisValue = _this.getAxisMotionValue(axis);\n      axisValue ? axisValue.stop() : _this.visualElement.stopLayoutAnimation();\n    });\n  };\n  VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n    var axisValue = this.getAxisMotionValue(axis);\n    if (!axisValue) return;\n    var currentValue = axisValue.get();\n    axisValue.set(currentValue);\n    axisValue.set(currentValue); // Set twice to hard-reset velocity\n    return startAnimation(axis, axisValue, 0, transition);\n  };\n  VisualElementDragControls.prototype.scalePoint = function () {\n    var _this = this;\n    var _a = this.props,\n      drag = _a.drag,\n      dragConstraints = _a.dragConstraints;\n    if (!isRefObject(dragConstraints) || !this.constraintsBox) return;\n    // Stop any current animations as there can be some visual glitching if we resize mid animation\n    this.stopMotion();\n    // Record the relative progress of the targetBox relative to the constraintsBox\n    var boxProgress = {\n      x: 0,\n      y: 0\n    };\n    eachAxis(function (axis) {\n      boxProgress[axis] = calcOrigin(_this.visualElement.projection.target[axis], _this.constraintsBox[axis]);\n    });\n    /**\n     * For each axis, calculate the current progress of the layout axis within the constraints.\n     * Then, using the latest layout and constraints measurements, reposition the new layout axis\n     * proportionally within the constraints.\n     */\n    this.updateConstraints(function () {\n      eachAxis(function (axis) {\n        if (!shouldDrag(axis, drag, null)) return;\n        // Calculate the position of the targetBox relative to the constraintsBox using the\n        // previously calculated progress\n        var _a = calcPositionFromProgress(_this.visualElement.projection.target[axis], _this.constraintsBox[axis], boxProgress[axis]),\n          min = _a.min,\n          max = _a.max;\n        _this.visualElement.setProjectionTargetAxis(axis, min, max);\n      });\n    });\n    /**\n     * If any other draggable components are queuing the same tasks synchronously\n     * this will wait until they've all been scheduled before flushing.\n     */\n    setTimeout(flushLayout, 1);\n  };\n  VisualElementDragControls.prototype.updateConstraints = function (onReady) {\n    var _this = this;\n    this.cancelLayout = batchLayout(function (read, write) {\n      var ancestors = collectProjectingAncestors(_this.visualElement);\n      write(function () {\n        return ancestors.forEach(function (element) {\n          return element.resetTransform();\n        });\n      });\n      read(function () {\n        return updateLayoutMeasurement(_this.visualElement);\n      });\n      write(function () {\n        return ancestors.forEach(function (element) {\n          return element.restoreTransform();\n        });\n      });\n      read(function () {\n        _this.resolveDragConstraints();\n      });\n      if (onReady) write(onReady);\n    });\n  };\n  VisualElementDragControls.prototype.mount = function (visualElement) {\n    var _this = this;\n    var element = 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.props,\n        drag = _a.drag,\n        _b = _a.dragListener,\n        dragListener = _b === void 0 ? true : _b;\n      drag && dragListener && _this.start(event);\n    });\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      _this.scalePoint();\n    });\n    /**\n     * Ensure drag constraints are resolved correctly relative to the dragging element\n     * whenever its layout changes.\n     */\n    var stopLayoutUpdateListener = visualElement.onLayoutUpdate(function () {\n      if (_this.isDragging) {\n        _this.resolveDragConstraints();\n      }\n    });\n    /**\n     * If the previous component with this same layoutId was dragging at the time\n     * it was unmounted, we want to continue the same gesture on this component.\n     */\n    var prevDragCursor = visualElement.prevDragCursor;\n    if (prevDragCursor) {\n      this.start(lastPointerEvent, {\n        cursorProgress: prevDragCursor\n      });\n    }\n    /**\n     * Return a function that will teardown the drag gesture\n     */\n    return function () {\n      stopPointerListener === null || stopPointerListener === void 0 ? void 0 : stopPointerListener();\n      stopResizeListener === null || stopResizeListener === void 0 ? void 0 : stopResizeListener();\n      stopLayoutUpdateListener === null || stopLayoutUpdateListener === void 0 ? void 0 : stopLayoutUpdateListener();\n      _this.cancelDrag();\n    };\n  };\n  return VisualElementDragControls;\n}();\nfunction shouldDrag(direction, drag, currentDirection) {\n  return (drag === true || drag === direction) && (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) {\n    lockThreshold = 10;\n  }\n  var direction = null;\n  if (Math.abs(offset.y) > lockThreshold) {\n    direction = \"y\";\n  } else if (Math.abs(offset.x) > lockThreshold) {\n    direction = \"x\";\n  }\n  return direction;\n}\nexport { VisualElementDragControls, elementDragControls };","import { calcRelativeOffset } from '../../../motion/features/layout/utils.js';\nimport { eachAxis } from '../../../utils/each-axis.js';\nimport { removeBoxTransforms } from '../../../utils/geometry/delta-apply.js';\n\n/**\n * Returns a boolean stating whether or not we converted the projection\n * to relative projection.\n */\nfunction convertToRelativeProjection(visualElement, isLayoutDrag) {\n  if (isLayoutDrag === void 0) {\n    isLayoutDrag = true;\n  }\n  var projectionParent = visualElement.getProjectionParent();\n  if (!projectionParent) return false;\n  var offset;\n  if (isLayoutDrag) {\n    offset = calcRelativeOffset(projectionParent.projection.target, visualElement.projection.target);\n    removeBoxTransforms(offset, projectionParent.getLatestValues());\n  } else {\n    offset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n  }\n  eachAxis(function (axis) {\n    return visualElement.setProjectionTargetAxis(axis, offset[axis].min, offset[axis].max, true);\n  });\n  return true;\n}\nexport { convertToRelativeProjection };","import { useDrag } from '../../gestures/drag/use-drag.js';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\nvar drag = {\n  pan: makeRenderlessComponent(usePanGesture),\n  drag: makeRenderlessComponent(useDrag)\n};\nexport { drag };","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.js';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.js';\nimport { usePointerEvent } from '../events/use-pointer-event.js';\nimport { PanSession } from './PanSession.js';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @internalremarks\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,\n    onPanStart = _a.onPanStart,\n    onPanEnd = _a.onPanEnd,\n    onPanSessionStart = _a.onPanSessionStart,\n    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 () {\n    return panSession.current && panSession.current.end();\n  });\n}\nexport { usePanGesture };","import { __assign } from 'tslib';\nimport { useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.js';\nimport { VisualElementDragControls } from './VisualElementDragControls.js';\nimport { useConstant } from '../../utils/use-constant.js';\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n  var groupDragControls = props.dragControls,\n    visualElement = props.visualElement;\n  var transformPagePoint = useContext(MotionConfigContext).transformPagePoint;\n  var dragControls = useConstant(function () {\n    return new VisualElementDragControls({\n      visualElement: visualElement\n    });\n  });\n  dragControls.setProps(__assign(__assign({}, props), {\n    transformPagePoint: transformPagePoint\n  }));\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 () {\n    return groupDragControls && groupDragControls.subscribe(dragControls);\n  }, [dragControls]);\n  // Mount the drag controls with the visualElement\n  useEffect(function () {\n    return dragControls.mount(visualElement);\n  }, []);\n}\nexport { useDrag };","import { isMouseEvent } from './utils/event-type.js';\nimport { AnimationType } from '../render/utils/types.js';\nimport { usePointerEvent } from '../events/use-pointer-event.js';\nimport { isDragActive } from './drag/utils/lock.js';\nfunction createHoverEvent(visualElement, isActive, callback) {\n  return function (event, info) {\n    var _a;\n    if (!isMouseEvent(event) || isDragActive()) return;\n    callback === null || callback === void 0 ? void 0 : callback(event, info);\n    (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\n  };\n}\nfunction useHoverGesture(_a) {\n  var onHoverStart = _a.onHoverStart,\n    onHoverEnd = _a.onHoverEnd,\n    whileHover = _a.whileHover,\n    visualElement = _a.visualElement;\n  usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover ? createHoverEvent(visualElement, true, onHoverStart) : undefined);\n  usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover ? createHoverEvent(visualElement, false, onHoverEnd) : undefined);\n}\nexport { useHoverGesture };","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nvar isNodeOrChild = function (parent, child) {\n  if (!child) {\n    return false;\n  } else if (parent === child) {\n    return true;\n  } else {\n    return isNodeOrChild(parent, child.parentElement);\n  }\n};\nexport { isNodeOrChild };","import { useFocusGesture } from '../../gestures/use-focus-gesture.js';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.js';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.js';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.js';\nvar gestureAnimations = {\n  tap: makeRenderlessComponent(useTapGesture),\n  focus: makeRenderlessComponent(useFocusGesture),\n  hover: makeRenderlessComponent(useHoverGesture)\n};\nexport { gestureAnimations };","import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.js';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.js';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.js';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.js';\nimport { isDragActive } from './drag/utils/lock.js';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n  var onTap = _a.onTap,\n    onTapStart = _a.onTapStart,\n    onTapCancel = _a.onTapCancel,\n    whileTap = _a.whileTap,\n    visualElement = _a.visualElement;\n  var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n  var isPressing = useRef(false);\n  var cancelPointerEndListeners = useRef(null);\n  function removePointerEndListener() {\n    var _a;\n    (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n    cancelPointerEndListeners.current = null;\n  }\n  function checkPointerEnd() {\n    var _a;\n    removePointerEndListener();\n    isPressing.current = false;\n    (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, false);\n    return !isDragActive();\n  }\n  function onPointerUp(event, info) {\n    if (!checkPointerEnd()) return;\n    /**\n     * We only count this as a tap gesture if the event.target is the same\n     * as, or a child of, this component's element\n     */\n    !isNodeOrChild(visualElement.getInstance(), event.target) ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info) : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n  }\n  function onPointerCancel(event, info) {\n    if (!checkPointerEnd()) return;\n    onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n  }\n  function onPointerDown(event, info) {\n    var _a;\n    removePointerEndListener();\n    if (isPressing.current) return;\n    isPressing.current = true;\n    cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp), addPointerEvent(window, \"pointercancel\", onPointerCancel));\n    onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n  }\n  usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined);\n  useUnmountEffect(removePointerEndListener);\n}\nexport { useTapGesture };","import { AnimationType } from '../render/utils/types.js';\nimport { useDomEvent } from '../events/use-dom-event.js';\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n  var whileFocus = _a.whileFocus,\n    visualElement = _a.visualElement;\n  var onFocus = function () {\n    var _a;\n    (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, true);\n  };\n  var onBlur = function () {\n    var _a;\n    (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, false);\n  };\n  useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n  useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\nexport { useFocusGesture };","import { __assign } from 'tslib';\nimport { complex, px } from 'style-value-types';\nimport { mix } from 'popmotion';\nimport { cssVariableRegex } from '../utils/css-variables-conversion.js';\nfunction pixelsToPercent(pixels, axis) {\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 */\nfunction correctBorderRadius(latest, _layoutState, _a) {\n  var target = _a.target;\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    } 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, target.x);\n  var y = pixelsToPercent(latest, target.y);\n  return x + \"% \" + y + \"%\";\n}\nvar varToken = \"_$css\";\nfunction correctBoxShadow(latest, _a) {\n  var delta = _a.delta,\n    treeScale = _a.treeScale;\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) 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 = delta.x.scale * treeScale.x;\n  var yScale = delta.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\") shadow[2 + offset] /= averageScale;\n  // Spread\n  if (typeof shadow[3 + offset] === \"number\") 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}\nvar borderCorrectionDefinition = {\n  process: correctBorderRadius\n};\nvar defaultScaleCorrectors = {\n  borderRadius: __assign(__assign({}, borderCorrectionDefinition), {\n    applyTo: [\"borderTopLeftRadius\", \"borderTopRightRadius\", \"borderBottomLeftRadius\", \"borderBottomRightRadius\"]\n  }),\n  borderTopLeftRadius: borderCorrectionDefinition,\n  borderTopRightRadius: borderCorrectionDefinition,\n  borderBottomLeftRadius: borderCorrectionDefinition,\n  borderBottomRightRadius: borderCorrectionDefinition,\n  boxShadow: {\n    process: correctBoxShadow\n  }\n};\nexport { correctBorderRadius, correctBoxShadow, defaultScaleCorrectors, pixelsToPercent };","import { __extends, __rest, __assign, __read } from 'tslib';\nimport * as React from 'react';\nimport { eachAxis } from '../../../utils/each-axis.js';\nimport { startAnimation, getValueTransition } from '../../../animation/utils/transitions.js';\nimport { checkIfParentHasChanged, calcRelativeOffset, tweenAxis } from './utils.js';\nimport { VisibilityAction } from '../../../components/AnimateSharedLayout/types.js';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.js';\nimport { axisBox } from '../../../utils/geometry/index.js';\nimport { addScaleCorrection } from '../../../render/dom/projection/scale-correction.js';\nimport { defaultScaleCorrectors } from '../../../render/dom/projection/default-scale-correctors.js';\nvar progressTarget = 1000;\nvar Animate = /** @class */function (_super) {\n  __extends(Animate, _super);\n  function Animate() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n    /**\n     * A mutable object that tracks the target viewport box\n     * for the current animation frame.\n     */\n    _this.frameTarget = axisBox();\n    /**\n     * The current animation target, we use this to check whether to start\n     * a new animation or continue the existing one.\n     */\n    _this.currentAnimationTarget = axisBox();\n    /**\n     * Track whether we're animating this axis.\n     */\n    _this.isAnimating = {\n      x: false,\n      y: false\n    };\n    _this.stopAxisAnimation = {\n      x: undefined,\n      y: undefined\n    };\n    _this.isAnimatingTree = false;\n    _this.animate = function (target, origin, _a) {\n      if (_a === void 0) {\n        _a = {};\n      }\n      var originBox = _a.originBox,\n        targetBox = _a.targetBox,\n        visibilityAction = _a.visibilityAction,\n        shouldStackAnimate = _a.shouldStackAnimate,\n        onComplete = _a.onComplete,\n        prevParent = _a.prevParent,\n        config = __rest(_a, [\"originBox\", \"targetBox\", \"visibilityAction\", \"shouldStackAnimate\", \"onComplete\", \"prevParent\"]);\n      var _b = _this.props,\n        visualElement = _b.visualElement,\n        layout = _b.layout;\n      /**\n       * Early return if we've been instructed not to animate this render.\n       */\n      if (shouldStackAnimate === false) {\n        _this.isAnimatingTree = false;\n        return _this.safeToRemove();\n      }\n      /**\n       * Prioritise tree animations\n       */\n      if (_this.isAnimatingTree && shouldStackAnimate !== true) {\n        return;\n      } else if (shouldStackAnimate) {\n        _this.isAnimatingTree = true;\n      }\n      /**\n       * Allow the measured origin (prev bounding box) and target (actual layout) to be\n       * overridden by the provided config.\n       */\n      origin = originBox || origin;\n      target = targetBox || target;\n      /**\n       * If this element has a projecting parent, there's an opportunity to animate\n       * it relatively to that parent rather than relatively to the viewport. This\n       * allows us to add orchestrated animations.\n       */\n      var isRelative = false;\n      var projectionParent = visualElement.getProjectionParent();\n      if (projectionParent) {\n        var prevParentViewportBox = projectionParent.prevViewportBox;\n        var parentLayout = projectionParent.getLayoutState().layout;\n        /**\n         * If we're being provided a previous parent VisualElement by AnimateSharedLayout\n         */\n        if (prevParent) {\n          /**\n           * If we've been provided an explicit target box it means we're animating back\n           * to this previous parent. So we can make a relative box by comparing to the previous\n           * parent's layout\n           */\n          if (targetBox) {\n            parentLayout = prevParent.getLayoutState().layout;\n          }\n          /**\n           * Likewise if we've been provided an explicit origin box it means we're\n           * animating out from a different element. So we should figure out where that was\n           * on screen relative to the new parent element.\n           */\n          if (originBox && !checkIfParentHasChanged(prevParent, projectionParent) && prevParent.prevViewportBox) {\n            prevParentViewportBox = prevParent.prevViewportBox;\n          }\n        }\n        if (prevParentViewportBox && isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox)) {\n          isRelative = true;\n          origin = calcRelativeOffset(prevParentViewportBox, origin);\n          target = calcRelativeOffset(parentLayout, target);\n        }\n      }\n      var boxHasMoved = hasMoved(origin, target);\n      var animations = eachAxis(function (axis) {\n        var _a, _b;\n        /**\n         * If layout is set to \"position\", we can resize the origin box based on the target\n         * box and only animate its position.\n         */\n        if (layout === \"position\") {\n          var targetLength = target[axis].max - target[axis].min;\n          origin[axis].max = origin[axis].min + targetLength;\n        }\n        if (visualElement.projection.isTargetLocked) {\n          return;\n        } else if (visibilityAction !== undefined) {\n          visualElement.setVisibility(visibilityAction === VisibilityAction.Show);\n        } else if (boxHasMoved) {\n          // If the box has moved, animate between it's current visual state and its\n          // final state\n          return _this.animateAxis(axis, target[axis], origin[axis], __assign(__assign({}, config), {\n            isRelative: isRelative\n          }));\n        } else {\n          (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a);\n          // If the box has remained in the same place, immediately set the axis target\n          // to the final desired state\n          return visualElement.setProjectionTargetAxis(axis, target[axis].min, target[axis].max, isRelative);\n        }\n      });\n      // Force a render to ensure there's no flash of uncorrected bounding box.\n      visualElement.syncRender();\n      /**\n       * If this visualElement isn't present (ie it's been removed from the tree by the user but\n       * kept in by the tree by AnimatePresence) then call safeToRemove when all axis animations\n       * have successfully finished.\n       */\n      return Promise.all(animations).then(function () {\n        _this.isAnimatingTree = false;\n        onComplete && onComplete();\n        visualElement.notifyLayoutAnimationComplete();\n      });\n    };\n    return _this;\n  }\n  Animate.prototype.componentDidMount = function () {\n    var _this = this;\n    var visualElement = this.props.visualElement;\n    visualElement.animateMotionValue = startAnimation;\n    visualElement.enableLayoutProjection();\n    this.unsubLayoutReady = visualElement.onLayoutUpdate(this.animate);\n    visualElement.layoutSafeToRemove = function () {\n      return _this.safeToRemove();\n    };\n    addScaleCorrection(defaultScaleCorrectors);\n  };\n  Animate.prototype.componentWillUnmount = function () {\n    var _this = this;\n    this.unsubLayoutReady();\n    eachAxis(function (axis) {\n      var _a, _b;\n      return (_b = (_a = _this.stopAxisAnimation)[axis]) === null || _b === void 0 ? void 0 : _b.call(_a);\n    });\n  };\n  /**\n   * TODO: This manually performs animations on the visualElement's layout progress\n   * values. It'd be preferable to amend the startLayoutAxisAnimation\n   * API to accept more custom animations like this.\n   */\n  Animate.prototype.animateAxis = function (axis, target, origin, _a) {\n    var _this = this;\n    var _b, _c;\n    var _d = _a === void 0 ? {} : _a,\n      transition = _d.transition,\n      isRelative = _d.isRelative;\n    /**\n     * If we're not animating to a new target, don't run this animation\n     */\n    if (this.isAnimating[axis] && axisIsEqual(target, this.currentAnimationTarget[axis])) {\n      return;\n    }\n    (_c = (_b = this.stopAxisAnimation)[axis]) === null || _c === void 0 ? void 0 : _c.call(_b);\n    this.isAnimating[axis] = true;\n    var visualElement = this.props.visualElement;\n    var frameTarget = this.frameTarget[axis];\n    var layoutProgress = visualElement.getProjectionAnimationProgress()[axis];\n    /**\n     * Set layout progress back to 0. We set it twice to hard-reset any velocity that might\n     * be re-incoporated into a subsequent spring animation.\n     */\n    layoutProgress.clearListeners();\n    layoutProgress.set(0);\n    layoutProgress.set(0);\n    /**\n     * Create an animation function to run once per frame. This will tween the visual bounding box from\n     * origin to target using the latest progress value.\n     */\n    var frame = function () {\n      // Convert the latest layoutProgress, which is a value from 0-1000, into a 0-1 progress\n      var p = layoutProgress.get() / progressTarget;\n      // Tween the axis and update the visualElement with the latest values\n      tweenAxis(frameTarget, origin, target, p);\n      visualElement.setProjectionTargetAxis(axis, frameTarget.min, frameTarget.max, isRelative);\n    };\n    // Synchronously run a frame to ensure there's no flash of the uncorrected bounding box.\n    frame();\n    // Create a function to stop animation on this specific axis\n    var unsubscribeProgress = layoutProgress.onChange(frame);\n    this.stopAxisAnimation[axis] = function () {\n      _this.isAnimating[axis] = false;\n      layoutProgress.stop();\n      unsubscribeProgress();\n    };\n    this.currentAnimationTarget[axis] = target;\n    var layoutTransition = transition || visualElement.getDefaultTransition() || defaultLayoutTransition;\n    // Start the animation on this axis\n    var animation = startAnimation(axis === \"x\" ? \"layoutX\" : \"layoutY\", layoutProgress, progressTarget, layoutTransition && getValueTransition(layoutTransition, \"layout\")).then(this.stopAxisAnimation[axis]);\n    return animation;\n  };\n  Animate.prototype.safeToRemove = function () {\n    var _a, _b;\n    (_b = (_a = this.props).safeToRemove) === null || _b === void 0 ? void 0 : _b.call(_a);\n  };\n  Animate.prototype.render = function () {\n    return null;\n  };\n  return Animate;\n}(React.Component);\nfunction AnimateLayoutContextProvider(props) {\n  var _a = __read(usePresence(), 2),\n    safeToRemove = _a[1];\n  return React.createElement(Animate, __assign({}, props, {\n    safeToRemove: safeToRemove\n  }));\n}\nfunction hasMoved(a, b) {\n  return !isZeroBox(a) && !isZeroBox(b) && (!axisIsEqual(a.x, b.x) || !axisIsEqual(a.y, b.y));\n}\nvar zeroAxis = {\n  min: 0,\n  max: 0\n};\nfunction isZeroBox(a) {\n  return axisIsEqual(a.x, zeroAxis) && axisIsEqual(a.y, zeroAxis);\n}\nfunction axisIsEqual(a, b) {\n  return a.min === b.min && a.max === b.max;\n}\nvar defaultLayoutTransition = {\n  duration: 0.45,\n  ease: [0.4, 0, 0.1, 1]\n};\nfunction isProvidedCorrectDataForRelativeSharedLayout(prevParent, originBox, targetBox) {\n  return prevParent || !prevParent && !(originBox || targetBox);\n}\nexport { AnimateLayoutContextProvider };","import { __spreadArray, __read } from 'tslib';\nimport sync, { flushSync } from 'framesync';\nimport { collectProjectingAncestors, updateLayoutMeasurement } from '../../../render/dom/projection/utils.js';\nimport { batchLayout, flushLayout } from '../../../render/dom/utils/batch-layout.js';\nimport { compareByDepth } from '../../../render/utils/compare-by-depth.js';\nimport { Presence } from '../types.js';\n\n/**\n * Default handlers for batching VisualElements\n */\nvar defaultHandler = {\n  layoutReady: function (child) {\n    return child.notifyLayoutReady();\n  }\n};\n/**\n * Create a batcher to process VisualElements\n */\nfunction createBatcher() {\n  var queue = new Set();\n  return {\n    add: function (child) {\n      return queue.add(child);\n    },\n    flush: function (_a) {\n      var _b = _a === void 0 ? defaultHandler : _a,\n        layoutReady = _b.layoutReady,\n        parent = _b.parent;\n      batchLayout(function (read, write) {\n        var order = Array.from(queue).sort(compareByDepth);\n        var ancestors = parent ? collectProjectingAncestors(parent) : [];\n        write(function () {\n          var allElements = __spreadArray(__spreadArray([], __read(ancestors)), __read(order));\n          allElements.forEach(function (element) {\n            return element.resetTransform();\n          });\n        });\n        read(function () {\n          order.forEach(updateLayoutMeasurement);\n        });\n        write(function () {\n          ancestors.forEach(function (element) {\n            return element.restoreTransform();\n          });\n          order.forEach(layoutReady);\n        });\n        read(function () {\n          /**\n           * After all children have started animating, ensure any Entering components are set to Present.\n           * If we add deferred animations (set up all animations and then start them in two loops) this\n           * could be moved to the start loop. But it needs to happen after all the animations configs\n           * are generated in AnimateSharedLayout as this relies on presence data\n           */\n          order.forEach(function (child) {\n            if (child.isPresent) child.presence = Presence.Present;\n          });\n        });\n        write(function () {\n          /**\n           * Starting these animations will have queued jobs on the frame loop. In some situations,\n           * like when removing an element, these will be processed too late after the DOM is manipulated,\n           * leaving a flash of incorrectly-projected content. By manually flushing these jobs\n           * we ensure there's no flash.\n           */\n          flushSync.preRender();\n          flushSync.render();\n        });\n        read(function () {\n          /**\n           * Schedule a callback at the end of the following frame to assign the latest projection\n           * box to the prevViewportBox snapshot. Once global batching is in place this could be run\n           * synchronously. But for now it ensures that if any nested `AnimateSharedLayout` top-level\n           * child attempts to calculate its previous relative position against a prevViewportBox\n           * it will be against its latest projection box instead, as the snapshot is useless beyond this\n           * render.\n           */\n          sync.postRender(function () {\n            return order.forEach(assignProjectionToSnapshot);\n          });\n          queue.clear();\n        });\n      });\n      // TODO: Need to find a layout-synchronous way of flushing this\n      flushLayout();\n    }\n  };\n}\nfunction assignProjectionToSnapshot(child) {\n  child.prevViewportBox = child.projection.target;\n}\nexport { createBatcher };","import { createContext } from 'react';\nimport { createBatcher } from '../components/AnimateSharedLayout/utils/batcher.js';\nvar SharedLayoutContext = createContext(createBatcher());\n/**\n * @internal\n */\nvar FramerTreeLayoutContext = createContext(createBatcher());\nfunction isSharedLayout(context) {\n  return !!context.forceUpdate;\n}\nexport { FramerTreeLayoutContext, SharedLayoutContext, isSharedLayout };","import { __extends, __assign } from 'tslib';\nimport React__default, { useContext } from 'react';\nimport { isSharedLayout, SharedLayoutContext, FramerTreeLayoutContext } from '../../../context/SharedLayoutContext.js';\nimport { snapshotViewportBox } from '../../../render/dom/projection/utils.js';\n\n/**\n * This component is responsible for scheduling the measuring of the motion component\n */\nvar Measure = /** @class */function (_super) {\n  __extends(Measure, _super);\n  function Measure() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n  /**\n   * If this is a child of a SyncContext, register the VisualElement with it on mount.\n   */\n  Measure.prototype.componentDidMount = function () {\n    var _a = this.props,\n      syncLayout = _a.syncLayout,\n      framerSyncLayout = _a.framerSyncLayout,\n      visualElement = _a.visualElement;\n    isSharedLayout(syncLayout) && syncLayout.register(visualElement);\n    isSharedLayout(framerSyncLayout) && framerSyncLayout.register(visualElement);\n    visualElement.onUnmount(function () {\n      if (isSharedLayout(syncLayout)) {\n        syncLayout.remove(visualElement);\n      }\n      if (isSharedLayout(framerSyncLayout)) {\n        framerSyncLayout.remove(visualElement);\n      }\n    });\n  };\n  /**\n   * If this is a child of a SyncContext, notify it that it needs to re-render. It will then\n   * handle the snapshotting.\n   *\n   * If it is stand-alone component, add it to the batcher.\n   */\n  Measure.prototype.getSnapshotBeforeUpdate = function () {\n    var _a = this.props,\n      syncLayout = _a.syncLayout,\n      visualElement = _a.visualElement;\n    if (isSharedLayout(syncLayout)) {\n      syncLayout.syncUpdate();\n    } else {\n      snapshotViewportBox(visualElement);\n      syncLayout.add(visualElement);\n    }\n    return null;\n  };\n  Measure.prototype.componentDidUpdate = function () {\n    var syncLayout = this.props.syncLayout;\n    if (!isSharedLayout(syncLayout)) syncLayout.flush();\n  };\n  Measure.prototype.render = function () {\n    return null;\n  };\n  return Measure;\n}(React__default.Component);\nfunction MeasureContextProvider(props) {\n  var syncLayout = useContext(SharedLayoutContext);\n  var framerSyncLayout = useContext(FramerTreeLayoutContext);\n  return React__default.createElement(Measure, __assign({}, props, {\n    syncLayout: syncLayout,\n    framerSyncLayout: framerSyncLayout\n  }));\n}\nexport { MeasureContextProvider };","import { AnimateLayoutContextProvider } from './Animate.js';\nimport { MeasureContextProvider } from './Measure.js';\nvar layoutAnimations = {\n  measureLayout: MeasureContextProvider,\n  layoutAnimation: AnimateLayoutContextProvider\n};\nexport { layoutAnimations };","import { mix } from 'popmotion';\nfunction tweenAxis(target, prev, next, p) {\n  target.min = mix(prev.min, next.min, p);\n  target.max = mix(prev.max, next.max, p);\n}\nfunction calcRelativeOffsetAxis(parent, child) {\n  return {\n    min: child.min - parent.min,\n    max: child.max - parent.min\n  };\n}\nfunction calcRelativeOffset(parent, child) {\n  return {\n    x: calcRelativeOffsetAxis(parent.x, child.x),\n    y: calcRelativeOffsetAxis(parent.y, child.y)\n  };\n}\nfunction checkIfParentHasChanged(prev, next) {\n  var prevId = prev.getLayoutId();\n  var nextId = next.getLayoutId();\n  return prevId !== nextId || nextId === undefined && prev !== next;\n}\nexport { calcRelativeOffset, calcRelativeOffsetAxis, checkIfParentHasChanged, tweenAxis };","var makeRenderlessComponent = function (hook) {\n  return function (props) {\n    hook(props);\n    return null;\n  };\n};\nexport { makeRenderlessComponent };","import { axisBox, delta } from '../../utils/geometry/index.js';\nvar createProjectionState = function () {\n  return {\n    isEnabled: false,\n    isHydrated: false,\n    isTargetLocked: false,\n    target: axisBox(),\n    targetFinal: axisBox()\n  };\n};\nfunction createLayoutState() {\n  return {\n    isHydrated: false,\n    layout: axisBox(),\n    layoutCorrected: axisBox(),\n    treeScale: {\n      x: 1,\n      y: 1\n    },\n    delta: delta(),\n    deltaFinal: delta(),\n    deltaTransform: \"\"\n  };\n}\nvar zeroLayout = createLayoutState();\nexport { createLayoutState, createProjectionState, zeroLayout };","import { zeroLayout } from '../../utils/state.js';\n\n/**\n * Build a transform style that takes a calculated delta between the element's current\n * space on screen and projects it into the desired space.\n */\nfunction buildLayoutProjectionTransform(_a, treeScale, latestTransform) {\n  var x = _a.x,\n    y = _a.y;\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 = x.translate / treeScale.x;\n  var yTranslate = y.translate / treeScale.y;\n  var transform = \"translate3d(\" + xTranslate + \"px, \" + yTranslate + \"px, 0) \";\n  if (latestTransform) {\n    var rotate = latestTransform.rotate,\n      rotateX = latestTransform.rotateX,\n      rotateY = latestTransform.rotateY;\n    if (rotate) transform += \"rotate(\" + rotate + \") \";\n    if (rotateX) transform += \"rotateX(\" + rotateX + \") \";\n    if (rotateY) transform += \"rotateY(\" + rotateY + \") \";\n  }\n  transform += \"scale(\" + x.scale + \", \" + y.scale + \")\";\n  return !latestTransform && transform === identityProjection ? \"\" : transform;\n}\n/**\n * Take the calculated delta origin and apply it as a transform string.\n */\nfunction buildLayoutProjectionTransformOrigin(_a) {\n  var deltaFinal = _a.deltaFinal;\n  return deltaFinal.x.origin * 100 + \"% \" + deltaFinal.y.origin * 100 + \"% 0\";\n}\nvar identityProjection = buildLayoutProjectionTransform(zeroLayout.delta, zeroLayout.treeScale, {\n  x: 1,\n  y: 1\n});\nexport { buildLayoutProjectionTransform, buildLayoutProjectionTransformOrigin, identityProjection };","import { __spreadArray, __read } from 'tslib';\nimport { SubscriptionManager } from '../../utils/subscription-manager.js';\nvar names = [\"LayoutMeasure\", \"BeforeLayoutMeasure\", \"LayoutUpdate\", \"ViewportBoxUpdate\", \"Update\", \"Render\", \"AnimationComplete\", \"LayoutAnimationComplete\", \"AnimationStart\", \"SetAxisTarget\", \"Unmount\"];\nfunction createLifecycles() {\n  var managers = names.map(function () {\n    return new SubscriptionManager();\n  });\n  var propSubscriptions = {};\n  var lifecycles = {\n    clearAllListeners: function () {\n      return managers.forEach(function (manager) {\n        return manager.clear();\n      });\n    },\n    updatePropListeners: function (props) {\n      return names.forEach(function (name) {\n        var _a;\n        (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n        var on = \"on\" + name;\n        var propListener = props[on];\n        if (propListener) {\n          propSubscriptions[name] = lifecycles[on](propListener);\n        }\n      });\n    }\n  };\n  managers.forEach(function (manager, i) {\n    lifecycles[\"on\" + names[i]] = function (handler) {\n      return manager.add(handler);\n    };\n    lifecycles[\"notify\" + names[i]] = function () {\n      var args = [];\n      for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n      }\n      return manager.notify.apply(manager, __spreadArray([], __read(args)));\n    };\n  });\n  return lifecycles;\n}\nexport { createLifecycles };","import { addUniqueItem, removeItem } from '../../utils/array.js';\nimport { compareByDepth } from './compare-by-depth.js';\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}();\nexport { FlatTree };","import { __assign, __spreadArray, __read } from 'tslib';\nimport sync, { cancelSync } from 'framesync';\nimport { pipe } from 'popmotion';\nimport { Presence } from '../components/AnimateSharedLayout/types.js';\nimport { eachAxis } from '../utils/each-axis.js';\nimport { axisBox } from '../utils/geometry/index.js';\nimport { removeBoxTransforms, applyBoxTransforms } from '../utils/geometry/delta-apply.js';\nimport { calcRelativeBox, updateBoxDelta } from '../utils/geometry/delta-calc.js';\nimport { motionValue } from '../value/index.js';\nimport { isMotionValue } from '../value/utils/is-motion-value.js';\nimport { buildLayoutProjectionTransform } from './html/utils/build-projection-transform.js';\nimport { variantPriorityOrder } from './utils/animation-state.js';\nimport { createLifecycles } from './utils/lifecycles.js';\nimport { updateMotionValuesFromProps } from './utils/motion-values.js';\nimport { updateLayoutDeltas } from './utils/projection.js';\nimport { createLayoutState, createProjectionState } from './utils/state.js';\nimport { FlatTree } from './utils/flat-tree.js';\nimport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.js';\nimport { setCurrentViewportBox } from './dom/projection/relative-set.js';\nimport { isDraggable } from './utils/is-draggable.js';\nvar visualElement = function (_a) {\n  var _b = _a.treeType,\n    treeType = _b === void 0 ? \"\" : _b,\n    build = _a.build,\n    getBaseTarget = _a.getBaseTarget,\n    makeTargetAnimatable = _a.makeTargetAnimatable,\n    measureViewportBox = _a.measureViewportBox,\n    renderInstance = _a.render,\n    readValueFromInstance = _a.readValueFromInstance,\n    resetTransform = _a.resetTransform,\n    restoreTransform = _a.restoreTransform,\n    removeValueFromRenderState = _a.removeValueFromRenderState,\n    sortNodePosition = _a.sortNodePosition,\n    scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n  return function (_a, options) {\n    var parent = _a.parent,\n      props = _a.props,\n      presenceId = _a.presenceId,\n      blockInitialAnimation = _a.blockInitialAnimation,\n      visualState = _a.visualState;\n    if (options === void 0) {\n      options = {};\n    }\n    var latestValues = visualState.latestValues,\n      renderState = visualState.renderState;\n    /**\n     * The instance of the render-specific node that will be hydrated by the\n     * exposed React ref. So for example, this visual element can host a\n     * HTMLElement, plain object, or Three.js object. The functions provided\n     * in VisualElementConfig allow us to interface with this instance.\n     */\n    var instance;\n    /**\n     * Manages the subscriptions for a visual element's lifecycle, for instance\n     * onRender and onViewportBoxUpdate.\n     */\n    var lifecycles = createLifecycles();\n    /**\n     *\n     */\n    var projection = createProjectionState();\n    /**\n     * A reference to the nearest projecting parent. This is either\n     * undefined if we haven't looked for the nearest projecting parent,\n     * false if there is no parent performing layout projection, or a reference\n     * to the projecting parent.\n     */\n    var projectionParent;\n    /**\n     * This is a reference to the visual state of the \"lead\" visual element.\n     * Usually, this will be this visual element. But if it shares a layoutId\n     * with other visual elements, only one of them will be designated lead by\n     * AnimateSharedLayout. All the other visual elements will take on the visual\n     * appearance of the lead while they crossfade to it.\n     */\n    var leadProjection = projection;\n    var leadLatestValues = latestValues;\n    var unsubscribeFromLeadVisualElement;\n    /**\n     * The latest layout measurements and calculated projections. This\n     * is seperate from the target projection data in visualState as\n     * many visual elements might point to the same piece of visualState as\n     * a target, whereas they might each have different layouts and thus\n     * projection calculations needed to project into the same viewport box.\n     */\n    var layoutState = createLayoutState();\n    /**\n     *\n     */\n    var crossfader;\n    /**\n     * Keep track of whether the viewport box has been updated since the\n     * last time the layout projection was re-calculated.\n     */\n    var hasViewportBoxUpdated = false;\n    /**\n     * A map of all motion values attached to this visual element. Motion\n     * values are source of truth for any given animated value. A motion\n     * value might be provided externally by the component via props.\n     */\n    var values = new Map();\n    /**\n     * A map of every subscription that binds the provided or generated\n     * motion values onChange listeners to this visual element.\n     */\n    var valueSubscriptions = new Map();\n    /**\n     * A reference to the previously-provided motion values as returned\n     * from scrapeMotionValuesFromProps. We use the keys in here to determine\n     * if any motion values need to be removed after props are updated.\n     */\n    var prevMotionValues = {};\n    /**\n     * x/y motion values that track the progress of initiated layout\n     * animations.\n     *\n     * TODO: Target for removal\n     */\n    var projectionTargetProgress;\n    /**\n     * When values are removed from all animation props we need to search\n     * for a fallback value to animate to. These values are tracked in baseTarget.\n     */\n    var baseTarget = __assign({}, latestValues);\n    // Internal methods ========================\n    /**\n     * On mount, this will be hydrated with a callback to disconnect\n     * this visual element from its parent on unmount.\n     */\n    var removeFromVariantTree;\n    /**\n     *\n     */\n    function render() {\n      if (!instance) return;\n      if (element.isProjectionReady()) {\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        applyBoxTransforms(leadProjection.targetFinal, leadProjection.target, leadLatestValues);\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        updateBoxDelta(layoutState.deltaFinal, layoutState.layoutCorrected, leadProjection.targetFinal, latestValues);\n      }\n      triggerBuild();\n      renderInstance(instance, renderState);\n    }\n    function triggerBuild() {\n      var valuesToRender = latestValues;\n      if (crossfader && crossfader.isActive()) {\n        var crossfadedValues = crossfader.getCrossfadeState(element);\n        if (crossfadedValues) valuesToRender = crossfadedValues;\n      }\n      build(element, renderState, valuesToRender, leadProjection, layoutState, options, props);\n    }\n    function update() {\n      lifecycles.notifyUpdate(latestValues);\n    }\n    function updateLayoutProjection() {\n      if (!element.isProjectionReady()) return;\n      var delta = layoutState.delta,\n        treeScale = layoutState.treeScale;\n      var prevTreeScaleX = treeScale.x;\n      var prevTreeScaleY = treeScale.y;\n      var prevDeltaTransform = layoutState.deltaTransform;\n      updateLayoutDeltas(layoutState, leadProjection, element.path, latestValues);\n      hasViewportBoxUpdated && element.notifyViewportBoxUpdate(leadProjection.target, delta);\n      hasViewportBoxUpdated = false;\n      var deltaTransform = buildLayoutProjectionTransform(delta, treeScale);\n      if (deltaTransform !== prevDeltaTransform ||\n      // Also compare calculated treeScale, for values that rely on this only for scale correction\n      prevTreeScaleX !== treeScale.x || prevTreeScaleY !== treeScale.y) {\n        element.scheduleRender();\n      }\n      layoutState.deltaTransform = deltaTransform;\n    }\n    function updateTreeLayoutProjection() {\n      element.layoutTree.forEach(fireUpdateLayoutProjection);\n    }\n    /**\n     *\n     */\n    function bindToMotionValue(key, value) {\n      var removeOnChange = value.onChange(function (latestValue) {\n        latestValues[key] = latestValue;\n        props.onUpdate && sync.update(update, false, true);\n      });\n      var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n      valueSubscriptions.set(key, function () {\n        removeOnChange();\n        removeOnRenderRequest();\n      });\n    }\n    /**\n     * Any motion values that are provided to the element when created\n     * aren't yet bound to the element, as this would technically be impure.\n     * However, we iterate through the motion values and set them to the\n     * initial values for this component.\n     *\n     * TODO: This is impure and we should look at changing this to run on mount.\n     * Doing so will break some tests but this isn't neccessarily a breaking change,\n     * more a reflection of the test.\n     */\n    var initialMotionValues = scrapeMotionValuesFromProps(props);\n    for (var key in initialMotionValues) {\n      var value = initialMotionValues[key];\n      if (latestValues[key] !== undefined && isMotionValue(value)) {\n        value.set(latestValues[key], false);\n      }\n    }\n    /**\n     * Determine what role this visual element should take in the variant tree.\n     */\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    var element = __assign(__assign({\n      treeType: treeType,\n      /**\n       * This is a mirror of the internal instance prop, which keeps\n       * VisualElement type-compatible with React's RefObject.\n       */\n      current: null,\n      /**\n       * The depth of this visual element within the visual element tree.\n       */\n      depth: parent ? parent.depth + 1 : 0,\n      parent: parent,\n      children: new Set(),\n      /**\n       * An ancestor path back to the root visual element. This is used\n       * by layout projection to quickly recurse back up the tree.\n       */\n      path: parent ? __spreadArray(__spreadArray([], __read(parent.path)), [parent]) : [],\n      layoutTree: parent ? parent.layoutTree : new FlatTree(),\n      /**\n       *\n       */\n      presenceId: presenceId,\n      projection: projection,\n      /**\n       * If this component is part of the variant tree, it should track\n       * any children that are also part of the tree. This is essentially\n       * a shadow tree to simplify logic around how to stagger over children.\n       */\n      variantChildren: isVariantNode ? new Set() : undefined,\n      /**\n       * Whether this instance is visible. This can be changed imperatively\n       * by AnimateSharedLayout, is analogous to CSS's visibility in that\n       * hidden elements should take up layout, and needs enacting by the configured\n       * render function.\n       */\n      isVisible: undefined,\n      /**\n       * Normally, if a component is controlled by a parent's variants, it can\n       * rely on that ancestor to trigger animations further down the tree.\n       * However, if a component is created after its parent is mounted, the parent\n       * won't trigger that mount animation so the child needs to.\n       *\n       * TODO: This might be better replaced with a method isParentMounted\n       */\n      manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()),\n      /**\n       * This can be set by AnimatePresence to force components that mount\n       * at the same time as it to mount as if they have initial={false} set.\n       */\n      blockInitialAnimation: blockInitialAnimation,\n      /**\n       * Determine whether this component has mounted yet. This is mostly used\n       * by variant children to determine whether they need to trigger their\n       * own animations on mount.\n       */\n      isMounted: function () {\n        return Boolean(instance);\n      },\n      mount: function (newInstance) {\n        instance = element.current = newInstance;\n        element.pointTo(element);\n        if (isVariantNode && parent && !isControllingVariants) {\n          removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n        }\n        parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n      },\n      /**\n       *\n       */\n      unmount: function () {\n        cancelSync.update(update);\n        cancelSync.render(render);\n        cancelSync.preRender(element.updateLayoutProjection);\n        valueSubscriptions.forEach(function (remove) {\n          return remove();\n        });\n        element.stopLayoutAnimation();\n        element.layoutTree.remove(element);\n        removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n        parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n        unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n        lifecycles.clearAllListeners();\n      },\n      /**\n       * Add a child visual element to our set of children.\n       */\n      addVariantChild: function (child) {\n        var _a;\n        var closestVariantNode = element.getClosestVariantNode();\n        if (closestVariantNode) {\n          (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n          return function () {\n            return closestVariantNode.variantChildren.delete(child);\n          };\n        }\n      },\n      sortNodePosition: function (other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!sortNodePosition || treeType !== other.treeType) return 0;\n        return sortNodePosition(element.getInstance(), other.getInstance());\n      },\n      /**\n       * Returns the closest variant node in the tree starting from\n       * this visual element.\n       */\n      getClosestVariantNode: function () {\n        return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n      },\n      /**\n       * A method that schedules an update to layout projections throughout\n       * the tree. We inherit from the parent so there's only ever one\n       * job scheduled on the next frame - that of the root visual element.\n       */\n      scheduleUpdateLayoutProjection: parent ? parent.scheduleUpdateLayoutProjection : function () {\n        return sync.preRender(element.updateTreeLayoutProjection, false, true);\n      },\n      /**\n       * Expose the latest layoutId prop.\n       */\n      getLayoutId: function () {\n        return props.layoutId;\n      },\n      /**\n       * Returns the current instance.\n       */\n      getInstance: function () {\n        return instance;\n      },\n      /**\n       * Get/set the latest static values.\n       */\n      getStaticValue: function (key) {\n        return latestValues[key];\n      },\n      setStaticValue: function (key, value) {\n        return latestValues[key] = value;\n      },\n      /**\n       * Returns the latest motion value state. Currently only used to take\n       * a snapshot of the visual element - perhaps this can return the whole\n       * visual state\n       */\n      getLatestValues: function () {\n        return latestValues;\n      },\n      /**\n       * Set the visiblity of the visual element. If it's changed, schedule\n       * a render to reflect these changes.\n       */\n      setVisibility: function (visibility) {\n        if (element.isVisible === visibility) return;\n        element.isVisible = visibility;\n        element.scheduleRender();\n      },\n      /**\n       * Make a target animatable by Popmotion. For instance, if we're\n       * trying to animate width from 100px to 100vw we need to measure 100vw\n       * in pixels to determine what we really need to animate to. This is also\n       * pluggable to support Framer's custom value types like Color,\n       * and CSS variables.\n       */\n      makeTargetAnimatable: function (target, canMutate) {\n        if (canMutate === void 0) {\n          canMutate = true;\n        }\n        return makeTargetAnimatable(element, target, props, canMutate);\n      },\n      // Motion values ========================\n      /**\n       * Add a motion value and bind it to this visual element.\n       */\n      addValue: function (key, value) {\n        // Remove existing value if it exists\n        if (element.hasValue(key)) element.removeValue(key);\n        values.set(key, value);\n        latestValues[key] = value.get();\n        bindToMotionValue(key, value);\n      },\n      /**\n       * Remove a motion value and unbind any active subscriptions.\n       */\n      removeValue: function (key) {\n        var _a;\n        values.delete(key);\n        (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n        valueSubscriptions.delete(key);\n        delete latestValues[key];\n        removeValueFromRenderState(key, renderState);\n      },\n      /**\n       * Check whether we have a motion value for this key\n       */\n      hasValue: function (key) {\n        return values.has(key);\n      },\n      /**\n       * Get a motion value for this key. If called with a default\n       * value, we'll create one if none exists.\n       */\n      getValue: function (key, defaultValue) {\n        var value = values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n          value = motionValue(defaultValue);\n          element.addValue(key, value);\n        }\n        return value;\n      },\n      /**\n       * Iterate over our motion values.\n       */\n      forEachValue: function (callback) {\n        return values.forEach(callback);\n      },\n      /**\n       * If we're trying to animate to a previously unencountered value,\n       * we need to check for it in our state and as a last resort read it\n       * directly from the instance (which might have performance implications).\n       */\n      readValue: function (key) {\n        var _a;\n        return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\n      },\n      /**\n       * Set the base target to later animate back to. This is currently\n       * only hydrated on creation and when we first read a value.\n       */\n      setBaseTarget: function (key, value) {\n        baseTarget[key] = value;\n      },\n      /**\n       * Find the base target for a value thats been removed from all animation\n       * props.\n       */\n      getBaseTarget: function (key) {\n        if (getBaseTarget) {\n          var target = getBaseTarget(props, key);\n          if (target !== undefined && !isMotionValue(target)) return target;\n        }\n        return baseTarget[key];\n      }\n    }, lifecycles), {\n      /**\n       * Build the renderer state based on the latest visual state.\n       */\n      build: function () {\n        triggerBuild();\n        return renderState;\n      },\n      /**\n       * Schedule a render on the next animation frame.\n       */\n      scheduleRender: function () {\n        sync.render(render, false, true);\n      },\n      /**\n       * Synchronously fire render. It's prefered that we batch renders but\n       * in many circumstances, like layout measurement, we need to run this\n       * synchronously. However in those instances other measures should be taken\n       * to batch reads/writes.\n       */\n      syncRender: render,\n      /**\n       * Update the provided props. Ensure any newly-added motion values are\n       * added to our map, old ones removed, and listeners updated.\n       */\n      setProps: function (newProps) {\n        props = newProps;\n        lifecycles.updatePropListeners(newProps);\n        prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n      },\n      getProps: function () {\n        return props;\n      },\n      // Variants ==============================\n      /**\n       * Returns the variant definition with a given name.\n       */\n      getVariant: function (name) {\n        var _a;\n        return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name];\n      },\n      /**\n       * Returns the defined default transition on this component.\n       */\n      getDefaultTransition: function () {\n        return props.transition;\n      },\n      /**\n       * Used by child variant nodes to get the closest ancestor variant props.\n       */\n      getVariantContext: function (startAtParent) {\n        if (startAtParent === void 0) {\n          startAtParent = false;\n        }\n        if (startAtParent) return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n        if (!isControllingVariants) {\n          var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n          if (props.initial !== undefined) {\n            context_1.initial = props.initial;\n          }\n          return context_1;\n        }\n        var context = {};\n        for (var i = 0; i < numVariantProps; i++) {\n          var name_1 = variantProps[i];\n          var prop = props[name_1];\n          if (isVariantLabel(prop) || prop === false) {\n            context[name_1] = prop;\n          }\n        }\n        return context;\n      },\n      // Layout projection ==============================\n      /**\n       * Enable layout projection for this visual element. Won't actually\n       * occur until we also have hydrated layout measurements.\n       */\n      enableLayoutProjection: function () {\n        projection.isEnabled = true;\n        element.layoutTree.add(element);\n      },\n      /**\n       * Lock the projection target, for instance when dragging, so\n       * nothing else can try and animate it.\n       */\n      lockProjectionTarget: function () {\n        projection.isTargetLocked = true;\n      },\n      unlockProjectionTarget: function () {\n        element.stopLayoutAnimation();\n        projection.isTargetLocked = false;\n      },\n      getLayoutState: function () {\n        return layoutState;\n      },\n      setCrossfader: function (newCrossfader) {\n        crossfader = newCrossfader;\n      },\n      isProjectionReady: function () {\n        return projection.isEnabled && projection.isHydrated && layoutState.isHydrated;\n      },\n      /**\n       * Start a layout animation on a given axis.\n       */\n      startLayoutAnimation: function (axis, transition, isRelative) {\n        if (isRelative === void 0) {\n          isRelative = false;\n        }\n        var progress = element.getProjectionAnimationProgress()[axis];\n        var _a = isRelative ? projection.relativeTarget[axis] : projection.target[axis],\n          min = _a.min,\n          max = _a.max;\n        var length = max - min;\n        progress.clearListeners();\n        progress.set(min);\n        progress.set(min); // Set twice to hard-reset velocity\n        progress.onChange(function (v) {\n          element.setProjectionTargetAxis(axis, v, v + length, isRelative);\n        });\n        return element.animateMotionValue(axis, progress, 0, transition);\n      },\n      /**\n       * Stop layout animations.\n       */\n      stopLayoutAnimation: function () {\n        eachAxis(function (axis) {\n          return element.getProjectionAnimationProgress()[axis].stop();\n        });\n      },\n      /**\n       * Measure the current viewport box with or without transforms.\n       * Only measures axis-aligned boxes, rotate and skew must be manually\n       * removed with a re-render to work.\n       */\n      measureViewportBox: function (withTransform) {\n        if (withTransform === void 0) {\n          withTransform = true;\n        }\n        var viewportBox = measureViewportBox(instance, options);\n        if (!withTransform) removeBoxTransforms(viewportBox, latestValues);\n        return viewportBox;\n      },\n      /**\n       * Get the motion values tracking the layout animations on each\n       * axis. Lazy init if not already created.\n       */\n      getProjectionAnimationProgress: function () {\n        projectionTargetProgress || (projectionTargetProgress = {\n          x: motionValue(0),\n          y: motionValue(0)\n        });\n        return projectionTargetProgress;\n      },\n      /**\n       * Update the projection of a single axis. Schedule an update to\n       * the tree layout projection.\n       */\n      setProjectionTargetAxis: function (axis, min, max, isRelative) {\n        if (isRelative === void 0) {\n          isRelative = false;\n        }\n        var target;\n        if (isRelative) {\n          if (!projection.relativeTarget) {\n            projection.relativeTarget = axisBox();\n          }\n          target = projection.relativeTarget[axis];\n        } else {\n          projection.relativeTarget = undefined;\n          target = projection.target[axis];\n        }\n        projection.isHydrated = true;\n        target.min = min;\n        target.max = max;\n        // Flag that we want to fire the onViewportBoxUpdate event handler\n        hasViewportBoxUpdated = true;\n        lifecycles.notifySetAxisTarget();\n      },\n      /**\n       * Rebase the projection target on top of the provided viewport box\n       * or the measured layout. This ensures that non-animating elements\n       * don't fall out of sync differences in measurements vs projections\n       * after a page scroll or other relayout.\n       */\n      rebaseProjectionTarget: function (force, box) {\n        if (box === void 0) {\n          box = layoutState.layout;\n        }\n        var _a = element.getProjectionAnimationProgress(),\n          x = _a.x,\n          y = _a.y;\n        var shouldRebase = !projection.relativeTarget && !projection.isTargetLocked && !x.isAnimating() && !y.isAnimating();\n        if (force || shouldRebase) {\n          eachAxis(function (axis) {\n            var _a = box[axis],\n              min = _a.min,\n              max = _a.max;\n            element.setProjectionTargetAxis(axis, min, max);\n          });\n        }\n      },\n      /**\n       * Notify the visual element that its layout is up-to-date.\n       * Currently Animate.tsx uses this to check whether a layout animation\n       * needs to be performed.\n       */\n      notifyLayoutReady: function (config) {\n        setCurrentViewportBox(element);\n        element.notifyLayoutUpdate(layoutState.layout, element.prevViewportBox || layoutState.layout, config);\n      },\n      /**\n       * Temporarily reset the transform of the instance.\n       */\n      resetTransform: function () {\n        return resetTransform(element, instance, props);\n      },\n      restoreTransform: function () {\n        return restoreTransform(instance, renderState);\n      },\n      updateLayoutProjection: updateLayoutProjection,\n      updateTreeLayoutProjection: function () {\n        element.layoutTree.forEach(fireResolveRelativeTargetBox);\n        /**\n         * Schedule the projection updates at the end of the current preRender\n         * step. This will ensure that all layout trees will first resolve\n         * relative projection boxes into viewport boxes, and *then*\n         * update projections.\n         */\n        sync.preRender(updateTreeLayoutProjection, false, true);\n        // sync.postRender(() => element.scheduleUpdateLayoutProjection())\n      },\n      getProjectionParent: function () {\n        if (projectionParent === undefined) {\n          var foundParent = false;\n          // Search backwards through the tree path\n          for (var i = element.path.length - 1; i >= 0; i--) {\n            var ancestor = element.path[i];\n            if (ancestor.projection.isEnabled) {\n              foundParent = ancestor;\n              break;\n            }\n          }\n          projectionParent = foundParent;\n        }\n        return projectionParent;\n      },\n      resolveRelativeTargetBox: function () {\n        var relativeParent = element.getProjectionParent();\n        if (!projection.relativeTarget || !relativeParent) return;\n        calcRelativeBox(projection, relativeParent.projection);\n        if (isDraggable(relativeParent)) {\n          var target = projection.target;\n          applyBoxTransforms(target, target, relativeParent.getLatestValues());\n        }\n      },\n      shouldResetTransform: function () {\n        return Boolean(props._layoutResetTransform);\n      },\n      /**\n       *\n       */\n      pointTo: function (newLead) {\n        leadProjection = newLead.projection;\n        leadLatestValues = newLead.getLatestValues();\n        /**\n         * Subscribe to lead component's layout animations\n         */\n        unsubscribeFromLeadVisualElement === null || unsubscribeFromLeadVisualElement === void 0 ? void 0 : unsubscribeFromLeadVisualElement();\n        unsubscribeFromLeadVisualElement = pipe(newLead.onSetAxisTarget(element.scheduleUpdateLayoutProjection), newLead.onLayoutAnimationComplete(function () {\n          var _a;\n          if (element.isPresent) {\n            element.presence = Presence.Present;\n          } else {\n            (_a = element.layoutSafeToRemove) === null || _a === void 0 ? void 0 : _a.call(element);\n          }\n        }));\n      },\n      // TODO: Clean this up\n      isPresent: true,\n      presence: Presence.Entering\n    });\n    return element;\n  };\n};\nfunction fireResolveRelativeTargetBox(child) {\n  child.resolveRelativeTargetBox();\n}\nfunction fireUpdateLayoutProjection(child) {\n  child.updateLayoutProjection();\n}\nvar variantProps = __spreadArray([\"initial\"], __read(variantPriorityOrder));\nvar numVariantProps = variantProps.length;\nexport { visualElement };","import { motionValue } from '../../value/index.js';\nimport { isMotionValue } from '../../value/utils/is-motion-value.js';\nfunction updateMotionValuesFromProps(element, next, prev) {\n  var _a;\n  for (var key in next) {\n    var nextValue = next[key];\n    var prevValue = prev[key];\n    if (isMotionValue(nextValue)) {\n      /**\n       * If this is a motion value found in props or style, we want to add it\n       * to our visual element's motion value map.\n       */\n      element.addValue(key, nextValue);\n    } else if (isMotionValue(prevValue)) {\n      /**\n       * If we're swapping to a new motion value, create a new motion value\n       * from that\n       */\n      element.addValue(key, motionValue(nextValue));\n    } else if (prevValue !== nextValue) {\n      /**\n       * If this is a flat value that has changed, update the motion value\n       * or create one if it doesn't exist. We only want to do this if we're\n       * not handling the value with our animation state.\n       */\n      if (element.hasValue(key)) {\n        var existingValue = element.getValue(key);\n        // TODO: Only update values that aren't being animated or even looked at\n        !existingValue.hasAnimated && existingValue.set(nextValue);\n      } else {\n        element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n      }\n    }\n  }\n  // Handle removed values\n  for (var key in prev) {\n    if (next[key] === undefined) element.removeValue(key);\n  }\n  return next;\n}\nexport { updateMotionValuesFromProps };","import { calcRelativeOffset } from '../../../motion/features/layout/utils.js';\nimport { eachAxis } from '../../../utils/each-axis.js';\nfunction setCurrentViewportBox(visualElement) {\n  var projectionParent = visualElement.getProjectionParent();\n  if (!projectionParent) {\n    visualElement.rebaseProjectionTarget();\n    return;\n  }\n  var relativeOffset = calcRelativeOffset(projectionParent.getLayoutState().layout, visualElement.getLayoutState().layout);\n  eachAxis(function (axis) {\n    visualElement.setProjectionTargetAxis(axis, relativeOffset[axis].min, relativeOffset[axis].max, true);\n  });\n}\nexport { setCurrentViewportBox };","import { resetBox, applyTreeDeltas } from '../../utils/geometry/delta-apply.js';\nimport { updateBoxDelta } from '../../utils/geometry/delta-calc.js';\nfunction updateLayoutDeltas(_a, _b, treePath, transformOrigin) {\n  var delta = _a.delta,\n    layout = _a.layout,\n    layoutCorrected = _a.layoutCorrected,\n    treeScale = _a.treeScale;\n  var target = _b.target;\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  resetBox(layoutCorrected, layout);\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(layoutCorrected, treeScale, treePath);\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  updateBoxDelta(delta, layoutCorrected, target, transformOrigin);\n}\nexport { updateLayoutDeltas };","import { __assign, __read } from 'tslib';\nimport { number, px } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.js';\nimport { invariant } from 'hey-listen';\nimport { transformProps } from '../../html/utils/transform.js';\nimport { findDimensionValueType } from '../value-types/dimensions.js';\nvar positionalKeys = new Set([\"width\", \"height\", \"top\", \"left\", \"right\", \"bottom\", \"x\", \"y\"]);\nvar isPositionalKey = function (key) {\n  return positionalKeys.has(key);\n};\nvar hasPositionalKey = function (target) {\n  return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n  // Looks odd but setting it twice doesn't render, it'll just\n  // set both prev and current to the latest value\n  value.set(to, false);\n  value.set(to);\n};\nvar isNumOrPxType = function (v) {\n  return v === number || v === px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n  BoundingBoxDimension[\"width\"] = \"width\";\n  BoundingBoxDimension[\"height\"] = \"height\";\n  BoundingBoxDimension[\"left\"] = \"left\";\n  BoundingBoxDimension[\"right\"] = \"right\";\n  BoundingBoxDimension[\"top\"] = \"top\";\n  BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n  return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) {\n  return function (_bbox, _a) {\n    var transform = _a.transform;\n    if (transform === \"none\" || !transform) return 0;\n    var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n    if (matrix3d) {\n      return getPosFromMatrix(matrix3d[1], pos3);\n    } else {\n      var matrix = transform.match(/^matrix\\((.+)\\)$/);\n      if (matrix) {\n        return getPosFromMatrix(matrix[1], pos2);\n      } else {\n        return 0;\n      }\n    }\n  };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) {\n  return !transformKeys.has(key);\n});\nfunction removeNonTranslationalTransform(visualElement) {\n  var removedTransforms = [];\n  nonTranslationalTransformKeys.forEach(function (key) {\n    var value = visualElement.getValue(key);\n    if (value !== undefined) {\n      removedTransforms.push([key, value.get()]);\n      value.set(key.startsWith(\"scale\") ? 1 : 0);\n    }\n  });\n  // Apply changes to element before measurement\n  if (removedTransforms.length) visualElement.syncRender();\n  return removedTransforms;\n}\nvar positionalValues = {\n  // Dimensions\n  width: function (_a) {\n    var x = _a.x;\n    return x.max - x.min;\n  },\n  height: function (_a) {\n    var y = _a.y;\n    return y.max - y.min;\n  },\n  top: function (_bbox, _a) {\n    var top = _a.top;\n    return parseFloat(top);\n  },\n  left: function (_bbox, _a) {\n    var left = _a.left;\n    return parseFloat(left);\n  },\n  bottom: function (_a, _b) {\n    var y = _a.y;\n    var top = _b.top;\n    return parseFloat(top) + (y.max - y.min);\n  },\n  right: function (_a, _b) {\n    var x = _a.x;\n    var left = _b.left;\n    return parseFloat(left) + (x.max - x.min);\n  },\n  // Transform\n  x: getTranslateFromMatrix(4, 13),\n  y: getTranslateFromMatrix(5, 14)\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n  var originBbox = visualElement.measureViewportBox();\n  var element = visualElement.getInstance();\n  var elementComputedStyle = getComputedStyle(element);\n  var display = elementComputedStyle.display,\n    top = elementComputedStyle.top,\n    left = elementComputedStyle.left,\n    bottom = elementComputedStyle.bottom,\n    right = elementComputedStyle.right,\n    transform = elementComputedStyle.transform;\n  var originComputedStyle = {\n    top: top,\n    left: left,\n    bottom: bottom,\n    right: right,\n    transform: transform\n  };\n  // If the element is currently set to display: \"none\", make it visible before\n  // measuring the target bounding box\n  if (display === \"none\") {\n    visualElement.setStaticValue(\"display\", target.display || \"block\");\n  }\n  // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n  visualElement.syncRender();\n  var targetBbox = visualElement.measureViewportBox();\n  changedKeys.forEach(function (key) {\n    // Restore styles to their **calculated computed style**, not their actual\n    // originally set style. This allows us to animate between equivalent pixel units.\n    var value = visualElement.getValue(key);\n    setAndResetVelocity(value, positionalValues[key](originBbox, originComputedStyle));\n    target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n  });\n  return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n  if (origin === void 0) {\n    origin = {};\n  }\n  if (transitionEnd === void 0) {\n    transitionEnd = {};\n  }\n  target = __assign({}, target);\n  transitionEnd = __assign({}, transitionEnd);\n  var targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n  // We want to remove any transform values that could affect the element's bounding box before\n  // it's measured. We'll reapply these later.\n  var removedTransformValues = [];\n  var hasAttemptedToRemoveTransformValues = false;\n  var changedValueTypeKeys = [];\n  targetPositionalKeys.forEach(function (key) {\n    var value = visualElement.getValue(key);\n    if (!visualElement.hasValue(key)) return;\n    var from = origin[key];\n    var to = target[key];\n    var fromType = findDimensionValueType(from);\n    var toType;\n    // TODO: The current implementation of this basically throws an error\n    // if you try and do value conversion via keyframes. There's probably\n    // a way of doing this but the performance implications would need greater scrutiny,\n    // as it'd be doing multiple resize-remeasure operations.\n    if (isKeyframesTarget(to)) {\n      var numKeyframes = to.length;\n      for (var i = to[0] === null ? 1 : 0; i < numKeyframes; i++) {\n        if (!toType) {\n          toType = findDimensionValueType(to[i]);\n          invariant(toType === fromType || isNumOrPxType(fromType) && isNumOrPxType(toType), \"Keyframes must be of the same dimension as the current value\");\n        } else {\n          invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n        }\n      }\n    } else {\n      toType = findDimensionValueType(to);\n    }\n    if (fromType !== toType) {\n      // If they're both just number or px, convert them both to numbers rather than\n      // relying on resize/remeasure to convert (which is wasteful in this situation)\n      if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n        var current = value.get();\n        if (typeof current === \"string\") {\n          value.set(parseFloat(current));\n        }\n        if (typeof to === \"string\") {\n          target[key] = parseFloat(to);\n        } else if (Array.isArray(to) && toType === px) {\n          target[key] = to.map(parseFloat);\n        }\n      } else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) && (toType === null || toType === void 0 ? void 0 : toType.transform) && (from === 0 || to === 0)) {\n        // If one or the other value is 0, it's safe to coerce it to the\n        // type of the other without measurement\n        if (from === 0) {\n          value.set(toType.transform(from));\n        } else {\n          target[key] = fromType.transform(to);\n        }\n      } else {\n        // If we're going to do value conversion via DOM measurements, we first\n        // need to remove non-positional transform values that could affect the bbox measurements.\n        if (!hasAttemptedToRemoveTransformValues) {\n          removedTransformValues = removeNonTranslationalTransform(visualElement);\n          hasAttemptedToRemoveTransformValues = true;\n        }\n        changedValueTypeKeys.push(key);\n        transitionEnd[key] = transitionEnd[key] !== undefined ? transitionEnd[key] : target[key];\n        setAndResetVelocity(value, to);\n      }\n    }\n  });\n  if (changedValueTypeKeys.length) {\n    var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n    // If we removed transform values, reapply them before the next render\n    if (removedTransformValues.length) {\n      removedTransformValues.forEach(function (_a) {\n        var _b = __read(_a, 2),\n          key = _b[0],\n          value = _b[1];\n        visualElement.getValue(key).set(value);\n      });\n    }\n    // Reapply original values\n    visualElement.syncRender();\n    return {\n      target: convertedTarget,\n      transitionEnd: transitionEnd\n    };\n  } else {\n    return {\n      target: target,\n      transitionEnd: transitionEnd\n    };\n  }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n  return hasPositionalKey(target) ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd) : {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\nexport { BoundingBoxDimension, unitConversion };","import { resolveCSSVariables } from './css-variables-conversion.js';\nimport { unitConversion } from './unit-conversion.js';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n  var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n  target = resolved.target;\n  transitionEnd = resolved.transitionEnd;\n  return unitConversion(visualElement, target, origin, transitionEnd);\n};\nexport { parseDomVariant };","import { __rest, __assign } from 'tslib';\nimport { visualElement } from '../index.js';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.js';\nimport { getBoundingBox } from '../dom/projection/measure.js';\nimport { buildHTMLStyles } from './utils/build-styles.js';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.js';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.js';\nimport { isTransformProp } from './utils/transform.js';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';\nimport { renderHTML } from './utils/render.js';\nimport { getDefaultValueType } from '../dom/value-types/defaults.js';\nimport { buildLayoutProjectionTransformOrigin, buildLayoutProjectionTransform } from './utils/build-projection-transform.js';\nfunction getComputedStyle(element) {\n  return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n  treeType: \"dom\",\n  readValueFromInstance: function (domElement, key) {\n    if (isTransformProp(key)) {\n      var defaultType = getDefaultValueType(key);\n      return defaultType ? defaultType.default || 0 : 0;\n    } else {\n      var computedStyle = getComputedStyle(domElement);\n      return (isCSSVariable(key) ? computedStyle.getPropertyValue(key) : computedStyle[key]) || 0;\n    }\n  },\n  sortNodePosition: function (a, b) {\n    /**\n     * compareDocumentPosition returns a bitmask, by using the bitwise &\n     * we're returning true if 2 in that bitmask is set to true. 2 is set\n     * to true if b preceeds a.\n     */\n    return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n  },\n  getBaseTarget: function (props, key) {\n    var _a;\n    return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n  },\n  measureViewportBox: function (element, _a) {\n    var transformPagePoint = _a.transformPagePoint;\n    return getBoundingBox(element, transformPagePoint);\n  },\n  /**\n   * Reset the transform on the current Element. This is called as part\n   * of a batched process across the entire layout tree. To remove this write\n   * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n   * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n   * works\n   */\n  resetTransform: function (element, domElement, props) {\n    var transformTemplate = props.transformTemplate;\n    domElement.style.transform = transformTemplate ? transformTemplate({}, \"\") : \"none\";\n    // Ensure that whatever happens next, we restore our transform on the next frame\n    element.scheduleRender();\n  },\n  restoreTransform: function (instance, mutableState) {\n    instance.style.transform = mutableState.style.transform;\n  },\n  removeValueFromRenderState: function (key, _a) {\n    var vars = _a.vars,\n      style = _a.style;\n    delete vars[key];\n    delete style[key];\n  },\n  /**\n   * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n   * can be animated by Motion.\n   */\n  makeTargetAnimatable: function (element, _a, _b, isMounted) {\n    var transformValues = _b.transformValues;\n    if (isMounted === void 0) {\n      isMounted = true;\n    }\n    var transition = _a.transition,\n      transitionEnd = _a.transitionEnd,\n      target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n    var origin = getOrigin(target, transition || {}, element);\n    /**\n     * If Framer has provided a function to convert `Color` etc value types, convert them\n     */\n    if (transformValues) {\n      if (transitionEnd) transitionEnd = transformValues(transitionEnd);\n      if (target) target = transformValues(target);\n      if (origin) origin = transformValues(origin);\n    }\n    if (isMounted) {\n      checkTargetForNewValues(element, target, origin);\n      var parsed = parseDomVariant(element, target, origin, transitionEnd);\n      transitionEnd = parsed.transitionEnd;\n      target = parsed.target;\n    }\n    return __assign({\n      transition: transition,\n      transitionEnd: transitionEnd\n    }, target);\n  },\n  scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n  build: function (element, renderState, latestValues, projection, layoutState, options, props) {\n    if (element.isVisible !== undefined) {\n      renderState.style.visibility = element.isVisible ? \"visible\" : \"hidden\";\n    }\n    var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n    buildHTMLStyles(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform ? buildLayoutProjectionTransformOrigin : undefined);\n  },\n  render: renderHTML\n};\nvar htmlVisualElement = visualElement(htmlConfig);\nexport { getComputedStyle, htmlConfig, htmlVisualElement };","import { __assign } from 'tslib';\nimport { visualElement } from '../index.js';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';\nimport { htmlConfig } from '../html/visual-element.js';\nimport { buildSVGAttrs } from './utils/build-attrs.js';\nimport { camelToDash } from '../dom/utils/camel-to-dash.js';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.js';\nimport { isTransformProp } from '../html/utils/transform.js';\nimport { renderSVG } from './utils/render.js';\nimport { getDefaultValueType } from '../dom/value-types/defaults.js';\nimport { buildLayoutProjectionTransformOrigin, buildLayoutProjectionTransform } from '../html/utils/build-projection-transform.js';\nvar svgVisualElement = visualElement(__assign(__assign({}, htmlConfig), {\n  getBaseTarget: function (props, key) {\n    return props[key];\n  },\n  readValueFromInstance: function (domElement, key) {\n    var _a;\n    if (isTransformProp(key)) {\n      return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n    }\n    key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n    return domElement.getAttribute(key);\n  },\n  scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n  build: function (_element, renderState, latestValues, projection, layoutState, options, props) {\n    var isProjectionTranform = projection.isEnabled && layoutState.isHydrated;\n    buildSVGAttrs(renderState, latestValues, projection, layoutState, options, props.transformTemplate, isProjectionTranform ? buildLayoutProjectionTransform : undefined, isProjectionTranform ? buildLayoutProjectionTransformOrigin : undefined);\n  },\n  render: renderSVG\n}));\nexport { svgVisualElement };","import { htmlVisualElement } from '../html/visual-element.js';\nimport { svgVisualElement } from '../svg/visual-element.js';\nimport { isSVGComponent } from './utils/is-svg-component.js';\nvar createDomVisualElement = function (Component, options) {\n  return isSVGComponent(Component) ? svgVisualElement(options, {\n    enableHardwareAcceleration: false\n  }) : htmlVisualElement(options, {\n    enableHardwareAcceleration: true\n  });\n};\nexport { createDomVisualElement };","import { __assign } from 'tslib';\nimport { createMotionComponent } from '../../motion/index.js';\nimport { createMotionProxy } from './motion-proxy.js';\nimport { createDomMotionConfig } from './utils/create-config.js';\nimport { gestureAnimations } from '../../motion/features/gestures.js';\nimport { animations } from '../../motion/features/animations.js';\nimport { drag } from '../../motion/features/drag.js';\nimport { layoutAnimations } from '../../motion/features/layout/index.js';\nimport { createDomVisualElement } from './create-visual-element.js';\nvar featureBundle = __assign(__assign(__assign(__assign({}, animations), gestureAnimations), drag), layoutAnimations);\n/**\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\n *\n * @public\n */\nvar motion = /*@__PURE__*/createMotionProxy(function (Component, config) {\n  return createDomMotionConfig(Component, config, featureBundle, createDomVisualElement);\n});\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n  return createMotionComponent(createDomMotionConfig(key, {\n    forwardMotionProps: false\n  }, featureBundle, createDomVisualElement));\n}\nexport { createDomMotionComponent, motion };","import { convertBoundingBoxToAxisBox, transformBoundingBox } from '../../../utils/geometry/index.js';\n\n/**\n * Measure and return the element bounding box.\n *\n * We convert the box into an AxisBox2D to make it easier to work with each axis\n * individually and programmatically.\n *\n * This function optionally accepts a transformPagePoint function which allows us to compensate\n * for, for instance, measuring the element within a scaled plane like a Framer devivce preview component.\n */\nfunction getBoundingBox(element, transformPagePoint) {\n  var box = element.getBoundingClientRect();\n  return convertBoundingBoxToAxisBox(transformBoundingBox(box, transformPagePoint));\n}\nexport { getBoundingBox };","import sync from 'framesync';\nimport { copyAxisBox } from '../../../utils/geometry/index.js';\nimport { compareByDepth } from '../../utils/compare-by-depth.js';\nfunction isProjecting(visualElement) {\n  var isEnabled = visualElement.projection.isEnabled;\n  return isEnabled || visualElement.shouldResetTransform();\n}\nfunction collectProjectingAncestors(visualElement, ancestors) {\n  if (ancestors === void 0) {\n    ancestors = [];\n  }\n  var parent = visualElement.parent;\n  if (parent) collectProjectingAncestors(parent, ancestors);\n  if (isProjecting(visualElement)) ancestors.push(visualElement);\n  return ancestors;\n}\nfunction collectProjectingChildren(visualElement) {\n  var children = [];\n  var addChild = function (child) {\n    if (isProjecting(child)) children.push(child);\n    child.children.forEach(addChild);\n  };\n  visualElement.children.forEach(addChild);\n  return children.sort(compareByDepth);\n}\n/**\n * Update the layoutState by measuring the DOM layout. This\n * should be called after resetting any layout-affecting transforms.\n */\nfunction updateLayoutMeasurement(visualElement) {\n  if (visualElement.shouldResetTransform()) return;\n  var layoutState = visualElement.getLayoutState();\n  visualElement.notifyBeforeLayoutMeasure(layoutState.layout);\n  layoutState.isHydrated = true;\n  layoutState.layout = visualElement.measureViewportBox();\n  layoutState.layoutCorrected = copyAxisBox(layoutState.layout);\n  visualElement.notifyLayoutMeasure(layoutState.layout, visualElement.prevViewportBox || layoutState.layout);\n  sync.update(function () {\n    return visualElement.rebaseProjectionTarget();\n  });\n}\n/**\n * Record the viewport box as it was before an expected mutation/re-render\n */\nfunction snapshotViewportBox(visualElement) {\n  if (visualElement.shouldResetTransform()) return;\n  visualElement.prevViewportBox = visualElement.measureViewportBox(false);\n  /**\n   * Update targetBox to match the prevViewportBox. This is just to ensure\n   * that targetBox is affected by scroll in the same way as the measured box\n   */\n  visualElement.rebaseProjectionTarget(false, visualElement.prevViewportBox);\n}\nexport { collectProjectingAncestors, collectProjectingChildren, snapshotViewportBox, updateLayoutMeasurement };","var unresolvedJobs = new Set();\nfunction pushJob(stack, job, pointer) {\n  if (!stack[pointer]) stack[pointer] = [];\n  stack[pointer].push(job);\n}\nfunction batchLayout(callback) {\n  unresolvedJobs.add(callback);\n  return function () {\n    return unresolvedJobs.delete(callback);\n  };\n}\nfunction flushLayout() {\n  if (!unresolvedJobs.size) return;\n  var pointer = 0;\n  var reads = [[]];\n  var writes = [];\n  var setRead = function (job) {\n    return pushJob(reads, job, pointer);\n  };\n  var setWrite = function (job) {\n    pushJob(writes, job, pointer);\n    pointer++;\n  };\n  /**\n   * Resolve jobs into their array stacks\n   */\n  unresolvedJobs.forEach(function (callback) {\n    callback(setRead, setWrite);\n    pointer = 0;\n  });\n  unresolvedJobs.clear();\n  /**\n   * Execute jobs\n   */\n  var numStacks = writes.length;\n  for (var i = 0; i <= numStacks; i++) {\n    reads[i] && reads[i].forEach(executeJob);\n    writes[i] && writes[i].forEach(executeJob);\n  }\n}\nvar executeJob = function (job) {\n  return job();\n};\nexport { batchLayout, flushLayout };","import { __rest, __assign, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nfunction isCSSVariable(value) {\n  return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n  var match = cssVariableRegex.exec(current);\n  if (!match) return [,];\n  var _a = __read(match, 3),\n    token = _a[1],\n    fallback = _a[2];\n  return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n  if (depth === void 0) {\n    depth = 1;\n  }\n  invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\" + current + \"\\\". This may indicate a circular fallback dependency.\");\n  var _a = __read(parseCSSVariable(current), 2),\n    token = _a[0],\n    fallback = _a[1];\n  // No CSS variable detected\n  if (!token) return;\n  // Attempt to read this CSS variable off the element\n  var resolved = window.getComputedStyle(element).getPropertyValue(token);\n  if (resolved) {\n    return resolved.trim();\n  } else if (isCSSVariable(fallback)) {\n    // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n    return getVariableValue(fallback, element, depth + 1);\n  } else {\n    return fallback;\n  }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n  var _b;\n  var target = __rest(_a, []);\n  var element = visualElement.getInstance();\n  if (!(element instanceof HTMLElement)) return {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n  // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n  // only if they change but I think this reads clearer and this isn't a performance-critical path.\n  if (transitionEnd) {\n    transitionEnd = __assign({}, transitionEnd);\n  }\n  // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n  visualElement.forEachValue(function (value) {\n    var current = value.get();\n    if (!isCSSVariable(current)) return;\n    var resolved = getVariableValue(current, element);\n    if (resolved) value.set(resolved);\n  });\n  // Cycle through every target property and resolve CSS variables. Currently\n  // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n  for (var key in target) {\n    var current = target[key];\n    if (!isCSSVariable(current)) continue;\n    var resolved = getVariableValue(current, element);\n    if (!resolved) continue;\n    // Clone target if it hasn't already been\n    target[key] = resolved;\n    // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n    // CSS variable. This will ensure that after the animation the component will reflect\n    // changes in the value of the CSS variable.\n    if (transitionEnd) (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : transitionEnd[key] = current;\n  }\n  return {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };","import { filter, complex } from 'style-value-types';\nimport { getDefaultValueType } from './defaults.js';\nfunction getAnimatableNone(key, value) {\n  var _a;\n  var defaultValueType = getDefaultValueType(key);\n  if (defaultValueType !== filter) defaultValueType = complex;\n  // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n  return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\nexport { getAnimatableNone };","import { __assign } from 'tslib';\nimport { color, filter } from 'style-value-types';\nimport { numberValueTypes } from './number.js';\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = __assign(__assign({}, numberValueTypes), {\n  // Color props\n  color: color,\n  backgroundColor: color,\n  outlineColor: color,\n  fill: color,\n  stroke: color,\n  // Border props\n  borderColor: color,\n  borderTopColor: color,\n  borderRightColor: color,\n  borderBottomColor: color,\n  borderLeftColor: color,\n  filter: filter,\n  WebkitFilter: filter\n});\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) {\n  return defaultValueTypes[key];\n};\nexport { defaultValueTypes, getDefaultValueType };","import { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.js';\nimport { auto } from './type-auto.js';\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n  return dimensionValueTypes.find(testValueType(v));\n};\nexport { dimensionValueTypes, findDimensionValueType };","/**\n * ValueType for \"auto\"\n */\nvar auto = {\n  test: function (v) {\n    return v === \"auto\";\n  },\n  parse: function (v) {\n    return v;\n  }\n};\nexport { auto };","/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) {\n  return function (type) {\n    return type.test(v);\n  };\n};\nexport { testValueType };","function shallowCompare(next, prev) {\n  if (!Array.isArray(prev)) return false;\n  var prevLength = prev.length;\n  if (prevLength !== next.length) return false;\n  for (var i = 0; i < prevLength; i++) {\n    if (prev[i] !== next[i]) return false;\n  }\n  return true;\n}\nexport { shallowCompare };","import { __spreadArray, __read, __assign, __rest } from 'tslib';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.js';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.js';\nimport { shallowCompare } from '../../utils/shallow-compare.js';\nimport { animateVisualElement } from './animation.js';\nimport { AnimationType } from './types.js';\nimport { isVariantLabels, resolveVariant, isVariantLabel } from './variants.js';\nvar variantPriorityOrder = [AnimationType.Animate, AnimationType.Hover, AnimationType.Tap, AnimationType.Drag, AnimationType.Focus, AnimationType.Exit];\nvar reversePriorityOrder = __spreadArray([], __read(variantPriorityOrder)).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n  return function (animations) {\n    return Promise.all(animations.map(function (_a) {\n      var animation = _a.animation,\n        options = _a.options;\n      return animateVisualElement(visualElement, animation, options);\n    }));\n  };\n}\nfunction createAnimationState(visualElement) {\n  var animate = animateList(visualElement);\n  var state = createState();\n  var allAnimatedKeys = {};\n  var isInitialRender = true;\n  /**\n   * This function will be used to reduce the animation definitions for\n   * each active animation type into an object of resolved values for it.\n   */\n  var buildResolvedTypeValues = function (acc, definition) {\n    var resolved = resolveVariant(visualElement, definition);\n    if (resolved) {\n      resolved.transition;\n      var transitionEnd = resolved.transitionEnd,\n        target = __rest(resolved, [\"transition\", \"transitionEnd\"]);\n      acc = __assign(__assign(__assign({}, acc), target), transitionEnd);\n    }\n    return acc;\n  };\n  function isAnimated(key) {\n    return allAnimatedKeys[key] !== undefined;\n  }\n  /**\n   * This just allows us to inject mocked animation functions\n   * @internal\n   */\n  function setAnimateFunction(makeAnimator) {\n    animate = makeAnimator(visualElement);\n  }\n  /**\n   * When we receive new props, we need to:\n   * 1. Create a list of protected keys for each type. This is a directory of\n   *    value keys that are currently being \"handled\" by types of a higher priority\n   *    so that whenever an animation is played of a given type, these values are\n   *    protected from being animated.\n   * 2. Determine if an animation type needs animating.\n   * 3. Determine if any values have been removed from a type and figure out\n   *    what to animate those to.\n   */\n  function animateChanges(options, changedActiveType) {\n    var _a;\n    var props = visualElement.getProps();\n    var context = visualElement.getVariantContext(true) || {};\n    /**\n     * A list of animations that we'll build into as we iterate through the animation\n     * types. This will get executed at the end of the function.\n     */\n    var animations = [];\n    /**\n     * Keep track of which values have been removed. Then, as we hit lower priority\n     * animation types, we can check if they contain removed values and animate to that.\n     */\n    var removedKeys = new Set();\n    /**\n     * A dictionary of all encountered keys. This is an object to let us build into and\n     * copy it without iteration. Each time we hit an animation type we set its protected\n     * keys - the keys its not allowed to animate - to the latest version of this object.\n     */\n    var encounteredKeys = {};\n    /**\n     * If a variant has been removed at a given index, and this component is controlling\n     * variant animations, we want to ensure lower-priority variants are forced to animate.\n     */\n    var removedVariantIndex = Infinity;\n    var _loop_1 = function (i) {\n      var type = reversePriorityOrder[i];\n      var typeState = state[type];\n      var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n      var propIsVariant = isVariantLabel(prop);\n      /**\n       * If this type has *just* changed isActive status, set activeDelta\n       * to that status. Otherwise set to null.\n       */\n      var activeDelta = type === changedActiveType ? typeState.isActive : null;\n      if (activeDelta === false) removedVariantIndex = i;\n      /**\n       * If this prop is an inherited variant, rather than been set directly on the\n       * component itself, we want to make sure we allow the parent to trigger animations.\n       *\n       * TODO: Can probably change this to a !isControllingVariants check\n       */\n      var isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n      /**\n       *\n       */\n      if (isInherited && isInitialRender && visualElement.manuallyAnimateOnMount) {\n        isInherited = false;\n      }\n      /**\n       * Set all encountered keys so far as the protected keys for this type. This will\n       * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n       */\n      typeState.protectedKeys = __assign({}, encounteredKeys);\n      // Check if we can skip analysing this prop early\n      if (\n      // If it isn't active and hasn't *just* been set as inactive\n      !typeState.isActive && activeDelta === null ||\n      // If we didn't and don't have any defined prop for this animation type\n      !prop && !typeState.prevProp ||\n      // Or if the prop doesn't define an animation\n      isAnimationControls(prop) || typeof prop === \"boolean\") {\n        return \"continue\";\n      }\n      /**\n       * As we go look through the values defined on this type, if we detect\n       * a changed value or a value that was removed in a higher priority, we set\n       * this to true and add this prop to the animation list.\n       */\n      var shouldAnimateType = variantsHaveChanged(typeState.prevProp, prop) ||\n      // If we're making this variant active, we want to always make it active\n      type === changedActiveType && typeState.isActive && !isInherited && propIsVariant ||\n      // If we removed a higher-priority variant (i is in reverse order)\n      i > removedVariantIndex && propIsVariant;\n      /**\n       * As animations can be set as variant lists, variants or target objects, we\n       * coerce everything to an array if it isn't one already\n       */\n      var definitionList = Array.isArray(prop) ? prop : [prop];\n      /**\n       * Build an object of all the resolved values. We'll use this in the subsequent\n       * animateChanges calls to determine whether a value has changed.\n       */\n      var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n      if (activeDelta === false) resolvedValues = {};\n      /**\n       * Now we need to loop through all the keys in the prev prop and this prop,\n       * and decide:\n       * 1. If the value has changed, and needs animating\n       * 2. If it has been removed, and needs adding to the removedKeys set\n       * 3. If it has been removed in a higher priority type and needs animating\n       * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n       *    needs adding to the type's protectedKeys list.\n       */\n      var _b = typeState.prevResolvedValues,\n        prevResolvedValues = _b === void 0 ? {} : _b;\n      var allKeys = __assign(__assign({}, prevResolvedValues), resolvedValues);\n      var markToAnimate = function (key) {\n        shouldAnimateType = true;\n        removedKeys.delete(key);\n        typeState.needsAnimating[key] = true;\n      };\n      for (var key in allKeys) {\n        var next = resolvedValues[key];\n        var prev = prevResolvedValues[key];\n        // If we've already handled this we can just skip ahead\n        if (encounteredKeys.hasOwnProperty(key)) continue;\n        /**\n         * If the value has changed, we probably want to animate it.\n         */\n        if (next !== prev) {\n          /**\n           * If both values are keyframes, we need to shallow compare them to\n           * detect whether any value has changed. If it has, we animate it.\n           */\n          if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n            if (!shallowCompare(next, prev)) {\n              markToAnimate(key);\n            } else {\n              /**\n               * If it hasn't changed, we want to ensure it doesn't animate by\n               * adding it to the list of protected keys.\n               */\n              typeState.protectedKeys[key] = true;\n            }\n          } else if (next !== undefined) {\n            // If next is defined and doesn't equal prev, it needs animating\n            markToAnimate(key);\n          } else {\n            // If it's undefined, it's been removed.\n            removedKeys.add(key);\n          }\n        } else if (next !== undefined && removedKeys.has(key)) {\n          /**\n           * If next hasn't changed and it isn't undefined, we want to check if it's\n           * been removed by a higher priority\n           */\n          markToAnimate(key);\n        } else {\n          /**\n           * If it hasn't changed, we add it to the list of protected values\n           * to ensure it doesn't get animated.\n           */\n          typeState.protectedKeys[key] = true;\n        }\n      }\n      /**\n       * Update the typeState so next time animateChanges is called we can compare the\n       * latest prop and resolvedValues to these.\n       */\n      typeState.prevProp = prop;\n      typeState.prevResolvedValues = resolvedValues;\n      /**\n       *\n       */\n      if (typeState.isActive) {\n        encounteredKeys = __assign(__assign({}, encounteredKeys), resolvedValues);\n      }\n      if (isInitialRender && visualElement.blockInitialAnimation) {\n        shouldAnimateType = false;\n      }\n      /**\n       * If this is an inherited prop we want to hard-block animations\n       * TODO: Test as this should probably still handle animations triggered\n       * by removed values?\n       */\n      if (shouldAnimateType && !isInherited) {\n        animations.push.apply(animations, __spreadArray([], __read(definitionList.map(function (animation) {\n          return {\n            animation: animation,\n            options: __assign({\n              type: type\n            }, options)\n          };\n        }))));\n      }\n    };\n    /**\n     * Iterate through all animation types in reverse priority order. For each, we want to\n     * detect which values it's handling and whether or not they've changed (and therefore\n     * need to be animated). If any values have been removed, we want to detect those in\n     * lower priority props and flag for animation.\n     */\n    for (var i = 0; i < numAnimationTypes; i++) {\n      _loop_1(i);\n    }\n    allAnimatedKeys = __assign({}, encounteredKeys);\n    /**\n     * If there are some removed value that haven't been dealt with,\n     * we need to create a new animation that falls back either to the value\n     * defined in the style prop, or the last read value.\n     */\n    if (removedKeys.size) {\n      var fallbackAnimation_1 = {};\n      removedKeys.forEach(function (key) {\n        var fallbackTarget = visualElement.getBaseTarget(key);\n        if (fallbackTarget !== undefined) {\n          fallbackAnimation_1[key] = fallbackTarget;\n        }\n      });\n      animations.push({\n        animation: fallbackAnimation_1\n      });\n    }\n    var shouldAnimate = Boolean(animations.length);\n    if (isInitialRender && props.initial === false && !visualElement.manuallyAnimateOnMount) {\n      shouldAnimate = false;\n    }\n    isInitialRender = false;\n    return shouldAnimate ? animate(animations) : Promise.resolve();\n  }\n  /**\n   * Change whether a certain animation type is active.\n   */\n  function setActive(type, isActive, options) {\n    var _a;\n    // If the active state hasn't changed, we can safely do nothing here\n    if (state[type].isActive === isActive) return Promise.resolve();\n    // Propagate active change to children\n    (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n      var _a;\n      return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive);\n    });\n    state[type].isActive = isActive;\n    return animateChanges(options, type);\n  }\n  return {\n    isAnimated: isAnimated,\n    animateChanges: animateChanges,\n    setActive: setActive,\n    setAnimateFunction: setAnimateFunction,\n    getState: function () {\n      return state;\n    }\n  };\n}\nfunction variantsHaveChanged(prev, next) {\n  if (typeof next === \"string\") {\n    return next !== prev;\n  } else if (isVariantLabels(next)) {\n    return !shallowCompare(next, prev);\n  }\n  return false;\n}\nfunction createTypeState(isActive) {\n  if (isActive === void 0) {\n    isActive = false;\n  }\n  return {\n    isActive: isActive,\n    protectedKeys: {},\n    needsAnimating: {},\n    prevResolvedValues: {}\n  };\n}\nfunction createState() {\n  var _a;\n  return _a = {}, _a[AnimationType.Animate] = createTypeState(true), _a[AnimationType.Hover] = createTypeState(), _a[AnimationType.Tap] = createTypeState(), _a[AnimationType.Drag] = createTypeState(), _a[AnimationType.Focus] = createTypeState(), _a[AnimationType.Exit] = createTypeState(), _a;\n}\nexport { createAnimationState, variantPriorityOrder, variantsHaveChanged };","import { __read, __rest, __assign } from 'tslib';\nimport { startAnimation } from '../../animation/utils/transitions.js';\nimport { setTarget } from './setters.js';\nimport { resolveVariant } from './variants.js';\n\n/**\n * @internal\n */\nfunction animateVisualElement(visualElement, definition, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  visualElement.notifyAnimationStart();\n  var animation;\n  if (Array.isArray(definition)) {\n    var animations = definition.map(function (variant) {\n      return animateVariant(visualElement, variant, options);\n    });\n    animation = Promise.all(animations);\n  } else if (typeof definition === \"string\") {\n    animation = animateVariant(visualElement, definition, options);\n  } else {\n    var resolvedDefinition = typeof definition === \"function\" ? resolveVariant(visualElement, definition, options.custom) : definition;\n    animation = animateTarget(visualElement, resolvedDefinition, options);\n  }\n  return animation.then(function () {\n    return visualElement.notifyAnimationComplete(definition);\n  });\n}\nfunction animateVariant(visualElement, variant, options) {\n  var _a;\n  if (options === void 0) {\n    options = {};\n  }\n  var resolved = resolveVariant(visualElement, variant, options.custom);\n  var _b = (resolved || {}).transition,\n    transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\n  if (options.transitionOverride) {\n    transition = options.transitionOverride;\n  }\n  /**\n   * If we have a variant, create a callback that runs it as an animation.\n   * Otherwise, we resolve a Promise immediately for a composable no-op.\n   */\n  var getAnimation = resolved ? function () {\n    return animateTarget(visualElement, resolved, options);\n  } : function () {\n    return Promise.resolve();\n  };\n  /**\n   * If we have children, create a callback that runs all their animations.\n   * Otherwise, we resolve a Promise immediately for a composable no-op.\n   */\n  var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size) ? function (forwardDelay) {\n    if (forwardDelay === void 0) {\n      forwardDelay = 0;\n    }\n    var _a = transition.delayChildren,\n      delayChildren = _a === void 0 ? 0 : _a,\n      staggerChildren = transition.staggerChildren,\n      staggerDirection = transition.staggerDirection;\n    return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n  } : function () {\n    return Promise.resolve();\n  };\n  /**\n   * If the transition explicitly defines a \"when\" option, we need to resolve either\n   * this animation or all children animations before playing the other.\n   */\n  var when = transition.when;\n  if (when) {\n    var _c = __read(when === \"beforeChildren\" ? [getAnimation, getChildAnimations] : [getChildAnimations, getAnimation], 2),\n      first = _c[0],\n      last = _c[1];\n    return first().then(last);\n  } else {\n    return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n  }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n  var _b;\n  var _c = _a === void 0 ? {} : _a,\n    _d = _c.delay,\n    delay = _d === void 0 ? 0 : _d,\n    transitionOverride = _c.transitionOverride,\n    type = _c.type;\n  var _e = visualElement.makeTargetAnimatable(definition),\n    _f = _e.transition,\n    transition = _f === void 0 ? visualElement.getDefaultTransition() : _f,\n    transitionEnd = _e.transitionEnd,\n    target = __rest(_e, [\"transition\", \"transitionEnd\"]);\n  if (transitionOverride) transition = transitionOverride;\n  var animations = [];\n  var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n  for (var key in target) {\n    var value = visualElement.getValue(key);\n    var valueTarget = target[key];\n    if (!value || valueTarget === undefined || animationTypeState && shouldBlockAnimation(animationTypeState, key)) {\n      continue;\n    }\n    var animation = startAnimation(key, value, valueTarget, __assign({\n      delay: delay\n    }, transition));\n    animations.push(animation);\n  }\n  return Promise.all(animations).then(function () {\n    transitionEnd && setTarget(visualElement, transitionEnd);\n  });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n  if (delayChildren === void 0) {\n    delayChildren = 0;\n  }\n  if (staggerChildren === void 0) {\n    staggerChildren = 0;\n  }\n  if (staggerDirection === void 0) {\n    staggerDirection = 1;\n  }\n  var animations = [];\n  var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n  var generateStaggerDuration = staggerDirection === 1 ? function (i) {\n    if (i === void 0) {\n      i = 0;\n    }\n    return i * staggerChildren;\n  } : function (i) {\n    if (i === void 0) {\n      i = 0;\n    }\n    return maxStaggerDuration - i * staggerChildren;\n  };\n  Array.from(visualElement.variantChildren).sort(sortByTreeOrder).forEach(function (child, i) {\n    animations.push(animateVariant(child, variant, __assign(__assign({}, options), {\n      delay: delayChildren + generateStaggerDuration(i)\n    })).then(function () {\n      return child.notifyAnimationComplete(variant);\n    }));\n  });\n  return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n  visualElement.forEachValue(function (value) {\n    return value.stop();\n  });\n}\nfunction sortByTreeOrder(a, b) {\n  return a.sortNodePosition(b);\n}\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation(_a, key) {\n  var protectedKeys = _a.protectedKeys,\n    needsAnimating = _a.needsAnimating;\n  var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n  needsAnimating[key] = false;\n  return shouldBlock;\n}\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };","var compareByDepth = function (a, b) {\n  return a.depth - b.depth;\n};\nexport { compareByDepth };","function isDraggable(visualElement) {\n  var _a = visualElement.getProps(),\n    drag = _a.drag,\n    _dragX = _a._dragX;\n  return drag && !_dragX;\n}\nexport { isDraggable };","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nvar isNumericalString = function (v) {\n  return /^\\-?\\d*\\.?\\d+$/.test(v);\n};\nexport { isNumericalString };","import { __spreadArray, __read } from 'tslib';\nimport { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.js';\nimport { testValueType } from './test.js';\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = __spreadArray(__spreadArray([], __read(dimensionValueTypes)), [color, complex]);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) {\n  return valueTypes.find(testValueType(v));\n};\nexport { findValueType };","import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { complex } from 'style-value-types';\nimport { isNumericalString } from '../../utils/is-numerical-string.js';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.js';\nimport { motionValue } from '../../value/index.js';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.js';\nimport { findValueType } from '../dom/value-types/find.js';\nimport { resolveVariant } from './variants.js';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n  if (visualElement.hasValue(key)) {\n    visualElement.getValue(key).set(value);\n  } else {\n    visualElement.addValue(key, motionValue(value));\n  }\n}\nfunction setTarget(visualElement, definition) {\n  var resolved = resolveVariant(visualElement, definition);\n  var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {},\n    _b = _a.transitionEnd,\n    transitionEnd = _b === void 0 ? {} : _b;\n  _a.transition;\n  var target = __rest(_a, [\"transitionEnd\", \"transition\"]);\n  target = __assign(__assign({}, target), transitionEnd);\n  for (var key in target) {\n    var value = resolveFinalValueInKeyframes(target[key]);\n    setMotionValue(visualElement, key, value);\n  }\n}\nfunction setVariants(visualElement, variantLabels) {\n  var reversedLabels = __spreadArray([], __read(variantLabels)).reverse();\n  reversedLabels.forEach(function (key) {\n    var _a;\n    var variant = visualElement.getVariant(key);\n    variant && setTarget(visualElement, variant);\n    (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n      setVariants(child, variantLabels);\n    });\n  });\n}\nfunction setValues(visualElement, definition) {\n  if (Array.isArray(definition)) {\n    return setVariants(visualElement, definition);\n  } else if (typeof definition === \"string\") {\n    return setVariants(visualElement, [definition]);\n  } else {\n    setTarget(visualElement, definition);\n  }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n  var _a, _b, _c;\n  var _d;\n  var newValueKeys = Object.keys(target).filter(function (key) {\n    return !visualElement.hasValue(key);\n  });\n  var numNewValues = newValueKeys.length;\n  if (!numNewValues) return;\n  for (var i = 0; i < numNewValues; i++) {\n    var key = newValueKeys[i];\n    var targetValue = target[key];\n    var value = null;\n    /**\n     * If the target is a series of keyframes, we can use the first value\n     * in the array. If this first value is null, we'll still need to read from the DOM.\n     */\n    if (Array.isArray(targetValue)) {\n      value = targetValue[0];\n    }\n    /**\n     * If the target isn't keyframes, or the first keyframe was null, we need to\n     * first check if an origin value was explicitly defined in the transition as \"from\",\n     * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n     */\n    if (value === null) {\n      value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n    }\n    /**\n     * If value is still undefined or null, ignore it. Preferably this would throw,\n     * but this was causing issues in Framer.\n     */\n    if (value === undefined || value === null) continue;\n    if (typeof value === \"string\" && isNumericalString(value)) {\n      // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n      value = parseFloat(value);\n    } else if (!findValueType(value) && complex.test(targetValue)) {\n      value = getAnimatableNone(key, targetValue);\n    }\n    visualElement.addValue(key, motionValue(value));\n    (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : _d[key] = value;\n    visualElement.setBaseTarget(key, value);\n  }\n}\nfunction getOriginFromTransition(key, transition) {\n  if (!transition) return;\n  var valueTransition = transition[key] || transition[\"default\"] || transition;\n  return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n  var _a, _b;\n  var origin = {};\n  for (var key in target) {\n    origin[key] = (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n  }\n  return origin;\n}\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };","var AnimationType;\n(function (AnimationType) {\n  AnimationType[\"Animate\"] = \"animate\";\n  AnimationType[\"Hover\"] = \"whileHover\";\n  AnimationType[\"Tap\"] = \"whileTap\";\n  AnimationType[\"Drag\"] = \"whileDrag\";\n  AnimationType[\"Focus\"] = \"whileFocus\";\n  AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\nexport { AnimationType };","function addUniqueItem(arr, item) {\n  arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n  var index = arr.indexOf(item);\n  index > -1 && arr.splice(index, 1);\n}\nexport { addUniqueItem, removeItem };","// Call a handler once for each axis\nfunction eachAxis(handler) {\n  return [handler(\"x\"), handler(\"y\")];\n}\nexport { eachAxis };","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { isDraggable } from '../../render/utils/is-draggable.js';\n\n/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction resetAxis(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 resetBox(box, originBox) {\n  resetAxis(box.x, originBox.x);\n  resetAxis(box.y, originBox.y);\n}\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n  var distanceFromOrigin = point - originPoint;\n  var scaled = scale * distanceFromOrigin;\n  return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n  if (boxScale !== undefined) {\n    point = scalePoint(point, boxScale, originPoint);\n  }\n  return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate, scale, originPoint, boxScale) {\n  if (translate === void 0) {\n    translate = 0;\n  }\n  if (scale === void 0) {\n    scale = 1;\n  }\n  axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n  axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _a) {\n  var x = _a.x,\n    y = _a.y;\n  applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n  applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction applyAxisTransforms(final, axis, transforms, _a) {\n  var _b = __read(_a, 3),\n    key = _b[0],\n    scaleKey = _b[1],\n    originKey = _b[2];\n  // Copy the current axis to the final axis before mutation\n  final.min = axis.min;\n  final.max = axis.max;\n  var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n  var originPoint = mix(axis.min, axis.max, axisOrigin);\n  // Apply the axis delta to the final axis\n  applyAxisDelta(final, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction applyBoxTransforms(finalBox, box, transforms) {\n  applyAxisTransforms(finalBox.x, box.x, transforms, xKeys);\n  applyAxisTransforms(finalBox.y, box.y, transforms, yKeys);\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) {\n  if (translate === void 0) {\n    translate = 0;\n  }\n  if (scale === void 0) {\n    scale = 1;\n  }\n  if (origin === void 0) {\n    origin = 0.5;\n  }\n  var originPoint = mix(axis.min, axis.max, origin) - 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) {\n  var _b = __read(_a, 3),\n    key = _b[0],\n    scaleKey = _b[1],\n    originKey = _b[2];\n  removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale);\n}\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) {\n  removeAxisTransforms(box.x, transforms, xKeys);\n  removeAxisTransforms(box.y, transforms, yKeys);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath) {\n  var treeLength = treePath.length;\n  if (!treeLength) return;\n  // Reset the treeScale\n  treeScale.x = treeScale.y = 1;\n  var node;\n  var delta;\n  for (var i = 0; i < treeLength; i++) {\n    node = treePath[i];\n    delta = node.getLayoutState().delta;\n    // Incoporate each ancestor's scale into a culmulative treeScale for this component\n    treeScale.x *= delta.x.scale;\n    treeScale.y *= delta.y.scale;\n    // Apply each ancestor's calculated delta into this component's recorded layout box\n    applyBoxDelta(box, delta);\n    // If this is a draggable ancestor, also incorporate the node's transform to the layout box\n    if (isDraggable(node)) {\n      applyBoxTransforms(box, box, node.getLatestValues());\n    }\n  }\n}\nexport { applyAxisDelta, applyAxisTransforms, applyBoxDelta, applyBoxTransforms, applyPointDelta, applyTreeDeltas, removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta, resetAxis, resetBox, scalePoint };","import { mix, distance, clamp, progress } from 'popmotion';\nvar clampProgress = function (v) {\n  return clamp(0, 1, v);\n};\n/**\n * Returns true if the provided value is within maxDistance of the provided target\n */\nfunction isNear(value, target, maxDistance) {\n  if (target === void 0) {\n    target = 0;\n  }\n  if (maxDistance === void 0) {\n    maxDistance = 0.01;\n  }\n  return distance(value, target) < maxDistance;\n}\nfunction calcLength(axis) {\n  return axis.max - axis.min;\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  } else if (sourceLength > targetLength) {\n    origin = progress(source.min, source.max - targetLength, target.min);\n  }\n  return clampProgress(origin);\n}\n/**\n * Update the AxisDelta with a transform that projects source into target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateAxisDelta(delta, source, target, origin) {\n  if (origin === void 0) {\n    origin = 0.5;\n  }\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)) delta.scale = 1;\n  delta.translate = mix(target.min, target.max, delta.origin) - delta.originPoint;\n  if (isNear(delta.translate)) delta.translate = 0;\n}\n/**\n * Update the BoxDelta with a transform that projects the source into the target.\n *\n * The transform `origin` is optional. If not provided, it'll be automatically\n * calculated based on the relative positions of the two bounding boxes.\n */\nfunction updateBoxDelta(delta, source, target, origin) {\n  updateAxisDelta(delta.x, source.x, target.x, defaultOrigin(origin.originX));\n  updateAxisDelta(delta.y, source.y, target.y, defaultOrigin(origin.originY));\n}\n/**\n * Currently this only accepts numerical origins, measured as 0-1, but could\n * accept pixel values by comparing to the target axis.\n */\nfunction defaultOrigin(origin) {\n  return typeof origin === \"number\" ? origin : 0.5;\n}\nfunction calcRelativeAxis(target, relative, parent) {\n  target.min = parent.min + relative.min;\n  target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(projection, parentProjection) {\n  calcRelativeAxis(projection.target.x, projection.relativeTarget.x, parentProjection.target.x);\n  calcRelativeAxis(projection.target.y, projection.relativeTarget.y, parentProjection.target.y);\n}\nexport { calcOrigin, calcRelativeAxis, calcRelativeBox, isNear, updateAxisDelta, updateBoxDelta };","function noop(any) {\n  return any;\n}\nexport { noop };","import { __assign } from 'tslib';\nimport { noop } from '../noop.js';\n\n/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToAxisBox(_a) {\n  var top = _a.top,\n    left = _a.left,\n    right = _a.right,\n    bottom = _a.bottom;\n  return {\n    x: {\n      min: left,\n      max: right\n    },\n    y: {\n      min: top,\n      max: bottom\n    }\n  };\n}\nfunction convertAxisBoxToBoundingBox(_a) {\n  var x = _a.x,\n    y = _a.y;\n  return {\n    top: y.min,\n    bottom: y.max,\n    left: x.min,\n    right: x.max\n  };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoundingBox(_a, transformPoint) {\n  var top = _a.top,\n    left = _a.left,\n    bottom = _a.bottom,\n    right = _a.right;\n  if (transformPoint === void 0) {\n    transformPoint = noop;\n  }\n  var topLeft = transformPoint({\n    x: left,\n    y: top\n  });\n  var bottomRight = transformPoint({\n    x: right,\n    y: bottom\n  });\n  return {\n    top: topLeft.y,\n    left: topLeft.x,\n    bottom: bottomRight.y,\n    right: bottomRight.x\n  };\n}\n/**\n * Create an empty axis box of zero size\n */\nfunction axisBox() {\n  return {\n    x: {\n      min: 0,\n      max: 1\n    },\n    y: {\n      min: 0,\n      max: 1\n    }\n  };\n}\nfunction copyAxisBox(box) {\n  return {\n    x: __assign({}, box.x),\n    y: __assign({}, box.y)\n  };\n}\n/**\n * Create an empty box delta\n */\nvar zeroDelta = {\n  translate: 0,\n  scale: 1,\n  origin: 0,\n  originPoint: 0\n};\nfunction delta() {\n  return {\n    x: __assign({}, zeroDelta),\n    y: __assign({}, zeroDelta)\n  };\n}\nexport { axisBox, convertAxisBoxToBoundingBox, convertBoundingBoxToAxisBox, copyAxisBox, delta, transformBoundingBox };","import { addUniqueItem, removeItem } from './array.js';\nvar SubscriptionManager = /** @class */function () {\n  function SubscriptionManager() {\n    this.subscriptions = [];\n  }\n  SubscriptionManager.prototype.add = function (handler) {\n    var _this = this;\n    addUniqueItem(this.subscriptions, handler);\n    return function () {\n      return removeItem(_this.subscriptions, handler);\n    };\n  };\n  SubscriptionManager.prototype.notify = function (a, b, c) {\n    var numSubscriptions = this.subscriptions.length;\n    if (!numSubscriptions) return;\n    if (numSubscriptions === 1) {\n      /**\n       * If there's only a single handler we can just call it without invoking a loop.\n       */\n      this.subscriptions[0](a, b, c);\n    } else {\n      for (var i = 0; i < numSubscriptions; i++) {\n        /**\n         * Check whether the handler exists before firing as it's possible\n         * the subscriptions were modified during this loop running.\n         */\n        var handler = this.subscriptions[i];\n        handler && handler(a, b, c);\n      }\n    }\n  };\n  SubscriptionManager.prototype.getSize = function () {\n    return this.subscriptions.length;\n  };\n  SubscriptionManager.prototype.clear = function () {\n    this.subscriptions.length = 0;\n  };\n  return SubscriptionManager;\n}();\nexport { SubscriptionManager };","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nvar secondsToMilliseconds = function (seconds) {\n  return seconds * 1000;\n};\nexport { secondsToMilliseconds };","import { useEffect } from 'react';\nfunction useUnmountEffect(callback) {\n  return useEffect(function () {\n    return function () {\n      return callback();\n    };\n  }, []);\n}\nexport { useUnmountEffect };","import sync, { getFrameData } from 'framesync';\nimport { velocityPerSecond } from 'popmotion';\nimport { SubscriptionManager } from '../utils/subscription-manager.js';\nvar isFloat = function (value) {\n  return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */function () {\n  /**\n   * @param init - The initiating value\n   * @param config - Optional configuration options\n   *\n   * -  `transformer`: A function to transform incoming values with.\n   *\n   * @internal\n   */\n  function MotionValue(init) {\n    var _this = this;\n    /**\n     * Duration, in milliseconds, since last updating frame.\n     *\n     * @internal\n     */\n    this.timeDelta = 0;\n    /**\n     * Timestamp of the last time this `MotionValue` was updated.\n     *\n     * @internal\n     */\n    this.lastUpdated = 0;\n    /**\n     * Functions to notify when the `MotionValue` updates.\n     *\n     * @internal\n     */\n    this.updateSubscribers = new SubscriptionManager();\n    /**\n     * Functions to notify when the velocity updates.\n     *\n     * @internal\n     */\n    this.velocityUpdateSubscribers = new SubscriptionManager();\n    /**\n     * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n     *\n     * @internal\n     */\n    this.renderSubscribers = new SubscriptionManager();\n    /**\n     * Tracks whether this value can output a velocity. Currently this is only true\n     * if the value is numerical, but we might be able to widen the scope here and support\n     * other value types.\n     *\n     * @internal\n     */\n    this.canTrackVelocity = false;\n    this.updateAndNotify = function (v, render) {\n      if (render === void 0) {\n        render = true;\n      }\n      _this.prev = _this.current;\n      _this.current = v;\n      // Update timestamp\n      var _a = getFrameData(),\n        delta = _a.delta,\n        timestamp = _a.timestamp;\n      if (_this.lastUpdated !== timestamp) {\n        _this.timeDelta = delta;\n        _this.lastUpdated = timestamp;\n        sync.postRender(_this.scheduleVelocityCheck);\n      }\n      // Update update subscribers\n      if (_this.prev !== _this.current) {\n        _this.updateSubscribers.notify(_this.current);\n      }\n      // Update velocity subscribers\n      if (_this.velocityUpdateSubscribers.getSize()) {\n        _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n      }\n      // Update render subscribers\n      if (render) {\n        _this.renderSubscribers.notify(_this.current);\n      }\n    };\n    /**\n     * Schedule a velocity check for the next frame.\n     *\n     * This is an instanced and bound function to prevent generating a new\n     * function once per frame.\n     *\n     * @internal\n     */\n    this.scheduleVelocityCheck = function () {\n      return sync.postRender(_this.velocityCheck);\n    };\n    /**\n     * Updates `prev` with `current` if the value hasn't been updated this frame.\n     * This ensures velocity calculations return `0`.\n     *\n     * This is an instanced and bound function to prevent generating a new\n     * function once per frame.\n     *\n     * @internal\n     */\n    this.velocityCheck = function (_a) {\n      var timestamp = _a.timestamp;\n      if (timestamp !== _this.lastUpdated) {\n        _this.prev = _this.current;\n        _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n      }\n    };\n    this.hasAnimated = false;\n    this.prev = this.current = init;\n    this.canTrackVelocity = isFloat(this.current);\n  }\n  /**\n   * Adds a function that will be notified when the `MotionValue` is updated.\n   *\n   * It returns a function that, when called, will cancel the subscription.\n   *\n   * When calling `onChange` inside a React component, it should be wrapped with the\n   * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n   * from the `useEffect` function to ensure you don't add duplicate subscribers..\n   *\n   * @library\n   *\n   * ```jsx\n   * function MyComponent() {\n   *   const x = useMotionValue(0)\n   *   const y = useMotionValue(0)\n   *   const opacity = useMotionValue(1)\n   *\n   *   useEffect(() => {\n   *     function updateOpacity() {\n   *       const maxXY = Math.max(x.get(), y.get())\n   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n   *       opacity.set(newOpacity)\n   *     }\n   *\n   *     const unsubscribeX = x.onChange(updateOpacity)\n   *     const unsubscribeY = y.onChange(updateOpacity)\n   *\n   *     return () => {\n   *       unsubscribeX()\n   *       unsubscribeY()\n   *     }\n   *   }, [])\n   *\n   *   return <Frame x={x} />\n   * }\n   * ```\n   *\n   * @motion\n   *\n   * ```jsx\n   * export const MyComponent = () => {\n   *   const x = useMotionValue(0)\n   *   const y = useMotionValue(0)\n   *   const opacity = useMotionValue(1)\n   *\n   *   useEffect(() => {\n   *     function updateOpacity() {\n   *       const maxXY = Math.max(x.get(), y.get())\n   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n   *       opacity.set(newOpacity)\n   *     }\n   *\n   *     const unsubscribeX = x.onChange(updateOpacity)\n   *     const unsubscribeY = y.onChange(updateOpacity)\n   *\n   *     return () => {\n   *       unsubscribeX()\n   *       unsubscribeY()\n   *     }\n   *   }, [])\n   *\n   *   return <motion.div style={{ x }} />\n   * }\n   * ```\n   *\n   * @internalremarks\n   *\n   * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n   *\n   * ```jsx\n   * useOnChange(x, () => {})\n   * ```\n   *\n   * @param subscriber - A function that receives the latest value.\n   * @returns A function that, when called, will cancel this subscription.\n   *\n   * @public\n   */\n  MotionValue.prototype.onChange = function (subscription) {\n    return this.updateSubscribers.add(subscription);\n  };\n  MotionValue.prototype.clearListeners = function () {\n    this.updateSubscribers.clear();\n  };\n  /**\n   * Adds a function that will be notified when the `MotionValue` requests a render.\n   *\n   * @param subscriber - A function that's provided the latest value.\n   * @returns A function that, when called, will cancel this subscription.\n   *\n   * @internal\n   */\n  MotionValue.prototype.onRenderRequest = function (subscription) {\n    // Render immediately\n    subscription(this.get());\n    return this.renderSubscribers.add(subscription);\n  };\n  /**\n   * Attaches a passive effect to the `MotionValue`.\n   *\n   * @internal\n   */\n  MotionValue.prototype.attach = function (passiveEffect) {\n    this.passiveEffect = passiveEffect;\n  };\n  /**\n   * Sets the state of the `MotionValue`.\n   *\n   * @remarks\n   *\n   * ```jsx\n   * const x = useMotionValue(0)\n   * x.set(10)\n   * ```\n   *\n   * @param latest - Latest value to set.\n   * @param render - Whether to notify render subscribers. Defaults to `true`\n   *\n   * @public\n   */\n  MotionValue.prototype.set = function (v, render) {\n    if (render === void 0) {\n      render = true;\n    }\n    if (!render || !this.passiveEffect) {\n      this.updateAndNotify(v, render);\n    } else {\n      this.passiveEffect(v, this.updateAndNotify);\n    }\n  };\n  /**\n   * Returns the latest state of `MotionValue`\n   *\n   * @returns - The latest state of `MotionValue`\n   *\n   * @public\n   */\n  MotionValue.prototype.get = function () {\n    return this.current;\n  };\n  /**\n   * @public\n   */\n  MotionValue.prototype.getPrevious = function () {\n    return this.prev;\n  };\n  /**\n   * Returns the latest velocity of `MotionValue`\n   *\n   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n   *\n   * @public\n   */\n  MotionValue.prototype.getVelocity = function () {\n    // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n    return this.canTrackVelocity ?\n    // These casts could be avoided if parseFloat would be typed better\n    velocityPerSecond(parseFloat(this.current) - parseFloat(this.prev), this.timeDelta) : 0;\n  };\n  /**\n   * Registers a new animation to control this `MotionValue`. Only one\n   * animation can drive a `MotionValue` at one time.\n   *\n   * ```jsx\n   * value.start()\n   * ```\n   *\n   * @param animation - A function that starts the provided animation\n   *\n   * @internal\n   */\n  MotionValue.prototype.start = function (animation) {\n    var _this = this;\n    this.stop();\n    return new Promise(function (resolve) {\n      _this.hasAnimated = true;\n      _this.stopAnimation = animation(resolve);\n    }).then(function () {\n      return _this.clearAnimation();\n    });\n  };\n  /**\n   * Stop the currently active animation.\n   *\n   * @public\n   */\n  MotionValue.prototype.stop = function () {\n    if (this.stopAnimation) this.stopAnimation();\n    this.clearAnimation();\n  };\n  /**\n   * Returns `true` if this value is currently animating.\n   *\n   * @public\n   */\n  MotionValue.prototype.isAnimating = function () {\n    return !!this.stopAnimation;\n  };\n  MotionValue.prototype.clearAnimation = function () {\n    this.stopAnimation = null;\n  };\n  /**\n   * Destroy and clean up subscribers to this `MotionValue`.\n   *\n   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n   * created a `MotionValue` via the `motionValue` function.\n   *\n   * @public\n   */\n  MotionValue.prototype.destroy = function () {\n    this.updateSubscribers.clear();\n    this.renderSubscribers.clear();\n    this.stop();\n  };\n  return MotionValue;\n}();\n/**\n * @internal\n */\nfunction motionValue(init) {\n  return new MotionValue(init);\n}\nexport { MotionValue, motionValue };","var defaultTimestep = 1 / 60 * 1000;\nvar getCurrentTime = typeof performance !== \"undefined\" ? function () {\n  return performance.now();\n} : function () {\n  return Date.now();\n};\nvar onNextFrame = typeof window !== \"undefined\" ? function (callback) {\n  return window.requestAnimationFrame(callback);\n} : function (callback) {\n  return setTimeout(function () {\n    return callback(getCurrentTime());\n  }, defaultTimestep);\n};\nexport { defaultTimestep, onNextFrame };","import { onNextFrame, defaultTimestep } from './on-next-frame.js';\nimport { createRenderStep } from './create-render-step.js';\nvar maxElapsed = 40;\nvar useDefaultElapsed = true;\nvar runNextFrame = false;\nvar isProcessing = false;\nvar frame = {\n  delta: 0,\n  timestamp: 0\n};\nvar stepsOrder = [\"read\", \"update\", \"preRender\", \"render\", \"postRender\"];\nvar steps = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n  acc[key] = createRenderStep(function () {\n    return runNextFrame = true;\n  });\n  return acc;\n}, {});\nvar sync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n  var step = steps[key];\n  acc[key] = function (process, keepAlive, immediate) {\n    if (keepAlive === void 0) {\n      keepAlive = false;\n    }\n    if (immediate === void 0) {\n      immediate = false;\n    }\n    if (!runNextFrame) startLoop();\n    return step.schedule(process, keepAlive, immediate);\n  };\n  return acc;\n}, {});\nvar cancelSync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n  acc[key] = steps[key].cancel;\n  return acc;\n}, {});\nvar flushSync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {\n  acc[key] = function () {\n    return steps[key].process(frame);\n  };\n  return acc;\n}, {});\nvar processStep = function (stepId) {\n  return steps[stepId].process(frame);\n};\nvar processFrame = function (timestamp) {\n  runNextFrame = false;\n  frame.delta = useDefaultElapsed ? defaultTimestep : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n  frame.timestamp = timestamp;\n  isProcessing = true;\n  stepsOrder.forEach(processStep);\n  isProcessing = false;\n  if (runNextFrame) {\n    useDefaultElapsed = false;\n    onNextFrame(processFrame);\n  }\n};\nvar startLoop = function () {\n  runNextFrame = true;\n  useDefaultElapsed = true;\n  if (!isProcessing) onNextFrame(processFrame);\n};\nvar getFrameData = function () {\n  return frame;\n};\nexport default sync;\nexport { cancelSync, flushSync, getFrameData };","function createRenderStep(runNextFrame) {\n  var toRun = [];\n  var toRunNextFrame = [];\n  var numToRun = 0;\n  var isProcessing = false;\n  var toKeepAlive = new WeakSet();\n  var step = {\n    schedule: function (callback, keepAlive, immediate) {\n      if (keepAlive === void 0) {\n        keepAlive = false;\n      }\n      if (immediate === void 0) {\n        immediate = false;\n      }\n      var addToCurrentFrame = immediate && isProcessing;\n      var buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n      if (keepAlive) toKeepAlive.add(callback);\n      if (buffer.indexOf(callback) === -1) {\n        buffer.push(callback);\n        if (addToCurrentFrame && isProcessing) numToRun = toRun.length;\n      }\n      return callback;\n    },\n    cancel: function (callback) {\n      var index = toRunNextFrame.indexOf(callback);\n      if (index !== -1) toRunNextFrame.splice(index, 1);\n      toKeepAlive.delete(callback);\n    },\n    process: function (frameData) {\n      var _a;\n      isProcessing = true;\n      _a = [toRunNextFrame, toRun], toRun = _a[0], toRunNextFrame = _a[1];\n      toRunNextFrame.length = 0;\n      numToRun = toRun.length;\n      if (numToRun) {\n        for (var i = 0; i < numToRun; i++) {\n          var callback = toRun[i];\n          callback(frameData);\n          if (toKeepAlive.has(callback)) {\n            step.schedule(callback);\n            runNextFrame();\n          }\n        }\n      }\n      isProcessing = false;\n    }\n  };\n  return step;\n}\nexport { createRenderStep };","var warning = function () {};\nvar invariant = function () {};\nif (process.env.NODE_ENV !== 'production') {\n  warning = function (check, message) {\n    if (!check && typeof console !== 'undefined') {\n      console.warn(message);\n    }\n  };\n  invariant = function (check, message) {\n    if (!check) {\n      throw new Error(message);\n    }\n  };\n}\nexport { invariant, warning };","var clamp = function (min, max, v) {\n  return Math.min(Math.max(v, min), max);\n};\nexport { clamp };","var isPoint = function (point) {\n  return point.hasOwnProperty('x') && point.hasOwnProperty('y');\n};\nexport { isPoint };","import { isPoint } from './is-point.js';\nvar isPoint3D = function (point) {\n  return isPoint(point) && point.hasOwnProperty('z');\n};\nexport { isPoint3D };","import { isPoint } from './is-point.js';\nimport { isPoint3D } from './is-point-3d.js';\nimport { isNum } from './inc.js';\nvar distance1D = function (a, b) {\n  return Math.abs(a - b);\n};\nfunction distance(a, b) {\n  if (isNum(a) && isNum(b)) {\n    return distance1D(a, b);\n  } else if (isPoint(a) && isPoint(b)) {\n    var xDelta = distance1D(a.x, b.x);\n    var yDelta = distance1D(a.y, b.y);\n    var 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}\nexport { distance };","var zeroPoint = {\n  x: 0,\n  y: 0,\n  z: 0\n};\nvar isNum = function (v) {\n  return typeof v === 'number';\n};\nexport { isNum, zeroPoint };","var mix = function (from, to, progress) {\n  return -progress * from + progress * to + from;\n};\nexport { mix };","var combineFunctions = function (a, b) {\n  return function (v) {\n    return b(a(v));\n  };\n};\nvar pipe = function () {\n  var transformers = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    transformers[_i] = arguments[_i];\n  }\n  return transformers.reduce(combineFunctions);\n};\nexport { pipe };","var progress = function (from, to, value) {\n  var toFromDifference = to - from;\n  return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\nexport { progress };","function velocityPerSecond(velocity, frameDuration) {\n  return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\nexport { velocityPerSecond };","/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */\n\nvar hasElementType = typeof Element !== 'undefined';\nvar hasMap = typeof Map === 'function';\nvar hasSet = typeof Set === 'function';\nvar hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView;\n\n// Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js\n\nfunction equal(a, b) {\n  // START: fast-deep-equal es6/index.js 3.1.3\n  if (a === b) return true;\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    // START: Modifications:\n    // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code\n    //    to co-exist with es5.\n    // 2. Replace `for of` with es5 compliant iteration using `for`.\n    //    Basically, take:\n    //\n    //    ```js\n    //    for (i of a.entries())\n    //      if (!b.has(i[0])) return false;\n    //    ```\n    //\n    //    ... and convert to:\n    //\n    //    ```js\n    //    it = a.entries();\n    //    while (!(i = it.next()).done)\n    //      if (!b.has(i.value[0])) return false;\n    //    ```\n    //\n    //    **Note**: `i` access switches to `i.value`.\n    var it;\n    if (hasMap && a instanceof Map && b instanceof Map) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;\n      it = a.entries();\n      while (!(i = it.next()).done) if (!equal(i.value[1], b.get(i.value[0]))) return false;\n      return true;\n    }\n    if (hasSet && a instanceof Set && b instanceof Set) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;\n      return true;\n    }\n    // END: Modifications\n\n    if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;) if (a[i] !== b[i]) return false;\n      return true;\n    }\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    // START: Modifications:\n    // Apply guards for `Object.create(null)` handling. See:\n    // - https://github.com/FormidableLabs/react-fast-compare/issues/64\n    // - https://github.com/epoberezkin/fast-deep-equal/issues/49\n    if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString && typeof a.toString === 'function' && typeof b.toString === 'function') return a.toString() === b.toString();\n    // END: Modifications\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n    for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    // END: fast-deep-equal\n\n    // START: react-fast-compare\n    // custom handling for DOM elements\n    if (hasElementType && a instanceof Element) return false;\n\n    // custom handling for React/Preact\n    for (i = length; i-- !== 0;) {\n      if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner\n        // Preact-specific: avoid traversing Preact elements' __v and __o\n        //    __v = $_original / $_vnode\n        //    __o = $_owner\n        // These properties contain circular references and are not needed when\n        // comparing the actual elements (and not their owners)\n        // .$$typeof and ._store on just reasonable markers of elements\n\n        continue;\n      }\n\n      // all other properties should be traversed as usual\n      if (!equal(a[keys[i]], b[keys[i]])) return false;\n    }\n    // END: react-fast-compare\n\n    // START: fast-deep-equal\n    return true;\n  }\n  return a !== a && b !== b;\n}\n// end fast-deep-equal\n\nmodule.exports = function isEqual(a, b) {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if ((error.message || '').match(/stack|recursion/i)) {\n      // warn on circular references, don't crash\n      // browsers give this different errors name and messages:\n      // chrome/safari: \"RangeError\", \"Maximum call stack size exceeded\"\n      // firefox: \"InternalError\", too much recursion\"\n      // edge: \"Error\", \"Out of stack space\"\n      console.warn('react-fast-compare cannot handle circular refs');\n      return false;\n    }\n    // some other error. we should definitely know about these\n    throw error;\n  }\n};","import PropTypes from 'prop-types';\nimport withSideEffect from 'react-side-effect';\nimport isEqual from 'react-fast-compare';\nimport React from 'react';\nimport objectAssign from 'object-assign';\nvar ATTRIBUTE_NAMES = {\n  BODY: \"bodyAttributes\",\n  HTML: \"htmlAttributes\",\n  TITLE: \"titleAttributes\"\n};\nvar TAG_NAMES = {\n  BASE: \"base\",\n  BODY: \"body\",\n  HEAD: \"head\",\n  HTML: \"html\",\n  LINK: \"link\",\n  META: \"meta\",\n  NOSCRIPT: \"noscript\",\n  SCRIPT: \"script\",\n  STYLE: \"style\",\n  TITLE: \"title\"\n};\nvar VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(function (name) {\n  return TAG_NAMES[name];\n});\nvar TAG_PROPERTIES = {\n  CHARSET: \"charset\",\n  CSS_TEXT: \"cssText\",\n  HREF: \"href\",\n  HTTPEQUIV: \"http-equiv\",\n  INNER_HTML: \"innerHTML\",\n  ITEM_PROP: \"itemprop\",\n  NAME: \"name\",\n  PROPERTY: \"property\",\n  REL: \"rel\",\n  SRC: \"src\",\n  TARGET: \"target\"\n};\nvar REACT_TAG_MAP = {\n  accesskey: \"accessKey\",\n  charset: \"charSet\",\n  class: \"className\",\n  contenteditable: \"contentEditable\",\n  contextmenu: \"contextMenu\",\n  \"http-equiv\": \"httpEquiv\",\n  itemprop: \"itemProp\",\n  tabindex: \"tabIndex\"\n};\nvar HELMET_PROPS = {\n  DEFAULT_TITLE: \"defaultTitle\",\n  DEFER: \"defer\",\n  ENCODE_SPECIAL_CHARACTERS: \"encodeSpecialCharacters\",\n  ON_CHANGE_CLIENT_STATE: \"onChangeClientState\",\n  TITLE_TEMPLATE: \"titleTemplate\"\n};\nvar HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce(function (obj, key) {\n  obj[REACT_TAG_MAP[key]] = key;\n  return obj;\n}, {});\nvar SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];\nvar HELMET_ATTRIBUTE = \"data-react-helmet\";\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n  return target;\n};\nvar inherits = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\nvar objectWithoutProperties = function (obj, keys) {\n  var target = {};\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n  return target;\n};\nvar possibleConstructorReturn = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\nvar encodeSpecialCharacters = function encodeSpecialCharacters(str) {\n  var encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n  if (encode === false) {\n    return String(str);\n  }\n  return String(str).replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\").replace(/'/g, \"&#x27;\");\n};\nvar getTitleFromPropsList = function getTitleFromPropsList(propsList) {\n  var innermostTitle = getInnermostProperty(propsList, TAG_NAMES.TITLE);\n  var innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);\n  if (innermostTemplate && innermostTitle) {\n    // use function arg to avoid need to escape $ characters\n    return innermostTemplate.replace(/%s/g, function () {\n      return Array.isArray(innermostTitle) ? innermostTitle.join(\"\") : innermostTitle;\n    });\n  }\n  var innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);\n  return innermostTitle || innermostDefaultTitle || undefined;\n};\nvar getOnChangeClientState = function getOnChangeClientState(propsList) {\n  return getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || function () {};\n};\nvar getAttributesFromPropsList = function getAttributesFromPropsList(tagType, propsList) {\n  return propsList.filter(function (props) {\n    return typeof props[tagType] !== \"undefined\";\n  }).map(function (props) {\n    return props[tagType];\n  }).reduce(function (tagAttrs, current) {\n    return _extends({}, tagAttrs, current);\n  }, {});\n};\nvar getBaseTagFromPropsList = function getBaseTagFromPropsList(primaryAttributes, propsList) {\n  return propsList.filter(function (props) {\n    return typeof props[TAG_NAMES.BASE] !== \"undefined\";\n  }).map(function (props) {\n    return props[TAG_NAMES.BASE];\n  }).reverse().reduce(function (innermostBaseTag, tag) {\n    if (!innermostBaseTag.length) {\n      var keys = Object.keys(tag);\n      for (var i = 0; i < keys.length; i++) {\n        var attributeKey = keys[i];\n        var lowerCaseAttributeKey = attributeKey.toLowerCase();\n        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {\n          return innermostBaseTag.concat(tag);\n        }\n      }\n    }\n    return innermostBaseTag;\n  }, []);\n};\nvar getTagsFromPropsList = function getTagsFromPropsList(tagName, primaryAttributes, propsList) {\n  // Calculate list of tags, giving priority innermost component (end of the propslist)\n  var approvedSeenTags = {};\n  return propsList.filter(function (props) {\n    if (Array.isArray(props[tagName])) {\n      return true;\n    }\n    if (typeof props[tagName] !== \"undefined\") {\n      warn(\"Helmet: \" + tagName + \" should be of type \\\"Array\\\". Instead found type \\\"\" + _typeof(props[tagName]) + \"\\\"\");\n    }\n    return false;\n  }).map(function (props) {\n    return props[tagName];\n  }).reverse().reduce(function (approvedTags, instanceTags) {\n    var instanceSeenTags = {};\n    instanceTags.filter(function (tag) {\n      var primaryAttributeKey = void 0;\n      var keys = Object.keys(tag);\n      for (var i = 0; i < keys.length; i++) {\n        var attributeKey = keys[i];\n        var lowerCaseAttributeKey = attributeKey.toLowerCase();\n\n        // Special rule with link tags, since rel and href are both primary tags, rel takes priority\n        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === TAG_PROPERTIES.REL && tag[primaryAttributeKey].toLowerCase() === \"canonical\") && !(lowerCaseAttributeKey === TAG_PROPERTIES.REL && tag[lowerCaseAttributeKey].toLowerCase() === \"stylesheet\")) {\n          primaryAttributeKey = lowerCaseAttributeKey;\n        }\n        // Special case for innerHTML which doesn't work lowercased\n        if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === TAG_PROPERTIES.INNER_HTML || attributeKey === TAG_PROPERTIES.CSS_TEXT || attributeKey === TAG_PROPERTIES.ITEM_PROP)) {\n          primaryAttributeKey = attributeKey;\n        }\n      }\n      if (!primaryAttributeKey || !tag[primaryAttributeKey]) {\n        return false;\n      }\n      var value = tag[primaryAttributeKey].toLowerCase();\n      if (!approvedSeenTags[primaryAttributeKey]) {\n        approvedSeenTags[primaryAttributeKey] = {};\n      }\n      if (!instanceSeenTags[primaryAttributeKey]) {\n        instanceSeenTags[primaryAttributeKey] = {};\n      }\n      if (!approvedSeenTags[primaryAttributeKey][value]) {\n        instanceSeenTags[primaryAttributeKey][value] = true;\n        return true;\n      }\n      return false;\n    }).reverse().forEach(function (tag) {\n      return approvedTags.push(tag);\n    });\n\n    // Update seen tags with tags from this instance\n    var keys = Object.keys(instanceSeenTags);\n    for (var i = 0; i < keys.length; i++) {\n      var attributeKey = keys[i];\n      var tagUnion = objectAssign({}, approvedSeenTags[attributeKey], instanceSeenTags[attributeKey]);\n      approvedSeenTags[attributeKey] = tagUnion;\n    }\n    return approvedTags;\n  }, []).reverse();\n};\nvar getInnermostProperty = function getInnermostProperty(propsList, property) {\n  for (var i = propsList.length - 1; i >= 0; i--) {\n    var props = propsList[i];\n    if (props.hasOwnProperty(property)) {\n      return props[property];\n    }\n  }\n  return null;\n};\nvar reducePropsToState = function reducePropsToState(propsList) {\n  return {\n    baseTag: getBaseTagFromPropsList([TAG_PROPERTIES.HREF, TAG_PROPERTIES.TARGET], propsList),\n    bodyAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.BODY, propsList),\n    defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),\n    encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),\n    htmlAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.HTML, propsList),\n    linkTags: getTagsFromPropsList(TAG_NAMES.LINK, [TAG_PROPERTIES.REL, TAG_PROPERTIES.HREF], propsList),\n    metaTags: getTagsFromPropsList(TAG_NAMES.META, [TAG_PROPERTIES.NAME, TAG_PROPERTIES.CHARSET, TAG_PROPERTIES.HTTPEQUIV, TAG_PROPERTIES.PROPERTY, TAG_PROPERTIES.ITEM_PROP], propsList),\n    noscriptTags: getTagsFromPropsList(TAG_NAMES.NOSCRIPT, [TAG_PROPERTIES.INNER_HTML], propsList),\n    onChangeClientState: getOnChangeClientState(propsList),\n    scriptTags: getTagsFromPropsList(TAG_NAMES.SCRIPT, [TAG_PROPERTIES.SRC, TAG_PROPERTIES.INNER_HTML], propsList),\n    styleTags: getTagsFromPropsList(TAG_NAMES.STYLE, [TAG_PROPERTIES.CSS_TEXT], propsList),\n    title: getTitleFromPropsList(propsList),\n    titleAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.TITLE, propsList)\n  };\n};\nvar rafPolyfill = function () {\n  var clock = Date.now();\n  return function (callback) {\n    var currentTime = Date.now();\n    if (currentTime - clock > 16) {\n      clock = currentTime;\n      callback(currentTime);\n    } else {\n      setTimeout(function () {\n        rafPolyfill(callback);\n      }, 0);\n    }\n  };\n}();\nvar cafPolyfill = function cafPolyfill(id) {\n  return clearTimeout(id);\n};\nvar requestAnimationFrame = typeof window !== \"undefined\" ? window.requestAnimationFrame && window.requestAnimationFrame.bind(window) || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || rafPolyfill : global.requestAnimationFrame || rafPolyfill;\nvar cancelAnimationFrame = typeof window !== \"undefined\" ? window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || cafPolyfill : global.cancelAnimationFrame || cafPolyfill;\nvar warn = function warn(msg) {\n  return console && typeof console.warn === \"function\" && console.warn(msg);\n};\nvar _helmetCallback = null;\nvar handleClientStateChange = function handleClientStateChange(newState) {\n  if (_helmetCallback) {\n    cancelAnimationFrame(_helmetCallback);\n  }\n  if (newState.defer) {\n    _helmetCallback = requestAnimationFrame(function () {\n      commitTagChanges(newState, function () {\n        _helmetCallback = null;\n      });\n    });\n  } else {\n    commitTagChanges(newState);\n    _helmetCallback = null;\n  }\n};\nvar commitTagChanges = function commitTagChanges(newState, cb) {\n  var baseTag = newState.baseTag,\n    bodyAttributes = newState.bodyAttributes,\n    htmlAttributes = newState.htmlAttributes,\n    linkTags = newState.linkTags,\n    metaTags = newState.metaTags,\n    noscriptTags = newState.noscriptTags,\n    onChangeClientState = newState.onChangeClientState,\n    scriptTags = newState.scriptTags,\n    styleTags = newState.styleTags,\n    title = newState.title,\n    titleAttributes = newState.titleAttributes;\n  updateAttributes(TAG_NAMES.BODY, bodyAttributes);\n  updateAttributes(TAG_NAMES.HTML, htmlAttributes);\n  updateTitle(title, titleAttributes);\n  var tagUpdates = {\n    baseTag: updateTags(TAG_NAMES.BASE, baseTag),\n    linkTags: updateTags(TAG_NAMES.LINK, linkTags),\n    metaTags: updateTags(TAG_NAMES.META, metaTags),\n    noscriptTags: updateTags(TAG_NAMES.NOSCRIPT, noscriptTags),\n    scriptTags: updateTags(TAG_NAMES.SCRIPT, scriptTags),\n    styleTags: updateTags(TAG_NAMES.STYLE, styleTags)\n  };\n  var addedTags = {};\n  var removedTags = {};\n  Object.keys(tagUpdates).forEach(function (tagType) {\n    var _tagUpdates$tagType = tagUpdates[tagType],\n      newTags = _tagUpdates$tagType.newTags,\n      oldTags = _tagUpdates$tagType.oldTags;\n    if (newTags.length) {\n      addedTags[tagType] = newTags;\n    }\n    if (oldTags.length) {\n      removedTags[tagType] = tagUpdates[tagType].oldTags;\n    }\n  });\n  cb && cb();\n  onChangeClientState(newState, addedTags, removedTags);\n};\nvar flattenArray = function flattenArray(possibleArray) {\n  return Array.isArray(possibleArray) ? possibleArray.join(\"\") : possibleArray;\n};\nvar updateTitle = function updateTitle(title, attributes) {\n  if (typeof title !== \"undefined\" && document.title !== title) {\n    document.title = flattenArray(title);\n  }\n  updateAttributes(TAG_NAMES.TITLE, attributes);\n};\nvar updateAttributes = function updateAttributes(tagName, attributes) {\n  var elementTag = document.getElementsByTagName(tagName)[0];\n  if (!elementTag) {\n    return;\n  }\n  var helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);\n  var helmetAttributes = helmetAttributeString ? helmetAttributeString.split(\",\") : [];\n  var attributesToRemove = [].concat(helmetAttributes);\n  var attributeKeys = Object.keys(attributes);\n  for (var i = 0; i < attributeKeys.length; i++) {\n    var attribute = attributeKeys[i];\n    var value = attributes[attribute] || \"\";\n    if (elementTag.getAttribute(attribute) !== value) {\n      elementTag.setAttribute(attribute, value);\n    }\n    if (helmetAttributes.indexOf(attribute) === -1) {\n      helmetAttributes.push(attribute);\n    }\n    var indexToSave = attributesToRemove.indexOf(attribute);\n    if (indexToSave !== -1) {\n      attributesToRemove.splice(indexToSave, 1);\n    }\n  }\n  for (var _i = attributesToRemove.length - 1; _i >= 0; _i--) {\n    elementTag.removeAttribute(attributesToRemove[_i]);\n  }\n  if (helmetAttributes.length === attributesToRemove.length) {\n    elementTag.removeAttribute(HELMET_ATTRIBUTE);\n  } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(\",\")) {\n    elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(\",\"));\n  }\n};\nvar updateTags = function updateTags(type, tags) {\n  var headElement = document.head || document.querySelector(TAG_NAMES.HEAD);\n  var tagNodes = headElement.querySelectorAll(type + \"[\" + HELMET_ATTRIBUTE + \"]\");\n  var oldTags = Array.prototype.slice.call(tagNodes);\n  var newTags = [];\n  var indexToDelete = void 0;\n  if (tags && tags.length) {\n    tags.forEach(function (tag) {\n      var newElement = document.createElement(type);\n      for (var attribute in tag) {\n        if (tag.hasOwnProperty(attribute)) {\n          if (attribute === TAG_PROPERTIES.INNER_HTML) {\n            newElement.innerHTML = tag.innerHTML;\n          } else if (attribute === TAG_PROPERTIES.CSS_TEXT) {\n            if (newElement.styleSheet) {\n              newElement.styleSheet.cssText = tag.cssText;\n            } else {\n              newElement.appendChild(document.createTextNode(tag.cssText));\n            }\n          } else {\n            var value = typeof tag[attribute] === \"undefined\" ? \"\" : tag[attribute];\n            newElement.setAttribute(attribute, value);\n          }\n        }\n      }\n      newElement.setAttribute(HELMET_ATTRIBUTE, \"true\");\n\n      // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.\n      if (oldTags.some(function (existingTag, index) {\n        indexToDelete = index;\n        return newElement.isEqualNode(existingTag);\n      })) {\n        oldTags.splice(indexToDelete, 1);\n      } else {\n        newTags.push(newElement);\n      }\n    });\n  }\n  oldTags.forEach(function (tag) {\n    return tag.parentNode.removeChild(tag);\n  });\n  newTags.forEach(function (tag) {\n    return headElement.appendChild(tag);\n  });\n  return {\n    oldTags: oldTags,\n    newTags: newTags\n  };\n};\nvar generateElementAttributesAsString = function generateElementAttributesAsString(attributes) {\n  return Object.keys(attributes).reduce(function (str, key) {\n    var attr = typeof attributes[key] !== \"undefined\" ? key + \"=\\\"\" + attributes[key] + \"\\\"\" : \"\" + key;\n    return str ? str + \" \" + attr : attr;\n  }, \"\");\n};\nvar generateTitleAsString = function generateTitleAsString(type, title, attributes, encode) {\n  var attributeString = generateElementAttributesAsString(attributes);\n  var flattenedTitle = flattenArray(title);\n  return attributeString ? \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeString + \">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\" : \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\";\n};\nvar generateTagsAsString = function generateTagsAsString(type, tags, encode) {\n  return tags.reduce(function (str, tag) {\n    var attributeHtml = Object.keys(tag).filter(function (attribute) {\n      return !(attribute === TAG_PROPERTIES.INNER_HTML || attribute === TAG_PROPERTIES.CSS_TEXT);\n    }).reduce(function (string, attribute) {\n      var attr = typeof tag[attribute] === \"undefined\" ? attribute : attribute + \"=\\\"\" + encodeSpecialCharacters(tag[attribute], encode) + \"\\\"\";\n      return string ? string + \" \" + attr : attr;\n    }, \"\");\n    var tagContent = tag.innerHTML || tag.cssText || \"\";\n    var isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;\n    return str + \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeHtml + (isSelfClosing ? \"/>\" : \">\" + tagContent + \"</\" + type + \">\");\n  }, \"\");\n};\nvar convertElementAttributestoReactProps = function convertElementAttributestoReactProps(attributes) {\n  var initProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return Object.keys(attributes).reduce(function (obj, key) {\n    obj[REACT_TAG_MAP[key] || key] = attributes[key];\n    return obj;\n  }, initProps);\n};\nvar convertReactPropstoHtmlAttributes = function convertReactPropstoHtmlAttributes(props) {\n  var initAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return Object.keys(props).reduce(function (obj, key) {\n    obj[HTML_TAG_MAP[key] || key] = props[key];\n    return obj;\n  }, initAttributes);\n};\nvar generateTitleAsReactComponent = function generateTitleAsReactComponent(type, title, attributes) {\n  var _initProps;\n\n  // assigning into an array to define toString function on it\n  var initProps = (_initProps = {\n    key: title\n  }, _initProps[HELMET_ATTRIBUTE] = true, _initProps);\n  var props = convertElementAttributestoReactProps(attributes, initProps);\n  return [React.createElement(TAG_NAMES.TITLE, props, title)];\n};\nvar generateTagsAsReactComponent = function generateTagsAsReactComponent(type, tags) {\n  return tags.map(function (tag, i) {\n    var _mappedTag;\n    var mappedTag = (_mappedTag = {\n      key: i\n    }, _mappedTag[HELMET_ATTRIBUTE] = true, _mappedTag);\n    Object.keys(tag).forEach(function (attribute) {\n      var mappedAttribute = REACT_TAG_MAP[attribute] || attribute;\n      if (mappedAttribute === TAG_PROPERTIES.INNER_HTML || mappedAttribute === TAG_PROPERTIES.CSS_TEXT) {\n        var content = tag.innerHTML || tag.cssText;\n        mappedTag.dangerouslySetInnerHTML = {\n          __html: content\n        };\n      } else {\n        mappedTag[mappedAttribute] = tag[attribute];\n      }\n    });\n    return React.createElement(type, mappedTag);\n  });\n};\nvar getMethodsForTag = function getMethodsForTag(type, tags, encode) {\n  switch (type) {\n    case TAG_NAMES.TITLE:\n      return {\n        toComponent: function toComponent() {\n          return generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode);\n        },\n        toString: function toString() {\n          return generateTitleAsString(type, tags.title, tags.titleAttributes, encode);\n        }\n      };\n    case ATTRIBUTE_NAMES.BODY:\n    case ATTRIBUTE_NAMES.HTML:\n      return {\n        toComponent: function toComponent() {\n          return convertElementAttributestoReactProps(tags);\n        },\n        toString: function toString() {\n          return generateElementAttributesAsString(tags);\n        }\n      };\n    default:\n      return {\n        toComponent: function toComponent() {\n          return generateTagsAsReactComponent(type, tags);\n        },\n        toString: function toString() {\n          return generateTagsAsString(type, tags, encode);\n        }\n      };\n  }\n};\nvar mapStateOnServer = function mapStateOnServer(_ref) {\n  var baseTag = _ref.baseTag,\n    bodyAttributes = _ref.bodyAttributes,\n    encode = _ref.encode,\n    htmlAttributes = _ref.htmlAttributes,\n    linkTags = _ref.linkTags,\n    metaTags = _ref.metaTags,\n    noscriptTags = _ref.noscriptTags,\n    scriptTags = _ref.scriptTags,\n    styleTags = _ref.styleTags,\n    _ref$title = _ref.title,\n    title = _ref$title === undefined ? \"\" : _ref$title,\n    titleAttributes = _ref.titleAttributes;\n  return {\n    base: getMethodsForTag(TAG_NAMES.BASE, baseTag, encode),\n    bodyAttributes: getMethodsForTag(ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),\n    htmlAttributes: getMethodsForTag(ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),\n    link: getMethodsForTag(TAG_NAMES.LINK, linkTags, encode),\n    meta: getMethodsForTag(TAG_NAMES.META, metaTags, encode),\n    noscript: getMethodsForTag(TAG_NAMES.NOSCRIPT, noscriptTags, encode),\n    script: getMethodsForTag(TAG_NAMES.SCRIPT, scriptTags, encode),\n    style: getMethodsForTag(TAG_NAMES.STYLE, styleTags, encode),\n    title: getMethodsForTag(TAG_NAMES.TITLE, {\n      title: title,\n      titleAttributes: titleAttributes\n    }, encode)\n  };\n};\nvar Helmet = function Helmet(Component) {\n  var _class, _temp;\n  return _temp = _class = function (_React$Component) {\n    inherits(HelmetWrapper, _React$Component);\n    function HelmetWrapper() {\n      classCallCheck(this, HelmetWrapper);\n      return possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n    }\n    HelmetWrapper.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n      return !isEqual(this.props, nextProps);\n    };\n    HelmetWrapper.prototype.mapNestedChildrenToProps = function mapNestedChildrenToProps(child, nestedChildren) {\n      if (!nestedChildren) {\n        return null;\n      }\n      switch (child.type) {\n        case TAG_NAMES.SCRIPT:\n        case TAG_NAMES.NOSCRIPT:\n          return {\n            innerHTML: nestedChildren\n          };\n        case TAG_NAMES.STYLE:\n          return {\n            cssText: nestedChildren\n          };\n      }\n      throw new Error(\"<\" + child.type + \" /> elements are self-closing and can not contain children. Refer to our API for more information.\");\n    };\n    HelmetWrapper.prototype.flattenArrayTypeChildren = function flattenArrayTypeChildren(_ref) {\n      var _babelHelpers$extends;\n      var child = _ref.child,\n        arrayTypeChildren = _ref.arrayTypeChildren,\n        newChildProps = _ref.newChildProps,\n        nestedChildren = _ref.nestedChildren;\n      return _extends({}, arrayTypeChildren, (_babelHelpers$extends = {}, _babelHelpers$extends[child.type] = [].concat(arrayTypeChildren[child.type] || [], [_extends({}, newChildProps, this.mapNestedChildrenToProps(child, nestedChildren))]), _babelHelpers$extends));\n    };\n    HelmetWrapper.prototype.mapObjectTypeChildren = function mapObjectTypeChildren(_ref2) {\n      var _babelHelpers$extends2, _babelHelpers$extends3;\n      var child = _ref2.child,\n        newProps = _ref2.newProps,\n        newChildProps = _ref2.newChildProps,\n        nestedChildren = _ref2.nestedChildren;\n      switch (child.type) {\n        case TAG_NAMES.TITLE:\n          return _extends({}, newProps, (_babelHelpers$extends2 = {}, _babelHelpers$extends2[child.type] = nestedChildren, _babelHelpers$extends2.titleAttributes = _extends({}, newChildProps), _babelHelpers$extends2));\n        case TAG_NAMES.BODY:\n          return _extends({}, newProps, {\n            bodyAttributes: _extends({}, newChildProps)\n          });\n        case TAG_NAMES.HTML:\n          return _extends({}, newProps, {\n            htmlAttributes: _extends({}, newChildProps)\n          });\n      }\n      return _extends({}, newProps, (_babelHelpers$extends3 = {}, _babelHelpers$extends3[child.type] = _extends({}, newChildProps), _babelHelpers$extends3));\n    };\n    HelmetWrapper.prototype.mapArrayTypeChildrenToProps = function mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {\n      var newFlattenedProps = _extends({}, newProps);\n      Object.keys(arrayTypeChildren).forEach(function (arrayChildName) {\n        var _babelHelpers$extends4;\n        newFlattenedProps = _extends({}, newFlattenedProps, (_babelHelpers$extends4 = {}, _babelHelpers$extends4[arrayChildName] = arrayTypeChildren[arrayChildName], _babelHelpers$extends4));\n      });\n      return newFlattenedProps;\n    };\n    HelmetWrapper.prototype.warnOnInvalidChildren = function warnOnInvalidChildren(child, nestedChildren) {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (!VALID_TAG_NAMES.some(function (name) {\n          return child.type === name;\n        })) {\n          if (typeof child.type === \"function\") {\n            return warn(\"You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.\");\n          }\n          return warn(\"Only elements types \" + VALID_TAG_NAMES.join(\", \") + \" are allowed. Helmet does not support rendering <\" + child.type + \"> elements. Refer to our API for more information.\");\n        }\n        if (nestedChildren && typeof nestedChildren !== \"string\" && (!Array.isArray(nestedChildren) || nestedChildren.some(function (nestedChild) {\n          return typeof nestedChild !== \"string\";\n        }))) {\n          throw new Error(\"Helmet expects a string as a child of <\" + child.type + \">. Did you forget to wrap your children in braces? ( <\" + child.type + \">{``}</\" + child.type + \"> ) Refer to our API for more information.\");\n        }\n      }\n      return true;\n    };\n    HelmetWrapper.prototype.mapChildrenToProps = function mapChildrenToProps(children, newProps) {\n      var _this2 = this;\n      var arrayTypeChildren = {};\n      React.Children.forEach(children, function (child) {\n        if (!child || !child.props) {\n          return;\n        }\n        var _child$props = child.props,\n          nestedChildren = _child$props.children,\n          childProps = objectWithoutProperties(_child$props, [\"children\"]);\n        var newChildProps = convertReactPropstoHtmlAttributes(childProps);\n        _this2.warnOnInvalidChildren(child, nestedChildren);\n        switch (child.type) {\n          case TAG_NAMES.LINK:\n          case TAG_NAMES.META:\n          case TAG_NAMES.NOSCRIPT:\n          case TAG_NAMES.SCRIPT:\n          case TAG_NAMES.STYLE:\n            arrayTypeChildren = _this2.flattenArrayTypeChildren({\n              child: child,\n              arrayTypeChildren: arrayTypeChildren,\n              newChildProps: newChildProps,\n              nestedChildren: nestedChildren\n            });\n            break;\n          default:\n            newProps = _this2.mapObjectTypeChildren({\n              child: child,\n              newProps: newProps,\n              newChildProps: newChildProps,\n              nestedChildren: nestedChildren\n            });\n            break;\n        }\n      });\n      newProps = this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);\n      return newProps;\n    };\n    HelmetWrapper.prototype.render = function render() {\n      var _props = this.props,\n        children = _props.children,\n        props = objectWithoutProperties(_props, [\"children\"]);\n      var newProps = _extends({}, props);\n      if (children) {\n        newProps = this.mapChildrenToProps(children, newProps);\n      }\n      return React.createElement(Component, newProps);\n    };\n    createClass(HelmetWrapper, null, [{\n      key: \"canUseDOM\",\n      // Component.peek comes from react-side-effect:\n      // For testing, you may use a static peek() method available on the returned component.\n      // It lets you get the current state without resetting the mounted instance stack.\n      // Don’t use it for anything other than testing.\n\n      /**\n       * @param {Object} base: {\"target\": \"_blank\", \"href\": \"http://mysite.com/\"}\n       * @param {Object} bodyAttributes: {\"className\": \"root\"}\n       * @param {String} defaultTitle: \"Default Title\"\n       * @param {Boolean} defer: true\n       * @param {Boolean} encodeSpecialCharacters: true\n       * @param {Object} htmlAttributes: {\"lang\": \"en\", \"amp\": undefined}\n       * @param {Array} link: [{\"rel\": \"canonical\", \"href\": \"http://mysite.com/example\"}]\n       * @param {Array} meta: [{\"name\": \"description\", \"content\": \"Test description\"}]\n       * @param {Array} noscript: [{\"innerHTML\": \"<img src='http://mysite.com/js/test.js'\"}]\n       * @param {Function} onChangeClientState: \"(newState) => console.log(newState)\"\n       * @param {Array} script: [{\"type\": \"text/javascript\", \"src\": \"http://mysite.com/js/test.js\"}]\n       * @param {Array} style: [{\"type\": \"text/css\", \"cssText\": \"div { display: block; color: blue; }\"}]\n       * @param {String} title: \"Title\"\n       * @param {Object} titleAttributes: {\"itemprop\": \"name\"}\n       * @param {String} titleTemplate: \"MySite.com - %s\"\n       */\n      set: function set$$1(canUseDOM) {\n        Component.canUseDOM = canUseDOM;\n      }\n    }]);\n    return HelmetWrapper;\n  }(React.Component), _class.propTypes = {\n    base: PropTypes.object,\n    bodyAttributes: PropTypes.object,\n    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),\n    defaultTitle: PropTypes.string,\n    defer: PropTypes.bool,\n    encodeSpecialCharacters: PropTypes.bool,\n    htmlAttributes: PropTypes.object,\n    link: PropTypes.arrayOf(PropTypes.object),\n    meta: PropTypes.arrayOf(PropTypes.object),\n    noscript: PropTypes.arrayOf(PropTypes.object),\n    onChangeClientState: PropTypes.func,\n    script: PropTypes.arrayOf(PropTypes.object),\n    style: PropTypes.arrayOf(PropTypes.object),\n    title: PropTypes.string,\n    titleAttributes: PropTypes.object,\n    titleTemplate: PropTypes.string\n  }, _class.defaultProps = {\n    defer: true,\n    encodeSpecialCharacters: true\n  }, _class.peek = Component.peek, _class.rewind = function () {\n    var mappedState = Component.rewind();\n    if (!mappedState) {\n      // provide fallback if mappedState is undefined\n      mappedState = mapStateOnServer({\n        baseTag: [],\n        bodyAttributes: {},\n        encodeSpecialCharacters: true,\n        htmlAttributes: {},\n        linkTags: [],\n        metaTags: [],\n        noscriptTags: [],\n        scriptTags: [],\n        styleTags: [],\n        title: \"\",\n        titleAttributes: {}\n      });\n    }\n    return mappedState;\n  }, _temp;\n};\nvar NullComponent = function NullComponent() {\n  return null;\n};\nvar HelmetSideEffects = withSideEffect(reducePropsToState, handleClientStateChange, mapStateOnServer)(NullComponent);\nvar HelmetExport = Helmet(HelmetSideEffects);\nHelmetExport.renderStatic = HelmetExport.rewind;\nexport default HelmetExport;\nexport { HelmetExport as Helmet };","'use strict';\n\nfunction _interopDefault(ex) {\n  return ex && typeof ex === 'object' && 'default' in ex ? ex['default'] : ex;\n}\nvar React = require('react');\nvar React__default = _interopDefault(React);\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {\n  if (typeof reducePropsToState !== 'function') {\n    throw new Error('Expected reducePropsToState to be a function.');\n  }\n  if (typeof handleStateChangeOnClient !== 'function') {\n    throw new Error('Expected handleStateChangeOnClient to be a function.');\n  }\n  if (typeof mapStateOnServer !== 'undefined' && typeof mapStateOnServer !== 'function') {\n    throw new Error('Expected mapStateOnServer to either be undefined or a function.');\n  }\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n  return function wrap(WrappedComponent) {\n    if (typeof WrappedComponent !== 'function') {\n      throw new Error('Expected WrappedComponent to be a React component.');\n    }\n    var mountedInstances = [];\n    var state;\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n      if (SideEffect.canUseDOM) {\n        handleStateChangeOnClient(state);\n      } else if (mapStateOnServer) {\n        state = mapStateOnServer(state);\n      }\n    }\n    var SideEffect = /*#__PURE__*/\n    function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      }\n\n      // Try to use displayName of wrapped component\n      // Expose canUseDOM so tests can monkeypatch it\n      SideEffect.peek = function peek() {\n        return state;\n      };\n      SideEffect.rewind = function rewind() {\n        if (SideEffect.canUseDOM) {\n          throw new Error('You may only call rewind() on the server. Call peek() to read the current state.');\n        }\n        var recordedState = state;\n        state = undefined;\n        mountedInstances = [];\n        return recordedState;\n      };\n      var _proto = SideEffect.prototype;\n      _proto.UNSAFE_componentWillMount = function UNSAFE_componentWillMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n      _proto.render = function render() {\n        return React__default.createElement(WrappedComponent, this.props);\n      };\n      return SideEffect;\n    }(React.PureComponent);\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n    _defineProperty(SideEffect, \"canUseDOM\", canUseDOM);\n    return SideEffect;\n  };\n}\nmodule.exports = withSideEffect;","import { rgba } from './rgba.js';\nimport { isColorString } from './utils.js';\nfunction parseHex(v) {\n  var r = '';\n  var g = '';\n  var b = '';\n  var a = '';\n  if (v.length > 5) {\n    r = v.substr(1, 2);\n    g = v.substr(3, 2);\n    b = v.substr(5, 2);\n    a = v.substr(7, 2);\n  } else {\n    r = v.substr(1, 1);\n    g = v.substr(2, 1);\n    b = v.substr(3, 1);\n    a = v.substr(4, 1);\n    r += r;\n    g += g;\n    b += b;\n    a += a;\n  }\n  return {\n    red: parseInt(r, 16),\n    green: parseInt(g, 16),\n    blue: parseInt(b, 16),\n    alpha: a ? parseInt(a, 16) / 255 : 1\n  };\n}\nvar hex = {\n  test: isColorString('#'),\n  parse: parseHex,\n  transform: rgba.transform\n};\nexport { hex };","import { alpha } from '../numbers/index.js';\nimport { percent } from '../numbers/units.js';\nimport { sanitize } from '../utils.js';\nimport { isColorString, splitColor } from './utils.js';\nvar hsla = {\n  test: isColorString('hsl', 'hue'),\n  parse: splitColor('hue', 'saturation', 'lightness'),\n  transform: function (_a) {\n    var hue = _a.hue,\n      saturation = _a.saturation,\n      lightness = _a.lightness,\n      _b = _a.alpha,\n      alpha$1 = _b === void 0 ? 1 : _b;\n    return 'hsla(' + Math.round(hue) + ', ' + percent.transform(sanitize(saturation)) + ', ' + percent.transform(sanitize(lightness)) + ', ' + sanitize(alpha.transform(alpha$1)) + ')';\n  }\n};\nexport { hsla };","import { isString } from '../utils.js';\nimport { hex } from './hex.js';\nimport { hsla } from './hsla.js';\nimport { rgba } from './rgba.js';\nvar color = {\n  test: function (v) {\n    return rgba.test(v) || hex.test(v) || hsla.test(v);\n  },\n  parse: function (v) {\n    if (rgba.test(v)) {\n      return rgba.parse(v);\n    } else if (hsla.test(v)) {\n      return hsla.parse(v);\n    } else {\n      return hex.parse(v);\n    }\n  },\n  transform: function (v) {\n    return isString(v) ? v : v.hasOwnProperty('red') ? rgba.transform(v) : hsla.transform(v);\n  }\n};\nexport { color };","import { __assign } from 'tslib';\nimport { number, alpha } from '../numbers/index.js';\nimport { sanitize, clamp } from '../utils.js';\nimport { isColorString, splitColor } from './utils.js';\nvar clampRgbUnit = clamp(0, 255);\nvar rgbUnit = __assign(__assign({}, number), {\n  transform: function (v) {\n    return Math.round(clampRgbUnit(v));\n  }\n});\nvar rgba = {\n  test: isColorString('rgb', 'red'),\n  parse: splitColor('red', 'green', 'blue'),\n  transform: function (_a) {\n    var red = _a.red,\n      green = _a.green,\n      blue = _a.blue,\n      _b = _a.alpha,\n      alpha$1 = _b === void 0 ? 1 : _b;\n    return 'rgba(' + rgbUnit.transform(red) + ', ' + rgbUnit.transform(green) + ', ' + rgbUnit.transform(blue) + ', ' + sanitize(alpha.transform(alpha$1)) + ')';\n  }\n};\nexport { rgbUnit, rgba };","import { isString, singleColorRegex, floatRegex } from '../utils.js';\nvar isColorString = function (type, testProp) {\n  return function (v) {\n    return Boolean(isString(v) && singleColorRegex.test(v) && v.startsWith(type) || testProp && Object.prototype.hasOwnProperty.call(v, testProp));\n  };\n};\nvar splitColor = function (aName, bName, cName) {\n  return function (v) {\n    var _a;\n    if (!isString(v)) return v;\n    var _b = v.match(floatRegex),\n      a = _b[0],\n      b = _b[1],\n      c = _b[2],\n      alpha = _b[3];\n    return _a = {}, _a[aName] = parseFloat(a), _a[bName] = parseFloat(b), _a[cName] = parseFloat(c), _a.alpha = alpha !== undefined ? parseFloat(alpha) : 1, _a;\n  };\n};\nexport { isColorString, splitColor };","import { __assign } from 'tslib';\nimport { complex } from './index.js';\nimport { floatRegex } from '../utils.js';\nvar maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n  var _a = v.slice(0, -1).split('('),\n    name = _a[0],\n    value = _a[1];\n  if (name === 'drop-shadow') return v;\n  var number = (value.match(floatRegex) || [])[0];\n  if (!number) return v;\n  var unit = value.replace(number, '');\n  var defaultValue = maxDefaults.has(name) ? 1 : 0;\n  if (number !== value) defaultValue *= 100;\n  return name + '(' + defaultValue + unit + ')';\n}\nvar functionRegex = /([a-z-]*)\\(.*?\\)/g;\nvar filter = __assign(__assign({}, complex), {\n  getAnimatableNone: function (v) {\n    var functions = v.match(functionRegex);\n    return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n  }\n});\nexport { filter };","import { color } from '../color/index.js';\nimport { number } from '../numbers/index.js';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.js';\nvar colorToken = '${c}';\nvar numberToken = '${n}';\nfunction test(v) {\n  var _a, _b, _c, _d;\n  return isNaN(v) && isString(v) && ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;\n}\nfunction analyse(v) {\n  var values = [];\n  var numColors = 0;\n  var colors = v.match(colorRegex);\n  if (colors) {\n    numColors = colors.length;\n    v = v.replace(colorRegex, colorToken);\n    values.push.apply(values, colors.map(color.parse));\n  }\n  var numbers = v.match(floatRegex);\n  if (numbers) {\n    v = v.replace(floatRegex, numberToken);\n    values.push.apply(values, numbers.map(number.parse));\n  }\n  return {\n    values: values,\n    numColors: numColors,\n    tokenised: v\n  };\n}\nfunction parse(v) {\n  return analyse(v).values;\n}\nfunction createTransformer(v) {\n  var _a = analyse(v),\n    values = _a.values,\n    numColors = _a.numColors,\n    tokenised = _a.tokenised;\n  var numValues = values.length;\n  return function (v) {\n    var output = tokenised;\n    for (var i = 0; i < numValues; i++) {\n      output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n    }\n    return output;\n  };\n}\nvar convertNumbersToZero = function (v) {\n  return typeof v === 'number' ? 0 : v;\n};\nfunction getAnimatableNone(v) {\n  var parsed = parse(v);\n  var transformer = createTransformer(v);\n  return transformer(parsed.map(convertNumbersToZero));\n}\nvar complex = {\n  test: test,\n  parse: parse,\n  createTransformer: createTransformer,\n  getAnimatableNone: getAnimatableNone\n};\nexport { complex };","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nexports.__esModule = true;\nvar _exportNames = {\n  Link: true,\n  withIntl: true,\n  navigate: true,\n  changeLocale: true,\n  IntlContextProvider: true,\n  IntlContextConsumer: true\n};\nexports.IntlContextConsumer = exports.IntlContextProvider = exports.changeLocale = exports.navigate = exports.withIntl = exports.Link = void 0;\n\nvar _reactIntl = require(\"react-intl\");\n\nObject.keys(_reactIntl).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;\n  exports[key] = _reactIntl[key];\n});\n\nvar _link = _interopRequireWildcard(require(\"./link\"));\n\nexports.Link = _link.default;\nexports.navigate = _link.navigate;\nexports.changeLocale = _link.changeLocale;\n\nvar _withIntl = _interopRequireDefault(require(\"./with-intl\"));\n\nexports.withIntl = _withIntl.default;\n\nvar _intlContext = require(\"./intl-context\");\n\nexports.IntlContextProvider = _intlContext.IntlContextProvider;\nexports.IntlContextConsumer = _intlContext.IntlContextConsumer;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.changeLocale = exports.navigate = exports.default = void 0;\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _objectWithoutPropertiesLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectWithoutPropertiesLoose\"));\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _gatsby = require(\"gatsby\");\n\nvar _intlContext = require(\"./intl-context\");\n\nvar Link = function Link(_ref) {\n  var to = _ref.to,\n      language = _ref.language,\n      children = _ref.children,\n      onClick = _ref.onClick,\n      rest = (0, _objectWithoutPropertiesLoose2.default)(_ref, [\"to\", \"language\", \"children\", \"onClick\"]);\n  return _react.default.createElement(_intlContext.IntlContextConsumer, null, function (intl) {\n    var languageLink = language || intl.language;\n    var link = intl.routed || language ? \"/\" + languageLink + to : \"\" + to;\n\n    var handleClick = function handleClick(e) {\n      if (language) {\n        localStorage.setItem(\"gatsby-intl-language\", language);\n      }\n\n      if (onClick) {\n        onClick(e);\n      }\n    };\n\n    return _react.default.createElement(_gatsby.Link, (0, _extends2.default)({}, rest, {\n      to: link,\n      onClick: handleClick\n    }), children);\n  });\n};\n\nLink.propTypes = {\n  children: _propTypes.default.node.isRequired,\n  to: _propTypes.default.string,\n  language: _propTypes.default.string\n};\nLink.defaultProps = {\n  to: \"\"\n};\nvar _default = Link;\nexports.default = _default;\n\nvar navigate = function navigate(to, options) {\n  if (typeof window === \"undefined\") {\n    return;\n  }\n\n  var _window$___gatsbyIntl = window.___gatsbyIntl,\n      language = _window$___gatsbyIntl.language,\n      routed = _window$___gatsbyIntl.routed;\n  var link = routed ? \"/\" + language + to : \"\" + to;\n  (0, _gatsby.navigate)(link, options);\n};\n\nexports.navigate = navigate;\n\nvar changeLocale = function changeLocale(language, to) {\n  if (typeof window === \"undefined\") {\n    return;\n  }\n\n  var routed = window.___gatsbyIntl.routed;\n\n  var removePrefix = function removePrefix(pathname) {\n    var base = typeof __BASE_PATH__ !== \"undefined\" ? __BASE_PATH__ : __PATH_PREFIX__;\n\n    if (base && pathname.indexOf(base) === 0) {\n      pathname = pathname.slice(base.length);\n    }\n\n    return pathname;\n  };\n\n  var removeLocalePart = function removeLocalePart(pathname) {\n    if (!routed) {\n      return pathname;\n    }\n\n    var i = pathname.indexOf(\"/\", 1);\n    return pathname.substring(i);\n  };\n\n  var pathname = to || removeLocalePart(removePrefix(window.location.pathname)); // TODO: check slash\n\n  var link = \"/\" + language + pathname + window.location.search;\n  localStorage.setItem(\"gatsby-intl-language\", language);\n  (0, _gatsby.navigate)(link);\n};\n\nexports.changeLocale = changeLocale;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _reactIntl = require(\"react-intl\");\n\nvar _default = function _default(Component) {\n  return function (props) {\n    console.warn(\"withIntl is deprecated. Please use injectIntl instead.\");\n    return _react.default.createElement((0, _reactIntl.injectIntl)(Component), props);\n  };\n};\n\nexports.default = _default;","import React, { forwardRef } from 'react'\nimport PropTypes from 'prop-types'\nimport { Link } from 'gatsby'\n\nimport { shouldNavigate } from '../utils/shouldNavigate'\nimport { triggerTransition } from '../utils/triggerTransition'\nimport { Consumer } from '../context/createTransitionContext'\n\nif (typeof forwardRef === 'undefined') {\n\tforwardRef = C => C\n}\n\nconst TransitionLink = forwardRef(\n\t(\n\t\t{\n\t\t\tto,\n\t\t\tchildren,\n\t\t\texit,\n\t\t\tentry,\n\t\t\tactiveStyle,\n\t\t\tpartiallyActive,\n\t\t\tstyle,\n\t\t\tclassName,\n\t\t\tactiveClassName,\n\t\t\tstate,\n\t\t\tonClick,\n\t\t\ttrigger,\n\t\t\treplace,\n\t\t\tinnerRef,\n\t\t\tpreventScrollJump,\n\t\t\t...rest\n\t\t},\n\t\tref\n\t) => {\n\t\treturn (\n\t\t\t<Consumer>\n\t\t\t\t{({ disableAnimation, ...context }) => (\n\t\t\t\t\t<Link\n\t\t\t\t\t\tstyle={style}\n\t\t\t\t\t\tactiveStyle={activeStyle}\n\t\t\t\t\t\tclassName={className}\n\t\t\t\t\t\tactiveClassName={activeClassName}\n\t\t\t\t\t\tpartiallyActive={partiallyActive}\n\t\t\t\t\t\tonClick={event => {\n\t\t\t\t\t\t\t// If the user has set their browser or OS to prefers-reduced-motion\n\t\t\t\t\t\t\t// we should respect that.\n\t\t\t\t\t\t\tif (disableAnimation) {\n\t\t\t\t\t\t\t\treturn\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tconst weShouldNavigate = shouldNavigate(event)\n\n\t\t\t\t\t\t\tif (weShouldNavigate) {\n\t\t\t\t\t\t\t\ttriggerTransition({\n\t\t\t\t\t\t\t\t\tevent,\n\t\t\t\t\t\t\t\t\tto,\n\t\t\t\t\t\t\t\t\texit,\n\t\t\t\t\t\t\t\t\tentry,\n\t\t\t\t\t\t\t\t\ttrigger,\n\t\t\t\t\t\t\t\t\treplace,\n\t\t\t\t\t\t\t\t\tpreventScrollJump,\n\t\t\t\t\t\t\t\t\tlinkState: state,\n\t\t\t\t\t\t\t\t\t...context,\n\t\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif (typeof onClick === 'function') {\n\t\t\t\t\t\t\t\tonClick(event, weShouldNavigate)\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}}\n\t\t\t\t\t\tto={to} // use gatsby link so prefetching still happens. this is prevent defaulted in triggertransition\n\t\t\t\t\t\tref={ref || innerRef}\n\t\t\t\t\t\t{...rest}>\n\t\t\t\t\t\t{children}\n\t\t\t\t\t</Link>\n\t\t\t\t)}\n\t\t\t</Consumer>\n\t\t)\n\t}\n)\n\nTransitionLink.propTypes = {\n\tto: PropTypes.string.isRequired,\n\texitLength: PropTypes.number,\n\tentryDelay: PropTypes.number,\n\texitFn: PropTypes.func,\n\tentryState: PropTypes.object,\n}\n\nexport { TransitionLink }\n","import { useRef, useContext, useEffect, useState } from 'react'\n\nimport { publicContext } from '../context/createTransitionContext'\n\nfunction TransitionObserver(props) {\n\tconst innerRef = useRef(null)\n\tconst context = useContext(publicContext)\n\tconst [contextState, updateContextState] = useState(null)\n\tconst [observing, setObserving] = useState(false)\n\n\tconst observerSupport =\n\t\t'IntersectionObserver' in window &&\n\t\t'IntersectionObserverEntry' in window &&\n\t\t'intersectionRatio' in window.IntersectionObserverEntry.prototype\n\n\tuseEffect(() => {\n\t\tif (innerRef && innerRef.current) {\n\t\t\tlet observer\n\n\t\t\tconst options = {\n\t\t\t\tthreshold: 1,\n\t\t\t}\n\n\t\t\tobserver = new IntersectionObserver(observed => {\n\t\t\t\tconst [thisObserved] = observed\n\t\t\t\tsetObserving(!!thisObserved.intersectionRatio)\n\t\t\t}, options)\n\t\t\tobserver.observe(innerRef.current)\n\n\t\t\treturn () => observer.unobserve(innerRef.current)\n\t\t}\n\t}, [innerRef])\n\n\tuseEffect(() => {\n\t\tif (!observerSupport || props.forceRender) {\n\t\t\t// always update the context if there is no intersection\n\t\t\t// observer support or if the prop forceRender is set to true\n\t\t\tupdateContextState(context)\n\t\t} else if (observing) {\n\t\t\tupdateContextState(context)\n\t\t}\n\t}, [context.transitionStatus, innerRef, observing])\n\n\treturn props.children(contextState, innerRef)\n}\n\nexport default TransitionObserver\n","import React, { Component } from 'react'\nimport ReactDOM from 'react-dom'\n\nconst portalRoot = typeof document !== `undefined` ? document.body : false\n\nconst PortalContainer = props => {\n\tconst zIndex = (function(level) {\n\t\tswitch (level) {\n\t\t\tcase 'bottom':\n\t\t\t\treturn 1000\n\t\t\tcase 'top':\n\t\t\t\treturn 1200\n\t\t\tdefault:\n\t\t\t\treturn 1100\n\t\t}\n\t})(props.level)\n\n\treturn (\n\t\t<div\n\t\t\tclassName=\"gatsby-plugin-transition-link-portal\"\n\t\t\tstyle={{\n\t\t\t\tposition: 'fixed',\n\t\t\t\ttop: 0,\n\t\t\t\tleft: 0,\n\t\t\t\tzIndex: zIndex,\n\t\t\t}}>\n\t\t\t{props.children}\n\t\t</div>\n\t)\n}\n\nexport default class TransitionPortal extends Component {\n\tconstructor() {\n\t\tsuper()\n\t\tthis.el =\n\t\t\ttypeof document !== `undefined`\n\t\t\t\t? document.createElement('section')\n\t\t\t\t: false\n\t}\n\n\tcomponentDidMount = () => {\n\t\tportalRoot && portalRoot.appendChild(this.el)\n\t}\n\n\tcomponentWillUnmount = () => {\n\t\tportalRoot && portalRoot.removeChild(this.el)\n\t}\n\n\trender() {\n\t\treturn this.el && portalRoot\n\t\t\t? ReactDOM.createPortal(\n\t\t\t\t\t<>\n\t\t\t\t\t\t{portalRoot && (\n\t\t\t\t\t\t\t<PortalContainer\n\t\t\t\t\t\t\t\tstyles={this.props.css}\n\t\t\t\t\t\t\t\tlevel={this.props.level}>\n\t\t\t\t\t\t\t\t{this.props.children}\n\t\t\t\t\t\t\t</PortalContainer>\n\t\t\t\t\t\t)}\n\t\t\t\t\t</>,\n\t\t\t\t\tthis.el\n\t\t\t  )\n\t\t\t: null\n\t}\n}\n","export { useTransitionState } from './useTransitionState'\nexport { useTriggerTransition } from './useTriggerTransition'\n","import { useContext } from 'react'\nimport { publicContext } from '../context/createTransitionContext'\n\nconst useTransitionState = () => useContext(publicContext)\n\nexport { useTransitionState }\n","import { useContext } from 'react'\nimport { navigate } from 'gatsby'\nimport { Context } from '../context/createTransitionContext'\nimport { triggerTransition } from '../utils/triggerTransition'\n\nconst useTriggerTransition = defaultOptions => {\n\tconst context = useContext(Context)\n\tconst programmaticallyTriggerTransition = calledOptions => {\n\t\t// allow passing an event directly instead of options\n\t\tif (\n\t\t\tcalledOptions instanceof Event ||\n\t\t\t(calledOptions.nativeEvent &&\n\t\t\t\tcalledOptions.nativeEvent instanceof Event)\n\t\t) {\n\t\t\tcalledOptions = {\n\t\t\t\tevent: calledOptions,\n\t\t\t}\n\t\t}\n\n\t\tconst options = {\n\t\t\t...defaultOptions,\n\t\t\t...calledOptions,\n\t\t}\n\n\t\tif (context.disableAnimation) {\n\t\t\t// If the user has set their browser or OS to prefers-reduced-motion\n\t\t\t// we should respect that.\n\t\t\tif (options.event) {\n\t\t\t\toptions.event.persist()\n\t\t\t\toptions.event.preventDefault()\n\t\t\t}\n\t\t\tnavigate(options.to)\n\t\t} else {\n\t\t\ttriggerTransition({\n\t\t\t\t...context,\n\t\t\t\t...options,\n\t\t\t})\n\t\t}\n\t}\n\treturn programmaticallyTriggerTransition\n}\n\nexport { useTriggerTransition }\n","import { TransitionLink } from './components/TransitionLink'\nimport TransitionHandler from './components/TransitionHandler'\nimport { PublicConsumer as TransitionState } from './context/createTransitionContext'\nimport TransitionPortal from './components/TransitionPortal'\nimport TransitionObserver from './components/TransitionObserver'\nimport { useTriggerTransition } from './hooks'\n\nexport {\n\tTransitionHandler,\n\tTransitionState,\n\tTransitionPortal,\n\tTransitionObserver,\n\tuseTriggerTransition,\n}\nexport default TransitionLink\n","/*\n * adapted from @reach/router implementation:\n * defintion: https://github.com/reach/router/blob/master/src/index.js#L542-L545\n * usage: https://github.com/reach/router/blob/master/src/index.js#L391-L397\n */\n\nconst shouldNavigate = event =>\n\t!event.defaultPrevented &&\n\tevent.button === 0 &&\n\t!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey)\n\nexport { shouldNavigate }\n","import { navigate, withPrefix } from 'gatsby'\nimport { setTimeout } from 'requestanimationframe-timer'\nimport { getMs } from './secondsMs'\nimport getPagesPromises from './getPagesPromises'\n\nconst triggerTransition = ({\n\tto,\n\tevent = null,\n\texit = {},\n\tentry = {},\n\tinTransition,\n\tpages,\n\ttrigger,\n\tupdateContext,\n\tlinkState,\n\treplace,\n\tpreventScrollJump,\n}) => {\n\tif (event) {\n\t\tevent.persist()\n\t\tevent.preventDefault()\n\t}\n\n\tif (inTransition) return false\n\n\tlet hash\n\n\t// handle anchor links to ID's\n\tif (to.includes('#')) {\n\t\tconst toSplit = to.split('#')\n\t\tto = toSplit[0]\n\t\thash = toSplit[1]\n\t}\n\n\t// these globals prevent the back button from being pressed during a transition as that can have unexpected results\n\twindow.__tl_inTransition = true\n\twindow.__tl_desiredPathname = withPrefix(to)\n\n\tupdateContext({\n\t\tinTransition: true,\n\t\texitDelay: 0,\n\t\texitLength: 0,\n\t\tappearAfter: 0,\n\t\texitState: {},\n\t})\n\n\tif (trigger && typeof trigger === 'function') {\n\t\ttrigger(pages)\n\t}\n\n\tconst {\n\t\tlength: exitLength = 0,\n\t\tdelay: exitDelay = 0,\n\t\tstate: exitState = {},\n\t\ttrigger: exitTrigger = () => {},\n\t} = exit\n\tconst {\n\t\tlength: entryLength = 1, // this allows scrollposition to be reset when there is no transition.\n\t\tdelay: entryDelay = 0,\n\t\tstate: entryState = {},\n\t\ttrigger: entryTrigger = () => {},\n\t\tappearAfter = 0,\n\t} = entry\n\n\tupdateContext({\n\t\tentryLength: entryLength,\n\t\tentryDelay: entryDelay,\n\t\texitLength: exitLength,\n\t\texitDelay: exitDelay,\n\t\tentryProps: entry,\n\t\texitProps: exit,\n\t\tappearAfter,\n\t\tpreventScrollJump,\n\t\texitTrigger: (exit, node, e) => exitTrigger(exit, node, e),\n\t\tentryTrigger: (entry, node, e) => entryTrigger(entry, node, e),\n\t\te: event,\n\t})\n\n\t// after exitDelay\n\tsetTimeout(() => {\n\t\tnavigate(to, {\n\t\t\tstate: {\n\t\t\t\t...linkState,\n\t\t\t},\n\t\t\treplace,\n\t\t})\n\n\t\tupdateContext({\n\t\t\texitState: exitState,\n\t\t\thash,\n\t\t})\n\t}, getMs(exitDelay))\n\n\tsetTimeout(() => {\n\t\t// wait for entryDelay before we add entry state\n\t\tupdateContext({ entryState: entryState })\n\t}, getMs(exitDelay + entryDelay))\n\n\t// reset entry animation times so they dont apply when using browser back/forward.\n\t//  this will be replaced with a better solution in the future\n\tsetTimeout(\n\t\t() =>\n\t\t\tupdateContext({\n\t\t\t\tentryDelay: 0,\n\t\t\t\tappearAfter: 0,\n\t\t\t\tentryLength: 0,\n\t\t\t}),\n\t\tgetMs(exitDelay + entryDelay + entryLength)\n\t)\n\n\tconst finalResetSeconds =\n\t\texitDelay + Math.max(exitLength, entryDelay + entryLength)\n\n\t// reset exit animation times so they dont apply when using browser back/forward.\n\t//  this will be replaced with a better solution in the future\n\tsetTimeout(() => {\n\t\t// these globals prevent the back button from being pressed during a transition as that can have unexpected results\n\t\twindow.__tl_inTransition = false\n\t\twindow.__tl_desiredPathname = false\n\t\twindow.__tl_back_button_pressed = false\n\n\t\tupdateContext({\n\t\t\texitDelay: 0,\n\t\t\texitLength: 0,\n\t\t\t// Once all animation is finished, it's safe to start a new animation since we're no longer inTransition.\n\t\t\tinTransition: false,\n\t\t\t// create new page promises for the trigger prop\n\t\t\t...getPagesPromises(),\n\t\t})\n\t}, getMs(finalResetSeconds) + 1)\n}\n\nexport { triggerTransition }\n","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _richTextReactRenderer = require(\"@contentful/rich-text-react-renderer\");\n\nvar _contentfulResolveResponse = _interopRequireDefault(require(\"contentful-resolve-response\"));\n\nfunction renderRichText({\n  raw,\n  references\n}, options = {}) {\n  const richText = JSON.parse(raw); // If no references are given, there is no need to resolve them\n\n  if (!references || !references.length) {\n    return (0, _richTextReactRenderer.documentToReactComponents)(richText, options);\n  } // Create dummy response so we can use official libraries for resolving the entries\n\n\n  const dummyResponse = {\n    items: [{\n      sys: {\n        type: `Entry`\n      },\n      richText\n    }],\n    includes: {\n      Entry: references.filter(({\n        __typename\n      }) => __typename !== `ContentfulAsset`).map(reference => {\n        return { ...reference,\n          sys: {\n            type: `Entry`,\n            id: reference.contentful_id\n          }\n        };\n      }),\n      Asset: references.filter(({\n        __typename\n      }) => __typename === `ContentfulAsset`).map(reference => {\n        return { ...reference,\n          sys: {\n            type: `Asset`,\n            id: reference.contentful_id\n          }\n        };\n      })\n    }\n  };\n  const resolved = (0, _contentfulResolveResponse.default)(dummyResponse, {\n    removeUnresolved: true\n  });\n  return (0, _richTextReactRenderer.documentToReactComponents)(resolved[0].richText, options);\n}\n\nexports.renderRichText = renderRichText;","import loadable from \"@loadable/component\";\nimport React from \"react\";\n\nconst BottomNavigationProxy = loadable(() => import(\"../bottom-navigation\"));\n\nconst BottomNavigation = ({ data, languageData }) => {\n\treturn <BottomNavigationProxy data={data} languageData={languageData} />;\n};\n\nexport default BottomNavigation;\n","import loadable from \"@loadable/component\";\nimport React from \"react\";\n\nconst FeedbackCommentProxy = loadable(() => import(\"../feedback/feedback-comment\"));\n\nconst FeedbackComment = ({ data, resourceId, commentStyles }) => {\n\treturn (\n\t\t<FeedbackCommentProxy\n\t\t\tdata={data}\n\t\t\tresourceId={resourceId}\n\t\t\tcommentStyles={commentStyles}\n\t\t/>\n\t);\n};\n\nexport default FeedbackComment;","import loadable from \"@loadable/component\";\nimport React from \"react\";\n\nconst FeedbackRatingProxy = loadable(() =>import(\"../feedback/feedback-rating\"));\n\nconst FeedbackRating = ({ data, resourceId, ratingStyles }) => {\n\treturn (\n\t\t<FeedbackRatingProxy\n\t\t\tdata={data}\n\t\t\tresourceId={resourceId}\n\t\t\tratingStyles={ratingStyles}\n\t\t/>\n\t);\n};\n\nexport default FeedbackRating;\n","import loadable from \"@loadable/component\";\nimport React from \"react\";\n\nconst FooterProxy = loadable(() => import(\"../footer\"));\n\nconst Footer = ({ data }) => {\n\treturn <FooterProxy data={data} />;\n};\n\nexport default Footer;\n","import loadable from \"@loadable/component\";\nimport React from \"react\";\n\nconst GeneralFeedbackProxy = loadable(() =>import(\"../bottom-navigation/general-feedback\"));\n\nconst GeneralFeedback = ({ data }) => {\n\treturn <GeneralFeedbackProxy data={data} />;\n};\n\nexport default GeneralFeedback;\n","import loadable from \"@loadable/component\";\nimport React from \"react\";\n\nconst HeaderProxy = loadable(() => import(\"../header\"));\n\nconst Header = ({ data, pageTitle }) => {\n\treturn <HeaderProxy data={data} pageTitle={pageTitle} />;\n};\n\nexport default Header;\n","import React, { useContext } from \"react\";\nimport tw, { styled } from \"twin.macro\";\nimport { useState, useEffect } from \"react\";\nimport { useDispatch, useSelector } from \"react-redux\";\nimport { graphql } from \"gatsby\";\n// import FeedbackRating from \"./feedback-rating\";\nimport FeedbackRating from \"../dynamic-components/feedback-rating\";\n// import FeedbackComment from \"./feedback-comment\";\nimport FeedbackComment from \"../dynamic-components/feedback-comment\";\nimport { resetFeedback } from \"../../store/actions/feedback\";\nimport { BLOCKS, MARKS, INLINES } from \"@contentful/rich-text-types\";\nimport { renderRichText } from \"gatsby-source-contentful/rich-text\";\nimport { ThemeContext } from \"../themes/theme-context\";\n\nconst StyledParagraph = tw.p`text-xs font-normal font-sans leading-sans-xs text-center px-8 pt-4`;\n\nconst StyledLink = styled.a(({ textColor, fontSize }) => [\n\ttw`hover:text-black underline cursor-pointer`,\n\ttextColor,\n\tfontSize,\n]);\n\nconst Feedback = ({ data, resourceId, ratingStyles, commentStyles, path }) => {\n\t// console.log(ratingStyles);\n\tconst [submitSuccess, setSubmitSuccess] = useState(false);\n\tconst [submitFailed, setSubmitFailed] = useState(false);\n\n\tconst state = useSelector((state) =>\n\t\tstate.feedback.current ? state.feedback.current : null\n\t);\n\n\tconst dispatch = useDispatch();\n\tconst { theme } = useContext(ThemeContext);\n\n\tconst options = {\n\t\trenderMark: {\n\t\t\t[MARKS.BOLD]: (text) => <strong>{text}</strong>,\n\t\t\t[MARKS.ITALIC]: (text) => <em>{text}</em>,\n\t\t},\n\t\trenderNode: {\n\t\t\t[BLOCKS.PARAGRAPH]: (node, children) => (\n\t\t\t\t<StyledParagraph>{children}</StyledParagraph>\n\t\t\t),\n\t\t\t[INLINES.HYPERLINK]: ({ data }, children) => {\n\t\t\t\t\n\t\t\t\t\tconst isSurveyLink = (typeof children?.[0] === 'string' && children?.[0]?.includes(\"Take a survey -- share your feedback on this page.\")) || \n\t\t\t\t\tchildren?.[0]?.props?.children === \"Help us improve the Safe Space – Click here to take a short survey\";\n\n\t\t\t\t\tconst fontSizeString = isSurveyLink ? tw`text-sm` : tw`text-xs`;\n\n\t\t\t\t\treturn <StyledLink fontSize={fontSizeString} textColor={theme.textColor} href={data.uri} target=\"_blank\">{children}</StyledLink>\t\t\t\n\t\t\t},\n\t\t},\n\t};\n\n\t// post feedback to contentful\n\tuseEffect(() => {\n\t\tconst { didSubmit, resourceId, ratingId, comment, token } = state;\n\n\t\tif (!didSubmit) return;\n\n\t\tasync function postFeedback() {\n\t\t\tconst BASE_API_GATEWAY_ENDPOINT = process.env.GATSBY_BASE_API_GATEWAY_ENDPOINT;\n\t\t\tconst fullEndpoint = `${BASE_API_GATEWAY_ENDPOINT}${path}`;\n\t\t\n\t\t\tawait fetch(fullEndpoint, {\n\t\t\t\theaders: {\n\t\t\t\t\t\"content-type\": \"application/json\",\n\t\t\t\t},\n\t\t\t\tmethod: \"POST\",\n\t\t\t\tbody: JSON.stringify({ resourceId, ratingId, comment, token }),\n\t\t\t})\n\t\t\t.then((response) => {\n\t\t\t\tif (!response.ok) {\n\t\t\t\t\t\t// console.log(response);\n\t\t\t\t\tsetSubmitFailed(true);\n\t\t\t\t\tthrow new Error(response.statusText);\n\t\t\t\t}\n\t\t\t\treturn response;\n\t\t\t})\n\t\t\t.then((res) => {\n\t\t\t\t\t// console.log(res);\n\t\t\t\tsetSubmitSuccess(true);\n\t\t\t})\n\t\t\t.catch((error) => {\n\t\t\t\tconsole.error(error);\n\t\t\t});\n\t\t}\n\n\t\tpostFeedback();\n\t}, [state, dispatch, path]);\n\n\t// hide thank you message after 1 second\n\tuseEffect(() => {\n\t\tconst { resourceId } = state;\n\t\tif (!submitSuccess) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst tick = () => {\n\t\t\tsetSubmitSuccess(false);\n\t\t\tdispatch(resetFeedback(resourceId));\n\t\t};\n\n\t\tlet id = setInterval(tick, 1000);\n\n\t\treturn () => {\n\t\t\tclearInterval(id);\n\t\t};\n\t}, [submitSuccess, dispatch, state]);\n\n\treturn (\n\t\t<>\n\t\t\t{state.step === 0 && (\n\t\t\t\t<FeedbackRating\n\t\t\t\t\tdata={data}\n\t\t\t\t\tresourceId={resourceId}\n\t\t\t\t\tratingStyles={ratingStyles}\n\t\t\t\t/>\n\t\t\t)}\n\t\t\t{state.step === 1 && (\n\t\t\t\t<FeedbackComment\n\t\t\t\t\tdata={data}\n\t\t\t\t\tresourceId={resourceId}\n\t\t\t\t\tcommentStyles={commentStyles}\n\t\t\t\t/>\n\t\t\t)}\n\t\t\t{state.step === 2 && !submitSuccess && !submitFailed && (\n\t\t\t\t<h3>Loading...</h3>\n\t\t\t)}\n\t\t\t{submitSuccess && <h3>Thanks for your feedback!</h3>}\n\t\t\t{submitFailed && <h3>Oops, something went wrong!</h3>}\n\t\t\t{renderRichText(data.recaptchaMessage, options)}\n\t\t</>\n\t);\n};\n\nexport const resourceFeedbackFrag = graphql`\n\tfragment feedbackComponent on ContentfulFeedbackComponent {\n\t\tid\n\t\ttitle\n\t\tratingQuestion\n\t\tratingScale {\n\t\t\ttitle\n\t\t\trating {\n\t\t\t\tid\n\t\t\t\tcontentful_id\n\t\t\t\ttitle\n\t\t\t\tratingValue\n\t\t\t}\n\t\t}\n\t\tcommentLabel\n\t\tsubmitButtonLabel\n\t\tskipButtonLabel\n\t\trecaptchaMessage {\n\t\t\traw\n\t\t}\n\t}\n`;\n\nexport default Feedback;\n","import React from \"react\";\nimport { graphql } from \"gatsby\";\nimport { Helmet } from \"react-helmet\";\n\nconst SiteMetadata = ({ data }) => {\n\tconst description = data.nodes[0].description;\n\n\treturn (\n\t\t<Helmet>\n\t\t\t<meta name=\"description\" content={description} />\n\t\t</Helmet>\n\t);\n};\n\nexport const siteMetadataFragment = graphql`\n\tfragment siteMetadata on ContentfulSiteMetadata {\n\t\ttitle\n\t\tdescription\n\t}\n`;\n\nexport default SiteMetadata;\n","import { actionTypes as resourceFeedbackActions } from \"../reducers/feedback\";\n\nexport const showFeedback = (resourceId) => {\n\tconst action = {\n\t\ttype: resourceFeedbackActions.SHOW,\n\t\tresourceId,\n\t};\n\treturn action;\n};\n\nexport const hideFeedback = (resourceId) => {\n\tconst action = {\n\t\ttype: resourceFeedbackActions.HIDE,\n\t\tresourceId,\n\t};\n\treturn action;\n};\n\nexport const setRating = (resourceId, ratingId, rating, value) => {\n\tconst action = {\n\t\ttype: resourceFeedbackActions.SET_RATING,\n\t\tresourceId,\n\t\tratingId,\n\t\trating,\n\t\tvalue,\n\t};\n\treturn action;\n};\n\nexport const setComment = (resourceId, comment) => {\n\tconst action = {\n\t\ttype: resourceFeedbackActions.SET_COMMENT,\n\t\tresourceId,\n\t\tcomment,\n\t};\n\treturn action;\n};\n\nexport const doSubmit = (resourceId, didSubmit, token) => {\n\tconst action = {\n\t\ttype: resourceFeedbackActions.SUBMIT,\n\t\tresourceId,\n\t\tdidSubmit,\n\t\ttoken,\n\t};\n\treturn action;\n};\n\nexport const resetFeedback = (resourceId) => {\n\tconst action = {\n\t\ttype: resourceFeedbackActions.RESET,\n\t\tresourceId,\n\t};\n\treturn action;\n};\n"],"names":["Object","defineProperty","exports","value","ex","React","React__default","__assign","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","commonjsGlobal","globalThis","window","g","self","fn","module","x","richTextTypes_es5","commonjsGlobal$1","createCommonjsModule","check","it","Math","global_1","Function","fails","exec","error","descriptors","get","$propertyIsEnumerable","propertyIsEnumerable","getOwnPropertyDescriptor","objectPropertyIsEnumerable","f","V","descriptor","enumerable","createPropertyDescriptor","bitmap","configurable","writable","toString","classofRaw","slice","split","indexedObject","toIndexedObject","undefined","TypeError","requireObjectCoercible","isObject","toPrimitive","input","PREFERRED_STRING","val","valueOf","has","key","document$1","document","EXISTS","createElement","documentCreateElement","ie8DomDefine","a","$getOwnPropertyDescriptor","objectGetOwnPropertyDescriptor","O","P","anObject","String","$defineProperty","objectDefineProperty","Attributes","createNonEnumerableProperty","object","setGlobal","SHARED","sharedStore","functionToString","inspectSource","set","has$1","WeakMap","nativeWeakMap","test","shared","push","version","mode","copyright","id","postfix","random","uid","keys","sharedKey","hiddenKeys","WeakMap$1","store$1","state","wmget","wmhas","wmset","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","redefine","getInternalState","enforceInternalState","TEMPLATE","options","unsafe","simple","noTargetGet","source","join","path","aFunction","variable","getBuiltIn","namespace","method","ceil","floor","toInteger","argument","isNaN","min","max","min$1","createMethod","IS_INCLUDES","$this","el","fromIndex","index","integer","toAbsoluteIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","result","enumBugKeys","hiddenKeys$1","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertySymbols","ownKeys","copyConstructorProperties","target","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","replace","toLowerCase","isForced_1","getOwnPropertyDescriptor$1","_export","targetProperty","sourceProperty","TARGET","GLOBAL","global","STATIC","stat","forced","sham","objectKeys","createMethod$1","TO_ENTRIES","$values","values","match","engineIsNode","process","engineUserAgent","versions","v8","activeXDocument","engineV8Version","nativeSymbol","Symbol","useSymbolAsUid","iterator","WellKnownSymbolsStore","Symbol$1","createWellKnownSymbol","withoutSetter","objectDefineProperties","defineProperties","Properties","html","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObject","domain","ActiveXObject","iframeDocument","iframe","JS","write","close","temp","parentWindow","NullProtoObjectViaActiveX","style","display","appendChild","src","contentWindow","open","F","name","objectCreate","create","UNSCOPABLES","ArrayPrototype","Array","$includes","proto","METHOD","BLOCKS","functionBindContext","that","aFunction$1","b","c","INLINES","BLOCKS$1","_a","INLINES$1","TOP_LEVEL_BLOCKS","PARAGRAPH","HEADING_1","HEADING_2","HEADING_3","HEADING_4","HEADING_5","HEADING_6","OL_LIST","UL_LIST","HR","QUOTE","EMBEDDED_ENTRY","EMBEDDED_ASSET","VOID_BLOCKS","CONTAINERS","LIST_ITEM","EMPTY_DOCUMENT","nodeType","DOCUMENT","marks","helpers","freeze","isInline","node","isBlock","isText","MARKS","BOLD","ITALIC","UNDERLINE","CODE","__esModule","_b","richTextTypes_es5_1","richTextTypes_es5_4","richTextTypes_es5_5","richTextTypes_es5_8","nodeListToReactComponents","nodes","map","element","nodeToReactComponent","isValidElement","cloneElement","renderNode","renderMark","renderText","reduce","mark","children","Fragment","defaultNodeRenderers","ASSET_HYPERLINK","defaultInline","ENTRY_HYPERLINK","HYPERLINK","href","uri","defaultMarkRenderers","text","sys","documentToReactComponents","richTextDocument","nativePropertyIsEnumerable","nativeGetOwnPropertyDescriptor","nativeDefineProperty","entries","cache","thrower","METHOD_NAME","ACCESSORS","argument0","argument1","arrayMethodUsesToLength","enumerableOnly","symbols","filter","sym","_objectSpread2","forEach","_defineProperty","getOwnPropertyDescriptors","_typeof","obj","constructor","_objectWithoutProperties","excluded","sourceKeys","_objectWithoutPropertiesLoose","sourceSymbolKeys","_toConsumableArray","arr","isArray","_arrayLikeToArray","_arrayWithoutHoles","iter","from","_iterableToArray","o","minLen","_unsupportedIterableToArray","_nonIterableSpread","len","arr2","camelize","chr","toUpperCase","substr","_excluded$1","PRODUCTION","e","normalizeIconArgs","icon","prefix","iconName","parse","objectWithKey","_excluded","FontAwesomeIcon","_ref","forwardedRef","props","iconArgs","maskArgs","mask","symbol","className","title","titleId","maskId","iconLookup","classes","_classes","beat","fade","beatFade","bounce","shake","flash","spin","spinPulse","spinReverse","pulse","fixedWidth","inverse","border","listItem","flip","size","rotation","pull","swapOpacity","classList","transform","renderedIcon","_console","console","log","abstract","extraProps","ref","defaultProps","convertCurry","displayName","propTypes","convert","child","mixins","attributes","acc","attrs","trim","pair","prop","startsWith","charAt","_extraProps$style","existingStyle","remaining","tag","bind","_slicedToArray","_arr","_n","_d","_e","_s","_i","next","done","err","sliceIterator","UNRESOLVED_LINK","lookupInEntityMap","entityMap","linkData","entryId","linkType","spaceId","environmentId","getResolvedLink","link","_link$sys","_getIdsFromUrn","urn","regExp","_urn$match","_urn$match2","_urn$match2$","getIdsFromUrn","_entryId","extractedLinkType","walkMutate","predicate","mutator","removeUnresolved","cleanUpLinks","response","items","responseClone","allIncludes","all","allEntries","entity","Boolean","Map","space","environment","item","entryObject","itemEntryPoints","ownKey","entryObj","entryPoint","makeEntryObject","isResourceLink","resolvedLink","normalizeLink","toStringFunction","getPrototypeOf$1","getPrototypeOf","SYMBOL_PROPERTIES","WEAK_MAP","createCache","Cache","_keys","_values","getCleanClone","realm","__proto__","Constructor","getObjectCloneLoose","handleCopy","clone","length_1","getObjectCloneStrict","properties","length_2","property","getRegExpFlags","flags","ignoreCase","multiline","unicode","sticky","GLOBAL_THIS","copy","isStrict","getObjectClone","Date","getTime","RegExp","lastIndex","Set","add","Blob","Buffer","isBuffer","allocUnsafe","ArrayBuffer","isView","buffer","then","Error","WeakSet","default","strict","factory","safeMin","minDuration","maxDuration","minDamping","maxDamping","findSpring","envelope","derivative","duration","_c","velocity","mass","dampingRatio","clamp","undampedFreq","exponentialDecay","delta","calcAngularFreq","exp","d","pow","initialGuess","rootIterations","approximateRoot","stiffness","damping","sqrt","durationKeys","physicsKeys","isSpringType","some","spring","to","restSpeed","restDelta","springOptions","isResolvedFromDuration","derived","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","abs","angularFreq_1","sin","cos","dampedAngularFreq_1","freqForT","sinh","cosh","current","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","_t","mixLinearColor","v","fromExpo","toExpo","colorTypes","hex","rgba","hsla","getColorType","find","notAnimatable","color","mixColor","fromColorType","toColorType","fromColor","toColor","blended","mixFunc","mix","alpha","getMixer","origin","mixComplex","mixArray","output","numValues","blendValue","fromThis","mixObject","analyse","parsed","complex","numNumbers","numRGB","numHSL","hue","template","createTransformer","originStats","targetStats","pipe","mixNumber","createMixers","ease","customMixer","mixers","mixerFactory","numMixers","mixer","easingFunction","interpolate","isClamp","inputLength","reverse","interpolator","progress","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","slowInterpolate","power","reverseEasing","easing","mirrorEasing","createBackIn","linear","easeIn","easeOut","easeInOut","circIn","acos","circOut","circInOut","backIn","backOut","backInOut","anticipate","backEasing","createAnticipate","bounceOut","p2","bounceIn","defaultEasing","splice","keyframes","offset","times","convertOffsetToTimes","_value","defaultOffset","createInterpolator","types","decay","timeConstant","_f","modifyTarget","amplitude","ideal","loopElapsed","elapsed","delay","framesync","update","passTimestamp","start","stop","animate","driverControls","latest","interpolateFromNumber","autoplay","driver","_g","repeat","repeatMax","_h","repeatType","_j","repeatDelay","onPlay","onStop","onComplete","onRepeat","onUpdate","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","config","detectAnimationFromOptions","animation","reverseElapsed","hasRepeatDelayElapsed","a1","a2","calcBezier","getSlope","subdivisionPrecision","subdivisionMaxIterations","newtonIterations","kSampleStepSize","cubicBezier","mX1","mY1","mX2","mY2","sampleValues","Float32Array","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","easingLookup","bounceInOut","easingDefinitionToFunction","definition","isEasingArray","isAnimatable","underDampedSpring","criticallyDampedSpring","linearTween","defaultTransitions","y","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","getDefaultTransition","valueKey","transitionFactory","legacyRepeatWarning","getPopmotionAnimationOptions","transition","hydrateKeyframes","when","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","yoyo","loop","convertTransitionToAnimationOptions","getAnimation","valueTransition","getValueTransition","isTargetAnimatable","isZero","getZeroUnit","isOriginAnimatable","getVelocity","currentAnimation","bounceStiffness","bounceDamping","isOutOfBounds","boundaryNearest","startAnimation","startSpring","prev_1","current_1","boundary_1","heading_1","inertia","parseFloat","potentialUnitType","delayTimer","controls","getDelayFromTransition","setTimeout","clearTimeout","Presence","VisibilityAction","defaultPagePoint","pageX","pageY","pointFromTouch","pointType","point","touches","changedTouches","pointFromMouse","extractEventInfo","event","getViewportPointFromEvent","wrapHandler","handler","shouldFilterPrimaryPointer","eventHandler","listener","isMouseEvent","MouseEvent","button","addDomEvent","eventName","addEventListener","removeEventListener","useDomEvent","useEffect","supportsPointerEvents","onpointerdown","supportsTouchEvents","ontouchstart","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","addPointerEvent","usePointerEvent","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","PointerEvent","pointerType","isTouchEvent","animations","visualElement","animationState","subscribe","exit","custom","isPresent","onExitComplete","presenceContext","useContext","setActive","Exit","PanSession","handlers","_this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","distance","timestamp","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","end","onEnd","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","updateHandlers","subtractPoint","lastDevicePoint","startDevicePoint","timeDelta","timestampedPoint","lastPoint","time","Infinity","applyConstraints","elastic","calcRelativeAxisConstraints","axis","calcViewportAxisConstraints","layoutAxis","constraintsAxis","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","lastPointerEvent","elementDragControls","VisualElementDragControls","isDragging","currentDirection","constraints","hasMutatedConstraints","cursorProgress","originPoint","openGlobalLock","panSession","enableLayoutProjection","originEvent","snapToCursor","stopMotion","initialPoint","cancelLayout","read","ancestors","tree","hasManuallySetCursorOrigin","isLayoutDrag","lockProjectionTarget","resetTransform","restoreTransform","getAxisMotionValue","isExternalDrag","rebaseProjectionTarget","measureViewportBox","scheduleUpdateLayoutProjection","projection","axisValue","preRender","render","postRender","resolveDragConstraints","dragPropagation","onDragStart","Drag","dragDirectionLock","lockThreshold","direction","getCurrentDirection","onDirectionLock","updateAxis","onDrag","dragConstraints","layout","getLayoutState","layoutCorrected","resolveRefConstraints","layoutBox","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","measuredConstraints","calcViewportConstraints","userConstraints","cancelDrag","unlockProjectionTarget","animateDragEnd","onDragEnd","shouldDrag","box","center","updateAxisMotionValue","updateVisualElementAxis","nextValue","axisLayout","axisLength","axisProgress","calcConstrainedMinPoint","setProjectionTargetAxis","setProps","dragMomentum","remainingProps","layoutId","dragKey","getValue","_dragX","_dragY","dragTransition","isRelative","projectionParent","getProjectionParent","getLatestValues","convertToRelativeProjection","relativeConstraints_1","targetFinal","momentumAnimations","startAxisValueAnimation","startLayoutAnimation","Promise","onDragTransitionEnd","stopLayoutAnimation","currentValue","scalePoint","boxProgress","updateConstraints","calcPositionFromProgress","onReady","mount","getInstance","stopPointerListener","dragListener","stopResizeListener","stopLayoutUpdateListener","onLayoutUpdate","prevDragCursor","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","MotionConfigContext","groupDragControls","dragControls","createHoverEvent","isActive","callback","Hover","isNodeOrChild","parent","parentElement","gestureAnimations","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","removePointerEndListener","checkPointerEnd","Tap","onPointerUp","onPointerCancel","focus","whileFocus","Focus","hover","onHoverStart","onHoverEnd","whileHover","pixelsToPercent","pixels","varToken","borderCorrectionDefinition","_layoutState","px","defaultScaleCorrectors","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","treeScale","original","containsCSSVariables","cssVariables","shadow","xScale","yScale","averageScale","i_1","cssVariable","Animate","_super","frameTarget","currentAnimationTarget","isAnimating","stopAxisAnimation","isAnimatingTree","originBox","targetBox","visibilityAction","shouldStackAnimate","prevParent","safeToRemove","prevParentViewportBox","prevViewportBox","parentLayout","isProvidedCorrectDataForRelativeSharedLayout","boxHasMoved","isZeroBox","axisIsEqual","targetLength","isTargetLocked","animateAxis","setVisibility","Show","syncRender","notifyLayoutAnimationComplete","componentDidMount","animateMotionValue","unsubLayoutReady","layoutSafeToRemove","componentWillUnmount","layoutProgress","getProjectionAnimationProgress","clearListeners","frame","unsubscribeProgress","onChange","layoutTransition","defaultLayoutTransition","zeroAxis","defaultHandler","layoutReady","notifyLayoutReady","createBatcher","queue","flush","order","sort","presence","Present","assignProjectionToSnapshot","clear","SharedLayoutContext","createContext","FramerTreeLayoutContext","isSharedLayout","context","forceUpdate","Measure","syncLayout","framerSyncLayout","register","onUnmount","remove","getSnapshotBeforeUpdate","syncUpdate","componentDidUpdate","layoutAnimations","measureLayout","layoutAnimation","tweenAxis","prev","calcRelativeOffsetAxis","calcRelativeOffset","checkIfParentHasChanged","prevId","getLayoutId","nextId","makeRenderlessComponent","hook","createLayoutState","isHydrated","deltaFinal","deltaTransform","zeroLayout","buildLayoutProjectionTransform","latestTransform","translate","identityProjection","buildLayoutProjectionTransformOrigin","FlatTree","isDirty","treeType","build","getBaseTarget","makeTargetAnimatable","renderInstance","readValueFromInstance","removeValueFromRenderState","sortNodePosition","scrapeMotionValuesFromProps","presenceId","blockInitialAnimation","visualState","instance","unsubscribeFromLeadVisualElement","crossfader","projectionTargetProgress","removeFromVariantTree","latestValues","renderState","lifecycles","managers","propSubscriptions","clearAllListeners","manager","updatePropListeners","on","propListener","args","notify","createLifecycles","isEnabled","leadProjection","leadLatestValues","layoutState","hasViewportBoxUpdated","valueSubscriptions","prevMotionValues","baseTarget","isProjectionReady","triggerBuild","valuesToRender","crossfadedValues","getCrossfadeState","notifyUpdate","updateTreeLayoutProjection","layoutTree","fireUpdateLayoutProjection","initialMotionValues","isControllingVariants","isVariantNode","depth","variantChildren","isVisible","manuallyAnimateOnMount","isMounted","newInstance","pointTo","addVariantChild","unmount","updateLayoutProjection","delete","closestVariantNode","getClosestVariantNode","other","getStaticValue","setStaticValue","visibility","scheduleRender","canMutate","addValue","hasValue","removeValue","removeOnChange","latestValue","removeOnRenderRequest","onRenderRequest","bindToMotionValue","defaultValue","forEachValue","readValue","setBaseTarget","newProps","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","getProps","getVariant","variants","getVariantContext","startAtParent","context_1","initial","numVariantProps","name_1","variantProps","setCrossfader","newCrossfader","relativeTarget","withTransform","viewportBox","notifySetAxisTarget","force","shouldRebase","relativeOffset","setCurrentViewportBox","notifyLayoutUpdate","prevTreeScaleX","prevTreeScaleY","prevDeltaTransform","treePath","transformOrigin","updateLayoutDeltas","notifyViewportBoxUpdate","fireResolveRelativeTargetBox","foundParent","ancestor","resolveRelativeTargetBox","relativeParent","shouldResetTransform","_layoutResetTransform","newLead","onSetAxisTarget","onLayoutAnimationComplete","Entering","BoundingBoxDimension","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","positionalValues","width","height","checkAndConvertChangedValueTypes","transitionEnd","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","removedTransforms","removeNonTranslationalTransform","convertedTarget","changedKeys","originBbox","elementComputedStyle","getComputedStyle","originComputedStyle","targetBbox","convertChangedValueTypes","unitConversion","hasPositionalKey","htmlConfig","domElement","defaultType","computedStyle","getPropertyValue","compareDocumentPosition","transformTemplate","mutableState","vars","transformValues","resolved","parseDomVariant","isProjectionTranform","htmlVisualElement","svgVisualElement","getAttribute","_element","createDomVisualElement","Component","enableHardwareAcceleration","featureBundle","motion","getBoundingBox","getBoundingClientRect","isProjecting","collectProjectingAncestors","collectProjectingChildren","addChild","updateLayoutMeasurement","notifyBeforeLayoutMeasure","notifyLayoutMeasure","snapshotViewportBox","unresolvedJobs","pushJob","stack","job","pointer","batchLayout","flushLayout","reads","writes","setRead","setWrite","numStacks","executeJob","isCSSVariable","cssVariableRegex","maxDepth","getVariableValue","parseCSSVariable","token","fallback","resolveCSSVariables","HTMLElement","getAnimatableNone","defaultValueType","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","dimensionValueTypes","vw","vh","findDimensionValueType","testValueType","shallowCompare","prevLength","variantPriorityOrder","reversePriorityOrder","numAnimationTypes","createAnimationState","animateList","createTypeState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","animateChanges","changedActiveType","removedKeys","encounteredKeys","removedVariantIndex","_loop_1","typeState","propIsVariant","activeDelta","isInherited","protectedKeys","prevProp","shouldAnimateType","variantsHaveChanged","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","needsAnimating","fallbackAnimation_1","fallbackTarget","shouldAnimate","resolve","isAnimated","setAnimateFunction","makeAnimator","getState","animateVisualElement","notifyAnimationStart","variant","animateVariant","resolvedDefinition","animateTarget","notifyAnimationComplete","transitionOverride","getChildAnimations","forwardDelay","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","animateChildren","first","last","animationTypeState","valueTarget","shouldBlockAnimation","stopAnimation","shouldBlock","compareByDepth","isDraggable","isNumericalString","valueTypes","findValueType","setMotionValue","setTarget","setVariants","variantLabels","setValues","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","getOriginFromTransition","getOrigin","AnimationType","addUniqueItem","removeItem","eachAxis","resetAxis","originAxis","resetBox","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","applyAxisTransforms","final","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","applyBoxTransforms","finalBox","removePointDelta","removeAxisTransforms","removeAxisDelta","removeBoxTransforms","applyTreeDeltas","treeLength","clampProgress","isNear","maxDistance","calcLength","calcOrigin","sourceLength","updateAxisDelta","updateBoxDelta","defaultOrigin","originX","originY","calcRelativeAxis","relative","calcRelativeBox","parentProjection","noop","any","convertBoundingBoxToAxisBox","convertAxisBoxToBoundingBox","transformBoundingBox","topLeft","bottomRight","axisBox","copyAxisBox","zeroDelta","SubscriptionManager","subscriptions","numSubscriptions","getSize","secondsToMilliseconds","seconds","useUnmountEffect","MotionValue","init","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","scheduleVelocityCheck","velocityCheck","subscription","attach","passiveEffect","getPrevious","clearAnimation","destroy","motionValue","defaultTimestep","getCurrentTime","performance","now","onNextFrame","requestAnimationFrame","useDefaultElapsed","runNextFrame","isProcessing","stepsOrder","steps","toRun","toRunNextFrame","numToRun","toKeepAlive","step","schedule","keepAlive","immediate","addToCurrentFrame","cancel","frameData","createRenderStep","sync","startLoop","cancelSync","flushSync","processStep","stepId","processFrame","getFrameData","warning","invariant","isPoint","isPoint3D","distance1D","xDelta","yDelta","zDelta","isNum","combineFunctions","transformers","toFromDifference","velocityPerSecond","frameDuration","hasElementType","Element","hasMap","hasSet","hasArrayBuffer","equal","$$typeof","message","warn","clock","_class","_temp","ATTRIBUTE_NAMES","TAG_NAMES","BASE","BODY","HEAD","HTML","LINK","META","NOSCRIPT","STYLE","TITLE","TAG_PROPERTIES","REACT_TAG_MAP","accesskey","charset","class","contenteditable","contextmenu","itemprop","tabindex","HELMET_PROPS","HTML_TAG_MAP","SELF_CLOSING_TAGS","HELMET_ATTRIBUTE","createClass","protoProps","staticProps","_extends","objectWithoutProperties","encodeSpecialCharacters","str","getTitleFromPropsList","propsList","innermostTitle","getInnermostProperty","innermostTemplate","innermostDefaultTitle","getOnChangeClientState","getAttributesFromPropsList","tagType","tagAttrs","getBaseTagFromPropsList","primaryAttributes","innermostBaseTag","lowerCaseAttributeKey","getTagsFromPropsList","tagName","approvedSeenTags","approvedTags","instanceTags","instanceSeenTags","primaryAttributeKey","attributeKey","tagUnion","rafPolyfill","currentTime","cafPolyfill","webkitRequestAnimationFrame","mozRequestAnimationFrame","cancelAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","msg","_helmetCallback","commitTagChanges","newState","cb","baseTag","bodyAttributes","htmlAttributes","linkTags","metaTags","noscriptTags","onChangeClientState","scriptTags","styleTags","titleAttributes","updateAttributes","updateTitle","tagUpdates","updateTags","addedTags","removedTags","_tagUpdates$tagType","newTags","oldTags","flattenArray","possibleArray","elementTag","getElementsByTagName","helmetAttributeString","helmetAttributes","attributesToRemove","attributeKeys","attribute","setAttribute","indexToSave","removeAttribute","tags","headElement","head","querySelector","tagNodes","querySelectorAll","indexToDelete","newElement","innerHTML","styleSheet","cssText","createTextNode","existingTag","isEqualNode","parentNode","removeChild","generateElementAttributesAsString","attr","convertElementAttributestoReactProps","initProps","getMethodsForTag","encode","toComponent","_initProps","attributeString","flattenedTitle","generateTitleAsString","_mappedTag","mappedTag","mappedAttribute","dangerouslySetInnerHTML","__html","generateTagsAsReactComponent","attributeHtml","tagContent","isSelfClosing","generateTagsAsString","mapStateOnServer","_ref$title","base","meta","noscript","script","HelmetSideEffects","defer","HelmetExport","_React$Component","HelmetWrapper","classCallCheck","ReferenceError","possibleConstructorReturn","subClass","superClass","setPrototypeOf","inherits","shouldComponentUpdate","nextProps","mapNestedChildrenToProps","nestedChildren","flattenArrayTypeChildren","_babelHelpers$extends","arrayTypeChildren","newChildProps","mapObjectTypeChildren","_ref2","_babelHelpers$extends2","_babelHelpers$extends3","mapArrayTypeChildrenToProps","newFlattenedProps","arrayChildName","_babelHelpers$extends4","warnOnInvalidChildren","mapChildrenToProps","_this2","_child$props","initAttributes","convertReactPropstoHtmlAttributes","_props","canUseDOM","defaultTitle","titleTemplate","peek","rewind","mappedState","renderStatic","reducePropsToState","handleStateChangeOnClient","WrappedComponent","mountedInstances","emitChange","SideEffect","_PureComponent","recordedState","_proto","UNSAFE_componentWillMount","PureComponent","getDisplayName","r","red","parseInt","green","blue","saturation","lightness","alpha$1","round","clampRgbUnit","rgbUnit","isColorString","testProp","splitColor","aName","bName","cName","maxDefaults","applyDefaultFilter","number","unit","functionRegex","functions","colorToken","numberToken","numColors","colors","numbers","tokenised","convertNumbersToZero","transformer","_interopRequireDefault","require","_interopRequireWildcard","_exportNames","Link","withIntl","navigate","changeLocale","IntlContextProvider","IntlContextConsumer","_reactIntl","_link","_withIntl","_intlContext","_extends2","_objectWithoutPropertiesLoose2","_react","_propTypes","_gatsby","language","onClick","rest","intl","languageLink","routed","localStorage","setItem","isRequired","_default","_window$___gatsbyIntl","___gatsbyIntl","pathname","substring","removeLocalePart","location","search","injectIntl","_shouldNavigate","_triggerTransition","_createTransitionContext","forwardRef","TransitionLink","entry","activeStyle","partiallyActive","activeClassName","trigger","innerRef","preventScrollJump","Consumer","__self","__source","fileName","_jsxFileName","lineNumber","columnNumber","disableAnimation","weShouldNavigate","shouldNavigate","triggerTransition","linkState","exitLength","entryDelay","exitFn","func","entryState","publicContext","contextState","updateContextState","useState","observing","setObserving","observerSupport","IntersectionObserverEntry","observer","IntersectionObserver","observed","thisObserved","intersectionRatio","threshold","observe","unobserve","forceRender","transitionStatus","TransitionObserver","_reactDom","portalRoot","body","PortalContainer","zIndex","level","position","TransitionPortal","_react$Component","_inheritsLoose","createPortal","styles","css","_useTransitionState","_useTriggerTransition","useTransitionState","defaultOptions","Context","calledOptions","Event","nativeEvent","persist","preventDefault","_TransitionLink","defaultPrevented","metaKey","altKey","ctrlKey","shiftKey","_requestanimationframeTimer","_secondsMs","_getPagesPromises","hash","inTransition","pages","updateContext","toSplit","__tl_inTransition","__tl_desiredPathname","withPrefix","exitDelay","appearAfter","exitState","exitTrigger","entryLength","entryTrigger","entryProps","exitProps","getMs","finalResetSeconds","__tl_back_button_pressed","_richTextReactRenderer","_contentfulResolveResponse","raw","references","richText","JSON","dummyResponse","Entry","__typename","reference","contentful_id","Asset","_ref3","BottomNavigationProxy","loadable","chunkName","isReady","__webpack_modules__","importAsync","requireAsync","requireSync","__webpack_require__","BottomNavigation","languageData","___EmotionJSX","FeedbackCommentProxy","FeedbackComment","resourceId","commentStyles","FeedbackRatingProxy","FeedbackRating","ratingStyles","FooterProxy","Footer","GeneralFeedbackProxy","GeneralFeedback","HeaderProxy","Header","pageTitle","StyledParagraph","_styled2","StyledLink","textColor","fontSize","submitSuccess","setSubmitSuccess","submitFailed","setSubmitFailed","useSelector","feedback","dispatch","useDispatch","theme","ThemeContext","_children$","_children$2","_children$2$props","fontSizeString","didSubmit","ratingId","comment","async","fullEndpoint","fetch","headers","stringify","ok","statusText","res","catch","postFeedback","setInterval","tick","resetFeedback","clearInterval","renderRichText","recaptchaMessage","description","Helmet","showFeedback","resourceFeedbackActions","SHOW","hideFeedback","HIDE","setRating","rating","SET_RATING","setComment","SET_COMMENT","doSubmit","SUBMIT","RESET"],"sourceRoot":""}