{"version":3,"file":"js/3132-c8a2191bfab8f00fcf70.js","mappings":"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","sources":["webpack://vesta/./node_modules/date-fns/esm/_lib/getTimezoneOffsetInMilliseconds/index.js","webpack://vesta/./node_modules/date-fns/esm/_lib/requiredArgs/index.js","webpack://vesta/./node_modules/date-fns/esm/startOfDay/index.js","webpack://vesta/./node_modules/date-fns/esm/differenceInCalendarDays/index.js","webpack://vesta/./node_modules/date-fns/esm/differenceInDays/index.js","webpack://vesta/./node_modules/date-fns/esm/toDate/index.js","webpack://vesta/./node_modules/dayjs/plugin/isToday.js","webpack://vesta/./node_modules/redux-persist/es/integration/react.js","webpack://vesta/./node_modules/@headlessui/react/dist/components/description/description.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-tab-direction.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-event-listener.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-watch.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-on-unmount.js","webpack://vesta/./node_modules/@headlessui/react/dist/components/focus-trap/focus-trap.js","webpack://vesta/./node_modules/@headlessui/react/dist/utils/document-ready.js","webpack://vesta/./node_modules/@headlessui/react/dist/internal/portal-force-root.js","webpack://vesta/./node_modules/@headlessui/react/dist/components/portal/portal.js","webpack://vesta/./node_modules/@headlessui/react/dist/internal/stack-context.js","webpack://vesta/./node_modules/@headlessui/react/dist/use-sync-external-store-shim/useSyncExternalStoreShimClient.js","webpack://vesta/./node_modules/@headlessui/react/dist/use-sync-external-store-shim/index.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/document-overflow/adjust-scrollbar-padding.js","webpack://vesta/./node_modules/@headlessui/react/dist/utils/platform.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/document-overflow/handle-ios-locking.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/document-overflow/overflow-store.js","webpack://vesta/./node_modules/@headlessui/react/dist/utils/store.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/document-overflow/prevent-scroll.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/document-overflow/use-document-overflow.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-store.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-inert.js","webpack://vesta/./node_modules/@headlessui/react/dist/components/dialog/dialog.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-root-containers.js","webpack://vesta/./node_modules/@headlessui/react/dist/components/menu/menu.js","webpack://vesta/./node_modules/@headlessui/react/dist/components/label/label.js","webpack://vesta/./node_modules/@headlessui/react/dist/components/radio-group/radio-group.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-owner.js","webpack://vesta/./node_modules/@headlessui/react/dist/hooks/use-tree-walker.js","webpack://vesta/./node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/components/AnimatePresence/utils.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/GlobalConfig.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/frameloop/batcher.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/frameloop/render-step.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/frameloop/microtask.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/is-ref-object.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/is-variant-label.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/variant-props.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/definitions.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/utils/symbol.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/load-features.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/motion-proxy.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/clamp.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/numbers/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/utils.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/numbers/units.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/use-props.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/use-props.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/use-render.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/resolve-variants.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/resolve-value.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/use-will-change/get-will-change-name.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/frameloop/frame.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/config-motion.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/events/add-dom-event.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/events/utils/is-primary-pointer.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/events/add-pointer-event.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/pipe.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/Feature.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/hover.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/press.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/focus.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/color/utils.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/color/rgba.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/color/hex.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/color/hsla.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/color/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/complex/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/utils/is-none.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/memo.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/frameloop/sync-time.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/generators/inertia.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/ease.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/circ.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/back.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/utils/map.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/anticipate.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/progress.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/mix/number.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/mix/immediate.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/mix/color.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/mix/visibility.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/mix/complex.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/mix/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/interpolate.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/offsets/default.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/offsets/fill.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/offsets/time.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/waapi/easing.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/scroll/supports.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/GroupPlaybackControls.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/scroll/observe.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/use-will-change/WillChangeMotionValue.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/animation/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/distance.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/pan/PanSession.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/get-context-window.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/pan/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/node/state.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-element.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/delay.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/animation/interfaces/single-value.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/gestures/drag/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/store.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/VisualElement.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/motion.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/motion/features/layout.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/errors.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/noop.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack://vesta/./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs"],"sourcesContent":["/**\n * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.\n * They usually appear for dates that denote time before the timezones were introduced\n * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891\n * and GMT+01:00:00 after that date)\n *\n * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,\n * which would lead to incorrect calculations.\n *\n * This function returns the timezone offset in milliseconds that takes seconds in account.\n */\nexport default function getTimezoneOffsetInMilliseconds(date) {\n  var utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));\n  utcDate.setUTCFullYear(date.getFullYear());\n  return date.getTime() - utcDate.getTime();\n}","export default function requiredArgs(required, args) {\n  if (args.length < required) {\n    throw new TypeError(required + ' argument' + (required > 1 ? 's' : '') + ' required, but only ' + args.length + ' present');\n  }\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfDay\n * @category Day Helpers\n * @summary Return the start of a day for the given date.\n *\n * @description\n * Return the start of a day for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a day\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a day for 2 September 2014 11:55:00:\n * const result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 02 2014 00:00:00\n */\nexport default function startOfDay(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import getTimezoneOffsetInMilliseconds from \"../_lib/getTimezoneOffsetInMilliseconds/index.js\";\nimport startOfDay from \"../startOfDay/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nvar MILLISECONDS_IN_DAY = 86400000;\n\n/**\n * @name differenceInCalendarDays\n * @category Day Helpers\n * @summary Get the number of calendar days between the given dates.\n *\n * @description\n * Get the number of calendar days between the given dates. This means that the times are removed\n * from the dates and then the difference in days is calculated.\n *\n * @param {Date|Number} dateLeft - the later date\n * @param {Date|Number} dateRight - the earlier date\n * @returns {Number} the number of calendar days\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // How many calendar days are between\n * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?\n * const result = differenceInCalendarDays(\n *   new Date(2012, 6, 2, 0, 0),\n *   new Date(2011, 6, 2, 23, 0)\n * )\n * //=> 366\n * // How many calendar days are between\n * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?\n * const result = differenceInCalendarDays(\n *   new Date(2011, 6, 3, 0, 1),\n *   new Date(2011, 6, 2, 23, 59)\n * )\n * //=> 1\n */\nexport default function differenceInCalendarDays(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var startOfDayLeft = startOfDay(dirtyDateLeft);\n  var startOfDayRight = startOfDay(dirtyDateRight);\n  var timestampLeft = startOfDayLeft.getTime() - getTimezoneOffsetInMilliseconds(startOfDayLeft);\n  var timestampRight = startOfDayRight.getTime() - getTimezoneOffsetInMilliseconds(startOfDayRight);\n\n  // Round the number of days to the nearest integer\n  // because the number of milliseconds in a day is not constant\n  // (e.g. it's different in the day of the daylight saving time clock shift)\n  return Math.round((timestampLeft - timestampRight) / MILLISECONDS_IN_DAY);\n}","import toDate from \"../toDate/index.js\";\nimport differenceInCalendarDays from \"../differenceInCalendarDays/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\"; // Like `compareAsc` but uses local time not UTC, which is needed\n// for accurate equality comparisons of UTC timestamps that end up\n// having the same representation in local time, e.g. one hour before\n// DST ends vs. the instant that DST ends.\nfunction compareLocalAsc(dateLeft, dateRight) {\n  var diff = dateLeft.getFullYear() - dateRight.getFullYear() || dateLeft.getMonth() - dateRight.getMonth() || dateLeft.getDate() - dateRight.getDate() || dateLeft.getHours() - dateRight.getHours() || dateLeft.getMinutes() - dateRight.getMinutes() || dateLeft.getSeconds() - dateRight.getSeconds() || dateLeft.getMilliseconds() - dateRight.getMilliseconds();\n  if (diff < 0) {\n    return -1;\n  } else if (diff > 0) {\n    return 1;\n    // Return 0 if diff is 0; return NaN if diff is NaN\n  } else {\n    return diff;\n  }\n}\n\n/**\n * @name differenceInDays\n * @category Day Helpers\n * @summary Get the number of full days between the given dates.\n *\n * @description\n * Get the number of full day periods between two dates. Fractional days are\n * truncated towards zero.\n *\n * One \"full day\" is the distance between a local time in one day to the same\n * local time on the next or previous day. A full day can sometimes be less than\n * or more than 24 hours if a daylight savings change happens between two dates.\n *\n * To ignore DST and only measure exact 24-hour periods, use this instead:\n * `Math.floor(differenceInHours(dateLeft, dateRight)/24)|0`.\n *\n *\n * @param {Date|Number} dateLeft - the later date\n * @param {Date|Number} dateRight - the earlier date\n * @returns {Number} the number of full days according to the local timezone\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // How many full days are between\n * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?\n * const result = differenceInDays(\n *   new Date(2012, 6, 2, 0, 0),\n *   new Date(2011, 6, 2, 23, 0)\n * )\n * //=> 365\n * // How many full days are between\n * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?\n * const result = differenceInDays(\n *   new Date(2011, 6, 3, 0, 1),\n *   new Date(2011, 6, 2, 23, 59)\n * )\n * //=> 0\n * // How many full days are between\n * // 1 March 2020 0:00 and 1 June 2020 0:00 ?\n * // Note: because local time is used, the\n * // result will always be 92 days, even in\n * // time zones where DST starts and the\n * // period has only 92*24-1 hours.\n * const result = differenceInDays(\n *   new Date(2020, 5, 1),\n *   new Date(2020, 2, 1)\n * )\n//=> 92\n */\nexport default function differenceInDays(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeft = toDate(dirtyDateLeft);\n  var dateRight = toDate(dirtyDateRight);\n  var sign = compareLocalAsc(dateLeft, dateRight);\n  var difference = Math.abs(differenceInCalendarDays(dateLeft, dateRight));\n  dateLeft.setDate(dateLeft.getDate() - sign * difference);\n\n  // Math.abs(diff in full days - diff in calendar days) === 1 if last calendar day is not full\n  // If so, result must be decreased by 1 in absolute value\n  var isLastDayNotFull = Number(compareLocalAsc(dateLeft, dateRight) === -sign);\n  var result = sign * (difference - isLastDayNotFull);\n  // Prevent negative zero\n  return result === 0 ? 0 : result;\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name toDate\n * @category Common Helpers\n * @summary Convert the given argument to an instance of Date.\n *\n * @description\n * Convert the given argument to an instance of Date.\n *\n * If the argument is an instance of Date, the function returns its clone.\n *\n * If the argument is a number, it is treated as a timestamp.\n *\n * If the argument is none of the above, the function returns Invalid Date.\n *\n * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.\n *\n * @param {Date|Number} argument - the value to convert\n * @returns {Date} the parsed date in the local time zone\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Clone the date:\n * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))\n * //=> Tue Feb 11 2014 11:30:30\n *\n * @example\n * // Convert the timestamp to date:\n * const result = toDate(1392098430000)\n * //=> Tue Feb 11 2014 11:30:30\n */\nexport default function toDate(argument) {\n  requiredArgs(1, arguments);\n  var argStr = Object.prototype.toString.call(argument);\n\n  // Clone the date\n  if (argument instanceof Date || _typeof(argument) === 'object' && argStr === '[object Date]') {\n    // Prevent the date to lose the milliseconds when passed to new Date() in IE10\n    return new Date(argument.getTime());\n  } else if (typeof argument === 'number' || argStr === '[object Number]') {\n    return new Date(argument);\n  } else {\n    if ((typeof argument === 'string' || argStr === '[object String]') && typeof console !== 'undefined') {\n      // eslint-disable-next-line no-console\n      console.warn(\"Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#string-arguments\");\n      // eslint-disable-next-line no-console\n      console.warn(new Error().stack);\n    }\n    return new Date(NaN);\n  }\n}","!function(e,o){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=o():\"function\"==typeof define&&define.amd?define(o):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_isToday=o()}(this,(function(){\"use strict\";return function(e,o,t){o.prototype.isToday=function(){var e=\"YYYY-MM-DD\",o=t();return this.format(e)===o.format(e)}}}));","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport React, { PureComponent } from 'react'; // eslint-disable-line import/no-unresolved\n\nexport var PersistGate =\n/*#__PURE__*/\nfunction (_PureComponent) {\n  _inherits(PersistGate, _PureComponent);\n\n  function PersistGate() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, PersistGate);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(PersistGate)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      bootstrapped: false\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_unsubscribe\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"handlePersistorState\", function () {\n      var persistor = _this.props.persistor;\n\n      var _persistor$getState = persistor.getState(),\n          bootstrapped = _persistor$getState.bootstrapped;\n\n      if (bootstrapped) {\n        if (_this.props.onBeforeLift) {\n          Promise.resolve(_this.props.onBeforeLift()).finally(function () {\n            return _this.setState({\n              bootstrapped: true\n            });\n          });\n        } else {\n          _this.setState({\n            bootstrapped: true\n          });\n        }\n\n        _this._unsubscribe && _this._unsubscribe();\n      }\n    });\n\n    return _this;\n  }\n\n  _createClass(PersistGate, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._unsubscribe = this.props.persistor.subscribe(this.handlePersistorState);\n      this.handlePersistorState();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this._unsubscribe && this._unsubscribe();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof this.props.children === 'function' && this.props.loading) console.error('redux-persist: PersistGate expects either a function child or loading prop, but not both. The loading prop will be ignored.');\n      }\n\n      if (typeof this.props.children === 'function') {\n        return this.props.children(this.state.bootstrapped);\n      }\n\n      return this.state.bootstrapped ? this.props.children : this.props.loading;\n    }\n  }]);\n\n  return PersistGate;\n}(PureComponent);\n\n_defineProperty(PersistGate, \"defaultProps\", {\n  children: null,\n  loading: null\n});","import u,{createContext as m,useContext as D,useMemo as l,useState as T}from\"react\";import{useId as P}from'../../hooks/use-id.js';import{forwardRefWithAs as g,render as E}from'../../utils/render.js';import{useIsoMorphicEffect as x}from'../../hooks/use-iso-morphic-effect.js';import{useSyncRefs as R}from'../../hooks/use-sync-refs.js';import{useEvent as I}from'../../hooks/use-event.js';let d=m(null);function f(){let r=D(d);if(r===null){let t=new Error(\"You used a <Description /> component, but it is not inside a relevant parent.\");throw Error.captureStackTrace&&Error.captureStackTrace(t,f),t}return r}function M(){let[r,t]=T([]);return[r.length>0?r.join(\" \"):void 0,l(()=>function(e){let i=I(s=>(t(o=>[...o,s]),()=>t(o=>{let p=o.slice(),c=p.indexOf(s);return c!==-1&&p.splice(c,1),p}))),n=l(()=>({register:i,slot:e.slot,name:e.name,props:e.props}),[i,e.slot,e.name,e.props]);return u.createElement(d.Provider,{value:n},e.children)},[t])]}let S=\"p\";function h(r,t){let a=P(),{id:e=`headlessui-description-${a}`,...i}=r,n=f(),s=R(t);x(()=>n.register(e),[e,n.register]);let o={ref:s,...n.props,id:e};return E({ourProps:o,theirProps:i,slot:n.slot||{},defaultTag:S,name:n.name||\"Description\"})}let y=g(h),b=Object.assign(y,{});export{b as Description,M as useDescriptions};\n","import{useRef as t}from\"react\";import{useWindowEvent as a}from'./use-window-event.js';var s=(r=>(r[r.Forwards=0]=\"Forwards\",r[r.Backwards=1]=\"Backwards\",r))(s||{});function n(){let e=t(0);return a(\"keydown\",o=>{o.key===\"Tab\"&&(e.current=o.shiftKey?1:0)},!0),e}export{s as Direction,n as useTabDirection};\n","import{useEffect as d}from\"react\";import{useLatestValue as s}from'./use-latest-value.js';function E(n,e,a,t){let i=s(a);d(()=>{n=n!=null?n:window;function r(o){i.current(o)}return n.addEventListener(e,r,t),()=>n.removeEventListener(e,r,t)},[n,e,t])}export{E as useEventListener};\n","import{useEffect as s,useRef as f}from\"react\";import{useEvent as i}from'./use-event.js';function m(u,t){let e=f([]),r=i(u);s(()=>{let o=[...e.current];for(let[n,a]of t.entries())if(e.current[n]!==a){let l=r(t,o);return e.current=t,l}},[r,...t])}export{m as useWatch};\n","import{useRef as u,useEffect as n}from\"react\";import{microTask as o}from'../utils/micro-task.js';import{useEvent as f}from'./use-event.js';function c(t){let r=f(t),e=u(!1);n(()=>(e.current=!1,()=>{e.current=!0,o(()=>{e.current&&r()})}),[r])}export{c as useOnUnmount};\n","import E,{useRef as L}from\"react\";import{forwardRefWithAs as U,render as N}from'../../utils/render.js';import{useServerHandoffComplete as I}from'../../hooks/use-server-handoff-complete.js';import{useSyncRefs as x}from'../../hooks/use-sync-refs.js';import{Features as R,Hidden as g}from'../../internal/hidden.js';import{focusElement as f,focusIn as M,Focus as p,FocusResult as w}from'../../utils/focus-management.js';import{match as k}from'../../utils/match.js';import{useEvent as A}from'../../hooks/use-event.js';import{useTabDirection as G,Direction as H}from'../../hooks/use-tab-direction.js';import{useIsMounted as C}from'../../hooks/use-is-mounted.js';import{useOwnerDocument as K}from'../../hooks/use-owner.js';import{useEventListener as W}from'../../hooks/use-event-listener.js';import{microTask as O}from'../../utils/micro-task.js';import{useWatch as F}from'../../hooks/use-watch.js';import{useDisposables as V}from'../../hooks/use-disposables.js';import{onDocumentReady as q}from'../../utils/document-ready.js';import{useOnUnmount as D}from'../../hooks/use-on-unmount.js';function P(t){if(!t)return new Set;if(typeof t==\"function\")return new Set(t());let r=new Set;for(let e of t.current)e.current instanceof HTMLElement&&r.add(e.current);return r}let J=\"div\";var h=(n=>(n[n.None=1]=\"None\",n[n.InitialFocus=2]=\"InitialFocus\",n[n.TabLock=4]=\"TabLock\",n[n.FocusLock=8]=\"FocusLock\",n[n.RestoreFocus=16]=\"RestoreFocus\",n[n.All=30]=\"All\",n))(h||{});function X(t,r){let e=L(null),o=x(e,r),{initialFocus:u,containers:i,features:n=30,...l}=t;I()||(n=1);let m=K(e);Y({ownerDocument:m},Boolean(n&16));let c=Z({ownerDocument:m,container:e,initialFocus:u},Boolean(n&2));$({ownerDocument:m,container:e,containers:i,previousActiveElement:c},Boolean(n&8));let v=G(),y=A(s=>{let T=e.current;if(!T)return;(B=>B())(()=>{k(v.current,{[H.Forwards]:()=>{M(T,p.First,{skipElements:[s.relatedTarget]})},[H.Backwards]:()=>{M(T,p.Last,{skipElements:[s.relatedTarget]})}})})}),_=V(),b=L(!1),j={ref:o,onKeyDown(s){s.key==\"Tab\"&&(b.current=!0,_.requestAnimationFrame(()=>{b.current=!1}))},onBlur(s){let T=P(i);e.current instanceof HTMLElement&&T.add(e.current);let d=s.relatedTarget;d instanceof HTMLElement&&d.dataset.headlessuiFocusGuard!==\"true\"&&(S(T,d)||(b.current?M(e.current,k(v.current,{[H.Forwards]:()=>p.Next,[H.Backwards]:()=>p.Previous})|p.WrapAround,{relativeTo:s.target}):s.target instanceof HTMLElement&&f(s.target)))}};return E.createElement(E.Fragment,null,Boolean(n&4)&&E.createElement(g,{as:\"button\",type:\"button\",\"data-headlessui-focus-guard\":!0,onFocus:y,features:R.Focusable}),N({ourProps:j,theirProps:l,defaultTag:J,name:\"FocusTrap\"}),Boolean(n&4)&&E.createElement(g,{as:\"button\",type:\"button\",\"data-headlessui-focus-guard\":!0,onFocus:y,features:R.Focusable}))}let z=U(X),ge=Object.assign(z,{features:h}),a=[];q(()=>{function t(r){r.target instanceof HTMLElement&&r.target!==document.body&&a[0]!==r.target&&(a.unshift(r.target),a=a.filter(e=>e!=null&&e.isConnected),a.splice(10))}window.addEventListener(\"click\",t,{capture:!0}),window.addEventListener(\"mousedown\",t,{capture:!0}),window.addEventListener(\"focus\",t,{capture:!0}),document.body.addEventListener(\"click\",t,{capture:!0}),document.body.addEventListener(\"mousedown\",t,{capture:!0}),document.body.addEventListener(\"focus\",t,{capture:!0})});function Q(t=!0){let r=L(a.slice());return F(([e],[o])=>{o===!0&&e===!1&&O(()=>{r.current.splice(0)}),o===!1&&e===!0&&(r.current=a.slice())},[t,a,r]),A(()=>{var e;return(e=r.current.find(o=>o!=null&&o.isConnected))!=null?e:null})}function Y({ownerDocument:t},r){let e=Q(r);F(()=>{r||(t==null?void 0:t.activeElement)===(t==null?void 0:t.body)&&f(e())},[r]),D(()=>{r&&f(e())})}function Z({ownerDocument:t,container:r,initialFocus:e},o){let u=L(null),i=C();return F(()=>{if(!o)return;let n=r.current;n&&O(()=>{if(!i.current)return;let l=t==null?void 0:t.activeElement;if(e!=null&&e.current){if((e==null?void 0:e.current)===l){u.current=l;return}}else if(n.contains(l)){u.current=l;return}e!=null&&e.current?f(e.current):M(n,p.First)===w.Error&&console.warn(\"There are no focusable elements inside the <FocusTrap />\"),u.current=t==null?void 0:t.activeElement})},[o]),u}function $({ownerDocument:t,container:r,containers:e,previousActiveElement:o},u){let i=C();W(t==null?void 0:t.defaultView,\"focus\",n=>{if(!u||!i.current)return;let l=P(e);r.current instanceof HTMLElement&&l.add(r.current);let m=o.current;if(!m)return;let c=n.target;c&&c instanceof HTMLElement?S(l,c)?(o.current=c,f(c)):(n.preventDefault(),n.stopPropagation(),f(m)):f(o.current)},!0)}function S(t,r){for(let e of t)if(e.contains(r))return!0;return!1}export{ge as FocusTrap};\n","function t(n){function e(){document.readyState!==\"loading\"&&(n(),document.removeEventListener(\"DOMContentLoaded\",e))}typeof window!=\"undefined\"&&typeof document!=\"undefined\"&&(document.addEventListener(\"DOMContentLoaded\",e),e())}export{t as onDocumentReady};\n","import t,{createContext as r,useContext as c}from\"react\";let e=r(!1);function l(){return c(e)}function P(o){return t.createElement(e.Provider,{value:o.force},o.children)}export{P as ForcePortalRoot,l as usePortalRoot};\n","import T,{Fragment as P,createContext as m,useContext as s,useEffect as d,useRef as g,useState as R,useMemo as E}from\"react\";import{createPortal as H}from\"react-dom\";import{forwardRefWithAs as c,render as y}from'../../utils/render.js';import{useIsoMorphicEffect as x}from'../../hooks/use-iso-morphic-effect.js';import{usePortalRoot as b}from'../../internal/portal-force-root.js';import{useServerHandoffComplete as h}from'../../hooks/use-server-handoff-complete.js';import{optionalRef as O,useSyncRefs as L}from'../../hooks/use-sync-refs.js';import{useOnUnmount as _}from'../../hooks/use-on-unmount.js';import{useOwnerDocument as A}from'../../hooks/use-owner.js';import{env as G}from'../../utils/env.js';import{useEvent as M}from'../../hooks/use-event.js';function F(p){let l=b(),n=s(v),e=A(p),[a,o]=R(()=>{if(!l&&n!==null||G.isServer)return null;let t=e==null?void 0:e.getElementById(\"headlessui-portal-root\");if(t)return t;if(e===null)return null;let r=e.createElement(\"div\");return r.setAttribute(\"id\",\"headlessui-portal-root\"),e.body.appendChild(r)});return d(()=>{a!==null&&(e!=null&&e.body.contains(a)||e==null||e.body.appendChild(a))},[a,e]),d(()=>{l||n!==null&&o(n.current)},[n,o,l]),a}let U=P;function N(p,l){let n=p,e=g(null),a=L(O(u=>{e.current=u}),l),o=A(e),t=F(e),[r]=R(()=>{var u;return G.isServer?null:(u=o==null?void 0:o.createElement(\"div\"))!=null?u:null}),i=s(f),C=h();return x(()=>{!t||!r||t.contains(r)||(r.setAttribute(\"data-headlessui-portal\",\"\"),t.appendChild(r))},[t,r]),x(()=>{if(r&&i)return i.register(r)},[i,r]),_(()=>{var u;!t||!r||(r instanceof Node&&t.contains(r)&&t.removeChild(r),t.childNodes.length<=0&&((u=t.parentElement)==null||u.removeChild(t)))}),C?!t||!r?null:H(y({ourProps:{ref:a},theirProps:n,defaultTag:U,name:\"Portal\"}),r):null}let S=P,v=m(null);function j(p,l){let{target:n,...e}=p,o={ref:L(l)};return T.createElement(v.Provider,{value:n},y({ourProps:o,theirProps:e,defaultTag:S,name:\"Popover.Group\"}))}let f=m(null);function ae(){let p=s(f),l=g([]),n=M(o=>(l.current.push(o),p&&p.register(o),()=>e(o))),e=M(o=>{let t=l.current.indexOf(o);t!==-1&&l.current.splice(t,1),p&&p.unregister(o)}),a=E(()=>({register:n,unregister:e,portals:l}),[n,e,l]);return[l,E(()=>function({children:t}){return T.createElement(f.Provider,{value:a},t)},[a])]}let D=c(N),I=c(j),pe=Object.assign(D,{Group:I});export{pe as Portal,ae as useNestedPortals};\n","import d,{createContext as c,useContext as m}from\"react\";import{useIsoMorphicEffect as f}from'../hooks/use-iso-morphic-effect.js';import{useEvent as p}from'../hooks/use-event.js';let a=c(()=>{});a.displayName=\"StackContext\";var s=(e=>(e[e.Add=0]=\"Add\",e[e.Remove=1]=\"Remove\",e))(s||{});function x(){return m(a)}function M({children:i,onUpdate:r,type:e,element:n,enabled:u}){let l=x(),o=p((...t)=>{r==null||r(...t),l(...t)});return f(()=>{let t=u===void 0||u===!0;return t&&o(0,e,n),()=>{t&&o(1,e,n)}},[o,e,n,u]),d.createElement(a.Provider,{value:o},i)}export{s as StackMessage,M as StackProvider,x as useStackContext};\n","import*as l from\"react\";function i(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}const d=typeof Object.is==\"function\"?Object.is:i,{useState:u,useEffect:h,useLayoutEffect:f,useDebugValue:p}=l;let S=!1,_=!1;function y(e,t,c){const a=t(),[{inst:n},o]=u({inst:{value:a,getSnapshot:t}});return f(()=>{n.value=a,n.getSnapshot=t,r(n)&&o({inst:n})},[e,a,t]),h(()=>(r(n)&&o({inst:n}),e(()=>{r(n)&&o({inst:n})})),[e]),p(a),a}function r(e){const t=e.getSnapshot,c=e.value;try{const a=t();return!d(c,a)}catch{return!0}}export{y as useSyncExternalStore};\n","import*as e from\"react\";import{useSyncExternalStore as t}from'./useSyncExternalStoreShimClient.js';import{useSyncExternalStore as o}from'./useSyncExternalStoreShimServer.js';const r=typeof window!=\"undefined\"&&typeof window.document!=\"undefined\"&&typeof window.document.createElement!=\"undefined\",s=!r,c=s?o:t,a=\"useSyncExternalStore\"in e?(n=>n.useSyncExternalStore)(e):c;export{a as useSyncExternalStore};\n","function c(){let o;return{before({doc:e}){var l;let n=e.documentElement;o=((l=e.defaultView)!=null?l:window).innerWidth-n.clientWidth},after({doc:e,d:n}){let t=e.documentElement,l=t.clientWidth-t.offsetWidth,r=o-l;n.style(t,\"paddingRight\",`${r}px`)}}}export{c as adjustScrollbarPadding};\n","function t(){return/iPhone/gi.test(window.navigator.platform)||/Mac/gi.test(window.navigator.platform)&&window.navigator.maxTouchPoints>0}function i(){return/Android/gi.test(window.navigator.userAgent)}function n(){return t()||i()}export{i as isAndroid,t as isIOS,n as isMobile};\n","import{disposables as m}from'../../utils/disposables.js';import{isIOS as f}from'../../utils/platform.js';function T(){if(!f())return{};let l;return{before(){l=window.pageYOffset},after({doc:o,d:t,meta:s}){function i(n){return s.containers.flatMap(e=>e()).some(e=>e.contains(n))}t.microTask(()=>{if(window.getComputedStyle(o.documentElement).scrollBehavior!==\"auto\"){let e=m();e.style(o.documentElement,\"scroll-behavior\",\"auto\"),t.add(()=>t.microTask(()=>e.dispose()))}t.style(o.body,\"marginTop\",`-${l}px`),window.scrollTo(0,0);let n=null;t.addEventListener(o,\"click\",e=>{if(e.target instanceof HTMLElement)try{let r=e.target.closest(\"a\");if(!r)return;let{hash:c}=new URL(r.href),a=o.querySelector(c);a&&!i(a)&&(n=a)}catch{}},!0),t.addEventListener(o,\"touchmove\",e=>{e.target instanceof HTMLElement&&!i(e.target)&&e.preventDefault()},{passive:!1}),t.add(()=>{window.scrollTo(0,window.pageYOffset+l),n&&n.isConnected&&(n.scrollIntoView({block:\"nearest\"}),n=null)})})}}}export{T as handleIOSLocking};\n","import{disposables as s}from'../../utils/disposables.js';import{createStore as i}from'../../utils/store.js';import{adjustScrollbarPadding as l}from'./adjust-scrollbar-padding.js';import{handleIOSLocking as d}from'./handle-ios-locking.js';import{preventScroll as p}from'./prevent-scroll.js';function m(e){let n={};for(let t of e)Object.assign(n,t(n));return n}let a=i(()=>new Map,{PUSH(e,n){var o;let t=(o=this.get(e))!=null?o:{doc:e,count:0,d:s(),meta:new Set};return t.count++,t.meta.add(n),this.set(e,t),this},POP(e,n){let t=this.get(e);return t&&(t.count--,t.meta.delete(n)),this},SCROLL_PREVENT({doc:e,d:n,meta:t}){let o={doc:e,d:n,meta:m(t)},c=[d(),l(),p()];c.forEach(({before:r})=>r==null?void 0:r(o)),c.forEach(({after:r})=>r==null?void 0:r(o))},SCROLL_ALLOW({d:e}){e.dispose()},TEARDOWN({doc:e}){this.delete(e)}});a.subscribe(()=>{let e=a.getSnapshot(),n=new Map;for(let[t]of e)n.set(t,t.documentElement.style.overflow);for(let t of e.values()){let o=n.get(t.doc)===\"hidden\",c=t.count!==0;(c&&!o||!c&&o)&&a.dispatch(t.count>0?\"SCROLL_PREVENT\":\"SCROLL_ALLOW\",t),t.count===0&&a.dispatch(\"TEARDOWN\",t)}});export{a as overflows};\n","function a(o,r){let t=o(),n=new Set;return{getSnapshot(){return t},subscribe(e){return n.add(e),()=>n.delete(e)},dispatch(e,...s){let i=r[e].call(t,...s);i&&(t=i,n.forEach(c=>c()))}}}export{a as createStore};\n","function l(){return{before({doc:e,d:o}){o.style(e.documentElement,\"overflow\",\"hidden\")}}}export{l as preventScroll};\n","import{useIsoMorphicEffect as u}from'../use-iso-morphic-effect.js';import{useStore as s}from'../../hooks/use-store.js';import{overflows as t}from'./overflow-store.js';function p(e,r,n){let f=s(t),o=e?f.get(e):void 0,i=o?o.count>0:!1;return u(()=>{if(!(!e||!r))return t.dispatch(\"PUSH\",e,n),()=>t.dispatch(\"POP\",e,n)},[r,e]),i}export{p as useDocumentOverflowLockedEffect};\n","import{useSyncExternalStore as r}from'../use-sync-external-store-shim/index.js';function S(t){return r(t.subscribe,t.getSnapshot,t.getSnapshot)}export{S as useStore};\n","import{useIsoMorphicEffect as s}from'./use-iso-morphic-effect.js';let u=new Map,t=new Map;function h(r,l=!0){s(()=>{var o;if(!l)return;let e=typeof r==\"function\"?r():r.current;if(!e)return;function a(){var d;if(!e)return;let i=(d=t.get(e))!=null?d:1;if(i===1?t.delete(e):t.set(e,i-1),i!==1)return;let n=u.get(e);n&&(n[\"aria-hidden\"]===null?e.removeAttribute(\"aria-hidden\"):e.setAttribute(\"aria-hidden\",n[\"aria-hidden\"]),e.inert=n.inert,u.delete(e))}let f=(o=t.get(e))!=null?o:0;return t.set(e,f+1),f!==0||(u.set(e,{\"aria-hidden\":e.getAttribute(\"aria-hidden\"),inert:e.inert}),e.setAttribute(\"aria-hidden\",\"true\"),e.inert=!0),a},[r,l])}export{h as useInert};\n","import u,{createContext as ce,createRef as De,useCallback as j,useContext as K,useEffect as w,useMemo as y,useReducer as me,useRef as Pe,useState as ye}from\"react\";import{match as B}from'../../utils/match.js';import{forwardRefWithAs as E,render as A,Features as V}from'../../utils/render.js';import{useSyncRefs as R}from'../../hooks/use-sync-refs.js';import{Keys as Ee}from'../keyboard.js';import{isDisabledReactIssue7711 as Ae}from'../../utils/bugs.js';import{useId as C}from'../../hooks/use-id.js';import{FocusTrap as v}from'../../components/focus-trap/focus-trap.js';import{Portal as H,useNestedPortals as Re}from'../../components/portal/portal.js';import{ForcePortalRoot as G}from'../../internal/portal-force-root.js';import{Description as Ce,useDescriptions as ve}from'../description/description.js';import{useOpenClosed as Oe,State as _}from'../../internal/open-closed.js';import{useServerHandoffComplete as be}from'../../hooks/use-server-handoff-complete.js';import{StackProvider as he,StackMessage as q}from'../../internal/stack-context.js';import{useOutsideClick as Se}from'../../hooks/use-outside-click.js';import{useOwnerDocument as Le}from'../../hooks/use-owner.js';import{useEventListener as Fe}from'../../hooks/use-event-listener.js';import{useEvent as O}from'../../hooks/use-event.js';import{useDocumentOverflowLockedEffect as ke}from'../../hooks/document-overflow/use-document-overflow.js';import{useInert as z}from'../../hooks/use-inert.js';import{useRootContainers as xe}from'../../hooks/use-root-containers.js';var _e=(o=>(o[o.Open=0]=\"Open\",o[o.Closed=1]=\"Closed\",o))(_e||{}),Ie=(e=>(e[e.SetTitleId=0]=\"SetTitleId\",e))(Ie||{});let Me={[0](t,e){return t.titleId===e.id?t:{...t,titleId:e.id}}},I=ce(null);I.displayName=\"DialogContext\";function b(t){let e=K(I);if(e===null){let o=new Error(`<${t} /> is missing a parent <Dialog /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,b),o}return e}function we(t,e,o=()=>[document.body]){ke(t,e,i=>{var n;return{containers:[...(n=i.containers)!=null?n:[],o]}})}function Be(t,e){return B(e.type,Me,t,e)}let He=\"div\",Ge=V.RenderStrategy|V.Static;function Ne(t,e){var X;let o=C(),{id:i=`headlessui-dialog-${o}`,open:n,onClose:l,initialFocus:s,__demoMode:g=!1,...T}=t,[m,h]=ye(0),a=Oe();n===void 0&&a!==null&&(n=(a&_.Open)===_.Open);let D=Pe(null),Q=R(D,e),f=Le(D),N=t.hasOwnProperty(\"open\")||a!==null,U=t.hasOwnProperty(\"onClose\");if(!N&&!U)throw new Error(\"You have to provide an `open` and an `onClose` prop to the `Dialog` component.\");if(!N)throw new Error(\"You provided an `onClose` prop to the `Dialog`, but forgot an `open` prop.\");if(!U)throw new Error(\"You provided an `open` prop to the `Dialog`, but forgot an `onClose` prop.\");if(typeof n!=\"boolean\")throw new Error(`You provided an \\`open\\` prop to the \\`Dialog\\`, but the value is not a boolean. Received: ${n}`);if(typeof l!=\"function\")throw new Error(`You provided an \\`onClose\\` prop to the \\`Dialog\\`, but the value is not a function. Received: ${l}`);let p=n?0:1,[S,Z]=me(Be,{titleId:null,descriptionId:null,panelRef:De()}),P=O(()=>l(!1)),W=O(r=>Z({type:0,id:r})),L=be()?g?!1:p===0:!1,F=m>1,Y=K(I)!==null,[ee,te]=Re(),{resolveContainers:M,mainTreeNodeRef:k,MainTreeNode:oe}=xe({portals:ee,defaultContainers:[(X=S.panelRef.current)!=null?X:D.current]}),re=F?\"parent\":\"leaf\",$=a!==null?(a&_.Closing)===_.Closing:!1,ne=(()=>Y||$?!1:L)(),le=j(()=>{var r,c;return(c=Array.from((r=f==null?void 0:f.querySelectorAll(\"body > *\"))!=null?r:[]).find(d=>d.id===\"headlessui-portal-root\"?!1:d.contains(k.current)&&d instanceof HTMLElement))!=null?c:null},[k]);z(le,ne);let ae=(()=>F?!0:L)(),ie=j(()=>{var r,c;return(c=Array.from((r=f==null?void 0:f.querySelectorAll(\"[data-headlessui-portal]\"))!=null?r:[]).find(d=>d.contains(k.current)&&d instanceof HTMLElement))!=null?c:null},[k]);z(ie,ae);let se=(()=>!(!L||F))();Se(M,P,se);let pe=(()=>!(F||p!==0))();Fe(f==null?void 0:f.defaultView,\"keydown\",r=>{pe&&(r.defaultPrevented||r.key===Ee.Escape&&(r.preventDefault(),r.stopPropagation(),P()))});let de=(()=>!($||p!==0||Y))();we(f,de,M),w(()=>{if(p!==0||!D.current)return;let r=new ResizeObserver(c=>{for(let d of c){let x=d.target.getBoundingClientRect();x.x===0&&x.y===0&&x.width===0&&x.height===0&&P()}});return r.observe(D.current),()=>r.disconnect()},[p,D,P]);let[ue,fe]=ve(),ge=y(()=>[{dialogState:p,close:P,setTitleId:W},S],[p,S,P,W]),J=y(()=>({open:p===0}),[p]),Te={ref:Q,id:i,role:\"dialog\",\"aria-modal\":p===0?!0:void 0,\"aria-labelledby\":S.titleId,\"aria-describedby\":ue};return u.createElement(he,{type:\"Dialog\",enabled:p===0,element:D,onUpdate:O((r,c)=>{c===\"Dialog\"&&B(r,{[q.Add]:()=>h(d=>d+1),[q.Remove]:()=>h(d=>d-1)})})},u.createElement(G,{force:!0},u.createElement(H,null,u.createElement(I.Provider,{value:ge},u.createElement(H.Group,{target:D},u.createElement(G,{force:!1},u.createElement(fe,{slot:J,name:\"Dialog.Description\"},u.createElement(v,{initialFocus:s,containers:M,features:L?B(re,{parent:v.features.RestoreFocus,leaf:v.features.All&~v.features.FocusLock}):v.features.None},u.createElement(te,null,A({ourProps:Te,theirProps:T,slot:J,defaultTag:He,features:Ge,visible:p===0,name:\"Dialog\"}))))))))),u.createElement(oe,null))}let Ue=\"div\";function We(t,e){let o=C(),{id:i=`headlessui-dialog-overlay-${o}`,...n}=t,[{dialogState:l,close:s}]=b(\"Dialog.Overlay\"),g=R(e),T=O(a=>{if(a.target===a.currentTarget){if(Ae(a.currentTarget))return a.preventDefault();a.preventDefault(),a.stopPropagation(),s()}}),m=y(()=>({open:l===0}),[l]);return A({ourProps:{ref:g,id:i,\"aria-hidden\":!0,onClick:T},theirProps:n,slot:m,defaultTag:Ue,name:\"Dialog.Overlay\"})}let Ye=\"div\";function $e(t,e){let o=C(),{id:i=`headlessui-dialog-backdrop-${o}`,...n}=t,[{dialogState:l},s]=b(\"Dialog.Backdrop\"),g=R(e);w(()=>{if(s.panelRef.current===null)throw new Error(\"A <Dialog.Backdrop /> component is being used, but a <Dialog.Panel /> component is missing.\")},[s.panelRef]);let T=y(()=>({open:l===0}),[l]);return u.createElement(G,{force:!0},u.createElement(H,null,A({ourProps:{ref:g,id:i,\"aria-hidden\":!0},theirProps:n,slot:T,defaultTag:Ye,name:\"Dialog.Backdrop\"})))}let Je=\"div\";function Xe(t,e){let o=C(),{id:i=`headlessui-dialog-panel-${o}`,...n}=t,[{dialogState:l},s]=b(\"Dialog.Panel\"),g=R(e,s.panelRef),T=y(()=>({open:l===0}),[l]),m=O(a=>{a.stopPropagation()});return A({ourProps:{ref:g,id:i,onClick:m},theirProps:n,slot:T,defaultTag:Je,name:\"Dialog.Panel\"})}let je=\"h2\";function Ke(t,e){let o=C(),{id:i=`headlessui-dialog-title-${o}`,...n}=t,[{dialogState:l,setTitleId:s}]=b(\"Dialog.Title\"),g=R(e);w(()=>(s(i),()=>s(null)),[i,s]);let T=y(()=>({open:l===0}),[l]);return A({ourProps:{ref:g,id:i},theirProps:n,slot:T,defaultTag:je,name:\"Dialog.Title\"})}let Ve=E(Ne),qe=E($e),ze=E(Xe),Qe=E(We),Ze=E(Ke),_t=Object.assign(Ve,{Backdrop:qe,Panel:ze,Overlay:Qe,Title:Ze,Description:Ce});export{_t as Dialog};\n","import s,{useRef as a,useMemo as m}from\"react\";import{Hidden as M,Features as d}from'../internal/hidden.js';import{useEvent as H}from'./use-event.js';import{useOwnerDocument as E}from'./use-owner.js';function j({defaultContainers:t=[],portals:r,mainTreeNodeRef:u}={}){var c;let o=a((c=u==null?void 0:u.current)!=null?c:null),l=E(o),f=H(()=>{var i;let n=[];for(let e of t)e!==null&&(e instanceof HTMLElement?n.push(e):\"current\"in e&&e.current instanceof HTMLElement&&n.push(e.current));if(r!=null&&r.current)for(let e of r.current)n.push(e);for(let e of(i=l==null?void 0:l.querySelectorAll(\"html > *, body > *\"))!=null?i:[])e!==document.body&&e!==document.head&&e instanceof HTMLElement&&e.id!==\"headlessui-portal-root\"&&(e.contains(o.current)||n.some(T=>e.contains(T))||n.push(e));return n});return{resolveContainers:f,contains:H(n=>f().some(i=>i.contains(n))),mainTreeNodeRef:o,MainTreeNode:m(()=>function(){return u!=null?null:s.createElement(M,{features:d.Hidden,ref:o})},[o,u])}}function y(){let t=a(null);return{mainTreeNodeRef:t,MainTreeNode:m(()=>function(){return s.createElement(M,{features:d.Hidden,ref:t})},[t])}}export{y as useMainTreeNode,j as useRootContainers};\n","import G,{Fragment as N,createContext as X,createRef as H,useContext as $,useEffect as q,useMemo as x,useReducer as z,useRef as K}from\"react\";import{match as j}from'../../utils/match.js';import{forwardRefWithAs as h,render as D,Features as Q}from'../../utils/render.js';import{disposables as _}from'../../utils/disposables.js';import{useDisposables as W}from'../../hooks/use-disposables.js';import{useIsoMorphicEffect as L}from'../../hooks/use-iso-morphic-effect.js';import{useSyncRefs as F}from'../../hooks/use-sync-refs.js';import{useId as k}from'../../hooks/use-id.js';import{Keys as c}from'../keyboard.js';import{Focus as y,calculateActiveIndex as Y}from'../../utils/calculate-active-index.js';import{isDisabledReactIssue7711 as Z}from'../../utils/bugs.js';import{isFocusableElement as ee,FocusableMode as te,sortByDomNode as ne,Focus as V,focusFrom as re,restoreFocusIfNecessary as J}from'../../utils/focus-management.js';import{useOutsideClick as oe}from'../../hooks/use-outside-click.js';import{useTreeWalker as ae}from'../../hooks/use-tree-walker.js';import{useOpenClosed as se,State as C,OpenClosedProvider as ie}from'../../internal/open-closed.js';import{useResolveButtonType as ue}from'../../hooks/use-resolve-button-type.js';import{useOwnerDocument as le}from'../../hooks/use-owner.js';import{useEvent as d}from'../../hooks/use-event.js';import{useTrackedPointer as pe}from'../../hooks/use-tracked-pointer.js';import{useTextValue as ce}from'../../hooks/use-text-value.js';var me=(r=>(r[r.Open=0]=\"Open\",r[r.Closed=1]=\"Closed\",r))(me||{}),de=(r=>(r[r.Pointer=0]=\"Pointer\",r[r.Other=1]=\"Other\",r))(de||{}),fe=(a=>(a[a.OpenMenu=0]=\"OpenMenu\",a[a.CloseMenu=1]=\"CloseMenu\",a[a.GoToItem=2]=\"GoToItem\",a[a.Search=3]=\"Search\",a[a.ClearSearch=4]=\"ClearSearch\",a[a.RegisterItem=5]=\"RegisterItem\",a[a.UnregisterItem=6]=\"UnregisterItem\",a))(fe||{});function w(e,u=r=>r){let r=e.activeItemIndex!==null?e.items[e.activeItemIndex]:null,i=ne(u(e.items.slice()),t=>t.dataRef.current.domRef.current),s=r?i.indexOf(r):null;return s===-1&&(s=null),{items:i,activeItemIndex:s}}let Te={[1](e){return e.menuState===1?e:{...e,activeItemIndex:null,menuState:1}},[0](e){return e.menuState===0?e:{...e,__demoMode:!1,menuState:0}},[2]:(e,u)=>{var s;let r=w(e),i=Y(u,{resolveItems:()=>r.items,resolveActiveIndex:()=>r.activeItemIndex,resolveId:t=>t.id,resolveDisabled:t=>t.dataRef.current.disabled});return{...e,...r,searchQuery:\"\",activeItemIndex:i,activationTrigger:(s=u.trigger)!=null?s:1}},[3]:(e,u)=>{let i=e.searchQuery!==\"\"?0:1,s=e.searchQuery+u.value.toLowerCase(),o=(e.activeItemIndex!==null?e.items.slice(e.activeItemIndex+i).concat(e.items.slice(0,e.activeItemIndex+i)):e.items).find(l=>{var m;return((m=l.dataRef.current.textValue)==null?void 0:m.startsWith(s))&&!l.dataRef.current.disabled}),a=o?e.items.indexOf(o):-1;return a===-1||a===e.activeItemIndex?{...e,searchQuery:s}:{...e,searchQuery:s,activeItemIndex:a,activationTrigger:1}},[4](e){return e.searchQuery===\"\"?e:{...e,searchQuery:\"\",searchActiveItemIndex:null}},[5]:(e,u)=>{let r=w(e,i=>[...i,{id:u.id,dataRef:u.dataRef}]);return{...e,...r}},[6]:(e,u)=>{let r=w(e,i=>{let s=i.findIndex(t=>t.id===u.id);return s!==-1&&i.splice(s,1),i});return{...e,...r,activationTrigger:1}}},U=X(null);U.displayName=\"MenuContext\";function O(e){let u=$(U);if(u===null){let r=new Error(`<${e} /> is missing a parent <Menu /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(r,O),r}return u}function ye(e,u){return j(u.type,Te,e,u)}let Ie=N;function Me(e,u){let{__demoMode:r=!1,...i}=e,s=z(ye,{__demoMode:r,menuState:r?0:1,buttonRef:H(),itemsRef:H(),items:[],searchQuery:\"\",activeItemIndex:null,activationTrigger:1}),[{menuState:t,itemsRef:o,buttonRef:a},l]=s,m=F(u);oe([a,o],(g,R)=>{var p;l({type:1}),ee(R,te.Loose)||(g.preventDefault(),(p=a.current)==null||p.focus())},t===0);let I=d(()=>{l({type:1})}),A=x(()=>({open:t===0,close:I}),[t,I]),f={ref:m};return G.createElement(U.Provider,{value:s},G.createElement(ie,{value:j(t,{[0]:C.Open,[1]:C.Closed})},D({ourProps:f,theirProps:i,slot:A,defaultTag:Ie,name:\"Menu\"})))}let ge=\"button\";function Re(e,u){var R;let r=k(),{id:i=`headlessui-menu-button-${r}`,...s}=e,[t,o]=O(\"Menu.Button\"),a=F(t.buttonRef,u),l=W(),m=d(p=>{switch(p.key){case c.Space:case c.Enter:case c.ArrowDown:p.preventDefault(),p.stopPropagation(),o({type:0}),l.nextFrame(()=>o({type:2,focus:y.First}));break;case c.ArrowUp:p.preventDefault(),p.stopPropagation(),o({type:0}),l.nextFrame(()=>o({type:2,focus:y.Last}));break}}),I=d(p=>{switch(p.key){case c.Space:p.preventDefault();break}}),A=d(p=>{if(Z(p.currentTarget))return p.preventDefault();e.disabled||(t.menuState===0?(o({type:1}),l.nextFrame(()=>{var M;return(M=t.buttonRef.current)==null?void 0:M.focus({preventScroll:!0})})):(p.preventDefault(),o({type:0})))}),f=x(()=>({open:t.menuState===0}),[t]),g={ref:a,id:i,type:ue(e,t.buttonRef),\"aria-haspopup\":\"menu\",\"aria-controls\":(R=t.itemsRef.current)==null?void 0:R.id,\"aria-expanded\":t.menuState===0,onKeyDown:m,onKeyUp:I,onClick:A};return D({ourProps:g,theirProps:s,slot:f,defaultTag:ge,name:\"Menu.Button\"})}let Ae=\"div\",be=Q.RenderStrategy|Q.Static;function Ee(e,u){var M,b;let r=k(),{id:i=`headlessui-menu-items-${r}`,...s}=e,[t,o]=O(\"Menu.Items\"),a=F(t.itemsRef,u),l=le(t.itemsRef),m=W(),I=se(),A=(()=>I!==null?(I&C.Open)===C.Open:t.menuState===0)();q(()=>{let n=t.itemsRef.current;n&&t.menuState===0&&n!==(l==null?void 0:l.activeElement)&&n.focus({preventScroll:!0})},[t.menuState,t.itemsRef,l]),ae({container:t.itemsRef.current,enabled:t.menuState===0,accept(n){return n.getAttribute(\"role\")===\"menuitem\"?NodeFilter.FILTER_REJECT:n.hasAttribute(\"role\")?NodeFilter.FILTER_SKIP:NodeFilter.FILTER_ACCEPT},walk(n){n.setAttribute(\"role\",\"none\")}});let f=d(n=>{var E,P;switch(m.dispose(),n.key){case c.Space:if(t.searchQuery!==\"\")return n.preventDefault(),n.stopPropagation(),o({type:3,value:n.key});case c.Enter:if(n.preventDefault(),n.stopPropagation(),o({type:1}),t.activeItemIndex!==null){let{dataRef:S}=t.items[t.activeItemIndex];(P=(E=S.current)==null?void 0:E.domRef.current)==null||P.click()}J(t.buttonRef.current);break;case c.ArrowDown:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:y.Next});case c.ArrowUp:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:y.Previous});case c.Home:case c.PageUp:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:y.First});case c.End:case c.PageDown:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:y.Last});case c.Escape:n.preventDefault(),n.stopPropagation(),o({type:1}),_().nextFrame(()=>{var S;return(S=t.buttonRef.current)==null?void 0:S.focus({preventScroll:!0})});break;case c.Tab:n.preventDefault(),n.stopPropagation(),o({type:1}),_().nextFrame(()=>{re(t.buttonRef.current,n.shiftKey?V.Previous:V.Next)});break;default:n.key.length===1&&(o({type:3,value:n.key}),m.setTimeout(()=>o({type:4}),350));break}}),g=d(n=>{switch(n.key){case c.Space:n.preventDefault();break}}),R=x(()=>({open:t.menuState===0}),[t]),p={\"aria-activedescendant\":t.activeItemIndex===null||(M=t.items[t.activeItemIndex])==null?void 0:M.id,\"aria-labelledby\":(b=t.buttonRef.current)==null?void 0:b.id,id:i,onKeyDown:f,onKeyUp:g,role:\"menu\",tabIndex:0,ref:a};return D({ourProps:p,theirProps:s,slot:R,defaultTag:Ae,features:be,visible:A,name:\"Menu.Items\"})}let Se=N;function Pe(e,u){let r=k(),{id:i=`headlessui-menu-item-${r}`,disabled:s=!1,...t}=e,[o,a]=O(\"Menu.Item\"),l=o.activeItemIndex!==null?o.items[o.activeItemIndex].id===i:!1,m=K(null),I=F(u,m);L(()=>{if(o.__demoMode||o.menuState!==0||!l||o.activationTrigger===0)return;let T=_();return T.requestAnimationFrame(()=>{var v,B;(B=(v=m.current)==null?void 0:v.scrollIntoView)==null||B.call(v,{block:\"nearest\"})}),T.dispose},[o.__demoMode,m,l,o.menuState,o.activationTrigger,o.activeItemIndex]);let A=ce(m),f=K({disabled:s,domRef:m,get textValue(){return A()}});L(()=>{f.current.disabled=s},[f,s]),L(()=>(a({type:5,id:i,dataRef:f}),()=>a({type:6,id:i})),[f,i]);let g=d(()=>{a({type:1})}),R=d(T=>{if(s)return T.preventDefault();a({type:1}),J(o.buttonRef.current)}),p=d(()=>{if(s)return a({type:2,focus:y.Nothing});a({type:2,focus:y.Specific,id:i})}),M=pe(),b=d(T=>M.update(T)),n=d(T=>{M.wasMoved(T)&&(s||l||a({type:2,focus:y.Specific,id:i,trigger:0}))}),E=d(T=>{M.wasMoved(T)&&(s||l&&a({type:2,focus:y.Nothing}))}),P=x(()=>({active:l,disabled:s,close:g}),[l,s,g]);return D({ourProps:{id:i,ref:I,role:\"menuitem\",tabIndex:s===!0?void 0:-1,\"aria-disabled\":s===!0?!0:void 0,disabled:void 0,onClick:R,onFocus:p,onPointerEnter:b,onMouseEnter:b,onPointerMove:n,onMouseMove:n,onPointerLeave:E,onMouseLeave:E},theirProps:t,slot:P,defaultTag:Se,name:\"Menu.Item\"})}let ve=h(Me),xe=h(Re),he=h(Ee),De=h(Pe),it=Object.assign(ve,{Button:xe,Items:he,Item:De});export{it as Menu};\n","import c,{createContext as m,useContext as L,useMemo as f,useState as b}from\"react\";import{useId as T}from'../../hooks/use-id.js';import{forwardRefWithAs as E,render as g}from'../../utils/render.js';import{useIsoMorphicEffect as x}from'../../hooks/use-iso-morphic-effect.js';import{useSyncRefs as P}from'../../hooks/use-sync-refs.js';import{useEvent as y}from'../../hooks/use-event.js';let d=m(null);function u(){let o=L(d);if(o===null){let t=new Error(\"You used a <Label /> component, but it is not inside a relevant parent.\");throw Error.captureStackTrace&&Error.captureStackTrace(t,u),t}return o}function H(){let[o,t]=b([]);return[o.length>0?o.join(\" \"):void 0,f(()=>function(e){let s=y(r=>(t(l=>[...l,r]),()=>t(l=>{let n=l.slice(),p=n.indexOf(r);return p!==-1&&n.splice(p,1),n}))),a=f(()=>({register:s,slot:e.slot,name:e.name,props:e.props}),[s,e.slot,e.name,e.props]);return c.createElement(d.Provider,{value:a},e.children)},[t])]}let A=\"label\";function h(o,t){let i=T(),{id:e=`headlessui-label-${i}`,passive:s=!1,...a}=o,r=u(),l=P(t);x(()=>r.register(e),[e,r.register]);let n={ref:l,...r.props,id:e};return s&&(\"onClick\"in n&&(delete n.htmlFor,delete n.onClick),\"onClick\"in a&&delete a.onClick),g({ourProps:n,theirProps:a,slot:r.slot||{},defaultTag:A,name:r.name||\"Label\"})}let v=E(h),M=Object.assign(v,{});export{M as Label,H as useLabels};\n","import O,{createContext as J,useContext as V,useMemo as A,useReducer as se,useRef as j,useEffect as ue}from\"react\";import{forwardRefWithAs as X,render as q,compact as de}from'../../utils/render.js';import{useId as Q}from'../../hooks/use-id.js';import{match as ce}from'../../utils/match.js';import{useIsoMorphicEffect as fe}from'../../hooks/use-iso-morphic-effect.js';import{Keys as D}from'../../components/keyboard.js';import{focusIn as Y,Focus as I,FocusResult as Z,sortByDomNode as Te}from'../../utils/focus-management.js';import{useFlags as me}from'../../hooks/use-flags.js';import{Label as ye,useLabels as z}from'../../components/label/label.js';import{Description as Re,useDescriptions as ee}from'../../components/description/description.js';import{useTreeWalker as be}from'../../hooks/use-tree-walker.js';import{useSyncRefs as te}from'../../hooks/use-sync-refs.js';import{Hidden as ge,Features as Oe}from'../../internal/hidden.js';import{attemptSubmit as Ee,objectToFormEntries as ve}from'../../utils/form.js';import{getOwnerDocument as Pe}from'../../utils/owner.js';import{useEvent as E}from'../../hooks/use-event.js';import{useControllable as Ae}from'../../hooks/use-controllable.js';import{isDisabledReactIssue7711 as re}from'../../utils/bugs.js';import{useLatestValue as De}from'../../hooks/use-latest-value.js';import{useDisposables as Ge}from'../../hooks/use-disposables.js';var Ce=(t=>(t[t.RegisterOption=0]=\"RegisterOption\",t[t.UnregisterOption=1]=\"UnregisterOption\",t))(Ce||{});let ke={[0](r,o){let t=[...r.options,{id:o.id,element:o.element,propsRef:o.propsRef}];return{...r,options:Te(t,p=>p.element.current)}},[1](r,o){let t=r.options.slice(),p=r.options.findIndex(T=>T.id===o.id);return p===-1?r:(t.splice(p,1),{...r,options:t})}},B=J(null);B.displayName=\"RadioGroupDataContext\";function oe(r){let o=V(B);if(o===null){let t=new Error(`<${r} /> is missing a parent <RadioGroup /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(t,oe),t}return o}let $=J(null);$.displayName=\"RadioGroupActionsContext\";function ne(r){let o=V($);if(o===null){let t=new Error(`<${r} /> is missing a parent <RadioGroup /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(t,ne),t}return o}function Le(r,o){return ce(o.type,ke,r,o)}let he=\"div\";function Fe(r,o){let t=Q(),{id:p=`headlessui-radiogroup-${t}`,value:T,defaultValue:v,form:S,name:m,onChange:M,by:G=(e,i)=>e===i,disabled:C=!1,...H}=r,y=E(typeof G==\"string\"?(e,i)=>{let n=G;return(e==null?void 0:e[n])===(i==null?void 0:i[n])}:G),[P,h]=se(Le,{options:[]}),a=P.options,[N,R]=z(),[k,U]=ee(),L=j(null),W=te(L,o),[l,s]=Ae(T,M,v),b=A(()=>a.find(e=>!e.propsRef.current.disabled),[a]),F=A(()=>a.some(e=>y(e.propsRef.current.value,l)),[a,l]),d=E(e=>{var n;if(C||y(e,l))return!1;let i=(n=a.find(f=>y(f.propsRef.current.value,e)))==null?void 0:n.propsRef.current;return i!=null&&i.disabled?!1:(s==null||s(e),!0)});be({container:L.current,accept(e){return e.getAttribute(\"role\")===\"radio\"?NodeFilter.FILTER_REJECT:e.hasAttribute(\"role\")?NodeFilter.FILTER_SKIP:NodeFilter.FILTER_ACCEPT},walk(e){e.setAttribute(\"role\",\"none\")}});let x=E(e=>{let i=L.current;if(!i)return;let n=Pe(i),f=a.filter(u=>u.propsRef.current.disabled===!1).map(u=>u.element.current);switch(e.key){case D.Enter:Ee(e.currentTarget);break;case D.ArrowLeft:case D.ArrowUp:if(e.preventDefault(),e.stopPropagation(),Y(f,I.Previous|I.WrapAround)===Z.Success){let g=a.find(K=>K.element.current===(n==null?void 0:n.activeElement));g&&d(g.propsRef.current.value)}break;case D.ArrowRight:case D.ArrowDown:if(e.preventDefault(),e.stopPropagation(),Y(f,I.Next|I.WrapAround)===Z.Success){let g=a.find(K=>K.element.current===(n==null?void 0:n.activeElement));g&&d(g.propsRef.current.value)}break;case D.Space:{e.preventDefault(),e.stopPropagation();let u=a.find(g=>g.element.current===(n==null?void 0:n.activeElement));u&&d(u.propsRef.current.value)}break}}),c=E(e=>(h({type:0,...e}),()=>h({type:1,id:e.id}))),_=A(()=>({value:l,firstOption:b,containsCheckedOption:F,disabled:C,compare:y,...P}),[l,b,F,C,y,P]),ie=A(()=>({registerOption:c,change:d}),[c,d]),ae={ref:W,id:p,role:\"radiogroup\",\"aria-labelledby\":N,\"aria-describedby\":k,onKeyDown:x},pe=A(()=>({value:l}),[l]),w=j(null),le=Ge();return ue(()=>{w.current&&v!==void 0&&le.addEventListener(w.current,\"reset\",()=>{d(v)})},[w,d]),O.createElement(U,{name:\"RadioGroup.Description\"},O.createElement(R,{name:\"RadioGroup.Label\"},O.createElement($.Provider,{value:ie},O.createElement(B.Provider,{value:_},m!=null&&l!=null&&ve({[m]:l}).map(([e,i],n)=>O.createElement(ge,{features:Oe.Hidden,ref:n===0?f=>{var u;w.current=(u=f==null?void 0:f.closest(\"form\"))!=null?u:null}:void 0,...de({key:e,as:\"input\",type:\"radio\",checked:i!=null,hidden:!0,readOnly:!0,form:S,name:e,value:i})})),q({ourProps:ae,theirProps:H,slot:pe,defaultTag:he,name:\"RadioGroup\"})))))}var xe=(t=>(t[t.Empty=1]=\"Empty\",t[t.Active=2]=\"Active\",t))(xe||{});let _e=\"div\";function we(r,o){var x;let t=Q(),{id:p=`headlessui-radiogroup-option-${t}`,value:T,disabled:v=!1,...S}=r,m=j(null),M=te(m,o),[G,C]=z(),[H,y]=ee(),{addFlag:P,removeFlag:h,hasFlag:a}=me(1),N=De({value:T,disabled:v}),R=oe(\"RadioGroup.Option\"),k=ne(\"RadioGroup.Option\");fe(()=>k.registerOption({id:p,element:m,propsRef:N}),[p,k,m,r]);let U=E(c=>{var _;if(re(c.currentTarget))return c.preventDefault();k.change(T)&&(P(2),(_=m.current)==null||_.focus())}),L=E(c=>{if(re(c.currentTarget))return c.preventDefault();P(2)}),W=E(()=>h(2)),l=((x=R.firstOption)==null?void 0:x.id)===p,s=R.disabled||v,b=R.compare(R.value,T),F={ref:M,id:p,role:\"radio\",\"aria-checked\":b?\"true\":\"false\",\"aria-labelledby\":G,\"aria-describedby\":H,\"aria-disabled\":s?!0:void 0,tabIndex:(()=>s?-1:b||!R.containsCheckedOption&&l?0:-1)(),onClick:s?void 0:U,onFocus:s?void 0:L,onBlur:s?void 0:W},d=A(()=>({checked:b,disabled:s,active:a(2)}),[b,s,a]);return O.createElement(y,{name:\"RadioGroup.Description\"},O.createElement(C,{name:\"RadioGroup.Label\"},q({ourProps:F,theirProps:S,slot:d,defaultTag:_e,name:\"RadioGroup.Option\"})))}let Ie=X(Fe),Se=X(we),yt=Object.assign(Ie,{Option:Se,Label:ye,Description:Re});export{yt as RadioGroup};\n","import{useMemo as t}from\"react\";import{getOwnerDocument as o}from'../utils/owner.js';function n(...e){return t(()=>o(...e),[...e])}export{n as useOwnerDocument};\n","import{useRef as E,useEffect as m}from\"react\";import{useIsoMorphicEffect as T}from'./use-iso-morphic-effect.js';import{getOwnerDocument as N}from'../utils/owner.js';function F({container:e,accept:t,walk:r,enabled:c=!0}){let o=E(t),l=E(r);m(()=>{o.current=t,l.current=r},[t,r]),T(()=>{if(!e||!c)return;let n=N(e);if(!n)return;let f=o.current,p=l.current,d=Object.assign(i=>f(i),{acceptNode:f}),u=n.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,d,!1);for(;u.nextNode();)p(u.currentNode)},[e,c,o,l])}export{F as useTreeWalker};\n","import { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useRef, useContext, useInsertionEffect } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\n\n/**\n * Measurement functionality has to be within a separate component\n * to leverage snapshot lifecycle.\n */\nclass PopChildMeasure extends React.Component {\n    getSnapshotBeforeUpdate(prevProps) {\n        const element = this.props.childRef.current;\n        if (element && prevProps.isPresent && !this.props.isPresent) {\n            const size = this.props.sizeRef.current;\n            size.height = element.offsetHeight || 0;\n            size.width = element.offsetWidth || 0;\n            size.top = element.offsetTop;\n            size.left = element.offsetLeft;\n        }\n        return null;\n    }\n    /**\n     * Required with getSnapshotBeforeUpdate to stop React complaining.\n     */\n    componentDidUpdate() { }\n    render() {\n        return this.props.children;\n    }\n}\nfunction PopChild({ children, isPresent }) {\n    const id = useId();\n    const ref = useRef(null);\n    const size = useRef({\n        width: 0,\n        height: 0,\n        top: 0,\n        left: 0,\n    });\n    const { nonce } = useContext(MotionConfigContext);\n    /**\n     * We create and inject a style block so we can apply this explicit\n     * sizing in a non-destructive manner by just deleting the style block.\n     *\n     * We can't apply size via render as the measurement happens\n     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the\n     * styles directly on the DOM node, we might be overwriting\n     * styles set via the style prop.\n     */\n    useInsertionEffect(() => {\n        const { width, height, top, left } = size.current;\n        if (isPresent || !ref.current || !width || !height)\n            return;\n        ref.current.dataset.motionPopId = id;\n        const style = document.createElement(\"style\");\n        if (nonce)\n            style.nonce = nonce;\n        document.head.appendChild(style);\n        if (style.sheet) {\n            style.sheet.insertRule(`\n          [data-motion-pop-id=\"${id}\"] {\n            position: absolute !important;\n            width: ${width}px !important;\n            height: ${height}px !important;\n            top: ${top}px !important;\n            left: ${left}px !important;\n          }\n        `);\n        }\n        return () => {\n            document.head.removeChild(style);\n        };\n    }, [isPresent]);\n    return (jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref }) }));\n}\n\nexport { PopChild };\n","import { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useMemo } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PopChild } from './PopChild.mjs';\n\nconst PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, }) => {\n    const presenceChildren = useConstant(newChildrenMap);\n    const id = useId();\n    const context = useMemo(() => ({\n        id,\n        initial,\n        isPresent,\n        custom,\n        onExitComplete: (childId) => {\n            presenceChildren.set(childId, true);\n            for (const isComplete of presenceChildren.values()) {\n                if (!isComplete)\n                    return; // can stop searching when any is incomplete\n            }\n            onExitComplete && onExitComplete();\n        },\n        register: (childId) => {\n            presenceChildren.set(childId, false);\n            return () => presenceChildren.delete(childId);\n        },\n    }), \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout ? [Math.random()] : [isPresent]);\n    useMemo(() => {\n        presenceChildren.forEach((_, key) => presenceChildren.set(key, false));\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React.useEffect(() => {\n        !isPresent &&\n            !presenceChildren.size &&\n            onExitComplete &&\n            onExitComplete();\n    }, [isPresent]);\n    if (mode === \"popLayout\") {\n        children = jsx(PopChild, { isPresent: isPresent, children: children });\n    }\n    return (jsx(PresenceContext.Provider, { value: context, children: children }));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nexport { PresenceChild };\n","import { Children, isValidElement } from 'react';\n\nconst getChildKey = (child) => child.key || \"\";\nfunction onlyElements(children) {\n    const filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    Children.forEach(children, (child) => {\n        if (isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n\nexport { getChildKey, onlyElements };\n","import { jsx, Fragment } from 'react/jsx-runtime';\nimport { useMemo, useRef, useState, useContext } from 'react';\nimport { PresenceChild } from './PresenceChild.mjs';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';\nimport { invariant } from '../../utils/errors.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { onlyElements, getChildKey } from './utils.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\n\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nconst AnimatePresence = ({ children, exitBeforeEnter, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = \"sync\", }) => {\n    invariant(!exitBeforeEnter, \"Replace exitBeforeEnter with mode='wait'\");\n    /**\n     * Filter any children that aren't ReactElements. We can only track components\n     * between renders with a props.key.\n     */\n    const presentChildren = useMemo(() => onlyElements(children), [children]);\n    /**\n     * Track the keys of the currently rendered children. This is used to\n     * determine which children are exiting.\n     */\n    const presentKeys = presentChildren.map(getChildKey);\n    /**\n     * If `initial={false}` we only want to pass this to components in the first render.\n     */\n    const isInitialRender = useRef(true);\n    /**\n     * A ref containing the currently present children. When all exit animations\n     * are complete, we use this to re-render the component with the latest children\n     * *committed* rather than the latest children *rendered*.\n     */\n    const pendingPresentChildren = useRef(presentChildren);\n    /**\n     * Track which exiting children have finished animating out.\n     */\n    const exitComplete = useConstant(() => new Map());\n    /**\n     * Save children to render as React state. To ensure this component is concurrent-safe,\n     * we check for exiting children via an effect.\n     */\n    const [diffedChildren, setDiffedChildren] = useState(presentChildren);\n    const [renderedChildren, setRenderedChildren] = useState(presentChildren);\n    useIsomorphicLayoutEffect(() => {\n        isInitialRender.current = false;\n        pendingPresentChildren.current = presentChildren;\n        /**\n         * Update complete status of exiting children.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const key = getChildKey(renderedChildren[i]);\n            if (!presentKeys.includes(key)) {\n                if (exitComplete.get(key) !== true) {\n                    exitComplete.set(key, false);\n                }\n            }\n            else {\n                exitComplete.delete(key);\n            }\n        }\n    }, [renderedChildren, presentKeys.length, presentKeys.join(\"-\")]);\n    const exitingChildren = [];\n    if (presentChildren !== diffedChildren) {\n        let nextChildren = [...presentChildren];\n        /**\n         * Loop through all the currently rendered components and decide which\n         * are exiting.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const child = renderedChildren[i];\n            const key = getChildKey(child);\n            if (!presentKeys.includes(key)) {\n                nextChildren.splice(i, 0, child);\n                exitingChildren.push(child);\n            }\n        }\n        /**\n         * If we're in \"wait\" mode, and we have exiting children, we want to\n         * only render these until they've all exited.\n         */\n        if (mode === \"wait\" && exitingChildren.length) {\n            nextChildren = exitingChildren;\n        }\n        setRenderedChildren(onlyElements(nextChildren));\n        setDiffedChildren(presentChildren);\n        /**\n         * Early return to ensure once we've set state with the latest diffed\n         * children, we can immediately re-render.\n         */\n        return;\n    }\n    if (process.env.NODE_ENV !== \"production\" &&\n        mode === \"wait\" &&\n        renderedChildren.length > 1) {\n        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to \"wait\". This will lead to odd visual behaviour.`);\n    }\n    /**\n     * If we've been provided a forceRender function by the LayoutGroupContext,\n     * we can use it to force a re-render amongst all surrounding components once\n     * all components have finished animating out.\n     */\n    const { forceRender } = useContext(LayoutGroupContext);\n    return (jsx(Fragment, { children: renderedChildren.map((child) => {\n            const key = getChildKey(child);\n            const isPresent = presentChildren === renderedChildren ||\n                presentKeys.includes(key);\n            const onExit = () => {\n                if (exitComplete.has(key)) {\n                    exitComplete.set(key, true);\n                }\n                else {\n                    return;\n                }\n                let isEveryExitComplete = true;\n                exitComplete.forEach((isExitComplete) => {\n                    if (!isExitComplete)\n                        isEveryExitComplete = false;\n                });\n                if (isEveryExitComplete) {\n                    forceRender === null || forceRender === void 0 ? void 0 : forceRender();\n                    setRenderedChildren(pendingPresentChildren.current);\n                    onExitComplete && onExitComplete();\n                }\n            };\n            return (jsx(PresenceChild, { isPresent: isPresent, initial: !isInitialRender.current || initial\n                    ? undefined\n                    : false, custom: isPresent ? undefined : custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode, onExitComplete: isPresent ? undefined : onExit, children: child }, key));\n        }) }));\n};\n\nexport { AnimatePresence };\n","import { createContext } from 'react';\n\nconst LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nconst MotionConfigContext = createContext({\n    transformPagePoint: (p) => p,\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nexport { MotionConfigContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nconst PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","import { createContext } from 'react';\n\nconst MotionContext = createContext({});\n\nexport { MotionContext };\n","import { createContext } from 'react';\n\nconst LazyContext = createContext({ strict: false });\n\nexport { LazyContext };\n","/**\n * Convert camelCase to dash-case properties.\n */\nconst camelToDash = (str) => str.replace(/([a-z])([A-Z])/gu, \"$1-$2\").toLowerCase();\n\nexport { camelToDash };\n","import { camelToDash } from '../../render/dom/utils/camel-to-dash.mjs';\n\nconst optimizedAppearDataId = \"framerAppearId\";\nconst optimizedAppearDataAttribute = \"data-\" + camelToDash(optimizedAppearDataId);\n\nexport { optimizedAppearDataAttribute, optimizedAppearDataId };\n","const MotionGlobalConfig = {\n    skipAnimations: false,\n    useManualTiming: false,\n};\n\nexport { MotionGlobalConfig };\n","import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';\nimport { createRenderStep } from './render-step.mjs';\n\nconst stepsOrder = [\n    \"read\", // Read\n    \"resolveKeyframes\", // Write/Read/Write/Read\n    \"update\", // Compute\n    \"preRender\", // Compute\n    \"render\", // Write\n    \"postRender\", // Compute\n];\nconst maxElapsed = 40;\nfunction createRenderBatcher(scheduleNextBatch, allowKeepAlive) {\n    let runNextFrame = false;\n    let useDefaultElapsed = true;\n    const state = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    const flagRunNextFrame = () => (runNextFrame = true);\n    const steps = stepsOrder.reduce((acc, key) => {\n        acc[key] = createRenderStep(flagRunNextFrame);\n        return acc;\n    }, {});\n    const { read, resolveKeyframes, update, preRender, render, postRender } = steps;\n    const processBatch = () => {\n        const timestamp = MotionGlobalConfig.useManualTiming\n            ? state.timestamp\n            : performance.now();\n        runNextFrame = false;\n        state.delta = useDefaultElapsed\n            ? 1000 / 60\n            : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);\n        state.timestamp = timestamp;\n        state.isProcessing = true;\n        // Unrolled render loop for better per-frame performance\n        read.process(state);\n        resolveKeyframes.process(state);\n        update.process(state);\n        preRender.process(state);\n        render.process(state);\n        postRender.process(state);\n        state.isProcessing = false;\n        if (runNextFrame && allowKeepAlive) {\n            useDefaultElapsed = false;\n            scheduleNextBatch(processBatch);\n        }\n    };\n    const wake = () => {\n        runNextFrame = true;\n        useDefaultElapsed = true;\n        if (!state.isProcessing) {\n            scheduleNextBatch(processBatch);\n        }\n    };\n    const schedule = stepsOrder.reduce((acc, key) => {\n        const step = steps[key];\n        acc[key] = (process, keepAlive = false, immediate = false) => {\n            if (!runNextFrame)\n                wake();\n            return step.schedule(process, keepAlive, immediate);\n        };\n        return acc;\n    }, {});\n    const cancel = (process) => {\n        for (let i = 0; i < stepsOrder.length; i++) {\n            steps[stepsOrder[i]].cancel(process);\n        }\n    };\n    return { schedule, cancel, state, steps };\n}\n\nexport { createRenderBatcher, stepsOrder };\n","function createRenderStep(runNextFrame) {\n    /**\n     * We create and reuse two queues, one to queue jobs for the current frame\n     * and one for the next. We reuse to avoid triggering GC after x frames.\n     */\n    let thisFrame = new Set();\n    let nextFrame = new Set();\n    /**\n     * Track whether we're currently processing jobs in this step. This way\n     * we can decide whether to schedule new jobs for this frame or next.\n     */\n    let isProcessing = false;\n    let flushNextFrame = false;\n    /**\n     * A set of processes which were marked keepAlive when scheduled.\n     */\n    const toKeepAlive = new WeakSet();\n    let latestFrameData = {\n        delta: 0.0,\n        timestamp: 0.0,\n        isProcessing: false,\n    };\n    function triggerCallback(callback) {\n        if (toKeepAlive.has(callback)) {\n            step.schedule(callback);\n            runNextFrame();\n        }\n        callback(latestFrameData);\n    }\n    const step = {\n        /**\n         * Schedule a process to run on the next frame.\n         */\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const queue = addToCurrentFrame ? thisFrame : nextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (!queue.has(callback))\n                queue.add(callback);\n            return callback;\n        },\n        /**\n         * Cancel the provided callback from running on the next frame.\n         */\n        cancel: (callback) => {\n            nextFrame.delete(callback);\n            toKeepAlive.delete(callback);\n        },\n        /**\n         * Execute all schedule callbacks.\n         */\n        process: (frameData) => {\n            latestFrameData = frameData;\n            /**\n             * If we're already processing we've probably been triggered by a flushSync\n             * inside an existing process. Instead of executing, mark flushNextFrame\n             * as true and ensure we flush the following frame at the end of this one.\n             */\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [thisFrame, nextFrame] = [nextFrame, thisFrame];\n            // Clear the next frame queue\n            nextFrame.clear();\n            // Execute this frame\n            thisFrame.forEach(triggerCallback);\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","import { createRenderBatcher } from './batcher.mjs';\n\nconst { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);\n\nexport { cancelMicrotask, microtask };\n","function isRefObject(ref) {\n    return (ref &&\n        typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\nexport { isRefObject };\n","import { createContext } from 'react';\n\n/**\n * Internal, exported only for usage in Framer\n */\nconst SwitchLayoutGroupContext = createContext({});\n\nexport { SwitchLayoutGroupContext };\n","import { useContext, useRef, useInsertionEffect, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { MotionContext } from '../../context/MotionContext/index.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\nimport { optimizedAppearDataAttribute } from '../../animation/optimized-appear/data-id.mjs';\nimport { microtask } from '../../frameloop/microtask.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { SwitchLayoutGroupContext } from '../../context/SwitchLayoutGroupContext.mjs';\n\nlet scheduleHandoffComplete = false;\nfunction useVisualElement(Component, visualState, props, createVisualElement, ProjectionNodeConstructor) {\n    var _a;\n    const { visualElement: parent } = useContext(MotionContext);\n    const lazyContext = useContext(LazyContext);\n    const presenceContext = useContext(PresenceContext);\n    const reducedMotionConfig = useContext(MotionConfigContext).reducedMotion;\n    const visualElementRef = useRef();\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    createVisualElement = createVisualElement || lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState,\n            parent,\n            props,\n            presenceContext,\n            blockInitialAnimation: presenceContext\n                ? presenceContext.initial === false\n                : false,\n            reducedMotionConfig,\n        });\n    }\n    const visualElement = visualElementRef.current;\n    /**\n     * Load Motion gesture and animation features. These are rendered as renderless\n     * components so each feature can optionally make use of React lifecycle methods.\n     */\n    const initialLayoutGroupConfig = useContext(SwitchLayoutGroupContext);\n    if (visualElement &&\n        !visualElement.projection &&\n        ProjectionNodeConstructor &&\n        (visualElement.type === \"html\" || visualElement.type === \"svg\")) {\n        createProjectionNode(visualElementRef.current, props, ProjectionNodeConstructor, initialLayoutGroupConfig);\n    }\n    useInsertionEffect(() => {\n        visualElement && visualElement.update(props, presenceContext);\n    });\n    /**\n     * Cache this value as we want to know whether HandoffAppearAnimations\n     * was present on initial render - it will be deleted after this.\n     */\n    const optimisedAppearId = props[optimizedAppearDataAttribute];\n    const wantsHandoff = useRef(Boolean(optimisedAppearId) &&\n        !window.MotionHandoffIsComplete &&\n        ((_a = window.MotionHasOptimisedAnimation) === null || _a === void 0 ? void 0 : _a.call(window, optimisedAppearId)));\n    useIsomorphicLayoutEffect(() => {\n        if (!visualElement)\n            return;\n        visualElement.updateFeatures();\n        microtask.render(visualElement.render);\n        /**\n         * Ideally this function would always run in a useEffect.\n         *\n         * However, if we have optimised appear animations to handoff from,\n         * it needs to happen synchronously to ensure there's no flash of\n         * incorrect styles in the event of a hydration error.\n         *\n         * So if we detect a situtation where optimised appear animations\n         * are running, we use useLayoutEffect to trigger animations.\n         */\n        if (wantsHandoff.current && visualElement.animationState) {\n            visualElement.animationState.animateChanges();\n        }\n    });\n    useEffect(() => {\n        if (!visualElement)\n            return;\n        if (!wantsHandoff.current && visualElement.animationState) {\n            visualElement.animationState.animateChanges();\n        }\n        wantsHandoff.current = false;\n        // This ensures all future calls to animateChanges() will run in useEffect\n        if (!scheduleHandoffComplete) {\n            scheduleHandoffComplete = true;\n            queueMicrotask(completeHandoff);\n        }\n    });\n    return visualElement;\n}\nfunction completeHandoff() {\n    window.MotionHandoffIsComplete = true;\n}\nfunction createProjectionNode(visualElement, props, ProjectionNodeConstructor, initialPromotionConfig) {\n    const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, } = props;\n    visualElement.projection = new ProjectionNodeConstructor(visualElement.latestValues, props[\"data-framer-portal-id\"]\n        ? undefined\n        : getClosestProjectingNode(visualElement.parent));\n    visualElement.projection.setOptions({\n        layoutId,\n        layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement,\n        /**\n         * TODO: Update options in an effect. This could be tricky as it'll be too late\n         * to update by the time layout animations run.\n         * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n         * ensuring it gets called if there's no potential layout animations.\n         *\n         */\n        animationType: typeof layout === \"string\" ? layout : \"both\",\n        initialPromotionConfig,\n        layoutScroll,\n        layoutRoot,\n    });\n}\nfunction getClosestProjectingNode(visualElement) {\n    if (!visualElement)\n        return undefined;\n    return visualElement.options.allowProjection !== false\n        ? visualElement.projection\n        : getClosestProjectingNode(visualElement.parent);\n}\n\nexport { useVisualElement };\n","import { useCallback } from 'react';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return useCallback((instance) => {\n        instance && visualState.mount && visualState.mount(instance);\n        if (visualElement) {\n            if (instance) {\n                visualElement.mount(instance);\n            }\n            else {\n                visualElement.unmount();\n            }\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\nexport { useMotionRef };\n","/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || Array.isArray(v);\n}\n\nexport { isVariantLabel };\n","function isAnimationControls(v) {\n    return (v !== null &&\n        typeof v === \"object\" &&\n        typeof v.start === \"function\");\n}\n\nexport { isAnimationControls };\n","const variantPriorityOrder = [\n    \"animate\",\n    \"whileInView\",\n    \"whileFocus\",\n    \"whileHover\",\n    \"whileTap\",\n    \"whileDrag\",\n    \"exit\",\n];\nconst variantProps = [\"initial\", ...variantPriorityOrder];\n\nexport { variantPriorityOrder, variantProps };\n","import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { variantProps } from './variant-props.mjs';\n\nfunction isControllingVariants(props) {\n    return (isAnimationControls(props.animate) ||\n        variantProps.some((name) => isVariantLabel(props[name])));\n}\nfunction isVariantNode(props) {\n    return Boolean(isControllingVariants(props) || props.variants);\n}\n\nexport { isControllingVariants, isVariantNode };\n","import { useContext, useMemo } from 'react';\nimport { MotionContext } from './index.mjs';\nimport { getCurrentTreeVariants } from './utils.mjs';\n\nfunction useCreateMotionContext(props) {\n    const { initial, animate } = getCurrentTreeVariants(props, useContext(MotionContext));\n    return useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nexport { useCreateMotionContext };\n","import { isVariantLabel } from '../../render/utils/is-variant-label.mjs';\nimport { isControllingVariants } from '../../render/utils/is-controlling-variants.mjs';\n\nfunction getCurrentTreeVariants(props, context) {\n    if (isControllingVariants(props)) {\n        const { initial, animate } = props;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nexport { getCurrentTreeVariants };\n","const featureProps = {\n    animation: [\n        \"animate\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"exit\",\n        \"whileInView\",\n        \"whileFocus\",\n        \"whileDrag\",\n    ],\n    exit: [\"exit\"],\n    drag: [\"drag\", \"dragControls\"],\n    focus: [\"whileFocus\"],\n    hover: [\"whileHover\", \"onHoverStart\", \"onHoverEnd\"],\n    tap: [\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"],\n    pan: [\"onPan\", \"onPanStart\", \"onPanSessionStart\", \"onPanEnd\"],\n    inView: [\"whileInView\", \"onViewportEnter\", \"onViewportLeave\"],\n    layout: [\"layout\", \"layoutId\"],\n};\nconst featureDefinitions = {};\nfor (const key in featureProps) {\n    featureDefinitions[key] = {\n        isEnabled: (props) => featureProps[key].some((name) => !!props[name]),\n    };\n}\n\nexport { featureDefinitions };\n","const motionComponentSymbol = Symbol.for(\"motionComponentSymbol\");\n\nexport { motionComponentSymbol };\n","import { jsxs, jsx } from 'react/jsx-runtime';\nimport { forwardRef, useContext } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { MotionContext } from '../context/MotionContext/index.mjs';\nimport { useVisualElement } from './utils/use-visual-element.mjs';\nimport { useMotionRef } from './utils/use-motion-ref.mjs';\nimport { useCreateMotionContext } from '../context/MotionContext/create.mjs';\nimport { loadFeatures } from './features/load-features.mjs';\nimport { isBrowser } from '../utils/is-browser.mjs';\nimport { LayoutGroupContext } from '../context/LayoutGroupContext.mjs';\nimport { LazyContext } from '../context/LazyContext.mjs';\nimport { motionComponentSymbol } from './utils/symbol.mjs';\nimport { warning, invariant } from '../utils/errors.mjs';\nimport { featureDefinitions } from './features/definitions.mjs';\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent({ preloadedFeatures, createVisualElement, useRender, useVisualState, Component, }) {\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        /**\n         * If we need to measure the element we load this functionality in a\n         * separate class component in order to gain access to getSnapshotBeforeUpdate.\n         */\n        let MeasureLayout;\n        const configAndProps = {\n            ...useContext(MotionConfigContext),\n            ...props,\n            layoutId: useLayoutId(props),\n        };\n        const { isStatic } = configAndProps;\n        const context = useCreateMotionContext(props);\n        const visualState = useVisualState(props, isStatic);\n        if (!isStatic && isBrowser) {\n            useStrictMode(configAndProps, preloadedFeatures);\n            const layoutProjection = getProjectionFunctionality(configAndProps);\n            MeasureLayout = layoutProjection.MeasureLayout;\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, configAndProps, createVisualElement, layoutProjection.ProjectionNode);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (jsxs(MotionContext.Provider, { value: context, children: [MeasureLayout && context.visualElement ? (jsx(MeasureLayout, { visualElement: context.visualElement, ...configAndProps })) : null, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, context.visualElement)] }));\n    }\n    const ForwardRefComponent = forwardRef(MotionComponent);\n    ForwardRefComponent[motionComponentSymbol] = Component;\n    return ForwardRefComponent;\n}\nfunction useLayoutId({ layoutId }) {\n    const layoutGroupId = useContext(LayoutGroupContext).id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\nfunction useStrictMode(configAndProps, preloadedFeatures) {\n    const isStrict = useContext(LazyContext).strict;\n    /**\n     * If we're in development mode, check to make sure we're not rendering a motion component\n     * as a child of LazyMotion, as this will break the file-size benefits of using it.\n     */\n    if (process.env.NODE_ENV !== \"production\" &&\n        preloadedFeatures &&\n        isStrict) {\n        const strictMessage = \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\";\n        configAndProps.ignoreStrict\n            ? warning(false, strictMessage)\n            : invariant(false, strictMessage);\n    }\n}\nfunction getProjectionFunctionality(props) {\n    const { drag, layout } = featureDefinitions;\n    if (!drag && !layout)\n        return {};\n    const combined = { ...drag, ...layout };\n    return {\n        MeasureLayout: (drag === null || drag === void 0 ? void 0 : drag.isEnabled(props)) || (layout === null || layout === void 0 ? void 0 : layout.isEnabled(props))\n            ? combined.MeasureLayout\n            : undefined,\n        ProjectionNode: combined.ProjectionNode,\n    };\n}\n\nexport { createMotionComponent };\n","import { featureDefinitions } from './definitions.mjs';\n\nfunction loadFeatures(features) {\n    for (const key in features) {\n        featureDefinitions[key] = {\n            ...featureDefinitions[key],\n            ...features[key],\n        };\n    }\n}\n\nexport { loadFeatures };\n","import { createMotionComponent } from '../../motion/index.mjs';\n\n/**\n * Convert any React component into a `motion` component. The provided component\n * **must** use `React.forwardRef` to the underlying DOM component you want to animate.\n *\n * ```jsx\n * const Component = React.forwardRef((props, ref) => {\n *   return <div ref={ref} />\n * })\n *\n * const MotionComponent = motion(Component)\n * ```\n *\n * @public\n */\nfunction createMotionProxy(createConfig) {\n    function custom(Component, customMotionComponentConfig = {}) {\n        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    const componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: (_target, key) => {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\nexport { createMotionProxy };\n","/**\n * We keep these listed separately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nconst lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"switch\",\n    \"symbol\",\n    \"svg\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n","import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/u.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\n","const scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n","/**\n * Generate a list of every possible transform key.\n */\nconst transformPropOrder = [\n    \"transformPerspective\",\n    \"x\",\n    \"y\",\n    \"z\",\n    \"translateX\",\n    \"translateY\",\n    \"translateZ\",\n    \"scale\",\n    \"scaleX\",\n    \"scaleY\",\n    \"rotate\",\n    \"rotateX\",\n    \"rotateY\",\n    \"rotateZ\",\n    \"skew\",\n    \"skewX\",\n    \"skewY\",\n];\n/**\n * A quick lookup for transform props.\n */\nconst transformProps = new Set(transformPropOrder);\n\nexport { transformPropOrder, transformProps };\n","import { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nimport { transformProps } from '../../render/html/utils/transform.mjs';\n\nfunction isForcedMotionValue(key, { layout, layoutId }) {\n    return (transformProps.has(key) ||\n        key.startsWith(\"origin\") ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","const isMotionValue = (value) => Boolean(value && value.getVelocity);\n\nexport { isMotionValue };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nconst getValueAsType = (value, type) => {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","const clamp = (min, max, v) => {\n    if (v > max)\n        return max;\n    if (v < min)\n        return min;\n    return v;\n};\n\nexport { clamp };\n","import { clamp } from '../../../utils/clamp.mjs';\n\nconst number = {\n    test: (v) => typeof v === \"number\",\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = {\n    ...number,\n    transform: (v) => clamp(0, 1, v),\n};\nconst scale = {\n    ...number,\n    default: 1,\n};\n\nexport { alpha, number, scale };\n","/**\n * TODO: When we move from string as a source of truth to data models\n * everything in this folder should probably be referred to as models vs types\n */\n// If this number is a decimal, make it just five decimal places\n// to avoid exponents\nconst sanitize = (v) => Math.round(v * 100000) / 100000;\nconst floatRegex = /-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/gu;\nconst colorRegex = /(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))/giu;\nconst singleColorRegex = /^(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))$/iu;\nfunction isString(v) {\n    return typeof v === \"string\";\n}\nfunction isNullish(v) {\n    return v == null;\n}\n\nexport { colorRegex, floatRegex, isNullish, isString, sanitize, singleColorRegex };\n","import { isString } from '../utils.mjs';\n\nconst createUnitType = (unit) => ({\n    test: (v) => isString(v) && v.endsWith(unit) && v.split(\" \").length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = createUnitType(\"deg\");\nconst percent = createUnitType(\"%\");\nconst px = createUnitType(\"px\");\nconst vh = createUnitType(\"vh\");\nconst vw = createUnitType(\"vw\");\nconst progressPercentage = {\n    ...percent,\n    parse: (v) => percent.parse(v) / 100,\n    transform: (v) => percent.transform(v * 100),\n};\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n","import { number } from '../../../value/types/numbers/index.mjs';\n\nconst int = {\n    ...number,\n    transform: Math.round,\n};\n\nexport { int };\n","import { scale, alpha } from '../../../value/types/numbers/index.mjs';\nimport { px, degrees, progressPercentage } from '../../../value/types/numbers/units.mjs';\nimport { int } from './type-int.mjs';\n\nconst numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    radius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    size: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    // Transform props\n    rotate: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n    // Misc\n    zIndex: int,\n    backgroundPositionX: px,\n    backgroundPositionY: px,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n\nexport { numberValueTypes };\n","import { transformPropOrder } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nconst translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\nconst numTransforms = transformPropOrder.length;\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(latestValues, transform, transformTemplate) {\n    // The transform string we're going to build into.\n    let transformString = \"\";\n    let transformIsDefault = true;\n    /**\n     * Loop over all possible transforms in order, adding the ones that\n     * are present to the transform string.\n     */\n    for (let i = 0; i < numTransforms; i++) {\n        const key = transformPropOrder[i];\n        const value = latestValues[key];\n        if (value === undefined)\n            continue;\n        let valueIsDefault = true;\n        if (typeof value === \"number\") {\n            valueIsDefault = value === (key.startsWith(\"scale\") ? 1 : 0);\n        }\n        else {\n            valueIsDefault = parseFloat(value) === 0;\n        }\n        if (!valueIsDefault || transformTemplate) {\n            const valueAsType = getValueAsType(value, numberValueTypes[key]);\n            if (!valueIsDefault) {\n                transformIsDefault = false;\n                const transformName = translateAlias[key] || key;\n                transformString += `${transformName}(${valueAsType}) `;\n            }\n            if (transformTemplate) {\n                transform[key] = valueAsType;\n            }\n        }\n    }\n    transformString = transformString.trim();\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n\nexport { buildTransform };\n","const checkStringStartsWith = (token) => (key) => typeof key === \"string\" && key.startsWith(token);\nconst isCSSVariableName = checkStringStartsWith(\"--\");\nconst startsAsVariableToken = checkStringStartsWith(\"var(--\");\nconst isCSSVariableToken = (value) => {\n    const startsWithToken = startsAsVariableToken(value);\n    if (!startsWithToken)\n        return false;\n    // Ensure any comments are stripped from the value as this can harm performance of the regex.\n    return singleCssVariableRegex.test(value.split(\"/*\")[0].trim());\n};\nconst singleCssVariableRegex = /var\\(--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)$/iu;\n\nexport { isCSSVariableName, isCSSVariableToken };\n","import { buildTransform } from './build-transform.mjs';\nimport { isCSSVariableName } from '../../dom/utils/is-css-variable.mjs';\nimport { transformProps } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nfunction buildHTMLStyles(state, latestValues, transformTemplate) {\n    const { style, vars, transformOrigin } = state;\n    // Track whether we encounter any transform or transformOrigin values.\n    let hasTransform = false;\n    let hasTransformOrigin = false;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept separately for further processing.\n     */\n    for (const key in latestValues) {\n        const value = latestValues[key];\n        if (transformProps.has(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            continue;\n        }\n        else if (isCSSVariableName(key)) {\n            vars[key] = value;\n            continue;\n        }\n        else {\n            // Convert the value to its default value type, ie 0 -> \"0px\"\n            const valueAsType = getValueAsType(value, numberValueTypes[key]);\n            if (key.startsWith(\"origin\")) {\n                // If this is a transform origin, flag and enable further transform-origin processing\n                hasTransformOrigin = true;\n                transformOrigin[key] =\n                    valueAsType;\n            }\n            else {\n                style[key] = valueAsType;\n            }\n        }\n    }\n    if (!latestValues.transform) {\n        if (hasTransform || transformTemplate) {\n            style.transform = buildTransform(latestValues, state.transform, transformTemplate);\n        }\n        else if (style.transform) {\n            /**\n             * If we have previously created a transform but currently don't have any,\n             * reset transform style to none.\n             */\n            style.transform = \"none\";\n        }\n    }\n    /**\n     * Build a transformOrigin style. Uses the same defaults as the browser for\n     * undefined origins.\n     */\n    if (hasTransformOrigin) {\n        const { originX = \"50%\", originY = \"50%\", originZ = 0, } = transformOrigin;\n        style.transformOrigin = `${originX} ${originY} ${originZ}`;\n    }\n}\n\nexport { buildHTMLStyles };\n","const createHtmlRenderState = () => ({\n    style: {},\n    transform: {},\n    transformOrigin: {},\n    vars: {},\n});\n\nexport { createHtmlRenderState };\n","import { useMemo } from 'react';\nimport { isForcedMotionValue } from '../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (const key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues({ transformTemplate }, visualState) {\n    return useMemo(() => {\n        const state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, transformTemplate);\n        return Object.assign({}, state.vars, state.style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState) {\n    const styleProp = props.style || {};\n    const style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState));\n    return style;\n}\nfunction useHTMLProps(props, visualState) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    const htmlProps = {};\n    const style = useStyle(props, visualState);\n    if (props.drag && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : `pan-${props.drag === \"x\" ? \"y\" : \"x\"}`;\n    }\n    if (props.tabIndex === undefined &&\n        (props.onTap || props.onTapStart || props.whileTap)) {\n        htmlProps.tabIndex = 0;\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\nexport { copyRawValuesOnly, useHTMLProps };\n","/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nconst validMotionProps = new Set([\n    \"animate\",\n    \"exit\",\n    \"variants\",\n    \"initial\",\n    \"style\",\n    \"values\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"custom\",\n    \"inherit\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"_dragX\",\n    \"_dragY\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"globalTapTarget\",\n    \"ignoreStrict\",\n    \"viewport\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return (key.startsWith(\"while\") ||\n        (key.startsWith(\"drag\") && key !== \"draggable\") ||\n        key.startsWith(\"layout\") ||\n        key.startsWith(\"onTap\") ||\n        key.startsWith(\"onPan\") ||\n        key.startsWith(\"onLayout\") ||\n        validMotionProps.has(key));\n}\n\nexport { isValidMotionProp };\n","import { isValidMotionProp } from '../../../motion/utils/valid-prop.mjs';\n\nlet shouldForward = (key) => !isValidMotionProp(key);\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = (key) => key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    const filteredProps = {};\n    for (const key in props) {\n        /**\n         * values is considered a valid prop by Emotion, so if it's present\n         * this will be rendered out to the DOM unless explicitly filtered.\n         *\n         * We check the type as it could be used with the `feColorMatrix`\n         * element, which we support.\n         */\n        if (key === \"values\" && typeof props.values === \"object\")\n            continue;\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] &&\n                key.startsWith(\"onDrag\"))) {\n            filteredProps[key] =\n                props[key];\n        }\n    }\n    return filteredProps;\n}\n\nexport { filterProps, loadExternalIsValidProp };\n","import { px } from '../../../value/types/numbers/units.mjs';\n\nfunction calcOrigin(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    const pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    const pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return `${pxOriginX} ${pxOriginY}`;\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from '../../../value/types/numbers/units.mjs';\n\nconst dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nconst camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    const keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    const pathLength = px.transform(length);\n    const pathSpacing = px.transform(spacing);\n    attrs[keys.array] = `${pathLength} ${pathSpacing}`;\n}\n\nexport { buildSVGPath };\n","import { buildHTMLStyles } from '../../html/utils/build-styles.mjs';\nimport { calcSVGTransformOrigin } from './transform-origin.mjs';\nimport { buildSVGPath } from './path.mjs';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, { attrX, attrY, attrScale, originX, originY, pathLength, pathSpacing = 1, pathOffset = 0, \n// This is object creation, which we try to avoid per-frame.\n...latest }, isSVGTag, transformTemplate) {\n    buildHTMLStyles(state, latest, transformTemplate);\n    /**\n     * For svg tags we just want to make sure viewBox is animatable and treat all the styles\n     * as normal HTML tags.\n     */\n    if (isSVGTag) {\n        if (state.style.viewBox) {\n            state.attrs.viewBox = state.style.viewBox;\n        }\n        return;\n    }\n    state.attrs = state.style;\n    state.style = {};\n    const { attrs, style, dimensions } = state;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Render attrX/attrY/attrScale as attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    if (attrScale !== undefined)\n        attrs.scale = attrScale;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nexport { buildSVGAttrs };\n","import { createHtmlRenderState } from '../../html/utils/create-render-state.mjs';\n\nconst createSvgRenderState = () => ({\n    ...createHtmlRenderState(),\n    attrs: {},\n});\n\nexport { createSvgRenderState };\n","const isSVGTag = (tag) => typeof tag === \"string\" && tag.toLowerCase() === \"svg\";\n\nexport { isSVGTag };\n","import { useMemo } from 'react';\nimport { copyRawValuesOnly } from '../html/use-props.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\n\nfunction useSVGProps(props, visualState, _isStatic, Component) {\n    const visualProps = useMemo(() => {\n        const state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, isSVGTag(Component), props.transformTemplate);\n        return {\n            ...state.attrs,\n            style: { ...state.style },\n        };\n    }, [visualState]);\n    if (props.style) {\n        const rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = { ...rawStyles, ...visualProps.style };\n    }\n    return visualProps;\n}\n\nexport { useSVGProps };\n","import { Fragment, useMemo, createElement } from 'react';\nimport { useHTMLProps } from '../html/use-props.mjs';\nimport { filterProps } from './utils/filter-props.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\nimport { useSVGProps } from '../svg/use-props.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction createUseRender(forwardMotionProps = false) {\n    const useRender = (Component, props, ref, { latestValues }, isStatic) => {\n        const useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        const visualProps = useVisualProps(props, latestValues, isStatic, Component);\n        const filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        const elementProps = Component !== Fragment\n            ? { ...filteredProps, ...visualProps, ref }\n            : {};\n        /**\n         * If component has been handed a motion value as its child,\n         * memoise its initial value and render that. Subsequent updates\n         * will be handled by the onChange handler\n         */\n        const { children } = props;\n        const renderedChildren = useMemo(() => (isMotionValue(children) ? children.get() : children), [children]);\n        return createElement(Component, {\n            ...elementProps,\n            children: renderedChildren,\n        });\n    };\n    return useRender;\n}\n\nexport { createUseRender };\n","function renderHTML(element, { style, vars }, styleProp, projection) {\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (const key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nconst camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n    \"startOffset\",\n    \"textLength\",\n    \"lengthAdjust\",\n]);\n\nexport { camelCaseAttributes };\n","import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';\nimport { renderHTML } from '../../html/utils/render.mjs';\nimport { camelCaseAttributes } from './camel-case-attrs.mjs';\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (const key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n    var _a;\n    const { style } = props;\n    const newValues = {};\n    for (const key in style) {\n        if (isMotionValue(style[key]) ||\n            (prevProps.style &&\n                isMotionValue(prevProps.style[key])) ||\n            isForcedMotionValue(key, props) ||\n            ((_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.liveStyle) !== undefined) {\n            newValues[key] = style[key];\n        }\n    }\n    /**\n     * If the willChange style has been manually set as a string, set\n     * applyWillChange to false to prevent it from automatically being applied.\n     */\n    if (visualElement && style && typeof style.willChange === \"string\") {\n        visualElement.applyWillChange = false;\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\nimport { transformPropOrder } from '../../html/utils/transform.mjs';\n\nfunction scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n    const newValues = scrapeMotionValuesFromProps$1(props, prevProps, visualElement);\n    for (const key in props) {\n        if (isMotionValue(props[key]) ||\n            isMotionValue(prevProps[key])) {\n            const targetKey = transformPropOrder.indexOf(key) !== -1\n                ? \"attr\" + key.charAt(0).toUpperCase() + key.substring(1)\n                : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","function getValueState(visualElement) {\n    const state = [{}, {}];\n    visualElement === null || visualElement === void 0 ? void 0 : visualElement.values.forEach((value, key) => {\n        state[0][key] = value.get();\n        state[1][key] = value.getVelocity();\n    });\n    return state;\n}\nfunction resolveVariantFromProps(props, definition, custom, visualElement) {\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        const [current, velocity] = getValueState(visualElement);\n        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = props.variants && props.variants[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        const [current, velocity] = getValueState(visualElement);\n        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);\n    }\n    return definition;\n}\n\nexport { resolveVariantFromProps };\n","const isKeyframesTarget = (v) => {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n","import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.mjs';\n\nconst isCustomValue = (v) => {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nconst resolveFinalValueInKeyframes = (v) => {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nexport { isCustomValue, resolveFinalValueInKeyframes };\n","import { isCustomValue } from '../../utils/resolve-value.mjs';\nimport { isMotionValue } from './is-motion-value.mjs';\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    const unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nexport { resolveMotionValue };\n","/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\n    \"opacity\",\n    \"clipPath\",\n    \"filter\",\n    \"transform\",\n    // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved\n    // or until we implement support for linear() easing.\n    // \"background-color\"\n]);\n\nexport { acceleratedValues };\n","import { acceleratedValues } from '../../animation/animators/utils/accelerated-values.mjs';\nimport { camelToDash } from '../../render/dom/utils/camel-to-dash.mjs';\nimport { transformProps } from '../../render/html/utils/transform.mjs';\n\nfunction getWillChangeName(name) {\n    if (transformProps.has(name)) {\n        return \"transform\";\n    }\n    else if (acceleratedValues.has(name)) {\n        return camelToDash(name);\n    }\n}\n\nexport { getWillChangeName };\n","function addUniqueItem(arr, item) {\n    if (arr.indexOf(item) === -1)\n        arr.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    if (index > -1)\n        arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem([...arr], fromIndex, toIndex) {\n    const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        const [item] = arr.splice(fromIndex, 1);\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n","import { useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { resolveVariantFromProps } from '../../render/utils/resolve-variants.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { MotionContext } from '../../context/MotionContext/index.mjs';\nimport { isControllingVariants, isVariantNode } from '../../render/utils/is-controlling-variants.mjs';\nimport { getWillChangeName } from '../../value/use-will-change/get-will-change-name.mjs';\nimport { addUniqueItem } from '../../utils/array.mjs';\n\nfunction makeState({ applyWillChange = false, scrapeMotionValuesFromProps, createRenderState, onMount, }, props, context, presenceContext, isStatic) {\n    const state = {\n        latestValues: makeLatestValues(props, context, presenceContext, isStatic ? false : applyWillChange, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = (instance) => onMount(props, instance, state);\n    }\n    return state;\n}\nconst makeUseVisualState = (config) => (props, isStatic) => {\n    const context = useContext(MotionContext);\n    const presenceContext = useContext(PresenceContext);\n    const make = () => makeState(config, props, context, presenceContext, isStatic);\n    return isStatic ? make() : useConstant(make);\n};\nfunction addWillChange(willChange, name) {\n    const memberName = getWillChangeName(name);\n    if (memberName) {\n        addUniqueItem(willChange, memberName);\n    }\n}\nfunction forEachDefinition(props, definition, callback) {\n    const list = Array.isArray(definition) ? definition : [definition];\n    for (let i = 0; i < list.length; i++) {\n        const resolved = resolveVariantFromProps(props, list[i]);\n        if (resolved) {\n            const { transitionEnd, transition, ...target } = resolved;\n            callback(target, transitionEnd);\n        }\n    }\n}\nfunction makeLatestValues(props, context, presenceContext, shouldApplyWillChange, scrapeMotionValues) {\n    var _a;\n    const values = {};\n    const willChange = [];\n    const applyWillChange = shouldApplyWillChange && ((_a = props.style) === null || _a === void 0 ? void 0 : _a.willChange) === undefined;\n    const motionValues = scrapeMotionValues(props, {});\n    for (const key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    let { initial, animate } = props;\n    const isControllingVariants$1 = isControllingVariants(props);\n    const isVariantNode$1 = isVariantNode(props);\n    if (context &&\n        isVariantNode$1 &&\n        !isControllingVariants$1 &&\n        props.inherit !== false) {\n        if (initial === undefined)\n            initial = context.initial;\n        if (animate === undefined)\n            animate = context.animate;\n    }\n    let isInitialAnimationBlocked = presenceContext\n        ? presenceContext.initial === false\n        : false;\n    isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;\n    const variantToSet = isInitialAnimationBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        forEachDefinition(props, variantToSet, (target, transitionEnd) => {\n            for (const key in target) {\n                let valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    const index = isInitialAnimationBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (const key in transitionEnd) {\n                values[key] = transitionEnd[key];\n            }\n        });\n    }\n    // Add animating values to will-change\n    if (applyWillChange) {\n        if (animate && initial !== false && !isAnimationControls(animate)) {\n            forEachDefinition(props, animate, (target) => {\n                for (const key in target) {\n                    addWillChange(willChange, key);\n                }\n            });\n        }\n        if (willChange.length) {\n            values.willChange = willChange.join(\",\");\n        }\n    }\n    return values;\n}\n\nexport { makeUseVisualState };\n","import { noop } from '../utils/noop.mjs';\nimport { createRenderBatcher } from './batcher.mjs';\n\nconst { schedule: frame, cancel: cancelFrame, state: frameData, steps, } = createRenderBatcher(typeof requestAnimationFrame !== \"undefined\" ? requestAnimationFrame : noop, true);\n\nexport { cancelFrame, frame, frameData, steps };\n","import { renderSVG } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: (props, instance, { renderState, latestValues }) => {\n            frame.read(() => {\n                try {\n                    renderState.dimensions =\n                        typeof instance.getBBox ===\n                            \"function\"\n                            ? instance.getBBox()\n                            : instance.getBoundingClientRect();\n                }\n                catch (e) {\n                    // Most likely trying to measure an unrendered element under Firefox\n                    renderState.dimensions = {\n                        x: 0,\n                        y: 0,\n                        width: 0,\n                        height: 0,\n                    };\n                }\n            });\n            frame.render(() => {\n                buildSVGAttrs(renderState, latestValues, isSVGTag(instance.tagName), props.transformTemplate);\n                renderSVG(instance, renderState);\n            });\n        },\n    }),\n};\n\nexport { svgMotionConfig };\n","import { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nconst htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        applyWillChange: true,\n        scrapeMotionValuesFromProps,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nexport { htmlMotionConfig };\n","function addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n\nexport { addDomEvent };\n","const isPrimaryPointer = (event) => {\n    if (event.pointerType === \"mouse\") {\n        return typeof event.button !== \"number\" || event.button <= 0;\n    }\n    else {\n        /**\n         * isPrimary is true for all mice buttons, whereas every touch point\n         * is regarded as its own input. So subsequent concurrent touch points\n         * will be false.\n         *\n         * Specifically match against false here as incomplete versions of\n         * PointerEvents in very old browser might have it set as undefined.\n         */\n        return event.isPrimary !== false;\n    }\n};\n\nexport { isPrimaryPointer };\n","import { isPrimaryPointer } from './utils/is-primary-pointer.mjs';\n\nfunction extractEventInfo(event, pointType = \"page\") {\n    return {\n        point: {\n            x: event[`${pointType}X`],\n            y: event[`${pointType}Y`],\n        },\n    };\n}\nconst addPointerInfo = (handler) => {\n    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));\n};\n\nexport { addPointerInfo, extractEventInfo };\n","import { addDomEvent } from './add-dom-event.mjs';\nimport { addPointerInfo } from './event-info.mjs';\n\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, eventName, addPointerInfo(handler), options);\n}\n\nexport { addPointerEvent };\n","/**\n * Pipe\n * Compose other transformers to run linearily\n * pipe(min(20), max(40))\n * @param  {...functions} transformers\n * @return {function}\n */\nconst combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\n","function createLock(name) {\n    let lock = null;\n    return () => {\n        const openLock = () => {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nconst globalHorizontalLock = createLock(\"dragHorizontal\");\nconst globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    let lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        const openHorizontal = globalHorizontalLock();\n        const openVertical = globalVerticalLock();\n        if (openHorizontal && openVertical) {\n            lock = () => {\n                openHorizontal();\n                openVertical();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal)\n                openHorizontal();\n            if (openVertical)\n                openVertical();\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    const openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n","import { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction addHoverEvent(node, isActive) {\n    const eventName = isActive ? \"pointerenter\" : \"pointerleave\";\n    const callbackName = isActive ? \"onHoverStart\" : \"onHoverEnd\";\n    const handleEvent = (event, info) => {\n        if (event.pointerType === \"touch\" || isDragActive())\n            return;\n        const props = node.getProps();\n        if (node.animationState && props.whileHover) {\n            node.animationState.setActive(\"whileHover\", isActive);\n        }\n        const callback = props[callbackName];\n        if (callback) {\n            frame.postRender(() => callback(event, info));\n        }\n    };\n    return addPointerEvent(node.current, eventName, handleEvent, {\n        passive: !node.getProps()[callbackName],\n    });\n}\nclass HoverGesture extends Feature {\n    mount() {\n        this.unmount = pipe(addHoverEvent(this.node, true), addHoverEvent(this.node, false));\n    }\n    unmount() { }\n}\n\nexport { HoverGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nconst isNodeOrChild = (parent, child) => {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","import { extractEventInfo } from '../events/event-info.mjs';\nimport { addDomEvent } from '../events/add-dom-event.mjs';\nimport { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { noop } from '../utils/noop.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction fireSyntheticPointerEvent(name, handler) {\n    if (!handler)\n        return;\n    const syntheticPointerEvent = new PointerEvent(\"pointer\" + name);\n    handler(syntheticPointerEvent, extractEventInfo(syntheticPointerEvent));\n}\nclass PressGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removeStartListeners = noop;\n        this.removeEndListeners = noop;\n        this.removeAccessibleListeners = noop;\n        this.startPointerPress = (startEvent, startInfo) => {\n            if (this.isPressing)\n                return;\n            this.removeEndListeners();\n            const props = this.node.getProps();\n            const endPointerPress = (endEvent, endInfo) => {\n                if (!this.checkPressEnd())\n                    return;\n                const { onTap, onTapCancel, globalTapTarget } = this.node.getProps();\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                const handler = !globalTapTarget &&\n                    !isNodeOrChild(this.node.current, endEvent.target)\n                    ? onTapCancel\n                    : onTap;\n                if (handler) {\n                    frame.update(() => handler(endEvent, endInfo));\n                }\n            };\n            const removePointerUpListener = addPointerEvent(window, \"pointerup\", endPointerPress, {\n                passive: !(props.onTap || props[\"onPointerUp\"]),\n            });\n            const removePointerCancelListener = addPointerEvent(window, \"pointercancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo), {\n                passive: !(props.onTapCancel ||\n                    props[\"onPointerCancel\"]),\n            });\n            this.removeEndListeners = pipe(removePointerUpListener, removePointerCancelListener);\n            this.startPress(startEvent, startInfo);\n        };\n        this.startAccessiblePress = () => {\n            const handleKeydown = (keydownEvent) => {\n                if (keydownEvent.key !== \"Enter\" || this.isPressing)\n                    return;\n                const handleKeyup = (keyupEvent) => {\n                    if (keyupEvent.key !== \"Enter\" || !this.checkPressEnd())\n                        return;\n                    fireSyntheticPointerEvent(\"up\", (event, info) => {\n                        const { onTap } = this.node.getProps();\n                        if (onTap) {\n                            frame.postRender(() => onTap(event, info));\n                        }\n                    });\n                };\n                this.removeEndListeners();\n                this.removeEndListeners = addDomEvent(this.node.current, \"keyup\", handleKeyup);\n                fireSyntheticPointerEvent(\"down\", (event, info) => {\n                    this.startPress(event, info);\n                });\n            };\n            const removeKeydownListener = addDomEvent(this.node.current, \"keydown\", handleKeydown);\n            const handleBlur = () => {\n                if (!this.isPressing)\n                    return;\n                fireSyntheticPointerEvent(\"cancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo));\n            };\n            const removeBlurListener = addDomEvent(this.node.current, \"blur\", handleBlur);\n            this.removeAccessibleListeners = pipe(removeKeydownListener, removeBlurListener);\n        };\n    }\n    startPress(event, info) {\n        this.isPressing = true;\n        const { onTapStart, whileTap } = this.node.getProps();\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        if (whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", true);\n        }\n        if (onTapStart) {\n            frame.postRender(() => onTapStart(event, info));\n        }\n    }\n    checkPressEnd() {\n        this.removeEndListeners();\n        this.isPressing = false;\n        const props = this.node.getProps();\n        if (props.whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", false);\n        }\n        return !isDragActive();\n    }\n    cancelPress(event, info) {\n        if (!this.checkPressEnd())\n            return;\n        const { onTapCancel } = this.node.getProps();\n        if (onTapCancel) {\n            frame.postRender(() => onTapCancel(event, info));\n        }\n    }\n    mount() {\n        const props = this.node.getProps();\n        const removePointerListener = addPointerEvent(props.globalTapTarget ? window : this.node.current, \"pointerdown\", this.startPointerPress, {\n            passive: !(props.onTapStart ||\n                props[\"onPointerStart\"]),\n        });\n        const removeFocusListener = addDomEvent(this.node.current, \"focus\", this.startAccessiblePress);\n        this.removeStartListeners = pipe(removePointerListener, removeFocusListener);\n    }\n    unmount() {\n        this.removeStartListeners();\n        this.removeEndListeners();\n        this.removeAccessibleListeners();\n    }\n}\n\nexport { PressGesture };\n","/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nconst observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nconst observers = new WeakMap();\nconst fireObserverCallback = (entry) => {\n    const callback = observerCallbacks.get(entry.target);\n    callback && callback(entry);\n};\nconst fireAllObserverCallbacks = (entries) => {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver({ root, ...options }) {\n    const lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    const rootObservers = observers.get(lookupRoot);\n    const key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    const rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return () => {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { Feature } from '../Feature.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nclass InViewFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n    startObserver() {\n        this.unmount();\n        const { viewport = {} } = this.node.getProps();\n        const { root, margin: rootMargin, amount = \"some\", once } = viewport;\n        const options = {\n            root: root ? root.current : undefined,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const onIntersectionUpdate = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (this.isInView === isIntersecting)\n                return;\n            this.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && this.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                this.hasEnteredView = true;\n            }\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const { onViewportEnter, onViewportLeave } = this.node.getProps();\n            const callback = isIntersecting ? onViewportEnter : onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(this.node.current, options, onIntersectionUpdate);\n    }\n    mount() {\n        this.startObserver();\n    }\n    update() {\n        if (typeof IntersectionObserver === \"undefined\")\n            return;\n        const { props, prevProps } = this.node;\n        const hasOptionsChanged = [\"amount\", \"margin\", \"root\"].some(hasViewportOptionChanged(props, prevProps));\n        if (hasOptionsChanged) {\n            this.startObserver();\n        }\n    }\n    unmount() { }\n}\nfunction hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {\n    return (name) => viewport[name] !== prevViewport[name];\n}\n\nexport { InViewFeature };\n","import { HoverGesture } from '../../gestures/hover.mjs';\nimport { FocusGesture } from '../../gestures/focus.mjs';\nimport { PressGesture } from '../../gestures/press.mjs';\nimport { InViewFeature } from './viewport/index.mjs';\n\nconst gestureAnimations = {\n    inView: {\n        Feature: InViewFeature,\n    },\n    tap: {\n        Feature: PressGesture,\n    },\n    focus: {\n        Feature: FocusGesture,\n    },\n    hover: {\n        Feature: HoverGesture,\n    },\n};\n\nexport { gestureAnimations };\n","import { addDomEvent } from '../events/add-dom-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\n\nclass FocusGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.isActive = false;\n    }\n    onFocus() {\n        let isFocusVisible = false;\n        /**\n         * If this element doesn't match focus-visible then don't\n         * apply whileHover. But, if matches throws that focus-visible\n         * is not a valid selector then in that browser outline styles will be applied\n         * to the element by default and we want to match that behaviour with whileFocus.\n         */\n        try {\n            isFocusVisible = this.node.current.matches(\":focus-visible\");\n        }\n        catch (e) {\n            isFocusVisible = true;\n        }\n        if (!isFocusVisible || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", true);\n        this.isActive = true;\n    }\n    onBlur() {\n        if (!this.isActive || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", false);\n        this.isActive = false;\n    }\n    mount() {\n        this.unmount = pipe(addDomEvent(this.node.current, \"focus\", () => this.onFocus()), addDomEvent(this.node.current, \"blur\", () => this.onBlur()));\n    }\n    unmount() { }\n}\n\nexport { FocusGesture };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    const prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (let i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","import { resolveVariantFromProps } from './resolve-variants.mjs';\n\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);\n}\n\nexport { resolveVariant };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nconst secondsToMilliseconds = (seconds) => seconds * 1000;\nconst millisecondsToSeconds = (milliseconds) => milliseconds / 1000;\n\nexport { millisecondsToSeconds, secondsToMilliseconds };\n","import { transformProps } from '../../render/html/utils/transform.mjs';\n\nconst underDampedSpring = {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n};\nconst criticallyDampedSpring = (target) => ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: target === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n});\nconst keyframesTransition = {\n    type: \"keyframes\",\n    duration: 0.8,\n};\n/**\n * Default easing curve is a slightly shallower version of\n * the default browser easing curve.\n */\nconst ease = {\n    type: \"keyframes\",\n    ease: [0.25, 0.1, 0.35, 1],\n    duration: 0.3,\n};\nconst getDefaultTransition = (valueKey, { keyframes }) => {\n    if (keyframes.length > 2) {\n        return keyframesTransition;\n    }\n    else if (transformProps.has(valueKey)) {\n        return valueKey.startsWith(\"scale\")\n            ? criticallyDampedSpring(keyframes[1])\n            : underDampedSpring;\n    }\n    return ease;\n};\n\nexport { getDefaultTransition };\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({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {\n    return !!Object.keys(transition).length;\n}\nfunction getValueTransition(transition, key) {\n    return (transition[key] ||\n        transition[\"default\"] ||\n        transition);\n}\n\nexport { getValueTransition, isTransitionDefined };\n","const instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","const isNotNull = (value) => value !== null;\nfunction getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }, finalKeyframe) {\n    const resolvedKeyframes = keyframes.filter(isNotNull);\n    const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1\n        ? 0\n        : resolvedKeyframes.length - 1;\n    return !index || finalKeyframe === undefined\n        ? resolvedKeyframes[index]\n        : finalKeyframe;\n}\n\nexport { getFinalKeyframe };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nconst isZeroValueString = (v) => /^0[^.\\s]+$/u.test(v);\n\nexport { isZeroValueString };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nconst isNumericalString = (v) => /^-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)$/u.test(v);\n\nexport { isNumericalString };\n","import { invariant } from '../../../utils/errors.mjs';\nimport { isNumericalString } from '../../../utils/is-numerical-string.mjs';\nimport { isCSSVariableToken } from './is-css-variable.mjs';\n\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst splitCSSVariableRegex = \n// eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words\n/^var\\(--(?:([\\w-]+)|([\\w-]+), ?([a-zA-Z\\d ()%#.,-]+))\\)/u;\nfunction parseCSSVariable(current) {\n    const match = splitCSSVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token1, token2, fallback] = match;\n    return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element, depth = 1) {\n    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n    const [token, fallback] = parseCSSVariable(current);\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    const resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        const trimmed = resolved.trim();\n        return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;\n    }\n    return isCSSVariableToken(fallback)\n        ? getVariableValue(fallback, element, depth + 1)\n        : fallback;\n}\n\nexport { getVariableValue, parseCSSVariable };\n","import { transformPropOrder } from '../../html/utils/transform.mjs';\nimport { number } from '../../../value/types/numbers/index.mjs';\nimport { px } from '../../../value/types/numbers/units.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n    \"translateX\",\n    \"translateY\",\n]);\nconst isNumOrPxType = (v) => v === number || v === px;\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/u);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/u);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n    const removedTransforms = [];\n    nonTranslationalTransformKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    return removedTransforms;\n}\nconst positionalValues = {\n    // Dimensions\n    width: ({ x }, { paddingLeft = \"0\", paddingRight = \"0\" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),\n    height: ({ y }, { paddingTop = \"0\", paddingBottom = \"0\" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),\n    top: (_bbox, { top }) => parseFloat(top),\n    left: (_bbox, { left }) => parseFloat(left),\n    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),\n    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\n// Alias translate longform names\npositionalValues.translateX = positionalValues.x;\npositionalValues.translateY = positionalValues.y;\n\nexport { isNumOrPxType, positionalKeys, positionalValues, removeNonTranslationalTransform };\n","/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px, percent, degrees, vw, vh } from '../../../value/types/numbers/units.mjs';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nconst auto = {\n    test: (v) => v === \"auto\",\n    parse: (v) => v,\n};\n\nexport { auto };\n","import { removeNonTranslationalTransform } from '../dom/utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    var _a;\n                    (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete());\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    readAllKeyframes();\n    measureAllKeyframes();\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        /**\n         * Track whether this resolver has completed. Once complete, it never\n         * needs to attempt keyframe resolution again.\n         */\n        this.isComplete = false;\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        /**\n         * Track whether this resolver is currently scheduled to resolve\n         * to allow it to be cancelled and resumed externally.\n         */\n        this.isScheduled = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.isScheduled = true;\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        /**\n         * If a keyframe is null, we hydrate it either by reading it from\n         * the instance, or propagating from previous keyframes.\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (unresolvedKeyframes[i] === null) {\n                /**\n                 * If the first keyframe is null, we need to find its value by sampling the element\n                 */\n                if (i === 0) {\n                    const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();\n                    const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n                    if (currentValue !== undefined) {\n                        unresolvedKeyframes[0] = currentValue;\n                    }\n                    else if (element && name) {\n                        const valueAsRead = element.readValue(name, finalKeyframe);\n                        if (valueAsRead !== undefined && valueAsRead !== null) {\n                            unresolvedKeyframes[0] = valueAsRead;\n                        }\n                    }\n                    if (unresolvedKeyframes[0] === undefined) {\n                        unresolvedKeyframes[0] = finalKeyframe;\n                    }\n                    if (motionValue && currentValue === undefined) {\n                        motionValue.set(unresolvedKeyframes[0]);\n                    }\n                }\n                else {\n                    unresolvedKeyframes[i] = unresolvedKeyframes[i - 1];\n                }\n            }\n        }\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete() {\n        this.isComplete = true;\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (!this.isComplete) {\n            this.isScheduled = false;\n            toResolve.delete(this);\n        }\n    }\n    resume() {\n        if (!this.isComplete)\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n","import { isString, singleColorRegex, isNullish, floatRegex } from '../utils.mjs';\n\n/**\n * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,\n * but false if a number or multiple colors\n */\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp &&\n            !isNullish(v) &&\n            Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { clamp } from '../../../utils/clamp.mjs';\nimport { alpha, number } from '../numbers/index.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = (v) => clamp(0, 255, v);\nconst rgbUnit = {\n    ...number,\n    transform: (v) => Math.round(clampRgbUnit(v)),\n};\nconst rgba = {\n    test: isColorString(\"rgb\", \"red\"),\n    parse: splitColor(\"red\", \"green\", \"blue\"),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => \"rgba(\" +\n        rgbUnit.transform(red) +\n        \", \" +\n        rgbUnit.transform(green) +\n        \", \" +\n        rgbUnit.transform(blue) +\n        \", \" +\n        sanitize(alpha.transform(alpha$1)) +\n        \")\",\n};\n\nexport { rgbUnit, rgba };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = \"\";\n    let g = \"\";\n    let b = \"\";\n    let a = \"\";\n    // If we have 6 characters, ie #FF0000\n    if (v.length > 5) {\n        r = v.substring(1, 3);\n        g = v.substring(3, 5);\n        b = v.substring(5, 7);\n        a = v.substring(7, 9);\n        // Or we have 3 characters, ie #F00\n    }\n    else {\n        r = v.substring(1, 2);\n        g = v.substring(2, 3);\n        b = v.substring(3, 4);\n        a = v.substring(4, 5);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString(\"#\"),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: isColorString(\"hsl\", \"hue\"),\n    parse: splitColor(\"hue\", \"saturation\", \"lightness\"),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return (\"hsla(\" +\n            Math.round(hue) +\n            \", \" +\n            percent.transform(sanitize(saturation)) +\n            \", \" +\n            percent.transform(sanitize(lightness)) +\n            \", \" +\n            sanitize(alpha.transform(alpha$1)) +\n            \")\");\n    },\n};\n\nexport { hsla };\n","import { isString } from '../utils.mjs';\nimport { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty(\"red\")\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { color } from '../color/index.mjs';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.mjs';\n\nfunction test(v) {\n    var _a, _b;\n    return (isNaN(v) &&\n        isString(v) &&\n        (((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) +\n            (((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) >\n            0);\n}\nconst NUMBER_TOKEN = \"number\";\nconst COLOR_TOKEN = \"color\";\nconst VAR_TOKEN = \"var\";\nconst VAR_FUNCTION_TOKEN = \"var(\";\nconst SPLIT_TOKEN = \"${}\";\n// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`\nconst complexRegex = /var\\s*\\(\\s*--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)|#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\)|-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/giu;\nfunction analyseComplexValue(value) {\n    const originalValue = value.toString();\n    const values = [];\n    const indexes = {\n        color: [],\n        number: [],\n        var: [],\n    };\n    const types = [];\n    let i = 0;\n    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {\n        if (color.test(parsedValue)) {\n            indexes.color.push(i);\n            types.push(COLOR_TOKEN);\n            values.push(color.parse(parsedValue));\n        }\n        else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {\n            indexes.var.push(i);\n            types.push(VAR_TOKEN);\n            values.push(parsedValue);\n        }\n        else {\n            indexes.number.push(i);\n            types.push(NUMBER_TOKEN);\n            values.push(parseFloat(parsedValue));\n        }\n        ++i;\n        return SPLIT_TOKEN;\n    });\n    const split = tokenised.split(SPLIT_TOKEN);\n    return { values, split, indexes, types };\n}\nfunction parseComplexValue(v) {\n    return analyseComplexValue(v).values;\n}\nfunction createTransformer(source) {\n    const { split, types } = analyseComplexValue(source);\n    const numSections = split.length;\n    return (v) => {\n        let output = \"\";\n        for (let i = 0; i < numSections; i++) {\n            output += split[i];\n            if (v[i] !== undefined) {\n                const type = types[i];\n                if (type === NUMBER_TOKEN) {\n                    output += sanitize(v[i]);\n                }\n                else if (type === COLOR_TOKEN) {\n                    output += color.transform(v[i]);\n                }\n                else {\n                    output += v[i];\n                }\n            }\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === \"number\" ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parseComplexValue(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = {\n    test,\n    parse: parseComplexValue,\n    createTransformer,\n    getAnimatableNone,\n};\n\nexport { analyseComplexValue, complex };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /\\b([a-z-]*)\\(.*?\\)/gu;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n    ...numberValueTypes,\n    // Color props\n    color,\n    backgroundColor: color,\n    outlineColor: color,\n    fill: color,\n    stroke: color,\n    // Border props\n    borderColor: color,\n    borderTopColor: color,\n    borderRightColor: color,\n    borderBottomColor: color,\n    borderLeftColor: color,\n    filter,\n    WebkitFilter: filter,\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = (key) => defaultValueTypes[key];\n\nexport { defaultValueTypes, getDefaultValueType };\n","import { complex } from '../../../value/types/complex/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return defaultValueType.getAnimatableNone\n        ? defaultValueType.getAnimatableNone(value)\n        : undefined;\n}\n\nexport { getAnimatableNone };\n","import { analyseComplexValue } from '../../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../../dom/value-types/animatable-none.mjs';\n\n/**\n * If we encounter keyframes like \"none\" or \"0\" and we also have keyframes like\n * \"#fff\" or \"200px 200px\" we want to find a keyframe to serve as a template for\n * the \"none\" keyframes. In this case \"#fff\" or \"200px 200px\" - then these get turned into\n * zero equivalents, i.e. \"#fff0\" or \"0px 0px\".\n */\nconst invalidTemplates = new Set([\"auto\", \"none\", \"0\"]);\nfunction makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {\n    let i = 0;\n    let animatableTemplate = undefined;\n    while (i < unresolvedKeyframes.length && !animatableTemplate) {\n        const keyframe = unresolvedKeyframes[i];\n        if (typeof keyframe === \"string\" &&\n            !invalidTemplates.has(keyframe) &&\n            analyseComplexValue(keyframe).values.length) {\n            animatableTemplate = unresolvedKeyframes[i];\n        }\n        i++;\n    }\n    if (animatableTemplate && name) {\n        for (const noneIndex of noneKeyframeIndexes) {\n            unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);\n        }\n    }\n}\n\nexport { makeNoneKeyframesAnimatable };\n","import { isNone } from '../../animation/utils/is-none.mjs';\nimport { getVariableValue } from './utils/css-variables-conversion.mjs';\nimport { isCSSVariableToken } from './utils/is-css-variable.mjs';\nimport { positionalKeys, isNumOrPxType, positionalValues } from './utils/unit-conversion.mjs';\nimport { findDimensionValueType } from './value-types/dimensions.mjs';\nimport { KeyframeResolver } from '../utils/KeyframesResolver.mjs';\nimport { makeNoneKeyframesAnimatable } from '../html/utils/make-none-animatable.mjs';\n\nclass DOMKeyframesResolver extends KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {\n        super(unresolvedKeyframes, onComplete, name, motionValue, element, true);\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, element, name } = this;\n        if (!element || !element.current)\n            return;\n        super.readKeyframes();\n        /**\n         * If any keyframe is a CSS variable, we need to find its value by sampling the element\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            let keyframe = unresolvedKeyframes[i];\n            if (typeof keyframe === \"string\") {\n                keyframe = keyframe.trim();\n                if (isCSSVariableToken(keyframe)) {\n                    const resolved = getVariableValue(keyframe, element.current);\n                    if (resolved !== undefined) {\n                        unresolvedKeyframes[i] = resolved;\n                    }\n                    if (i === unresolvedKeyframes.length - 1) {\n                        this.finalKeyframe = keyframe;\n                    }\n                }\n            }\n        }\n        /**\n         * Resolve \"none\" values. We do this potentially twice - once before and once after measuring keyframes.\n         * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which\n         * have a far bigger performance impact.\n         */\n        this.resolveNoneKeyframes();\n        /**\n         * Check to see if unit type has changed. If so schedule jobs that will\n         * temporarily set styles to the destination keyframes.\n         * Skip if we have more than two keyframes or this isn't a positional value.\n         * TODO: We can throw if there are multiple keyframes and the value type changes.\n         */\n        if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {\n            return;\n        }\n        const [origin, target] = unresolvedKeyframes;\n        const originType = findDimensionValueType(origin);\n        const targetType = findDimensionValueType(target);\n        /**\n         * Either we don't recognise these value types or we can animate between them.\n         */\n        if (originType === targetType)\n            return;\n        /**\n         * If both values are numbers or pixels, we can animate between them by\n         * converting them to numbers.\n         */\n        if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {\n            for (let i = 0; i < unresolvedKeyframes.length; i++) {\n                const value = unresolvedKeyframes[i];\n                if (typeof value === \"string\") {\n                    unresolvedKeyframes[i] = parseFloat(value);\n                }\n            }\n        }\n        else {\n            /**\n             * Else, the only way to resolve this is by measuring the element.\n             */\n            this.needsMeasurement = true;\n        }\n    }\n    resolveNoneKeyframes() {\n        const { unresolvedKeyframes, name } = this;\n        const noneKeyframeIndexes = [];\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (isNone(unresolvedKeyframes[i])) {\n                noneKeyframeIndexes.push(i);\n            }\n        }\n        if (noneKeyframeIndexes.length) {\n            makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);\n        }\n    }\n    measureInitialState() {\n        const { element, unresolvedKeyframes, name } = this;\n        if (!element || !element.current)\n            return;\n        if (name === \"height\") {\n            this.suspendedScrollY = window.pageYOffset;\n        }\n        this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        unresolvedKeyframes[0] = this.measuredOrigin;\n        // Set final key frame to measure after next render\n        const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n        if (measureKeyframe !== undefined) {\n            element.getValue(name, measureKeyframe).jump(measureKeyframe, false);\n        }\n    }\n    measureEndState() {\n        var _a;\n        const { element, name, unresolvedKeyframes } = this;\n        if (!element || !element.current)\n            return;\n        const value = element.getValue(name);\n        value && value.jump(this.measuredOrigin, false);\n        const finalKeyframeIndex = unresolvedKeyframes.length - 1;\n        const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];\n        unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        if (finalKeyframe !== null && this.finalKeyframe === undefined) {\n            this.finalKeyframe = finalKeyframe;\n        }\n        // If we removed transform values, reapply them before the next render\n        if ((_a = this.removedTransforms) === null || _a === void 0 ? void 0 : _a.length) {\n            this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {\n                element\n                    .getValue(unsetTransformName)\n                    .set(unsetTransformValue);\n            });\n        }\n        this.resolveNoneKeyframes();\n    }\n}\n\nexport { DOMKeyframesResolver };\n","import { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\n\nfunction isNone(value) {\n    if (typeof value === \"number\") {\n        return value === 0;\n    }\n    else if (value !== null) {\n        return value === \"none\" || value === \"0\" || isZeroValueString(value);\n    }\n    else {\n        return true;\n    }\n}\n\nexport { isNone };\n","function memo(callback) {\n    let result;\n    return () => {\n        if (result === undefined)\n            result = callback();\n        return result;\n    };\n}\n\nexport { memo };\n","import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';\nimport { frameData } from './frame.mjs';\n\nlet now;\nfunction clearTime() {\n    now = undefined;\n}\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\nconst time = {\n    now: () => {\n        if (now === undefined) {\n            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming\n                ? frameData.timestamp\n                : performance.now());\n        }\n        return now;\n    },\n    set: (newTime) => {\n        now = newTime;\n        queueMicrotask(clearTime);\n    },\n};\n\nexport { time };\n","import { complex } from '../../value/types/complex/index.mjs';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (value, name) => {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (name === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        (complex.test(value) || value === \"0\") && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true;\n    }\n    return false;\n};\n\nexport { isAnimatable };\n","import { time } from '../../frameloop/sync-time.mjs';\nimport { flushKeyframeResolvers } from '../../render/utils/KeyframesResolver.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\n/**\n * Maximum time allowed between an animation being created and it being\n * resolved for us to use the latter as the start time.\n *\n * This is to ensure that while we prefer to \"start\" an animation as soon\n * as it's triggered, we also want to avoid a visual jump if there's a big delay\n * between these two moments.\n */\nconst MAX_RESOLVE_DELAY = 40;\nclass BaseAnimation {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", ...options }) {\n        // Track whether the animation has been stopped. Stopped animations won't restart.\n        this.isStopped = false;\n        this.hasAttemptedResolve = false;\n        this.createdAt = time.now();\n        this.options = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            ...options,\n        };\n        this.updateFinishedPromise();\n    }\n    /**\n     * This method uses the createdAt and resolvedAt to calculate the\n     * animation startTime. *Ideally*, we would use the createdAt time as t=0\n     * as the following frame would then be the first frame of the animation in\n     * progress, which would feel snappier.\n     *\n     * However, if there's a delay (main thread work) between the creation of\n     * the animation and the first commited frame, we prefer to use resolvedAt\n     * to avoid a sudden jump into the animation.\n     */\n    calcStartTime() {\n        if (!this.resolvedAt)\n            return this.createdAt;\n        return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY\n            ? this.resolvedAt\n            : this.createdAt;\n    }\n    /**\n     * A getter for resolved data. If keyframes are not yet resolved, accessing\n     * this.resolved will synchronously flush all pending keyframe resolvers.\n     * This is a deoptimisation, but at its worst still batches read/writes.\n     */\n    get resolved() {\n        if (!this._resolved && !this.hasAttemptedResolve) {\n            flushKeyframeResolvers();\n        }\n        return this._resolved;\n    }\n    /**\n     * A method to be called when the keyframes resolver completes. This method\n     * will check if its possible to run the animation and, if not, skip it.\n     * Otherwise, it will call initPlayback on the implementing class.\n     */\n    onKeyframesResolved(keyframes, finalKeyframe) {\n        this.resolvedAt = time.now();\n        this.hasAttemptedResolve = true;\n        const { name, type, velocity, delay, onComplete, onUpdate, isGenerator, } = this.options;\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {\n            // Finish immediately\n            if (instantAnimationState.current || !delay) {\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete === null || onComplete === void 0 ? void 0 : onComplete();\n                this.resolveFinishedPromise();\n                return;\n            }\n            // Finish after a delay\n            else {\n                this.options.duration = 0;\n            }\n        }\n        const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);\n        if (resolvedAnimation === false)\n            return;\n        this._resolved = {\n            keyframes,\n            finalKeyframe,\n            ...resolvedAnimation,\n        };\n        this.onPostResolved();\n    }\n    onPostResolved() { }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.currentFinishedPromise.then(resolve, reject);\n    }\n    updateFinishedPromise() {\n        this.currentFinishedPromise = new Promise((resolve) => {\n            this.resolveFinishedPromise = resolve;\n        });\n    }\n}\n\nexport { BaseAnimation };\n","import { warning } from '../../../utils/errors.mjs';\nimport { isAnimatable } from '../../utils/is-animatable.mjs';\n\nfunction hasKeyframesChanged(keyframes) {\n    const current = keyframes[0];\n    if (keyframes.length === 1)\n        return true;\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] !== current)\n            return true;\n    }\n}\nfunction canAnimate(keyframes, name, type, velocity) {\n    /**\n     * Check if we're able to animate between the start and end keyframes,\n     * and throw a warning if we're attempting to animate between one that's\n     * animatable and another that isn't.\n     */\n    const originKeyframe = keyframes[0];\n    if (originKeyframe === null)\n        return false;\n    /**\n     * These aren't traditionally animatable but we do support them.\n     * In future we could look into making this more generic or replacing\n     * this function with mix() === mixImmediate\n     */\n    if (name === \"display\" || name === \"visibility\")\n        return true;\n    const targetKeyframe = keyframes[keyframes.length - 1];\n    const isOriginAnimatable = isAnimatable(originKeyframe, name);\n    const isTargetAnimatable = isAnimatable(targetKeyframe, name);\n    warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from \"${originKeyframe}\" to \"${targetKeyframe}\". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \\`style\\` property.`);\n    // Always skip if any of these are true\n    if (!isOriginAnimatable || !isTargetAnimatable) {\n        return false;\n    }\n    return hasKeyframesChanged(keyframes) || (type === \"spring\" && velocity);\n}\n\nexport { canAnimate };\n","/*\n  Convert velocity into velocity per second\n\n  @param [number]: Unit per frame\n  @param [number]: Frame duration in ms\n*/\nfunction velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","import { velocityPerSecond } from '../../../utils/velocity-per-second.mjs';\n\nconst velocitySampleDuration = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { calcGeneratorVelocity };\n","import { warning } from '../../../utils/errors.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { secondsToMilliseconds, millisecondsToSeconds } from '../../../utils/time-conversion.mjs';\n\nconst safeMin = 0.001;\nconst minDuration = 0.01;\nconst maxDuration = 10.0;\nconst minDamping = 0.05;\nconst maxDamping = 1;\nfunction findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(maxDuration), \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: 100,\n            damping: 10,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };\n","import { millisecondsToSeconds, secondsToMilliseconds } from '../../../utils/time-conversion.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.mjs';\nimport { findSpring, calcAngularFreq } from './find.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    const origin = keyframes[0];\n    const target = keyframes[keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);\n    restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    return {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = 0.0;\n                /**\n                 * We only need to calculate velocity for under-damped springs\n                 * as over- and critically-damped springs can't overshoot, so\n                 * checking only for displacement is enough.\n                 */\n                if (dampingRatio < 1) {\n                    currentVelocity =\n                        t === 0\n                            ? secondsToMilliseconds(initialVelocity)\n                            : calcGeneratorVelocity(resolveSpring, t, current);\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n    };\n}\n\nexport { spring };\n","import { spring } from './spring/index.mjs';\nimport { calcGeneratorVelocity } from './utils/velocity.mjs';\n\nfunction inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {\n    const origin = keyframes[0];\n    const state = {\n        done: false,\n        value: origin,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (v) => {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);\n    const calcLatest = (t) => target + calcDelta(t);\n    const applyFriction = (t) => {\n        const delta = calcDelta(t);\n        const latest = calcLatest(t);\n        state.done = Math.abs(delta) <= restDelta;\n        state.value = state.done ? target : latest;\n    };\n    /**\n     * Ideally this would resolve for t in a stateless way, we could\n     * do that by always precalculating the animation but as we know\n     * this will be done anyway we can assume that spring will\n     * be discovered during that.\n     */\n    let timeReachedBoundary;\n    let spring$1;\n    const checkCatchBoundary = (t) => {\n        if (!isOutOfBounds(state.value))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            keyframes: [state.value, nearestBoundary(state.value)],\n            velocity: calcGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDelta,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return {\n        calculatedDuration: null,\n        next: (t) => {\n            /**\n             * We need to resolve the friction to figure out if we need a\n             * spring but we don't want to do this twice per frame. So here\n             * we flag if we updated for this frame and later if we did\n             * we can skip doing it again.\n             */\n            let hasUpdatedFrame = false;\n            if (!spring$1 && timeReachedBoundary === undefined) {\n                hasUpdatedFrame = true;\n                applyFriction(t);\n                checkCatchBoundary(t);\n            }\n            /**\n             * If we have a spring and the provided t is beyond the moment the friction\n             * animation crossed the min/max boundary, use the spring.\n             */\n            if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {\n                return spring$1.next(t - timeReachedBoundary);\n            }\n            else {\n                !hasUpdatedFrame && applyFriction(t);\n                return state;\n            }\n        },\n    };\n}\n\nexport { inertia };\n","import { noop } from '../utils/noop.mjs';\n\n/*\n  Bezier function generator\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *\n    t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noop;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { cubicBezier } from './cubic-bezier.mjs';\n\nconst easeIn = cubicBezier(0.42, 0, 1, 1);\nconst easeOut = cubicBezier(0, 0, 0.58, 1);\nconst easeInOut = cubicBezier(0.42, 0, 0.58, 1);\n\nexport { easeIn, easeInOut, easeOut };\n","// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\nexport { mirrorEasing };\n","// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = (easing) => (p) => 1 - easing(1 - p);\n\nexport { reverseEasing };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst circIn = (p) => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circIn);\n\nexport { circIn, circInOut, circOut };\n","import { cubicBezier } from './cubic-bezier.mjs';\nimport { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst backOut = cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = reverseEasing(backOut);\nconst backInOut = mirrorEasing(backIn);\n\nexport { backIn, backInOut, backOut };\n","import { invariant } from '../../utils/errors.mjs';\nimport { cubicBezier } from '../cubic-bezier.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { easeIn, easeInOut, easeOut } from '../ease.mjs';\nimport { circIn, circInOut, circOut } from '../circ.mjs';\nimport { backIn, backInOut, backOut } from '../back.mjs';\nimport { anticipate } from '../anticipate.mjs';\n\nconst easingLookup = {\n    linear: noop,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n};\nconst easingDefinitionToFunction = (definition) => {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);\n        const [x1, y1, x2, y2] = definition;\n        return cubicBezier(x1, y1, x2, y2);\n    }\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};\n\nexport { easingDefinitionToFunction };\n","import { backIn } from './back.mjs';\n\nconst anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n\nexport { anticipate };\n","/*\n  Progress within given range\n\n  Given a lower limit and an upper limit, we return the progress\n  (expressed as a number 0-1) represented by the given value, and\n  limit that progress to within 0-1.\n\n  @param [number]: Lower limit\n  @param [number]: Upper limit\n  @param [number]: Value to find progress within given range\n  @return [number]: Progress of value within range as expressed 0-1\n*/\nconst progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","/*\n  Value in range from progress\n\n  Given a lower limit and an upper limit, we return the value within\n  that range as expressed by progress (usually a number from 0 to 1)\n\n  So progress = 0.5 would change\n\n  from -------- to\n\n  to\n\n  from ---- to\n\n  E.g. from = 10, to = 20, progress = 0.5 => 15\n\n  @param [number]: Lower limit of range\n  @param [number]: Upper limit of range\n  @param [number]: The progress between lower and upper limits expressed 0-1\n  @return [number]: Value as calculated from progress within range (not limited within range)\n*/\nconst mixNumber = (from, to, progress) => {\n    return from + (to - from) * progress;\n};\n\nexport { mixNumber };\n","// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n","function mixImmediate(a, b) {\n    return (p) => (p > 0 ? b : a);\n}\n\nexport { mixImmediate };\n","import { mixNumber } from './number.mjs';\nimport { warning } from '../errors.mjs';\nimport { hslaToRgba } from '../hsla-to-rgba.mjs';\nimport { hex } from '../../value/types/color/hex.mjs';\nimport { rgba } from '../../value/types/color/rgba.mjs';\nimport { hsla } from '../../value/types/color/hsla.mjs';\nimport { mixImmediate } from './immediate.mjs';\n\n// Linear color space blending\n// Explained https://www.youtube.com/watch?v=LKnqECcg6Gw\n// Demonstrated http://codepen.io/osublake/pen/xGVVaN\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const expo = v * (to * to - fromExpo) + fromExpo;\n    return expo < 0 ? 0 : Math.sqrt(expo);\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nfunction asRGBA(color) {\n    const type = getColorType(color);\n    warning(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`);\n    if (!Boolean(type))\n        return false;\n    let model = type.parse(color);\n    if (type === hsla) {\n        // TODO Remove this cast - needed since Framer Motion's stricter typing\n        model = hslaToRgba(model);\n    }\n    return model;\n}\nconst mixColor = (from, to) => {\n    const fromRGBA = asRGBA(from);\n    const toRGBA = asRGBA(to);\n    if (!fromRGBA || !toRGBA) {\n        return mixImmediate(from, to);\n    }\n    const blended = { ...fromRGBA };\n    return (v) => {\n        blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);\n        blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);\n        blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);\n        blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v);\n        return rgba.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","const invisibleValues = new Set([\"none\", \"hidden\"]);\n/**\n * Returns a function that, when provided a progress value between 0 and 1,\n * will return the \"none\" or \"hidden\" string only when the progress is that of\n * the origin or target.\n */\nfunction mixVisibility(origin, target) {\n    if (invisibleValues.has(origin)) {\n        return (p) => (p <= 0 ? origin : target);\n    }\n    else {\n        return (p) => (p >= 1 ? target : origin);\n    }\n}\n\nexport { invisibleValues, mixVisibility };\n","import { mixNumber as mixNumber$1 } from './number.mjs';\nimport { mixColor } from './color.mjs';\nimport { pipe } from '../pipe.mjs';\nimport { warning } from '../errors.mjs';\nimport { color } from '../../value/types/color/index.mjs';\nimport { complex, analyseComplexValue } from '../../value/types/complex/index.mjs';\nimport { isCSSVariableToken } from '../../render/dom/utils/is-css-variable.mjs';\nimport { invisibleValues, mixVisibility } from './visibility.mjs';\nimport { mixImmediate } from './immediate.mjs';\n\nfunction mixNumber(a, b) {\n    return (p) => mixNumber$1(a, b, p);\n}\nfunction getMixer(a) {\n    if (typeof a === \"number\") {\n        return mixNumber;\n    }\n    else if (typeof a === \"string\") {\n        return isCSSVariableToken(a)\n            ? mixImmediate\n            : color.test(a)\n                ? mixColor\n                : mixComplex;\n    }\n    else if (Array.isArray(a)) {\n        return mixArray;\n    }\n    else if (typeof a === \"object\") {\n        return color.test(a) ? mixColor : mixObject;\n    }\n    return mixImmediate;\n}\nfunction mixArray(a, b) {\n    const output = [...a];\n    const numValues = output.length;\n    const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));\n    return (p) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](p);\n        }\n        return output;\n    };\n}\nfunction mixObject(a, b) {\n    const output = { ...a, ...b };\n    const blendValue = {};\n    for (const key in output) {\n        if (a[key] !== undefined && b[key] !== undefined) {\n            blendValue[key] = getMixer(a[key])(a[key], b[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n}\nfunction matchOrder(origin, target) {\n    var _a;\n    const orderedOrigin = [];\n    const pointers = { color: 0, var: 0, number: 0 };\n    for (let i = 0; i < target.values.length; i++) {\n        const type = target.types[i];\n        const originIndex = origin.indexes[type][pointers[type]];\n        const originValue = (_a = origin.values[originIndex]) !== null && _a !== void 0 ? _a : 0;\n        orderedOrigin[i] = originValue;\n        pointers[type]++;\n    }\n    return orderedOrigin;\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyseComplexValue(origin);\n    const targetStats = analyseComplexValue(target);\n    const canInterpolate = originStats.indexes.var.length === targetStats.indexes.var.length &&\n        originStats.indexes.color.length === targetStats.indexes.color.length &&\n        originStats.indexes.number.length >= targetStats.indexes.number.length;\n    if (canInterpolate) {\n        if ((invisibleValues.has(origin) &&\n            !targetStats.values.length) ||\n            (invisibleValues.has(target) &&\n                !originStats.values.length)) {\n            return mixVisibility(origin, target);\n        }\n        return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n        return mixImmediate(origin, target);\n    }\n};\n\nexport { getMixer, mixArray, mixComplex, mixObject };\n","import { getMixer } from './complex.mjs';\nimport { mixNumber } from './number.mjs';\n\nfunction mix(from, to, p) {\n    if (typeof from === \"number\" &&\n        typeof to === \"number\" &&\n        typeof p === \"number\") {\n        return mixNumber(from, to, p);\n    }\n    const mixer = getMixer(from);\n    return mixer(from, to);\n}\n\nexport { mix };\n","import { invariant } from './errors.mjs';\nimport { clamp } from './clamp.mjs';\nimport { pipe } from './pipe.mjs';\nimport { progress } from './progress.mjs';\nimport { noop } from './noop.mjs';\nimport { mix } from './mix/index.mjs';\n\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || mix;\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] || noop : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\n/**\n * Create a function that maps from a numerical input array to a generic output array.\n *\n * Accepts:\n *   - Numbers\n *   - Colors (hex, hsl, hsla, rgb, rgba)\n *   - Complex (combinations of one or more numbers or strings)\n *\n * ```jsx\n * const mixColor = interpolate([0, 1], ['#fff', '#000'])\n *\n * mixColor(0.5) // 'rgba(128, 128, 128, 1)'\n * ```\n *\n * TODO Revist this approach once we've moved to data models for values,\n * probably not needed to pregenerate mixer functions.\n *\n * @public\n */\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, \"Both input and output ranges must be the same length\");\n    /**\n     * If we're only provided a single input, we can just make a function\n     * that returns the output.\n     */\n    if (inputLength === 1)\n        return () => output[0];\n    if (inputLength === 2 && input[0] === input[1])\n        return () => output[1];\n    // If input runs highest -> lowest, reverse both arrays\n    if (input[0] > input[inputLength - 1]) {\n        input = [...input].reverse();\n        output = [...output].reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const numMixers = mixers.length;\n    const interpolator = (v) => {\n        let i = 0;\n        if (numMixers > 1) {\n            for (; i < input.length - 2; i++) {\n                if (v < input[i + 1])\n                    break;\n            }\n        }\n        const progressInRange = progress(input[i], input[i + 1], v);\n        return mixers[i](progressInRange);\n    };\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n","import { fillOffset } from './fill.mjs';\n\nfunction defaultOffset(arr) {\n    const offset = [0];\n    fillOffset(offset, arr.length - 1);\n    return offset;\n}\n\nexport { defaultOffset };\n","import { mixNumber } from '../mix/number.mjs';\nimport { progress } from '../progress.mjs';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mixNumber(min, 1, offsetProgress));\n    }\n}\n\nexport { fillOffset };\n","import { easeInOut } from '../../easing/ease.mjs';\nimport { isEasingArray } from '../../easing/utils/is-easing-array.mjs';\nimport { easingDefinitionToFunction } from '../../easing/utils/map.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../../utils/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n","const isEasingArray = (ease) => {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { isEasingArray };\n","function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n","import { time } from '../../../frameloop/sync-time.mjs';\nimport { frame, cancelFrame, frameData } from '../../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: () => frame.update(passTimestamp, true),\n        stop: () => cancelFrame(passTimestamp),\n        /**\n         * If we're processing this frame we can use the\n         * framelocked timestamp to keep things in sync.\n         */\n        now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),\n    };\n};\n\nexport { frameloopDriver };\n","import { KeyframeResolver } from '../../render/utils/KeyframesResolver.mjs';\nimport { spring } from '../generators/spring/index.mjs';\nimport { inertia } from '../generators/inertia.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { mix } from '../../utils/mix/index.mjs';\nimport { calcGeneratorDuration } from '../generators/utils/calc-duration.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { clamp } from '../../utils/clamp.mjs';\nimport { invariant } from '../../utils/errors.mjs';\nimport { frameloopDriver } from './drivers/driver-frameloop.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\nconst generators = {\n    decay: inertia,\n    inertia,\n    tween: keyframes,\n    keyframes: keyframes,\n    spring,\n};\nconst percentToProgress = (percent) => percent / 100;\n/**\n * Animation that runs on the main thread. Designed to be WAAPI-spec in the subset of\n * features we expose publically. Mostly the compatibility is to ensure visual identity\n * between both WAAPI and main thread animations.\n */\nclass MainThreadAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * The time at which the animation was cancelled.\n         */\n        this.cancelTime = null;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * The state of the animation to apply when the animation is resolved. This\n         * allows calls to the public API to control the animation before it is resolved,\n         * without us having to resolve it first.\n         */\n        this.pendingPlayState = \"running\";\n        /**\n         * The time at which the animation was started.\n         */\n        this.startTime = null;\n        this.state = \"idle\";\n        /**\n         * This method is bound to the instance to fix a pattern where\n         * animation.stop is returned as a reference from a useEffect.\n         */\n        this.stop = () => {\n            this.resolver.cancel();\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            const { onStop } = this.options;\n            onStop && onStop();\n        };\n        const { name, motionValue, element, keyframes } = this.options;\n        const KeyframeResolver$1 = (element === null || element === void 0 ? void 0 : element.KeyframeResolver) || KeyframeResolver;\n        const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);\n        this.resolver = new KeyframeResolver$1(keyframes, onResolved, name, motionValue, element);\n        this.resolver.scheduleResolve();\n    }\n    initPlayback(keyframes$1) {\n        const { type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = this.options;\n        const generatorFactory = generators[type] || keyframes;\n        /**\n         * If our generator doesn't support mixing numbers, we need to replace keyframes with\n         * [0, 100] and then make a function that maps that to the actual keyframes.\n         *\n         * 100 is chosen instead of 1 as it works nicer with spring animations.\n         */\n        let mapPercentToKeyframes;\n        let mirroredGenerator;\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            if (process.env.NODE_ENV !== \"production\") {\n                invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n            }\n            mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });\n        /**\n         * If we have a mirror repeat type we need to create a second generator that outputs the\n         * mirrored (not reversed) animation and later ping pong between the two generators.\n         */\n        if (repeatType === \"mirror\") {\n            mirroredGenerator = generatorFactory({\n                ...this.options,\n                keyframes: [...keyframes$1].reverse(),\n                velocity: -velocity,\n            });\n        }\n        /**\n         * If duration is undefined and we have repeat options,\n         * we need to calculate a duration from the generator.\n         *\n         * We set it to the generator itself to cache the duration.\n         * Any timeline resolver will need to have already precalculated\n         * the duration by this step.\n         */\n        if (generator.calculatedDuration === null) {\n            generator.calculatedDuration = calcGeneratorDuration(generator);\n        }\n        const { calculatedDuration } = generator;\n        const resolvedDuration = calculatedDuration + repeatDelay;\n        const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n        return {\n            generator,\n            mirroredGenerator,\n            mapPercentToKeyframes,\n            calculatedDuration,\n            resolvedDuration,\n            totalDuration,\n        };\n    }\n    onPostResolved() {\n        const { autoplay = true } = this.options;\n        this.play();\n        if (this.pendingPlayState === \"paused\" || !autoplay) {\n            this.pause();\n        }\n        else {\n            this.state = this.pendingPlayState;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { resolved } = this;\n        // If the animations has failed to resolve, return the final keyframe.\n        if (!resolved) {\n            const { keyframes } = this.options;\n            return { done: true, value: keyframes[keyframes.length - 1] };\n        }\n        const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes, calculatedDuration, totalDuration, resolvedDuration, } = resolved;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay, repeat, repeatType, repeatDelay, onUpdate } = this.options;\n        /**\n         * requestAnimationFrame timestamps can come through as lower than\n         * the startTime as set by performance.now(). Here we prevent this,\n         * though in the future it could be possible to make setting startTime\n         * a pending operation that gets resolved here.\n         */\n        if (this.speed > 0) {\n            this.startTime = Math.min(this.startTime, timestamp);\n        }\n        else if (this.speed < 0) {\n            this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);\n        }\n        // Update currentTime\n        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else if (this.holdTime !== null) {\n            this.currentTime = this.holdTime;\n        }\n        else {\n            // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n            // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n            // example.\n            this.currentTime =\n                Math.round(timestamp - this.startTime) * this.speed;\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.speed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.speed >= 0\n            ? timeWithoutDelay < 0\n            : timeWithoutDelay > totalDuration;\n        this.currentTime = Math.max(timeWithoutDelay, 0);\n        // If this animation has finished, set the current time  to the total duration.\n        if (this.state === \"finished\" && this.holdTime === null) {\n            this.currentTime = totalDuration;\n        }\n        let elapsed = this.currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        const state = isInDelayPhase\n            ? { done: false, value: keyframes[0] }\n            : frameGenerator.next(elapsed);\n        if (mapPercentToKeyframes) {\n            state.value = mapPercentToKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.speed >= 0\n                    ? this.currentTime >= totalDuration\n                    : this.currentTime <= 0;\n        }\n        const isAnimationFinished = this.holdTime === null &&\n            (this.state === \"finished\" || (this.state === \"running\" && done));\n        if (isAnimationFinished && finalKeyframe !== undefined) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\n    get duration() {\n        const { resolved } = this;\n        return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;\n    }\n    get time() {\n        return millisecondsToSeconds(this.currentTime);\n    }\n    set time(newTime) {\n        newTime = secondsToMilliseconds(newTime);\n        this.currentTime = newTime;\n        if (this.holdTime !== null || this.speed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.speed;\n        }\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        this.playbackSpeed = newSpeed;\n        if (hasChanged) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (!this.resolver.isScheduled) {\n            this.resolver.resume();\n        }\n        if (!this._resolved) {\n            this.pendingPlayState = \"running\";\n            return;\n        }\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, onPlay, startTime } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        onPlay && onPlay();\n        const now = this.driver.now();\n        if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();\n        }\n        else if (this.state === \"finished\") {\n            this.startTime = now;\n        }\n        if (this.state === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        this.cancelTime = this.startTime;\n        this.holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        this.state = \"running\";\n        this.driver.start();\n    }\n    pause() {\n        var _a;\n        if (!this._resolved) {\n            this.pendingPlayState = \"paused\";\n            return;\n        }\n        this.state = \"paused\";\n        this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.pendingPlayState = this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.teardown();\n        this.state = \"finished\";\n        const { onComplete } = this.options;\n        onComplete && onComplete();\n    }\n    cancel() {\n        if (this.cancelTime !== null) {\n            this.tick(this.cancelTime);\n        }\n        this.teardown();\n        this.updateFinishedPromise();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        this.startTime = this.cancelTime = null;\n        this.resolver.cancel();\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(time) {\n        this.startTime = 0;\n        return this.tick(time, true);\n    }\n}\n// Legacy interface\nfunction animateValue(options) {\n    return new MainThreadAnimation(options);\n}\n\nexport { MainThreadAnimation, animateValue };\n","/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n","const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === \"number\";\n\nexport { isBezierDefinition };\n","import { isBezierDefinition } from '../../../easing/utils/is-bezier-definition.mjs';\n\nfunction isWaapiSupportedEasing(easing) {\n    return Boolean(!easing ||\n        (typeof easing === \"string\" && easing in supportedWaapiEasing) ||\n        isBezierDefinition(easing) ||\n        (Array.isArray(easing) && easing.every(isWaapiSupportedEasing)));\n}\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\nconst supportedWaapiEasing = {\n    linear: \"linear\",\n    ease: \"ease\",\n    easeIn: \"ease-in\",\n    easeOut: \"ease-out\",\n    easeInOut: \"ease-in-out\",\n    circIn: cubicBezierAsString([0, 0.65, 0.55, 1]),\n    circOut: cubicBezierAsString([0.55, 0, 1, 0.45]),\n    backIn: cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),\n    backOut: cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),\n};\nfunction mapEasingToNativeEasingWithDefault(easing) {\n    return (mapEasingToNativeEasing(easing) ||\n        supportedWaapiEasing.easeOut);\n}\nfunction mapEasingToNativeEasing(easing) {\n    if (!easing) {\n        return undefined;\n    }\n    else if (isBezierDefinition(easing)) {\n        return cubicBezierAsString(easing);\n    }\n    else if (Array.isArray(easing)) {\n        return easing.map(mapEasingToNativeEasingWithDefault);\n    }\n    else {\n        return supportedWaapiEasing[easing];\n    }\n}\n\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing };\n","import { DOMKeyframesResolver } from '../../render/dom/DOMKeyframesResolver.mjs';\nimport { memo } from '../../utils/memo.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { millisecondsToSeconds, secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { MainThreadAnimation } from './MainThreadAnimation.mjs';\nimport { acceleratedValues } from './utils/accelerated-values.mjs';\nimport { animateStyle } from './waapi/index.mjs';\nimport { isWaapiSupportedEasing } from './waapi/easing.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\nconst supportsWaapi = memo(() => Object.hasOwnProperty.call(Element.prototype, \"animate\"));\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxDuration = 20000;\n/**\n * Check if an animation can run natively via WAAPI or requires pregenerated keyframes.\n * WAAPI doesn't support spring or function easings so we run these as JS animation before\n * handing off.\n */\nfunction requiresPregeneratedKeyframes(options) {\n    return options.type === \"spring\" || !isWaapiSupportedEasing(options.ease);\n}\nfunction pregenerateKeyframes(keyframes, options) {\n    /**\n     * Create a main-thread animation to pregenerate keyframes.\n     * We sample this at regular intervals to generate keyframes that we then\n     * linearly interpolate between.\n     */\n    const sampleAnimation = new MainThreadAnimation({\n        ...options,\n        keyframes,\n        repeat: 0,\n        delay: 0,\n        isGenerator: true,\n    });\n    let state = { done: false, value: keyframes[0] };\n    const pregeneratedKeyframes = [];\n    /**\n     * Bail after 20 seconds of pre-generated keyframes as it's likely\n     * we're heading for an infinite loop.\n     */\n    let t = 0;\n    while (!state.done && t < maxDuration) {\n        state = sampleAnimation.sample(t);\n        pregeneratedKeyframes.push(state.value);\n        t += sampleDelta;\n    }\n    return {\n        times: undefined,\n        keyframes: pregeneratedKeyframes,\n        duration: t - sampleDelta,\n        ease: \"linear\",\n    };\n}\nclass AcceleratedAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        const { name, motionValue, element, keyframes } = this.options;\n        this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue, element);\n        this.resolver.scheduleResolve();\n    }\n    initPlayback(keyframes, finalKeyframe) {\n        var _a;\n        let { duration = 300, times, ease, type, motionValue, name, startTime, } = this.options;\n        /**\n         * If element has since been unmounted, return false to indicate\n         * the animation failed to initialised.\n         */\n        if (!((_a = motionValue.owner) === null || _a === void 0 ? void 0 : _a.current)) {\n            return false;\n        }\n        /**\n         * If this animation needs pre-generated keyframes then generate.\n         */\n        if (requiresPregeneratedKeyframes(this.options)) {\n            const { onComplete, onUpdate, motionValue, element, ...options } = this.options;\n            const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);\n            keyframes = pregeneratedAnimation.keyframes;\n            // If this is a very short animation, ensure we have\n            // at least two keyframes to animate between as older browsers\n            // can't animate between a single keyframe.\n            if (keyframes.length === 1) {\n                keyframes[1] = keyframes[0];\n            }\n            duration = pregeneratedAnimation.duration;\n            times = pregeneratedAnimation.times;\n            ease = pregeneratedAnimation.ease;\n            type = \"keyframes\";\n        }\n        const animation = animateStyle(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });\n        // Override the browser calculated startTime with one synchronised to other JS\n        // and WAAPI animations starting this event loop.\n        animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();\n        if (this.pendingTimeline) {\n            animation.timeline = this.pendingTimeline;\n            this.pendingTimeline = undefined;\n        }\n        else {\n            /**\n             * Prefer the `onfinish` prop as it's more widely supported than\n             * the `finished` promise.\n             *\n             * Here, we synchronously set the provided MotionValue to the end\n             * keyframe. If we didn't, when the WAAPI animation is finished it would\n             * be removed from the element which would then revert to its old styles.\n             */\n            animation.onfinish = () => {\n                const { onComplete } = this.options;\n                motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.cancel();\n                this.resolveFinishedPromise();\n            };\n        }\n        return {\n            animation,\n            duration,\n            times,\n            type,\n            ease,\n            keyframes: keyframes,\n        };\n    }\n    get duration() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { duration } = resolved;\n        return millisecondsToSeconds(duration);\n    }\n    get time() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { animation } = resolved;\n        return millisecondsToSeconds(animation.currentTime || 0);\n    }\n    set time(newTime) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.currentTime = secondsToMilliseconds(newTime);\n    }\n    get speed() {\n        const { resolved } = this;\n        if (!resolved)\n            return 1;\n        const { animation } = resolved;\n        return animation.playbackRate;\n    }\n    set speed(newSpeed) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.playbackRate = newSpeed;\n    }\n    get state() {\n        const { resolved } = this;\n        if (!resolved)\n            return \"idle\";\n        const { animation } = resolved;\n        return animation.playState;\n    }\n    get startTime() {\n        const { resolved } = this;\n        if (!resolved)\n            return null;\n        const { animation } = resolved;\n        // Coerce to number as TypeScript incorrectly types this\n        // as CSSNumberish\n        return animation.startTime;\n    }\n    /**\n     * Replace the default DocumentTimeline with another AnimationTimeline.\n     * Currently used for scroll animations.\n     */\n    attachTimeline(timeline) {\n        if (!this._resolved) {\n            this.pendingTimeline = timeline;\n        }\n        else {\n            const { resolved } = this;\n            if (!resolved)\n                return noop;\n            const { animation } = resolved;\n            animation.timeline = timeline;\n            animation.onfinish = null;\n        }\n        return noop;\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        if (animation.playState === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        animation.play();\n    }\n    pause() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.pause();\n    }\n    stop() {\n        this.resolver.cancel();\n        this.isStopped = true;\n        if (this.state === \"idle\")\n            return;\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation, keyframes, duration, type, ease, times } = resolved;\n        if (animation.playState === \"idle\" ||\n            animation.playState === \"finished\") {\n            return;\n        }\n        /**\n         * WAAPI doesn't natively have any interruption capabilities.\n         *\n         * Rather than read commited styles back out of the DOM, we can\n         * create a renderless JS animation and sample it twice to calculate\n         * its current value, \"previous\" value, and therefore allow\n         * Motion to calculate velocity for any subsequent animation.\n         */\n        if (this.time) {\n            const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n            const sampleAnimation = new MainThreadAnimation({\n                ...options,\n                keyframes,\n                duration,\n                type,\n                ease,\n                times,\n                isGenerator: true,\n            });\n            const sampleTime = secondsToMilliseconds(this.time);\n            motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);\n        }\n        const { onStop } = this.options;\n        onStop && onStop();\n        this.cancel();\n    }\n    complete() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.finish();\n    }\n    cancel() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.cancel();\n    }\n    static supports(options) {\n        const { motionValue, name, repeatDelay, repeatType, damping, type } = options;\n        return (supportsWaapi() &&\n            name &&\n            acceleratedValues.has(name) &&\n            motionValue &&\n            motionValue.owner &&\n            motionValue.owner.current instanceof HTMLElement &&\n            /**\n             * If we're outputting values to onUpdate then we can't use WAAPI as there's\n             * no way to read the value from WAAPI every frame.\n             */\n            !motionValue.owner.getProps().onUpdate &&\n            !repeatDelay &&\n            repeatType !== \"mirror\" &&\n            damping !== 0 &&\n            type !== \"inertia\");\n    }\n}\n\nexport { AcceleratedAnimation };\n","import { mapEasingToNativeEasing } from './easing.mjs';\n\nfunction animateStyle(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = \"loop\", ease, times, } = {}) {\n    const keyframeOptions = { [valueName]: keyframes };\n    if (times)\n        keyframeOptions.offset = times;\n    const easing = mapEasingToNativeEasing(ease);\n    /**\n     * If this is an easing array, apply to keyframes, not animation as a whole\n     */\n    if (Array.isArray(easing))\n        keyframeOptions.easing = easing;\n    return element.animate(keyframeOptions, {\n        delay,\n        duration,\n        easing: !Array.isArray(easing) ? easing : \"linear\",\n        fill: \"both\",\n        iterations: repeat + 1,\n        direction: repeatType === \"reverse\" ? \"alternate\" : \"normal\",\n    });\n}\n\nexport { animateStyle };\n","import { memo } from '../../../utils/memo.mjs';\n\nconst supportsScrollTimeline = memo(() => window.ScrollTimeline !== undefined);\n\nexport { supportsScrollTimeline };\n","import { observeTimeline } from '../render/dom/scroll/observe.mjs';\nimport { supportsScrollTimeline } from '../render/dom/scroll/supports.mjs';\n\nclass GroupPlaybackControls {\n    constructor(animations) {\n        // Bound to accomodate common `return animation.stop` pattern\n        this.stop = () => this.runAll(\"stop\");\n        this.animations = animations.filter(Boolean);\n    }\n    then(onResolve, onReject) {\n        return Promise.all(this.animations).then(onResolve).catch(onReject);\n    }\n    /**\n     * TODO: Filter out cancelled or stopped animations before returning\n     */\n    getAll(propName) {\n        return this.animations[0][propName];\n    }\n    setAll(propName, newValue) {\n        for (let i = 0; i < this.animations.length; i++) {\n            this.animations[i][propName] = newValue;\n        }\n    }\n    attachTimeline(timeline) {\n        const cancelAll = this.animations.map((animation) => {\n            if (supportsScrollTimeline() && animation.attachTimeline) {\n                animation.attachTimeline(timeline);\n            }\n            else {\n                animation.pause();\n                return observeTimeline((progress) => {\n                    animation.time = animation.duration * progress;\n                }, timeline);\n            }\n        });\n        return () => {\n            cancelAll.forEach((cancelTimeline, i) => {\n                if (cancelTimeline)\n                    cancelTimeline();\n                this.animations[i].stop();\n            });\n        };\n    }\n    get time() {\n        return this.getAll(\"time\");\n    }\n    set time(time) {\n        this.setAll(\"time\", time);\n    }\n    get speed() {\n        return this.getAll(\"speed\");\n    }\n    set speed(speed) {\n        this.setAll(\"speed\", speed);\n    }\n    get startTime() {\n        return this.getAll(\"startTime\");\n    }\n    get duration() {\n        let max = 0;\n        for (let i = 0; i < this.animations.length; i++) {\n            max = Math.max(max, this.animations[i].duration);\n        }\n        return max;\n    }\n    runAll(methodName) {\n        this.animations.forEach((controls) => controls[methodName]());\n    }\n    play() {\n        this.runAll(\"play\");\n    }\n    pause() {\n        this.runAll(\"pause\");\n    }\n    cancel() {\n        this.runAll(\"cancel\");\n    }\n    complete() {\n        this.runAll(\"complete\");\n    }\n}\n\nexport { GroupPlaybackControls };\n","import { frame, cancelFrame } from '../../../frameloop/frame.mjs';\n\nfunction observeTimeline(update, timeline) {\n    let prevProgress;\n    const onFrame = () => {\n        const { currentTime } = timeline;\n        const percentage = currentTime === null ? 0 : currentTime.value;\n        const progress = percentage / 100;\n        if (prevProgress !== progress) {\n            update(progress);\n        }\n        prevProgress = progress;\n    };\n    frame.update(onFrame, true);\n    return () => cancelFrame(onFrame);\n}\n\nexport { observeTimeline };\n","import { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getValueTransition, isTransitionDefined } from '../utils/transitions.mjs';\nimport { MotionGlobalConfig } from '../../utils/GlobalConfig.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { getFinalKeyframe } from '../animators/waapi/utils/get-final-keyframe.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\nimport { AcceleratedAnimation } from '../animators/AcceleratedAnimation.mjs';\nimport { MainThreadAnimation } from '../animators/MainThreadAnimation.mjs';\nimport { GroupPlaybackControls } from '../GroupPlaybackControls.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff, \n/**\n * Currently used to remove values from will-change when an animation ends.\n * Preferably this would be handled by event listeners on the MotionValue\n * but these aren't consistent enough yet when considering the different ways\n * an animation can be cancelled.\n */\nonEnd) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    let options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n            onEnd && onEnd();\n        },\n        onStop: onEnd,\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unqiue transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        options = {\n            ...options,\n            ...getDefaultTransition(name, options),\n        };\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    if (options.duration) {\n        options.duration = secondsToMilliseconds(options.duration);\n    }\n    if (options.repeatDelay) {\n        options.repeatDelay = secondsToMilliseconds(options.repeatDelay);\n    }\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        options.duration = 0;\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (instantAnimationState.current ||\n        MotionGlobalConfig.skipAnimations) {\n        shouldSkip = true;\n        options.duration = 0;\n        options.delay = 0;\n    }\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            // We still want to return some animation controls here rather\n            // than returning undefined\n            return new GroupPlaybackControls([]);\n        }\n    }\n    /**\n     * Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via\n     * WAAPI. Therefore, this animation must be JS to ensure it runs \"under\" the\n     * optimised animation.\n     */\n    if (!isHandoff && AcceleratedAnimation.supports(options)) {\n        return new AcceleratedAnimation(options);\n    }\n    else {\n        return new MainThreadAnimation(options);\n    }\n};\n\nexport { animateMotionValue };\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nclass SubscriptionManager {\n    constructor() {\n        this.subscriptions = [];\n    }\n    add(handler) {\n        addUniqueItem(this.subscriptions, handler);\n        return () => removeItem(this.subscriptions, handler);\n    }\n    notify(a, b, c) {\n        const numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (let i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                const handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    }\n    getSize() {\n        return this.subscriptions.length;\n    }\n    clear() {\n        this.subscriptions.length = 0;\n    }\n}\n\nexport { SubscriptionManager };\n","import { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    constructor(init, options = {}) {\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"11.3.29\";\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 = null;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v, render = true) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev && this.events.change) {\n                this.events.change.notify(this.current);\n            }\n            // Update render subscribers\n            if (render && this.events.renderRequest) {\n                this.events.renderRequest.notify(this.current);\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n        if (this.canTrackVelocity === null && current !== undefined) {\n            this.canTrackVelocity = isFloat(this.current);\n        }\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v, render = true) {\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v, endAnimation = true) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        endAnimation && this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nfunction motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n\nexport { MotionValue, collectMotionValues, motionValue };\n","import { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved || {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\n\nexport { setTarget };\n","import { optimizedAppearDataAttribute } from './data-id.mjs';\n\nfunction getOptimisedAppearId(visualElement) {\n    return visualElement.getProps()[optimizedAppearDataAttribute];\n}\n\nexport { getOptimisedAppearId };\n","import { MotionValue } from '../index.mjs';\nimport { getWillChangeName } from './get-will-change-name.mjs';\nimport { removeItem } from '../../utils/array.mjs';\n\nclass WillChangeMotionValue extends MotionValue {\n    constructor() {\n        super(...arguments);\n        this.output = [];\n        this.counts = new Map();\n    }\n    add(name) {\n        const styleName = getWillChangeName(name);\n        if (!styleName)\n            return;\n        /**\n         * Update counter. Each value has an indepdent counter\n         * as multiple sources could be requesting the same value\n         * gets added to will-change.\n         */\n        const prevCount = this.counts.get(styleName) || 0;\n        this.counts.set(styleName, prevCount + 1);\n        if (prevCount === 0) {\n            this.output.push(styleName);\n            this.update();\n        }\n        /**\n         * Prevents the remove function from being called multiple times.\n         */\n        let hasRemoved = false;\n        return () => {\n            if (hasRemoved)\n                return;\n            hasRemoved = true;\n            const newCount = this.counts.get(styleName) - 1;\n            this.counts.set(styleName, newCount);\n            if (newCount === 0) {\n                removeItem(this.output, styleName);\n                this.update();\n            }\n        };\n    }\n    update() {\n        this.set(this.output.length ? this.output.join(\", \") : \"auto\");\n    }\n}\n\nexport { WillChangeMotionValue };\n","import { WillChangeMotionValue } from './WillChangeMotionValue.mjs';\nimport { isWillChangeMotionValue } from './is.mjs';\n\nfunction addValueToWillChange(visualElement, key) {\n    var _a;\n    if (!visualElement.applyWillChange)\n        return;\n    let willChange = visualElement.getValue(\"willChange\");\n    /**\n     * If we haven't created a willChange MotionValue, and the we haven't been\n     * manually provided one, create one.\n     */\n    if (!willChange && !((_a = visualElement.props.style) === null || _a === void 0 ? void 0 : _a.willChange)) {\n        willChange = new WillChangeMotionValue(\"auto\");\n        visualElement.addValue(\"willChange\", willChange);\n    }\n    /**\n     * It could be that a user has set willChange to a regular MotionValue,\n     * in which case we can't add the value to it.\n     */\n    if (isWillChangeMotionValue(willChange)) {\n        return willChange.add(key);\n    }\n}\n\nexport { addValueToWillChange };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n","import { transformProps } from '../../render/html/utils/transform.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { getValueTransition } from '../utils/transitions.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { addValueToWillChange } from '../../value/use-will-change/add-will-change.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\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({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    var _a;\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    for (const key in target) {\n        const value = visualElement.getValue(key, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            ...getValueTransition(transition || {}, key),\n        };\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.MotionHandoffAnimation) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const startTime = window.MotionHandoffAnimation(appearId, key, frame);\n                if (startTime !== null) {\n                    valueTransition.startTime = startTime;\n                    isHandoff = true;\n                }\n            }\n        }\n        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff, addValueToWillChange(visualElement, key)));\n        const animation = value.animation;\n        if (animation) {\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        Promise.all(animations).then(() => {\n            frame.update(() => {\n                transitionEnd && setTarget(visualElement, transitionEnd);\n            });\n        });\n    }\n    return animations;\n}\n\nexport { animateTarget };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    var _a;\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n        : undefined);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\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    const getAnimation = resolved\n        ? () => Promise.all(animateTarget(visualElement, resolved, options))\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n\nexport { animateVariant, sortByTreeOrder };\n","import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\nimport { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    let state = createState();\n    let 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    const buildResolvedTypeValues = (type) => (acc, definition) => {\n        var _a;\n        const resolved = resolveVariant(visualElement, definition, type === \"exit\"\n            ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n            : undefined);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\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(changedActiveType) {\n        const props = visualElement.getProps();\n        const 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        const 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        const 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        let 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        let removedVariantIndex = Infinity;\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 (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined\n                ? props[type]\n                : context[type];\n            const 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            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] &&\n                prop !== props[type] &&\n                propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                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            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            let handledRemovedValues = false;\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            const 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            let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                if (removedKeys.has(key)) {\n                    handledRemovedValues = true;\n                    removedKeys.delete(key);\n                }\n                typeState.needsAnimating[key] = true;\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = false;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                let valueHasChanged = false;\n                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                    valueHasChanged = !shallowCompare(next, prev);\n                }\n                else {\n                    valueHasChanged = next !== prev;\n                }\n                if (valueHasChanged) {\n                    if (next !== undefined && next !== null) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...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             */\n            if (shouldAnimateType && (!isInherited || handledRemovedValues)) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type },\n                })));\n            }\n        }\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            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = true;\n                // @ts-expect-error - @mattgperry to figure if we should do something here\n                fallbackAnimation[key] = fallbackTarget !== null && fallbackTarget !== void 0 ? fallbackTarget : null;\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            (props.initial === false || props.initial === props.animate) &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n        reset: () => {\n            state = createState();\n            isInitialRender = true;\n        },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\nimport { animateVariant } from './visual-element-variant.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => {\n        visualElement.notify(\"AnimationComplete\", definition);\n    });\n}\n\nexport { animateVisualElement };\n","import { Feature } from '../Feature.mjs';\n\nlet id = 0;\nclass ExitAnimationFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.id = id++;\n    }\n    update() {\n        if (!this.node.presenceContext)\n            return;\n        const { isPresent, onExitComplete } = this.node.presenceContext;\n        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};\n        if (!this.node.animationState || isPresent === prevIsPresent) {\n            return;\n        }\n        const exitAnimation = this.node.animationState.setActive(\"exit\", !isPresent);\n        if (onExitComplete && !isPresent) {\n            exitAnimation.then(() => onExitComplete(this.id));\n        }\n    }\n    mount() {\n        const { register } = this.node.presenceContext || {};\n        if (register) {\n            this.unmount = register(this.id);\n        }\n    }\n    unmount() { }\n}\n\nexport { ExitAnimationFeature };\n","import { AnimationFeature } from './animation/index.mjs';\nimport { ExitAnimationFeature } from './animation/exit.mjs';\n\nconst animations = {\n    animation: {\n        Feature: AnimationFeature,\n    },\n    exit: {\n        Feature: ExitAnimationFeature,\n    },\n};\n\nexport { animations };\n","import { isAnimationControls } from '../../../animation/utils/is-animation-controls.mjs';\nimport { createAnimationState } from '../../../render/utils/animation-state.mjs';\nimport { Feature } from '../Feature.mjs';\n\nclass AnimationFeature extends Feature {\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    constructor(node) {\n        super(node);\n        node.animationState || (node.animationState = createAnimationState(node));\n    }\n    updateAnimationControlsSubscription() {\n        const { animate } = this.node.getProps();\n        if (isAnimationControls(animate)) {\n            this.unmountControls = animate.subscribe(this.node);\n        }\n    }\n    /**\n     * Subscribe any provided AnimationControls to the component's VisualElement\n     */\n    mount() {\n        this.updateAnimationControlsSubscription();\n    }\n    update() {\n        const { animate } = this.node.getProps();\n        const { animate: prevAnimate } = this.node.prevProps || {};\n        if (animate !== prevAnimate) {\n            this.updateAnimationControlsSubscription();\n        }\n    }\n    unmount() {\n        var _a;\n        this.node.animationState.reset();\n        (_a = this.unmountControls) === null || _a === void 0 ? void 0 : _a.call(this);\n    }\n}\n\nexport { AnimationFeature };\n","const distance = (a, b) => Math.abs(a - b);\nfunction distance2D(a, b) {\n    // Multi-dimensional\n    const xDelta = distance(a.x, b.x);\n    const yDelta = distance(a.y, b.y);\n    return Math.sqrt(xDelta ** 2 + yDelta ** 2);\n}\n\nexport { distance, distance2D };\n","import { extractEventInfo } from '../../events/event-info.mjs';\nimport { secondsToMilliseconds, millisecondsToSeconds } from '../../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { distance2D } from '../../utils/distance.mjs';\nimport { isPrimaryPointer } from '../../events/utils/is-primary-pointer.mjs';\nimport { frame, cancelFrame, frameData } from '../../frameloop/frame.mjs';\n\n/**\n * @internal\n */\nclass PanSession {\n    constructor(event, handlers, { transformPagePoint, contextWindow, dragSnapToOrigin = false } = {}) {\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        /**\n         * @internal\n         */\n        this.contextWindow = window;\n        this.updatePoint = () => {\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const info = getPanInfo(this.lastMoveEventInfo, this.history);\n            const 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            const isDistancePastThreshold = distance2D(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            const { point } = info;\n            const { timestamp } = frameData;\n            this.history.push({ ...point, timestamp });\n            const { onStart, onMove } = this.handlers;\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 = (event, info) => {\n            this.lastMoveEvent = event;\n            this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);\n            // Throttle mouse move event to once per frame\n            frame.update(this.updatePoint, true);\n        };\n        this.handlePointerUp = (event, info) => {\n            this.end();\n            const { onEnd, onSessionEnd, resumeAnimation } = this.handlers;\n            if (this.dragSnapToOrigin)\n                resumeAnimation && resumeAnimation();\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const panInfo = getPanInfo(event.type === \"pointercancel\"\n                ? this.lastMoveEventInfo\n                : 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 (!isPrimaryPointer(event))\n            return;\n        this.dragSnapToOrigin = dragSnapToOrigin;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        this.contextWindow = contextWindow || window;\n        const info = extractEventInfo(event);\n        const initialInfo = transformPoint(info, this.transformPagePoint);\n        const { point } = initialInfo;\n        const { timestamp } = frameData;\n        this.history = [{ ...point, timestamp }];\n        const { onSessionStart } = handlers;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(this.contextWindow, \"pointermove\", this.handlePointerMove), addPointerEvent(this.contextWindow, \"pointerup\", this.handlePointerUp), addPointerEvent(this.contextWindow, \"pointercancel\", this.handlePointerUp));\n    }\n    updateHandlers(handlers) {\n        this.handlers = handlers;\n    }\n    end() {\n        this.removeListeners && this.removeListeners();\n        cancelFrame(this.updatePoint);\n    }\n}\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo({ point }, history) {\n    return {\n        point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    let i = history.length - 1;\n    let timestampedPoint = null;\n    const lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    const time = millisecondsToSeconds(lastPoint.timestamp - timestampedPoint.timestamp);\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    const currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nexport { PanSession };\n","import { mixNumber } from '../../utils/mix/number.mjs';\n\nconst SCALE_PRECISION = 0.0001;\nconst SCALE_MIN = 1 - SCALE_PRECISION;\nconst SCALE_MAX = 1 + SCALE_PRECISION;\nconst TRANSLATE_PRECISION = 0.01;\nconst TRANSLATE_MIN = 0 - TRANSLATE_PRECISION;\nconst TRANSLATE_MAX = 0 + TRANSLATE_PRECISION;\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    return Math.abs(value - target) <= maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin = 0.5) {\n    delta.origin = origin;\n    delta.originPoint = mixNumber(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    delta.translate =\n        mixNumber(target.min, target.max, delta.origin) - delta.originPoint;\n    if ((delta.scale >= SCALE_MIN && delta.scale <= SCALE_MAX) ||\n        isNaN(delta.scale)) {\n        delta.scale = 1.0;\n    }\n    if ((delta.translate >= TRANSLATE_MIN &&\n        delta.translate <= TRANSLATE_MAX) ||\n        isNaN(delta.translate)) {\n        delta.translate = 0.0;\n    }\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin ? origin.originX : undefined);\n    calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : undefined);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","import { progress } from '../../../utils/progress.mjs';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { mixNumber } from '../../../utils/mix/number.mjs';\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, { min, max }, elastic) {\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic\n            ? mixNumber(min, point, elastic.min)\n            : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic\n            ? mixNumber(max, point, elastic.max)\n            : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, { top, left, bottom, 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    let min = constraintsAxis.min - layoutAxis.min;\n    let max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        [min, max] = [max, min];\n    }\n    return { min, max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    let origin = 0.5;\n    const sourceLength = calcLength(source);\n    const targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    const 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}\nconst defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic = defaultElastic) {\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : dragElastic[label] || 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","const createAxisDelta = () => ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n});\nconst createDelta = () => ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n});\nconst createAxis = () => ({ min: 0, max: 0 });\nconst createBox = () => ({\n    x: createAxis(),\n    y: createAxis(),\n});\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox({ top, left, right, bottom, }) {\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox({ x, y }) {\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    const topLeft = transformPoint({ x: point.left, y: point.top });\n    const bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale({ scale, scaleX, scaleY }) {\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        has2DTranslate(values) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY ||\n        values.skewX ||\n        values.skewY);\n}\nfunction has2DTranslate(values) {\n    return is2DTranslate(values.x) || is2DTranslate(values.y);\n}\nfunction is2DTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { has2DTranslate, hasScale, hasTransform };\n","import { mixNumber } from '../../utils/mix/number.mjs';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    const distanceFromOrigin = point - originPoint;\n    const scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {\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, { x, y }) {\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\nconst TREE_SCALE_SNAP_MIN = 0.999999999999;\nconst TREE_SCALE_SNAP_MAX = 1.0000000000001;\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {\n    const treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    let node;\n    let delta;\n    for (let i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        /**\n         * TODO: Prefer to remove this, but currently we have motion components with\n         * display: contents in Framer.\n         */\n        const { visualElement } = node.options;\n        if (visualElement &&\n            visualElement.props.style &&\n            visualElement.props.style.display === \"contents\") {\n            continue;\n        }\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, {\n                x: -node.scroll.offset.x,\n                y: -node.scroll.offset.y,\n            });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n    /**\n     * Snap tree scale back to 1 if it's within a non-perceivable threshold.\n     * This will help reduce useless scales getting rendered.\n     */\n    if (treeScale.x < TREE_SCALE_SNAP_MAX &&\n        treeScale.x > TREE_SCALE_SNAP_MIN) {\n        treeScale.x = 1.0;\n    }\n    if (treeScale.y < TREE_SCALE_SNAP_MAX &&\n        treeScale.y > TREE_SCALE_SNAP_MIN) {\n        treeScale.y = 1.0;\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, axisTranslate, axisScale, boxScale, axisOrigin = 0.5) {\n    const originPoint = mixNumber(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, axisTranslate, axisScale, originPoint, boxScale);\n}\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform.x, transform.scaleX, transform.scale, transform.originX);\n    transformAxis(box.y, transform.y, transform.scaleY, transform.scale, transform.originY);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    const viewportBox = measureViewportBox(element, transformPagePoint);\n    const { scroll } = rootProjectionNode;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.offset.x);\n        translateAxis(viewportBox.y, scroll.offset.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","// Fixes https://github.com/framer/motion/issues/2270\nconst getContextWindow = ({ current }) => {\n    return current ? current.ownerDocument.defaultView : null;\n};\n\nexport { getContextWindow };\n","import { invariant } from '../../utils/errors.mjs';\nimport { PanSession } from '../pan/PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/add-dom-event.mjs';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\nimport { mixNumber } from '../../utils/mix/number.mjs';\nimport { percent } from '../../value/types/numbers/units.mjs';\nimport { animateMotionValue } from '../../animation/interfaces/motion-value.mjs';\nimport { getContextWindow } from '../../utils/get-context-window.mjs';\nimport { addValueToWillChange } from '../../value/use-will-change/add-will-change.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: PointerEvent\nclass VisualElementDragControls {\n    constructor(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    start(originEvent, { snapToCursor = false } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        const { presenceContext } = this.visualElement;\n        if (presenceContext && presenceContext.isPresent === false)\n            return;\n        const onSessionStart = (event) => {\n            const { dragSnapToOrigin } = this.getProps();\n            // Stop or pause any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            dragSnapToOrigin ? this.pauseAnimation() : this.stopAnimation();\n            if (snapToCursor) {\n                this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        const onStart = (event, info) => {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\n            if (drag && !dragPropagation) {\n                if (this.openGlobalLock)\n                    this.openGlobalLock();\n                this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!this.openGlobalLock)\n                    return;\n            }\n            this.isDragging = true;\n            this.currentDirection = null;\n            this.resolveConstraints();\n            if (this.visualElement.projection) {\n                this.visualElement.projection.isAnimationBlocked = true;\n                this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis((axis) => {\n                let current = this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    const { projection } = this.visualElement;\n                    if (projection && projection.layout) {\n                        const measuredAxis = projection.layout.layoutBox[axis];\n                        if (measuredAxis) {\n                            const length = calcLength(measuredAxis);\n                            current = length * (parseFloat(current) / 100);\n                        }\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            if (onDragStart) {\n                frame.postRender(() => onDragStart(event, info));\n            }\n            (_a = this.removeWillChange) === null || _a === void 0 ? void 0 : _a.call(this);\n            this.removeWillChange = addValueToWillChange(this.visualElement, \"transform\");\n            const { animationState } = this.visualElement;\n            animationState && animationState.setActive(\"whileDrag\", true);\n        };\n        const onMove = (event, info) => {\n            // latestPointerEvent = event\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openGlobalLock)\n                return;\n            const { offset } = info;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && this.currentDirection === null) {\n                this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (this.currentDirection !== null) {\n                    onDirectionLock && onDirectionLock(this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            this.updateAxis(\"x\", info.point, offset);\n            this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            this.visualElement.render();\n            /**\n             * This must fire after the render call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag && onDrag(event, info);\n        };\n        const onSessionEnd = (event, info) => this.stop(event, info);\n        const resumeAnimation = () => eachAxis((axis) => {\n            var _a;\n            return this.getAnimationState(axis) === \"paused\" &&\n                ((_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.play());\n        });\n        const { dragSnapToOrigin } = this.getProps();\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n            resumeAnimation,\n        }, {\n            transformPagePoint: this.visualElement.getTransformPagePoint(),\n            dragSnapToOrigin,\n            contextWindow: getContextWindow(this.visualElement),\n        });\n    }\n    stop(event, info) {\n        var _a;\n        (_a = this.removeWillChange) === null || _a === void 0 ? void 0 : _a.call(this);\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        const { velocity } = info;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        if (onDragEnd) {\n            frame.postRender(() => onDragEnd(event, info));\n        }\n    }\n    cancel() {\n        this.isDragging = false;\n        const { projection, animationState } = this.visualElement;\n        if (projection) {\n            projection.isAnimationBlocked = false;\n        }\n        this.panSession && this.panSession.end();\n        this.panSession = undefined;\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        animationState && animationState.setActive(\"whileDrag\", false);\n    }\n    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    }\n    resolveConstraints() {\n        var _a;\n        const { dragConstraints, dragElastic } = this.getProps();\n        const layout = this.visualElement.projection &&\n            !this.visualElement.projection.layout\n            ? this.visualElement.projection.measure(false)\n            : (_a = this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout;\n        const prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.layoutBox, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis((axis) => {\n                if (this.constraints !== false &&\n                    this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        const 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        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, 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            const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (constraints && constraints[axis]) || {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            const bounceStiffness = dragElastic ? 200 : 1000000;\n            const bounceDamping = dragElastic ? 40 : 10000000;\n            const inertia = {\n                type: \"inertia\",\n                velocity: dragMomentum ? velocity[axis] : 0,\n                bounceStiffness,\n                bounceDamping,\n                timeConstant: 750,\n                restDelta: 1,\n                restSpeed: 10,\n                ...dragTransition,\n                ...transition,\n            };\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    }\n    startAxisValueAnimation(axis, transition) {\n        const axisValue = this.getAxisMotionValue(axis);\n        return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement, false, addValueToWillChange(this.visualElement, axis)));\n    }\n    stopAnimation() {\n        eachAxis((axis) => this.getAxisMotionValue(axis).stop());\n    }\n    pauseAnimation() {\n        eachAxis((axis) => { var _a; return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.pause(); });\n    }\n    getAnimationState(axis) {\n        var _a;\n        return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.state;\n    }\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    getAxisMotionValue(axis) {\n        const dragKey = `_drag${axis.toUpperCase()}`;\n        const props = this.visualElement.getProps();\n        const externalMotionValue = props[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (props.initial\n                ? props.initial[axis]\n                : undefined) || 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\n                axisValue.set(point[axis] - mixNumber(min, max, 0.5));\n            }\n        });\n    }\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    scalePositionWithinConstraints() {\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue && this.constraints !== false) {\n                const latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        projection.root && projection.root.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(mixNumber(min, max, boxProgress[axis]));\n        });\n    }\n    addListeners() {\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            drag && dragListener && this.start(event);\n        });\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (isRefObject(dragConstraints) && dragConstraints.current) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        };\n        const { projection } = this.visualElement;\n        const stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            projection.root && projection.root.updateScroll();\n            projection.updateLayout();\n        }\n        frame.read(measureDragConstraints);\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const motionValue = this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                this.visualElement.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener && stopLayoutUpdateListener();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\n}\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold = 10) {\n    let direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n","import { PanSession } from './PanSession.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { getContextWindow } from '../../utils/get-context-window.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst asyncHandler = (handler) => (event, info) => {\n    if (handler) {\n        frame.postRender(() => handler(event, info));\n    }\n};\nclass PanGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removePointerDownListener = noop;\n    }\n    onPointerDown(pointerDownEvent) {\n        this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), {\n            transformPagePoint: this.node.getTransformPagePoint(),\n            contextWindow: getContextWindow(this.node),\n        });\n    }\n    createPanHandlers() {\n        const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();\n        return {\n            onSessionStart: asyncHandler(onPanSessionStart),\n            onStart: asyncHandler(onPanStart),\n            onMove: onPan,\n            onEnd: (event, info) => {\n                delete this.session;\n                if (onPanEnd) {\n                    frame.postRender(() => onPanEnd(event, info));\n                }\n            },\n        };\n    }\n    mount() {\n        this.removePointerDownListener = addPointerEvent(this.node.current, \"pointerdown\", (event) => this.onPointerDown(event));\n    }\n    update() {\n        this.session && this.session.updateHandlers(this.createPanHandlers());\n    }\n    unmount() {\n        this.removePointerDownListener();\n        this.session && this.session.end();\n    }\n}\n\nexport { PanGesture };\n","/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nconst globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nexport { globalProjectionState };\n","import { px } from '../../value/types/numbers/units.mjs';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nconst correctBorderRadius = {\n    correct: (latest, node) => {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        const x = pixelsToPercent(latest, node.target.x);\n        const y = pixelsToPercent(latest, node.target.y);\n        return `${x}% ${y}%`;\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\n","import { mixNumber } from '../../utils/mix/number.mjs';\nimport { complex } from '../../value/types/complex/index.mjs';\n\nconst correctBoxShadow = {\n    correct: (latest, { treeScale, projectionDelta }) => {\n        const original = latest;\n        const shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        const template = complex.createTransformer(latest);\n        const offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        const xScale = projectionDelta.x.scale * treeScale.x;\n        const yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        const averageScale = mixNumber(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        return template(shadow);\n    },\n};\n\nexport { correctBoxShadow };\n","import { jsx } from 'react/jsx-runtime';\nimport { useContext, Component } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\nimport { microtask } from '../../../frameloop/microtask.mjs';\nimport { frame } from '../../../frameloop/frame.mjs';\n\nclass MeasureLayoutWithContext extends Component {\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    componentDidMount() {\n        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;\n        const { projection } = visualElement;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", () => {\n                this.safeToRemove();\n            });\n            projection.setOptions({\n                ...projection.options,\n                onExitComplete: () => this.safeToRemove(),\n            });\n        }\n        globalProjectionState.hasEverUpdated = true;\n    }\n    getSnapshotBeforeUpdate(prevProps) {\n        const { layoutDependency, visualElement, drag, isPresent } = this.props;\n        const projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                frame.postRender(() => {\n                    const stack = projection.getStack();\n                    if (!stack || !stack.members.length) {\n                        this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    }\n    componentDidUpdate() {\n        const { projection } = this.props.visualElement;\n        if (projection) {\n            projection.root.didUpdate();\n            microtask.postRender(() => {\n                if (!projection.currentAnimation && projection.isLead()) {\n                    this.safeToRemove();\n                }\n            });\n        }\n    }\n    componentWillUnmount() {\n        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;\n        const { projection } = visualElement;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup && layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext && promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    }\n    safeToRemove() {\n        const { safeToRemove } = this.props;\n        safeToRemove && safeToRemove();\n    }\n    render() {\n        return null;\n    }\n}\nfunction MeasureLayout(props) {\n    const [isPresent, safeToRemove] = usePresence();\n    const layoutGroup = useContext(LayoutGroupContext);\n    return (jsx(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));\n}\nconst defaultScaleCorrectors = {\n    borderRadius: {\n        ...correctBorderRadius,\n        applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ],\n    },\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { useContext, useId, useEffect, useCallback } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    const context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    const { isPresent, onExitComplete, register } = context;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    const id = useId();\n    useEffect(() => register(id), []);\n    const safeToRemove = useCallback(() => onExitComplete && onExitComplete(id), [id, onExitComplete]);\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","import { circOut } from '../../easing/circ.mjs';\nimport { progress } from '../../utils/progress.mjs';\nimport { mixNumber } from '../../utils/mix/number.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { percent, px } from '../../value/types/numbers/units.mjs';\n\nconst borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nconst numBorders = borders.length;\nconst asNumber = (value) => typeof value === \"string\" ? parseFloat(value) : value;\nconst isPx = (value) => typeof value === \"number\" || px.test(value);\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mixNumber(0, \n        // TODO Reinstate this if only child\n        lead.opacity !== undefined ? lead.opacity : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mixNumber(follow.opacity !== undefined ? follow.opacity : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mixNumber(follow.opacity !== undefined ? follow.opacity : 1, lead.opacity !== undefined ? lead.opacity : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (let i = 0; i < numBorders; i++) {\n        const borderLabel = `border${borders[i]}Radius`;\n        let followRadius = getRadius(follow, borderLabel);\n        let leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        const canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(mixNumber(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (percent.test(leadRadius) || percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = mixNumber(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    return values[radiusName] !== undefined\n        ? values[radiusName]\n        : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nconst easeCrossfadeIn = compress(0, 0.5, circOut);\nconst easeCrossfadeOut = compress(0.5, 0.95, noop);\nfunction compress(min, max, easing) {\n    return (p) => {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(progress(min, max, p));\n    };\n}\n\nexport { mixValues };\n","/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n/**\n * Reset a delta to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisDeltaInto(delta, originDelta) {\n    delta.translate = originDelta.translate;\n    delta.scale = originDelta.scale;\n    delta.originPoint = originDelta.originPoint;\n    delta.origin = originDelta.origin;\n}\n\nexport { copyAxisDeltaInto, copyAxisInto, copyBoxInto };\n","import { mixNumber } from '../../utils/mix/number.mjs';\nimport { percent } from '../../value/types/numbers/units.mjs';\nimport { scalePoint } from './delta-apply.mjs';\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        const relativeProgress = mixNumber(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    let originPoint = mixNumber(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox ? originBox.x : undefined, sourceBox ? sourceBox.x : undefined);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : undefined, sourceBox ? sourceBox.y : undefined);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","import { calcLength } from './delta-calc.mjs';\n\nfunction isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction axisEquals(a, b) {\n    return a.min === b.min && a.max === b.max;\n}\nfunction boxEquals(a, b) {\n    return axisEquals(a.x, b.x) && axisEquals(a.y, b.y);\n}\nfunction axisEqualsRounded(a, b) {\n    return (Math.round(a.min) === Math.round(b.min) &&\n        Math.round(a.max) === Math.round(b.max));\n}\nfunction boxEqualsRounded(a, b) {\n    return axisEqualsRounded(a.x, b.x) && axisEqualsRounded(a.y, b.y);\n}\nfunction aspectRatio(box) {\n    return calcLength(box.x) / calcLength(box.y);\n}\nfunction axisDeltaEquals(a, b) {\n    return (a.translate === b.translate &&\n        a.scale === b.scale &&\n        a.originPoint === b.originPoint);\n}\n\nexport { aspectRatio, axisDeltaEquals, axisEquals, axisEqualsRounded, boxEquals, boxEqualsRounded, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nclass NodeStack {\n    constructor() {\n        this.members = [];\n    }\n    add(node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    }\n    remove(node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            const prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    }\n    relegate(node) {\n        const indexOfNode = this.members.findIndex((member) => node === member);\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        let prevLead;\n        for (let i = indexOfNode; i >= 0; i--) {\n            const member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    promote(node, preserveFollowOpacity) {\n        const prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n            }\n            if (node.root && node.root.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            const { crossfade } = node.options;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    }\n    exitAnimationComplete() {\n        this.members.forEach((node) => {\n            const { options, resumingFrom } = node;\n            options.onExitComplete && options.onExitComplete();\n            if (resumingFrom) {\n                resumingFrom.options.onExitComplete &&\n                    resumingFrom.options.onExitComplete();\n            }\n        });\n    }\n    scheduleRender() {\n        this.members.forEach((node) => {\n            node.instance && node.scheduleRender(false);\n        });\n    }\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    removeLeadSnapshot() {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    }\n}\n\nexport { NodeStack };\n","const compareByDepth = (a, b) => a.depth - b.depth;\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nclass FlatTree {\n    constructor() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    add(child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    }\n    remove(child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    }\n    forEach(callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    }\n}\n\nexport { FlatTree };\n","import { SubscriptionManager } from '../../utils/subscription-manager.mjs';\nimport { mixValues } from '../animation/mix-values.mjs';\nimport { copyBoxInto, copyAxisDeltaInto } from '../geometry/copy.mjs';\nimport { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from '../geometry/delta-apply.mjs';\nimport { calcRelativePosition, calcRelativeBox, calcBoxDelta, calcLength, isNear } from '../geometry/delta-calc.mjs';\nimport { removeBoxTransforms } from '../geometry/delta-remove.mjs';\nimport { getValueTransition } from '../../animation/utils/transitions.mjs';\nimport { boxEqualsRounded, isDeltaZero, axisDeltaEquals, aspectRatio, boxEquals } from '../geometry/utils.mjs';\nimport { NodeStack } from '../shared/stack.mjs';\nimport { scaleCorrectors } from '../styles/scale-correction.mjs';\nimport { buildProjectionTransform } from '../styles/transform.mjs';\nimport { eachAxis } from '../utils/each-axis.mjs';\nimport { hasTransform, hasScale, has2DTranslate } from '../utils/has-transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { globalProjectionState } from './state.mjs';\nimport { delay } from '../../utils/delay.mjs';\nimport { mixNumber } from '../../utils/mix/number.mjs';\nimport { isSVGElement } from '../../render/dom/utils/is-svg-element.mjs';\nimport { animateSingleValue } from '../../animation/interfaces/single-value.mjs';\nimport { clamp } from '../../utils/clamp.mjs';\nimport { cancelFrame, frameData, steps, frame } from '../../frameloop/frame.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { time } from '../../frameloop/sync-time.mjs';\nimport { microtask } from '../../frameloop/microtask.mjs';\nimport { getOptimisedAppearId } from '../../animation/optimized-appear/get-appear-id.mjs';\nimport { createBox, createDelta } from '../geometry/models.mjs';\n\nconst metrics = {\n    type: \"projectionFrame\",\n    totalNodes: 0,\n    resolvedTargetDeltas: 0,\n    recalculatedProjection: 0,\n};\nconst isDebug = typeof window !== \"undefined\" && window.MotionDebug !== undefined;\nconst transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\nconst hiddenVisibility = { visibility: \"hidden\" };\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nconst animationTarget = 1000;\nlet id = 0;\nfunction resetDistortingTransform(key, visualElement, values, sharedAnimationValues) {\n    const { latestValues } = visualElement;\n    // Record the distorting transform and then temporarily set it to 0\n    if (latestValues[key]) {\n        values[key] = latestValues[key];\n        visualElement.setStaticValue(key, 0);\n        if (sharedAnimationValues) {\n            sharedAnimationValues[key] = 0;\n        }\n    }\n}\nfunction cancelTreeOptimisedTransformAnimations(projectionNode) {\n    projectionNode.hasCheckedOptimisedAppear = true;\n    if (projectionNode.root === projectionNode)\n        return;\n    const { visualElement } = projectionNode.options;\n    if (!visualElement)\n        return;\n    const appearId = getOptimisedAppearId(visualElement);\n    if (window.MotionHasOptimisedTransformAnimation(appearId)) {\n        window.MotionCancelOptimisedTransform(appearId);\n    }\n    const { parent } = projectionNode;\n    if (parent && !parent.hasCheckedOptimisedAppear) {\n        cancelTreeOptimisedTransformAnimations(parent);\n    }\n}\nfunction createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform, }) {\n    return class ProjectionNode {\n        constructor(latestValues = {}, parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent()) {\n            /**\n             * A unique ID generated for every projection node.\n             */\n            this.id = id++;\n            /**\n             * An id that represents a unique session instigated by startUpdate.\n             */\n            this.animationId = 0;\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Flag to true if we think the projection calculations for this node needs\n             * recalculating as a result of an updated transform or layout animation.\n             */\n            this.isProjectionDirty = false;\n            /**\n             * Flag to true if the layout *or* transform has changed. This then gets propagated\n             * throughout the projection tree, forcing any element below to recalculate on the next frame.\n             */\n            this.isSharedProjectionDirty = false;\n            /**\n             * Flag transform dirty. This gets propagated throughout the whole tree but is only\n             * respected by shared nodes.\n             */\n            this.isTransformDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * Store whether this node has been checked for optimised appear animations. As\n             * effects fire bottom-up, and we want to look up the tree for appear animations,\n             * this makes sure we only check each path once, stopping at nodes that\n             * have already been checked.\n             */\n            this.hasCheckedOptimisedAppear = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to layoutly\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            this.hasTreeAnimated = false;\n            // Note: Currently only running on root node\n            this.updateScheduled = false;\n            this.scheduleUpdate = () => this.update();\n            this.projectionUpdateScheduled = false;\n            this.checkUpdateFailed = () => {\n                if (this.isUpdating) {\n                    this.isUpdating = false;\n                    this.clearAllSnapshots();\n                }\n            };\n            /**\n             * This is a multi-step process as shared nodes might be of different depths. Nodes\n             * are sorted by depth order, so we need to resolve the entire tree before moving to\n             * the next step.\n             */\n            this.updateProjection = () => {\n                this.projectionUpdateScheduled = false;\n                /**\n                 * Reset debug counts. Manually resetting rather than creating a new\n                 * object each frame.\n                 */\n                if (isDebug) {\n                    metrics.totalNodes =\n                        metrics.resolvedTargetDeltas =\n                            metrics.recalculatedProjection =\n                                0;\n                }\n                this.nodes.forEach(propagateDirtyNodes);\n                this.nodes.forEach(resolveTargetDelta);\n                this.nodes.forEach(calcProjection);\n                this.nodes.forEach(cleanDirtyNodes);\n                if (isDebug) {\n                    window.MotionDebug.record(metrics);\n                }\n            };\n            /**\n             * Frame calculations\n             */\n            this.resolvedRelativeTargetAt = 0.0;\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? [...parent.path, parent] : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            for (let i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        addEventListener(name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        }\n        notifyListeners(name, ...args) {\n            const subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager && subscriptionManager.notify(...args);\n        }\n        hasListeners(name) {\n            return this.eventHandlers.has(name);\n        }\n        /**\n         * Lifecycles\n         */\n        mount(instance, isLayoutDirty = this.root.hasTreeAnimated) {\n            if (this.instance)\n                return;\n            this.isSVG = isSVGElement(instance);\n            this.instance = instance;\n            const { layoutId, layout, visualElement } = this.options;\n            if (visualElement && !visualElement.current) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            this.parent && this.parent.children.add(this);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                let cancelDelay;\n                const resizeUnblockUpdate = () => (this.root.updateBlockedByResize = false);\n                attachResizeListener(instance, () => {\n                    this.root.updateBlockedByResize = true;\n                    cancelDelay && cancelDelay();\n                    cancelDelay = delay(resizeUnblockUpdate, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", ({ delta, hasLayoutChanged, hasRelativeTargetChanged, layout: newLayout, }) => {\n                    if (this.isTreeAnimationBlocked()) {\n                        this.target = undefined;\n                        this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    const layoutTransition = this.options.transition ||\n                        visualElement.getDefaultTransition() ||\n                        defaultLayoutTransition;\n                    const { onLayoutAnimationStart, onLayoutAnimationComplete, } = visualElement.getProps();\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    const targetChanged = !this.targetLayout ||\n                        !boxEqualsRounded(this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (this.options.layoutRoot ||\n                        (this.resumeFrom && this.resumeFrom.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !this.currentAnimation))) {\n                        if (this.resumeFrom) {\n                            this.resumingFrom = this.resumeFrom;\n                            this.resumingFrom.resumingFrom = undefined;\n                        }\n                        this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        const animationOptions = {\n                            ...getValueTransition(layoutTransition, \"layout\"),\n                            onPlay: onLayoutAnimationStart,\n                            onComplete: onLayoutAnimationComplete,\n                        };\n                        if (visualElement.shouldReduceMotion ||\n                            this.options.layoutRoot) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged) {\n                            finishAnimation(this);\n                        }\n                        if (this.isLead() && this.options.onExitComplete) {\n                            this.options.onExitComplete();\n                        }\n                    }\n                    this.targetLayout = newLayout;\n                });\n            }\n        }\n        unmount() {\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            const stack = this.getStack();\n            stack && stack.remove(this);\n            this.parent && this.parent.children.delete(this);\n            this.instance = undefined;\n            cancelFrame(this.updateProjection);\n        }\n        // only on the root\n        blockUpdate() {\n            this.updateManuallyBlocked = true;\n        }\n        unblockUpdate() {\n            this.updateManuallyBlocked = false;\n        }\n        isUpdateBlocked() {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        }\n        isTreeAnimationBlocked() {\n            return (this.isAnimationBlocked ||\n                (this.parent && this.parent.isTreeAnimationBlocked()) ||\n                false);\n        }\n        // Note: currently only running on root node\n        startUpdate() {\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            this.nodes && this.nodes.forEach(resetSkewAndRotation);\n            this.animationId++;\n        }\n        getTransformTemplate() {\n            const { visualElement } = this.options;\n            return visualElement && visualElement.getProps().transformTemplate;\n        }\n        willUpdate(shouldNotifyListeners = true) {\n            this.root.hasTreeAnimated = true;\n            if (this.root.isUpdateBlocked()) {\n                this.options.onExitComplete && this.options.onExitComplete();\n                return;\n            }\n            /**\n             * If we're running optimised appear animations then these must be\n             * cancelled before measuring the DOM. This is so we can measure\n             * the true layout of the element rather than the WAAPI animation\n             * which will be unaffected by the resetSkewAndRotate step.\n             *\n             * Note: This is a DOM write. Worst case scenario is this is sandwiched\n             * between other snapshot reads which will cause unnecessary style recalculations.\n             * This has to happen here though, as we don't yet know which nodes will need\n             * snapshots in startUpdate(), but we only want to cancel optimised animations\n             * if a layout animation measurement is actually going to be affected by them.\n             */\n            if (window.MotionCancelOptimisedTransform &&\n                !this.hasCheckedOptimisedAppear) {\n                cancelTreeOptimisedTransformAnimations(this);\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                node.shouldResetTransform = true;\n                node.updateScroll(\"snapshot\");\n                if (node.options.layoutRoot) {\n                    node.willUpdate(false);\n                }\n            }\n            const { layoutId, layout } = this.options;\n            if (layoutId === undefined && !layout)\n                return;\n            const transformTemplate = this.getTransformTemplate();\n            this.prevTransformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        }\n        update() {\n            this.updateScheduled = false;\n            const updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating) {\n                this.nodes.forEach(clearIsLayoutDirty);\n            }\n            this.isUpdating = false;\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            /**\n             * Manually flush any pending updates. Ideally\n             * we could leave this to the following requestAnimationFrame but this seems\n             * to leave a flash of incorrectly styled content.\n             */\n            const now = time.now();\n            frameData.delta = clamp(0, 1000 / 60, now - frameData.timestamp);\n            frameData.timestamp = now;\n            frameData.isProcessing = true;\n            steps.update.process(frameData);\n            steps.preRender.process(frameData);\n            steps.render.process(frameData);\n            frameData.isProcessing = false;\n        }\n        didUpdate() {\n            if (!this.updateScheduled) {\n                this.updateScheduled = true;\n                microtask.read(this.scheduleUpdate);\n            }\n        }\n        clearAllSnapshots() {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        }\n        scheduleUpdateProjection() {\n            if (!this.projectionUpdateScheduled) {\n                this.projectionUpdateScheduled = true;\n                frame.preRender(this.updateProjection, false, true);\n            }\n        }\n        scheduleCheckAfterUnmount() {\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            frame.postRender(() => {\n                if (this.isLayoutDirty) {\n                    this.root.didUpdate();\n                }\n                else {\n                    this.root.checkUpdateFailed();\n                }\n            });\n        }\n        /**\n         * Update measurements\n         */\n        updateSnapshot() {\n            if (this.snapshot || !this.instance)\n                return;\n            this.snapshot = this.measure();\n        }\n        updateLayout() {\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (let i = 0; i < this.path.length; i++) {\n                    const node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            const prevLayout = this.layout;\n            this.layout = this.measure(false);\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.layoutBox);\n            const { visualElement } = this.options;\n            visualElement &&\n                visualElement.notify(\"LayoutMeasure\", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : undefined);\n        }\n        updateScroll(phase = \"measure\") {\n            let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);\n            if (this.scroll &&\n                this.scroll.animationId === this.root.animationId &&\n                this.scroll.phase === phase) {\n                needsMeasurement = false;\n            }\n            if (needsMeasurement) {\n                const isRoot = checkIsScrollRoot(this.instance);\n                this.scroll = {\n                    animationId: this.root.animationId,\n                    phase,\n                    isRoot,\n                    offset: measureScroll(this.instance),\n                    wasRoot: this.scroll ? this.scroll.isRoot : isRoot,\n                };\n            }\n        }\n        resetTransform() {\n            if (!resetTransform)\n                return;\n            const isResetRequested = this.isLayoutDirty ||\n                this.shouldResetTransform ||\n                this.options.alwaysMeasureLayout;\n            const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            const transformTemplate = this.getTransformTemplate();\n            const transformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\n            const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        }\n        measure(removeTransform = true) {\n            const pageBox = this.measurePageBox();\n            let layoutBox = this.removeElementScroll(pageBox);\n            /**\n             * Measurements taken during the pre-render stage\n             * still have transforms applied so we remove them\n             * via calculation.\n             */\n            if (removeTransform) {\n                layoutBox = this.removeTransform(layoutBox);\n            }\n            roundBox(layoutBox);\n            return {\n                animationId: this.root.animationId,\n                measuredBox: pageBox,\n                layoutBox,\n                latestValues: {},\n                source: this.id,\n            };\n        }\n        measurePageBox() {\n            var _a;\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return createBox();\n            const box = visualElement.measureViewportBox();\n            const wasInScrollRoot = ((_a = this.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot) || this.path.some(checkNodeWasScrollRoot);\n            if (!wasInScrollRoot) {\n                // Remove viewport scroll to give page-relative coordinates\n                const { scroll } = this.root;\n                if (scroll) {\n                    translateAxis(box.x, scroll.offset.x);\n                    translateAxis(box.y, scroll.offset.y);\n                }\n            }\n            return box;\n        }\n        removeElementScroll(box) {\n            var _a;\n            const boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            if ((_a = this.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot) {\n                return boxWithoutScroll;\n            }\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                const { scroll, options } = node;\n                if (node !== this.root && scroll && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (scroll.wasRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll.offset.x);\n                    translateAxis(boxWithoutScroll.y, scroll.offset.y);\n                }\n            }\n            return boxWithoutScroll;\n        }\n        applyTransform(box, transformOnly = false) {\n            const withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.offset.x,\n                        y: -node.scroll.offset.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        }\n        removeTransform(box) {\n            const boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                const sourceBox = createBox();\n                const nodeBox = node.measurePageBox();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, node.snapshot ? node.snapshot.layoutBox : undefined, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        }\n        setTargetDelta(delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n            this.isProjectionDirty = true;\n        }\n        setOptions(options) {\n            this.options = {\n                ...this.options,\n                ...options,\n                crossfade: options.crossfade !== undefined ? options.crossfade : true,\n            };\n        }\n        clearMeasurements() {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        }\n        forceRelativeParentToResolveTarget() {\n            if (!this.relativeParent)\n                return;\n            /**\n             * If the parent target isn't up-to-date, force it to update.\n             * This is an unfortunate de-optimisation as it means any updating relative\n             * projection will cause all the relative parents to recalculate back\n             * up the tree.\n             */\n            if (this.relativeParent.resolvedRelativeTargetAt !==\n                frameData.timestamp) {\n                this.relativeParent.resolveTargetDelta(true);\n            }\n        }\n        resolveTargetDelta(forceRecalculation = false) {\n            var _a;\n            /**\n             * Once the dirty status of nodes has been spread through the tree, we also\n             * need to check if we have a shared node of a different depth that has itself\n             * been dirtied.\n             */\n            const lead = this.getLead();\n            this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);\n            this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);\n            this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            /**\n             * We don't use transform for this step of processing so we don't\n             * need to check whether any nodes have changed transform.\n             */\n            const canSkip = !(forceRecalculation ||\n                (isShared && this.isSharedProjectionDirty) ||\n                this.isProjectionDirty ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty) ||\n                this.attemptToResolveRelativeTarget ||\n                this.root.updateBlockedByResize);\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            this.resolvedRelativeTargetAt = frameData.timestamp;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            if (!this.targetDelta && !this.relativeTarget) {\n                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent &&\n                    relativeParent.layout &&\n                    this.animationProgress !== 1) {\n                    this.relativeParent = relativeParent;\n                    this.forceRelativeParentToResolveTarget();\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.layoutBox, relativeParent.layout.layoutBox);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                this.relativeParent &&\n                this.relativeParent.target) {\n                this.forceRelativeParentToResolveTarget();\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.layoutBox);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.layoutBox);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.layoutBox);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent &&\n                    Boolean(relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !relativeParent.options.layoutScroll &&\n                    relativeParent.target &&\n                    this.animationProgress !== 1) {\n                    this.relativeParent = relativeParent;\n                    this.forceRelativeParentToResolveTarget();\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n            /**\n             * Increase debug counter for resolved target deltas\n             */\n            if (isDebug) {\n                metrics.resolvedTargetDeltas++;\n            }\n        }\n        getClosestProjectingParent() {\n            if (!this.parent ||\n                hasScale(this.parent.latestValues) ||\n                has2DTranslate(this.parent.latestValues)) {\n                return undefined;\n            }\n            if (this.parent.isProjecting()) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        }\n        isProjecting() {\n            return Boolean((this.relativeTarget ||\n                this.targetDelta ||\n                this.options.layoutRoot) &&\n                this.layout);\n        }\n        calcProjection() {\n            var _a;\n            const lead = this.getLead();\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            let canSkip = true;\n            /**\n             * If this is a normal layout animation and neither this node nor its nearest projecting\n             * is dirty then we can't skip.\n             */\n            if (this.isProjectionDirty || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty)) {\n                canSkip = false;\n            }\n            /**\n             * If this is a shared layout animation and this node's shared projection is dirty then\n             * we can't skip.\n             */\n            if (isShared &&\n                (this.isSharedProjectionDirty || this.isTransformDirty)) {\n                canSkip = false;\n            }\n            /**\n             * If we have resolved the target this frame we must recalculate the\n             * projection to ensure it visually represents the internal calculations.\n             */\n            if (this.resolvedRelativeTargetAt === frameData.timestamp) {\n                canSkip = false;\n            }\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean((this.parent && this.parent.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.layoutBox);\n            /**\n             * Record previous tree scales before updating.\n             */\n            const prevTreeScaleX = this.treeScale.x;\n            const prevTreeScaleY = this.treeScale.y;\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);\n            /**\n             * If this layer needs to perform scale correction but doesn't have a target,\n             * use the layout as the target.\n             */\n            if (lead.layout &&\n                !lead.target &&\n                (this.treeScale.x !== 1 || this.treeScale.y !== 1)) {\n                lead.target = lead.layout.layoutBox;\n                lead.targetWithTransforms = createBox();\n            }\n            const { target } = lead;\n            if (!target) {\n                /**\n                 * If we don't have a target to project into, but we were previously\n                 * projecting, we want to remove the stored transform and schedule\n                 * a render to ensure the elements reflect the removed transform.\n                 */\n                if (this.prevProjectionDelta) {\n                    this.createProjectionDeltas();\n                    this.scheduleRender();\n                }\n                return;\n            }\n            if (!this.projectionDelta || !this.prevProjectionDelta) {\n                this.createProjectionDeltas();\n            }\n            else {\n                copyAxisDeltaInto(this.prevProjectionDelta.x, this.projectionDelta.x);\n                copyAxisDeltaInto(this.prevProjectionDelta.y, this.projectionDelta.y);\n            }\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            if (this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY ||\n                !axisDeltaEquals(this.projectionDelta.x, this.prevProjectionDelta.x) ||\n                !axisDeltaEquals(this.projectionDelta.y, this.prevProjectionDelta.y)) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n            /**\n             * Increase debug counter for recalculated projections\n             */\n            if (isDebug) {\n                metrics.recalculatedProjection++;\n            }\n        }\n        hide() {\n            this.isVisible = false;\n            // TODO: Schedule render\n        }\n        show() {\n            this.isVisible = true;\n            // TODO: Schedule render\n        }\n        scheduleRender(notifyAll = true) {\n            var _a;\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.scheduleRender();\n            if (notifyAll) {\n                const stack = this.getStack();\n                stack && stack.scheduleRender();\n            }\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        }\n        createProjectionDeltas() {\n            this.prevProjectionDelta = createDelta();\n            this.projectionDelta = createDelta();\n            this.projectionDeltaWithTransform = createDelta();\n        }\n        setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {\n            const snapshot = this.snapshot;\n            const snapshotLatestValues = snapshot\n                ? snapshot.latestValues\n                : {};\n            const mixedValues = { ...this.latestValues };\n            const targetDelta = createDelta();\n            if (!this.relativeParent ||\n                !this.relativeParent.options.layoutRoot) {\n                this.relativeTarget = this.relativeTargetOrigin = undefined;\n            }\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            const relativeLayout = createBox();\n            const snapshotSource = snapshot ? snapshot.source : undefined;\n            const layoutSource = this.layout ? this.layout.source : undefined;\n            const isSharedLayoutAnimation = snapshotSource !== layoutSource;\n            const stack = this.getStack();\n            const isOnlyMember = !stack || stack.members.length <= 1;\n            const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            let prevRelativeTarget;\n            this.mixTargetDelta = (latest) => {\n                const progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                this.setTargetDelta(targetDelta);\n                if (this.relativeTarget &&\n                    this.relativeTargetOrigin &&\n                    this.layout &&\n                    this.relativeParent &&\n                    this.relativeParent.layout) {\n                    calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);\n                    mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);\n                    /**\n                     * If this is an unchanged relative target we can consider the\n                     * projection not dirty.\n                     */\n                    if (prevRelativeTarget &&\n                        boxEquals(this.relativeTarget, prevRelativeTarget)) {\n                        this.isProjectionDirty = false;\n                    }\n                    if (!prevRelativeTarget)\n                        prevRelativeTarget = createBox();\n                    copyBoxInto(prevRelativeTarget, this.relativeTarget);\n                }\n                if (isSharedLayoutAnimation) {\n                    this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                this.root.scheduleUpdateProjection();\n                this.scheduleRender();\n                this.animationProgress = progress;\n            };\n            this.mixTargetDelta(this.options.layoutRoot ? 1000 : 0);\n        }\n        startAnimation(options) {\n            this.notifyListeners(\"animationStart\");\n            this.currentAnimation && this.currentAnimation.stop();\n            if (this.resumingFrom && this.resumingFrom.currentAnimation) {\n                this.resumingFrom.currentAnimation.stop();\n            }\n            if (this.pendingAnimation) {\n                cancelFrame(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = frame.update(() => {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                this.currentAnimation = animateSingleValue(0, animationTarget, {\n                    ...options,\n                    onUpdate: (latest) => {\n                        this.mixTargetDelta(latest);\n                        options.onUpdate && options.onUpdate(latest);\n                    },\n                    onComplete: () => {\n                        options.onComplete && options.onComplete();\n                        this.completeAnimation();\n                    },\n                });\n                if (this.resumingFrom) {\n                    this.resumingFrom.currentAnimation = this.currentAnimation;\n                }\n                this.pendingAnimation = undefined;\n            });\n        }\n        completeAnimation() {\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            const stack = this.getStack();\n            stack && stack.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        }\n        finishAnimation() {\n            if (this.currentAnimation) {\n                this.mixTargetDelta && this.mixTargetDelta(animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        }\n        applyTransformsToTarget() {\n            const lead = this.getLead();\n            let { targetWithTransforms, target, layout, latestValues } = lead;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            /**\n             * If we're only animating position, and this element isn't the lead element,\n             * then instead of projecting into the lead box we instead want to calculate\n             * a new target that aligns the two boxes but maintains the layout shape.\n             */\n            if (this !== lead &&\n                this.layout &&\n                layout &&\n                shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout.layoutBox)) {\n                target = this.target || createBox();\n                const xLength = calcLength(this.layout.layoutBox.x);\n                target.x.min = lead.target.x.min;\n                target.x.max = target.x.min + xLength;\n                const yLength = calcLength(this.layout.layoutBox.y);\n                target.y.min = lead.target.y.min;\n                target.y.max = target.y.min + yLength;\n            }\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its layout layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        }\n        registerSharedNode(layoutId, node) {\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            const stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            const config = node.options.initialPromotionConfig;\n            node.promote({\n                transition: config ? config.transition : undefined,\n                preserveFollowOpacity: config && config.shouldPreserveFollowOpacity\n                    ? config.shouldPreserveFollowOpacity(node)\n                    : undefined,\n            });\n        }\n        isLead() {\n            const stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        }\n        getLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        }\n        getPrevLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        }\n        getStack() {\n            const { layoutId } = this.options;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        }\n        promote({ needsReset, transition, preserveFollowOpacity, } = {}) {\n            const stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition });\n        }\n        relegate() {\n            const stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        }\n        resetSkewAndRotation() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return;\n            // If there's no detected skew or rotation values, we can early return without a forced render.\n            let hasDistortingTransform = false;\n            /**\n             * An unrolled check for rotation values. Most elements don't have any rotation and\n             * skipping the nested loop and new object creation is 50% faster.\n             */\n            const { latestValues } = visualElement;\n            if (latestValues.z ||\n                latestValues.rotate ||\n                latestValues.rotateX ||\n                latestValues.rotateY ||\n                latestValues.rotateZ ||\n                latestValues.skewX ||\n                latestValues.skewY) {\n                hasDistortingTransform = true;\n            }\n            // If there's no distorting values, we don't need to do any more.\n            if (!hasDistortingTransform)\n                return;\n            const resetValues = {};\n            if (latestValues.z) {\n                resetDistortingTransform(\"z\", visualElement, resetValues, this.animationValues);\n            }\n            // Check the skew and rotate value of all axes and reset to 0\n            for (let i = 0; i < transformAxes.length; i++) {\n                resetDistortingTransform(`rotate${transformAxes[i]}`, visualElement, resetValues, this.animationValues);\n                resetDistortingTransform(`skew${transformAxes[i]}`, visualElement, resetValues, this.animationValues);\n            }\n            // Force a render of this element to apply the transform with all skews and rotations\n            // set to 0.\n            visualElement.render();\n            // Put back all the values we reset\n            for (const key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n                if (this.animationValues) {\n                    this.animationValues[key] = resetValues[key];\n                }\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        }\n        getProjectionStyles(styleProp) {\n            var _a, _b;\n            if (!this.instance || this.isSVG)\n                return undefined;\n            if (!this.isVisible) {\n                return hiddenVisibility;\n            }\n            const styles = {\n                visibility: \"\",\n            };\n            const transformTemplate = this.getTransformTemplate();\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            const lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                const emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity =\n                        this.latestValues.opacity !== undefined\n                            ? this.latestValues.opacity\n                            : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            const valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            const { x, y } = this.projectionDelta;\n            styles.transformOrigin = `${x.origin * 100}% ${y.origin * 100}% 0`;\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_b = (_a = valuesToRender.opacity) !== null && _a !== void 0 ? _a : this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its layout\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? valuesToRender.opacity !== undefined\n                            ? valuesToRender.opacity\n                            : \"\"\n                        : valuesToRender.opacityExit !== undefined\n                            ? valuesToRender.opacityExit\n                            : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (const key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                const { correct, applyTo } = scaleCorrectors[key];\n                /**\n                 * Only apply scale correction to the value if we have an\n                 * active projection transform. Otherwise these values become\n                 * vulnerable to distortion if the element changes size without\n                 * a corresponding layout animation.\n                 */\n                const corrected = styles.transform === \"none\"\n                    ? valuesToRender[key]\n                    : correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    const num = applyTo.length;\n                    for (let i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        }\n        clearSnapshot() {\n            this.resumeFrom = this.snapshot = undefined;\n        }\n        // Only run on root\n        resetTree() {\n            this.root.nodes.forEach((node) => { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        }\n    };\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a;\n    const snapshot = ((_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) || node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        const { layoutBox: layout, measuredBox: measuredLayout } = node.layout;\n        const { animationType } = node.options;\n        const isShared = snapshot.source !== node.layout.source;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (animationType === \"size\") {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout)) {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(layout[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n                /**\n                 * Ensure relative target gets resized and rerendererd\n                 */\n                if (node.relativeTarget && !node.currentAnimation) {\n                    node.isProjectionDirty = true;\n                    node.relativeTarget[axis].max =\n                        node.relativeTarget[axis].min + length;\n                }\n            });\n        }\n        const layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout, snapshot.layoutBox);\n        const visualDelta = createDelta();\n        if (isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measuredBox);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout, snapshot.layoutBox);\n        }\n        const hasLayoutChanged = !isDeltaZero(layoutDelta);\n        let hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            const relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (relativeParent && !relativeParent.resumeFrom) {\n                const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;\n                if (parentSnapshot && parentLayout) {\n                    const relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox);\n                    const relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout, parentLayout.layoutBox);\n                    if (!boxEqualsRounded(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                    if (relativeParent.options.layoutRoot) {\n                        node.relativeTarget = relativeLayout;\n                        node.relativeTargetOrigin = relativeSnapshot;\n                        node.relativeParent = relativeParent;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout,\n            snapshot,\n            delta: visualDelta,\n            layoutDelta,\n            hasLayoutChanged,\n            hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        const { onExitComplete } = node.options;\n        onExitComplete && onExitComplete();\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction propagateDirtyNodes(node) {\n    /**\n     * Increase debug counter for nodes encountered this frame\n     */\n    if (isDebug) {\n        metrics.totalNodes++;\n    }\n    if (!node.parent)\n        return;\n    /**\n     * If this node isn't projecting, propagate isProjectionDirty. It will have\n     * no performance impact but it will allow the next child that *is* projecting\n     * but *isn't* dirty to just check its parent to see if *any* ancestor needs\n     * correcting.\n     */\n    if (!node.isProjecting()) {\n        node.isProjectionDirty = node.parent.isProjectionDirty;\n    }\n    /**\n     * Propagate isSharedProjectionDirty and isTransformDirty\n     * throughout the whole tree. A future revision can take another look at\n     * this but for safety we still recalcualte shared nodes.\n     */\n    node.isSharedProjectionDirty || (node.isSharedProjectionDirty = Boolean(node.isProjectionDirty ||\n        node.parent.isProjectionDirty ||\n        node.parent.isSharedProjectionDirty));\n    node.isTransformDirty || (node.isTransformDirty = node.parent.isTransformDirty);\n}\nfunction cleanDirtyNodes(node) {\n    node.isProjectionDirty =\n        node.isSharedProjectionDirty =\n            node.isTransformDirty =\n                false;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction clearIsLayoutDirty(node) {\n    node.isLayoutDirty = false;\n}\nfunction resetTransformStyle(node) {\n    const { visualElement } = node.options;\n    if (visualElement && visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notify(\"BeforeLayoutMeasure\");\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n    node.isProjectionDirty = true;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetSkewAndRotation(node) {\n    node.resetSkewAndRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = mixNumber(delta.translate, 0, p);\n    output.scale = mixNumber(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = mixNumber(from.min, to.min, p);\n    output.max = mixNumber(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nconst defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nconst userAgentContains = (string) => typeof navigator !== \"undefined\" &&\n    navigator.userAgent &&\n    navigator.userAgent.toLowerCase().includes(string);\n/**\n * Measured bounding boxes must be rounded in Safari and\n * left untouched in Chrome, otherwise non-integer layouts within scaled-up elements\n * can appear to jump.\n */\nconst roundPoint = userAgentContains(\"applewebkit/\") && !userAgentContains(\"chrome/\")\n    ? Math.round\n    : noop;\nfunction roundAxis(axis) {\n    // Round to the nearest .5 pixels to support subpixel layouts\n    axis.min = roundPoint(axis.min);\n    axis.max = roundPoint(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\nfunction shouldAnimatePositionOnly(animationType, snapshot, layout) {\n    return (animationType === \"position\" ||\n        (animationType === \"preserve-aspect\" &&\n            !isNear(aspectRatio(snapshot), aspectRatio(layout), 0.2)));\n}\nfunction checkNodeWasScrollRoot(node) {\n    var _a;\n    return node !== node.root && ((_a = node.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot);\n}\n\nexport { cleanDirtyNodes, createProjectionNode, mixAxis, mixAxisDelta, mixBox, propagateDirtyNodes };\n","function isSVGElement(element) {\n    return element instanceof SVGElement && element.tagName !== \"svg\";\n}\n\nexport { isSVGElement };\n","import { time } from '../frameloop/sync-time.mjs';\nimport { frame, cancelFrame } from '../frameloop/frame.mjs';\n\n/**\n * Timeout defined in ms\n */\nfunction delay(callback, timeout) {\n    const start = time.now();\n    const checkElapsed = ({ timestamp }) => {\n        const elapsed = timestamp - start;\n        if (elapsed >= timeout) {\n            cancelFrame(checkElapsed);\n            callback(elapsed - timeout);\n        }\n    };\n    frame.read(checkElapsed, true);\n    return () => cancelFrame(checkElapsed);\n}\n\nexport { delay };\n","import { animateMotionValue } from './motion-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction animateSingleValue(value, keyframes, options) {\n    const motionValue$1 = isMotionValue(value) ? value : motionValue(value);\n    motionValue$1.start(animateMotionValue(\"\", motionValue$1, keyframes, options));\n    return motionValue$1.animation;\n}\n\nexport { animateSingleValue };\n","function buildProjectionTransform(delta, treeScale, latestTransform) {\n    let transform = \"\";\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    const xTranslate = delta.x.translate / treeScale.x;\n    const yTranslate = delta.y.translate / treeScale.y;\n    const zTranslate = (latestTransform === null || latestTransform === void 0 ? void 0 : latestTransform.z) || 0;\n    if (xTranslate || yTranslate || zTranslate) {\n        transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;\n    }\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    if (treeScale.x !== 1 || treeScale.y !== 1) {\n        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;\n    }\n    if (latestTransform) {\n        const { transformPerspective, rotate, rotateX, rotateY, skewX, skewY } = latestTransform;\n        if (transformPerspective)\n            transform = `perspective(${transformPerspective}px) ${transform}`;\n        if (rotate)\n            transform += `rotate(${rotate}deg) `;\n        if (rotateX)\n            transform += `rotateX(${rotateX}deg) `;\n        if (rotateY)\n            transform += `rotateY(${rotateY}deg) `;\n        if (skewX)\n            transform += `skewX(${skewX}deg) `;\n        if (skewY)\n            transform += `skewY(${skewY}deg) `;\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    const elementScaleX = delta.x.scale * treeScale.x;\n    const elementScaleY = delta.y.scale * treeScale.y;\n    if (elementScaleX !== 1 || elementScaleY !== 1) {\n        transform += `scale(${elementScaleX}, ${elementScaleY})`;\n    }\n    return transform || \"none\";\n}\n\nexport { buildProjectionTransform };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/add-dom-event.mjs';\n\nconst DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: (ref, notify) => addDomEvent(ref, \"resize\", notify),\n    measureScroll: () => ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }),\n    checkIsScrollRoot: () => true,\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nconst rootProjectionNode = {\n    current: undefined,\n};\nconst HTMLProjectionNode = createProjectionNode({\n    measureScroll: (instance) => ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }),\n    defaultParent: () => {\n        if (!rootProjectionNode.current) {\n            const documentNode = new DocumentProjectionNode({});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: (instance, value) => {\n        instance.style.transform = value !== undefined ? value : \"none\";\n    },\n    checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === \"fixed\"),\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { DragGesture } from '../../gestures/drag/index.mjs';\nimport { PanGesture } from '../../gestures/pan/index.mjs';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\nconst drag = {\n    pan: {\n        Feature: PanGesture,\n    },\n    drag: {\n        Feature: DragGesture,\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { drag };\n","import { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\n\nclass DragGesture extends Feature {\n    constructor(node) {\n        super(node);\n        this.removeGroupControls = noop;\n        this.removeListeners = noop;\n        this.controls = new VisualElementDragControls(node);\n    }\n    mount() {\n        // If we've been provided a DragControls for manual control over the drag gesture,\n        // subscribe this component to it on mount.\n        const { dragControls } = this.node.getProps();\n        if (dragControls) {\n            this.removeGroupControls = dragControls.subscribe(this.controls);\n        }\n        this.removeListeners = this.controls.addListeners() || noop;\n    }\n    unmount() {\n        this.removeGroupControls();\n        this.removeListeners();\n    }\n}\n\nexport { DragGesture };\n","// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n","const visualElementStore = new WeakMap();\n\nexport { visualElementStore };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { complex } from '../../../value/types/complex/index.mjs';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = (v) => valueTypes.find(testValueType(v));\n\nexport { findValueType };\n","import { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { transformProps } from './html/utils/transform.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { isVariantLabel } from './utils/is-variant-label.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { variantProps } from './utils/variant-props.mjs';\nimport { visualElementStore } from './store.mjs';\nimport { KeyframeResolver } from './utils/KeyframesResolver.mjs';\nimport { isNumericalString } from '../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../utils/is-zero-value-string.mjs';\nimport { findValueType } from './dom/value-types/find.mjs';\nimport { complex } from '../value/types/complex/index.mjs';\nimport { getAnimatableNone } from './dom/value-types/animatable-none.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { frame, cancelFrame } from '../frameloop/frame.mjs';\n\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\nconst numVariantProps = variantProps.length;\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {\n        return {};\n    }\n    constructor({ parent, props, presenceContext, reducedMotionConfig, blockInitialAnimation, visualState, }, options = {}) {\n        /**\n         * If true, will-change will be applied to the element. Only HTMLVisualElements\n         * currently support this.\n         */\n        this.applyWillChange = false;\n        /**\n         * A reference to the current underlying Instance, e.g. a HTMLElement\n         * or Three.Mesh etc.\n         */\n        this.current = null;\n        /**\n         * A set containing references to this VisualElement's children.\n         */\n        this.children = new Set();\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        this.isVariantNode = false;\n        this.isControllingVariants = false;\n        /**\n         * Decides whether this VisualElement should animate in reduced motion\n         * mode.\n         *\n         * TODO: This is currently set on every individual VisualElement but feels\n         * like it could be set globally.\n         */\n        this.shouldReduceMotion = null;\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        this.values = new Map();\n        this.KeyframeResolver = KeyframeResolver;\n        /**\n         * Cleanup functions for active features (hover/tap/exit etc)\n         */\n        this.features = {};\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            this.isRenderScheduled = false;\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.isRenderScheduled = false;\n        this.scheduleRender = () => {\n            if (!this.isRenderScheduled) {\n                this.isRenderScheduled = true;\n                frame.render(this.render, false, true);\n            }\n        };\n        const { latestValues, renderState } = visualState;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.presenceContext = presenceContext;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.blockInitialAnimation = Boolean(blockInitialAnimation);\n        this.isControllingVariants = isControllingVariants(props);\n        this.isVariantNode = isVariantNode(props);\n        if (this.isVariantNode) {\n            this.variantChildren = new Set();\n        }\n        this.manuallyAnimateOnMount = Boolean(parent && parent.current);\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't necessarily a breaking change,\n         * more a reflection of the test.\n         */\n        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);\n        for (const key in initialMotionValues) {\n            const value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n    }\n    mount(instance) {\n        this.current = instance;\n        visualElementStore.set(instance, this);\n        if (this.projection && !this.projection.instance) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = this.parent.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n        }\n        if (this.parent)\n            this.parent.children.add(this);\n        this.update(this.props, this.presenceContext);\n    }\n    unmount() {\n        visualElementStore.delete(this.current);\n        this.projection && this.projection.unmount();\n        cancelFrame(this.notifyUpdate);\n        cancelFrame(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        this.removeFromVariantTree && this.removeFromVariantTree();\n        this.parent && this.parent.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        for (const key in this.features) {\n            const feature = this.features[key];\n            if (feature) {\n                feature.unmount();\n                feature.isMounted = false;\n            }\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        const valueIsTransform = transformProps.has(key);\n        const removeOnChange = value.on(\"change\", (latestValue) => {\n            this.latestValues[key] = latestValue;\n            this.props.onUpdate && frame.preRender(this.notifyUpdate);\n            if (valueIsTransform && this.projection) {\n                this.projection.isTransformDirty = true;\n            }\n        });\n        const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n            if (value.owner)\n                value.stop();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type) {\n            return 0;\n        }\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    updateFeatures() {\n        let key = \"animation\";\n        for (key in featureDefinitions) {\n            const featureDefinition = featureDefinitions[key];\n            if (!featureDefinition)\n                continue;\n            const { isEnabled, Feature: FeatureConstructor } = featureDefinition;\n            /**\n             * If this feature is enabled but not active, make a new instance.\n             */\n            if (!this.features[key] &&\n                FeatureConstructor &&\n                isEnabled(this.props)) {\n                this.features[key] = new FeatureConstructor(this);\n            }\n            /**\n             * If we have a feature, mount or update it.\n             */\n            if (this.features[key]) {\n                const feature = this.features[key];\n                if (feature.isMounted) {\n                    feature.update();\n                }\n                else {\n                    feature.mount();\n                    feature.isMounted = true;\n                }\n            }\n        }\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, this.props);\n    }\n    /**\n     * Measure the current viewport box with or without transforms.\n     * Only measures axis-aligned boxes, rotate and skew must be manually\n     * removed with a re-render to work.\n     */\n    measureViewportBox() {\n        return this.current\n            ? this.measureInstanceViewportBox(this.current, this.props)\n            : createBox();\n    }\n    getStaticValue(key) {\n        return this.latestValues[key];\n    }\n    setStaticValue(key, value) {\n        this.latestValues[key] = value;\n    }\n    /**\n     * Update the provided props. Ensure any newly-added motion values are\n     * added to our map, old ones removed, and listeners updated.\n     */\n    update(props, presenceContext) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.prevProps = this.props;\n        this.props = props;\n        this.prevPresenceContext = this.presenceContext;\n        this.presenceContext = presenceContext;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listenerName = (\"on\" + key);\n            const listener = props[listenerName];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps, this), this.prevMotionValues);\n        if (this.handleChildMotionValue) {\n            this.handleChildMotionValue();\n        }\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        return this.props.variants ? this.props.variants[name] : undefined;\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        return this.isVariantNode\n            ? this\n            : this.parent\n                ? this.parent.getClosestVariantNode()\n                : undefined;\n    }\n    getVariantContext(startAtParent = false) {\n        if (startAtParent) {\n            return this.parent ? this.parent.getVariantContext() : undefined;\n        }\n        if (!this.isControllingVariants) {\n            const context = this.parent\n                ? this.parent.getVariantContext() || {}\n                : {};\n            if (this.props.initial !== undefined) {\n                context.initial = this.props.initial;\n            }\n            return context;\n        }\n        const context = {};\n        for (let i = 0; i < numVariantProps; i++) {\n            const name = variantProps[i];\n            const prop = this.props[name];\n            if (isVariantLabel(prop) || prop === false) {\n                context[name] = prop;\n            }\n        }\n        return context;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            closestVariantNode.variantChildren &&\n                closestVariantNode.variantChildren.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        const existingValue = this.values.get(key);\n        if (value !== existingValue) {\n            if (existingValue)\n                this.removeValue(key);\n            this.bindToMotionValue(key, value);\n            this.values.set(key, value);\n            this.latestValues[key] = value.get();\n        }\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        this.values.delete(key);\n        const unsubscribe = this.valueSubscriptions.get(key);\n        if (unsubscribe) {\n            unsubscribe();\n            this.valueSubscriptions.delete(key);\n        }\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\n    getValue(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue === null ? undefined : defaultValue, { owner: this });\n            this.addValue(key, value);\n        }\n        return value;\n    }\n    /**\n     * If we're trying to animate to a previously unencountered value,\n     * we need to check for it in our state and as a last resort read it\n     * directly from the instance (which might have performance implications).\n     */\n    readValue(key, target) {\n        var _a;\n        let value = this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);\n        if (value !== undefined && value !== null) {\n            if (typeof value === \"string\" &&\n                (isNumericalString(value) || isZeroValueString(value))) {\n                // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n                value = parseFloat(value);\n            }\n            else if (!findValueType(value) && complex.test(target)) {\n                value = getAnimatableNone(key, target);\n            }\n            this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);\n        }\n        return isMotionValue(value) ? value.get() : value;\n    }\n    /**\n     * Set the base target to later animate back to. This is currently\n     * only hydrated on creation and when we first read a value.\n     */\n    setBaseTarget(key, value) {\n        this.baseTarget[key] = value;\n    }\n    /**\n     * Find the base target for a value thats been removed from all animation\n     * props.\n     */\n    getBaseTarget(key) {\n        var _a;\n        const { initial } = this.props;\n        let valueFromInitial;\n        if (typeof initial === \"string\" || typeof initial === \"object\") {\n            const variant = resolveVariantFromProps(this.props, initial, (_a = this.presenceContext) === null || _a === void 0 ? void 0 : _a.custom);\n            if (variant) {\n                valueFromInitial = variant[key];\n            }\n        }\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        if (this.events[eventName]) {\n            this.events[eventName].notify(...args);\n        }\n    }\n}\n\nexport { VisualElement };\n","import { isBrowser } from '../is-browser.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from './state.mjs';\n\nfunction initPrefersReducedMotion() {\n    hasReducedMotionListener.current = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);\n        motionMediaQuery.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n\nexport { initPrefersReducedMotion };\n","import { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"11.3.29\", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.3.29 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                if (existingValue.liveStyle === true) {\n                    existingValue.jump(nextValue);\n                }\n                else if (!existingValue.hasAnimated) {\n                    existingValue.set(nextValue);\n                }\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { VisualElement } from '../VisualElement.mjs';\nimport { DOMKeyframesResolver } from './DOMKeyframesResolver.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    constructor() {\n        super(...arguments);\n        this.KeyframeResolver = DOMKeyframesResolver;\n    }\n    sortInstanceNodePosition(a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props.style\n            ? props.style[key]\n            : undefined;\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n}\n\nexport { DOMVisualElement };\n","import { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariableName } from '../dom/utils/is-css-variable.mjs';\nimport { transformProps } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"html\";\n        this.applyWillChange = true;\n        this.renderInstance = renderHTML;\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariableName(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, props) {\n        buildHTMLStyles(renderState, latestValues, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n    handleChildMotionValue() {\n        if (this.childSubscription) {\n            this.childSubscription();\n            delete this.childSubscription;\n        }\n        const { children } = this.props;\n        if (isMotionValue(children)) {\n            this.childSubscription = children.on(\"change\", (latest) => {\n                if (this.current)\n                    this.current.textContent = `${latest}`;\n            });\n        }\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { transformProps } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"svg\";\n        this.isSVGTag = false;\n        this.measureInstanceViewportBox = createBox;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return instance.getAttribute(key);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n    build(renderState, latestValues, props) {\n        buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n    mount(instance) {\n        this.isSVGTag = isSVGTag(instance.tagName);\n        super.mount(instance);\n    }\n}\n\nexport { SVGVisualElement };\n","import { Fragment } from 'react';\nimport { HTMLVisualElement } from '../html/HTMLVisualElement.mjs';\nimport { SVGVisualElement } from '../svg/SVGVisualElement.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nconst createDomVisualElement = (Component, options) => {\n    return isSVGComponent(Component)\n        ? new SVGVisualElement(options)\n        : new HTMLVisualElement(options, {\n            allowProjection: Component !== Fragment,\n        });\n};\n\nexport { createDomVisualElement };\n","import { createMotionComponent } from '../../motion/index.mjs';\nimport { createMotionProxy } from './motion-proxy.mjs';\nimport { createDomMotionConfig } from './utils/create-config.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { animations } from '../../motion/features/animations.mjs';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\nimport { layout } from '../../motion/features/layout.mjs';\n\nconst preloadedFeatures = {\n    ...animations,\n    ...gestureAnimations,\n    ...drag,\n    ...layout,\n};\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 */\nconst motion = /*@__PURE__*/ createMotionProxy((Component, config) => createDomMotionConfig(Component, config, preloadedFeatures, createDomVisualElement));\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n    return createMotionComponent(createDomMotionConfig(key, { forwardMotionProps: false }, preloadedFeatures, createDomVisualElement));\n}\n\nexport { createDomMotionComponent, motion };\n","import { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\n\nconst layout = {\n    layout: {\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { layout };\n","import { isSVGComponent } from './is-svg-component.mjs';\nimport { createUseRender } from '../use-render.mjs';\nimport { svgMotionConfig } from '../../svg/config-motion.mjs';\nimport { htmlMotionConfig } from '../../html/config-motion.mjs';\n\nfunction createDomMotionConfig(Component, { forwardMotionProps = false }, preloadedFeatures, createVisualElement) {\n    const baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return {\n        ...baseConfig,\n        preloadedFeatures,\n        useRender: createUseRender(forwardMotionProps),\n        createVisualElement,\n        Component,\n    };\n}\n\nexport { createDomMotionConfig };\n","import { noop } from './noop.mjs';\n\nlet warning = noop;\nlet invariant = noop;\nif (process.env.NODE_ENV !== \"production\") {\n    warning = (check, message) => {\n        if (!check && typeof console !== \"undefined\") {\n            console.warn(message);\n        }\n    };\n    invariant = (check, message) => {\n        if (!check) {\n            throw new Error(message);\n        }\n    };\n}\n\nexport { invariant, warning };\n","const isBrowser = typeof window !== \"undefined\";\n\nexport { isBrowser };\n","const noop = (any) => any;\n\nexport { noop };\n","import { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    const ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\n","import { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.mjs';\n\nconst useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\n"],"names":["getTimezoneOffsetInMilliseconds","date","utcDate","Date","UTC","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getMilliseconds","setUTCFullYear","getTime","requiredArgs","required","args","length","TypeError","startOfDay","dirtyDate","arguments","toDate","setHours","MILLISECONDS_IN_DAY","compareLocalAsc","dateLeft","dateRight","diff","differenceInDays","dirtyDateLeft","dirtyDateRight","sign","difference","Math","abs","startOfDayLeft","startOfDayRight","timestampLeft","timestampRight","round","differenceInCalendarDays","setDate","result","Number","argument","argStr","Object","prototype","toString","call","console","warn","Error","stack","NaN","module","exports","e","o","t","isToday","this","format","_typeof","obj","Symbol","iterator","constructor","_defineProperties","target","props","i","descriptor","enumerable","configurable","writable","defineProperty","key","_getPrototypeOf","setPrototypeOf","getPrototypeOf","__proto__","_assertThisInitialized","self","ReferenceError","_setPrototypeOf","p","_defineProperty","value","PersistGate","_PureComponent","_getPrototypeOf2","_this","instance","Constructor","_classCallCheck","_len","Array","_key","_possibleConstructorReturn","apply","concat","bootstrapped","persistor","getState","onBeforeLift","Promise","resolve","finally","setState","_unsubscribe","protoProps","staticProps","subClass","superClass","create","_inherits","subscribe","handlePersistorState","children","state","loading","PureComponent","d","f","r","captureStackTrace","M","join","s","slice","c","indexOf","splice","n","register","slot","name","Provider","y","a","id","ref","ourProps","theirProps","defaultTag","b","assign","Forwards","Backwards","E","current","window","addEventListener","removeEventListener","u","entries","l","P","Set","HTMLElement","add","h","None","InitialFocus","TabLock","FocusLock","RestoreFocus","All","z","initialFocus","containers","features","m","Y","ownerDocument","Boolean","container","activeElement","contains","First","Z","previousActiveElement","defaultView","S","preventDefault","stopPropagation","$","v","shiftKey","T","skipElements","relatedTarget","Last","_","j","onKeyDown","requestAnimationFrame","onBlur","dataset","headlessuiFocusGuard","Next","Previous","WrapAround","relativeTo","as","type","onFocus","Focusable","find","isConnected","Q","body","document","readyState","unshift","filter","capture","force","U","push","unregister","portals","D","isServer","getElementById","createElement","setAttribute","appendChild","F","C","Node","removeChild","childNodes","parentElement","I","Group","displayName","Add","Remove","onUpdate","element","enabled","is","useState","useEffect","useLayoutEffect","useDebugValue","getSnapshot","useSyncExternalStore","before","doc","documentElement","innerWidth","clientWidth","after","offsetWidth","style","test","navigator","platform","maxTouchPoints","pageYOffset","meta","flatMap","some","microTask","getComputedStyle","scrollBehavior","dispose","scrollTo","closest","hash","URL","href","querySelector","passive","scrollIntoView","block","delete","dispatch","forEach","Map","PUSH","get","count","set","POP","SCROLL_PREVENT","SCROLL_ALLOW","TEARDOWN","overflow","values","getAttribute","inert","removeAttribute","_e","Open","Closed","Ie","SetTitleId","Me","titleId","Be","Ge","RenderStrategy","Static","Ve","X","open","onClose","__demoMode","g","N","hasOwnProperty","descriptionId","panelRef","W","L","ee","te","resolveContainers","mainTreeNodeRef","k","MainTreeNode","oe","defaultContainers","querySelectorAll","head","Hidden","re","Closing","ne","le","from","ae","ie","se","pe","defaultPrevented","Escape","we","ResizeObserver","x","getBoundingClientRect","width","height","observe","disconnect","ue","fe","ge","dialogState","close","setTitleId","J","Te","role","parent","leaf","visible","qe","ze","onClick","Qe","currentTarget","Ze","_t","Backdrop","Panel","Overlay","Title","Description","me","de","Pointer","Other","OpenMenu","CloseMenu","GoToItem","Search","ClearSearch","RegisterItem","UnregisterItem","w","activeItemIndex","items","dataRef","domRef","menuState","resolveItems","resolveActiveIndex","resolveId","resolveDisabled","disabled","searchQuery","activationTrigger","trigger","toLowerCase","textValue","startsWith","searchActiveItemIndex","findIndex","O","ye","be","Se","ve","buttonRef","itemsRef","R","Loose","focus","A","xe","Space","Enter","ArrowDown","nextFrame","ArrowUp","preventScroll","onKeyUp","he","accept","NodeFilter","FILTER_REJECT","hasAttribute","FILTER_SKIP","FILTER_ACCEPT","walk","click","Home","PageUp","End","PageDown","Tab","setTimeout","tabIndex","De","B","Nothing","Specific","update","wasMoved","active","onPointerEnter","onMouseEnter","onPointerMove","onMouseMove","onPointerLeave","onMouseLeave","it","Button","Items","Item","htmlFor","Ce","RegisterOption","UnregisterOption","ke","options","propsRef","Le","Empty","Active","defaultValue","form","onChange","by","G","H","map","ArrowLeft","Success","K","ArrowRight","firstOption","containsCheckedOption","compare","registerOption","change","checked","hidden","readOnly","addFlag","removeFlag","hasFlag","yt","Option","Label","acceptNode","createTreeWalker","SHOW_ELEMENT","nextNode","currentNode","PopChildMeasure","getSnapshotBeforeUpdate","prevProps","childRef","isPresent","size","sizeRef","offsetHeight","top","offsetTop","left","offsetLeft","componentDidUpdate","render","PopChild","useId","useRef","nonce","useContext","MotionConfigContext","useInsertionEffect","motionPopId","sheet","insertRule","jsx","PresenceChild","initial","onExitComplete","custom","presenceAffectsLayout","mode","presenceChildren","newChildrenMap","context","useMemo","childId","isComplete","random","PresenceContext","getChildKey","child","onlyElements","filtered","Children","isValidElement","AnimatePresence","exitBeforeEnter","presentChildren","presentKeys","isInitialRender","pendingPresentChildren","exitComplete","diffedChildren","setDiffedChildren","renderedChildren","setRenderedChildren","includes","exitingChildren","nextChildren","forceRender","LayoutGroupContext","Fragment","undefined","has","isEveryExitComplete","isExitComplete","createContext","transformPagePoint","isStatic","reducedMotion","MotionContext","LazyContext","strict","camelToDash","str","replace","optimizedAppearDataAttribute","MotionGlobalConfig","stepsOrder","createRenderBatcher","scheduleNextBatch","allowKeepAlive","runNextFrame","useDefaultElapsed","delta","timestamp","isProcessing","flagRunNextFrame","steps","reduce","acc","thisFrame","flushNextFrame","toKeepAlive","WeakSet","latestFrameData","triggerCallback","callback","step","schedule","keepAlive","immediate","queue","cancel","process","frameData","clear","createRenderStep","read","resolveKeyframes","preRender","postRender","processBatch","performance","now","max","min","microtask","cancelMicrotask","queueMicrotask","isRefObject","SwitchLayoutGroupContext","scheduleHandoffComplete","useVisualElement","Component","visualState","createVisualElement","ProjectionNodeConstructor","_a","visualElement","lazyContext","presenceContext","reducedMotionConfig","visualElementRef","renderer","blockInitialAnimation","initialLayoutGroupConfig","projection","initialPromotionConfig","layoutId","layout","drag","dragConstraints","layoutScroll","layoutRoot","latestValues","getClosestProjectingNode","setOptions","alwaysMeasureLayout","animationType","createProjectionNode","optimisedAppearId","wantsHandoff","MotionHandoffIsComplete","MotionHasOptimisedAnimation","updateFeatures","animationState","animateChanges","completeHandoff","allowProjection","useMotionRef","externalRef","useCallback","mount","unmount","isVariantLabel","isArray","isAnimationControls","start","variantPriorityOrder","variantProps","isControllingVariants","animate","isVariantNode","variants","useCreateMotionContext","inherit","getCurrentTreeVariants","variantLabelsAsDependency","prop","featureProps","animation","exit","hover","tap","pan","inView","featureDefinitions","isEnabled","motionComponentSymbol","for","preloadedFeatures","useRender","useVisualState","loadFeatures","ForwardRefComponent","forwardRef","MeasureLayout","configAndProps","useLayoutId","useStrictMode","layoutProjection","combined","ProjectionNode","getProjectionFunctionality","jsxs","layoutGroupId","createMotionProxy","createConfig","customMotionComponentConfig","Proxy","componentCache","_target","lowercaseSVGElements","isSVGComponent","scaleCorrectors","transformPropOrder","transformProps","isForcedMotionValue","isMotionValue","getVelocity","getValueAsType","transform","clamp","number","parse","parseFloat","alpha","scale","default","sanitize","floatRegex","colorRegex","singleColorRegex","isString","createUnitType","unit","endsWith","split","degrees","percent","px","vh","vw","progressPercentage","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxWidth","maxHeight","right","bottom","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","transformPerspective","opacity","originX","originY","originZ","zIndex","backgroundPositionX","backgroundPositionY","fillOpacity","strokeOpacity","numOctaves","translateAlias","numTransforms","checkStringStartsWith","token","isCSSVariableName","startsAsVariableToken","isCSSVariableToken","singleCssVariableRegex","trim","buildHTMLStyles","transformTemplate","vars","transformOrigin","hasTransform","hasTransformOrigin","valueAsType","transformString","transformIsDefault","valueIsDefault","buildTransform","createHtmlRenderState","copyRawValuesOnly","source","useStyle","useInitialMotionValues","useHTMLProps","htmlProps","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","onTap","onTapStart","whileTap","validMotionProps","isValidMotionProp","shouldForward","isValidProp","require","calcOrigin","origin","offset","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","attrScale","pathLength","pathSpacing","pathOffset","latest","isSVGTag","viewBox","attrs","dimensions","calcSVGTransformOrigin","spacing","useDashCase","keys","buildSVGPath","createSvgRenderState","tag","useSVGProps","_isStatic","visualProps","rawStyles","createUseRender","forwardMotionProps","filteredProps","isDom","filterProps","elementProps","renderHTML","styleProp","getProjectionStyles","setProperty","camelCaseAttributes","renderSVG","renderState","_styleProp","scrapeMotionValuesFromProps","newValues","getValue","liveStyle","willChange","applyWillChange","charAt","toUpperCase","substring","getValueState","resolveVariantFromProps","definition","velocity","isKeyframesTarget","isCustomValue","mix","toValue","resolveFinalValueInKeyframes","resolveMotionValue","unwrappedValue","acceleratedValues","getWillChangeName","addUniqueItem","arr","item","removeItem","index","makeUseVisualState","config","make","createRenderState","onMount","makeLatestValues","makeState","addWillChange","memberName","forEachDefinition","list","resolved","transitionEnd","transition","shouldApplyWillChange","scrapeMotionValues","motionValues","isControllingVariants$1","isVariantNode$1","isInitialAnimationBlocked","variantToSet","valueTarget","cancelFrame","noop","svgMotionConfig","getBBox","tagName","htmlMotionConfig","addDomEvent","eventName","handler","isPrimaryPointer","event","pointerType","button","isPrimary","extractEventInfo","pointType","point","addPointerInfo","addPointerEvent","combineFunctions","pipe","transformers","createLock","lock","openLock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal","openVertical","isDragActive","openGestureLock","Feature","node","isMounted","addHoverEvent","isActive","callbackName","info","getProps","whileHover","setActive","isNodeOrChild","fireSyntheticPointerEvent","syntheticPointerEvent","PointerEvent","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","observeIntersection","rootInteresectionObserver","root","lookupRoot","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","unobserve","thresholdNames","all","gestureAnimations","super","hasEnteredView","isInView","startObserver","viewport","rootMargin","amount","once","threshold","isIntersecting","onViewportEnter","onViewportLeave","prevViewport","hasViewportOptionChanged","removeStartListeners","removeEndListeners","removeAccessibleListeners","startPointerPress","startEvent","startInfo","isPressing","removePointerUpListener","endEvent","endInfo","checkPressEnd","onTapCancel","globalTapTarget","removePointerCancelListener","cancelEvent","cancelInfo","cancelPress","startPress","startAccessiblePress","removeKeydownListener","keydownEvent","keyupEvent","removeBlurListener","removePointerListener","removeFocusListener","isFocusVisible","matches","shallowCompare","next","prev","prevLength","resolveVariant","secondsToMilliseconds","seconds","millisecondsToSeconds","milliseconds","underDampedSpring","stiffness","damping","restSpeed","keyframesTransition","duration","ease","getDefaultTransition","valueKey","keyframes","sqrt","getValueTransition","instantAnimationState","isNotNull","getFinalKeyframe","repeat","repeatType","finalKeyframe","resolvedKeyframes","isZeroValueString","isNumericalString","splitCSSVariableRegex","getVariableValue","depth","fallback","match","exec","token1","token2","parseCSSVariable","getPropertyValue","trimmed","positionalKeys","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","positionalValues","testValueType","dimensionValueTypes","findDimensionValueType","toResolve","isScheduled","anyNeedsMeasurement","measureAllKeyframes","resolversToMeasure","resolver","needsMeasurement","elementsToMeasure","transformsToRestore","removedTransforms","removeNonTranslationalTransform","measureInitialState","restore","measureEndState","suspendedScrollY","complete","readAllKeyframes","readKeyframes","KeyframeResolver","unresolvedKeyframes","onComplete","motionValue","isAsync","scheduleResolve","currentValue","valueAsRead","readValue","setFinalKeyframe","renderEndStyles","resume","isColorString","testProp","isNullish","splitColor","aName","bName","cName","rgbUnit","clampRgbUnit","rgba","red","green","blue","alpha$1","hex","parseInt","hsla","hue","saturation","lightness","color","NUMBER_TOKEN","COLOR_TOKEN","VAR_TOKEN","VAR_FUNCTION_TOKEN","SPLIT_TOKEN","complexRegex","analyseComplexValue","originalValue","indexes","var","types","parsedValue","parseComplexValue","createTransformer","numSections","output","convertNumbersToZero","complex","_b","isNaN","getAnimatableNone","parsed","transformer","maxDefaults","applyDefaultFilter","functionRegex","functions","defaultValueTypes","backgroundColor","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","defaultValueType","invalidTemplates","DOMKeyframesResolver","keyframe","resolveNoneKeyframes","originType","targetType","noneKeyframeIndexes","animatableTemplate","noneIndex","makeNoneKeyframesAnimatable","measuredOrigin","measureViewportBox","measureKeyframe","jump","finalKeyframeIndex","unsetTransformName","unsetTransformValue","memo","clearTime","time","newTime","isAnimatable","BaseAnimation","autoplay","delay","repeatDelay","isStopped","hasAttemptedResolve","createdAt","updateFinishedPromise","calcStartTime","resolvedAt","_resolved","onKeyframesResolved","isGenerator","originKeyframe","targetKeyframe","isOriginAnimatable","isTargetAnimatable","hasKeyframesChanged","canAnimate","resolveFinishedPromise","resolvedAnimation","initPlayback","onPostResolved","then","reject","currentFinishedPromise","velocityPerSecond","frameDuration","velocitySampleDuration","calcGeneratorVelocity","resolveValue","prevT","safeMin","minDuration","maxDuration","minDamping","maxDamping","findSpring","bounce","mass","envelope","derivative","dampingRatio","undampedFreq","exponentialDecay","calcAngularFreq","exp","pow","initialGuess","rootIterations","approximateRoot","durationKeys","physicsKeys","isSpringType","spring","restDelta","done","isResolvedFromDuration","springOptions","derived","getSpringOptions","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","sin","cos","dampedAngularFreq","freqForT","sinh","cosh","calculatedDuration","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","inertia","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","nearestBoundary","amplitude","ideal","calcDelta","calcLatest","applyFriction","timeReachedBoundary","spring$1","checkCatchBoundary","hasUpdatedFrame","calcBezier","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","getTForX","aX","lowerBound","upperBound","currentX","currentT","binarySubdivide","easeIn","easeOut","easeInOut","mirrorEasing","easing","reverseEasing","circIn","acos","circOut","circInOut","backOut","backIn","backInOut","easingLookup","linear","anticipate","easingDefinitionToFunction","x1","y1","x2","y2","progress","to","toFromDifference","mixNumber","hueToRgb","q","mixImmediate","mixLinearColor","fromExpo","expo","colorTypes","asRGBA","model","hslaToRgba","mixColor","fromRGBA","toRGBA","blended","invisibleValues","getMixer","mixComplex","mixArray","mixObject","numValues","blendValue","template","originStats","targetStats","mixVisibility","orderedOrigin","pointers","originIndex","originValue","matchOrder","mixer","interpolate","input","isClamp","inputLength","reverse","mixers","customMixer","mixerFactory","numMixers","easingFunction","createMixers","interpolator","progressInRange","defaultOffset","remaining","offsetProgress","fillOffset","keyframeValues","times","easingFunctions","isEasingArray","absoluteTimes","convertOffsetToTimes","mapTimeToKeyframe","frameloopDriver","passTimestamp","stop","generators","decay","tween","percentToProgress","MainThreadAnimation","holdTime","cancelTime","currentTime","playbackSpeed","pendingPlayState","startTime","teardown","onStop","KeyframeResolver$1","keyframes$1","generatorFactory","mapPercentToKeyframes","mirroredGenerator","generator","Infinity","calcGeneratorDuration","resolvedDuration","totalDuration","play","pause","tick","sample","speed","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","currentIteration","floor","iterationProgress","isAnimationFinished","finish","driver","newSpeed","hasChanged","onPlay","stopDriver","isBezierDefinition","isWaapiSupportedEasing","supportedWaapiEasing","every","cubicBezierAsString","mapEasingToNativeEasingWithDefault","mapEasingToNativeEasing","supportsWaapi","Element","AcceleratedAnimation","owner","pregeneratedAnimation","sampleAnimation","pregeneratedKeyframes","pregenerateKeyframes","valueName","keyframeOptions","iterations","direction","animateStyle","pendingTimeline","timeline","onfinish","playbackRate","playState","attachTimeline","sampleTime","setWithVelocity","supports","supportsScrollTimeline","ScrollTimeline","GroupPlaybackControls","animations","runAll","onResolve","onReject","catch","getAll","propName","setAll","newValue","cancelAll","prevProgress","onFrame","observeTimeline","cancelTimeline","methodName","controls","animateMotionValue","isHandoff","onEnd","valueTransition","when","_delay","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","shouldSkip","SubscriptionManager","subscriptions","notify","numSubscriptions","getSize","collectMotionValues","MotionValue","init","version","canTrackVelocity","events","updateAndNotify","updatedAt","setPrevFrameValue","setCurrent","renderRequest","hasAnimated","prevFrameValue","prevUpdatedAt","subscription","on","unsubscribe","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","endAnimation","getPrevious","startAnimation","animationStart","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","setMotionValue","hasValue","addValue","getOptimisedAppearId","WillChangeMotionValue","counts","styleName","prevCount","hasRemoved","newCount","addValueToWillChange","shouldBlockAnimation","protectedKeys","needsAnimating","shouldBlock","animateTarget","targetAndTransition","transitionOverride","animationTypeState","MotionHandoffAnimation","appearId","shouldReduceMotion","setTarget","animateVariant","variant","getAnimation","getChildAnimations","variantChildren","forwardDelay","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","animateChildren","first","last","sortNodePosition","reversePriorityOrder","numAnimationTypes","animateList","resolvedDefinition","animateVisualElement","checkVariantsDidChange","createTypeState","prevResolvedValues","createState","whileInView","whileDrag","whileFocus","buildResolvedTypeValues","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","shouldAnimateType","handledRemovedValues","definitionList","resolvedValues","allKeys","markToAnimate","valueHasChanged","fallbackAnimation","fallbackTarget","getBaseTarget","shouldAnimate","setAnimateFunction","makeAnimator","reset","createAnimationState","updateAnimationControlsSubscription","unmountControls","prevAnimate","prevIsPresent","prevPresenceContext","exitAnimation","PanSession","handlers","contextWindow","dragSnapToOrigin","lastMoveEvent","lastMoveEventInfo","updatePoint","getPanInfo","history","isPanStarted","isDistancePastThreshold","xDelta","yDelta","distance2D","onStart","onMove","handlePointerMove","transformPoint","handlePointerUp","end","onSessionEnd","resumeAnimation","panInfo","initialInfo","onSessionStart","removeListeners","updateHandlers","subtractPoint","lastDevicePoint","startDevicePoint","timeDelta","timestampedPoint","lastPoint","SCALE_MIN","SCALE_MAX","TRANSLATE_MIN","TRANSLATE_MAX","calcLength","axis","calcAxisDelta","originPoint","translate","calcBoxDelta","calcRelativeAxis","relative","calcRelativeAxisPosition","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createDelta","createBox","eachAxis","convertBoundingBoxToBox","isIdentityScale","hasScale","has2DTranslate","is2DTranslate","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","TREE_SCALE_SNAP_MIN","TREE_SCALE_SNAP_MAX","translateAxis","transformAxis","axisTranslate","axisScale","axisOrigin","transformBox","topLeft","bottomRight","transformBoxPoints","getContextWindow","elementDragControls","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","snapToCursor","panSession","pauseAnimation","stopAnimation","dragPropagation","onDragStart","resolveConstraints","isAnimationBlocked","getAxisMotionValue","measuredAxis","layoutBox","removeWillChange","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","getCurrentDirection","updateAxis","getAnimationState","getTransformPagePoint","onDragEnd","_point","shouldDrag","axisValue","applyConstraints","measure","prevConstraints","resolveRefConstraints","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","scroll","measurePageBox","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","onDragTransitionEnd","momentumAnimations","startAxisValueAnimation","dragKey","externalMotionValue","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","updateScroll","updateLayout","addListeners","stopPointerListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","stopLayoutUpdateListener","hasLayoutChanged","asyncHandler","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","pixelsToPercent","pixels","correctBorderRadius","correct","correctBoxShadow","treeScale","projectionDelta","original","shadow","xScale","yScale","averageScale","MeasureLayoutWithContext","componentDidMount","layoutGroup","switchLayoutGroup","correctors","defaultScaleCorrectors","group","didUpdate","safeToRemove","layoutDependency","willUpdate","promote","relegate","getStack","members","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","usePresence","applyTo","boxShadow","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","copyAxisInto","originAxis","copyBoxInto","originBox","copyAxisDeltaInto","originDelta","removePointDelta","removeAxisTransforms","transforms","scaleKey","originKey","sourceAxis","removeAxisDelta","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","axisEquals","axisEqualsRounded","boxEqualsRounded","aspectRatio","axisDeltaEquals","NodeStack","scheduleRender","prevLead","lead","indexOfNode","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","compareByDepth","FlatTree","isDirty","metrics","totalNodes","resolvedTargetDeltas","recalculatedProjection","isDebug","MotionDebug","transformAxes","hiddenVisibility","visibility","resetDistortingTransform","sharedAnimationValues","setStaticValue","cancelTreeOptimisedTransformAnimations","projectionNode","hasCheckedOptimisedAppear","MotionHasOptimisedTransformAnimation","MotionCancelOptimisedTransform","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","animationId","isTreeAnimating","isProjectionDirty","isSharedProjectionDirty","isTransformDirty","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","hasTreeAnimated","updateScheduled","scheduleUpdate","projectionUpdateScheduled","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","propagateDirtyNodes","resolveTargetDelta","calcProjection","cleanDirtyNodes","record","resolvedRelativeTargetAt","hasProjected","isVisible","animationProgress","sharedNodes","path","notifyListeners","subscriptionManager","hasListeners","SVGElement","cancelDelay","resizeUnblockUpdate","timeout","checkElapsed","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetSkewAndRotation","getTransformTemplate","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","clearIsLayoutDirty","resetTransformStyle","notifyLayoutUpdate","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","prevLayout","layoutCorrected","phase","isRoot","wasRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","removeTransform","pageBox","removeElementScroll","roundAxis","measuredBox","checkNodeWasScrollRoot","boxWithoutScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","forceRelativeParentToResolveTarget","relativeParent","forceRecalculation","getLead","isShared","attemptToResolveRelativeTarget","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","isProjecting","canSkip","pendingAnimation","prevTreeScaleX","prevTreeScaleY","treePath","isSharedTransition","treeLength","display","applyTreeDeltas","prevProjectionDelta","createProjectionDeltas","notifyAll","projectionDeltaWithTransform","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","prevRelativeTarget","mixTargetDelta","mixAxisDelta","mixAxis","boxEquals","follow","opacityExit","borderLabel","followRadius","leadRadius","mixValues","motionValue$1","animateSingleValue","completeAnimation","applyTransformsToTarget","shouldAnimatePositionOnly","xLength","yLength","shouldPreserveFollowOpacity","getPrevLead","hasDistortingTransform","resetValues","styles","pointerEvents","emptyStyles","valuesToRender","latestTransform","xTranslate","yTranslate","zTranslate","elementScaleX","elementScaleY","buildProjectionTransform","corrected","num","resetTree","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","userAgentContains","string","userAgent","roundPoint","maxDistance","DocumentProjectionNode","scrollLeft","scrollTop","HTMLProjectionNode","documentNode","position","removePointerDownListener","onPointerDown","pointerDownEvent","session","createPanHandlers","onPanSessionStart","onPanStart","onPan","onPanEnd","removeGroupControls","dragControls","prefersReducedMotion","hasReducedMotionListener","visualElementStore","valueTypes","propEventHandlers","numVariantProps","VisualElement","_props","_prevProps","_visualElement","valueSubscriptions","prevMotionValues","propEventSubscriptions","notifyUpdate","isRenderScheduled","triggerBuild","renderInstance","baseTarget","initialValues","initialMotionValues","removeFromVariantTree","addVariantChild","bindToMotionValue","matchMedia","motionMediaQuery","setReducedMotionPreferences","addListener","initPrefersReducedMotion","feature","valueIsTransform","removeOnChange","latestValue","removeOnRenderRequest","other","sortInstanceNodePosition","featureDefinition","FeatureConstructor","build","measureInstanceViewportBox","getStaticValue","listener","nextValue","prevValue","existingValue","removeValue","updateMotionValuesFromProps","handleChildMotionValue","getVariant","getClosestVariantNode","startAtParent","closestVariantNode","removeValueFromRenderState","getBaseTargetFromProps","readValueFromInstance","setBaseTarget","valueFromInitial","DOMVisualElement","compareDocumentPosition","HTMLVisualElement","defaultType","computedStyle","childSubscription","textContent","SVGVisualElement","motion","warning","invariant","isBrowser","any","useConstant","useIsomorphicLayoutEffect"],"sourceRoot":""}