{"version":3,"file":"static/chunks/765-b2d96677e7dab8f0.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@algolia/events/events.js","webpack://_N_E/./node_modules/react-fast-compare/index.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/index.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/DerivedHelper/index.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/SearchParameters/RefinementList.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/SearchParameters/index.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/SearchResults/generate-hierarchical-tree.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/SearchResults/index.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/algoliasearch.helper.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/compact.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/defaultsPure.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/escapeFacetValue.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/find.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/findIndex.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/formatSort.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/inherits.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/intersection.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/merge.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/objectHasKeys.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/omit.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/orderBy.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/functions/valToNumber.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/requestBuilder.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/utils/isValidUserToken.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/algoliasearch-helper/src/version.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/connectors/connectSearchBox.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/connectors/connectStateResults.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/context.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/createConnector.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/indexUtils.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/utils.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/connectors/connectConfigure.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/widgets/Configure.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/widgets/Index.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/highlight.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/createInstantSearchManager.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/version.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/createWidgetsManager.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/createStore.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/core/metadata.js","webpack://_N_E/./node_modules/react-instantsearch-dom/node_modules/react-instantsearch-core/dist/es/widgets/InstantSearch.js","webpack://_N_E/./node_modules/react-spinners/esm/ClipLoader.js","webpack://_N_E/./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/GlobalConfig.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/frameloop/batcher.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/frameloop/render-step.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/frameloop/microtask.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-ref-object.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/is-variant-label.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/variant-props.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/definitions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/utils/symbol.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/load-features.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/motion-proxy.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/clamp.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/numbers/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/utils.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/numbers/units.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/use-props.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/use-props.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/use-render.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/resolve-variants.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/resolve-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/use-will-change/get-will-change-name.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/noop.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/frameloop/frame.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/config-motion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/events/add-dom-event.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/events/utils/is-primary-pointer.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/events/add-pointer-event.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/pipe.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/Feature.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/hover.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/press.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/focus.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/errors.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/utils.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/rgba.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/hex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/hsla.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/complex/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-none.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/memo.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/frameloop/sync-time.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/inertia.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/ease.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/circ.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/back.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/map.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/anticipate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/progress.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/number.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/immediate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/color.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/visibility.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/complex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/interpolate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/default.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/fill.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/time.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/easing.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/scroll/supports.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/GroupPlaybackControls.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/scroll/observe.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/use-will-change/WillChangeMotionValue.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/animation/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/distance.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/pan/PanSession.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/get-context-window.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/pan/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/node/state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-element.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/delay.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/single-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/drag/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/store.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/VisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/motion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/layout.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs"],"sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\n// EventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener))\n      return 1;\n    else if (evlistener)\n      return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */\n\nvar hasElementType = typeof Element !== 'undefined';\nvar hasMap = typeof Map === 'function';\nvar hasSet = typeof Set === 'function';\nvar hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView;\n\n// Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js\n\nfunction equal(a, b) {\n  // START: fast-deep-equal es6/index.js 3.1.3\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    // START: Modifications:\n    // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code\n    //    to co-exist with es5.\n    // 2. Replace `for of` with es5 compliant iteration using `for`.\n    //    Basically, take:\n    //\n    //    ```js\n    //    for (i of a.entries())\n    //      if (!b.has(i[0])) return false;\n    //    ```\n    //\n    //    ... and convert to:\n    //\n    //    ```js\n    //    it = a.entries();\n    //    while (!(i = it.next()).done)\n    //      if (!b.has(i.value[0])) return false;\n    //    ```\n    //\n    //    **Note**: `i` access switches to `i.value`.\n    var it;\n    if (hasMap && (a instanceof Map) && (b instanceof Map)) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      while (!(i = it.next()).done)\n        if (!b.has(i.value[0])) return false;\n      it = a.entries();\n      while (!(i = it.next()).done)\n        if (!equal(i.value[1], b.get(i.value[0]))) return false;\n      return true;\n    }\n\n    if (hasSet && (a instanceof Set) && (b instanceof Set)) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      while (!(i = it.next()).done)\n        if (!b.has(i.value[0])) return false;\n      return true;\n    }\n    // END: Modifications\n\n    if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    // START: Modifications:\n    // Apply guards for `Object.create(null)` handling. See:\n    // - https://github.com/FormidableLabs/react-fast-compare/issues/64\n    // - https://github.com/epoberezkin/fast-deep-equal/issues/49\n    if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString && typeof a.toString === 'function' && typeof b.toString === 'function') return a.toString() === b.toString();\n    // END: Modifications\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    // END: fast-deep-equal\n\n    // START: react-fast-compare\n    // custom handling for DOM elements\n    if (hasElementType && a instanceof Element) return false;\n\n    // custom handling for React/Preact\n    for (i = length; i-- !== 0;) {\n      if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner\n        // Preact-specific: avoid traversing Preact elements' __v and __o\n        //    __v = $_original / $_vnode\n        //    __o = $_owner\n        // These properties contain circular references and are not needed when\n        // comparing the actual elements (and not their owners)\n        // .$$typeof and ._store on just reasonable markers of elements\n\n        continue;\n      }\n\n      // all other properties should be traversed as usual\n      if (!equal(a[keys[i]], b[keys[i]])) return false;\n    }\n    // END: react-fast-compare\n\n    // START: fast-deep-equal\n    return true;\n  }\n\n  return a !== a && b !== b;\n}\n// end fast-deep-equal\n\nmodule.exports = function isEqual(a, b) {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if (((error.message || '').match(/stack|recursion/i))) {\n      // warn on circular references, don't crash\n      // browsers give this different errors name and messages:\n      // chrome/safari: \"RangeError\", \"Maximum call stack size exceeded\"\n      // firefox: \"InternalError\", too much recursion\"\n      // edge: \"Error\", \"Out of stack space\"\n      console.warn('react-fast-compare cannot handle circular refs');\n      return false;\n    }\n    // some other error. we should definitely know about these\n    throw error;\n  }\n};\n","'use strict';\n\nvar AlgoliaSearchHelper = require('./src/algoliasearch.helper');\nvar SearchParameters = require('./src/SearchParameters');\nvar SearchResults = require('./src/SearchResults');\n\n/**\n * The algoliasearchHelper module is the function that will let its\n * contains everything needed to use the Algoliasearch\n * Helper. It is a also a function that instanciate the helper.\n * To use the helper, you also need the Algolia JS client v3.\n * @example\n * //using the UMD build\n * var client = algoliasearch('latency', '6be0576ff61c053d5f9a3225e2a90f76');\n * var helper = algoliasearchHelper(client, 'bestbuy', {\n *   facets: ['shipping'],\n *   disjunctiveFacets: ['category']\n * });\n * helper.on('result', function(event) {\n *   console.log(event.results);\n * });\n * helper\n *   .toggleFacetRefinement('category', 'Movies & TV Shows')\n *   .toggleFacetRefinement('shipping', 'Free shipping')\n *   .search();\n * @example\n * // The helper is an event emitter using the node API\n * helper.on('result', updateTheResults);\n * helper.once('result', updateTheResults);\n * helper.removeListener('result', updateTheResults);\n * helper.removeAllListeners('result');\n * @module algoliasearchHelper\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the name of the index to query\n * @param  {SearchParameters|object} opts an object defining the initial config of the search. It doesn't have to be a {SearchParameters}, just an object containing the properties you need from it.\n * @return {AlgoliaSearchHelper} The helper instance\n */\nfunction algoliasearchHelper(client, index, opts) {\n  return new AlgoliaSearchHelper(client, index, opts);\n}\n\n/**\n * The version currently used\n * @member module:algoliasearchHelper.version\n * @type {number}\n */\nalgoliasearchHelper.version = require('./src/version');\n\n/**\n * Constructor for the Helper.\n * @member module:algoliasearchHelper.AlgoliaSearchHelper\n * @type {AlgoliaSearchHelper}\n */\nalgoliasearchHelper.AlgoliaSearchHelper = AlgoliaSearchHelper;\n\n/**\n * Constructor for the object containing all the parameters of the search.\n * @member module:algoliasearchHelper.SearchParameters\n * @type {SearchParameters}\n */\nalgoliasearchHelper.SearchParameters = SearchParameters;\n\n/**\n * Constructor for the object containing the results of the search.\n * @member module:algoliasearchHelper.SearchResults\n * @type {SearchResults}\n */\nalgoliasearchHelper.SearchResults = SearchResults;\n\nmodule.exports = algoliasearchHelper;\n","'use strict';\n\nvar EventEmitter = require('@algolia/events');\n\nvar inherits = require('../functions/inherits');\n\n/**\n * A DerivedHelper is a way to create sub requests to\n * Algolia from a main helper.\n * @class\n * @classdesc The DerivedHelper provides an event based interface for search callbacks:\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n * @param {AlgoliaSearchHelper} mainHelper the main helper\n * @param {function} fn the function to create the derived state\n */\nfunction DerivedHelper(mainHelper, fn) {\n  this.main = mainHelper;\n  this.fn = fn;\n  this.lastResults = null;\n}\n\ninherits(DerivedHelper, EventEmitter);\n\n/**\n * Detach this helper from the main helper\n * @return {undefined}\n * @throws Error if the derived helper is already detached\n */\nDerivedHelper.prototype.detach = function () {\n  this.removeAllListeners();\n  this.main.detachDerivedHelper(this);\n};\n\nDerivedHelper.prototype.getModifiedState = function (parameters) {\n  return this.fn(parameters);\n};\n\nmodule.exports = DerivedHelper;\n","'use strict';\n\n/**\n * Functions to manipulate refinement lists\n *\n * The RefinementList is not formally defined through a prototype but is based\n * on a specific structure.\n *\n * @module SearchParameters.refinementList\n *\n * @typedef {string[]} SearchParameters.refinementList.Refinements\n * @typedef {Object.<string, SearchParameters.refinementList.Refinements>} SearchParameters.refinementList.RefinementList\n */\n\nvar defaultsPure = require('../functions/defaultsPure');\nvar objectHasKeys = require('../functions/objectHasKeys');\nvar omit = require('../functions/omit');\n\nvar lib = {\n  /**\n   * Adds a refinement to a RefinementList\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement, if the value is not a string it will be converted\n   * @return {RefinementList} a new and updated refinement list\n   */\n  addRefinement: function addRefinement(refinementList, attribute, value) {\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return refinementList;\n    }\n\n    var valueAsString = '' + value;\n\n    var facetRefinement = !refinementList[attribute]\n      ? [valueAsString]\n      : refinementList[attribute].concat(valueAsString);\n\n    var mod = {};\n\n    mod[attribute] = facetRefinement;\n\n    return defaultsPure({}, mod, refinementList);\n  },\n  /**\n   * Removes refinement(s) for an attribute:\n   *  - if the value is specified removes the refinement for the value on the attribute\n   *  - if no value is specified removes all the refinements for this attribute\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} [value] the value of the refinement\n   * @return {RefinementList} a new and updated refinement lst\n   */\n  removeRefinement: function removeRefinement(\n    refinementList,\n    attribute,\n    value\n  ) {\n    if (value === undefined) {\n      // we use the \"filter\" form of clearRefinement, since it leaves empty values as-is\n      // the form with a string will remove the attribute completely\n      return lib.clearRefinement(refinementList, function (v, f) {\n        return attribute === f;\n      });\n    }\n\n    var valueAsString = '' + value;\n\n    return lib.clearRefinement(refinementList, function (v, f) {\n      return attribute === f && valueAsString === v;\n    });\n  },\n  /**\n   * Toggles the refinement value for an attribute.\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement\n   * @return {RefinementList} a new and updated list\n   */\n  toggleRefinement: function toggleRefinement(\n    refinementList,\n    attribute,\n    value\n  ) {\n    if (value === undefined)\n      throw new Error('toggleRefinement should be used with a value');\n\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return lib.removeRefinement(refinementList, attribute, value);\n    }\n\n    return lib.addRefinement(refinementList, attribute, value);\n  },\n  /**\n   * Clear all or parts of a RefinementList. Depending on the arguments, three\n   * kinds of behavior can happen:\n   *  - if no attribute is provided: clears the whole list\n   *  - if an attribute is provided as a string: clears the list for the specific attribute\n   *  - if an attribute is provided as a function: discards the elements for which the function returns true\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} [attribute] the attribute or function to discard\n   * @param {string} [refinementType] optional parameter to give more context to the attribute function\n   * @return {RefinementList} a new and updated refinement list\n   */\n  clearRefinement: function clearRefinement(\n    refinementList,\n    attribute,\n    refinementType\n  ) {\n    if (attribute === undefined) {\n      // return the same object if the list is already empty\n      // this is mainly for tests, as it doesn't have much impact on performance\n      if (!objectHasKeys(refinementList)) {\n        return refinementList;\n      }\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(refinementList, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n\n      var newRefinementList = Object.keys(refinementList).reduce(function (\n        memo,\n        key\n      ) {\n        var values = refinementList[key] || [];\n        var facetList = values.filter(function (value) {\n          return !attribute(value, key, refinementType);\n        });\n\n        if (facetList.length !== values.length) {\n          hasChanged = true;\n        }\n\n        memo[key] = facetList;\n\n        return memo;\n      },\n      {});\n\n      if (hasChanged) return newRefinementList;\n      return refinementList;\n    }\n\n    // We return nothing if the attribute is not undefined, a string or a function,\n    // as it is not a valid value for a refinement\n    return undefined;\n  },\n  /**\n   * Test if the refinement value is used for the attribute. If no refinement value\n   * is provided, test if the refinementList contains any refinement for the\n   * given attribute.\n   * @param {RefinementList} refinementList the list of refinement\n   * @param {string} attribute name of the attribute\n   * @param {string} [refinementValue] value of the filter/refinement\n   * @return {boolean} true if the attribute is refined, false otherwise\n   */\n  isRefined: function isRefined(refinementList, attribute, refinementValue) {\n    var containsRefinements =\n      Boolean(refinementList[attribute]) &&\n      refinementList[attribute].length > 0;\n\n    if (refinementValue === undefined || !containsRefinements) {\n      return containsRefinements;\n    }\n\n    var refinementValueAsString = '' + refinementValue;\n\n    return refinementList[attribute].indexOf(refinementValueAsString) !== -1;\n  },\n};\n\nmodule.exports = lib;\n","'use strict';\n\nvar defaultsPure = require('../functions/defaultsPure');\nvar find = require('../functions/find');\nvar intersection = require('../functions/intersection');\nvar merge = require('../functions/merge');\nvar objectHasKeys = require('../functions/objectHasKeys');\nvar omit = require('../functions/omit');\nvar valToNumber = require('../functions/valToNumber');\nvar isValidUserToken = require('../utils/isValidUserToken');\n\nvar RefinementList = require('./RefinementList');\n\n/**\n * isEqual, but only for numeric refinement values, possible values:\n * - 5\n * - [5]\n * - [[5]]\n * - [[5,5],[4]]\n * @param {any} a numeric refinement value\n * @param {any} b numeric refinement value\n * @return {boolean} true if the values are equal\n */\nfunction isEqualNumericRefinement(a, b) {\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return (\n      a.length === b.length &&\n      a.every(function (el, i) {\n        return isEqualNumericRefinement(b[i], el);\n      })\n    );\n  }\n  return a === b;\n}\n\n/**\n * like _.find but using deep equality to be able to use it\n * to find arrays.\n * @private\n * @param {any[]} array array to search into (elements are base or array of base)\n * @param {any} searchedValue the value we're looking for (base or array of base)\n * @return {any} the searched value or undefined\n */\nfunction findArray(array, searchedValue) {\n  return find(array, function (currentValue) {\n    return isEqualNumericRefinement(currentValue, searchedValue);\n  });\n}\n\n/**\n * The facet list is the structure used to store the list of values used to\n * filter a single attribute.\n * @typedef {string[]} SearchParameters.FacetList\n */\n\n/**\n * Structure to store numeric filters with the operator as the key. The supported operators\n * are `=`, `>`, `<`, `>=`, `<=` and `!=`.\n * @typedef {Object.<string, Array.<number|number[]>>} SearchParameters.OperatorList\n */\n\n/**\n * SearchParameters is the data structure that contains all the information\n * usable for making a search to Algolia API. It doesn't do the search itself,\n * nor does it contains logic about the parameters.\n * It is an immutable object, therefore it has been created in a way that each\n * changes does not change the object itself but returns a copy with the\n * modification.\n * This object should probably not be instantiated outside of the helper. It will\n * be provided when needed. This object is documented for reference as you'll\n * get it from events generated by the {@link AlgoliaSearchHelper}.\n * If need be, instantiate the Helper from the factory function {@link SearchParameters.make}\n * @constructor\n * @classdesc contains all the parameters of a search\n * @param {object|SearchParameters} newParameters existing parameters or partial object\n * for the properties of a new SearchParameters\n * @see SearchParameters.make\n * @example <caption>SearchParameters of the first query in\n *   <a href=\"http://demos.algolia.com/instant-search-demo/\">the instant search demo</a></caption>\n{\n   \"query\": \"\",\n   \"disjunctiveFacets\": [\n      \"customerReviewCount\",\n      \"category\",\n      \"salePrice_range\",\n      \"manufacturer\"\n  ],\n   \"maxValuesPerFacet\": 30,\n   \"page\": 0,\n   \"hitsPerPage\": 10,\n   \"facets\": [\n      \"type\",\n      \"shipping\"\n  ]\n}\n */\nfunction SearchParameters(newParameters) {\n  var params = newParameters\n    ? SearchParameters._parseNumbers(newParameters)\n    : {};\n\n  if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      '[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\\n  - Format: [a-zA-Z0-9_-]{1,64}'\n    );\n  }\n  /**\n   * This attribute contains the list of all the conjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n  this.facets = params.facets || [];\n  /**\n   * This attribute contains the list of all the disjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n  this.disjunctiveFacets = params.disjunctiveFacets || [];\n  /**\n   * This attribute contains the list of all the hierarchical facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * Hierarchical facets are a sub type of disjunctive facets that\n   * let you filter faceted attributes hierarchically.\n   * @member {string[]|object[]}\n   */\n  this.hierarchicalFacets = params.hierarchicalFacets || [];\n\n  // Refinements\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.facetsRefinements = params.facetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * excluded from the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters excluded for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.facetsExcludes = params.facetsExcludes || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the disjunctive facets. Each facet must be properly\n   * defined in the `disjunctiveFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.disjunctiveFacetsRefinements = params.disjunctiveFacetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the numeric attributes.\n   *\n   * The key is the name of the attribute, and the value is the\n   * filters to apply to this attribute.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `numericFilters` attribute.\n   * @member {Object.<string, SearchParameters.OperatorList>}\n   */\n  this.numericRefinements = params.numericRefinements || {};\n  /**\n   * This attribute contains all the tags used to refine the query.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `tagFilters` attribute.\n   * @member {string[]}\n   */\n  this.tagRefinements = params.tagRefinements || [];\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the hierarchical facets. Each facet must be properly\n   * defined in the `hierarchicalFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name. The FacetList values\n   * are structured as a string that contain the values for each level\n   * separated by the configured separator.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n  this.hierarchicalFacetsRefinements =\n    params.hierarchicalFacetsRefinements || {};\n\n  // eslint-disable-next-line consistent-this\n  var self = this;\n  Object.keys(params).forEach(function (paramName) {\n    var isKeyKnown = SearchParameters.PARAMETERS.indexOf(paramName) !== -1;\n    var isValueDefined = params[paramName] !== undefined;\n\n    if (!isKeyKnown && isValueDefined) {\n      self[paramName] = params[paramName];\n    }\n  });\n}\n\n/**\n * List all the properties in SearchParameters and therefore all the known Algolia properties\n * This doesn't contain any beta/hidden features.\n * @private\n */\nSearchParameters.PARAMETERS = Object.keys(new SearchParameters());\n\n/**\n * @private\n * @param {object} partialState full or part of a state\n * @return {object} a new object with the number keys as number\n */\nSearchParameters._parseNumbers = function (partialState) {\n  // Do not parse numbers again in SearchParameters, they ought to be parsed already\n  if (partialState instanceof SearchParameters) return partialState;\n\n  var numbers = {};\n\n  var numberKeys = [\n    'aroundPrecision',\n    'aroundRadius',\n    'getRankingInfo',\n    'minWordSizefor2Typos',\n    'minWordSizefor1Typo',\n    'page',\n    'maxValuesPerFacet',\n    'distinct',\n    'minimumAroundRadius',\n    'hitsPerPage',\n    'minProximity',\n  ];\n\n  numberKeys.forEach(function (k) {\n    var value = partialState[k];\n    if (typeof value === 'string') {\n      var parsedValue = parseFloat(value);\n      // global isNaN is ok to use here, value is only number or NaN\n      numbers[k] = isNaN(parsedValue) ? value : parsedValue;\n    }\n  });\n\n  // there's two formats of insideBoundingBox, we need to parse\n  // the one which is an array of float geo rectangles\n  if (Array.isArray(partialState.insideBoundingBox)) {\n    numbers.insideBoundingBox = partialState.insideBoundingBox.map(function (\n      geoRect\n    ) {\n      if (Array.isArray(geoRect)) {\n        return geoRect.map(function (value) {\n          return parseFloat(value);\n        });\n      }\n      return geoRect;\n    });\n  }\n\n  if (partialState.numericRefinements) {\n    var numericRefinements = {};\n    Object.keys(partialState.numericRefinements).forEach(function (attribute) {\n      var operators = partialState.numericRefinements[attribute] || {};\n      numericRefinements[attribute] = {};\n      Object.keys(operators).forEach(function (operator) {\n        var values = operators[operator];\n        var parsedValues = values.map(function (v) {\n          if (Array.isArray(v)) {\n            return v.map(function (vPrime) {\n              if (typeof vPrime === 'string') {\n                return parseFloat(vPrime);\n              }\n              return vPrime;\n            });\n          } else if (typeof v === 'string') {\n            return parseFloat(v);\n          }\n          return v;\n        });\n        numericRefinements[attribute][operator] = parsedValues;\n      });\n    });\n    numbers.numericRefinements = numericRefinements;\n  }\n\n  return merge({}, partialState, numbers);\n};\n\n/**\n * Factory for SearchParameters\n * @param {object|SearchParameters} newParameters existing parameters or partial\n * object for the properties of a new SearchParameters\n * @return {SearchParameters} frozen instance of SearchParameters\n */\nSearchParameters.make = function makeSearchParameters(newParameters) {\n  var instance = new SearchParameters(newParameters);\n\n  var hierarchicalFacets = newParameters.hierarchicalFacets || [];\n  hierarchicalFacets.forEach(function (facet) {\n    if (facet.rootPath) {\n      var currentRefinement = instance.getHierarchicalRefinement(facet.name);\n\n      if (\n        currentRefinement.length > 0 &&\n        currentRefinement[0].indexOf(facet.rootPath) !== 0\n      ) {\n        instance = instance.clearRefinements(facet.name);\n      }\n\n      // get it again in case it has been cleared\n      currentRefinement = instance.getHierarchicalRefinement(facet.name);\n      if (currentRefinement.length === 0) {\n        instance = instance.toggleHierarchicalFacetRefinement(\n          facet.name,\n          facet.rootPath\n        );\n      }\n    }\n  });\n\n  return instance;\n};\n\n/**\n * Validates the new parameters based on the previous state\n * @param {SearchParameters} currentState the current state\n * @param {object|SearchParameters} parameters the new parameters to set\n * @return {Error|null} Error if the modification is invalid, null otherwise\n */\nSearchParameters.validate = function (currentState, parameters) {\n  var params = parameters || {};\n\n  if (\n    currentState.tagFilters &&\n    params.tagRefinements &&\n    params.tagRefinements.length > 0\n  ) {\n    return new Error(\n      '[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' +\n        'an error, if it is really what you want, you should first clear the tags with clearTags method.'\n    );\n  }\n\n  if (currentState.tagRefinements.length > 0 && params.tagFilters) {\n    return new Error(\n      '[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' +\n        'an error, if it is not, you should first clear the tags with clearTags method.'\n    );\n  }\n\n  if (\n    currentState.numericFilters &&\n    params.numericRefinements &&\n    objectHasKeys(params.numericRefinements)\n  ) {\n    return new Error(\n      \"[Numeric filters] Can't switch from the advanced to the managed API. It\" +\n        ' is probably an error, if this is really what you want, you have to first' +\n        ' clear the numeric filters.'\n    );\n  }\n\n  if (objectHasKeys(currentState.numericRefinements) && params.numericFilters) {\n    return new Error(\n      \"[Numeric filters] Can't switch from the managed API to the advanced. It\" +\n        ' is probably an error, if this is really what you want, you have to first' +\n        ' clear the numeric filters.'\n    );\n  }\n\n  return null;\n};\n\nSearchParameters.prototype = {\n  constructor: SearchParameters,\n\n  /**\n   * Remove all refinements (disjunctive + conjunctive + excludes + numeric filters)\n   * @method\n   * @param {undefined|string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {SearchParameters} new instance with filters cleared\n   */\n  clearRefinements: function clearRefinements(attribute) {\n    var patch = {\n      numericRefinements: this._clearNumericRefinements(attribute),\n      facetsRefinements: RefinementList.clearRefinement(\n        this.facetsRefinements,\n        attribute,\n        'conjunctiveFacet'\n      ),\n      facetsExcludes: RefinementList.clearRefinement(\n        this.facetsExcludes,\n        attribute,\n        'exclude'\n      ),\n      disjunctiveFacetsRefinements: RefinementList.clearRefinement(\n        this.disjunctiveFacetsRefinements,\n        attribute,\n        'disjunctiveFacet'\n      ),\n      hierarchicalFacetsRefinements: RefinementList.clearRefinement(\n        this.hierarchicalFacetsRefinements,\n        attribute,\n        'hierarchicalFacet'\n      ),\n    };\n    if (\n      patch.numericRefinements === this.numericRefinements &&\n      patch.facetsRefinements === this.facetsRefinements &&\n      patch.facetsExcludes === this.facetsExcludes &&\n      patch.disjunctiveFacetsRefinements ===\n        this.disjunctiveFacetsRefinements &&\n      patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements\n    ) {\n      return this;\n    }\n    return this.setQueryParameters(patch);\n  },\n  /**\n   * Remove all the refined tags from the SearchParameters\n   * @method\n   * @return {SearchParameters} new instance with tags cleared\n   */\n  clearTags: function clearTags() {\n    if (this.tagFilters === undefined && this.tagRefinements.length === 0)\n      return this;\n\n    return this.setQueryParameters({\n      tagFilters: undefined,\n      tagRefinements: [],\n    });\n  },\n  /**\n   * Set the index.\n   * @method\n   * @param {string} index the index name\n   * @return {SearchParameters} new instance\n   */\n  setIndex: function setIndex(index) {\n    if (index === this.index) return this;\n\n    return this.setQueryParameters({\n      index: index,\n    });\n  },\n  /**\n   * Query setter\n   * @method\n   * @param {string} newQuery value for the new query\n   * @return {SearchParameters} new instance\n   */\n  setQuery: function setQuery(newQuery) {\n    if (newQuery === this.query) return this;\n\n    return this.setQueryParameters({\n      query: newQuery,\n    });\n  },\n  /**\n   * Page setter\n   * @method\n   * @param {number} newPage new page number\n   * @return {SearchParameters} new instance\n   */\n  setPage: function setPage(newPage) {\n    if (newPage === this.page) return this;\n\n    return this.setQueryParameters({\n      page: newPage,\n    });\n  },\n  /**\n   * Facets setter\n   * The facets are the simple facets, used for conjunctive (and) faceting.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for conjunctive faceting\n   * @return {SearchParameters} new instance\n   */\n  setFacets: function setFacets(facets) {\n    return this.setQueryParameters({\n      facets: facets,\n    });\n  },\n  /**\n   * Disjunctive facets setter\n   * Change the list of disjunctive (or) facets the helper chan handle.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for disjunctive faceting\n   * @return {SearchParameters} new instance\n   */\n  setDisjunctiveFacets: function setDisjunctiveFacets(facets) {\n    return this.setQueryParameters({\n      disjunctiveFacets: facets,\n    });\n  },\n  /**\n   * HitsPerPage setter\n   * Hits per page represents the number of hits retrieved for this query\n   * @method\n   * @param {number} n number of hits retrieved per page of results\n   * @return {SearchParameters} new instance\n   */\n  setHitsPerPage: function setHitsPerPage(n) {\n    if (this.hitsPerPage === n) return this;\n\n    return this.setQueryParameters({\n      hitsPerPage: n,\n    });\n  },\n  /**\n   * typoTolerance setter\n   * Set the value of typoTolerance\n   * @method\n   * @param {string} typoTolerance new value of typoTolerance (\"true\", \"false\", \"min\" or \"strict\")\n   * @return {SearchParameters} new instance\n   */\n  setTypoTolerance: function setTypoTolerance(typoTolerance) {\n    if (this.typoTolerance === typoTolerance) return this;\n\n    return this.setQueryParameters({\n      typoTolerance: typoTolerance,\n    });\n  },\n  /**\n   * Add a numeric filter for a given attribute\n   * When value is an array, they are combined with OR\n   * When value is a single value, it will combined with AND\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} operator operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number | number[]} value value of the filter\n   * @return {SearchParameters} new instance\n   * @example\n   * // for price = 50 or 40\n   * state.addNumericRefinement('price', '=', [50, 40]);\n   * @example\n   * // for size = 38 and 40\n   * state.addNumericRefinement('size', '=', 38);\n   * state.addNumericRefinement('size', '=', 40);\n   */\n  addNumericRefinement: function (attribute, operator, value) {\n    var val = valToNumber(value);\n\n    if (this.isNumericRefined(attribute, operator, val)) return this;\n\n    var mod = merge({}, this.numericRefinements);\n\n    mod[attribute] = merge({}, mod[attribute]);\n\n    if (mod[attribute][operator]) {\n      // Array copy\n      mod[attribute][operator] = mod[attribute][operator].slice();\n      // Add the element. Concat can't be used here because value can be an array.\n      mod[attribute][operator].push(val);\n    } else {\n      mod[attribute][operator] = [val];\n    }\n\n    return this.setQueryParameters({\n      numericRefinements: mod,\n    });\n  },\n  /**\n   * Get the list of conjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getConjunctiveRefinements: function (facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n    return this.facetsRefinements[facetName] || [];\n  },\n  /**\n   * Get the list of disjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getDisjunctiveRefinements: function (facetName) {\n    if (!this.isDisjunctiveFacet(facetName)) {\n      return [];\n    }\n    return this.disjunctiveFacetsRefinements[facetName] || [];\n  },\n  /**\n   * Get the list of hierarchical refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getHierarchicalRefinement: function (facetName) {\n    // we send an array but we currently do not support multiple\n    // hierarchicalRefinements for a hierarchicalFacet\n    return this.hierarchicalFacetsRefinements[facetName] || [];\n  },\n  /**\n   * Get the list of exclude refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getExcludeRefinements: function (facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n    return this.facetsExcludes[facetName] || [];\n  },\n\n  /**\n   * Remove all the numeric filter for a given (attribute, operator)\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} [operator] operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number} [number] the value to be removed\n   * @return {SearchParameters} new instance\n   */\n  removeNumericRefinement: function (attribute, operator, number) {\n    var paramValue = number;\n    if (paramValue !== undefined) {\n      if (!this.isNumericRefined(attribute, operator, paramValue)) {\n        return this;\n      }\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function (\n          value,\n          key\n        ) {\n          return (\n            key === attribute &&\n            value.op === operator &&\n            isEqualNumericRefinement(value.val, valToNumber(paramValue))\n          );\n        }),\n      });\n    } else if (operator !== undefined) {\n      if (!this.isNumericRefined(attribute, operator)) return this;\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function (\n          value,\n          key\n        ) {\n          return key === attribute && value.op === operator;\n        }),\n      });\n    }\n\n    if (!this.isNumericRefined(attribute)) return this;\n    return this.setQueryParameters({\n      numericRefinements: this._clearNumericRefinements(function (value, key) {\n        return key === attribute;\n      }),\n    });\n  },\n  /**\n   * Get the list of numeric refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {SearchParameters.OperatorList} list of refinements\n   */\n  getNumericRefinements: function (facetName) {\n    return this.numericRefinements[facetName] || {};\n  },\n  /**\n   * Return the current refinement for the (attribute, operator)\n   * @param {string} attribute attribute in the record\n   * @param {string} operator operator applied on the refined values\n   * @return {Array.<number|number[]>} refined values\n   */\n  getNumericRefinement: function (attribute, operator) {\n    return (\n      this.numericRefinements[attribute] &&\n      this.numericRefinements[attribute][operator]\n    );\n  },\n  /**\n   * Clear numeric filters.\n   * @method\n   * @private\n   * @param {string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {Object.<string, OperatorList>} new numeric refinements\n   */\n  _clearNumericRefinements: function _clearNumericRefinements(attribute) {\n    if (attribute === undefined) {\n      if (!objectHasKeys(this.numericRefinements)) {\n        return this.numericRefinements;\n      }\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(this.numericRefinements, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n      var numericRefinements = this.numericRefinements;\n      var newNumericRefinements = Object.keys(numericRefinements).reduce(\n        function (memo, key) {\n          var operators = numericRefinements[key];\n          var operatorList = {};\n\n          operators = operators || {};\n          Object.keys(operators).forEach(function (operator) {\n            var values = operators[operator] || [];\n            var outValues = [];\n            values.forEach(function (value) {\n              var predicateResult = attribute(\n                { val: value, op: operator },\n                key,\n                'numeric'\n              );\n              if (!predicateResult) outValues.push(value);\n            });\n            if (outValues.length !== values.length) {\n              hasChanged = true;\n            }\n            operatorList[operator] = outValues;\n          });\n\n          memo[key] = operatorList;\n\n          return memo;\n        },\n        {}\n      );\n\n      if (hasChanged) return newNumericRefinements;\n      return this.numericRefinements;\n    }\n\n    // We return nothing if the attribute is not undefined, a string or a function,\n    // as it is not a valid value for a refinement\n    return undefined;\n  },\n  /**\n   * Add a facet to the facets attribute of the helper configuration, if it\n   * isn't already present.\n   * @method\n   * @param {string} facet facet name to add\n   * @return {SearchParameters} new instance\n   */\n  addFacet: function addFacet(facet) {\n    if (this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      facets: this.facets.concat([facet]),\n    });\n  },\n  /**\n   * Add a disjunctive facet to the disjunctiveFacets attribute of the helper\n   * configuration, if it isn't already present.\n   * @method\n   * @param {string} facet disjunctive facet name to add\n   * @return {SearchParameters} new instance\n   */\n  addDisjunctiveFacet: function addDisjunctiveFacet(facet) {\n    if (this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.concat([facet]),\n    });\n  },\n  /**\n   * Add a hierarchical facet to the hierarchicalFacets attribute of the helper\n   * configuration.\n   * @method\n   * @param {object} hierarchicalFacet hierarchical facet to add\n   * @return {SearchParameters} new instance\n   * @throws will throw an error if a hierarchical facet with the same name was already declared\n   */\n  addHierarchicalFacet: function addHierarchicalFacet(hierarchicalFacet) {\n    if (this.isHierarchicalFacet(hierarchicalFacet.name)) {\n      throw new Error(\n        'Cannot declare two hierarchical facets with the same name: `' +\n          hierarchicalFacet.name +\n          '`'\n      );\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet]),\n    });\n  },\n  /**\n   * Add a refinement on a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters} new instance\n   */\n  addFacetRefinement: function addFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the facets attribute of the helper configuration'\n      );\n    }\n    if (RefinementList.isRefined(this.facetsRefinements, facet, value))\n      return this;\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.addRefinement(\n        this.facetsRefinements,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Exclude a value from a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the exclusion on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters} new instance\n   */\n  addExcludeRefinement: function addExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the facets attribute of the helper configuration'\n      );\n    }\n    if (RefinementList.isRefined(this.facetsExcludes, facet, value))\n      return this;\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.addRefinement(\n        this.facetsExcludes,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Adds a refinement on a disjunctive facet.\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters} new instance\n   */\n  addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(\n    facet,\n    value\n  ) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the disjunctiveFacets attribute of the helper configuration'\n      );\n    }\n\n    if (\n      RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)\n    )\n      return this;\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.addRefinement(\n        this.disjunctiveFacetsRefinements,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * addTagRefinement adds a tag to the list used to filter the results\n   * @param {string} tag tag to be added\n   * @return {SearchParameters} new instance\n   */\n  addTagRefinement: function addTagRefinement(tag) {\n    if (this.isTagRefined(tag)) return this;\n\n    var modification = {\n      tagRefinements: this.tagRefinements.concat(tag),\n    };\n\n    return this.setQueryParameters(modification);\n  },\n  /**\n   * Remove a facet from the facets attribute of the helper configuration, if it\n   * is present.\n   * @method\n   * @param {string} facet facet name to remove\n   * @return {SearchParameters} new instance\n   */\n  removeFacet: function removeFacet(facet) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      facets: this.facets.filter(function (f) {\n        return f !== facet;\n      }),\n    });\n  },\n  /**\n   * Remove a disjunctive facet from the disjunctiveFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet disjunctive facet name to remove\n   * @return {SearchParameters} new instance\n   */\n  removeDisjunctiveFacet: function removeDisjunctiveFacet(facet) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.filter(function (f) {\n        return f !== facet;\n      }),\n    });\n  },\n  /**\n   * Remove a hierarchical facet from the hierarchicalFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet hierarchical facet name to remove\n   * @return {SearchParameters} new instance\n   */\n  removeHierarchicalFacet: function removeHierarchicalFacet(facet) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.filter(function (f) {\n        return f.name !== facet;\n      }),\n    });\n  },\n  /**\n   * Remove a refinement set on facet. If a value is provided, it will clear the\n   * refinement for the given value, otherwise it will clear all the refinement\n   * values for the faceted attribute.\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} [value] value used to filter\n   * @return {SearchParameters} new instance\n   */\n  removeFacetRefinement: function removeFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the facets attribute of the helper configuration'\n      );\n    }\n    if (!RefinementList.isRefined(this.facetsRefinements, facet, value))\n      return this;\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.removeRefinement(\n        this.facetsRefinements,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Remove a negative refinement on a facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters} new instance\n   */\n  removeExcludeRefinement: function removeExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the facets attribute of the helper configuration'\n      );\n    }\n    if (!RefinementList.isRefined(this.facetsExcludes, facet, value))\n      return this;\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.removeRefinement(\n        this.facetsExcludes,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Remove a refinement on a disjunctive facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters} new instance\n   */\n  removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(\n    facet,\n    value\n  ) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the disjunctiveFacets attribute of the helper configuration'\n      );\n    }\n    if (\n      !RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)\n    )\n      return this;\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.removeRefinement(\n        this.disjunctiveFacetsRefinements,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Remove a tag from the list of tag refinements\n   * @method\n   * @param {string} tag the tag to remove\n   * @return {SearchParameters} new instance\n   */\n  removeTagRefinement: function removeTagRefinement(tag) {\n    if (!this.isTagRefined(tag)) return this;\n\n    var modification = {\n      tagRefinements: this.tagRefinements.filter(function (t) {\n        return t !== tag;\n      }),\n    };\n\n    return this.setQueryParameters(modification);\n  },\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters} new instance\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   * @deprecated since version 2.19.0, see {@link SearchParameters#toggleFacetRefinement}\n   */\n  toggleRefinement: function toggleRefinement(facet, value) {\n    return this.toggleFacetRefinement(facet, value);\n  },\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters} new instance\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   */\n  toggleFacetRefinement: function toggleFacetRefinement(facet, value) {\n    if (this.isHierarchicalFacet(facet)) {\n      return this.toggleHierarchicalFacetRefinement(facet, value);\n    } else if (this.isConjunctiveFacet(facet)) {\n      return this.toggleConjunctiveFacetRefinement(facet, value);\n    } else if (this.isDisjunctiveFacet(facet)) {\n      return this.toggleDisjunctiveFacetRefinement(facet, value);\n    }\n\n    throw new Error(\n      'Cannot refine the undeclared facet ' +\n        facet +\n        '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets'\n    );\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters} new instance\n   */\n  toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(\n    facet,\n    value\n  ) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the facets attribute of the helper configuration'\n      );\n    }\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.toggleRefinement(\n        this.facetsRefinements,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters} new instance\n   */\n  toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(\n    facet,\n    value\n  ) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the facets attribute of the helper configuration'\n      );\n    }\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.toggleRefinement(\n        this.facetsExcludes,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters} new instance\n   */\n  toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(\n    facet,\n    value\n  ) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the disjunctiveFacets attribute of the helper configuration'\n      );\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.toggleRefinement(\n        this.disjunctiveFacetsRefinements,\n        facet,\n        value\n      ),\n    });\n  },\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters} new instance\n   */\n  toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(\n    facet,\n    value\n  ) {\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the hierarchicalFacets attribute of the helper configuration'\n      );\n    }\n\n    var separator = this._getHierarchicalFacetSeparator(\n      this.getHierarchicalFacetByName(facet)\n    );\n\n    var mod = {};\n\n    var upOneOrMultipleLevel =\n      this.hierarchicalFacetsRefinements[facet] !== undefined &&\n      this.hierarchicalFacetsRefinements[facet].length > 0 &&\n      // remove current refinement:\n      // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`\n      (this.hierarchicalFacetsRefinements[facet][0] === value ||\n        // remove a parent refinement of the current refinement:\n        //  - refinement was 'beer > IPA > Flying dog'\n        //  - call is toggleRefine('beer > IPA')\n        //  - refinement should be `beer`\n        this.hierarchicalFacetsRefinements[facet][0].indexOf(\n          value + separator\n        ) === 0);\n\n    if (upOneOrMultipleLevel) {\n      if (value.indexOf(separator) === -1) {\n        // go back to root level\n        mod[facet] = [];\n      } else {\n        mod[facet] = [value.slice(0, value.lastIndexOf(separator))];\n      }\n    } else {\n      mod[facet] = [value];\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure(\n        {},\n        mod,\n        this.hierarchicalFacetsRefinements\n      ),\n    });\n  },\n\n  /**\n   * Adds a refinement on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @param {string} path the hierarchical facet path\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is refined\n   */\n  addHierarchicalFacetRefinement: function (facet, path) {\n    if (this.isHierarchicalFacetRefined(facet)) {\n      throw new Error(facet + ' is already refined.');\n    }\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(\n        facet +\n          ' is not defined in the hierarchicalFacets attribute of the helper configuration.'\n      );\n    }\n    var mod = {};\n    mod[facet] = [path];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure(\n        {},\n        mod,\n        this.hierarchicalFacetsRefinements\n      ),\n    });\n  },\n\n  /**\n   * Removes the refinement set on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is not refined\n   */\n  removeHierarchicalFacetRefinement: function (facet) {\n    if (!this.isHierarchicalFacetRefined(facet)) {\n      return this;\n    }\n    var mod = {};\n    mod[facet] = [];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure(\n        {},\n        mod,\n        this.hierarchicalFacetsRefinements\n      ),\n    });\n  },\n  /**\n   * Switch the tag refinement\n   * @method\n   * @param {string} tag the tag to remove or add\n   * @return {SearchParameters} new instance\n   */\n  toggleTagRefinement: function toggleTagRefinement(tag) {\n    if (this.isTagRefined(tag)) {\n      return this.removeTagRefinement(tag);\n    }\n\n    return this.addTagRefinement(tag);\n  },\n  /**\n   * Test if the facet name is from one of the disjunctive facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean} true if facet is a disjunctive facet\n   */\n  isDisjunctiveFacet: function (facet) {\n    return this.disjunctiveFacets.indexOf(facet) > -1;\n  },\n  /**\n   * Test if the facet name is from one of the hierarchical facets\n   * @method\n   * @param {string} facetName facet name to test\n   * @return {boolean} true if facetName is a hierarchical facet\n   */\n  isHierarchicalFacet: function (facetName) {\n    return this.getHierarchicalFacetByName(facetName) !== undefined;\n  },\n  /**\n   * Test if the facet name is from one of the conjunctive/normal facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean} true if facet is a conjunctive facet\n   */\n  isConjunctiveFacet: function (facet) {\n    return this.facets.indexOf(facet) > -1;\n  },\n  /**\n   * Returns true if the facet is refined, either for a specific value or in\n   * general.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value, optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isFacetRefined: function isFacetRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n    return RefinementList.isRefined(this.facetsRefinements, facet, value);\n  },\n  /**\n   * Returns true if the facet contains exclusions or if a specific value is\n   * excluded.\n   *\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} [value] optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isExcludeRefined: function isExcludeRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n    return RefinementList.isRefined(this.facetsExcludes, facet, value);\n  },\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean} true if the facet is refined\n   */\n  isDisjunctiveFacetRefined: function isDisjunctiveFacetRefined(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return false;\n    }\n    return RefinementList.isRefined(\n      this.disjunctiveFacetsRefinements,\n      facet,\n      value\n    );\n  },\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean} true if the facet is refined\n   */\n  isHierarchicalFacetRefined: function isHierarchicalFacetRefined(\n    facet,\n    value\n  ) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return false;\n    }\n\n    var refinements = this.getHierarchicalRefinement(facet);\n\n    if (!value) {\n      return refinements.length > 0;\n    }\n\n    return refinements.indexOf(value) !== -1;\n  },\n  /**\n   * Test if the triple (attribute, operator, value) is already refined.\n   * If only the attribute and the operator are provided, it tests if the\n   * contains any refinement value.\n   * @method\n   * @param {string} attribute attribute for which the refinement is applied\n   * @param {string} [operator] operator of the refinement\n   * @param {string} [value] value of the refinement\n   * @return {boolean} true if it is refined\n   */\n  isNumericRefined: function isNumericRefined(attribute, operator, value) {\n    if (value === undefined && operator === undefined) {\n      return Boolean(this.numericRefinements[attribute]);\n    }\n\n    var isOperatorDefined =\n      this.numericRefinements[attribute] &&\n      this.numericRefinements[attribute][operator] !== undefined;\n\n    if (value === undefined || !isOperatorDefined) {\n      return isOperatorDefined;\n    }\n\n    var parsedValue = valToNumber(value);\n    var isAttributeValueDefined =\n      findArray(this.numericRefinements[attribute][operator], parsedValue) !==\n      undefined;\n\n    return isOperatorDefined && isAttributeValueDefined;\n  },\n  /**\n   * Returns true if the tag refined, false otherwise\n   * @method\n   * @param {string} tag the tag to check\n   * @return {boolean} true if tag is refined\n   */\n  isTagRefined: function isTagRefined(tag) {\n    return this.tagRefinements.indexOf(tag) !== -1;\n  },\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]} returns the list of refinements\n   */\n  getRefinedDisjunctiveFacets: function getRefinedDisjunctiveFacets() {\n    // eslint-disable-next-line consistent-this\n    var self = this;\n\n    // attributes used for numeric filter can also be disjunctive\n    var disjunctiveNumericRefinedFacets = intersection(\n      Object.keys(this.numericRefinements).filter(function (facet) {\n        return Object.keys(self.numericRefinements[facet]).length > 0;\n      }),\n      this.disjunctiveFacets\n    );\n\n    return Object.keys(this.disjunctiveFacetsRefinements)\n      .filter(function (facet) {\n        return self.disjunctiveFacetsRefinements[facet].length > 0;\n      })\n      .concat(disjunctiveNumericRefinedFacets)\n      .concat(this.getRefinedHierarchicalFacets())\n      .sort();\n  },\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]} returns the list of refinements\n   */\n  getRefinedHierarchicalFacets: function getRefinedHierarchicalFacets() {\n    // eslint-disable-next-line consistent-this\n    var self = this;\n    return intersection(\n      // enforce the order between the two arrays,\n      // so that refinement name index === hierarchical facet index\n      this.hierarchicalFacets.map(function (facet) {\n        return facet.name;\n      }),\n      Object.keys(this.hierarchicalFacetsRefinements).filter(function (facet) {\n        return self.hierarchicalFacetsRefinements[facet].length > 0;\n      })\n    ).sort();\n  },\n  /**\n   * Returned the list of all disjunctive facets not refined\n   * @method\n   * @return {string[]} returns the list of facets that are not refined\n   */\n  getUnrefinedDisjunctiveFacets: function () {\n    var refinedFacets = this.getRefinedDisjunctiveFacets();\n\n    return this.disjunctiveFacets.filter(function (f) {\n      return refinedFacets.indexOf(f) === -1;\n    });\n  },\n\n  managedParameters: [\n    'index',\n\n    'facets',\n    'disjunctiveFacets',\n    'facetsRefinements',\n    'hierarchicalFacets',\n    'facetsExcludes',\n\n    'disjunctiveFacetsRefinements',\n    'numericRefinements',\n    'tagRefinements',\n    'hierarchicalFacetsRefinements',\n  ],\n\n  getQueryParams: function getQueryParams() {\n    var managedParameters = this.managedParameters;\n\n    var queryParams = {};\n\n    // eslint-disable-next-line consistent-this\n    var self = this;\n    Object.keys(this).forEach(function (paramName) {\n      var paramValue = self[paramName];\n      if (\n        managedParameters.indexOf(paramName) === -1 &&\n        paramValue !== undefined\n      ) {\n        queryParams[paramName] = paramValue;\n      }\n    });\n\n    return queryParams;\n  },\n  /**\n   * Let the user set a specific value for a given parameter. Will return the\n   * same instance if the parameter is invalid or if the value is the same as the\n   * previous one.\n   * @method\n   * @param {string} parameter the parameter name\n   * @param {any} value the value to be set, must be compliant with the definition\n   * of the attribute on the object\n   * @return {SearchParameters} the updated state\n   */\n  setQueryParameter: function setParameter(parameter, value) {\n    if (this[parameter] === value) return this;\n\n    var modification = {};\n\n    modification[parameter] = value;\n\n    return this.setQueryParameters(modification);\n  },\n  /**\n   * Let the user set any of the parameters with a plain object.\n   * @method\n   * @param {object} params all the keys and the values to be updated\n   * @return {SearchParameters} a new updated instance\n   */\n  setQueryParameters: function setQueryParameters(params) {\n    if (!params) return this;\n\n    var error = SearchParameters.validate(this, params);\n\n    if (error) {\n      throw error;\n    }\n\n    // eslint-disable-next-line consistent-this\n    var self = this;\n    var nextWithNumbers = SearchParameters._parseNumbers(params);\n    var previousPlainObject = Object.keys(this).reduce(function (acc, key) {\n      acc[key] = self[key];\n      return acc;\n    }, {});\n\n    var nextPlainObject = Object.keys(nextWithNumbers).reduce(function (\n      previous,\n      key\n    ) {\n      var isPreviousValueDefined = previous[key] !== undefined;\n      var isNextValueDefined = nextWithNumbers[key] !== undefined;\n\n      if (isPreviousValueDefined && !isNextValueDefined) {\n        return omit(previous, [key]);\n      }\n\n      if (isNextValueDefined) {\n        previous[key] = nextWithNumbers[key];\n      }\n\n      return previous;\n    },\n    previousPlainObject);\n\n    return new this.constructor(nextPlainObject);\n  },\n\n  /**\n   * Returns a new instance with the page reset. Two scenarios possible:\n   * the page is omitted -> return the given instance\n   * the page is set -> return a new instance with a page of 0\n   * @return {SearchParameters} a new updated instance\n   */\n  resetPage: function () {\n    if (this.page === undefined) {\n      return this;\n    }\n\n    return this.setPage(0);\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @param  {object} hierarchicalFacet the hierarchicalFacet object\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSortBy: function (hierarchicalFacet) {\n    return hierarchicalFacet.sortBy || ['isRefined:desc', 'name:asc'];\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @private\n   * @param  {object} hierarchicalFacet the hierarchicalFacet object\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSeparator: function (hierarchicalFacet) {\n    return hierarchicalFacet.separator || ' > ';\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet prefix path or null\n   * @private\n   * @param  {object} hierarchicalFacet the hierarchicalFacet object\n   * @return {string} returns the hierarchicalFacet.rootPath or null as default\n   */\n  _getHierarchicalRootPath: function (hierarchicalFacet) {\n    return hierarchicalFacet.rootPath || null;\n  },\n\n  /**\n   * Helper function to check if we show the parent level of the hierarchicalFacet\n   * @private\n   * @param  {object} hierarchicalFacet the hierarchicalFacet object\n   * @return {string} returns the hierarchicalFacet.showParentLevel or true as default\n   */\n  _getHierarchicalShowParentLevel: function (hierarchicalFacet) {\n    if (typeof hierarchicalFacet.showParentLevel === 'boolean') {\n      return hierarchicalFacet.showParentLevel;\n    }\n    return true;\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet by it's name\n   * @param  {string} hierarchicalFacetName the hierarchicalFacet name\n   * @return {object} a hierarchicalFacet\n   */\n  getHierarchicalFacetByName: function (hierarchicalFacetName) {\n    return find(this.hierarchicalFacets, function (f) {\n      return f.name === hierarchicalFacetName;\n    });\n  },\n\n  /**\n   * Get the current breadcrumb for a hierarchical facet, as an array\n   * @param  {string} facetName Hierarchical facet name\n   * @return {array.<string>} the path as an array of string\n   */\n  getHierarchicalFacetBreadcrumb: function (facetName) {\n    if (!this.isHierarchicalFacet(facetName)) {\n      return [];\n    }\n\n    var refinement = this.getHierarchicalRefinement(facetName)[0];\n    if (!refinement) return [];\n\n    var separator = this._getHierarchicalFacetSeparator(\n      this.getHierarchicalFacetByName(facetName)\n    );\n    var path = refinement.split(separator);\n    return path.map(function (part) {\n      return part.trim();\n    });\n  },\n\n  toString: function () {\n    return JSON.stringify(this, null, 2);\n  },\n};\n\n/**\n * Callback used for clearRefinement method\n * @callback SearchParameters.clearCallback\n * @param {OperatorList|FacetList} value the value of the filter\n * @param {string} key the current attribute name\n * @param {string} type `numeric`, `disjunctiveFacet`, `conjunctiveFacet`, `hierarchicalFacet` or `exclude`\n * depending on the type of facet\n * @return {boolean} `true` if the element should be removed. `false` otherwise.\n */\nmodule.exports = SearchParameters;\n","'use strict';\n\nmodule.exports = generateTrees;\n\nvar fv = require('../functions/escapeFacetValue');\nvar find = require('../functions/find');\nvar prepareHierarchicalFacetSortBy = require('../functions/formatSort');\nvar orderBy = require('../functions/orderBy');\nvar escapeFacetValue = fv.escapeFacetValue;\nvar unescapeFacetValue = fv.unescapeFacetValue;\n\nfunction generateTrees(state) {\n  return function generate(hierarchicalFacetResult, hierarchicalFacetIndex) {\n    var hierarchicalFacet = state.hierarchicalFacets[hierarchicalFacetIndex];\n    var hierarchicalFacetRefinement =\n      (state.hierarchicalFacetsRefinements[hierarchicalFacet.name] &&\n        state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0]) ||\n      '';\n    var hierarchicalSeparator =\n      state._getHierarchicalFacetSeparator(hierarchicalFacet);\n    var hierarchicalRootPath =\n      state._getHierarchicalRootPath(hierarchicalFacet);\n    var hierarchicalShowParentLevel =\n      state._getHierarchicalShowParentLevel(hierarchicalFacet);\n    var sortBy = prepareHierarchicalFacetSortBy(\n      state._getHierarchicalFacetSortBy(hierarchicalFacet)\n    );\n\n    var rootExhaustive = hierarchicalFacetResult.every(function (facetResult) {\n      return facetResult.exhaustive;\n    });\n\n    var generateTreeFn = generateHierarchicalTree(\n      sortBy,\n      hierarchicalSeparator,\n      hierarchicalRootPath,\n      hierarchicalShowParentLevel,\n      hierarchicalFacetRefinement\n    );\n\n    var results = hierarchicalFacetResult;\n\n    if (hierarchicalRootPath) {\n      results = hierarchicalFacetResult.slice(\n        hierarchicalRootPath.split(hierarchicalSeparator).length\n      );\n    }\n\n    return results.reduce(generateTreeFn, {\n      name: state.hierarchicalFacets[hierarchicalFacetIndex].name,\n      count: null, // root level, no count\n      isRefined: true, // root level, always refined\n      path: null, // root level, no path\n      escapedValue: null,\n      exhaustive: rootExhaustive,\n      data: null,\n    });\n  };\n}\n\nfunction generateHierarchicalTree(\n  sortBy,\n  hierarchicalSeparator,\n  hierarchicalRootPath,\n  hierarchicalShowParentLevel,\n  currentRefinement\n) {\n  return function generateTree(\n    hierarchicalTree,\n    hierarchicalFacetResult,\n    currentHierarchicalLevel\n  ) {\n    var parent = hierarchicalTree;\n\n    if (currentHierarchicalLevel > 0) {\n      var level = 0;\n\n      parent = hierarchicalTree;\n\n      while (level < currentHierarchicalLevel) {\n        /**\n         * @type {object[]]} hierarchical data\n         */\n        var data = parent && Array.isArray(parent.data) ? parent.data : [];\n        parent = find(data, function (subtree) {\n          return subtree.isRefined;\n        });\n        level++;\n      }\n    }\n\n    // we found a refined parent, let's add current level data under it\n    if (parent) {\n      // filter values in case an object has multiple categories:\n      //   {\n      //     categories: {\n      //       level0: ['beers', 'bières'],\n      //       level1: ['beers > IPA', 'bières > Belges']\n      //     }\n      //   }\n      //\n      // If parent refinement is `beers`, then we do not want to have `bières > Belges`\n      // showing up\n\n      var picked = Object.keys(hierarchicalFacetResult.data)\n        .map(function (facetValue) {\n          return [facetValue, hierarchicalFacetResult.data[facetValue]];\n        })\n        .filter(function (tuple) {\n          var facetValue = tuple[0];\n          return onlyMatchingTree(\n            facetValue,\n            parent.path || hierarchicalRootPath,\n            currentRefinement,\n            hierarchicalSeparator,\n            hierarchicalRootPath,\n            hierarchicalShowParentLevel\n          );\n        });\n\n      parent.data = orderBy(\n        picked.map(function (tuple) {\n          var facetValue = tuple[0];\n          var facetCount = tuple[1];\n\n          return format(\n            facetCount,\n            facetValue,\n            hierarchicalSeparator,\n            unescapeFacetValue(currentRefinement),\n            hierarchicalFacetResult.exhaustive\n          );\n        }),\n        sortBy[0],\n        sortBy[1]\n      );\n    }\n\n    return hierarchicalTree;\n  };\n}\n\n// eslint-disable-next-line max-params\nfunction onlyMatchingTree(\n  facetValue,\n  parentPath,\n  currentRefinement,\n  hierarchicalSeparator,\n  hierarchicalRootPath,\n  hierarchicalShowParentLevel\n) {\n  // we want the facetValue is a child of hierarchicalRootPath\n  if (\n    hierarchicalRootPath &&\n    (facetValue.indexOf(hierarchicalRootPath) !== 0 ||\n      hierarchicalRootPath === facetValue)\n  ) {\n    return false;\n  }\n\n  // we always want root levels (only when there is no prefix path)\n  return (\n    (!hierarchicalRootPath &&\n      facetValue.indexOf(hierarchicalSeparator) === -1) ||\n    // if there is a rootPath, being root level mean 1 level under rootPath\n    (hierarchicalRootPath &&\n      facetValue.split(hierarchicalSeparator).length -\n        hierarchicalRootPath.split(hierarchicalSeparator).length ===\n        1) ||\n    // if current refinement is a root level and current facetValue is a root level,\n    // keep the facetValue\n    (facetValue.indexOf(hierarchicalSeparator) === -1 &&\n      currentRefinement.indexOf(hierarchicalSeparator) === -1) ||\n    // currentRefinement is a child of the facet value\n    currentRefinement.indexOf(facetValue) === 0 ||\n    // facetValue is a child of the current parent, add it\n    (facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 &&\n      (hierarchicalShowParentLevel ||\n        facetValue.indexOf(currentRefinement) === 0))\n  );\n}\n\nfunction format(\n  facetCount,\n  facetValue,\n  hierarchicalSeparator,\n  currentRefinement,\n  exhaustive\n) {\n  var parts = facetValue.split(hierarchicalSeparator);\n  return {\n    name: parts[parts.length - 1].trim(),\n    path: facetValue,\n    escapedValue: escapeFacetValue(facetValue),\n    count: facetCount,\n    isRefined:\n      currentRefinement === facetValue ||\n      currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,\n    exhaustive: exhaustive,\n    data: null,\n  };\n}\n","'use strict';\n\nvar compact = require('../functions/compact');\nvar defaultsPure = require('../functions/defaultsPure');\nvar fv = require('../functions/escapeFacetValue');\nvar find = require('../functions/find');\nvar findIndex = require('../functions/findIndex');\nvar formatSort = require('../functions/formatSort');\nvar merge = require('../functions/merge');\nvar orderBy = require('../functions/orderBy');\nvar escapeFacetValue = fv.escapeFacetValue;\nvar unescapeFacetValue = fv.unescapeFacetValue;\n\nvar generateHierarchicalTree = require('./generate-hierarchical-tree');\n\n/**\n * @typedef SearchResults.Facet\n * @type {object}\n * @property {string} name name of the attribute in the record\n * @property {object} data the faceting data: value, number of entries\n * @property {object} stats undefined unless facet_stats is retrieved from algolia\n */\n\n/**\n * @typedef SearchResults.HierarchicalFacet\n * @type {object}\n * @property {string} name name of the current value given the hierarchical level, trimmed.\n * If root node, you get the facet name\n * @property {number} count number of objects matching this hierarchical value\n * @property {string} path the current hierarchical value full path\n * @property {boolean} isRefined `true` if the current value was refined, `false` otherwise\n * @property {HierarchicalFacet[]} data sub values for the current level\n */\n\n/**\n * @typedef SearchResults.FacetValue\n * @type {object}\n * @property {string} name the facet value itself\n * @property {number} count times this facet appears in the results\n * @property {boolean} isRefined is the facet currently selected\n * @property {boolean} isExcluded is the facet currently excluded (only for conjunctive facets)\n */\n\n/**\n * @typedef Refinement\n * @type {object}\n * @property {string} type the type of filter used:\n * `numeric`, `facet`, `exclude`, `disjunctive`, `hierarchical`\n * @property {string} attributeName name of the attribute used for filtering\n * @property {string} name the value of the filter\n * @property {number} numericValue the value as a number. Only for numeric filters.\n * @property {string} operator the operator used. Only for numeric filters.\n * @property {number} count the number of computed hits for this filter. Only on facets.\n * @property {boolean} exhaustive if the count is exhaustive\n */\n\n/**\n * Turn an array of attributes in an object of attributes with their position in the array as value\n * @param {string[]} attributes the list of attributes in the record\n * @return {object} the list of attributes indexed by attribute name\n */\nfunction getIndices(attributes) {\n  var indices = {};\n\n  attributes.forEach(function (val, idx) {\n    indices[val] = idx;\n  });\n\n  return indices;\n}\n\nfunction assignFacetStats(dest, facetStats, key) {\n  if (facetStats && facetStats[key]) {\n    dest.stats = facetStats[key];\n  }\n}\n\n/**\n * @typedef {Object} HierarchicalFacet\n * @property {string} name\n * @property {string[]} attributes\n */\n\n/**\n * @param {HierarchicalFacet[]} hierarchicalFacets All hierarchical facets\n * @param {string} hierarchicalAttributeName The name of the hierarchical attribute\n * @return {HierarchicalFacet} The hierarchical facet matching the attribute name\n */\nfunction findMatchingHierarchicalFacetFromAttributeName(\n  hierarchicalFacets,\n  hierarchicalAttributeName\n) {\n  return find(\n    hierarchicalFacets,\n    function facetKeyMatchesAttribute(hierarchicalFacet) {\n      var facetNames = hierarchicalFacet.attributes || [];\n      return facetNames.indexOf(hierarchicalAttributeName) > -1;\n    }\n  );\n}\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * Constructor for SearchResults\n * @class\n * @classdesc SearchResults contains the results of a query to Algolia using the\n * {@link AlgoliaSearchHelper}.\n * @param {SearchParameters} state state that led to the response\n * @param {array.<object>} results the results from algolia client\n * @example <caption>SearchResults of the first query in\n * <a href=\"http://demos.algolia.com/instant-search-demo\">the instant search demo</a></caption>\n{\n   \"hitsPerPage\": 10,\n   \"processingTimeMS\": 2,\n   \"facets\": [\n      {\n         \"name\": \"type\",\n         \"data\": {\n            \"HardGood\": 6627,\n            \"BlackTie\": 550,\n            \"Music\": 665,\n            \"Software\": 131,\n            \"Game\": 456,\n            \"Movie\": 1571\n         },\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"Free shipping\": 5507\n         },\n         \"name\": \"shipping\"\n      }\n  ],\n   \"hits\": [\n      {\n         \"thumbnailImage\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_54x108_s.gif\",\n         \"_highlightResult\": {\n            \"shortDescription\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n               \"matchedWords\": []\n            },\n            \"category\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Computer Security Software\",\n               \"matchedWords\": []\n            },\n            \"manufacturer\": {\n               \"matchedWords\": [],\n               \"value\": \"Webroot\",\n               \"matchLevel\": \"none\"\n            },\n            \"name\": {\n               \"value\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n               \"matchedWords\": [],\n               \"matchLevel\": \"none\"\n            }\n         },\n         \"image\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_105x210_sc.jpg\",\n         \"shipping\": \"Free shipping\",\n         \"bestSellingRank\": 4,\n         \"shortDescription\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n         \"url\": \"http://www.bestbuy.com/site/webroot-secureanywhere-internet-security-3-devi…d=1219060687969&skuId=1688832&cmp=RMX&ky=2d3GfEmNIzjA0vkzveHdZEBgpPCyMnLTJ\",\n         \"name\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n         \"category\": \"Computer Security Software\",\n         \"salePrice_range\": \"1 - 50\",\n         \"objectID\": \"1688832\",\n         \"type\": \"Software\",\n         \"customerReviewCount\": 5980,\n         \"salePrice\": 49.99,\n         \"manufacturer\": \"Webroot\"\n      },\n      ....\n  ],\n   \"nbHits\": 10000,\n   \"disjunctiveFacets\": [\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"5\": 183,\n            \"12\": 112,\n            \"7\": 149,\n            ...\n         },\n         \"name\": \"customerReviewCount\",\n         \"stats\": {\n            \"max\": 7461,\n            \"avg\": 157.939,\n            \"min\": 1\n         }\n      },\n      {\n         \"data\": {\n            \"Printer Ink\": 142,\n            \"Wireless Speakers\": 60,\n            \"Point & Shoot Cameras\": 48,\n            ...\n         },\n         \"name\": \"category\",\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"> 5000\": 2,\n            \"1 - 50\": 6524,\n            \"501 - 2000\": 566,\n            \"201 - 500\": 1501,\n            \"101 - 200\": 1360,\n            \"2001 - 5000\": 47\n         },\n         \"name\": \"salePrice_range\"\n      },\n      {\n         \"data\": {\n            \"Dynex™\": 202,\n            \"Insignia™\": 230,\n            \"PNY\": 72,\n            ...\n         },\n         \"name\": \"manufacturer\",\n         \"exhaustive\": false\n      }\n  ],\n   \"query\": \"\",\n   \"nbPages\": 100,\n   \"page\": 0,\n   \"index\": \"bestbuy\"\n}\n **/\nfunction SearchResults(state, results, options) {\n  var mainSubResponse = results[0];\n\n  this._rawResults = results;\n\n  // eslint-disable-next-line consistent-this\n  var self = this;\n\n  // https://www.algolia.com/doc/api-reference/api-methods/search/#response\n  Object.keys(mainSubResponse).forEach(function (key) {\n    self[key] = mainSubResponse[key];\n  });\n\n  // Make every key of the result options reachable from the instance\n  Object.keys(options || {}).forEach(function (key) {\n    self[key] = options[key];\n  });\n\n  /**\n   * query used to generate the results\n   * @name query\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * The query as parsed by the engine given all the rules.\n   * @name parsedQuery\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * all the records that match the search parameters. Each record is\n   * augmented with a new attribute `_highlightResult`\n   * which is an object keyed by attribute and with the following properties:\n   * - `value` : the value of the facet highlighted (html)\n   * - `matchLevel`: `full`, `partial` or `none`, depending on how the query terms match\n   * @name hits\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * index where the results come from\n   * @name index\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * number of hits per page requested\n   * @name hitsPerPage\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * total number of hits of this query on the index\n   * @name nbHits\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * total number of pages with respect to the number of hits per page and the total number of hits\n   * @name nbPages\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * current page\n   * @name page\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * The position if the position was guessed by IP.\n   * @name aroundLatLng\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"48.8637,2.3615\",\n   */\n  /**\n   * The radius computed by Algolia.\n   * @name automaticRadius\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"126792922\",\n   */\n  /**\n   * String identifying the server used to serve this request.\n   *\n   * getRankingInfo needs to be set to `true` for this to be returned\n   *\n   * @name serverUsed\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"c7-use-2.algolia.net\",\n   */\n  /**\n   * Boolean that indicates if the computation of the counts did time out.\n   * @deprecated\n   * @name timeoutCounts\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * Boolean that indicates if the computation of the hits did time out.\n   * @deprecated\n   * @name timeoutHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * True if the counts of the facets is exhaustive\n   * @name exhaustiveFacetsCount\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * True if the number of hits is exhaustive\n   * @name exhaustiveNbHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * Contains the userData if they are set by a [query rule](https://www.algolia.com/doc/guides/query-rules/query-rules-overview/).\n   * @name userData\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n  /**\n   * queryID is the unique identifier of the query used to generate the current search results.\n   * This value is only available if the `clickAnalytics` search parameter is set to `true`.\n   * @name queryID\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * sum of the processing time of all the queries\n   * @name processingTimeMS\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n  this.processingTimeMS = results.reduce(function (sum, result) {\n    return result.processingTimeMS === undefined\n      ? sum\n      : sum + result.processingTimeMS;\n  }, 0);\n\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.Facet[]}\n   */\n  this.disjunctiveFacets = [];\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.HierarchicalFacet[]}\n   */\n  this.hierarchicalFacets = state.hierarchicalFacets.map(\n    function initFutureTree() {\n      return [];\n    }\n  );\n  /**\n   * other facets results\n   * @member {SearchResults.Facet[]}\n   */\n  this.facets = [];\n\n  var disjunctiveFacets = state.getRefinedDisjunctiveFacets();\n\n  var facetsIndices = getIndices(state.facets);\n  var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);\n  var nextDisjunctiveResult = 1;\n\n  // Since we send request only for disjunctive facets that have been refined,\n  // we get the facets information from the first, general, response.\n\n  var mainFacets = mainSubResponse.facets || {};\n\n  Object.keys(mainFacets).forEach(function (facetKey) {\n    var facetValueObject = mainFacets[facetKey];\n\n    var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(\n      state.hierarchicalFacets,\n      facetKey\n    );\n\n    if (hierarchicalFacet) {\n      // Place the hierarchicalFacet data at the correct index depending on\n      // the attributes order that was defined at the helper initialization\n      var facetIndex = hierarchicalFacet.attributes.indexOf(facetKey);\n      var idxAttributeName = findIndex(state.hierarchicalFacets, function (f) {\n        return f.name === hierarchicalFacet.name;\n      });\n      self.hierarchicalFacets[idxAttributeName][facetIndex] = {\n        attribute: facetKey,\n        data: facetValueObject,\n        exhaustive: mainSubResponse.exhaustiveFacetsCount,\n      };\n    } else {\n      var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;\n      var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;\n      var position;\n\n      if (isFacetDisjunctive) {\n        position = disjunctiveFacetsIndices[facetKey];\n        self.disjunctiveFacets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount,\n        };\n        assignFacetStats(\n          self.disjunctiveFacets[position],\n          mainSubResponse.facets_stats,\n          facetKey\n        );\n      }\n      if (isFacetConjunctive) {\n        position = facetsIndices[facetKey];\n        self.facets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount,\n        };\n        assignFacetStats(\n          self.facets[position],\n          mainSubResponse.facets_stats,\n          facetKey\n        );\n      }\n    }\n  });\n\n  // Make sure we do not keep holes within the hierarchical facets\n  this.hierarchicalFacets = compact(this.hierarchicalFacets);\n\n  // aggregate the refined disjunctive facets\n  disjunctiveFacets.forEach(function (disjunctiveFacet) {\n    var result = results[nextDisjunctiveResult];\n    var facets = result && result.facets ? result.facets : {};\n    var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet);\n\n    // There should be only item in facets.\n    Object.keys(facets).forEach(function (dfacet) {\n      var facetResults = facets[dfacet];\n\n      var position;\n\n      if (hierarchicalFacet) {\n        position = findIndex(state.hierarchicalFacets, function (f) {\n          return f.name === hierarchicalFacet.name;\n        });\n        var attributeIndex = findIndex(\n          self.hierarchicalFacets[position],\n          function (f) {\n            return f.attribute === dfacet;\n          }\n        );\n\n        // previous refinements and no results so not able to find it\n        if (attributeIndex === -1) {\n          return;\n        }\n\n        self.hierarchicalFacets[position][attributeIndex].data = merge(\n          {},\n          self.hierarchicalFacets[position][attributeIndex].data,\n          facetResults\n        );\n      } else {\n        position = disjunctiveFacetsIndices[dfacet];\n\n        var dataFromMainRequest =\n          (mainSubResponse.facets && mainSubResponse.facets[dfacet]) || {};\n\n        self.disjunctiveFacets[position] = {\n          name: dfacet,\n          data: defaultsPure({}, facetResults, dataFromMainRequest),\n          exhaustive: result.exhaustiveFacetsCount,\n        };\n        assignFacetStats(\n          self.disjunctiveFacets[position],\n          result.facets_stats,\n          dfacet\n        );\n\n        if (state.disjunctiveFacetsRefinements[dfacet]) {\n          state.disjunctiveFacetsRefinements[dfacet].forEach(function (\n            refinementValue\n          ) {\n            // add the disjunctive refinements if it is no more retrieved\n            if (\n              !self.disjunctiveFacets[position].data[refinementValue] &&\n              state.disjunctiveFacetsRefinements[dfacet].indexOf(\n                unescapeFacetValue(refinementValue)\n              ) > -1\n            ) {\n              self.disjunctiveFacets[position].data[refinementValue] = 0;\n            }\n          });\n        }\n      }\n    });\n    nextDisjunctiveResult++;\n  });\n\n  // if we have some parent level values for hierarchical facets, merge them\n  state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {\n    var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    var currentRefinement = state.getHierarchicalRefinement(refinedFacet);\n    // if we are already at a root refinement (or no refinement at all), there is no\n    // root level values request\n    if (\n      currentRefinement.length === 0 ||\n      currentRefinement[0].split(separator).length < 2\n    ) {\n      return;\n    }\n\n    results.slice(nextDisjunctiveResult).forEach(function (result) {\n      var facets = result && result.facets ? result.facets : {};\n\n      Object.keys(facets).forEach(function (dfacet) {\n        var facetResults = facets[dfacet];\n        var position = findIndex(state.hierarchicalFacets, function (f) {\n          return f.name === hierarchicalFacet.name;\n        });\n        var attributeIndex = findIndex(\n          self.hierarchicalFacets[position],\n          function (f) {\n            return f.attribute === dfacet;\n          }\n        );\n\n        // previous refinements and no results so not able to find it\n        if (attributeIndex === -1) {\n          return;\n        }\n\n        // when we always get root levels, if the hits refinement is `beers > IPA` (count: 5),\n        // then the disjunctive values will be `beers` (count: 100),\n        // but we do not want to display\n        //   | beers (100)\n        //     > IPA (5)\n        // We want\n        //   | beers (5)\n        //     > IPA (5)\n        var defaultData = {};\n\n        if (currentRefinement.length > 0) {\n          var root = currentRefinement[0].split(separator)[0];\n          defaultData[root] =\n            self.hierarchicalFacets[position][attributeIndex].data[root];\n        }\n\n        self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(\n          defaultData,\n          facetResults,\n          self.hierarchicalFacets[position][attributeIndex].data\n        );\n      });\n\n      nextDisjunctiveResult++;\n    });\n  });\n\n  // add the excludes\n  Object.keys(state.facetsExcludes).forEach(function (facetName) {\n    var excludes = state.facetsExcludes[facetName];\n    var position = facetsIndices[facetName];\n\n    self.facets[position] = {\n      name: facetName,\n      data: mainFacets[facetName],\n      exhaustive: mainSubResponse.exhaustiveFacetsCount,\n    };\n    excludes.forEach(function (facetValue) {\n      self.facets[position] = self.facets[position] || { name: facetName };\n      self.facets[position].data = self.facets[position].data || {};\n      self.facets[position].data[facetValue] = 0;\n    });\n  });\n\n  /**\n   * @type {Array}\n   */\n  this.hierarchicalFacets = this.hierarchicalFacets.map(\n    generateHierarchicalTree(state)\n  );\n\n  /**\n   * @type {Array}\n   */\n  this.facets = compact(this.facets);\n  /**\n   * @type {Array}\n   */\n  this.disjunctiveFacets = compact(this.disjunctiveFacets);\n\n  this._state = state;\n}\n\n/**\n * Get a facet object with its name\n * @deprecated\n * @param {string} name name of the faceted attribute\n * @return {SearchResults.Facet} the facet object\n */\nSearchResults.prototype.getFacetByName = function (name) {\n  function predicate(facet) {\n    return facet.name === name;\n  }\n\n  return (\n    find(this.facets, predicate) ||\n    find(this.disjunctiveFacets, predicate) ||\n    find(this.hierarchicalFacets, predicate)\n  );\n};\n\n/**\n * Get the facet values of a specified attribute from a SearchResults object.\n * @private\n * @param {SearchResults} results the search results to search in\n * @param {string} attribute name of the faceted attribute to search for\n * @return {array|object} facet values. For the hierarchical facets it is an object.\n */\nfunction extractNormalizedFacetValues(results, attribute) {\n  function predicate(facet) {\n    return facet.name === attribute;\n  }\n\n  if (results._state.isConjunctiveFacet(attribute)) {\n    var facet = find(results.facets, predicate);\n    if (!facet) return [];\n\n    return Object.keys(facet.data).map(function (name) {\n      var value = escapeFacetValue(name);\n      return {\n        name: name,\n        escapedValue: value,\n        count: facet.data[name],\n        isRefined: results._state.isFacetRefined(attribute, value),\n        isExcluded: results._state.isExcludeRefined(attribute, name),\n      };\n    });\n  } else if (results._state.isDisjunctiveFacet(attribute)) {\n    var disjunctiveFacet = find(results.disjunctiveFacets, predicate);\n    if (!disjunctiveFacet) return [];\n\n    return Object.keys(disjunctiveFacet.data).map(function (name) {\n      var value = escapeFacetValue(name);\n      return {\n        name: name,\n        escapedValue: value,\n        count: disjunctiveFacet.data[name],\n        isRefined: results._state.isDisjunctiveFacetRefined(attribute, value),\n      };\n    });\n  } else if (results._state.isHierarchicalFacet(attribute)) {\n    var hierarchicalFacetValues = find(results.hierarchicalFacets, predicate);\n    if (!hierarchicalFacetValues) return hierarchicalFacetValues;\n\n    var hierarchicalFacet =\n      results._state.getHierarchicalFacetByName(attribute);\n    var separator =\n      results._state._getHierarchicalFacetSeparator(hierarchicalFacet);\n    var currentRefinement = unescapeFacetValue(\n      results._state.getHierarchicalRefinement(attribute)[0] || ''\n    );\n\n    if (currentRefinement.indexOf(hierarchicalFacet.rootPath) === 0) {\n      currentRefinement = currentRefinement.replace(\n        hierarchicalFacet.rootPath + separator,\n        ''\n      );\n    }\n\n    var currentRefinementSplit = currentRefinement.split(separator);\n    currentRefinementSplit.unshift(attribute);\n\n    setIsRefined(hierarchicalFacetValues, currentRefinementSplit, 0);\n\n    return hierarchicalFacetValues;\n  }\n\n  return undefined;\n}\n\n/**\n * Set the isRefined of a hierarchical facet result based on the current state.\n * @param {SearchResults.HierarchicalFacet} item Hierarchical facet to fix\n * @param {string[]} currentRefinement array of parts of the current hierarchical refinement\n * @param {number} depth recursion depth in the currentRefinement\n * @return {undefined} function mutates the item\n */\nfunction setIsRefined(item, currentRefinement, depth) {\n  item.isRefined = item.name === currentRefinement[depth];\n  if (item.data) {\n    item.data.forEach(function (child) {\n      setIsRefined(child, currentRefinement, depth + 1);\n    });\n  }\n}\n\n/**\n * Sort nodes of a hierarchical or disjunctive facet results\n * @private\n * @param {function} sortFn sort function to apply\n * @param {HierarchicalFacet|Array} node node upon which we want to apply the sort\n * @param {string[]} names attribute names\n * @param {number} [level=0] current index in the names array\n * @return {HierarchicalFacet|Array} sorted node\n */\nfunction recSort(sortFn, node, names, level) {\n  level = level || 0;\n\n  if (Array.isArray(node)) {\n    return sortFn(node, names[level]);\n  }\n\n  if (!node.data || node.data.length === 0) {\n    return node;\n  }\n\n  var children = node.data.map(function (childNode) {\n    return recSort(sortFn, childNode, names, level + 1);\n  });\n  var sortedChildren = sortFn(children, names[level]);\n  var newNode = defaultsPure({ data: sortedChildren }, node);\n  return newNode;\n}\n\nSearchResults.DEFAULT_SORT = ['isRefined:desc', 'count:desc', 'name:asc'];\n\nfunction vanillaSortFn(order, data) {\n  return data.sort(order);\n}\n\n/**\n * @typedef FacetOrdering\n * @type {Object}\n * @property {string[]} [order]\n * @property {'count' | 'alpha' | 'hidden'} [sortRemainingBy]\n */\n\n/**\n * Sorts facet arrays via their facet ordering\n * @param {Array} facetValues the values\n * @param {FacetOrdering} facetOrdering the ordering\n * @returns {Array} the sorted facet values\n */\nfunction sortViaFacetOrdering(facetValues, facetOrdering) {\n  var orderedFacets = [];\n  var remainingFacets = [];\n\n  var order = facetOrdering.order || [];\n  /**\n   * an object with the keys being the values in order, the values their index:\n   * ['one', 'two'] -> { one: 0, two: 1 }\n   */\n  var reverseOrder = order.reduce(function (acc, name, i) {\n    acc[name] = i;\n    return acc;\n  }, {});\n\n  facetValues.forEach(function (item) {\n    // hierarchical facets get sorted using their raw name\n    var name = item.path || item.name;\n    if (reverseOrder[name] !== undefined) {\n      orderedFacets[reverseOrder[name]] = item;\n    } else {\n      remainingFacets.push(item);\n    }\n  });\n\n  orderedFacets = orderedFacets.filter(function (facet) {\n    return facet;\n  });\n\n  var sortRemainingBy = facetOrdering.sortRemainingBy;\n  var ordering;\n  if (sortRemainingBy === 'hidden') {\n    return orderedFacets;\n  } else if (sortRemainingBy === 'alpha') {\n    ordering = [\n      ['path', 'name'],\n      ['asc', 'asc'],\n    ];\n  } else {\n    ordering = [['count'], ['desc']];\n  }\n\n  return orderedFacets.concat(\n    orderBy(remainingFacets, ordering[0], ordering[1])\n  );\n}\n\n/**\n * @param {SearchResults} results the search results class\n * @param {string} attribute the attribute to retrieve ordering of\n * @returns {FacetOrdering | undefined} the facet ordering\n */\nfunction getFacetOrdering(results, attribute) {\n  return (\n    results.renderingContent &&\n    results.renderingContent.facetOrdering &&\n    results.renderingContent.facetOrdering.values &&\n    results.renderingContent.facetOrdering.values[attribute]\n  );\n}\n\n/**\n * Get a the list of values for a given facet attribute. Those values are sorted\n * refinement first, descending count (bigger value on top), and name ascending\n * (alphabetical order). The sort formula can overridden using either string based\n * predicates or a function.\n *\n * This method will return all the values returned by the Algolia engine plus all\n * the values already refined. This means that it can happen that the\n * `maxValuesPerFacet` [configuration](https://www.algolia.com/doc/rest-api/search#param-maxValuesPerFacet)\n * might not be respected if you have facet values that are already refined.\n * @param {string} attribute attribute name\n * @param {object} opts configuration options.\n * @param {boolean} [opts.facetOrdering]\n * Force the use of facetOrdering from the result if a sortBy is present. If\n * sortBy isn't present, facetOrdering will be used automatically.\n * @param {Array.<string> | function} opts.sortBy\n * When using strings, it consists of\n * the name of the [FacetValue](#SearchResults.FacetValue) or the\n * [HierarchicalFacet](#SearchResults.HierarchicalFacet) attributes with the\n * order (`asc` or `desc`). For example to order the value by count, the\n * argument would be `['count:asc']`.\n *\n * If only the attribute name is specified, the ordering defaults to the one\n * specified in the default value for this attribute.\n *\n * When not specified, the order is\n * ascending.  This parameter can also be a function which takes two facet\n * values and should return a number, 0 if equal, 1 if the first argument is\n * bigger or -1 otherwise.\n *\n * The default value for this attribute `['isRefined:desc', 'count:desc', 'name:asc']`\n * @return {FacetValue[]|HierarchicalFacet|undefined} depending on the type of facet of\n * the attribute requested (hierarchical, disjunctive or conjunctive)\n * @example\n * helper.on('result', function(event){\n *   //get values ordered only by name ascending using the string predicate\n *   event.results.getFacetValues('city', {sortBy: ['name:asc']});\n *   //get values  ordered only by count ascending using a function\n *   event.results.getFacetValues('city', {\n *     // this is equivalent to ['count:asc']\n *     sortBy: function(a, b) {\n *       if (a.count === b.count) return 0;\n *       if (a.count > b.count)   return 1;\n *       if (b.count > a.count)   return -1;\n *     }\n *   });\n * });\n */\nSearchResults.prototype.getFacetValues = function (attribute, opts) {\n  var facetValues = extractNormalizedFacetValues(this, attribute);\n  if (!facetValues) {\n    return undefined;\n  }\n\n  var options = defaultsPure({}, opts, {\n    sortBy: SearchResults.DEFAULT_SORT,\n    // if no sortBy is given, attempt to sort based on facetOrdering\n    // if it is given, we still allow to sort via facet ordering first\n    facetOrdering: !(opts && opts.sortBy),\n  });\n\n  // eslint-disable-next-line consistent-this\n  var results = this;\n  var attributes;\n  if (Array.isArray(facetValues)) {\n    attributes = [attribute];\n  } else {\n    var config = results._state.getHierarchicalFacetByName(facetValues.name);\n    attributes = config.attributes;\n  }\n\n  return recSort(\n    function (data, facetName) {\n      if (options.facetOrdering) {\n        var facetOrdering = getFacetOrdering(results, facetName);\n        if (facetOrdering) {\n          return sortViaFacetOrdering(data, facetOrdering);\n        }\n      }\n\n      if (Array.isArray(options.sortBy)) {\n        var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);\n        return orderBy(data, order[0], order[1]);\n      } else if (typeof options.sortBy === 'function') {\n        return vanillaSortFn(options.sortBy, data);\n      }\n      throw new Error(\n        'options.sortBy is optional but if defined it must be ' +\n          'either an array of string (predicates) or a sorting function'\n      );\n    },\n    facetValues,\n    attributes\n  );\n};\n\n/**\n * Returns the facet stats if attribute is defined and the facet contains some.\n * Otherwise returns undefined.\n * @param {string} attribute name of the faceted attribute\n * @return {object} The stats of the facet\n */\nSearchResults.prototype.getFacetStats = function (attribute) {\n  if (this._state.isConjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.facets, attribute);\n  } else if (this._state.isDisjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);\n  }\n\n  return undefined;\n};\n\n/**\n * @typedef {Object} FacetListItem\n * @property {string} name\n */\n\n/**\n * @param {FacetListItem[]} facetList (has more items, but enough for here)\n * @param {string} facetName The attribute to look for\n * @return {object|undefined} The stats of the facet\n */\nfunction getFacetStatsIfAvailable(facetList, facetName) {\n  var data = find(facetList, function (facet) {\n    return facet.name === facetName;\n  });\n  return data && data.stats;\n}\n\n/**\n * Returns all refinements for all filters + tags. It also provides\n * additional information: count and exhaustiveness for each filter.\n *\n * See the [refinement type](#Refinement) for an exhaustive view of the available\n * data.\n *\n * Note that for a numeric refinement, results are grouped per operator, this\n * means that it will return responses for operators which are empty.\n *\n * @return {Array.<Refinement>} all the refinements\n */\nSearchResults.prototype.getRefinements = function () {\n  var state = this._state;\n  // eslint-disable-next-line consistent-this\n  var results = this;\n  var res = [];\n\n  Object.keys(state.facetsRefinements).forEach(function (attributeName) {\n    state.facetsRefinements[attributeName].forEach(function (name) {\n      res.push(\n        getRefinement(state, 'facet', attributeName, name, results.facets)\n      );\n    });\n  });\n\n  Object.keys(state.facetsExcludes).forEach(function (attributeName) {\n    state.facetsExcludes[attributeName].forEach(function (name) {\n      res.push(\n        getRefinement(state, 'exclude', attributeName, name, results.facets)\n      );\n    });\n  });\n\n  Object.keys(state.disjunctiveFacetsRefinements).forEach(function (\n    attributeName\n  ) {\n    state.disjunctiveFacetsRefinements[attributeName].forEach(function (name) {\n      res.push(\n        getRefinement(\n          state,\n          'disjunctive',\n          attributeName,\n          name,\n          results.disjunctiveFacets\n        )\n      );\n    });\n  });\n\n  Object.keys(state.hierarchicalFacetsRefinements).forEach(function (\n    attributeName\n  ) {\n    state.hierarchicalFacetsRefinements[attributeName].forEach(function (name) {\n      res.push(\n        getHierarchicalRefinement(\n          state,\n          attributeName,\n          name,\n          results.hierarchicalFacets\n        )\n      );\n    });\n  });\n\n  Object.keys(state.numericRefinements).forEach(function (attributeName) {\n    var operators = state.numericRefinements[attributeName];\n    Object.keys(operators).forEach(function (operator) {\n      operators[operator].forEach(function (value) {\n        res.push({\n          type: 'numeric',\n          attributeName: attributeName,\n          name: value,\n          numericValue: value,\n          operator: operator,\n        });\n      });\n    });\n  });\n\n  state.tagRefinements.forEach(function (name) {\n    res.push({ type: 'tag', attributeName: '_tags', name: name });\n  });\n\n  return res;\n};\n\n/**\n * @typedef {Object} Facet\n * @property {string} name\n * @property {Object} data\n * @property {boolean} exhaustive\n */\n\n/**\n * @param {SearchParameters} state the current state\n * @param {string} type the type of the refinement\n * @param {string} attributeName The attribute of the facet\n * @param {*} name The name of the facet\n * @param {Facet[]} resultsFacets facets from the results\n * @return {Refinement} the refinement\n */\nfunction getRefinement(state, type, attributeName, name, resultsFacets) {\n  var facet = find(resultsFacets, function (f) {\n    return f.name === attributeName;\n  });\n  var count = facet && facet.data && facet.data[name] ? facet.data[name] : 0;\n  var exhaustive = (facet && facet.exhaustive) || false;\n\n  return {\n    type: type,\n    attributeName: attributeName,\n    name: name,\n    count: count,\n    exhaustive: exhaustive,\n  };\n}\n\n/**\n * @param {SearchParameters} state the current state\n * @param {string} attributeName the attribute of the hierarchical facet\n * @param {string} name the name of the facet\n * @param {Facet[]} resultsFacets facets from the results\n * @return {HierarchicalFacet} the hierarchical facet\n */\nfunction getHierarchicalRefinement(state, attributeName, name, resultsFacets) {\n  var facetDeclaration = state.getHierarchicalFacetByName(attributeName);\n  var separator = state._getHierarchicalFacetSeparator(facetDeclaration);\n  var split = name.split(separator);\n  var rootFacet = find(resultsFacets, function (facet) {\n    return facet.name === attributeName;\n  });\n\n  var facet = split.reduce(function (intermediateFacet, part) {\n    var newFacet =\n      intermediateFacet &&\n      find(intermediateFacet.data, function (f) {\n        return f.name === part;\n      });\n    return newFacet !== undefined ? newFacet : intermediateFacet;\n  }, rootFacet);\n\n  var count = (facet && facet.count) || 0;\n  var exhaustive = (facet && facet.exhaustive) || false;\n  var path = (facet && facet.path) || '';\n\n  return {\n    type: 'hierarchical',\n    attributeName: attributeName,\n    name: path,\n    count: count,\n    exhaustive: exhaustive,\n  };\n}\n\nmodule.exports = SearchResults;\n","'use strict';\n\nvar EventEmitter = require('@algolia/events');\n\nvar DerivedHelper = require('./DerivedHelper');\nvar escapeFacetValue = require('./functions/escapeFacetValue').escapeFacetValue;\nvar inherits = require('./functions/inherits');\nvar merge = require('./functions/merge');\nvar objectHasKeys = require('./functions/objectHasKeys');\nvar omit = require('./functions/omit');\nvar requestBuilder = require('./requestBuilder');\nvar SearchParameters = require('./SearchParameters');\nvar SearchResults = require('./SearchResults');\nvar version = require('./version');\n\n/**\n * Event triggered when a parameter is set or updated\n * @event AlgoliaSearchHelper#event:change\n * @property {object} event\n * @property {SearchParameters} event.state the current parameters with the latest changes applied\n * @property {SearchResults} event.results the previous results received from Algolia. `null` before the first request\n * @example\n * helper.on('change', function(event) {\n *   console.log('The parameters have changed');\n * });\n */\n\n/**\n * Event triggered when a main search is sent to Algolia\n * @event AlgoliaSearchHelper#event:search\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search\n * @property {SearchResults} event.results the results from the previous search. `null` if it is the first search.\n * @example\n * helper.on('search', function(event) {\n *   console.log('Search sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchForFacetValues` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchForFacetValues\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @property {string} event.facet the facet searched into\n * @property {string} event.query the query used to search in the facets\n * @example\n * helper.on('searchForFacetValues', function(event) {\n *   console.log('searchForFacetValues sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchOnce` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchOnce\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @example\n * helper.on('searchOnce', function(event) {\n *   console.log('searchOnce sent');\n * });\n */\n\n/**\n * Event triggered when the results are retrieved from Algolia\n * @event AlgoliaSearchHelper#event:result\n * @property {object} event\n * @property {SearchResults} event.results the results received from Algolia\n * @property {SearchParameters} event.state the parameters used to query Algolia. Those might be different from the one in the helper instance (for example if the network is unreliable).\n * @example\n * helper.on('result', function(event) {\n *   console.log('Search results received');\n * });\n */\n\n/**\n * Event triggered when Algolia sends back an error. For example, if an unknown parameter is\n * used, the error can be caught using this event.\n * @event AlgoliaSearchHelper#event:error\n * @property {object} event\n * @property {Error} event.error the error returned by the Algolia.\n * @example\n * helper.on('error', function(event) {\n *   console.log('Houston we got a problem.');\n * });\n */\n\n/**\n * Event triggered when the queue of queries have been depleted (with any result or outdated queries)\n * @event AlgoliaSearchHelper#event:searchQueueEmpty\n * @example\n * helper.on('searchQueueEmpty', function() {\n *   console.log('No more search pending');\n *   // This is received before the result event if we're not expecting new results\n * });\n *\n * helper.search();\n */\n\n/**\n * Initialize a new AlgoliaSearchHelper\n * @class\n * @classdesc The AlgoliaSearchHelper is a class that ease the management of the\n * search. It provides an event based interface for search callbacks:\n *  - change: when the internal search state is changed.\n *    This event contains a {@link SearchParameters} object and the\n *    {@link SearchResults} of the last result if any.\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n *  - error: when the response is an error. This event contains the error returned by the server.\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the index name to query\n * @param  {SearchParameters | object} options an object defining the initial\n * config of the search. It doesn't have to be a {SearchParameters},\n * just an object containing the properties you need from it.\n */\nfunction AlgoliaSearchHelper(client, index, options) {\n  if (typeof client.addAlgoliaAgent === 'function') {\n    client.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n\n  this.setClient(client);\n  var opts = options || {};\n  opts.index = index;\n  this.state = SearchParameters.make(opts);\n  this.lastResults = null;\n  this._queryId = 0;\n  this._lastQueryIdReceived = -1;\n  this.derivedHelpers = [];\n  this._currentNbQueries = 0;\n}\n\ninherits(AlgoliaSearchHelper, EventEmitter);\n\n/**\n * Start the search with the parameters set in the state. When the\n * method is called, it triggers a `search` event. The results will\n * be available through the `result` event. If an error occurs, an\n * `error` will be fired instead.\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires search\n * @fires result\n * @fires error\n * @chainable\n */\nAlgoliaSearchHelper.prototype.search = function () {\n  this._search({ onlyWithDerivedHelpers: false });\n  return this;\n};\n\nAlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function () {\n  this._search({ onlyWithDerivedHelpers: true });\n  return this;\n};\n\n/**\n * Gets the search query parameters that would be sent to the Algolia Client\n * for the hits\n * @return {object} Query Parameters\n */\nAlgoliaSearchHelper.prototype.getQuery = function () {\n  var state = this.state;\n  return requestBuilder._getHitsSearchParams(state);\n};\n\n/**\n * Start a search using a modified version of the current state. This method does\n * not trigger the helper lifecycle and does not modify the state kept internally\n * by the helper. This second aspect means that the next search call will be the\n * same as a search call before calling searchOnce.\n * @param {object} options can contain all the parameters that can be set to SearchParameters\n * plus the index\n * @param {function} [cb] optional callback executed when the response from the\n * server is back.\n * @return {promise|undefined} if a callback is passed the method returns undefined\n * otherwise it returns a promise containing an object with two keys :\n *  - content with a SearchResults\n *  - state with the state used for the query as a SearchParameters\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the callback API\n * var state = helper.searchOnce({hitsPerPage: 1},\n *   function(error, content, state) {\n *     // if an error occurred it will be passed in error, otherwise its value is null\n *     // content contains the results formatted as a SearchResults\n *     // state is the instance of SearchParameters used for this search\n *   });\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the promise API\n * var state1 = helper.searchOnce({hitsPerPage: 1})\n *                 .then(promiseHandler);\n *\n * function promiseHandler(res) {\n *   // res contains\n *   // {\n *   //   content : SearchResults\n *   //   state   : SearchParameters (the one used for this specific search)\n *   // }\n * }\n */\nAlgoliaSearchHelper.prototype.searchOnce = function (options, cb) {\n  var tempState = !options\n    ? this.state\n    : this.state.setQueryParameters(options);\n  var queries = requestBuilder._getQueries(tempState.index, tempState);\n  // eslint-disable-next-line consistent-this\n  var self = this;\n\n  this._currentNbQueries++;\n\n  this.emit('searchOnce', {\n    state: tempState,\n  });\n\n  if (cb) {\n    this.client\n      .search(queries)\n      .then(function (content) {\n        self._currentNbQueries--;\n        if (self._currentNbQueries === 0) {\n          self.emit('searchQueueEmpty');\n        }\n\n        cb(null, new SearchResults(tempState, content.results), tempState);\n      })\n      .catch(function (err) {\n        self._currentNbQueries--;\n        if (self._currentNbQueries === 0) {\n          self.emit('searchQueueEmpty');\n        }\n\n        cb(err, null, tempState);\n      });\n\n    return undefined;\n  }\n\n  return this.client.search(queries).then(\n    function (content) {\n      self._currentNbQueries--;\n      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n      return {\n        content: new SearchResults(tempState, content.results),\n        state: tempState,\n        _originalResponse: content,\n      };\n    },\n    function (e) {\n      self._currentNbQueries--;\n      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n      throw e;\n    }\n  );\n};\n\n/**\n * Start the search for answers with the parameters set in the state.\n * This method returns a promise.\n * @param {Object} options - the options for answers API call\n * @param {string[]} options.attributesForPrediction - Attributes to use for predictions. If empty, `searchableAttributes` is used instead.\n * @param {string[]} options.queryLanguages - The languages in the query. Currently only supports ['en'].\n * @param {number} options.nbHits - Maximum number of answers to retrieve from the Answers Engine. Cannot be greater than 1000.\n *\n * @return {promise} the answer results\n * @deprecated answers is deprecated and will be replaced with new initiatives\n */\nAlgoliaSearchHelper.prototype.findAnswers = function (options) {\n  // eslint-disable-next-line no-console\n  console.warn('[algoliasearch-helper] answers is no longer supported');\n  var state = this.state;\n  var derivedHelper = this.derivedHelpers[0];\n  if (!derivedHelper) {\n    return Promise.resolve([]);\n  }\n  var derivedState = derivedHelper.getModifiedState(state);\n  var data = merge(\n    {\n      attributesForPrediction: options.attributesForPrediction,\n      nbHits: options.nbHits,\n    },\n    {\n      params: omit(requestBuilder._getHitsSearchParams(derivedState), [\n        'attributesToSnippet',\n        'hitsPerPage',\n        'restrictSearchableAttributes',\n        'snippetEllipsisText',\n      ]),\n    }\n  );\n\n  var errorMessage =\n    'search for answers was called, but this client does not have a function client.initIndex(index).findAnswers';\n  if (typeof this.client.initIndex !== 'function') {\n    throw new Error(errorMessage);\n  }\n  var index = this.client.initIndex(derivedState.index);\n  if (typeof index.findAnswers !== 'function') {\n    throw new Error(errorMessage);\n  }\n  return index.findAnswers(derivedState.query, options.queryLanguages, data);\n};\n\n/**\n * Structure of each result when using\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * @typedef FacetSearchHit\n * @type {object}\n * @property {string} value the facet value\n * @property {string} highlighted the facet value highlighted with the query string\n * @property {number} count number of occurrence of this facet value\n * @property {boolean} isRefined true if the value is already refined\n */\n\n/**\n * Structure of the data resolved by the\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * promise.\n * @typedef FacetSearchResult\n * @type {object}\n * @property {FacetSearchHit} facetHits the results for this search for facet values\n * @property {number} processingTimeMS time taken by the query inside the engine\n */\n\n/**\n * Search for facet values based on an query and the name of a faceted attribute. This\n * triggers a search and will return a promise. On top of using the query, it also sends\n * the parameters from the state so that the search is narrowed down to only the possible values.\n *\n * See the description of [FacetSearchResult](reference.html#FacetSearchResult)\n * @param {string} facet the name of the faceted attribute\n * @param {string} query the string query for the search\n * @param {number} [maxFacetHits] the maximum number values returned. Should be > 0 and <= 100\n * @param {object} [userState] the set of custom parameters to use on top of the current state. Setting a property to `undefined` removes\n * it in the generated query.\n * @return {promise.<FacetSearchResult>} the results of the search\n */\nAlgoliaSearchHelper.prototype.searchForFacetValues = function (\n  facet,\n  query,\n  maxFacetHits,\n  userState\n) {\n  var clientHasSFFV = typeof this.client.searchForFacetValues === 'function';\n  var clientHasInitIndex = typeof this.client.initIndex === 'function';\n  if (\n    !clientHasSFFV &&\n    !clientHasInitIndex &&\n    typeof this.client.search !== 'function'\n  ) {\n    throw new Error(\n      'search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues'\n    );\n  }\n\n  var state = this.state.setQueryParameters(userState || {});\n  var isDisjunctive = state.isDisjunctiveFacet(facet);\n  var algoliaQuery = requestBuilder.getSearchForFacetQuery(\n    facet,\n    query,\n    maxFacetHits,\n    state\n  );\n\n  this._currentNbQueries++;\n  // eslint-disable-next-line consistent-this\n  var self = this;\n  var searchForFacetValuesPromise;\n  // newer algoliasearch ^3.27.1 - ~4.0.0\n  if (clientHasSFFV) {\n    searchForFacetValuesPromise = this.client.searchForFacetValues([\n      { indexName: state.index, params: algoliaQuery },\n    ]);\n    // algoliasearch < 3.27.1\n  } else if (clientHasInitIndex) {\n    searchForFacetValuesPromise = this.client\n      .initIndex(state.index)\n      .searchForFacetValues(algoliaQuery);\n    // algoliasearch ~5.0.0\n  } else {\n    // @MAJOR only use client.search\n    delete algoliaQuery.facetName;\n    searchForFacetValuesPromise = this.client\n      .search([\n        {\n          type: 'facet',\n          facet: facet,\n          indexName: state.index,\n          params: algoliaQuery,\n        },\n      ])\n      .then(function processResponse(response) {\n        return response.results[0];\n      });\n  }\n\n  this.emit('searchForFacetValues', {\n    state: state,\n    facet: facet,\n    query: query,\n  });\n\n  return searchForFacetValuesPromise.then(\n    function addIsRefined(content) {\n      self._currentNbQueries--;\n      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n\n      content = Array.isArray(content) ? content[0] : content;\n\n      content.facetHits.forEach(function (f) {\n        f.escapedValue = escapeFacetValue(f.value);\n        f.isRefined = isDisjunctive\n          ? state.isDisjunctiveFacetRefined(facet, f.escapedValue)\n          : state.isFacetRefined(facet, f.escapedValue);\n      });\n\n      return content;\n    },\n    function (e) {\n      self._currentNbQueries--;\n      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n      throw e;\n    }\n  );\n};\n\n/**\n * Sets the text query used for the search.\n *\n * This method resets the current page to 0.\n * @param  {string} q the user query\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setQuery = function (q) {\n  this._change({\n    state: this.state.resetPage().setQuery(q),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Remove all the types of refinements except tags. A string can be provided to remove\n * only the refinements of a specific attribute. For more advanced use case, you can\n * provide a function instead. This function should follow the\n * [clearCallback definition](#SearchParameters.clearCallback).\n *\n * This method resets the current page to 0.\n * @param {string} [name] optional name of the facet / attribute on which we want to remove all refinements\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n * @example\n * // Removing all the refinements\n * helper.clearRefinements().search();\n * @example\n * // Removing all the filters on a the category attribute.\n * helper.clearRefinements('category').search();\n * @example\n * // Removing only the exclude filters on the category facet.\n * helper.clearRefinements(function(value, attribute, type) {\n *   return type === 'exclude' && attribute === 'category';\n * }).search();\n */\nAlgoliaSearchHelper.prototype.clearRefinements = function (name) {\n  this._change({\n    state: this.state.resetPage().clearRefinements(name),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Remove all the tag filters.\n *\n * This method resets the current page to 0.\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.clearTags = function () {\n  this._change({\n    state: this.state.resetPage().clearTags(),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Adds a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function (\n  facet,\n  value\n) {\n  this._change({\n    state: this.state.resetPage().addDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.addDisjunctiveRefine = function () {\n  return this.addDisjunctiveFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Adds a refinement on a hierarchical facet. It will throw\n * an exception if the facet is not defined or if the facet\n * is already refined.\n *\n * This method resets the current page to 0.\n * @param {string} facet the facet name\n * @param {string} path the hierarchical facet path\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @throws Error if the facet is not defined or if the facet is refined\n * @chainable\n * @fires change\n */\nAlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function (\n  facet,\n  path\n) {\n  this._change({\n    state: this.state.resetPage().addHierarchicalFacetRefinement(facet, path),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Adds a an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} operator the operator of the filter\n * @param  {number} value the value of the filter\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addNumericRefinement = function (\n  attribute,\n  operator,\n  value\n) {\n  this._change({\n    state: this.state\n      .resetPage()\n      .addNumericRefinement(attribute, operator, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Adds a filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addFacetRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.addRefine = function () {\n  return this.addFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Adds a an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addExcludeRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.addExclude = function () {\n  return this.addFacetExclusion.apply(this, arguments);\n};\n\n/**\n * Adds a tag filter with the `tag` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag the tag to add to the filter\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.addTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().addTagRefinement(tag),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Removes an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * Some parameters are optional, triggering different behavior:\n *  - if the value is not provided, then all the numeric value will be removed for the\n *  specified attribute/operator couple.\n *  - if the operator is not provided either, then all the numeric filter on this attribute\n *  will be removed.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} [operator] the operator of the filter\n * @param  {number} [value] the value of the filter\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeNumericRefinement = function (\n  attribute,\n  operator,\n  value\n) {\n  this._change({\n    state: this.state\n      .resetPage()\n      .removeNumericRefinement(attribute, operator, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Removes a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function (\n  facet,\n  value\n) {\n  this._change({\n    state: this.state\n      .resetPage()\n      .removeDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function () {\n  return this.removeDisjunctiveFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Removes the refinement set on a hierarchical facet.\n * @param {string} facet the facet name\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @throws Error if the facet is not defined or if the facet is not refined\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function (\n  facet\n) {\n  this._change({\n    state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Removes a filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeFacetRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.removeRefine = function () {\n  return this.removeFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Removes an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeExcludeRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.removeExclude = function () {\n  return this.removeFacetExclusion.apply(this, arguments);\n};\n\n/**\n * Removes a tag filter with the `tag` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove from the filter\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.removeTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().removeTagRefinement(tag),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Adds or removes an exclusion filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.toggleFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.toggleExclude = function () {\n  return this.toggleFacetExclusion.apply(this, arguments);\n};\n\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n * @deprecated since version 2.19.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.toggleRefinement = function (facet, value) {\n  return this.toggleFacetRefinement(facet, value);\n};\n\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.toggleFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleFacetRefinement(facet, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.toggleRefine = function () {\n  return this.toggleFacetRefinement.apply(this, arguments);\n};\n\n/**\n * Adds or removes a tag filter with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove or add\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.toggleTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().toggleTagRefinement(tag),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Increments the page number by one.\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n * @example\n * helper.setPage(0).nextPage().getPage();\n * // returns 1\n */\nAlgoliaSearchHelper.prototype.nextPage = function () {\n  var page = this.state.page || 0;\n  return this.setPage(page + 1);\n};\n\n/**\n * Decrements the page number by one.\n * @fires change\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @chainable\n * @example\n * helper.setPage(1).previousPage().getPage();\n * // returns 0\n */\nAlgoliaSearchHelper.prototype.previousPage = function () {\n  var page = this.state.page || 0;\n  return this.setPage(page - 1);\n};\n\n/**\n * @private\n * @param {number} page The page number\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @chainable\n * @fires change\n */\nfunction setCurrentPage(page) {\n  if (page < 0) throw new Error('Page requested below 0.');\n\n  this._change({\n    state: this.state.setPage(page),\n    isPageReset: false,\n  });\n\n  return this;\n}\n\n/**\n * Change the current page\n * @deprecated\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setCurrentPage = setCurrentPage;\n\n/**\n * Updates the current page.\n * @function\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setPage = setCurrentPage;\n\n/**\n * Updates the name of the index that will be targeted by the query.\n *\n * This method resets the current page to 0.\n * @param {string} name the index name\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setIndex = function (name) {\n  this._change({\n    state: this.state.resetPage().setIndex(name),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Update a parameter of the search. This method reset the page\n *\n * The complete list of parameters is available on the\n * [Algolia website](https://www.algolia.com/doc/rest#query-an-index).\n * The most commonly used parameters have their own [shortcuts](#query-parameters-shortcuts)\n * or benefit from higher-level APIs (all the kind of filters and facets have their own API)\n *\n * This method resets the current page to 0.\n * @param {string} parameter name of the parameter to update\n * @param {any} value new value of the parameter\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n * @example\n * helper.setQueryParameter('hitsPerPage', 20).search();\n */\nAlgoliaSearchHelper.prototype.setQueryParameter = function (parameter, value) {\n  this._change({\n    state: this.state.resetPage().setQueryParameter(parameter, value),\n    isPageReset: true,\n  });\n\n  return this;\n};\n\n/**\n * Set the whole state (warning: will erase previous state)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setState = function (newState) {\n  this._change({\n    state: SearchParameters.make(newState),\n    isPageReset: false,\n  });\n\n  return this;\n};\n\n/**\n * Override the current state without triggering a change event.\n * Do not use this method unless you know what you are doing. (see the example\n * for a legit use case)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n * @example\n *  helper.on('change', function(state){\n *    // In this function you might want to find a way to store the state in the url/history\n *    updateYourURL(state)\n *  })\n *  window.onpopstate = function(event){\n *    // This is naive though as you should check if the state is really defined etc.\n *    helper.overrideStateWithoutTriggeringChangeEvent(event.state).search()\n *  }\n * @chainable\n */\nAlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent =\n  function (newState) {\n    this.state = new SearchParameters(newState);\n    return this;\n  };\n\n/**\n * Check if an attribute has any numeric, conjunctive, disjunctive or hierarchical filters.\n * @param {string} attribute the name of the attribute\n * @return {boolean} true if the attribute is filtered by at least one value\n * @example\n * // hasRefinements works with numeric, conjunctive, disjunctive and hierarchical filters\n * helper.hasRefinements('price'); // false\n * helper.addNumericRefinement('price', '>', 100);\n * helper.hasRefinements('price'); // true\n *\n * helper.hasRefinements('color'); // false\n * helper.addFacetRefinement('color', 'blue');\n * helper.hasRefinements('color'); // true\n *\n * helper.hasRefinements('material'); // false\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * helper.hasRefinements('material'); // true\n *\n * helper.hasRefinements('categories'); // false\n * helper.toggleFacetRefinement('categories', 'kitchen > knife');\n * helper.hasRefinements('categories'); // true\n *\n */\nAlgoliaSearchHelper.prototype.hasRefinements = function (attribute) {\n  if (objectHasKeys(this.state.getNumericRefinements(attribute))) {\n    return true;\n  } else if (this.state.isConjunctiveFacet(attribute)) {\n    return this.state.isFacetRefined(attribute);\n  } else if (this.state.isDisjunctiveFacet(attribute)) {\n    return this.state.isDisjunctiveFacetRefined(attribute);\n  } else if (this.state.isHierarchicalFacet(attribute)) {\n    return this.state.isHierarchicalFacetRefined(attribute);\n  }\n\n  // there's currently no way to know that the user did call `addNumericRefinement` at some point\n  // thus we cannot distinguish if there once was a numeric refinement that was cleared\n  // so we will return false in every other situations to be consistent\n  // while what we should do here is throw because we did not find the attribute in any type\n  // of refinement\n  return false;\n};\n\n/**\n * Check if a value is excluded for a specific faceted attribute. If the value\n * is omitted then the function checks if there is any excluding refinements.\n *\n * @param  {string}  facet name of the attribute for used for faceting\n * @param  {string}  [value] optional value. If passed will test that this value\n * is filtering the given facet.\n * @return {boolean} true if refined\n * @example\n * helper.isExcludeRefined('color'); // false\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // false\n *\n * helper.addFacetExclusion('color', 'red');\n *\n * helper.isExcludeRefined('color'); // true\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // true\n */\nAlgoliaSearchHelper.prototype.isExcluded = function (facet, value) {\n  return this.state.isExcludeRefined(facet, value);\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}\n */\nAlgoliaSearchHelper.prototype.isDisjunctiveRefined = function (facet, value) {\n  return this.state.isDisjunctiveFacetRefined(facet, value);\n};\n\n/**\n * Check if the string is a currently filtering tag.\n * @param {string} tag tag to check\n * @return {boolean} true if the tag is currently refined\n */\nAlgoliaSearchHelper.prototype.hasTag = function (tag) {\n  return this.state.isTagRefined(tag);\n};\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}\n */\nAlgoliaSearchHelper.prototype.isTagRefined = function () {\n  return this.hasTagRefinements.apply(this, arguments);\n};\n\n/**\n * Get the name of the currently used index.\n * @return {string} name of the index\n * @example\n * helper.setIndex('highestPrice_products').getIndex();\n * // returns 'highestPrice_products'\n */\nAlgoliaSearchHelper.prototype.getIndex = function () {\n  return this.state.index;\n};\n\nfunction getCurrentPage() {\n  return this.state.page;\n}\n\n/**\n * Get the currently selected page\n * @deprecated\n * @return {number} the current page\n */\nAlgoliaSearchHelper.prototype.getCurrentPage = getCurrentPage;\n/**\n * Get the currently selected page\n * @function\n * @return {number} the current page\n */\nAlgoliaSearchHelper.prototype.getPage = getCurrentPage;\n\n/**\n * Get all the tags currently set to filters the results.\n *\n * @return {string[]} The list of tags currently set.\n */\nAlgoliaSearchHelper.prototype.getTags = function () {\n  return this.state.tagRefinements;\n};\n\n/**\n * Get the list of refinements for a given attribute. This method works with\n * conjunctive, disjunctive, excluding and numerical filters.\n *\n * See also SearchResults#getRefinements\n *\n * @param {string} facetName attribute name used for faceting\n * @return {Array.<FacetRefinement|NumericRefinement>} All Refinement are objects that contain a value, and\n * a type. Numeric also contains an operator.\n * @example\n * helper.addNumericRefinement('price', '>', 100);\n * helper.getRefinements('price');\n * // [\n * //   {\n * //     \"value\": [\n * //       100\n * //     ],\n * //     \"operator\": \">\",\n * //     \"type\": \"numeric\"\n * //   }\n * // ]\n * @example\n * helper.addFacetRefinement('color', 'blue');\n * helper.addFacetExclusion('color', 'red');\n * helper.getRefinements('color');\n * // [\n * //   {\n * //     \"value\": \"blue\",\n * //     \"type\": \"conjunctive\"\n * //   },\n * //   {\n * //     \"value\": \"red\",\n * //     \"type\": \"exclude\"\n * //   }\n * // ]\n * @example\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * // [\n * //   {\n * //     \"value\": \"plastic\",\n * //     \"type\": \"disjunctive\"\n * //   }\n * // ]\n */\nAlgoliaSearchHelper.prototype.getRefinements = function (facetName) {\n  var refinements = [];\n\n  if (this.state.isConjunctiveFacet(facetName)) {\n    var conjRefinements = this.state.getConjunctiveRefinements(facetName);\n\n    conjRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'conjunctive',\n      });\n    });\n\n    var excludeRefinements = this.state.getExcludeRefinements(facetName);\n\n    excludeRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'exclude',\n      });\n    });\n  } else if (this.state.isDisjunctiveFacet(facetName)) {\n    var disjunctiveRefinements =\n      this.state.getDisjunctiveRefinements(facetName);\n\n    disjunctiveRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'disjunctive',\n      });\n    });\n  }\n\n  var numericRefinements = this.state.getNumericRefinements(facetName);\n\n  Object.keys(numericRefinements).forEach(function (operator) {\n    var value = numericRefinements[operator];\n\n    refinements.push({\n      value: value,\n      operator: operator,\n      type: 'numeric',\n    });\n  });\n\n  return refinements;\n};\n\n/**\n * Return the current refinement for the (attribute, operator)\n * @param {string} attribute attribute in the record\n * @param {string} operator operator applied on the refined values\n * @return {Array.<number|number[]>} refined values\n */\nAlgoliaSearchHelper.prototype.getNumericRefinement = function (\n  attribute,\n  operator\n) {\n  return this.state.getNumericRefinement(attribute, operator);\n};\n\n/**\n * Get the current breadcrumb for a hierarchical facet, as an array\n * @param  {string} facetName Hierarchical facet name\n * @return {array.<string>} the path as an array of string\n */\nAlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function (\n  facetName\n) {\n  return this.state.getHierarchicalFacetBreadcrumb(facetName);\n};\n\n// /////////// PRIVATE\n\n/**\n * Perform the underlying queries\n * @private\n * @param {object} options options for the query\n * @param {boolean} [options.onlyWithDerivedHelpers=false] if true, only the derived helpers will be queried\n * @return {undefined} does not return anything\n * @fires search\n * @fires result\n * @fires error\n */\nAlgoliaSearchHelper.prototype._search = function (options) {\n  var state = this.state;\n  var states = [];\n  var mainQueries = [];\n\n  if (!options.onlyWithDerivedHelpers) {\n    mainQueries = requestBuilder._getQueries(state.index, state);\n\n    states.push({\n      state: state,\n      queriesCount: mainQueries.length,\n      helper: this,\n    });\n\n    this.emit('search', {\n      state: state,\n      results: this.lastResults,\n    });\n  }\n\n  var derivedQueries = this.derivedHelpers.map(function (derivedHelper) {\n    var derivedState = derivedHelper.getModifiedState(state);\n    var derivedStateQueries = derivedState.index\n      ? requestBuilder._getQueries(derivedState.index, derivedState)\n      : [];\n\n    states.push({\n      state: derivedState,\n      queriesCount: derivedStateQueries.length,\n      helper: derivedHelper,\n    });\n\n    derivedHelper.emit('search', {\n      state: derivedState,\n      results: derivedHelper.lastResults,\n    });\n\n    return derivedStateQueries;\n  });\n\n  var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);\n\n  var queryId = this._queryId++;\n  this._currentNbQueries++;\n\n  if (!queries.length) {\n    return Promise.resolve({ results: [] }).then(\n      this._dispatchAlgoliaResponse.bind(this, states, queryId)\n    );\n  }\n\n  try {\n    this.client\n      .search(queries)\n      .then(this._dispatchAlgoliaResponse.bind(this, states, queryId))\n      .catch(this._dispatchAlgoliaError.bind(this, queryId));\n  } catch (error) {\n    // If we reach this part, we're in an internal error state\n    this.emit('error', {\n      error: error,\n    });\n  }\n\n  return undefined;\n};\n\n/**\n * Transform the responses as sent by the server and transform them into a user\n * usable object that merge the results of all the batch requests. It will dispatch\n * over the different helper + derived helpers (when there are some).\n * @private\n * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>} states state used to generate the request\n * @param {number} queryId id of the current request\n * @param {object} content content of the response\n * @return {undefined}\n */\nAlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function (\n  states,\n  queryId,\n  content\n) {\n  // @TODO remove the number of outdated queries discarded instead of just one\n\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n\n  var results = content.results.slice();\n\n  states.forEach(function (s) {\n    var state = s.state;\n    var queriesCount = s.queriesCount;\n    var helper = s.helper;\n    var specificResults = results.splice(0, queriesCount);\n\n    if (!state.index) {\n      helper.emit('result', {\n        results: null,\n        state: state,\n      });\n      return;\n    }\n\n    helper.lastResults = new SearchResults(state, specificResults);\n\n    helper.emit('result', {\n      results: helper.lastResults,\n      state: state,\n    });\n  });\n};\n\nAlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (\n  queryId,\n  error\n) {\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n\n  this.emit('error', {\n    error: error,\n  });\n\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n};\n\nAlgoliaSearchHelper.prototype.containsRefinement = function (\n  query,\n  facetFilters,\n  numericFilters,\n  tagFilters\n) {\n  return (\n    query ||\n    facetFilters.length !== 0 ||\n    numericFilters.length !== 0 ||\n    tagFilters.length !== 0\n  );\n};\n\n/**\n * Test if there are some disjunctive refinements on the facet\n * @private\n * @param {string} facet the attribute to test\n * @return {boolean} true if there are refinements on this attribute\n */\nAlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function (facet) {\n  return (\n    this.state.disjunctiveRefinements[facet] &&\n    this.state.disjunctiveRefinements[facet].length > 0\n  );\n};\n\nAlgoliaSearchHelper.prototype._change = function (event) {\n  var state = event.state;\n  var isPageReset = event.isPageReset;\n\n  if (state !== this.state) {\n    this.state = state;\n\n    this.emit('change', {\n      state: this.state,\n      results: this.lastResults,\n      isPageReset: isPageReset,\n    });\n  }\n};\n\n/**\n * Clears the cache of the underlying Algolia client.\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n */\nAlgoliaSearchHelper.prototype.clearCache = function () {\n  if (this.client.clearCache) this.client.clearCache();\n  return this;\n};\n\n/**\n * Updates the internal client instance. If the reference of the clients\n * are equal then no update is actually done.\n * @param  {AlgoliaSearch} newClient an AlgoliaSearch client\n * @return {AlgoliaSearchHelper} Method is chainable, it returns itself\n */\nAlgoliaSearchHelper.prototype.setClient = function (newClient) {\n  if (this.client === newClient) return this;\n\n  if (typeof newClient.addAlgoliaAgent === 'function') {\n    newClient.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n  this.client = newClient;\n\n  return this;\n};\n\n/**\n * Gets the instance of the currently used client.\n * @return {AlgoliaSearch} the currently used client\n */\nAlgoliaSearchHelper.prototype.getClient = function () {\n  return this.client;\n};\n\n/**\n * Creates an derived instance of the Helper. A derived helper\n * is a way to request other indices synchronised with the lifecycle\n * of the main Helper. This mechanism uses the multiqueries feature\n * of Algolia to aggregate all the requests in a single network call.\n *\n * This method takes a function that is used to create a new SearchParameter\n * that will be used to create requests to Algolia. Those new requests\n * are created just before the `search` event. The signature of the function\n * is `SearchParameters -> SearchParameters`.\n *\n * This method returns a new DerivedHelper which is an EventEmitter\n * that fires the same `search`, `result` and `error` events. Those\n * events, however, will receive data specific to this DerivedHelper\n * and the SearchParameters that is returned by the call of the\n * parameter function.\n * @param {function} fn SearchParameters -> SearchParameters\n * @return {DerivedHelper} a new DerivedHelper\n */\nAlgoliaSearchHelper.prototype.derive = function (fn) {\n  var derivedHelper = new DerivedHelper(this, fn);\n  this.derivedHelpers.push(derivedHelper);\n  return derivedHelper;\n};\n\n/**\n * This method detaches a derived Helper from the main one. Prefer using the one from the\n * derived helper itself, to remove the event listeners too.\n * @private\n * @param  {DerivedHelper} derivedHelper the derived helper to detach\n * @return {undefined} nothing is returned\n * @throws Error\n */\nAlgoliaSearchHelper.prototype.detachDerivedHelper = function (derivedHelper) {\n  var pos = this.derivedHelpers.indexOf(derivedHelper);\n  if (pos === -1) throw new Error('Derived helper already detached');\n  this.derivedHelpers.splice(pos, 1);\n};\n\n/**\n * This method returns true if there is currently at least one on-going search.\n * @return {boolean} true if there is a search pending\n */\nAlgoliaSearchHelper.prototype.hasPendingRequests = function () {\n  return this._currentNbQueries > 0;\n};\n\n/**\n * @typedef AlgoliaSearchHelper.NumericRefinement\n * @type {object}\n * @property {number[]} value the numbers that are used for filtering this attribute with\n * the operator specified.\n * @property {string} operator the faceting data: value, number of entries\n * @property {string} type will be 'numeric'\n */\n\n/**\n * @typedef AlgoliaSearchHelper.FacetRefinement\n * @type {object}\n * @property {string} value the string use to filter the attribute\n * @property {string} type the type of filter: 'conjunctive', 'disjunctive', 'exclude'\n */\n\nmodule.exports = AlgoliaSearchHelper;\n","'use strict';\n\nmodule.exports = function compact(array) {\n  if (!Array.isArray(array)) {\n    return [];\n  }\n\n  return array.filter(Boolean);\n};\n","'use strict';\n\n// NOTE: this behaves like lodash/defaults, but doesn't mutate the target\n// it also preserve keys order\nmodule.exports = function defaultsPure() {\n  var sources = Array.prototype.slice.call(arguments);\n\n  return sources.reduceRight(function (acc, source) {\n    Object.keys(Object(source)).forEach(function (key) {\n      if (source[key] === undefined) {\n        return;\n      }\n      if (acc[key] !== undefined) {\n        // remove if already added, so that we can add it in correct order\n        delete acc[key];\n      }\n      acc[key] = source[key];\n    });\n    return acc;\n  }, {});\n};\n","'use strict';\n\n/**\n * Replaces a leading - with \\-\n * @private\n * @param {any} value the facet value to replace\n * @returns {any} the escaped facet value or the value if it was not a string\n */\nfunction escapeFacetValue(value) {\n  if (typeof value !== 'string') return value;\n\n  return String(value).replace(/^-/, '\\\\-');\n}\n\n/**\n * Replaces a leading \\- with -\n * @private\n * @param {any} value the escaped facet value\n * @returns {any} the unescaped facet value or the value if it was not a string\n */\nfunction unescapeFacetValue(value) {\n  if (typeof value !== 'string') return value;\n\n  return value.replace(/^\\\\-/, '-');\n}\n\nmodule.exports = {\n  escapeFacetValue: escapeFacetValue,\n  unescapeFacetValue: unescapeFacetValue,\n};\n","'use strict';\n\n// @MAJOR can be replaced by native Array#find when we change support\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return undefined;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return array[i];\n    }\n  }\n\n  return undefined;\n};\n","'use strict';\n\n// @MAJOR can be replaced by native Array#findIndex when we change support\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return -1;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return i;\n    }\n  }\n  return -1;\n};\n","'use strict';\n\nvar find = require('./find');\n\n/**\n * Transform sort format from user friendly notation to lodash format\n * @param {string[]} sortBy array of predicate of the form \"attribute:order\"\n * @param {string[]} [defaults] array of predicate of the form \"attribute:order\"\n * @return {array.<string[]>} array containing 2 elements : attributes, orders\n */\nmodule.exports = function formatSort(sortBy, defaults) {\n  var defaultInstructions = (defaults || []).map(function (sort) {\n    return sort.split(':');\n  });\n\n  return sortBy.reduce(\n    function preparePredicate(out, sort) {\n      var sortInstruction = sort.split(':');\n\n      var matchingDefault = find(\n        defaultInstructions,\n        function (defaultInstruction) {\n          return defaultInstruction[0] === sortInstruction[0];\n        }\n      );\n\n      if (sortInstruction.length > 1 || !matchingDefault) {\n        out[0].push(sortInstruction[0]);\n        out[1].push(sortInstruction[1]);\n        return out;\n      }\n\n      out[0].push(matchingDefault[0]);\n      out[1].push(matchingDefault[1]);\n      return out;\n    },\n    [[], []]\n  );\n};\n","'use strict';\n\nfunction inherits(ctor, superCtor) {\n  ctor.prototype = Object.create(superCtor.prototype, {\n    constructor: {\n      value: ctor,\n      enumerable: false,\n      writable: true,\n      configurable: true,\n    },\n  });\n}\n\nmodule.exports = inherits;\n","'use strict';\n\nfunction intersection(arr1, arr2) {\n  return arr1.filter(function (value, index) {\n    return (\n      arr2.indexOf(value) > -1 &&\n      arr1.indexOf(value) === index /* skips duplicates */\n    );\n  });\n}\n\nmodule.exports = intersection;\n","'use strict';\n\nfunction clone(value) {\n  if (typeof value === 'object' && value !== null) {\n    return _merge(Array.isArray(value) ? [] : {}, value);\n  }\n  return value;\n}\n\nfunction isObjectOrArrayOrFunction(value) {\n  return (\n    typeof value === 'function' ||\n    Array.isArray(value) ||\n    Object.prototype.toString.call(value) === '[object Object]'\n  );\n}\n\nfunction _merge(target, source) {\n  if (target === source) {\n    return target;\n  }\n\n  // eslint-disable-next-line no-restricted-syntax\n  for (var key in source) {\n    if (\n      !Object.prototype.hasOwnProperty.call(source, key) ||\n      key === '__proto__' ||\n      key === 'constructor'\n    ) {\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n\n    var sourceVal = source[key];\n    var targetVal = target[key];\n\n    if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n\n    if (\n      isObjectOrArrayOrFunction(targetVal) &&\n      isObjectOrArrayOrFunction(sourceVal)\n    ) {\n      target[key] = _merge(targetVal, sourceVal);\n    } else {\n      target[key] = clone(sourceVal);\n    }\n  }\n  return target;\n}\n\n/**\n * This method is like Object.assign, but recursively merges own and inherited\n * enumerable keyed properties of source objects into the destination object.\n *\n * NOTE: this behaves like lodash/merge, but:\n * - does mutate functions if they are a source\n * - treats non-plain objects as plain\n * - does not work for circular objects\n * - treats sparse arrays as sparse\n * - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays\n *\n * @param {Object} target The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n */\nfunction merge(target) {\n  if (!isObjectOrArrayOrFunction(target)) {\n    target = {};\n  }\n\n  for (var i = 1, l = arguments.length; i < l; i++) {\n    var source = arguments[i];\n\n    if (isObjectOrArrayOrFunction(source)) {\n      _merge(target, source);\n    }\n  }\n  return target;\n}\n\nmodule.exports = merge;\n","'use strict';\n\nfunction objectHasKeys(obj) {\n  return obj && Object.keys(obj).length > 0;\n}\n\nmodule.exports = objectHasKeys;\n","'use strict';\n\n// https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source === null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key;\n  var i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    // eslint-disable-next-line no-continue\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\n\nmodule.exports = _objectWithoutPropertiesLoose;\n","'use strict';\n\nfunction compareAscending(value, other) {\n  if (value !== other) {\n    var valIsDefined = value !== undefined;\n    var valIsNull = value === null;\n\n    var othIsDefined = other !== undefined;\n    var othIsNull = other === null;\n\n    if (\n      (!othIsNull && value > other) ||\n      (valIsNull && othIsDefined) ||\n      !valIsDefined\n    ) {\n      return 1;\n    }\n    if (\n      (!valIsNull && value < other) ||\n      (othIsNull && valIsDefined) ||\n      !othIsDefined\n    ) {\n      return -1;\n    }\n  }\n  return 0;\n}\n\n/**\n * @param {Array<object>} collection object with keys in attributes\n * @param {Array<string>} iteratees attributes\n * @param {Array<string>} orders asc | desc\n * @return {Array<object>} sorted collection\n */\nfunction orderBy(collection, iteratees, orders) {\n  if (!Array.isArray(collection)) {\n    return [];\n  }\n\n  if (!Array.isArray(orders)) {\n    orders = [];\n  }\n\n  var result = collection.map(function (value, index) {\n    return {\n      criteria: iteratees.map(function (iteratee) {\n        return value[iteratee];\n      }),\n      index: index,\n      value: value,\n    };\n  });\n\n  result.sort(function comparer(object, other) {\n    var index = -1;\n\n    while (++index < object.criteria.length) {\n      var res = compareAscending(object.criteria[index], other.criteria[index]);\n      if (res) {\n        if (index >= orders.length) {\n          return res;\n        }\n        if (orders[index] === 'desc') {\n          return -res;\n        }\n        return res;\n      }\n    }\n\n    // This ensures a stable sort in V8 and other engines.\n    // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n    return object.index - other.index;\n  });\n\n  return result.map(function (res) {\n    return res.value;\n  });\n}\n\nmodule.exports = orderBy;\n","'use strict';\n\nfunction valToNumber(v) {\n  if (typeof v === 'number') {\n    return v;\n  } else if (typeof v === 'string') {\n    return parseFloat(v);\n  } else if (Array.isArray(v)) {\n    return v.map(valToNumber);\n  }\n\n  throw new Error(\n    'The value should be a number, a parsable string or an array of those.'\n  );\n}\n\nmodule.exports = valToNumber;\n","'use strict';\n\nvar merge = require('./functions/merge');\n\nfunction sortObject(obj) {\n  return Object.keys(obj)\n    .sort()\n    .reduce(function (acc, curr) {\n      acc[curr] = obj[curr];\n      return acc;\n    }, {});\n}\n\nvar requestBuilder = {\n  /**\n   * Get all the queries to send to the client, those queries can used directly\n   * with the Algolia client.\n   * @private\n   * @param  {string} index The name of the index\n   * @param  {SearchParameters} state The state from which to get the queries\n   * @return {object[]} The queries\n   */\n  _getQueries: function getQueries(index, state) {\n    var queries = [];\n\n    // One query for the hits\n    queries.push({\n      indexName: index,\n      params: requestBuilder._getHitsSearchParams(state),\n    });\n\n    // One for each disjunctive facets\n    state.getRefinedDisjunctiveFacets().forEach(function (refinedFacet) {\n      queries.push({\n        indexName: index,\n        params: requestBuilder._getDisjunctiveFacetSearchParams(\n          state,\n          refinedFacet\n        ),\n      });\n    });\n\n    // More to get the parent levels of the hierarchical facets when refined\n    state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {\n      var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n      var currentRefinement = state.getHierarchicalRefinement(refinedFacet);\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      // If we are deeper than level 0 (starting from `beer > IPA`)\n      // we want to get all parent values\n      if (\n        currentRefinement.length > 0 &&\n        currentRefinement[0].split(separator).length > 1\n      ) {\n        // We generate a map of the filters we will use for our facet values queries\n        var filtersMap = currentRefinement[0]\n          .split(separator)\n          .slice(0, -1)\n          .reduce(function createFiltersMap(map, segment, level) {\n            return map.concat({\n              attribute: hierarchicalFacet.attributes[level],\n              value:\n                level === 0\n                  ? segment\n                  : [map[map.length - 1].value, segment].join(separator),\n            });\n          }, []);\n\n        filtersMap.forEach(function (filter, level) {\n          var params = requestBuilder._getDisjunctiveFacetSearchParams(\n            state,\n            filter.attribute,\n            level === 0\n          );\n\n          // Keep facet filters unrelated to current hierarchical attributes\n          function hasHierarchicalFacetFilter(value) {\n            return hierarchicalFacet.attributes.some(function (attribute) {\n              return attribute === value.split(':')[0];\n            });\n          }\n\n          var filteredFacetFilters = (params.facetFilters || []).reduce(\n            function (acc, facetFilter) {\n              if (Array.isArray(facetFilter)) {\n                var filtered = facetFilter.filter(function (filterValue) {\n                  return !hasHierarchicalFacetFilter(filterValue);\n                });\n\n                if (filtered.length > 0) {\n                  acc.push(filtered);\n                }\n              }\n\n              if (\n                typeof facetFilter === 'string' &&\n                !hasHierarchicalFacetFilter(facetFilter)\n              ) {\n                acc.push(facetFilter);\n              }\n\n              return acc;\n            },\n            []\n          );\n\n          var parent = filtersMap[level - 1];\n          if (level > 0) {\n            params.facetFilters = filteredFacetFilters.concat(\n              parent.attribute + ':' + parent.value\n            );\n          } else {\n            params.facetFilters =\n              filteredFacetFilters.length > 0\n                ? filteredFacetFilters\n                : undefined;\n          }\n\n          queries.push({ indexName: index, params: params });\n        });\n      }\n    });\n\n    return queries;\n  },\n\n  /**\n   * Build search parameters used to fetch hits\n   * @private\n   * @param  {SearchParameters} state The state from which to get the queries\n   * @return {object.<string, any>} The search parameters for hits\n   */\n  _getHitsSearchParams: function (state) {\n    var facets = state.facets\n      .concat(state.disjunctiveFacets)\n      .concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state))\n      .sort();\n\n    var facetFilters = requestBuilder._getFacetFilters(state);\n    var numericFilters = requestBuilder._getNumericFilters(state);\n    var tagFilters = requestBuilder._getTagFilters(state);\n    var additionalParams = {\n      facets: facets.indexOf('*') > -1 ? ['*'] : facets,\n      tagFilters: tagFilters,\n    };\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    return sortObject(merge({}, state.getQueryParams(), additionalParams));\n  },\n\n  /**\n   * Build search parameters used to fetch a disjunctive facet\n   * @private\n   * @param  {SearchParameters} state The state from which to get the queries\n   * @param  {string} facet the associated facet name\n   * @param  {boolean} hierarchicalRootLevel ?? FIXME\n   * @return {object} The search parameters for a disjunctive facet\n   */\n  _getDisjunctiveFacetSearchParams: function (\n    state,\n    facet,\n    hierarchicalRootLevel\n  ) {\n    var facetFilters = requestBuilder._getFacetFilters(\n      state,\n      facet,\n      hierarchicalRootLevel\n    );\n    var numericFilters = requestBuilder._getNumericFilters(state, facet);\n    var tagFilters = requestBuilder._getTagFilters(state);\n    var additionalParams = {\n      hitsPerPage: 0,\n      page: 0,\n      analytics: false,\n      clickAnalytics: false,\n    };\n\n    if (tagFilters.length > 0) {\n      additionalParams.tagFilters = tagFilters;\n    }\n\n    var hierarchicalFacet = state.getHierarchicalFacetByName(facet);\n\n    if (hierarchicalFacet) {\n      additionalParams.facets =\n        requestBuilder._getDisjunctiveHierarchicalFacetAttribute(\n          state,\n          hierarchicalFacet,\n          hierarchicalRootLevel\n        );\n    } else {\n      additionalParams.facets = facet;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    return sortObject(merge({}, state.getQueryParams(), additionalParams));\n  },\n\n  /**\n   * Return the numeric filters in an algolia request fashion\n   * @private\n   * @param {SearchParameters} state the state from which to get the filters\n   * @param {string} [facetName] the name of the attribute for which the filters should be excluded\n   * @return {string[]} the numeric filters in the algolia format\n   */\n  _getNumericFilters: function (state, facetName) {\n    if (state.numericFilters) {\n      return state.numericFilters;\n    }\n\n    var numericFilters = [];\n\n    Object.keys(state.numericRefinements).forEach(function (attribute) {\n      var operators = state.numericRefinements[attribute] || {};\n      Object.keys(operators).forEach(function (operator) {\n        var values = operators[operator] || [];\n        if (facetName !== attribute) {\n          values.forEach(function (value) {\n            if (Array.isArray(value)) {\n              var vs = value.map(function (v) {\n                return attribute + operator + v;\n              });\n              numericFilters.push(vs);\n            } else {\n              numericFilters.push(attribute + operator + value);\n            }\n          });\n        }\n      });\n    });\n\n    return numericFilters;\n  },\n\n  /**\n   * Return the tags filters depending on which format is used, either tagFilters or tagRefinements\n   * @private\n   * @param {SearchParameters} state the state from which to get the filters\n   * @return {string} Tag filters in a single string\n   */\n  _getTagFilters: function (state) {\n    if (state.tagFilters) {\n      return state.tagFilters;\n    }\n\n    return state.tagRefinements.join(',');\n  },\n\n  /**\n   * Build facetFilters parameter based on current refinements. The array returned\n   * contains strings representing the facet filters in the algolia format.\n   * @private\n   * @param  {SearchParameters} state The state from which to get the queries\n   * @param  {string} [facet] if set, the current disjunctive facet\n   * @param  {boolean} [hierarchicalRootLevel] ?? FIXME\n   * @return {array.<string>} The facet filters in the algolia format\n   */\n  _getFacetFilters: function (state, facet, hierarchicalRootLevel) {\n    var facetFilters = [];\n\n    var facetsRefinements = state.facetsRefinements || {};\n    Object.keys(facetsRefinements)\n      .sort()\n      .forEach(function (facetName) {\n        var facetValues = facetsRefinements[facetName] || [];\n        facetValues.sort().forEach(function (facetValue) {\n          facetFilters.push(facetName + ':' + facetValue);\n        });\n      });\n\n    var facetsExcludes = state.facetsExcludes || {};\n    Object.keys(facetsExcludes)\n      .sort()\n      .forEach(function (facetName) {\n        var facetValues = facetsExcludes[facetName] || [];\n        facetValues.sort().forEach(function (facetValue) {\n          facetFilters.push(facetName + ':-' + facetValue);\n        });\n      });\n\n    var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};\n    Object.keys(disjunctiveFacetsRefinements)\n      .sort()\n      .forEach(function (facetName) {\n        var facetValues = disjunctiveFacetsRefinements[facetName] || [];\n        if (facetName === facet || !facetValues || facetValues.length === 0) {\n          return;\n        }\n        var orFilters = [];\n\n        facetValues.sort().forEach(function (facetValue) {\n          orFilters.push(facetName + ':' + facetValue);\n        });\n\n        facetFilters.push(orFilters);\n      });\n\n    var hierarchicalFacetsRefinements =\n      state.hierarchicalFacetsRefinements || {};\n    Object.keys(hierarchicalFacetsRefinements)\n      .sort()\n      .forEach(function (facetName) {\n        var facetValues = hierarchicalFacetsRefinements[facetName] || [];\n        var facetValue = facetValues[0];\n\n        if (facetValue === undefined) {\n          return;\n        }\n\n        var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);\n        var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n        var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n        var attributeToRefine;\n        var attributesIndex;\n\n        // we ask for parent facet values only when the `facet` is the current hierarchical facet\n        if (facet === facetName) {\n          // if we are at the root level already, no need to ask for facet values, we get them from\n          // the hits query\n          if (\n            facetValue.indexOf(separator) === -1 ||\n            (!rootPath && hierarchicalRootLevel === true) ||\n            (rootPath &&\n              rootPath.split(separator).length ===\n                facetValue.split(separator).length)\n          ) {\n            return;\n          }\n\n          if (!rootPath) {\n            attributesIndex = facetValue.split(separator).length - 2;\n            facetValue = facetValue.slice(0, facetValue.lastIndexOf(separator));\n          } else {\n            attributesIndex = rootPath.split(separator).length - 1;\n            facetValue = rootPath;\n          }\n\n          attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n        } else {\n          attributesIndex = facetValue.split(separator).length - 1;\n\n          attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n        }\n\n        if (attributeToRefine) {\n          facetFilters.push([attributeToRefine + ':' + facetValue]);\n        }\n      });\n\n    return facetFilters;\n  },\n\n  _getHitsHierarchicalFacetsAttributes: function (state) {\n    var out = [];\n\n    return state.hierarchicalFacets.reduce(\n      // ask for as much levels as there's hierarchical refinements\n      function getHitsAttributesForHierarchicalFacet(\n        allAttributes,\n        hierarchicalFacet\n      ) {\n        var hierarchicalRefinement = state.getHierarchicalRefinement(\n          hierarchicalFacet.name\n        )[0];\n\n        // if no refinement, ask for root level\n        if (!hierarchicalRefinement) {\n          allAttributes.push(hierarchicalFacet.attributes[0]);\n          return allAttributes;\n        }\n\n        var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n        var level = hierarchicalRefinement.split(separator).length;\n        var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);\n\n        return allAttributes.concat(newAttributes);\n      },\n      out\n    );\n  },\n\n  _getDisjunctiveHierarchicalFacetAttribute: function (\n    state,\n    hierarchicalFacet,\n    rootLevel\n  ) {\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n    if (rootLevel === true) {\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n      var attributeIndex = 0;\n\n      if (rootPath) {\n        attributeIndex = rootPath.split(separator).length;\n      }\n      return [hierarchicalFacet.attributes[attributeIndex]];\n    }\n\n    var hierarchicalRefinement =\n      state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';\n    // if refinement is 'beers > IPA > Flying dog',\n    // then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)\n\n    var parentLevel = hierarchicalRefinement.split(separator).length - 1;\n    return hierarchicalFacet.attributes.slice(0, parentLevel + 1);\n  },\n\n  getSearchForFacetQuery: function (facetName, query, maxFacetHits, state) {\n    var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName)\n      ? state.clearRefinements(facetName)\n      : state;\n    var searchForFacetSearchParameters = {\n      facetQuery: query,\n      facetName: facetName,\n    };\n    if (typeof maxFacetHits === 'number') {\n      searchForFacetSearchParameters.maxFacetHits = maxFacetHits;\n    }\n    return sortObject(\n      merge(\n        {},\n        requestBuilder._getHitsSearchParams(stateForSearchForFacetValues),\n        searchForFacetSearchParameters\n      )\n    );\n  },\n};\n\nmodule.exports = requestBuilder;\n","'use strict';\n\nmodule.exports = function isValidUserToken(userToken) {\n  if (userToken === null) {\n    return false;\n  }\n  return /^[a-zA-Z0-9_-]{1,64}$/.test(userToken);\n};\n","'use strict';\n\nmodule.exports = '3.14.0';\n","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport PropTypes from 'prop-types';\nimport createConnector from \"../core/createConnector.js\";\nimport { cleanUpValue, refineValue, getCurrentRefinementValue, getIndexId } from \"../core/indexUtils.js\";\nfunction getId() {\n  return 'query';\n}\nfunction getCurrentRefinement(props, searchState, context) {\n  var id = getId(props);\n  var currentRefinement = getCurrentRefinementValue(props, searchState, context, id, '');\n  if (currentRefinement) {\n    return currentRefinement;\n  }\n  return '';\n}\nfunction _refine(props, searchState, nextRefinement, context) {\n  var id = getId();\n  var nextValue = _defineProperty({}, id, nextRefinement);\n  var resetPage = true;\n  return refineValue(searchState, nextValue, context, resetPage);\n}\nfunction _cleanUp(props, searchState, context) {\n  return cleanUpValue(searchState, context, getId());\n}\n\n/**\n * connectSearchBox connector provides the logic to build a widget that will\n * let the user search for a query\n * @name connectSearchBox\n * @kind connector\n * @propType {string} [defaultRefinement] - Provide a default value for the query\n * @providedPropType {function} refine - a function to change the current query\n * @providedPropType {string} currentRefinement - the current query used\n * @providedPropType {boolean} isSearchStalled - a flag that indicates if InstantSearch has detected that searches are stalled\n */\nexport default createConnector({\n  displayName: 'AlgoliaSearchBox',\n  $$type: 'ais.searchBox',\n  propTypes: {\n    defaultRefinement: PropTypes.string\n  },\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    return {\n      currentRefinement: getCurrentRefinement(props, searchState, {\n        ais: props.contextValue,\n        multiIndexContext: props.indexContextValue\n      }),\n      isSearchStalled: searchResults.isSearchStalled\n    };\n  },\n  refine: function refine(props, searchState, nextRefinement) {\n    return _refine(props, searchState, nextRefinement, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  cleanUp: function cleanUp(props, searchState) {\n    return _cleanUp(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  getSearchParameters: function getSearchParameters(searchParameters, props, searchState) {\n    return searchParameters.setQuery(getCurrentRefinement(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    }));\n  },\n  getMetadata: function getMetadata(props, searchState) {\n    var id = getId(props);\n    var currentRefinement = getCurrentRefinement(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    return {\n      id: id,\n      index: getIndexId({\n        ais: props.contextValue,\n        multiIndexContext: props.indexContextValue\n      }),\n      items: currentRefinement === null ? [] : [{\n        label: \"\".concat(id, \": \").concat(currentRefinement),\n        value: function value(nextState) {\n          return _refine(props, nextState, '', {\n            ais: props.contextValue,\n            multiIndexContext: props.indexContextValue\n          });\n        },\n        currentRefinement: currentRefinement\n      }]\n    };\n  }\n});","import createConnector from \"../core/createConnector.js\";\nimport { getResults } from \"../core/indexUtils.js\";\n\n/**\n * The `connectStateResults` connector provides a way to access the `searchState` and the `searchResults`\n * of InstantSearch.\n * For instance this connector allows you to create results/noResults or query/noQuery pages.\n * @name connectStateResults\n * @kind connector\n * @providedPropType {object} searchState - The search state of the instant search component. <br/><br/> See: [Search state structure](https://community.algolia.com/react-instantsearch/guide/Search_state.html)\n * @providedPropType {object} searchResults - The search results. <br/><br/> In case of multiple indices: if used under `<Index>`, results will be those of the corresponding index otherwise it'll be those of the root index  See: [Search results structure](https://community.algolia.com/algoliasearch-helper-js/reference.html#searchresults)\n * @providedPropType {object} allSearchResults - In case of multiple indices you can retrieve all the results\n * @providedPropType {string} error - If the search failed, the error will be logged here.\n * @providedPropType {boolean} searching - If there is a search in progress.\n * @providedPropType {boolean} isSearchStalled - Flag that indicates if React InstantSearch has detected that searches are stalled.\n * @providedPropType {boolean} searchingForFacetValues - If there is a search in a list in progress.\n * @providedPropType {object} props - component props.\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits, connectStateResults } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const Content = connectStateResults(({ searchState, searchResults }) => {\n *   const hasResults = searchResults && searchResults.nbHits !== 0;\n *\n *    return (\n *      <div>\n *        <div hidden={!hasResults}>\n *          <Hits />\n *        </div>\n *        <div hidden={hasResults}>\n *          <div>No results has been found for {searchState.query}</div>\n *        </div>\n *      </div>\n *    );\n * });\n *\n * const App = () => (\n *   <InstantSearch\n *      searchClient={searchClient}\n *      indexName=\"instant_search\"\n *    >\n *      <SearchBox />\n *      <Content />\n *    </InstantSearch>\n * );\n */\nexport default createConnector({\n  displayName: 'AlgoliaStateResults',\n  $$type: 'ais.stateResults',\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    var results = getResults(searchResults, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    return {\n      searchState: searchState,\n      searchResults: results,\n      allSearchResults: searchResults.results,\n      searching: searchResults.searching,\n      isSearchStalled: searchResults.isSearchStalled,\n      error: searchResults.error,\n      searchingForFacetValues: searchResults.searchingForFacetValues,\n      props: props\n    };\n  }\n});","import { createContext } from 'react';\nexport var instantSearchContext = /*#__PURE__*/createContext({\n  onInternalStateUpdate: function onInternalStateUpdate() {\n    return undefined;\n  },\n  createHrefForState: function createHrefForState() {\n    return '#';\n  },\n  onSearchForFacetValues: function onSearchForFacetValues() {\n    return undefined;\n  },\n  onSearchStateChange: function onSearchStateChange() {\n    return undefined;\n  },\n  onSearchParameters: function onSearchParameters() {\n    return undefined;\n  },\n  store: {},\n  widgetsManager: {},\n  mainTargetedIndex: ''\n});\nvar InstantSearchConsumer = instantSearchContext.Consumer,\n  InstantSearchProvider = instantSearchContext.Provider;\nexport { InstantSearchConsumer, InstantSearchProvider };\nvar _createContext = /*#__PURE__*/createContext(undefined),\n  IndexConsumer = _createContext.Consumer,\n  IndexProvider = _createContext.Provider;\nexport { IndexConsumer, IndexProvider };","var _excluded = [\"contextValue\"];\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\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 } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport React, { Component } from 'react';\nimport isEqual from 'react-fast-compare';\nimport { InstantSearchConsumer, IndexConsumer } from \"./context.js\";\nimport { shallowEqual, getDisplayName, removeEmptyKey } from \"./utils.js\";\n/**\n * Connectors are the HOC used to transform React components\n * into InstantSearch widgets.\n * In order to simplify the construction of such connectors\n * `createConnector` takes a description and transform it into\n * a connector.\n * @param {ConnectorDescription} connectorDesc the description of the connector\n * @return {Connector} a function that wraps a component into\n * an instantsearch connected one.\n */\nexport function createConnectorWithoutContext(connectorDesc) {\n  if (!connectorDesc.displayName) {\n    throw new Error('`createConnector` requires you to provide a `displayName` property.');\n  }\n  var isWidget = typeof connectorDesc.getSearchParameters === 'function' || typeof connectorDesc.getMetadata === 'function' || typeof connectorDesc.transitionState === 'function';\n  return function (Composed) {\n    var additionalWidgetProperties = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var Connector = /*#__PURE__*/function (_Component) {\n      _inherits(Connector, _Component);\n      var _super = _createSuper(Connector);\n      function Connector(props) {\n        var _this;\n        _classCallCheck(this, Connector);\n        _this = _super.call(this, props);\n        _defineProperty(_assertThisInitialized(_this), \"unsubscribe\", void 0);\n        _defineProperty(_assertThisInitialized(_this), \"unregisterWidget\", void 0);\n        _defineProperty(_assertThisInitialized(_this), \"cleanupTimerRef\", null);\n        _defineProperty(_assertThisInitialized(_this), \"isUnmounting\", false);\n        _defineProperty(_assertThisInitialized(_this), \"state\", {\n          providedProps: _this.getProvidedProps(_this.props)\n        });\n        _defineProperty(_assertThisInitialized(_this), \"refine\", function () {\n          var _ref;\n          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n            args[_key] = arguments[_key];\n          }\n          _this.props.contextValue.onInternalStateUpdate(\n          // refine will always be defined here because the prop is only given conditionally\n          (_ref = connectorDesc.refine).call.apply(_ref, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n        _defineProperty(_assertThisInitialized(_this), \"createURL\", function () {\n          var _ref2;\n          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n            args[_key2] = arguments[_key2];\n          }\n          return _this.props.contextValue.createHrefForState(\n          // refine will always be defined here because the prop is only given conditionally\n          (_ref2 = connectorDesc.refine).call.apply(_ref2, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n        _defineProperty(_assertThisInitialized(_this), \"searchForFacetValues\", function () {\n          var _ref3;\n          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n            args[_key3] = arguments[_key3];\n          }\n          _this.props.contextValue.onSearchForFacetValues(\n          // searchForFacetValues will always be defined here because the prop is only given conditionally\n          (_ref3 = connectorDesc.searchForFacetValues).call.apply(_ref3, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n        if (connectorDesc.getSearchParameters) {\n          _this.props.contextValue.onSearchParameters(connectorDesc.getSearchParameters.bind(_assertThisInitialized(_this)), {\n            ais: _this.props.contextValue,\n            multiIndexContext: _this.props.indexContextValue\n          }, _this.props, connectorDesc.getMetadata && connectorDesc.getMetadata.bind(_assertThisInitialized(_this)), connectorDesc.displayName);\n        }\n        return _this;\n      }\n      _createClass(Connector, [{\n        key: \"componentDidMount\",\n        value: function componentDidMount() {\n          var _this2 = this;\n          if (this.cleanupTimerRef) {\n            clearTimeout(this.cleanupTimerRef);\n            this.cleanupTimerRef = null;\n          }\n          this.unsubscribe = this.props.contextValue.store.subscribe(function () {\n            if (!_this2.isUnmounting) {\n              _this2.setState({\n                providedProps: _this2.getProvidedProps(_this2.props)\n              });\n            }\n          });\n          if (isWidget) {\n            this.unregisterWidget = this.props.contextValue.widgetsManager.registerWidget(this);\n          }\n        }\n      }, {\n        key: \"shouldComponentUpdate\",\n        value: function shouldComponentUpdate(nextProps, nextState) {\n          if (typeof connectorDesc.shouldComponentUpdate === 'function') {\n            return connectorDesc.shouldComponentUpdate.call(this, this.props, nextProps, this.state, nextState);\n          }\n          var propsEqual = shallowEqual(this.props, nextProps);\n          if (this.state.providedProps === null || nextState.providedProps === null) {\n            if (this.state.providedProps === nextState.providedProps) {\n              return !propsEqual;\n            }\n            return true;\n          }\n          return !propsEqual || !shallowEqual(this.state.providedProps, nextState.providedProps);\n        }\n      }, {\n        key: \"componentDidUpdate\",\n        value: function componentDidUpdate(prevProps) {\n          if (!isEqual(prevProps, this.props)) {\n            this.setState({\n              providedProps: this.getProvidedProps(this.props)\n            });\n            if (isWidget) {\n              this.props.contextValue.widgetsManager.update();\n              if (typeof connectorDesc.transitionState === 'function') {\n                this.props.contextValue.onSearchStateChange(connectorDesc.transitionState.call(this, this.props, this.props.contextValue.store.getState().widgets, this.props.contextValue.store.getState().widgets));\n              }\n            }\n          }\n        }\n      }, {\n        key: \"componentWillUnmount\",\n        value: function componentWillUnmount() {\n          var _this3 = this;\n          this.cleanupTimerRef = setTimeout(function () {\n            _this3.isUnmounting = true;\n            if (_this3.unsubscribe) {\n              _this3.unsubscribe();\n            }\n            if (_this3.unregisterWidget) {\n              _this3.unregisterWidget();\n              if (typeof connectorDesc.cleanUp === 'function') {\n                var nextState = connectorDesc.cleanUp.call(_this3, _this3.props, _this3.props.contextValue.store.getState().widgets);\n                _this3.props.contextValue.store.setState(_objectSpread(_objectSpread({}, _this3.props.contextValue.store.getState()), {}, {\n                  widgets: nextState\n                }));\n                _this3.props.contextValue.onSearchStateChange(removeEmptyKey(nextState));\n              }\n            }\n          });\n        }\n      }, {\n        key: \"getProvidedProps\",\n        value: function getProvidedProps(props) {\n          var _this$props$contextVa = this.props.contextValue.store.getState(),\n            widgets = _this$props$contextVa.widgets,\n            results = _this$props$contextVa.results,\n            resultsFacetValues = _this$props$contextVa.resultsFacetValues,\n            searching = _this$props$contextVa.searching,\n            searchingForFacetValues = _this$props$contextVa.searchingForFacetValues,\n            isSearchStalled = _this$props$contextVa.isSearchStalled,\n            metadata = _this$props$contextVa.metadata,\n            error = _this$props$contextVa.error;\n          var searchResults = {\n            results: results,\n            searching: searching,\n            searchingForFacetValues: searchingForFacetValues,\n            isSearchStalled: isSearchStalled,\n            error: error\n          };\n          return connectorDesc.getProvidedProps.call(this, props, widgets, searchResults, metadata,\n          // @MAJOR: move this attribute on the `searchResults` it doesn't\n          // makes sense to have it into a separate argument. The search\n          // flags are on the object why not the results?\n          resultsFacetValues);\n        }\n      }, {\n        key: \"getSearchParameters\",\n        value: function getSearchParameters(searchParameters) {\n          if (typeof connectorDesc.getSearchParameters === 'function') {\n            return connectorDesc.getSearchParameters.call(this, searchParameters, this.props, this.props.contextValue.store.getState().widgets);\n          }\n          return null;\n        }\n      }, {\n        key: \"getMetadata\",\n        value: function getMetadata(nextWidgetsState) {\n          if (typeof connectorDesc.getMetadata === 'function') {\n            return connectorDesc.getMetadata.call(this, this.props, nextWidgetsState);\n          }\n          return {};\n        }\n      }, {\n        key: \"transitionState\",\n        value: function transitionState(prevWidgetsState, nextWidgetsState) {\n          if (typeof connectorDesc.transitionState === 'function') {\n            return connectorDesc.transitionState.call(this, this.props, prevWidgetsState, nextWidgetsState);\n          }\n          return nextWidgetsState;\n        }\n      }, {\n        key: \"render\",\n        value: function render() {\n          var _this$props = this.props,\n            contextValue = _this$props.contextValue,\n            props = _objectWithoutProperties(_this$props, _excluded);\n          var providedProps = this.state.providedProps;\n          if (providedProps === null) {\n            return null;\n          }\n          var refineProps = typeof connectorDesc.refine === 'function' ? {\n            refine: this.refine,\n            createURL: this.createURL\n          } : {};\n          var searchForFacetValuesProps = typeof connectorDesc.searchForFacetValues === 'function' ? {\n            searchForItems: this.searchForFacetValues\n          } : {};\n          return /*#__PURE__*/React.createElement(Composed, _extends({}, props, providedProps, refineProps, searchForFacetValuesProps));\n        }\n      }]);\n      return Connector;\n    }(Component);\n    _defineProperty(Connector, \"displayName\", \"\".concat(connectorDesc.displayName, \"(\").concat(getDisplayName(Composed), \")\"));\n    _defineProperty(Connector, \"$$type\", connectorDesc.$$type);\n    _defineProperty(Connector, \"$$widgetType\", additionalWidgetProperties.$$widgetType);\n    _defineProperty(Connector, \"propTypes\", connectorDesc.propTypes);\n    _defineProperty(Connector, \"defaultProps\", connectorDesc.defaultProps);\n    _defineProperty(Connector, \"_connectorDesc\", connectorDesc);\n    return Connector;\n  };\n}\nvar createConnectorWithContext = function createConnectorWithContext(connectorDesc) {\n  return function (Composed, additionalWidgetProperties) {\n    var Connector = createConnectorWithoutContext(connectorDesc)(Composed, additionalWidgetProperties);\n    var ConnectorWrapper = function ConnectorWrapper(props) {\n      return /*#__PURE__*/React.createElement(InstantSearchConsumer, null, function (contextValue) {\n        return /*#__PURE__*/React.createElement(IndexConsumer, null, function (indexContextValue) {\n          return /*#__PURE__*/React.createElement(Connector, _extends({\n            contextValue: contextValue,\n            indexContextValue: indexContextValue\n          }, props));\n        });\n      });\n    };\n    return ConnectorWrapper;\n  };\n};\nexport default createConnectorWithContext;","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport { omit } from \"./utils.js\";\nexport function getIndexId(context) {\n  return hasMultipleIndices(context) ? context.multiIndexContext.targetedIndex : context.ais.mainTargetedIndex;\n}\n\n// eslint-disable-next-line valid-jsdoc\n/**\n * @returns {import('algoliasearch-helper').SearchResults} results\n */\nexport function getResults(searchResults, context) {\n  if (searchResults.results) {\n    if (searchResults.results.hits) {\n      return searchResults.results;\n    }\n    var indexId = getIndexId(context);\n    if (searchResults.results[indexId]) {\n      return searchResults.results[indexId];\n    }\n  }\n  return null;\n}\nexport function hasMultipleIndices(context) {\n  return context && context.multiIndexContext;\n}\nexport function refineValue(searchState, nextRefinement, context, resetPage, namespace) {\n  if (hasMultipleIndices(context)) {\n    var indexId = getIndexId(context);\n    return namespace ? refineMultiIndexWithNamespace(searchState, nextRefinement, indexId, resetPage, namespace) : refineMultiIndex(searchState, nextRefinement, indexId, resetPage);\n  } else {\n    // When we have a multi index page with shared widgets we should also\n    // reset their page to 1 if the resetPage is provided. Otherwise the\n    // indices will always be reset\n    // see: https://github.com/algolia/react-instantsearch/issues/310\n    // see: https://github.com/algolia/react-instantsearch/issues/637\n    if (searchState.indices && resetPage) {\n      Object.keys(searchState.indices).forEach(function (targetedIndex) {\n        searchState = refineValue(searchState, {\n          page: 1\n        }, {\n          multiIndexContext: {\n            targetedIndex: targetedIndex\n          }\n        }, true, namespace);\n      });\n    }\n    return namespace ? refineSingleIndexWithNamespace(searchState, nextRefinement, resetPage, namespace) : refineSingleIndex(searchState, nextRefinement, resetPage);\n  }\n}\nfunction refineMultiIndex(searchState, nextRefinement, indexId, resetPage) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  var state = searchState.indices && searchState.indices[indexId] ? _objectSpread(_objectSpread({}, searchState.indices), {}, _defineProperty({}, indexId, _objectSpread(_objectSpread(_objectSpread({}, searchState.indices[indexId]), nextRefinement), page))) : _objectSpread(_objectSpread({}, searchState.indices), {}, _defineProperty({}, indexId, _objectSpread(_objectSpread({}, nextRefinement), page)));\n  return _objectSpread(_objectSpread({}, searchState), {}, {\n    indices: state\n  });\n}\nfunction refineSingleIndex(searchState, nextRefinement, resetPage) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  return _objectSpread(_objectSpread(_objectSpread({}, searchState), nextRefinement), page);\n}\nfunction refineMultiIndexWithNamespace(searchState, nextRefinement, indexId, resetPage, namespace) {\n  var _objectSpread4;\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  var state = searchState.indices && searchState.indices[indexId] ? _objectSpread(_objectSpread({}, searchState.indices), {}, _defineProperty({}, indexId, _objectSpread(_objectSpread({}, searchState.indices[indexId]), {}, (_objectSpread4 = {}, _defineProperty(_objectSpread4, namespace, _objectSpread(_objectSpread({}, searchState.indices[indexId][namespace]), nextRefinement)), _defineProperty(_objectSpread4, \"page\", 1), _objectSpread4)))) : _objectSpread(_objectSpread({}, searchState.indices), {}, _defineProperty({}, indexId, _objectSpread(_defineProperty({}, namespace, nextRefinement), page)));\n  return _objectSpread(_objectSpread({}, searchState), {}, {\n    indices: state\n  });\n}\nfunction refineSingleIndexWithNamespace(searchState, nextRefinement, resetPage, namespace) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  return _objectSpread(_objectSpread({}, searchState), {}, _defineProperty({}, namespace, _objectSpread(_objectSpread({}, searchState[namespace]), nextRefinement)), page);\n}\nfunction getNamespaceAndAttributeName(id) {\n  var parts = id.match(/^([^.]*)\\.(.*)/);\n  var namespace = parts && parts[1];\n  var attributeName = parts && parts[2];\n  return {\n    namespace: namespace,\n    attributeName: attributeName\n  };\n}\nfunction hasRefinements(_ref) {\n  var multiIndex = _ref.multiIndex,\n    indexId = _ref.indexId,\n    namespace = _ref.namespace,\n    attributeName = _ref.attributeName,\n    id = _ref.id,\n    searchState = _ref.searchState;\n  if (multiIndex && namespace) {\n    return searchState.indices && searchState.indices[indexId] && searchState.indices[indexId][namespace] && Object.hasOwnProperty.call(searchState.indices[indexId][namespace], attributeName);\n  }\n  if (multiIndex) {\n    return searchState.indices && searchState.indices[indexId] && Object.hasOwnProperty.call(searchState.indices[indexId], id);\n  }\n  if (namespace) {\n    return searchState[namespace] && Object.hasOwnProperty.call(searchState[namespace], attributeName);\n  }\n  return Object.hasOwnProperty.call(searchState, id);\n}\nfunction getRefinements(_ref2) {\n  var multiIndex = _ref2.multiIndex,\n    indexId = _ref2.indexId,\n    namespace = _ref2.namespace,\n    attributeName = _ref2.attributeName,\n    id = _ref2.id,\n    searchState = _ref2.searchState;\n  if (multiIndex && namespace) {\n    return searchState.indices[indexId][namespace][attributeName];\n  }\n  if (multiIndex) {\n    return searchState.indices[indexId][id];\n  }\n  if (namespace) {\n    return searchState[namespace][attributeName];\n  }\n  return searchState[id];\n}\nexport function getCurrentRefinementValue(props, searchState, context, id, defaultValue) {\n  var indexId = getIndexId(context);\n  var _getNamespaceAndAttri = getNamespaceAndAttributeName(id),\n    namespace = _getNamespaceAndAttri.namespace,\n    attributeName = _getNamespaceAndAttri.attributeName;\n  var multiIndex = hasMultipleIndices(context);\n  var args = {\n    multiIndex: multiIndex,\n    indexId: indexId,\n    namespace: namespace,\n    attributeName: attributeName,\n    id: id,\n    searchState: searchState\n  };\n  var hasRefinementsValue = hasRefinements(args);\n  if (hasRefinementsValue) {\n    return getRefinements(args);\n  }\n  if (props.defaultRefinement) {\n    return props.defaultRefinement;\n  }\n  return defaultValue;\n}\nexport function cleanUpValue(searchState, context, id) {\n  var indexId = getIndexId(context);\n  var _getNamespaceAndAttri2 = getNamespaceAndAttributeName(id),\n    namespace = _getNamespaceAndAttri2.namespace,\n    attributeName = _getNamespaceAndAttri2.attributeName;\n  if (hasMultipleIndices(context) && Boolean(searchState.indices)) {\n    return cleanUpValueWithMultiIndex({\n      attribute: attributeName,\n      searchState: searchState,\n      indexId: indexId,\n      id: id,\n      namespace: namespace\n    });\n  }\n  return cleanUpValueWithSingleIndex({\n    attribute: attributeName,\n    searchState: searchState,\n    id: id,\n    namespace: namespace\n  });\n}\nfunction cleanUpValueWithSingleIndex(_ref3) {\n  var searchState = _ref3.searchState,\n    id = _ref3.id,\n    namespace = _ref3.namespace,\n    attribute = _ref3.attribute;\n  if (namespace) {\n    return _objectSpread(_objectSpread({}, searchState), {}, _defineProperty({}, namespace, omit(searchState[namespace], [attribute])));\n  }\n  return omit(searchState, [id]);\n}\nfunction cleanUpValueWithMultiIndex(_ref4) {\n  var searchState = _ref4.searchState,\n    indexId = _ref4.indexId,\n    id = _ref4.id,\n    namespace = _ref4.namespace,\n    attribute = _ref4.attribute;\n  var indexSearchState = searchState.indices[indexId];\n  if (namespace && indexSearchState) {\n    return _objectSpread(_objectSpread({}, searchState), {}, {\n      indices: _objectSpread(_objectSpread({}, searchState.indices), {}, _defineProperty({}, indexId, _objectSpread(_objectSpread({}, indexSearchState), {}, _defineProperty({}, namespace, omit(indexSearchState[namespace], [attribute])))))\n    });\n  }\n  if (indexSearchState) {\n    return _objectSpread(_objectSpread({}, searchState), {}, {\n      indices: _objectSpread(_objectSpread({}, searchState.indices), {}, _defineProperty({}, indexId, omit(indexSearchState, [id])))\n    });\n  }\n  return searchState;\n}","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n// eslint-disable-next-line @typescript-eslint/unbound-method\nvar hasOwn = Object.prototype.hasOwnProperty;\n\n// From https://github.com/reactjs/react-redux/blob/master/src/utils/shallowEqual.js\nexport var shallowEqual = function shallowEqual(objA, objB) {\n  if (objA === objB) {\n    return true;\n  }\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  // Test for A's keys different from B.\n  for (var i = 0; i < keysA.length; i++) {\n    if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {\n      return false;\n    }\n  }\n  return true;\n};\nexport var getDisplayName = function getDisplayName(Component) {\n  return Component.displayName || Component.name || 'UnknownComponent';\n};\nvar resolved = Promise.resolve();\nexport var defer = function defer(f) {\n  resolved.then(f);\n};\nvar isPlainObject = function isPlainObject(value) {\n  return _typeof(value) === 'object' && value !== null && !Array.isArray(value);\n};\nexport var removeEmptyKey = function removeEmptyKey(obj) {\n  Object.keys(obj).forEach(function (key) {\n    var value = obj[key];\n    if (!isPlainObject(value)) {\n      return;\n    }\n    if (!objectHasKeys(value)) {\n      delete obj[key];\n    } else {\n      removeEmptyKey(value);\n    }\n  });\n  return obj;\n};\nexport var removeEmptyArraysFromObject = function removeEmptyArraysFromObject(obj) {\n  Object.keys(obj).forEach(function (key) {\n    var value = obj[key];\n    if (Array.isArray(value) && value.length === 0) {\n      delete obj[key];\n    }\n  });\n  return obj;\n};\nexport function addAbsolutePositions(hits, hitsPerPage, page) {\n  return hits.map(function (hit, index) {\n    return _objectSpread(_objectSpread({}, hit), {}, {\n      __position: hitsPerPage * page + index + 1\n    });\n  });\n}\nexport function addQueryID(hits, queryID) {\n  if (!queryID) {\n    return hits;\n  }\n  return hits.map(function (hit) {\n    return _objectSpread(_objectSpread({}, hit), {}, {\n      __queryID: queryID\n    });\n  });\n}\nexport function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return undefined;\n  }\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return array[i];\n    }\n  }\n  return undefined;\n}\nexport function objectHasKeys(object) {\n  return object && Object.keys(object).length > 0;\n}\n\n// https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620\nexport function omit(source, excluded) {\n  if (source === null || source === undefined) {\n    return {};\n  }\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  for (var i = 0; i < sourceKeys.length; i++) {\n    var key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) {\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n    target[key] = source[key];\n  }\n  return target;\n}\n\n/**\n * Retrieve the value at a path of the object:\n *\n * @example\n * getPropertyByPath(\n *   { test: { this: { function: [{ now: { everyone: true } }] } } },\n *   'test.this.function[0].now.everyone'\n * ); // true\n *\n * getPropertyByPath(\n *   { test: { this: { function: [{ now: { everyone: true } }] } } },\n *   ['test', 'this', 'function', 0, 'now', 'everyone']\n * ); // true\n *\n * @param object Source object to query\n * @param path either an array of properties, or a string form of the properties, separated by .\n */\nexport var getPropertyByPath = function getPropertyByPath(object, path) {\n  return (Array.isArray(path) ? path : path.replace(/\\[(\\d+)]/g, '.$1').split('.')).reduce(function (current, key) {\n    return current ? current[key] : undefined;\n  }, object);\n};\nexport function getObjectType(object) {\n  return Object.prototype.toString.call(object).slice(8, -1);\n}\nexport function unescapeFacetValue(value) {\n  return value.replace(/^\\\\-/, '-');\n}","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nvar _excluded = [\"children\", \"contextValue\", \"indexContextValue\"],\n  _excluded2 = [\"children\", \"contextValue\", \"indexContextValue\"];\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport createConnector from \"../core/createConnector.js\";\nimport { refineValue, getIndexId, hasMultipleIndices } from \"../core/indexUtils.js\";\nimport { omit } from \"../core/utils.js\";\nfunction getId() {\n  return 'configure';\n}\nexport default createConnector({\n  displayName: 'AlgoliaConfigure',\n  $$type: 'ais.configure',\n  getProvidedProps: function getProvidedProps() {\n    return {};\n  },\n  getSearchParameters: function getSearchParameters(searchParameters, props) {\n    var children = props.children,\n      contextValue = props.contextValue,\n      indexContextValue = props.indexContextValue,\n      items = _objectWithoutProperties(props, _excluded);\n    return searchParameters.setQueryParameters(items);\n  },\n  transitionState: function transitionState(props, prevSearchState, nextSearchState) {\n    var id = getId();\n    var children = props.children,\n      contextValue = props.contextValue,\n      indexContextValue = props.indexContextValue,\n      items = _objectWithoutProperties(props, _excluded2);\n    var propKeys = Object.keys(props);\n    var nonPresentKeys = this._props ? Object.keys(this._props).filter(function (prop) {\n      return propKeys.indexOf(prop) === -1;\n    }) : [];\n    this._props = props;\n    var nextValue = _defineProperty({}, id, _objectSpread(_objectSpread({}, omit(nextSearchState[id], nonPresentKeys)), items));\n    return refineValue(nextSearchState, nextValue, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  cleanUp: function cleanUp(props, searchState) {\n    var id = getId();\n    var indexId = getIndexId({\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    var subState = hasMultipleIndices({\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    }) && searchState.indices ? searchState.indices[indexId] : searchState;\n    var configureKeys = subState && subState[id] ? Object.keys(subState[id]) : [];\n    var configureState = configureKeys.reduce(function (acc, item) {\n      if (!props[item]) {\n        acc[item] = subState[id][item];\n      }\n      return acc;\n    }, {});\n    var nextValue = _defineProperty({}, id, configureState);\n    return refineValue(searchState, nextValue, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  }\n});","import connectConfigure from \"../connectors/connectConfigure.js\";\n\n/**\n * Configure is a widget that lets you provide raw search parameters\n * to the Algolia API.\n *\n * Any of the props added to this widget will be forwarded to Algolia. For more information\n * on the different parameters that can be set, have a look at the\n * [reference](https://www.algolia.com/doc/api-client/javascript/search#search-parameters).\n *\n * This widget can be used either with react-dom and react-native. It will not render anything\n * on screen, only configure some parameters.\n *\n * Read more in the [Search parameters](guide/Search_parameters.html) guide.\n * @name Configure\n * @kind widget\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Configure, Hits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <Configure hitsPerPage={5} />\n *     <Hits />\n *   </InstantSearch>\n * );\n */\n\nexport default connectConfigure(function Configure() {\n  return null;\n}, {\n  $$widgetType: 'ais.configure'\n});","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\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 } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport PropTypes from 'prop-types';\nimport React, { Component, Children } from 'react';\nimport { InstantSearchConsumer, IndexProvider } from \"../core/context.js\";\nfunction getIndexContext(props) {\n  return {\n    targetedIndex: props.indexId\n  };\n}\n/**\n * The component that allows you to apply widgets to a dedicated index. It's\n * useful if you want to build an interface that targets multiple indices.\n *\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Index, SearchBox, Hits, Configure } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <Configure hitsPerPage={5} />\n *     <SearchBox />\n *     <Index indexName=\"instant_search\">\n *       <Hits />\n *     </Index>\n *     <Index indexName=\"bestbuy\">\n *       <Hits />\n *     </Index>\n *   </InstantSearch>\n * );\n */\nvar Index = /*#__PURE__*/function (_Component) {\n  _inherits(Index, _Component);\n  var _super = _createSuper(Index);\n  function Index(props) {\n    var _this;\n    _classCallCheck(this, Index);\n    _this = _super.call(this, props);\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      indexContext: getIndexContext(_this.props)\n    });\n    _defineProperty(_assertThisInitialized(_this), \"unregisterWidget\", void 0);\n    _this.props.contextValue.onSearchParameters(_this.getSearchParameters.bind(_assertThisInitialized(_this)), {\n      ais: _this.props.contextValue,\n      multiIndexContext: _this.state.indexContext\n    }, _this.props, undefined, Index.displayName);\n    return _this;\n  }\n  _createClass(Index, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this.unregisterWidget = this.props.contextValue.widgetsManager.registerWidget(this);\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      if (this.props.indexName !== prevProps.indexName) {\n        this.props.contextValue.widgetsManager.update();\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (typeof this.unregisterWidget === 'function') {\n        this.unregisterWidget();\n      }\n    }\n  }, {\n    key: \"getSearchParameters\",\n    value: function getSearchParameters(searchParameters, props) {\n      return searchParameters.setIndex(this.props ? this.props.indexName : props.indexName);\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var childrenCount = Children.count(this.props.children);\n      if (childrenCount === 0) {\n        return null;\n      }\n      return /*#__PURE__*/React.createElement(IndexProvider, {\n        value: this.state.indexContext\n      }, this.props.children);\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(props) {\n      return {\n        indexContext: getIndexContext(props)\n      };\n    }\n  }]);\n  return Index;\n}(Component);\n_defineProperty(Index, \"propTypes\", {\n  indexName: PropTypes.string.isRequired,\n  indexId: PropTypes.string.isRequired,\n  children: PropTypes.node\n});\n_defineProperty(Index, \"displayName\", 'AlgoliaIndex');\n_defineProperty(Index, \"$$type\", 'ais.index');\n_defineProperty(Index, \"$$widgetType\", 'ais.index');\nvar IndexWrapper = function IndexWrapper(props) {\n  var inferredIndexId = props.indexName;\n  return /*#__PURE__*/React.createElement(InstantSearchConsumer, null, function (contextValue) {\n    return /*#__PURE__*/React.createElement(Index, _extends({\n      contextValue: contextValue,\n      indexId: inferredIndexId\n    }, props));\n  });\n};\nIndexWrapper.propTypes = {\n  indexName: PropTypes.string.isRequired,\n  indexId: PropTypes.string\n};\nexport var IndexComponentWithoutContext = Index;\nexport default IndexWrapper;","import { getPropertyByPath } from \"./utils.js\";\nexport var HIGHLIGHT_TAGS = {\n  highlightPreTag: \"<ais-highlight-0000000000>\",\n  highlightPostTag: \"</ais-highlight-0000000000>\"\n};\n\n/**\n * Parses an highlighted attribute into an array of objects with the string value, and\n * a boolean that indicated if this part is highlighted.\n *\n * @param {string} preTag - string used to identify the start of an highlighted value\n * @param {string} postTag - string used to identify the end of an highlighted value\n * @param {string} highlightedValue - highlighted attribute as returned by Algolia highlight feature\n * @return {object[]} - An array of {value: string, isHighlighted: boolean}.\n */\nfunction parseHighlightedAttribute(_ref) {\n  var preTag = _ref.preTag,\n    postTag = _ref.postTag,\n    _ref$highlightedValue = _ref.highlightedValue,\n    highlightedValue = _ref$highlightedValue === void 0 ? '' : _ref$highlightedValue;\n  var splitByPreTag = highlightedValue.split(preTag);\n  var firstValue = splitByPreTag.shift();\n  var elements = firstValue === '' ? [] : [{\n    value: firstValue,\n    isHighlighted: false\n  }];\n  if (postTag === preTag) {\n    var isHighlighted = true;\n    splitByPreTag.forEach(function (split) {\n      elements.push({\n        value: split,\n        isHighlighted: isHighlighted\n      });\n      isHighlighted = !isHighlighted;\n    });\n  } else {\n    splitByPreTag.forEach(function (split) {\n      var splitByPostTag = split.split(postTag);\n      elements.push({\n        value: splitByPostTag[0],\n        isHighlighted: true\n      });\n      if (splitByPostTag[1] !== '') {\n        elements.push({\n          value: splitByPostTag[1],\n          isHighlighted: false\n        });\n      }\n    });\n  }\n  return elements;\n}\n\n/**\n * Find an highlighted attribute given an `attribute` and an `highlightProperty`, parses it,\n * and provided an array of objects with the string value and a boolean if this\n * value is highlighted.\n *\n * In order to use this feature, highlight must be activated in the configuration of\n * the index. The `preTag` and `postTag` attributes are respectively highlightPreTag and\n * highlightPostTag in Algolia configuration.\n *\n * @param {string} preTag - string used to identify the start of an highlighted value\n * @param {string} postTag - string used to identify the end of an highlighted value\n * @param {string} highlightProperty - the property that contains the highlight structure in the results\n * @param {string} attribute - the highlighted attribute to look for\n * @param {object} hit - the actual hit returned by Algolia.\n * @return {object[]} - An array of {value: string, isHighlighted: boolean}.\n */\nexport function parseAlgoliaHit(_ref2) {\n  var _ref2$preTag = _ref2.preTag,\n    preTag = _ref2$preTag === void 0 ? '<em>' : _ref2$preTag,\n    _ref2$postTag = _ref2.postTag,\n    postTag = _ref2$postTag === void 0 ? '</em>' : _ref2$postTag,\n    highlightProperty = _ref2.highlightProperty,\n    attribute = _ref2.attribute,\n    hit = _ref2.hit;\n  if (!hit) throw new Error('`hit`, the matching record, must be provided');\n  var highlightObject = getPropertyByPath(hit[highlightProperty], attribute) || {};\n  if (Array.isArray(highlightObject)) {\n    return highlightObject.map(function (item) {\n      return parseHighlightedAttribute({\n        preTag: preTag,\n        postTag: postTag,\n        highlightedValue: item.value\n      });\n    });\n  }\n  return parseHighlightedAttribute({\n    preTag: preTag,\n    postTag: postTag,\n    highlightedValue: highlightObject.value\n  });\n}","var _excluded = [\"resultsFacetValues\"],\n  _excluded2 = [\"resultsFacetValues\"],\n  _excluded3 = [\"resultsFacetValues\"];\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport algoliasearchHelper from 'algoliasearch-helper';\nimport { version as ReactVersion } from 'react';\nimport createStore from \"./createStore.js\";\nimport createWidgetsManager from \"./createWidgetsManager.js\";\nimport { HIGHLIGHT_TAGS } from \"./highlight.js\";\nimport { hasMultipleIndices } from \"./indexUtils.js\";\nimport version from \"./version.js\";\nfunction addAlgoliaAgents(searchClient) {\n  if (typeof searchClient.addAlgoliaAgent === 'function') {\n    searchClient.addAlgoliaAgent(\"react (\".concat(ReactVersion, \")\"));\n    searchClient.addAlgoliaAgent(\"react-instantsearch (\".concat(version, \")\"));\n  }\n}\nvar isMultiIndexContext = function isMultiIndexContext(widget) {\n  return hasMultipleIndices({\n    ais: widget.props.contextValue,\n    multiIndexContext: widget.props.indexContextValue\n  });\n};\nvar isTargetedIndexEqualIndex = function isTargetedIndexEqualIndex(widget, indexId) {\n  return widget.props.indexContextValue.targetedIndex === indexId;\n};\n\n// Relying on the `indexId` is a bit brittle to detect the `Index` widget.\n// Since it's a class we could rely on `instanceof` or similar. We never\n// had an issue though. Works for now.\nvar isIndexWidget = function isIndexWidget(widget) {\n  return Boolean(widget.props.indexId);\n};\nvar isIndexWidgetEqualIndex = function isIndexWidgetEqualIndex(widget, indexId) {\n  return widget.props.indexId === indexId;\n};\nvar sortIndexWidgetsFirst = function sortIndexWidgetsFirst(firstWidget, secondWidget) {\n  var isFirstWidgetIndex = isIndexWidget(firstWidget);\n  var isSecondWidgetIndex = isIndexWidget(secondWidget);\n  if (isFirstWidgetIndex && !isSecondWidgetIndex) {\n    return -1;\n  }\n  if (!isFirstWidgetIndex && isSecondWidgetIndex) {\n    return 1;\n  }\n  return 0;\n};\n\n// This function is copied from the algoliasearch v4 API Client. If modified,\n// consider updating it also in `serializeQueryParameters` from `@algolia/transporter`.\nfunction serializeQueryParameters(parameters) {\n  var isObjectOrArray = function isObjectOrArray(value) {\n    return Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';\n  };\n  var encode = function encode(format) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n    var i = 0;\n    return format.replace(/%s/g, function () {\n      return encodeURIComponent(args[i++]);\n    });\n  };\n  return Object.keys(parameters).map(function (key) {\n    return encode('%s=%s', key, isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]);\n  }).join('&');\n}\n\n/**\n * Creates a new instance of the InstantSearchManager which controls the widgets and\n * trigger the search when the widgets are updated.\n * @param {string} indexName - the main index name\n * @param {object} initialState - initial widget state\n * @param {object} SearchParameters - optional additional parameters to send to the algolia API\n * @param {number} stalledSearchDelay - time (in ms) after the search is stalled\n * @return {InstantSearchManager} a new instance of InstantSearchManager\n */\nexport default function createInstantSearchManager(_ref) {\n  var indexName = _ref.indexName,\n    _ref$initialState = _ref.initialState,\n    initialState = _ref$initialState === void 0 ? {} : _ref$initialState,\n    searchClient = _ref.searchClient,\n    resultsState = _ref.resultsState,\n    stalledSearchDelay = _ref.stalledSearchDelay;\n  var helper = algoliasearchHelper(searchClient, indexName, _objectSpread({}, HIGHLIGHT_TAGS));\n  addAlgoliaAgents(searchClient);\n  helper.on('search', handleNewSearch).on('result', handleSearchSuccess({\n    indexId: indexName\n  })).on('error', handleSearchError);\n  var skip = false;\n  var stalledSearchTimer = null;\n  var initialSearchParameters = helper.state;\n  var searchCounter;\n  var widgetsManager = createWidgetsManager(onWidgetsUpdate);\n  hydrateSearchClient(searchClient, resultsState);\n  var store = createStore({\n    widgets: initialState,\n    metadata: hydrateMetadata(resultsState),\n    results: hydrateResultsState(resultsState),\n    error: null,\n    searching: false,\n    isSearchStalled: true,\n    searchingForFacetValues: false\n  });\n  function skipSearch() {\n    skip = true;\n  }\n  function updateClient(client) {\n    addAlgoliaAgents(client);\n    helper.setClient(client);\n    search();\n  }\n  function clearCache() {\n    helper.clearCache();\n    search();\n  }\n  function getMetadata(state) {\n    return widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getMetadata);\n    }).map(function (widget) {\n      return widget.getMetadata(state);\n    });\n  }\n  function getSearchParameters() {\n    var sharedParameters = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      return !isMultiIndexContext(widget) && !isIndexWidget(widget);\n    }).reduce(function (res, widget) {\n      return widget.getSearchParameters(res);\n    }, initialSearchParameters);\n    var mainParameters = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      var targetedIndexEqualMainIndex = isMultiIndexContext(widget) && isTargetedIndexEqualIndex(widget, indexName);\n      var subIndexEqualMainIndex = isIndexWidget(widget) && isIndexWidgetEqualIndex(widget, indexName);\n      return targetedIndexEqualMainIndex || subIndexEqualMainIndex;\n    })\n    // We have to sort the `Index` widgets first so the `index` parameter\n    // is correctly set in the `reduce` function for the following widgets\n    .sort(sortIndexWidgetsFirst).reduce(function (res, widget) {\n      return widget.getSearchParameters(res);\n    }, sharedParameters);\n    var derivedIndices = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      var targetedIndexNotEqualMainIndex = isMultiIndexContext(widget) && !isTargetedIndexEqualIndex(widget, indexName);\n      var subIndexNotEqualMainIndex = isIndexWidget(widget) && !isIndexWidgetEqualIndex(widget, indexName);\n      return targetedIndexNotEqualMainIndex || subIndexNotEqualMainIndex;\n    })\n    // We have to sort the `Index` widgets first so the `index` parameter\n    // is correctly set in the `reduce` function for the following widgets\n    .sort(sortIndexWidgetsFirst).reduce(function (indices, widget) {\n      var indexId = isMultiIndexContext(widget) ? widget.props.indexContextValue.targetedIndex : widget.props.indexId;\n      var widgets = indices[indexId] || [];\n      return _objectSpread(_objectSpread({}, indices), {}, _defineProperty({}, indexId, widgets.concat(widget)));\n    }, {});\n    var derivedParameters = Object.keys(derivedIndices).map(function (indexId) {\n      return {\n        parameters: derivedIndices[indexId].reduce(function (res, widget) {\n          return widget.getSearchParameters(res);\n        }, sharedParameters),\n        indexId: indexId\n      };\n    });\n    return {\n      mainParameters: mainParameters,\n      derivedParameters: derivedParameters\n    };\n  }\n  function search() {\n    if (!skip) {\n      var _getSearchParameters = getSearchParameters(helper.state),\n        mainParameters = _getSearchParameters.mainParameters,\n        derivedParameters = _getSearchParameters.derivedParameters;\n      searchCounter = derivedParameters.length + 1;\n\n      // We have to call `slice` because the method `detach` on the derived\n      // helpers mutates the value `derivedHelpers`. The `forEach` loop does\n      // not iterate on each value and we're not able to correctly clear the\n      // previous derived helpers (memory leak + useless requests).\n      helper.derivedHelpers.slice().forEach(function (derivedHelper) {\n        // Since we detach the derived helpers on **every** new search they\n        // won't receive intermediate results in case of a stalled search.\n        // Only the last result is dispatched by the derived helper because\n        // they are not detached yet:\n        //\n        // - a -> main helper receives results\n        // - ap -> main helper receives results\n        // - app -> main helper + derived helpers receive results\n        //\n        // The quick fix is to avoid to detach them on search but only once they\n        // received the results. But it means that in case of a stalled search\n        // all the derived helpers not detached yet register a new search inside\n        // the helper. The number grows fast in case of a bad network and it's\n        // not deterministic.\n        derivedHelper.detach();\n      });\n      derivedParameters.forEach(function (_ref2) {\n        var indexId = _ref2.indexId,\n          parameters = _ref2.parameters;\n        var derivedHelper = helper.derive(function () {\n          return parameters;\n        });\n        derivedHelper.on('result', handleSearchSuccess({\n          indexId: indexId\n        })).on('error', handleSearchError);\n      });\n      helper.setState(mainParameters);\n      helper.search();\n    }\n  }\n  function handleSearchSuccess(_ref3) {\n    var indexId = _ref3.indexId;\n    return function (event) {\n      searchCounter--;\n      var state = store.getState();\n      var isDerivedHelpersEmpty = !helper.derivedHelpers.length;\n      var results = state.results ? state.results : {};\n\n      // Switching from mono index to multi index and vice versa must reset the\n      // results to an empty object, otherwise we keep reference of stalled and\n      // unused results.\n      results = !isDerivedHelpersEmpty && results.getFacetByName ? {} : results;\n      if (!isDerivedHelpersEmpty) {\n        results = _objectSpread(_objectSpread({}, results), {}, _defineProperty({}, indexId, event.results));\n      } else {\n        results = event.results;\n      }\n      var currentState = store.getState();\n      var nextIsSearchStalled = currentState.isSearchStalled;\n      if (!helper.hasPendingRequests()) {\n        clearTimeout(stalledSearchTimer);\n        stalledSearchTimer = null;\n        nextIsSearchStalled = false;\n      }\n      var resultsFacetValues = currentState.resultsFacetValues,\n        partialState = _objectWithoutProperties(currentState, _excluded);\n      store.setState(_objectSpread(_objectSpread({}, partialState), {}, {\n        results: results,\n        isSearchStalled: nextIsSearchStalled,\n        searching: searchCounter > 0,\n        error: null\n      }));\n    };\n  }\n  function handleSearchError(_ref4) {\n    var error = _ref4.error;\n    var currentState = store.getState();\n    var nextIsSearchStalled = currentState.isSearchStalled;\n    if (!helper.hasPendingRequests()) {\n      clearTimeout(stalledSearchTimer);\n      nextIsSearchStalled = false;\n    }\n    var resultsFacetValues = currentState.resultsFacetValues,\n      partialState = _objectWithoutProperties(currentState, _excluded2);\n    store.setState(_objectSpread(_objectSpread({}, partialState), {}, {\n      isSearchStalled: nextIsSearchStalled,\n      error: error,\n      searching: false\n    }));\n  }\n  function handleNewSearch() {\n    if (!stalledSearchTimer) {\n      stalledSearchTimer = setTimeout(function () {\n        var _store$getState = store.getState(),\n          resultsFacetValues = _store$getState.resultsFacetValues,\n          partialState = _objectWithoutProperties(_store$getState, _excluded3);\n        store.setState(_objectSpread(_objectSpread({}, partialState), {}, {\n          isSearchStalled: true\n        }));\n      }, stalledSearchDelay);\n    }\n  }\n  function hydrateSearchClient(client, results) {\n    if (!results) {\n      return;\n    }\n\n    // Disable cache hydration on:\n    // - Algoliasearch API Client < v4 with cache disabled\n    // - Third party clients (detected by the `addAlgoliaAgent` function missing)\n\n    if ((!client.transporter || client._cacheHydrated) && (!client._useCache || typeof client.addAlgoliaAgent !== 'function')) {\n      return;\n    }\n\n    // Algoliasearch API Client >= v4\n    // To hydrate the client we need to populate the cache with the data from\n    // the server (done in `hydrateSearchClientWithMultiIndexRequest` or\n    // `hydrateSearchClientWithSingleIndexRequest`). But since there is no way\n    // for us to compute the key the same way as `algoliasearch-client` we need\n    // to populate it on a custom key and override the `search` method to\n    // search on it first.\n    if (client.transporter && !client._cacheHydrated) {\n      client._cacheHydrated = true;\n      var baseMethod = client.search;\n      client.search = function (requests) {\n        for (var _len2 = arguments.length, methodArgs = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n          methodArgs[_key2 - 1] = arguments[_key2];\n        }\n        var requestsWithSerializedParams = requests.map(function (request) {\n          return _objectSpread(_objectSpread({}, request), {}, {\n            params: serializeQueryParameters(request.params)\n          });\n        });\n        return client.transporter.responsesCache.get({\n          method: 'search',\n          args: [requestsWithSerializedParams].concat(methodArgs)\n        }, function () {\n          return baseMethod.apply(void 0, [requests].concat(methodArgs));\n        });\n      };\n    }\n    if (Array.isArray(results.results)) {\n      hydrateSearchClientWithMultiIndexRequest(client, results.results);\n      return;\n    }\n    hydrateSearchClientWithSingleIndexRequest(client, results);\n  }\n  function hydrateSearchClientWithMultiIndexRequest(client, results) {\n    // Algoliasearch API Client >= v4\n    // Populate the cache with the data from the server\n    if (client.transporter) {\n      client.transporter.responsesCache.set({\n        method: 'search',\n        args: [results.reduce(function (acc, result) {\n          return acc.concat(result.rawResults.map(function (request) {\n            return {\n              indexName: request.index,\n              params: request.params\n            };\n          }));\n        }, [])]\n      }, {\n        results: results.reduce(function (acc, result) {\n          return acc.concat(result.rawResults);\n        }, [])\n      });\n      return;\n    }\n\n    // Algoliasearch API Client < v4\n    // Prior to client v4 we didn't have a proper API to hydrate the client\n    // cache from the outside. The following code populates the cache with\n    // a single-index result. You can find more information about the\n    // computation of the key inside the client (see link below).\n    // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240\n    var key = \"/1/indexes/*/queries_body_\".concat(JSON.stringify({\n      requests: results.reduce(function (acc, result) {\n        return acc.concat(result.rawResults.map(function (request) {\n          return {\n            indexName: request.index,\n            params: request.params\n          };\n        }));\n      }, [])\n    }));\n    client.cache = _objectSpread(_objectSpread({}, client.cache), {}, _defineProperty({}, key, JSON.stringify({\n      results: results.reduce(function (acc, result) {\n        return acc.concat(result.rawResults);\n      }, [])\n    })));\n  }\n  function hydrateSearchClientWithSingleIndexRequest(client, results) {\n    // Algoliasearch API Client >= v4\n    // Populate the cache with the data from the server\n    if (client.transporter) {\n      client.transporter.responsesCache.set({\n        method: 'search',\n        args: [results.rawResults.map(function (request) {\n          return {\n            indexName: request.index,\n            params: request.params\n          };\n        })]\n      }, {\n        results: results.rawResults\n      });\n      return;\n    }\n    // Algoliasearch API Client < v4\n    // Prior to client v4 we didn't have a proper API to hydrate the client\n    // cache from the outside. The following code populates the cache with\n    // a single-index result. You can find more information about the\n    // computation of the key inside the client (see link below).\n    // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240\n    var key = \"/1/indexes/*/queries_body_\".concat(JSON.stringify({\n      requests: results.rawResults.map(function (request) {\n        return {\n          indexName: request.index,\n          params: request.params\n        };\n      })\n    }));\n    client.cache = _objectSpread(_objectSpread({}, client.cache), {}, _defineProperty({}, key, JSON.stringify({\n      results: results.rawResults\n    })));\n  }\n  function hydrateResultsState(results) {\n    if (!results) {\n      return null;\n    }\n    if (Array.isArray(results.results)) {\n      return results.results.reduce(function (acc, result) {\n        return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, result._internalIndexId, new algoliasearchHelper.SearchResults(new algoliasearchHelper.SearchParameters(result.state), result.rawResults)));\n      }, {});\n    }\n    return new algoliasearchHelper.SearchResults(new algoliasearchHelper.SearchParameters(results.state), results.rawResults);\n  }\n\n  // Called whenever a widget has been rendered with new props.\n  function onWidgetsUpdate() {\n    var metadata = getMetadata(store.getState().widgets);\n    store.setState(_objectSpread(_objectSpread({}, store.getState()), {}, {\n      metadata: metadata,\n      searching: true\n    }));\n\n    // Since the `getSearchParameters` method of widgets also depends on props,\n    // the result search parameters might have changed.\n    search();\n  }\n  function transitionState(nextSearchState) {\n    var searchState = store.getState().widgets;\n    return widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.transitionState);\n    }).reduce(function (res, widget) {\n      return widget.transitionState(searchState, res);\n    }, nextSearchState);\n  }\n  function onExternalStateUpdate(nextSearchState) {\n    var metadata = getMetadata(nextSearchState);\n    store.setState(_objectSpread(_objectSpread({}, store.getState()), {}, {\n      widgets: nextSearchState,\n      metadata: metadata,\n      searching: true\n    }));\n    search();\n  }\n  function onSearchForFacetValues(_ref5) {\n    var facetName = _ref5.facetName,\n      query = _ref5.query,\n      _ref5$maxFacetHits = _ref5.maxFacetHits,\n      maxFacetHits = _ref5$maxFacetHits === void 0 ? 10 : _ref5$maxFacetHits;\n    // The values 1, 100 are the min / max values that the engine accepts.\n    // see: https://www.algolia.com/doc/api-reference/api-parameters/maxFacetHits\n    var maxFacetHitsWithinRange = Math.max(1, Math.min(maxFacetHits, 100));\n    store.setState(_objectSpread(_objectSpread({}, store.getState()), {}, {\n      searchingForFacetValues: true\n    }));\n    helper.searchForFacetValues(facetName, query, maxFacetHitsWithinRange).then(function (content) {\n      var _objectSpread7;\n      store.setState(_objectSpread(_objectSpread({}, store.getState()), {}, {\n        error: null,\n        searchingForFacetValues: false,\n        resultsFacetValues: _objectSpread(_objectSpread({}, store.getState().resultsFacetValues), {}, (_objectSpread7 = {}, _defineProperty(_objectSpread7, facetName, content.facetHits), _defineProperty(_objectSpread7, \"query\", query), _objectSpread7))\n      }));\n    }, function (error) {\n      store.setState(_objectSpread(_objectSpread({}, store.getState()), {}, {\n        searchingForFacetValues: false,\n        error: error\n      }));\n    }).catch(function (error) {\n      // Since setState is synchronous, any error that occurs in the render of a\n      // component will be swallowed by this promise.\n      // This is a trick to make the error show up correctly in the console.\n      // See http://stackoverflow.com/a/30741722/969302\n      setTimeout(function () {\n        throw error;\n      });\n    });\n  }\n  function updateIndex(newIndex) {\n    initialSearchParameters = initialSearchParameters.setIndex(newIndex);\n    // No need to trigger a new search here as the widgets will also update and trigger it if needed.\n  }\n\n  function getWidgetsIds() {\n    return store.getState().metadata.reduce(function (res, meta) {\n      return typeof meta.id !== 'undefined' ? res.concat(meta.id) : res;\n    }, []);\n  }\n  return {\n    store: store,\n    widgetsManager: widgetsManager,\n    getWidgetsIds: getWidgetsIds,\n    getSearchParameters: getSearchParameters,\n    onSearchForFacetValues: onSearchForFacetValues,\n    onExternalStateUpdate: onExternalStateUpdate,\n    transitionState: transitionState,\n    updateClient: updateClient,\n    updateIndex: updateIndex,\n    clearCache: clearCache,\n    skipSearch: skipSearch\n  };\n}\nfunction hydrateMetadata(resultsState) {\n  if (!resultsState) {\n    return [];\n  }\n\n  // add a value noop, which gets replaced once the widgets are mounted\n  return resultsState.metadata.map(function (datum) {\n    return _objectSpread(_objectSpread({\n      value: function value() {\n        return {};\n      }\n    }, datum), {}, {\n      items: datum.items && datum.items.map(function (item) {\n        return _objectSpread(_objectSpread({\n          value: function value() {\n            return {};\n          }\n        }, item), {}, {\n          items: item.items && item.items.map(function (nestedItem) {\n            return _objectSpread({\n              value: function value() {\n                return {};\n              }\n            }, nestedItem);\n          })\n        });\n      })\n    });\n  });\n}","export default '6.40.4';","import { defer } from \"./utils.js\";\nexport default function createWidgetsManager(onWidgetsUpdate) {\n  var widgets = [];\n  // Is an update scheduled?\n  var scheduled = false;\n\n  // The state manager's updates need to be batched since more than one\n  // component can register or unregister widgets during the same tick.\n  function scheduleUpdate() {\n    if (scheduled) {\n      return;\n    }\n    scheduled = true;\n    defer(function () {\n      scheduled = false;\n      onWidgetsUpdate();\n    });\n  }\n  return {\n    registerWidget: function registerWidget(widget) {\n      widgets.push(widget);\n      scheduleUpdate();\n      return function unregisterWidget() {\n        widgets.splice(widgets.indexOf(widget), 1);\n        scheduleUpdate();\n      };\n    },\n    update: scheduleUpdate,\n    getWidgets: function getWidgets() {\n      return widgets;\n    }\n  };\n}","export default function createStore(initialState) {\n  var state = initialState;\n  var listeners = [];\n  return {\n    getState: function getState() {\n      return state;\n    },\n    setState: function setState(nextState) {\n      state = nextState;\n      listeners.forEach(function (listener) {\n        return listener();\n      });\n    },\n    subscribe: function subscribe(listener) {\n      listeners.push(listener);\n      return function unsubscribe() {\n        listeners.splice(listeners.indexOf(listener), 1);\n      };\n    }\n  };\n}","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nexport function isMetadataEnabled() {\n  return (typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === 'object' && _typeof(window.navigator) === 'object' && typeof window.navigator.userAgent === 'string' && window.navigator.userAgent.includes('Algolia Crawler') && _typeof(window.document) === 'object';\n}\nexport function getMetadataPayload(widgets, searchClient) {\n  var internalProps = ['contextValue', 'indexContextValue'];\n  var widgetsPayload = widgets.map(function (_ref) {\n    var props = _ref.props,\n      constructor = _ref.constructor;\n    var _ref2 = constructor._connectorDesc || {},\n      _ref2$defaultProps = _ref2.defaultProps,\n      defaultProps = _ref2$defaultProps === void 0 ? {} : _ref2$defaultProps,\n      _ref2$displayName = _ref2.displayName,\n      displayName = _ref2$displayName === void 0 ? constructor.displayName : _ref2$displayName;\n    return {\n      displayName: displayName,\n      $$type: constructor.$$type,\n      $$widgetType: constructor.$$widgetType,\n      params: Object.keys(props).filter(function (prop) {\n        return !internalProps.includes(prop) && defaultProps[prop] !== props[prop] && props[prop] !== undefined;\n      })\n    };\n  });\n  var client = searchClient;\n  var ua = client.transporter && client.transporter.userAgent ? client.transporter.userAgent.value : client._ua;\n  return {\n    ua: ua,\n    widgets: widgetsPayload\n  };\n}\nexport function injectMetadata(widgets, searchClient) {\n  var payloadContainer = document.createElement('meta');\n  var refNode = document.querySelector('head');\n  payloadContainer.name = 'algolia:metadata';\n  var payload = getMetadataPayload(widgets, searchClient);\n  payloadContainer.content = JSON.stringify(payload);\n  refNode.appendChild(payloadContainer);\n}","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\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 } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport PropTypes from 'prop-types';\nimport React, { Component, Children } from 'react';\nimport isEqual from 'react-fast-compare';\nimport { InstantSearchProvider } from \"../core/context.js\";\nimport createInstantSearchManager from \"../core/createInstantSearchManager.js\";\nimport { isMetadataEnabled, injectMetadata } from \"../core/metadata.js\";\nfunction isControlled(props) {\n  return Boolean(props.searchState);\n}\n\n/**\n * @description\n * `<InstantSearch>` is the root component of all React InstantSearch implementations.\n * It provides all the connected components (aka widgets) a means to interact\n * with the searchState.\n * @kind widget\n * @name <InstantSearch>\n * @requirements You will need to have an Algolia account to be able to use this widget.\n * [Create one now](https://www.algolia.com/users/sign_up).\n * @propType {string} indexName - Main index in which to search.\n * @propType {boolean} [refresh=false] - Flag to activate when the cache needs to be cleared so that the front-end is updated when a change occurs in the index.\n * @propType {object} [searchClient] - Provide a custom search client.\n * @propType {func} [onSearchStateChange] - Function to be called everytime a new search is done. Useful for [URL Routing](guide/Routing.html).\n * @propType {object} [searchState] - Object to inject some search state. Switches the InstantSearch component in controlled mode. Useful for [URL Routing](guide/Routing.html).\n * @propType {func} [createURL] - Function to call when creating links, useful for [URL Routing](guide/Routing.html).\n * @propType {SearchResults|SearchResults[]} [resultsState] - Use this to inject the results that will be used at first rendering. Those results are found by using the `findResultsState` function. Useful for [Server Side Rendering](guide/Server-side_rendering.html).\n * @propType {number} [stalledSearchDelay=200] - The amount of time before considering that the search takes too much time. The time is expressed in milliseconds.\n * @propType {{ Root: string|function, props: object }} [root] - Use this to customize the root element. Default value: `{ Root: 'div' }`\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <SearchBox />\n *     <Hits />\n *   </InstantSearch>\n * );\n */\nvar InstantSearch = /*#__PURE__*/function (_Component) {\n  _inherits(InstantSearch, _Component);\n  var _super = _createSuper(InstantSearch);\n  function InstantSearch(props) {\n    var _this;\n    _classCallCheck(this, InstantSearch);\n    _this = _super.call(this, props);\n    _defineProperty(_assertThisInitialized(_this), \"cleanupTimerRef\", null);\n    _defineProperty(_assertThisInitialized(_this), \"isUnmounting\", false);\n    var instantSearchManager = createInstantSearchManager({\n      indexName: _this.props.indexName,\n      searchClient: _this.props.searchClient,\n      initialState: _this.props.searchState || {},\n      resultsState: _this.props.resultsState,\n      stalledSearchDelay: _this.props.stalledSearchDelay\n    });\n    var contextValue = {\n      store: instantSearchManager.store,\n      widgetsManager: instantSearchManager.widgetsManager,\n      mainTargetedIndex: _this.props.indexName,\n      onInternalStateUpdate: _this.onWidgetsInternalStateUpdate.bind(_assertThisInitialized(_this)),\n      createHrefForState: _this.createHrefForState.bind(_assertThisInitialized(_this)),\n      onSearchForFacetValues: _this.onSearchForFacetValues.bind(_assertThisInitialized(_this)),\n      onSearchStateChange: _this.onSearchStateChange.bind(_assertThisInitialized(_this)),\n      onSearchParameters: _this.onSearchParameters.bind(_assertThisInitialized(_this))\n    };\n    _this.state = {\n      isControlled: isControlled(_this.props),\n      instantSearchManager: instantSearchManager,\n      contextValue: contextValue\n    };\n    return _this;\n  }\n  _createClass(InstantSearch, [{\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      var prevIsControlled = isControlled(prevProps);\n      if (prevIsControlled && !this.state.isControlled) {\n        throw new Error(\"You can't switch <InstantSearch> from being controlled to uncontrolled\");\n      }\n      if (!prevIsControlled && this.state.isControlled) {\n        throw new Error(\"You can't switch <InstantSearch> from being uncontrolled to controlled\");\n      }\n      if (this.props.refresh !== prevProps.refresh && this.props.refresh) {\n        this.state.instantSearchManager.clearCache();\n      }\n      if (prevProps.indexName !== this.props.indexName) {\n        this.state.instantSearchManager.updateIndex(this.props.indexName);\n      }\n      if (prevProps.searchClient !== this.props.searchClient) {\n        this.state.instantSearchManager.updateClient(this.props.searchClient);\n      }\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      if (this.cleanupTimerRef) {\n        clearTimeout(this.cleanupTimerRef);\n        this.cleanupTimerRef = null;\n      }\n      if (isMetadataEnabled()) {\n        injectMetadata(this.state.instantSearchManager.widgetsManager.getWidgets(), this.props.searchClient);\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      var _this2 = this;\n      this.cleanupTimerRef = setTimeout(function () {\n        _this2.isUnmounting = true;\n        _this2.state.instantSearchManager.skipSearch();\n      });\n    }\n  }, {\n    key: \"createHrefForState\",\n    value: function createHrefForState(searchState) {\n      searchState = this.state.instantSearchManager.transitionState(searchState);\n      return this.state.isControlled && this.props.createURL ? this.props.createURL(searchState, this.getKnownKeys()) : '#';\n    }\n  }, {\n    key: \"onWidgetsInternalStateUpdate\",\n    value: function onWidgetsInternalStateUpdate(searchState) {\n      searchState = this.state.instantSearchManager.transitionState(searchState);\n      this.onSearchStateChange(searchState);\n      if (!this.state.isControlled) {\n        this.state.instantSearchManager.onExternalStateUpdate(searchState);\n      }\n    }\n  }, {\n    key: \"onSearchStateChange\",\n    value: function onSearchStateChange(searchState) {\n      if (this.props.onSearchStateChange && !this.isUnmounting) {\n        this.props.onSearchStateChange(searchState);\n      }\n    }\n  }, {\n    key: \"onSearchParameters\",\n    value: function onSearchParameters(getSearchParameters, context, props, getMetadata, displayName) {\n      if (this.props.onSearchParameters) {\n        var _searchState = this.props.searchState ? this.props.searchState : {};\n        this.props.onSearchParameters(getSearchParameters, context, props, _searchState);\n      }\n      if (this.props.widgetsCollector) {\n        var _searchState2 = this.props.searchState ? this.props.searchState : {};\n        this.props.widgetsCollector({\n          getSearchParameters: getSearchParameters,\n          getMetadata: getMetadata,\n          context: context,\n          props: props,\n          searchState: _searchState2,\n          displayName: displayName\n        });\n      }\n    }\n  }, {\n    key: \"onSearchForFacetValues\",\n    value: function onSearchForFacetValues(searchState) {\n      this.state.instantSearchManager.onSearchForFacetValues(searchState);\n    }\n  }, {\n    key: \"getKnownKeys\",\n    value: function getKnownKeys() {\n      return this.state.instantSearchManager.getWidgetsIds();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      if (Children.count(this.props.children) === 0) {\n        return null;\n      }\n      return /*#__PURE__*/React.createElement(InstantSearchProvider, {\n        value: this.state.contextValue\n      }, this.props.children);\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      var nextIsControlled = isControlled(nextProps);\n      var previousSearchState = prevState.instantSearchManager.store.getState().widgets;\n      var nextSearchState = nextProps.searchState;\n      if (nextIsControlled && !isEqual(previousSearchState, nextSearchState)) {\n        prevState.instantSearchManager.onExternalStateUpdate(nextProps.searchState);\n      }\n      return {\n        isControlled: nextIsControlled,\n        contextValue: _objectSpread(_objectSpread({}, prevState.contextValue), {}, {\n          mainTargetedIndex: nextProps.indexName\n        })\n      };\n    }\n  }]);\n  return InstantSearch;\n}(Component);\n_defineProperty(InstantSearch, \"defaultProps\", {\n  stalledSearchDelay: 200,\n  refresh: false\n});\n_defineProperty(InstantSearch, \"propTypes\", {\n  // @TODO: These props are currently constant.\n  indexName: PropTypes.string.isRequired,\n  searchClient: PropTypes.shape({\n    search: PropTypes.func.isRequired,\n    searchForFacetValues: PropTypes.func,\n    addAlgoliaAgent: PropTypes.func,\n    clearCache: PropTypes.func\n  }).isRequired,\n  createURL: PropTypes.func,\n  refresh: PropTypes.bool,\n  searchState: PropTypes.object,\n  onSearchStateChange: PropTypes.func,\n  onSearchParameters: PropTypes.func,\n  widgetsCollector: PropTypes.func,\n  resultsState: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),\n  children: PropTypes.node,\n  stalledSearchDelay: PropTypes.number\n});\nexport default InstantSearch;","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport * as React from \"react\";\nimport { cssValue } from \"./helpers/unitConverter\";\nimport { createAnimation } from \"./helpers/animation\";\nvar clip = createAnimation(\"ClipLoader\", \"0% {transform: rotate(0deg) scale(1)} 50% {transform: rotate(180deg) scale(0.8)} 100% {transform: rotate(360deg) scale(1)}\", \"clip\");\nfunction ClipLoader(_a) {\n    var _b = _a.loading, loading = _b === void 0 ? true : _b, _c = _a.color, color = _c === void 0 ? \"#000000\" : _c, _d = _a.speedMultiplier, speedMultiplier = _d === void 0 ? 1 : _d, _e = _a.cssOverride, cssOverride = _e === void 0 ? {} : _e, _f = _a.size, size = _f === void 0 ? 35 : _f, additionalprops = __rest(_a, [\"loading\", \"color\", \"speedMultiplier\", \"cssOverride\", \"size\"]);\n    var style = __assign({ background: \"transparent !important\", width: cssValue(size), height: cssValue(size), borderRadius: \"100%\", border: \"2px solid\", borderTopColor: color, borderBottomColor: \"transparent\", borderLeftColor: color, borderRightColor: color, display: \"inline-block\", animation: \"\".concat(clip, \" \").concat(0.75 / speedMultiplier, \"s 0s infinite linear\"), animationFillMode: \"both\" }, cssOverride);\n    if (!loading) {\n        return null;\n    }\n    return React.createElement(\"span\", __assign({ style: style }, additionalprops));\n}\nexport default ClipLoader;\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\nconst MotionContext = createContext({});\n\nexport { MotionContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nconst PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","const isBrowser = typeof window !== \"undefined\";\n\nexport { isBrowser };\n","import { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.mjs';\n\nconst useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\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","import { createContext } from 'react';\n\nconst LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\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 { 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","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","/**\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 { 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","const noop = (any) => any;\n\nexport { noop };\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","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","/**\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 { 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 { 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 { 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"],"names":["EventEmitter","this","_events","_maxListeners","undefined","isFunction","arg","isObject","isUndefined","module","exports","prototype","defaultMaxListeners","setMaxListeners","n","isNaN","TypeError","emit","type","er","handler","len","args","i","listeners","error","length","arguments","Error","err","context","call","Array","slice","apply","addListener","listener","m","newListener","push","warned","console","trace","on","once","fired","g","removeListener","list","position","splice","removeAllListeners","key","listenerCount","evlistener","emitter","hasElementType","Element","hasMap","Map","hasSet","Set","hasArrayBuffer","ArrayBuffer","isView","equal","a","b","constructor","keys","it","isArray","size","entries","next","done","has","value","get","RegExp","source","flags","valueOf","Object","toString","hasOwnProperty","$$typeof","message","match","warn","AlgoliaSearchHelper","SearchParameters","SearchResults","algoliasearchHelper","client","index","opts","version","DerivedHelper","mainHelper","fn","main","lastResults","inherits","detach","detachDerivedHelper","getModifiedState","parameters","defaultsPure","objectHasKeys","omit","lib","addRefinement","refinementList","attribute","isRefined","valueAsString","facetRefinement","concat","mod","removeRefinement","clearRefinement","v","f","toggleRefinement","refinementType","hasChanged","newRefinementList","reduce","memo","values","facetList","filter","refinementValue","containsRefinements","Boolean","refinementValueAsString","indexOf","find","intersection","merge","valToNumber","isValidUserToken","RefinementList","isEqualNumericRefinement","every","el","newParameters","params","_parseNumbers","userToken","facets","disjunctiveFacets","hierarchicalFacets","facetsRefinements","facetsExcludes","disjunctiveFacetsRefinements","numericRefinements","tagRefinements","hierarchicalFacetsRefinements","self","forEach","paramName","isKeyKnown","PARAMETERS","isValueDefined","partialState","numbers","k","parsedValue","parseFloat","insideBoundingBox","map","geoRect","operators","operator","parsedValues","vPrime","make","instance","facet","rootPath","currentRefinement","getHierarchicalRefinement","name","clearRefinements","toggleHierarchicalFacetRefinement","validate","currentState","tagFilters","numericFilters","patch","_clearNumericRefinements","setQueryParameters","clearTags","setIndex","setQuery","newQuery","query","setPage","newPage","page","setFacets","setDisjunctiveFacets","setHitsPerPage","hitsPerPage","setTypoTolerance","typoTolerance","addNumericRefinement","val","isNumericRefined","getConjunctiveRefinements","facetName","isConjunctiveFacet","getDisjunctiveRefinements","isDisjunctiveFacet","getExcludeRefinements","removeNumericRefinement","number","paramValue","op","getNumericRefinements","getNumericRefinement","newNumericRefinements","operatorList","outValues","addFacet","addDisjunctiveFacet","addHierarchicalFacet","hierarchicalFacet","isHierarchicalFacet","addFacetRefinement","addExcludeRefinement","addDisjunctiveFacetRefinement","addTagRefinement","tag","isTagRefined","modification","removeFacet","removeDisjunctiveFacet","removeHierarchicalFacet","removeFacetRefinement","removeExcludeRefinement","removeDisjunctiveFacetRefinement","removeTagRefinement","t","toggleFacetRefinement","toggleConjunctiveFacetRefinement","toggleDisjunctiveFacetRefinement","toggleExcludeFacetRefinement","separator","_getHierarchicalFacetSeparator","getHierarchicalFacetByName","lastIndexOf","addHierarchicalFacetRefinement","path","isHierarchicalFacetRefined","removeHierarchicalFacetRefinement","toggleTagRefinement","isFacetRefined","isExcludeRefined","isDisjunctiveFacetRefined","refinements","isOperatorDefined","array","searchedValue","isAttributeValueDefined","currentValue","getRefinedDisjunctiveFacets","disjunctiveNumericRefinedFacets","getRefinedHierarchicalFacets","sort","getUnrefinedDisjunctiveFacets","refinedFacets","managedParameters","getQueryParams","queryParams","setQueryParameter","parameter","nextWithNumbers","previousPlainObject","acc","nextPlainObject","previous","isPreviousValueDefined","isNextValueDefined","resetPage","_getHierarchicalFacetSortBy","sortBy","_getHierarchicalRootPath","_getHierarchicalShowParentLevel","showParentLevel","hierarchicalFacetName","getHierarchicalFacetBreadcrumb","refinement","split","part","trim","JSON","stringify","state","hierarchicalFacetResult","hierarchicalFacetIndex","hierarchicalFacetRefinement","hierarchicalSeparator","hierarchicalRootPath","hierarchicalShowParentLevel","prepareHierarchicalFacetSortBy","rootExhaustive","facetResult","exhaustive","generateTreeFn","hierarchicalTree","currentHierarchicalLevel","parent","level","data","subtree","picked","facetValue","tuple","parentPath","onlyMatchingTree","orderBy","facetCount","parts","escapedValue","escapeFacetValue","count","format","unescapeFacetValue","generateHierarchicalTree","results","fv","compact","findIndex","formatSort","getIndices","attributes","indices","idx","assignFacetStats","dest","facetStats","stats","options","mainSubResponse","_rawResults","processingTimeMS","sum","result","facetsIndices","disjunctiveFacetsIndices","nextDisjunctiveResult","mainFacets","facetKey","hierarchicalAttributeName","facetValueObject","facetIndex","idxAttributeName","exhaustiveFacetsCount","isFacetDisjunctive","isFacetConjunctive","facets_stats","disjunctiveFacet","dfacet","facetResults","attributeIndex","dataFromMainRequest","refinedFacet","defaultData","root","excludes","_state","extractNormalizedFacetValues","predicate","isExcluded","hierarchicalFacetValues","replace","currentRefinementSplit","unshift","setIsRefined","item","depth","child","recSort","sortFn","node","names","children","childNode","sortedChildren","getFacetStatsIfAvailable","getRefinement","attributeName","resultsFacets","getFacetByName","DEFAULT_SORT","getFacetValues","facetValues","facetOrdering","renderingContent","getFacetOrdering","orderedFacets","remainingFacets","reverseOrder","order","ordering","sortRemainingBy","sortViaFacetOrdering","vanillaSortFn","getFacetStats","getRefinements","res","facetDeclaration","rootFacet","intermediateFacet","newFacet","numericValue","requestBuilder","addAlgoliaAgent","setClient","_queryId","_lastQueryIdReceived","derivedHelpers","_currentNbQueries","setCurrentPage","_change","isPageReset","getCurrentPage","search","_search","onlyWithDerivedHelpers","searchOnlyWithDerivedHelpers","getQuery","_getHitsSearchParams","searchOnce","cb","tempState","queries","_getQueries","then","content","_originalResponse","e","catch","findAnswers","derivedHelper","Promise","resolve","derivedState","attributesForPrediction","nbHits","errorMessage","initIndex","queryLanguages","searchForFacetValues","maxFacetHits","userState","clientHasSFFV","clientHasInitIndex","isDisjunctive","algoliaQuery","getSearchForFacetQuery","searchForFacetValuesPromise","indexName","response","facetHits","q","addDisjunctiveRefine","addRefine","addFacetExclusion","addExclude","addTag","removeDisjunctiveRefine","removeRefine","removeFacetExclusion","removeExclude","removeTag","toggleFacetExclusion","toggleExclude","toggleRefine","toggleTag","nextPage","previousPage","setState","newState","overrideStateWithoutTriggeringChangeEvent","hasRefinements","isDisjunctiveRefined","hasTag","hasTagRefinements","getIndex","getPage","getTags","r","states","mainQueries","queriesCount","helper","derivedQueries","derivedStateQueries","queryId","_dispatchAlgoliaResponse","bind","_dispatchAlgoliaError","s","specificResults","containsRefinement","facetFilters","_hasDisjunctiveRefinements","disjunctiveRefinements","event","clearCache","newClient","getClient","derive","pos","hasPendingRequests","sources","reduceRight","String","comparator","defaults","defaultInstructions","out","sortInstruction","matchingDefault","defaultInstruction","ctor","superCtor","create","enumerable","writable","configurable","arr1","arr2","isObjectOrArrayOrFunction","_merge","target","sourceVal","targetVal","l","obj","excluded","sourceKeys","compareAscending","other","valIsDefined","valIsNull","othIsDefined","othIsNull","collection","iteratees","orders","criteria","iteratee","object","sortObject","curr","_getDisjunctiveFacetSearchParams","filtersMap","segment","join","hasHierarchicalFacetFilter","some","filteredFacetFilters","facetFilter","filtered","filterValue","_getHitsHierarchicalFacetsAttributes","_getFacetFilters","_getNumericFilters","_getTagFilters","additionalParams","hierarchicalRootLevel","analytics","clickAnalytics","_getDisjunctiveHierarchicalFacetAttribute","vs","orFilters","attributeToRefine","attributesIndex","allAttributes","hierarchicalRefinement","newAttributes","rootLevel","parentLevel","stateForSearchForFacetValues","searchForFacetSearchParameters","facetQuery","test","_typeof","Symbol","iterator","_defineProperty","input","hint","prim","toPrimitive","Number","_toPrimitive","_toPropertyKey","defineProperty","getCurrentRefinement","props","searchState","_refine","nextRefinement","nextValue","displayName","$$type","propTypes","defaultRefinement","getProvidedProps","searchResults","ais","contextValue","multiIndexContext","indexContextValue","isSearchStalled","refine","cleanUp","_cleanUp","getSearchParameters","searchParameters","getMetadata","id","items","label","nextState","allSearchResults","searching","searchingForFacetValues","instantSearchContext","createContext","onInternalStateUpdate","createHrefForState","onSearchForFacetValues","onSearchStateChange","onSearchParameters","store","widgetsManager","mainTargetedIndex","InstantSearchConsumer","Consumer","InstantSearchProvider","Provider","_createContext","IndexConsumer","IndexProvider","_excluded","_extends","assign","_objectWithoutProperties","_objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","ownKeys","enumerableOnly","symbols","sym","getOwnPropertyDescriptor","_objectSpread","getOwnPropertyDescriptors","defineProperties","_classCallCheck","Constructor","_defineProperties","descriptor","_createClass","protoProps","staticProps","_inherits","subClass","superClass","_setPrototypeOf","o","p","setPrototypeOf","__proto__","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","_isNativeReflectConstruct","Super","_getPrototypeOf","NewTarget","_possibleConstructorReturn","_assertThisInitialized","ReferenceError","getPrototypeOf","connectorDesc","Composed","additionalWidgetProperties","Connector","isWidget","transitionState","_Component","_super","_this","providedProps","_ref","_len","_key","getState","widgets","_ref2","_len2","_key2","_ref3","_len3","_key3","_this2","cleanupTimerRef","clearTimeout","unsubscribe","subscribe","isUnmounting","unregisterWidget","registerWidget","nextProps","shouldComponentUpdate","propsEqual","prevProps","update","_this3","setTimeout","_this$props$contextVa","resultsFacetValues","metadata","nextWidgetsState","prevWidgetsState","_this$props","refineProps","createURL","searchForFacetValuesProps","searchForItems","Component","$$widgetType","defaultProps","createConnectorWithoutContext","getIndexId","hasMultipleIndices","targetedIndex","getResults","hits","indexId","refineValue","namespace","_objectSpread4","refineMultiIndexWithNamespace","refineMultiIndex","refineSingleIndexWithNamespace","refineSingleIndex","getNamespaceAndAttributeName","getCurrentRefinementValue","defaultValue","_getNamespaceAndAttri","multiIndex","hasRefinementsValue","cleanUpValue","_getNamespaceAndAttri2","_ref4","indexSearchState","cleanUpValueWithMultiIndex","cleanUpValueWithSingleIndex","hasOwn","shallowEqual","objA","objB","keysA","keysB","getDisplayName","resolved","defer","removeEmptyKey","isPlainObject","_excluded2","createConnector","prevSearchState","nextSearchState","propKeys","nonPresentKeys","_props","prop","subState","configureState","getIndexContext","Index","indexContext","Children","IndexWrapper","inferredIndexId","HIGHLIGHT_TAGS","highlightPreTag","highlightPostTag","_excluded3","addAlgoliaAgents","searchClient","isMultiIndexContext","widget","isTargetedIndexEqualIndex","isIndexWidget","isIndexWidgetEqualIndex","sortIndexWidgetsFirst","firstWidget","secondWidget","isFirstWidgetIndex","isSecondWidgetIndex","serializeQueryParameters","encodeURIComponent","encode","createInstantSearchManager","_ref$initialState","initialState","resultsState","stalledSearchDelay","stalledSearchTimer","_store$getState","handleSearchSuccess","handleSearchError","searchCounter","skip","initialSearchParameters","onWidgetsUpdate","scheduled","scheduleUpdate","getWidgets","createWidgetsManager","transporter","_cacheHydrated","_useCache","baseMethod","requests","methodArgs","requestsWithSerializedParams","request","responsesCache","method","set","rawResults","cache","hydrateSearchClientWithMultiIndexRequest","hydrateSearchClientWithSingleIndexRequest","hydrateSearchClient","createStore","hydrateMetadata","_internalIndexId","hydrateResultsState","sharedParameters","mainParameters","targetedIndexEqualMainIndex","subIndexEqualMainIndex","derivedIndices","targetedIndexNotEqualMainIndex","subIndexNotEqualMainIndex","derivedParameters","_getSearchParameters","isDerivedHelpersEmpty","nextIsSearchStalled","getWidgetsIds","meta","_ref5","_ref5$maxFacetHits","maxFacetHitsWithinRange","Math","max","min","_objectSpread7","onExternalStateUpdate","updateClient","updateIndex","newIndex","skipSearch","datum","nestedItem","injectMetadata","payloadContainer","document","createElement","refNode","querySelector","payload","internalProps","widgetsPayload","_connectorDesc","_ref2$defaultProps","_ref2$displayName","includes","ua","userAgent","_ua","getMetadataPayload","appendChild","isControlled","InstantSearch","instantSearchManager","onWidgetsInternalStateUpdate","prevState","nextIsControlled","previousSearchState","prevIsControlled","refresh","window","navigator","getKnownKeys","_searchState","widgetsCollector","_searchState2","isRequired","__assign","__rest","clip","_a","_b","loading","_c","color","_d","speedMultiplier","_e","cssOverride","_f","additionalprops","style","background","width","height","borderRadius","border","borderTopColor","borderBottomColor","borderLeftColor","borderRightColor","display","animation","animationFillMode","MotionConfigContext","transformPagePoint","isStatic","reducedMotion","MotionContext","isBrowser","useIsomorphicLayoutEffect","useLayoutEffect","useEffect","LazyContext","strict","camelToDash","str","toLowerCase","optimizedAppearDataAttribute","MotionGlobalConfig","stepsOrder","createRenderBatcher","scheduleNextBatch","allowKeepAlive","runNextFrame","useDefaultElapsed","delta","timestamp","isProcessing","flagRunNextFrame","steps","thisFrame","nextFrame","flushNextFrame","toKeepAlive","WeakSet","latestFrameData","triggerCallback","callback","step","schedule","keepAlive","immediate","queue","add","cancel","delete","process","frameData","clear","createRenderStep","read","resolveKeyframes","preRender","render","postRender","processBatch","performance","now","microtask","cancelMicrotask","queueMicrotask","isRefObject","ref","SwitchLayoutGroupContext","scheduleHandoffComplete","useVisualElement","visualState","createVisualElement","ProjectionNodeConstructor","visualElement","useContext","lazyContext","presenceContext","reducedMotionConfig","visualElementRef","useRef","renderer","current","blockInitialAnimation","initial","initialLayoutGroupConfig","projection","initialPromotionConfig","layoutId","layout","drag","dragConstraints","layoutScroll","layoutRoot","latestValues","getClosestProjectingNode","setOptions","alwaysMeasureLayout","animationType","createProjectionNode","useInsertionEffect","optimisedAppearId","wantsHandoff","MotionHandoffIsComplete","MotionHasOptimisedAnimation","updateFeatures","animationState","animateChanges","completeHandoff","allowProjection","useMotionRef","externalRef","useCallback","mount","unmount","isVariantLabel","isAnimationControls","start","variantPriorityOrder","variantProps","isControllingVariants","animate","isVariantNode","variants","useCreateMotionContext","inherit","getCurrentTreeVariants","useMemo","variantLabelsAsDependency","featureProps","exit","focus","hover","tap","pan","inView","featureDefinitions","isEnabled","LayoutGroupContext","motionComponentSymbol","for","preloadedFeatures","useRender","useVisualState","features","loadFeatures","ForwardRefComponent","forwardRef","MeasureLayout","configAndProps","useLayoutId","useStrictMode","layoutProjection","combined","ProjectionNode","getProjectionFunctionality","jsxs","jsx","layoutGroupId","createMotionProxy","createConfig","custom","customMotionComponentConfig","componentCache","_target","lowercaseSVGElements","isSVGComponent","scaleCorrectors","transformPropOrder","transformProps","isForcedMotionValue","startsWith","isMotionValue","getVelocity","getValueAsType","transform","clamp","parse","alpha","scale","default","sanitize","round","floatRegex","colorRegex","singleColorRegex","isString","createUnitType","unit","endsWith","degrees","percent","px","vh","vw","progressPercentage","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxWidth","maxHeight","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","x","y","z","perspective","transformPerspective","opacity","originX","originY","originZ","zIndex","backgroundPositionX","backgroundPositionY","fillOpacity","strokeOpacity","numOctaves","translateAlias","numTransforms","checkStringStartsWith","token","isCSSVariableName","startsAsVariableToken","isCSSVariableToken","singleCssVariableRegex","buildHTMLStyles","transformTemplate","vars","transformOrigin","hasTransform","hasTransformOrigin","valueAsType","transformString","transformIsDefault","valueIsDefault","buildTransform","createHtmlRenderState","copyRawValuesOnly","useStyle","useInitialMotionValues","useHTMLProps","htmlProps","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","tabIndex","onTap","onTapStart","whileTap","validMotionProps","isValidMotionProp","shouldForward","isValidProp","require","calcOrigin","origin","offset","dashKeys","camelKeys","buildSVGAttrs","attrX","attrY","attrScale","pathLength","pathSpacing","pathOffset","latest","isSVGTag","viewBox","attrs","dimensions","calcSVGTransformOrigin","spacing","useDashCase","buildSVGPath","createSvgRenderState","useSVGProps","_isStatic","visualProps","rawStyles","createUseRender","forwardMotionProps","filteredProps","isDom","filterProps","elementProps","Fragment","renderedChildren","renderHTML","element","styleProp","getProjectionStyles","setProperty","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","scrapeMotionValuesFromProps","newValues","getValue","liveStyle","willChange","applyWillChange","charAt","toUpperCase","substring","getValueState","resolveVariantFromProps","definition","velocity","isKeyframesTarget","resolveMotionValue","unwrappedValue","mix","toValue","acceleratedValues","getWillChangeName","addUniqueItem","arr","removeItem","makeUseVisualState","config","createRenderState","onMount","makeLatestValues","makeState","init","useConstant","addWillChange","memberName","forEachDefinition","transitionEnd","transition","shouldApplyWillChange","scrapeMotionValues","motionValues","isControllingVariants$1","isVariantNode$1","isInitialAnimationBlocked","variantToSet","valueTarget","noop","any","cancelFrame","requestAnimationFrame","svgMotionConfig","getBBox","getBoundingClientRect","tagName","htmlMotionConfig","addDomEvent","eventName","passive","addEventListener","removeEventListener","isPrimaryPointer","pointerType","button","isPrimary","extractEventInfo","pointType","point","addPointerEvent","addPointerInfo","combineFunctions","pipe","transformers","createLock","lock","openLock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal","openVertical","isDragActive","openGestureLock","Feature","isMounted","addHoverEvent","isActive","callbackName","info","getProps","whileHover","setActive","isNodeOrChild","parentElement","fireSyntheticPointerEvent","syntheticPointerEvent","PointerEvent","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","observeIntersection","rootInteresectionObserver","lookupRoot","rootObservers","IntersectionObserver","initIntersectionObserver","observe","unobserve","thresholdNames","all","gestureAnimations","super","hasEnteredView","isInView","startObserver","viewport","rootMargin","amount","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","onFocus","isFocusVisible","matches","onBlur","shallowCompare","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","warning","invariant","isNumericalString","splitCSSVariableRegex","getVariableValue","fallback","exec","token1","token2","parseCSSVariable","getComputedStyle","getPropertyValue","trimmed","positionalKeys","isNumOrPxType","getPosFromMatrix","matrix","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","positionalValues","testValueType","dimensionValueTypes","findDimensionValueType","toResolve","isScheduled","anyNeedsMeasurement","measureAllKeyframes","resolversToMeasure","from","resolver","needsMeasurement","elementsToMeasure","transformsToRestore","removedTransforms","removeNonTranslationalTransform","measureInitialState","restore","measureEndState","suspendedScrollY","scrollTo","complete","readAllKeyframes","readKeyframes","KeyframeResolver","unresolvedKeyframes","onComplete","motionValue","isAsync","isComplete","scheduleResolve","valueAsRead","readValue","setFinalKeyframe","renderEndStyles","resume","isColorString","testProp","isNullish","splitColor","aName","bName","cName","c","rgbUnit","clampRgbUnit","rgba","red","green","blue","alpha$1","hex","parseInt","hsla","hue","saturation","lightness","NUMBER_TOKEN","COLOR_TOKEN","complexRegex","analyseComplexValue","originalValue","indexes","var","types","parseComplexValue","createTransformer","numSections","output","convertNumbersToZero","complex","getAnimatableNone","parsed","transformer","maxDefaults","applyDefaultFilter","functionRegex","functions","defaultValueTypes","backgroundColor","outlineColor","fill","stroke","borderColor","WebkitFilter","getDefaultValueType","defaultValueType","invalidTemplates","DOMKeyframesResolver","keyframe","resolveNoneKeyframes","originType","targetType","noneKeyframeIndexes","animatableTemplate","noneIndex","makeNoneKeyframesAnimatable","pageYOffset","measuredOrigin","measureViewportBox","measureKeyframe","jump","finalKeyframeIndex","unsetTransformName","unsetTransformValue","clearTime","time","newTime","isAnimatable","BaseAnimation","autoplay","delay","repeatDelay","isStopped","hasAttemptedResolve","createdAt","updateFinishedPromise","calcStartTime","resolvedAt","_resolved","onKeyframesResolved","onUpdate","isGenerator","originKeyframe","targetKeyframe","isOriginAnimatable","isTargetAnimatable","hasKeyframesChanged","canAnimate","resolveFinishedPromise","resolvedAnimation","initPlayback","onPostResolved","reject","currentFinishedPromise","velocityPerSecond","frameDuration","calcGeneratorVelocity","resolveValue","prevT","safeMin","findSpring","bounce","mass","envelope","derivative","dampingRatio","undampedFreq","exponentialDecay","calcAngularFreq","exp","d","pow","initialGuess","approximateRoot","durationKeys","physicsKeys","isSpringType","spring","restDelta","isResolvedFromDuration","springOptions","derived","getSpringOptions","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","abs","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","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","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","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","onPlay","stopDriver","isBezierDefinition","isWaapiSupportedEasing","supportedWaapiEasing","cubicBezierAsString","mapEasingToNativeEasingWithDefault","mapEasingToNativeEasing","supportsWaapi","AcceleratedAnimation","owner","pregeneratedAnimation","sampleAnimation","pregeneratedKeyframes","pregenerateKeyframes","valueName","keyframeOptions","iterations","direction","animateStyle","pendingTimeline","timeline","onfinish","playbackRate","playState","attachTimeline","sampleTime","setWithVelocity","static","HTMLElement","supportsScrollTimeline","ScrollTimeline","GroupPlaybackControls","animations","runAll","onResolve","onReject","getAll","propName","setAll","newValue","cancelAll","prevProgress","onFrame","observeTimeline","cancelTimeline","methodName","controls","animateMotionValue","isHandoff","onEnd","valueTransition","when","_delay","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","shouldSkip","supports","SubscriptionManager","subscriptions","notify","numSubscriptions","getSize","collectMotionValues","MotionValue","canTrackVelocity","events","updateAndNotify","updatedAt","setPrevFrameValue","setCurrent","change","renderRequest","hasAnimated","prevFrameValue","prevUpdatedAt","onChange","subscription","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","sortByTreeOrder","animateChildren","first","last","sortNodePosition","reversePriorityOrder","numAnimationTypes","animateList","resolvedDefinition","animateVisualElement","checkVariantsDidChange","createTypeState","prevResolvedValues","createState","whileInView","whileDrag","whileFocus","isInitialRender","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","isPresent","onExitComplete","prevIsPresent","prevPresenceContext","exitAnimation","register","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","calcLength","axis","calcAxisDelta","originPoint","translate","calcBoxDelta","calcRelativeAxis","relative","calcRelativeAxisPosition","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","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","ownerDocument","defaultView","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","getSnapshotBeforeUpdate","layoutDependency","willUpdate","promote","relegate","stack","getStack","members","componentDidUpdate","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","useId","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","projectionUpdateScheduled","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","propagateDirtyNodes","resolveTargetDelta","calcProjection","cleanDirtyNodes","record","resolvedRelativeTargetAt","hasProjected","isVisible","animationProgress","sharedNodes","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","applyTreeDeltas","prevProjectionDelta","createProjectionDeltas","notifyAll","projectionDeltaWithTransform","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","prevRelativeTarget","mixTargetDelta","mixAxisDelta","mixAxis","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","roundPoint","maxDistance","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","documentNode","removePointerDownListener","onPointerDown","pointerDownEvent","session","createPanHandlers","onPanSessionStart","onPanStart","onPan","onPanEnd","removeGroupControls","dragControls","prefersReducedMotion","hasReducedMotionListener","visualElementStore","valueTypes","propEventHandlers","numVariantProps","DOMVisualElement","_prevProps","_visualElement","valueSubscriptions","prevMotionValues","propEventSubscriptions","notifyUpdate","isRenderScheduled","triggerBuild","renderInstance","baseTarget","initialValues","initialMotionValues","removeFromVariantTree","addVariantChild","bindToMotionValue","matchMedia","motionMediaQuery","setReducedMotionPreferences","initPrefersReducedMotion","feature","valueIsTransform","removeOnChange","latestValue","removeOnRenderRequest","sortInstanceNodePosition","featureDefinition","FeatureConstructor","build","measureInstanceViewportBox","getStaticValue","prevValue","existingValue","removeValue","updateMotionValuesFromProps","handleChildMotionValue","getVariant","getClosestVariantNode","startAtParent","closestVariantNode","removeValueFromRenderState","getBaseTargetFromProps","readValueFromInstance","setBaseTarget","valueFromInitial","compareDocumentPosition","HTMLVisualElement","defaultType","computedStyle","childSubscription","textContent","SVGVisualElement","getAttribute","motion"],"sourceRoot":""}