: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
list.forEach((definition) => {
const resolved = resolveVariantFromProps(props, definition);
const { transitionEnd, transition, ...target } = resolved;
for (const key in target) {
let valueTarget = target[key];
if (Array.isArray(valueTarget)) {
* Take final keyframe if the initial animation is blocked because
* we want to initialise at the end of that blocked animation.
const index = isInitialAnimationBlocked
valueTarget = valueTarget[index];
if (valueTarget !== null) {
values[key] = valueTarget;
for (const key in transitionEnd)
values[key] = transitionEnd[key];
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/utils/noop.mjs
const noop_noop = (any) => any;
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/frameloop/frame.mjs
const { schedule: frame_frame, cancel: cancelFrame, state: frameData, steps, } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop_noop, true);
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs
const svgMotionConfig = {
useVisualState: makeUseVisualState({
scrapeMotionValuesFromProps: scrape_motion_values_scrapeMotionValuesFromProps,
createRenderState: createSvgRenderState,
onMount: (props, instance, { renderState, latestValues }) => {
typeof instance.getBBox ===
: instance.getBoundingClientRect();
// Most likely trying to measure an unrendered element under Firefox
renderState.dimensions = {
frame_frame.render(() => {
buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, isSVGTag(instance.tagName), props.transformTemplate);
renderSVG(instance, renderState);
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/render/html/config-motion.mjs
const htmlMotionConfig = {
useVisualState: makeUseVisualState({
scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,
createRenderState: createHtmlRenderState,
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs
function create_config_createDomMotionConfig(Component, { forwardMotionProps = false }, preloadedFeatures, createVisualElement) {
const baseConfig = isSVGComponent(Component)
useRender: createUseRender(forwardMotionProps),
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/events/add-dom-event.mjs
function addDomEvent(target, eventName, handler, options = { passive: true }) {
target.addEventListener(eventName, handler, options);
return () => target.removeEventListener(eventName, handler);
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/events/utils/is-primary-pointer.mjs
const isPrimaryPointer = (event) => {
if (event.pointerType === "mouse") {
return typeof event.button !== "number" || event.button <= 0;
* isPrimary is true for all mice buttons, whereas every touch point
* is regarded as its own input. So subsequent concurrent touch points
* Specifically match against false here as incomplete versions of
* PointerEvents in very old browser might have it set as undefined.
return event.isPrimary !== false;
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/events/event-info.mjs
function extractEventInfo(event, pointType = "page") {
x: event[`${pointType}X`],
y: event[`${pointType}Y`],
const addPointerInfo = (handler) => {
return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/events/add-pointer-event.mjs
function addPointerEvent(target, eventName, handler, options) {
return addDomEvent(target, eventName, addPointerInfo(handler), options);
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/utils/pipe.mjs
* Compose other transformers to run linearily
* @param {...functions} transformers
const combineFunctions = (a, b) => (v) => b(a(v));
const pipe = (...transformers) => transformers.reduce(combineFunctions);
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs
function createLock(name) {
const globalHorizontalLock = createLock("dragHorizontal");
const globalVerticalLock = createLock("dragVertical");
function getGlobalLock(drag) {
lock = globalVerticalLock();
lock = globalHorizontalLock();
const openHorizontal = globalHorizontalLock();
const openVertical = globalVerticalLock();
if (openHorizontal && openVertical) {
// Release the locks because we don't use them
function isDragActive() {
// Check the gesture lock - if we get it, it means no drag gesture is active
// and we can safely fire the tap gesture.
const openGestureLock = getGlobalLock(true);
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/motion/features/Feature.mjs
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/gestures/hover.mjs
function addHoverEvent(node, isActive) {
const eventName = isActive ? "pointerenter" : "pointerleave";
const callbackName = isActive ? "onHoverStart" : "onHoverEnd";
const handleEvent = (event, info) => {
if (event.pointerType === "touch" || isDragActive())
const props = node.getProps();
if (node.animationState && props.whileHover) {
node.animationState.setActive("whileHover", isActive);
const callback = props[callbackName];
frame_frame.postRender(() => callback(event, info));
return addPointerEvent(node.current, eventName, handleEvent, {
passive: !node.getProps()[callbackName],
class HoverGesture extends Feature {
this.unmount = pipe(addHoverEvent(this.node, true), addHoverEvent(this.node, false));
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/gestures/focus.mjs
class FocusGesture extends Feature {
let isFocusVisible = false;
* If this element doesn't match focus-visible then don't
* apply whileHover. But, if matches throws that focus-visible
* is not a valid selector then in that browser outline styles will be applied
* to the element by default and we want to match that behaviour with whileFocus.
isFocusVisible = this.node.current.matches(":focus-visible");
if (!isFocusVisible || !this.node.animationState)
this.node.animationState.setActive("whileFocus", true);
if (!this.isActive || !this.node.animationState)
this.node.animationState.setActive("whileFocus", false);
this.unmount = pipe(addDomEvent(this.node.current, "focus", () => this.onFocus()), addDomEvent(this.node.current, "blur", () => this.onBlur()));
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs
* Recursively traverse up the tree to check whether the provided child node
* is the parent or a descendant of it.
* @param parent - Element to find
* @param child - Element to test against parent
const isNodeOrChild = (parent, child) => {
else if (parent === child) {
return isNodeOrChild(parent, child.parentElement);
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/gestures/press.mjs
function fireSyntheticPointerEvent(name, handler) {
const syntheticPointerEvent = new PointerEvent("pointer" + name);
handler(syntheticPointerEvent, extractEventInfo(syntheticPointerEvent));
class PressGesture extends Feature {
this.removeStartListeners = noop_noop;
this.removeEndListeners = noop_noop;
this.removeAccessibleListeners = noop_noop;
this.startPointerPress = (startEvent, startInfo) => {
this.removeEndListeners();
const props = this.node.getProps();
const endPointerPress = (endEvent, endInfo) => {
if (!this.checkPressEnd())
const { onTap, onTapCancel, globalTapTarget } = this.node.getProps();
* We only count this as a tap gesture if the event.target is the same
* as, or a child of, this component's element
const handler = !globalTapTarget &&
!isNodeOrChild(this.node.current, endEvent.target)
frame_frame.update(() => handler(endEvent, endInfo));
const removePointerUpListener = addPointerEvent(window, "pointerup", endPointerPress, {
passive: !(props.onTap || props["onPointerUp"]),
const removePointerCancelListener = addPointerEvent(window, "pointercancel", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo), {
passive: !(props.onTapCancel ||
props["onPointerCancel"]),
this.removeEndListeners = pipe(removePointerUpListener, removePointerCancelListener);
this.startPress(startEvent, startInfo);
this.startAccessiblePress = () => {
const handleKeydown = (keydownEvent) => {
if (keydownEvent.key !== "Enter" || this.isPressing)
const handleKeyup = (keyupEvent) => {
if (keyupEvent.key !== "Enter" || !this.checkPressEnd())
fireSyntheticPointerEvent("up", (event, info) => {
const { onTap } = this.node.getProps();
frame_frame.postRender(() => onTap(event, info));
this.removeEndListeners();
this.removeEndListeners = addDomEvent(this.node.current, "keyup", handleKeyup);
fireSyntheticPointerEvent("down", (event, info) => {
this.startPress(event, info);
const removeKeydownListener = addDomEvent(this.node.current, "keydown", handleKeydown);
const handleBlur = () => {
fireSyntheticPointerEvent("cancel", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo));
const removeBlurListener = addDomEvent(this.node.current, "blur", handleBlur);
this.removeAccessibleListeners = pipe(removeKeydownListener, removeBlurListener);
startPress(event, info) {
const { onTapStart, whileTap } = this.node.getProps();
* Ensure we trigger animations before firing event callback
if (whileTap && this.node.animationState) {
this.node.animationState.setActive("whileTap", true);
frame_frame.postRender(() => onTapStart(event, info));
this.removeEndListeners();
const props = this.node.getProps();
if (props.whileTap && this.node.animationState) {
this.node.animationState.setActive("whileTap", false);
cancelPress(event, info) {
if (!this.checkPressEnd())
const { onTapCancel } = this.node.getProps();
frame_frame.postRender(() => onTapCancel(event, info));
const props = this.node.getProps();
const removePointerListener = addPointerEvent(props.globalTapTarget ? window : this.node.current, "pointerdown", this.startPointerPress, {
passive: !(props.onTapStart ||
props["onPointerStart"]),
const removeFocusListener = addDomEvent(this.node.current, "focus", this.startAccessiblePress);
this.removeStartListeners = pipe(removePointerListener, removeFocusListener);
this.removeStartListeners();
this.removeEndListeners();
this.removeAccessibleListeners();
;// CONCATENATED MODULE: ./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs
* Map an IntersectionHandler callback to an element. We only ever make one handler for one
* element, so even though these handlers might all be triggered by different
* observers, we can keep them in the same map.
const observerCallbacks = new WeakMap();
* Multiple observers can be created for multiple element/document roots. Each with
* different settings. So here we store dictionaries of observers to each root,
* using serialised settings (threshold/margin) as lookup keys.
const observers = new WeakMap();
const fireObserverCallback = (entry) => {