https://hunter.io/assets/react-BWmk41Uc.js

1(function() {
2	try {
3		var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {};
4		e.SENTRY_RELEASE = { id: "b96dc26" };
5		var n = new e.Error().stack;
6		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "ecfd61b1-ef84-4835-b8ae-0eafa2810a1e", e._sentryDebugIdIdentifier = "sentry-dbid-ecfd61b1-ef84-4835-b8ae-0eafa2810a1e");
7	} catch (e) {}
8})();
9import { a as __toESM, n as __esmMin } from "./rolldown-runtime-sLwMD6dS.js";
10import { t as require_jsx_runtime } from "./jsx-runtime-CHSMGLHp.js";
11import { t as require_react } from "./react-CrLPhuc5.js";
12import { $ as NativeAnimation, $t as circOut, A as init_is_svg_element, B as init_keys_position, Bt as init_sync_time, C as init_build_attrs, Cn as invariant, D as resolveElements, Dn as addUniqueItem, En as init_clamp, F as init_DOMKeyframesResolver, Ft as init_units, G as init_get_value_transition, Gt as frameSteps, H as animateMotionValue, Ht as cancelFrame, I as camelToDash, It as percent, Jt as init_batcher, Kt as init_frame, Lt as px, M as init_is_html_element, Mt as mixNumber, N as isHTMLElement, Nt as complex, P as DOMKeyframesResolver, Pt as init_complex, Q as init_accelerated_values, R as init_is_motion_value, Rt as init_is_css_variable, S as cssStyleProperties, Sn as init_errors, St as notifyLayoutAnimationStart, T as init_build_styles, Tn as clamp, U as init_motion_value, Ut as frame, V as positionalKeys, Vt as time, W as getValueTransition, Wt as frameData, X as motionValue, Y as init_value, Z as acceleratedValues, a as init_measure, an as secondsToMilliseconds, at as KeyframeResolver, bn as MotionGlobalConfig, c as applyBoxDelta, cn as init_progress, ct as transformPropOrder, d as scalePoint, dn as pipe, dt as init_parse_transform, en as init_circ, et as init_NativeAnimation, f as transformBox, fn as init_noop, ft as readTransformValue, g as hasTransform, gt as init_defaults, h as hasScale, hn as isZeroValueString, ht as getDefaultValueType, i as visualElementStore, in as millisecondsToSeconds, j as isSVGElement, jt as init_number, kn as removeItem, l as applyTreeDeltas, ln as progress, lt as transformProps, m as has2DTranslate, mn as init_is_zero_value_string, mt as init_animatable_none, n as init_single_value, o as measurePageBox, on as SubscriptionManager, ot as init_KeyframesResolver, p as translateAxis, pn as noop, pt as getAnimatableNone, q as resolveTransition, qt as createRenderBatcher, r as init_store, rn as init_time_conversion, s as measureViewportBox, sn as init_subscription_manager, st as init_keys_transform, t as animateSingleValue, u as init_delta_apply, un as init_pipe, ut as defaultTransformValue, v as convertBoundingBoxToBox, vn as init_is_numerical_string, w as buildHTMLStyles, x as buildSVGAttrs, xn as init_global_config, xt as init_notify_inspector, y as convertBoxToBoundingBox, yn as isNumericalString, z as isMotionValue, zt as isCSSVariableName } from "./single-value-zOKmmSUX.js";
13import { r as init_MotionConfig } from "./Index-DO6EqESk.js";
14//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/animation/utils/calc-child-stagger.mjs
15function calcChildStagger(children, child, delayChildren, staggerChildren = 0, staggerDirection = 1) {
16	const index = Array.from(children).sort((a, b) => a.sortNodePosition(b)).indexOf(child);
17	const numChildren = children.size;
18	const maxStaggerDuration = (numChildren - 1) * staggerChildren;
19	return typeof delayChildren === "function" ? delayChildren(index, numChildren) : staggerDirection === 1 ? index * staggerChildren : maxStaggerDuration - index * staggerChildren;
20}
21//#endregion
22//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/resolve-variants.mjs
23function getValueState(visualElement) {
24	const state = [{}, {}];
25	visualElement?.values.forEach((value, key) => {
26		state[0][key] = value.get();
27		state[1][key] = value.getVelocity();
28	});
29	return state;
30}
31function resolveVariantFromProps(props, definition, custom, visualElement) {
32	/**
33	* If the variant definition is a function, resolve.
34	*/
35	if (typeof definition === "function") {
36		const [current, velocity] = getValueState(visualElement);
37		definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
38	}
39	/**
40	* If the variant definition is a variant label, or
41	* the function returned a variant label, resolve.
42	*/
43	if (typeof definition === "string") definition = props.variants && props.variants[definition];
44	/**
45	* At this point we've resolved both functions and variant labels,
46	* but the resolved variant label might itself have been a function.
47	* If so, resolve. This can only have returned a valid target object.
48	*/
49	if (typeof definition === "function") {
50		const [current, velocity] = getValueState(visualElement);
51		definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
52	}
53	return definition;
54}
55//#endregion
56//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/resolve-dynamic-variants.mjs
57function resolveVariant(visualElement, definition, custom) {
58	const props = visualElement.getProps();
59	return resolveVariantFromProps(props, definition, custom !== void 0 ? custom : props.custom, visualElement);
60}
61function init_resolve_dynamic_variants() {
62	return (init_resolve_dynamic_variants = __esmMin((() => {})))();
63}
64//#endregion
65//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/is-keyframes-target.mjs
66var isKeyframesTarget;
67function init_is_keyframes_target() {
68	return (init_is_keyframes_target = __esmMin((() => {
69		isKeyframesTarget = (v) => {
70			return Array.isArray(v);
71		};
72	})))();
73}
74//#endregion
75//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/setters.mjs
76/**
77* Set VisualElement's MotionValue, creating a new MotionValue for it if
78* it doesn't exist.
79*/
80function setMotionValue(visualElement, key, value) {
81	if (visualElement.hasValue(key)) visualElement.getValue(key).set(value);
82	else visualElement.addValue(key, motionValue(value));
83}
84function resolveFinalValueInKeyframes(v) {
85	return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
86}
87function setTarget(visualElement, definition) {
88	let { transitionEnd = {}, transition = {}, ...target } = resolveVariant(visualElement, definition) || {};
89	target = {
90		...target,
91		...transitionEnd
92	};
93	for (const key in target) setMotionValue(visualElement, key, resolveFinalValueInKeyframes(target[key]));
94}
95function init_setters() {
96	return (init_setters = __esmMin((() => {

97		init_value();
98		init_resolve_dynamic_variants();
99		init_is_keyframes_target();
100	})))();
101}
102//#endregion
103//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/value/will-change/is.mjs
104function isWillChangeMotionValue(value) {
105	return Boolean(isMotionValue(value) && value.add);
106}
107function init_is() {
108	return (init_is = __esmMin((() => {
109		init_is_motion_value();
110	})))();
111}
112//#endregion
113//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/value/will-change/add-will-change.mjs
114function addValueToWillChange(visualElement, key) {
115	const willChange = visualElement.getValue("willChange");
116	/**
117	* It could be that a user has set willChange to a regular MotionValue,
118	* in which case we can't add the value to it.
119	*/
120	if (isWillChangeMotionValue(willChange)) return willChange.add(key);
121	else if (!willChange && MotionGlobalConfig.WillChange) {
122		const newWillChange = new MotionGlobalConfig.WillChange("auto");
123		visualElement.addValue("willChange", newWillChange);
124		newWillChange.add(key);
125	}
126}
127function init_add_will_change() {
128	return (init_add_will_change = __esmMin((() => {
129		init_global_config();
130		init_is();
131	})))();
132}
133//#endregion
134//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/animation/optimized-appear/data-id.mjs
135var optimizedAppearDataId, optimizedAppearDataAttribute;
136function init_data_id() {
137	return (init_data_id = __esmMin((() => {
138		optimizedAppearDataId = "framerAppearId";
139		optimizedAppearDataAttribute = "data-" + camelToDash(optimizedAppearDataId);
140	})))();
141}
142//#endregion
143//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/animation/optimized-appear/get-appear-id.mjs
144function getOptimisedAppearId(visualElement) {
145	return visualElement.props[optimizedAppearDataAttribute];
146}
147function init_get_appear_id() {
148	return (init_get_appear_id = __esmMin((() => {
149		init_data_id();
150	})))();
151}
152//#endregion
153//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs
154/**
155* Decide whether we should block this animation. Previously, we achieved this
156* just by checking whether the key was listed in protectedKeys, but this
157* posed problems if an animation was triggered by afterChildren and protectedKeys
158* had been set to true in the meantime.
159*/
160function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
161	const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
162	needsAnimating[key] = false;
163	return shouldBlock;
164}
165function animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {
166	let { transition, transitionEnd, ...target } = targetAndTransition;
167	const defaultTransition = visualElement.getDefaultTransition();
168	transition = transition ? resolveTransition(transition, defaultTransition) : defaultTransition;
169	const reduceMotion = transition?.reduceMotion;
170	const skipAnimations = transition?.skipAnimations;
171	if (transitionOverride) transition = transitionOverride;
172	const animations = [];
173	const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];
174	const path = transition?.path;
175	if (path) path.animateVisualElement(visualElement, target, transition, delay, animations);
176	for (const key in target) {
177		const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);
178		const valueTarget = target[key];
179		if (valueTarget === void 0 || animationTypeState && shouldBlockAnimation(animationTypeState, key)) continue;
180		const valueTransition = {
181			delay,
182			...getValueTransition(transition || {}, key)
183		};
184		if (skipAnimations) valueTransition.skipAnimations = true;
185		/**
186		* If the value is already at the defined target, skip the animation.
187		* We still re-assert the value via frame.update to take precedence
188		* over any stale transitionEnd callbacks from previous animations.
189		*/
190		const currentValue = value.get();
191		if (currentValue !== void 0 && !value.isAnimating() && !Array.isArray(valueTarget) && valueTarget === currentValue && !valueTransition.velocity) {
192			frame.update(() => value.set(valueTarget));
193			continue;
194		}
195		/**
196		* If this is the first time a value is being animated, check
197		* to see if we're handling off from an existing animation.
198		*/
199		let isHandoff = false;

200		if (isBrowser$2 && window.MotionHandoffAnimation) {
201			const appearId = getOptimisedAppearId(visualElement);
202			if (appearId) {
203				const startTime = window.MotionHandoffAnimation(appearId, key, frame);
204				if (startTime !== null) {
205					valueTransition.startTime = startTime;
206					isHandoff = true;
207				}
208			}
209		}
210		addValueToWillChange(visualElement, key);
211		const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;
212		value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key) ? { type: false } : valueTransition, visualElement, isHandoff));
213		const animation = value.animation;
214		if (animation) animations.push(animation);
215	}
216	if (transitionEnd) {
217		const applyTransitionEnd = () => frame.update(() => {
218			transitionEnd && setTarget(visualElement, transitionEnd);
219		});
220		if (animations.length) Promise.all(animations).then(applyTransitionEnd);
221		else applyTransitionEnd();
222	}
223	return animations;
224}
225var isBrowser$2;
226function init_visual_element_target() {
227	return (init_visual_element_target = __esmMin((() => {
228		init_get_value_transition();
229		init_keys_position();
230		init_setters();
231		init_add_will_change();
232		init_get_appear_id();
233		init_motion_value();
234		init_frame();
235		isBrowser$2 = typeof window !== "undefined";
236	})))();
237}
238//#endregion
239//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs
240function animateVariant(visualElement, variant, options = {}) {
241	const resolved = resolveVariant(visualElement, variant, options.type === "exit" ? visualElement.presenceContext?.custom : void 0);
242	let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
243	if (options.transitionOverride) transition = options.transitionOverride;
244	/**
245	* If we have a variant, create a callback that runs it as an animation.
246	* Otherwise, we resolve a Promise immediately for a composable no-op.
247	*/
248	const getAnimation = resolved ? () => Promise.all(animateTarget(visualElement, resolved, options)) : () => Promise.resolve();
249	/**
250	* If we have children, create a callback that runs all their animations.
251	* Otherwise, we resolve a Promise immediately for a composable no-op.
252	*/
253	const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size ? (forwardDelay = 0) => {
254		const { delayChildren = 0, staggerChildren, staggerDirection } = transition;
255		return animateChildren(visualElement, variant, forwardDelay, delayChildren, staggerChildren, staggerDirection, options);
256	} : () => Promise.resolve();
257	/**
258	* If the transition explicitly defines a "when" option, we need to resolve either
259	* this animation or all children animations before playing the other.
260	*/
261	const { when } = transition;
262	if (when) {
263		const [first, last] = when === "beforeChildren" ? [getAnimation, getChildAnimations] : [getChildAnimations, getAnimation];
264		return first().then(() => last());
265	} else return Promise.all([getAnimation(), getChildAnimations(options.delay)]);
266}
267function animateChildren(visualElement, variant, delay = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {
268	const animations = [];
269	for (const child of visualElement.variantChildren) {
270		child.notify("AnimationStart", variant);
271		animations.push(animateVariant(child, variant, {
272			...options,
273			delay: delay + (typeof delayChildren === "function" ? 0 : delayChildren) + calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection)
274		}).then(() => child.notify("AnimationComplete", variant)));
275	}
276	return Promise.all(animations);
277}
278function init_visual_element_variant() {
279	return (init_visual_element_variant = __esmMin((() => {
280		init_resolve_dynamic_variants();
281		init_visual_element_target();
282	})))();
283}
284//#endregion
285//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs
286function animateVisualElement(visualElement, definition, options = {}) {
287	visualElement.notify("AnimationStart", definition);
288	let animation;
289	if (Array.isArray(definition)) {
290		const animations = definition.map((variant) => animateVariant(visualElement, variant, options));
291		animation = Promise.all(animations);
292	} else if (typeof definition === "string") animation = animateVariant(visualElement, definition, options);
293	else {
294		const resolvedDefinition = typeof definition === "function" ? resolveVariant(visualElement, definition, options.custom) : definition;
295		animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));
296	}
297	return animation.then(() => {
298		visualElement.notify("AnimationComplete", definition);
299	});
300}

301function init_visual_element() {
302	return (init_visual_element = __esmMin((() => {
303		init_resolve_dynamic_variants();
304		init_visual_element_target();
305		init_visual_element_variant();
306	})))();
307}
308//#endregion
309//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/utils/border-radius.mjs
310var cornerRadiusProps;
311function init_border_radius() {
312	return (init_border_radius = __esmMin((() => {
313		cornerRadiusProps = [
314			"borderTopLeftRadius",
315			"borderTopRightRadius",
316			"borderBottomRightRadius",
317			"borderBottomLeftRadius"
318		];
319	})))();
320}
321//#endregion
322//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/frameloop/microtask.mjs
323var microtask, cancelMicrotask;
324function init_microtask() {
325	return (init_microtask = __esmMin((() => {
326		init_batcher();
327		({schedule: microtask, cancel: cancelMicrotask} = /* @__PURE__ */ createRenderBatcher(queueMicrotask, false));
328	})))();
329}
330//#endregion
331//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/drag/state/is-active.mjs
332function isDragActive() {
333	return isDragging.x || isDragging.y;
334}
335var isDragging;
336function init_is_active() {
337	return (init_is_active = __esmMin((() => {
338		isDragging = {
339			x: false,
340			y: false
341		};
342	})))();
343}
344//#endregion
345//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/drag/state/set-active.mjs
346function setDragLock(axis) {
347	if (axis === "x" || axis === "y") {
348		if (isDragging[axis]) return null;
349		else {
350			isDragging[axis] = true;
351			return () => {
352				isDragging[axis] = false;
353			};
354		}
355	} else if (isDragging.x || isDragging.y) return null;
356	else {
357		isDragging.x = isDragging.y = true;
358		return () => {
359			isDragging.x = isDragging.y = false;
360		};
361	}
362}
363function init_set_active() {
364	return (init_set_active = __esmMin((() => {
365		init_is_active();
366	})))();
367}
368//#endregion
369//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/utils/setup.mjs
370function setupGesture(elementOrSelector, options) {
371	const elements = resolveElements(elementOrSelector);
372	const gestureAbortController = new AbortController();
373	const eventOptions = {
374		passive: true,
375		...options,
376		signal: gestureAbortController.signal
377	};
378	const cancel = () => gestureAbortController.abort();
379	return [
380		elements,
381		eventOptions,
382		cancel
383	];
384}
385function init_setup() {
386	return (init_setup = __esmMin((() => {})))();
387}
388//#endregion
389//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/hover.mjs
390function isValidHover(event) {
391	return !(event.pointerType === "touch" || isDragActive());
392}
393/**
394* Create a hover gesture. hover() is different to .addEventListener("pointerenter")
395* in that it has an easier syntax, filters out polyfilled touch events, interoperates
396* with drag gestures, and automatically removes the "pointerennd" event listener when the hover ends.
397*
398* @public
399*/
400function hover(elementOrSelector, onHoverStart, options = {}) {
401	const [elements, eventOptions, cancel] = setupGesture(elementOrSelector, options);
402	elements.forEach((element) => {
403		let isPressed = false;
404		let deferredHoverEnd = false;
405		let hoverEndCallback;
406		const removePointerLeave = () => {
407			element.removeEventListener("pointerleave", onPointerLeave);
408		};
409		const endHover = (event) => {
410			if (hoverEndCallback) {
411				hoverEndCallback(event);
412				hoverEndCallback = void 0;
413			}
414			removePointerLeave();
415		};
416		const onPointerUp = (event) => {
417			isPressed = false;
418			window.removeEventListener("pointerup", onPointerUp);
419			window.removeEventListener("pointercancel", onPointerUp);
420			if (deferredHoverEnd) {
421				deferredHoverEnd = false;
422				endHover(event);
423			}
424		};
425		const onPointerDown = () => {
426			isPressed = true;
427			window.addEventListener("pointerup", onPointerUp, eventOptions);
428			window.addEventListener("pointercancel", onPointerUp, eventOptions);
429		};
430		const onPointerLeave = (leaveEvent) => {
431			if (leaveEvent.pointerType === "touch") return;
432			if (isPressed) {
433				deferredHoverEnd = true;
434				return;
435			}
436			endHover(leaveEvent);
437		};
438		const onPointerEnter = (enterEvent) => {
439			if (!isValidHover(enterEvent)) return;
440			deferredHoverEnd = false;

441			const onHoverEnd = onHoverStart(element, enterEvent);
442			if (typeof onHoverEnd !== "function") return;
443			hoverEndCallback = onHoverEnd;
444			element.addEventListener("pointerleave", onPointerLeave, eventOptions);
445		};
446		element.addEventListener("pointerenter", onPointerEnter, eventOptions);
447		element.addEventListener("pointerdown", onPointerDown, eventOptions);
448	});
449	return cancel;
450}
451function init_hover() {
452	return (init_hover = __esmMin((() => {
453		init_is_active();
454		init_setup();
455	})))();
456}
457//#endregion
458//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/utils/is-node-or-child.mjs
459var isNodeOrChild;
460function init_is_node_or_child() {
461	return (init_is_node_or_child = __esmMin((() => {
462		isNodeOrChild = (parent, child) => {
463			if (!child) return false;
464			else if (parent === child) return true;
465			else return isNodeOrChild(parent, child.parentElement);
466		};
467	})))();
468}
469//#endregion
470//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs
471var isPrimaryPointer;
472function init_is_primary_pointer() {
473	return (init_is_primary_pointer = __esmMin((() => {
474		isPrimaryPointer = (event) => {
475			if (event.pointerType === "mouse") return typeof event.button !== "number" || event.button <= 0;
476			else
477 /**
478			* isPrimary is true for all mice buttons, whereas every touch point
479			* is regarded as its own input. So subsequent concurrent touch points
480			* will be false.
481			*
482			* Specifically match against false here as incomplete versions of
483			* PointerEvents in very old browser might have it set as undefined.
484			*/
485			return event.isPrimary !== false;
486		};
487	})))();
488}
489//#endregion
490//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.mjs
491/**
492* Checks if an element is natively keyboard accessible (focusable).
493* Used by the press gesture to determine if we need to add tabIndex.
494*/
495function isElementKeyboardAccessible(element) {
496	return keyboardAccessibleElements.has(element.tagName) || element.isContentEditable === true;
497}
498/**
499* Checks if an element has text selection or direct interaction behavior
500* that should block drag gestures from starting.
501*
502* This specifically targets form controls where the user might want to select
503* text or interact with the control (e.g., sliders, dropdowns).
504*
505* Buttons and links are NOT included because they don't have click-and-move
506* actions of their own - they only respond to click events, so dragging
507* should still work when initiated from these elements.
508*/
509function isElementTextInput(element) {
510	return textInputElements.has(element.tagName) || element.isContentEditable === true;
511}
512var keyboardAccessibleElements, textInputElements;
513function init_is_keyboard_accessible() {
514	return (init_is_keyboard_accessible = __esmMin((() => {
515		keyboardAccessibleElements = /* @__PURE__ */ new Set([
516			"BUTTON",
517			"INPUT",
518			"SELECT",
519			"TEXTAREA",
520			"A"
521		]);
522		textInputElements = /* @__PURE__ */ new Set([
523			"INPUT",
524			"SELECT",
525			"TEXTAREA"
526		]);
527	})))();
528}
529//#endregion
530//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/press/utils/state.mjs
531var isPressing;
532function init_state() {
533	return (init_state = __esmMin((() => {
534		isPressing = /* @__PURE__ */ new WeakSet();
535	})))();
536}
537//#endregion
538//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/press/utils/keyboard.mjs
539/**
540* Filter out events that are not "Enter" keys.
541*/
542function filterEvents(callback) {
543	return (event) => {
544		if (event.key !== "Enter") return;
545		callback(event);
546	};
547}
548function firePointerEvent(target, type) {
549	target.dispatchEvent(new PointerEvent("pointer" + type, {
550		isPrimary: true,
551		bubbles: true
552	}));
553}
554var enableKeyboardPress;
555function init_keyboard() {
556	return (init_keyboard = __esmMin((() => {
557		init_state();
558		enableKeyboardPress = (focusEvent, eventOptions) => {
559			const element = focusEvent.currentTarget;
560			if (!element) return;
561			const handleKeydown = filterEvents(() => {
562				if (isPressing.has(element)) return;
563				firePointerEvent(element, "down");
564				const handleKeyup = filterEvents(() => {
565					firePointerEvent(element, "up");
566				});
567				const handleBlur = () => firePointerEvent(element, "cancel");
568				element.addEventListener("keyup", handleKeyup, eventOptions);
569				element.addEventListener("blur", handleBlur, eventOptions);
570			});
571			element.addEventListener("keydown", handleKeydown, eventOptions);
572			/**
573			* Add an event listener that fires on blur to remove the keydown events.
574			*/
575			element.addEventListener("blur", () => element.removeEventListener("keydown", handleKeydown), eventOptions);
576		};
577	})))();
578}
579//#endregion
580//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/gestures/press/index.mjs
581/**
582* Filter out events that are not primary pointer events, or are triggering
583* while a Motion gesture is active.
584*/
585function isValidPressEvent(event) {
586	return isPrimaryPointer(event) && !isDragActive();
587}
588/**
589* Create a press gesture.
590*
591* Press is different to `"pointerdown"`, `"pointerup"` in that it
592* automatically filters out secondary pointer events like right
593* click and multitouch.
594*
595* It also adds accessibility support for keyboards, where
596* an element with a press gesture will receive focus and
597*  trigger on Enter `"keydown"` and `"keyup"` events.
598*
599* This is different to a browser's `"click"` event, which does
600* respond to keyboards but only for the `"click"` itself, rather
601* than the press start and end/cancel. The element also needs
602* to be focusable for this to work, whereas a press gesture will
603* make an element focusable by default.
604*
605* @public
606*/
607function press(targetOrSelector, onPressStart, options = {}) {
608	const [targets, eventOptions, cancelEvents] = setupGesture(targetOrSelector, options);
609	const startPress = (startEvent) => {
610		const target = startEvent.currentTarget;
611		if (!isValidPressEvent(startEvent)) return;
612		if (claimedPointerDownEvents.has(startEvent)) return;
613		isPressing.add(target);
614		if (options.stopPropagation) claimedPointerDownEvents.add(startEvent);
615		const onPressEnd = onPressStart(target, startEvent);
616		/**

617		* End listeners run in the capture phase so a descendant calling
618		* stopPropagation() in its own pointerup handler can't prevent the
619		* press gesture from ending. This also keeps the gesture-end
620		* ordering consistent with the drag gesture. See #2794.
621		*/
622		const endEventOptions = {
623			...eventOptions,
624			capture: true
625		};
626		const onPointerEnd = (endEvent, success) => {
627			window.removeEventListener("pointerup", onPointerUp, endEventOptions);
628			window.removeEventListener("pointercancel", onPointerCancel, endEventOptions);
629			if (isPressing.has(target)) isPressing.delete(target);
630			if (!isValidPressEvent(endEvent)) return;
631			if (typeof onPressEnd === "function") onPressEnd(endEvent, { success });
632		};
633		const onPointerUp = (upEvent) => {
634			onPointerEnd(upEvent, target === window || target === document || options.useGlobalTarget || isNodeOrChild(target, upEvent.target));
635		};
636		const onPointerCancel = (cancelEvent) => {
637			onPointerEnd(cancelEvent, false);
638		};
639		window.addEventListener("pointerup", onPointerUp, endEventOptions);
640		window.addEventListener("pointercancel", onPointerCancel, endEventOptions);
641	};
642	targets.forEach((target) => {
643		(options.useGlobalTarget ? window : target).addEventListener("pointerdown", startPress, eventOptions);
644		if (isHTMLElement(target)) {
645			target.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions));
646			if (!isElementKeyboardAccessible(target) && !target.hasAttribute("tabindex")) target.tabIndex = 0;
647		}
648	});
649	return cancelEvents;
650}
651var claimedPointerDownEvents;
652function init_press() {
653	return (init_press = __esmMin((() => {
654		init_is_html_element();
655		init_is_active();
656		init_is_node_or_child();
657		init_is_primary_pointer();
658		init_setup();
659		init_is_keyboard_accessible();
660		init_keyboard();
661		init_state();
662		claimedPointerDownEvents = /* @__PURE__ */ new WeakSet();
663	})))();
664}
665//#endregion
666//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/resize/handle-element.mjs
667function notifyTarget({ target, borderBoxSize }) {
668	resizeHandlers.get(target)?.forEach((handler) => {
669		handler(target, {
670			get width() {
671				return getWidth(target, borderBoxSize);
672			},
673			get height() {
674				return getHeight(target, borderBoxSize);
675			}
676		});
677	});
678}
679function notifyAll(entries) {
680	entries.forEach(notifyTarget);
681}
682function createResizeObserver() {
683	if (typeof ResizeObserver === "undefined") return;
684	observer = new ResizeObserver(notifyAll);
685}
686function resizeElement(target, handler) {
687	if (!observer) createResizeObserver();
688	const elements = resolveElements(target);
689	elements.forEach((element) => {
690		let elementHandlers = resizeHandlers.get(element);
691		if (!elementHandlers) {
692			elementHandlers = /* @__PURE__ */ new Set();
693			resizeHandlers.set(element, elementHandlers);
694		}
695		elementHandlers.add(handler);
696		observer?.observe(element);
697	});
698	return () => {
699		elements.forEach((element) => {
700			const elementHandlers = resizeHandlers.get(element);
701			elementHandlers?.delete(handler);
702			if (!elementHandlers?.size) observer?.unobserve(element);
703		});
704	};
705}
706var resizeHandlers, observer, getSize, getWidth, getHeight;
707function init_handle_element() {
708	return (init_handle_element = __esmMin((() => {
709		init_is_svg_element();
710		resizeHandlers = /* @__PURE__ */ new WeakMap();
711		getSize = (borderBoxAxis, svgAxis, htmlAxis) => (target, borderBoxSize) => {
712			if (borderBoxSize && borderBoxSize[0]) return borderBoxSize[0][borderBoxAxis + "Size"];
713			else if (isSVGElement(target) && "getBBox" in target) return target.getBBox()[svgAxis];
714			else return target[htmlAxis];
715		};
716		getWidth = /*@__PURE__*/ getSize("inline", "width", "offsetWidth");
717		getHeight = /*@__PURE__*/ getSize("block", "height", "offsetHeight");
718	})))();
719}
720//#endregion
721//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/resize/handle-window.mjs
722function createWindowResizeHandler() {
723	windowResizeHandler = () => {
724		const info = {
725			get width() {
726				return window.innerWidth;
727			},
728			get height() {
729				return window.innerHeight;
730			}
731		};
732		windowCallbacks.forEach((callback) => callback(info));
733	};
734	window.addEventListener("resize", windowResizeHandler);
735}
736function resizeWindow(callback) {
737	windowCallbacks.add(callback);
738	if (!windowResizeHandler) createWindowResizeHandler();
739	return () => {
740		windowCallbacks.delete(callback);
741		if (!windowCallbacks.size && typeof windowResizeHandler === "function") {
742			window.removeEventListener("resize", windowResizeHandler);
743			windowResizeHandler = void 0;
744		}
745	};
746}
747var windowCallbacks, windowResizeHandler;
748function init_handle_window() {
749	return (init_handle_window = __esmMin((() => {
750		windowCallbacks = /* @__PURE__ */ new Set();
751	})))();
752}
753//#endregion
754//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/resize/index.mjs
755function resize(a, b) {
756	return typeof a === "function" ? resizeWindow(a) : resizeElement(a, b);
757}
758function init_resize() {
759	return (init_resize = __esmMin((() => {

760		init_handle_element();
761		init_handle_window();
762	})))();
763}
764//#endregion
765//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/stats/buffer.mjs
766var statsBuffer;
767function init_buffer() {
768	return (init_buffer = __esmMin((() => {
769		statsBuffer = {
770			value: null,
771			addProjectionMetrics: null
772		};
773	})))();
774}
775//#endregion
776//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/utils/is-svg-svg-element.mjs
777/**
778* Checks if an element is specifically an SVGSVGElement (the root SVG element)
779* in a way that works across iframes
780*/
781function isSVGSVGElement(element) {
782	return isSVGElement(element) && element.tagName === "svg";
783}
784function init_is_svg_svg_element() {
785	return (init_is_svg_svg_element = __esmMin((() => {
786		init_is_svg_element();
787	})))();
788}
789//#endregion
790//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/geometry/models.mjs
791var createAxisDelta, createDelta, createAxis, createBox;
792function init_models() {
793	return (init_models = __esmMin((() => {
794		createAxisDelta = () => ({
795			translate: 0,
796			scale: 1,
797			origin: 0,
798			originPoint: 0
799		});
800		createDelta = () => ({
801			x: createAxisDelta(),
802			y: createAxisDelta()
803		});
804		createAxis = () => ({
805			min: 0,
806			max: 0
807		});
808		createBox = () => ({
809			x: createAxis(),
810			y: createAxis()
811		});
812	})))();
813}
814//#endregion
815//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.mjs
816function isAnimationControls(v) {
817	return v !== null && typeof v === "object" && typeof v.start === "function";
818}
819//#endregion
820//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/is-variant-label.mjs
821/**
822* Decides if the supplied variable is variant label
823*/
824function isVariantLabel(v) {
825	return typeof v === "string" || Array.isArray(v);
826}
827//#endregion
828//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/variant-props.mjs
829var variantPriorityOrder, variantProps;
830function init_variant_props() {
831	return (init_variant_props = __esmMin((() => {
832		variantPriorityOrder = [
833			"animate",
834			"whileInView",
835			"whileFocus",
836			"whileHover",
837			"whileTap",
838			"whileDrag",
839			"exit"
840		];
841		variantProps = ["initial", ...variantPriorityOrder];
842	})))();
843}
844//#endregion
845//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.mjs
846function isControllingVariants(props) {
847	if (isAnimationControls(props.animate)) return true;
848	for (let i = 0; i < variantProps.length; i++) if (isVariantLabel(props[variantProps[i]])) return true;
849	return false;
850}
851function isVariantNode(props) {
852	return Boolean(isControllingVariants(props) || props.variants);
853}
854function init_is_controlling_variants() {
855	return (init_is_controlling_variants = __esmMin((() => {
856		init_variant_props();
857	})))();
858}
859//#endregion
860//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/motion-values.mjs
861/**
862* Updates motion values from props changes.
863* Uses `any` type for element to avoid circular dependencies with VisualElement.
864*/
865function updateMotionValuesFromProps(element, next, prev) {
866	for (const key in next) {
867		const nextValue = next[key];
868		const prevValue = prev[key];
869		if (isMotionValue(nextValue))
870 /**
871		* If this is a motion value found in props or style, we want to add it
872		* to our visual element's motion value map.
873		*/
874		element.addValue(key, nextValue);
875		else if (isMotionValue(prevValue))
876 /**
877		* If we're swapping from a motion value to a static value,
878		* create a new motion value from that
879		*/
880		element.addValue(key, motionValue(nextValue, { owner: element }));
881		else if (prevValue !== nextValue) {
882			/**
883			* If this is a flat value that has changed, update the motion value
884			* or create one if it doesn't exist. We only want to do this if we're
885			* not handling the value with our animation state.
886			*/
887			if (element.hasValue(key)) {
888				const existingValue = element.getValue(key);
889				if (existingValue.liveStyle === true) existingValue.jump(nextValue);

890				else if (!existingValue.hasAnimated) existingValue.set(nextValue);
891			} else {
892				const latestValue = element.getStaticValue(key);
893				element.addValue(key, motionValue(latestValue !== void 0 ? latestValue : nextValue, { owner: element }));
894			}
895		}
896	}
897	for (const key in prev) if (next[key] === void 0) element.removeValue(key);
898	return next;
899}
900function init_motion_values() {
901	return (init_motion_values = __esmMin((() => {
902		init_value();
903		init_is_motion_value();
904	})))();
905}
906//#endregion
907//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/reduced-motion/state.mjs
908var prefersReducedMotion, hasReducedMotionListener;
909function init_state$1() {
910	return (init_state$1 = __esmMin((() => {
911		prefersReducedMotion = { current: null };
912		hasReducedMotionListener = { current: false };
913	})))();
914}
915//#endregion
916//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/reduced-motion/index.mjs
917function initPrefersReducedMotion() {
918	hasReducedMotionListener.current = true;
919	if (!isBrowser$1) return;
920	if (window.matchMedia) {
921		const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
922		const setReducedMotionPreferences = () => prefersReducedMotion.current = motionMediaQuery.matches;
923		motionMediaQuery.addEventListener("change", setReducedMotionPreferences);
924		setReducedMotionPreferences();
925	} else prefersReducedMotion.current = false;
926}
927var isBrowser$1;
928function init_reduced_motion() {
929	return (init_reduced_motion = __esmMin((() => {
930		init_state$1();
931		isBrowser$1 = typeof window !== "undefined";
932	})))();
933}
934//#endregion
935//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/VisualElement.mjs
936/**
937* Set feature definitions for all VisualElements.
938* This should be called by the framework layer (e.g., framer-motion) during initialization.
939*/
940function setFeatureDefinitions(definitions) {
941	featureDefinitions = definitions;
942}
943/**
944* Get the current feature definitions
945*/
946function getFeatureDefinitions() {
947	return featureDefinitions;
948}
949var propEventHandlers, featureDefinitions, VisualElement;
950function init_VisualElement() {
951	return (init_VisualElement = __esmMin((() => {
952		init_time_conversion(), init_is_numerical_string(), init_is_zero_value_string(), init_subscription_manager();
953		init_KeyframesResolver();
954		init_NativeAnimation();
955		init_accelerated_values();
956		init_microtask();
957		init_sync_time();
958		init_models();
959		init_value();
960		init_complex();
961		init_animatable_none();
962		init_is_motion_value();
963		init_store();
964		init_is_controlling_variants();
965		init_keys_transform();
966		init_motion_values();
967		init_reduced_motion();
968		init_state$1();
969		init_frame();
970		propEventHandlers = [
971			"AnimationStart",
972			"AnimationComplete",
973			"Update",
974			"BeforeLayoutMeasure",
975			"LayoutMeasure",
976			"LayoutAnimationStart",
977			"LayoutAnimationComplete"
978		];
979		featureDefinitions = {};
980		VisualElement = class {
981			/**
982			* This method takes React props and returns found MotionValues. For example, HTML
983			* MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
984			*
985			* This isn't an abstract method as it needs calling in the constructor, but it is
986			* intended to be one.
987			*/
988			scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {
989				return {};
990			}
991			constructor({ parent, props, presenceContext, reducedMotionConfig, skipAnimations, blockInitialAnimation, visualState }, options = {}) {
992				/**
993				* A reference to the current underlying Instance, e.g. a HTMLElement
994				* or Three.Mesh etc.
995				*/
996				this.current = null;
997				/**
998				* A set containing references to this VisualElement's children.
999				*/
1000				this.children = /* @__PURE__ */ new Set();
1001				/**
1002				* Determine what role this visual element should take in the variant tree.
1003				*/
1004				this.isVariantNode = false;
1005				this.isControllingVariants = false;
1006				/**
1007				* Decides whether this VisualElement should animate in reduced motion
1008				* mode.
1009				*
1010				* TODO: This is currently set on every individual VisualElement but feels
1011				* like it could be set globally.
1012				*/
1013				this.shouldReduceMotion = null;
1014				/**
1015				* Decides whether animations should be skipped for this VisualElement.
1016				* Useful for E2E tests and visual regression testing.
1017				*/
1018				this.shouldSkipAnimations = false;

1019				/**
1020				* A map of all motion values attached to this visual element. Motion
1021				* values are source of truth for any given animated value. A motion
1022				* value might be provided externally by the component via props.
1023				*/
1024				this.values = /* @__PURE__ */ new Map();
1025				this.KeyframeResolver = KeyframeResolver;
1026				/**
1027				* Cleanup functions for active features (hover/tap/exit etc)
1028				*/
1029				this.features = {};
1030				/**
1031				* A map of every subscription that binds the provided or generated
1032				* motion values onChange listeners to this visual element.
1033				*/
1034				this.valueSubscriptions = /* @__PURE__ */ new Map();
1035				/**
1036				* A reference to the previously-provided motion values as returned
1037				* from scrapeMotionValuesFromProps. We use the keys in here to determine
1038				* if any motion values need to be removed after props are updated.
1039				*/
1040				this.prevMotionValues = {};
1041				/**
1042				* Track whether this element has been mounted before, to detect
1043				* remounts after Suspense unmount/remount cycles.
1044				*/
1045				this.hasBeenMounted = false;
1046				/**
1047				* An object containing a SubscriptionManager for each active event.
1048				*/
1049				this.events = {};
1050				/**
1051				* An object containing an unsubscribe function for each prop event subscription.
1052				* For example, every "Update" event can have multiple subscribers via
1053				* VisualElement.on(), but only one of those can be defined via the onUpdate prop.
1054				*/
1055				this.propEventSubscriptions = {};
1056				this.notifyUpdate = () => this.notify("Update", this.latestValues);
1057				this.render = () => {
1058					if (!this.current) return;
1059					this.triggerBuild();
1060					this.renderInstance(this.current, this.renderState, this.props.style, this.projection);
1061				};
1062				this.renderScheduledAt = 0;
1063				this.scheduleRender = () => {
1064					const now = time.now();
1065					if (this.renderScheduledAt < now) {
1066						this.renderScheduledAt = now;
1067						frame.render(this.render, false, true);
1068					}
1069				};
1070				const { latestValues, renderState } = visualState;
1071				this.latestValues = latestValues;
1072				this.baseTarget = { ...latestValues };
1073				this.initialValues = props.initial ? { ...latestValues } : {};
1074				this.renderState = renderState;
1075				this.parent = parent;
1076				this.props = props;
1077				this.presenceContext = presenceContext;
1078				this.depth = parent ? parent.depth + 1 : 0;
1079				this.reducedMotionConfig = reducedMotionConfig;
1080				this.skipAnimationsConfig = skipAnimations;
1081				this.options = options;
1082				this.blockInitialAnimation = Boolean(blockInitialAnimation);
1083				this.isControllingVariants = isControllingVariants(props);
1084				this.isVariantNode = isVariantNode(props);
1085				if (this.isVariantNode) this.variantChildren = /* @__PURE__ */ new Set();
1086				this.manuallyAnimateOnMount = Boolean(parent && parent.current);
1087				/**
1088				* Any motion values that are provided to the element when created
1089				* aren't yet bound to the element, as this would technically be impure.
1090				* However, we iterate through the motion values and set them to the
1091				* initial values for this component.
1092				*
1093				* TODO: This is impure and we should look at changing this to run on mount.
1094				* Doing so will break some tests but this isn't necessarily a breaking change,
1095				* more a reflection of the test.
1096				*/
1097				const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);
1098				for (const key in initialMotionValues) {
1099					const value = initialMotionValues[key];
1100					if (latestValues[key] !== void 0 && isMotionValue(value)) value.set(latestValues[key]);
1101				}
1102			}
1103			mount(instance) {
1104				/**
1105				* If this element has been mounted before (e.g. after a Suspense
1106				* unmount/remount), reset motion values to their initial state
1107				* so animations replay correctly from initial → animate.
1108				*/
1109				if (this.hasBeenMounted) for (const key in this.initialValues) {
1110					this.values.get(key)?.jump(this.initialValues[key]);
1111					this.latestValues[key] = this.initialValues[key];
1112				}
1113				this.current = instance;
1114				visualElementStore.set(instance, this);
1115				if (this.projection && !this.projection.instance) this.projection.mount(instance);
1116				if (this.parent && this.isVariantNode && !this.isControllingVariants) this.removeFromVariantTree = this.parent.addVariantChild(this);

1117				this.values.forEach((value, key) => this.bindToMotionValue(key, value));
1118				/**
1119				* Determine reduced motion preference. Only initialize the matchMedia
1120				* listener if we actually need the dynamic value (i.e., when config
1121				* is neither "never" nor "always").
1122				*/
1123				if (this.reducedMotionConfig === "never") this.shouldReduceMotion = false;
1124				else if (this.reducedMotionConfig === "always") this.shouldReduceMotion = true;
1125				else {
1126					if (!hasReducedMotionListener.current) initPrefersReducedMotion();
1127					this.shouldReduceMotion = prefersReducedMotion.current;
1128				}
1129				/**
1130				* Set whether animations should be skipped based on the config.
1131				*/
1132				this.shouldSkipAnimations = this.skipAnimationsConfig ?? false;
1133				this.parent?.addChild(this);
1134				this.update(this.props, this.presenceContext);
1135				this.hasBeenMounted = true;
1136			}
1137			unmount() {
1138				this.projection && this.projection.unmount();
1139				cancelFrame(this.notifyUpdate);
1140				cancelFrame(this.render);
1141				this.valueSubscriptions.forEach((remove) => remove());
1142				this.valueSubscriptions.clear();
1143				this.removeFromVariantTree && this.removeFromVariantTree();
1144				this.parent?.removeChild(this);
1145				for (const key in this.events) this.events[key].clear();
1146				for (const key in this.features) {
1147					const feature = this.features[key];
1148					if (feature) {
1149						feature.unmount();
1150						feature.isMounted = false;
1151					}
1152				}
1153				this.current = null;
1154			}
1155			addChild(child) {
1156				this.children.add(child);
1157				this.enteringChildren ?? (this.enteringChildren = /* @__PURE__ */ new Set());
1158				this.enteringChildren.add(child);
1159			}
1160			removeChild(child) {
1161				this.children.delete(child);
1162				this.enteringChildren && this.enteringChildren.delete(child);
1163			}
1164			bindToMotionValue(key, value) {
1165				if (this.valueSubscriptions.has(key)) this.valueSubscriptions.get(key)();
1166				if (value.accelerate && acceleratedValues.has(key) && this.current instanceof HTMLElement) {
1167					const { factory, keyframes, times, ease, duration } = value.accelerate;
1168					const animation = new NativeAnimation({
1169						element: this.current,
1170						name: key,
1171						keyframes,
1172						times,
1173						ease,
1174						duration: secondsToMilliseconds(duration)
1175					});
1176					const cleanup = factory(animation);
1177					this.valueSubscriptions.set(key, () => {
1178						cleanup();
1179						animation.cancel();
1180					});
1181					return;
1182				}
1183				const valueIsTransform = transformProps.has(key);
1184				if (valueIsTransform && this.onBindTransform) this.onBindTransform();
1185				const removeOnChange = value.on("change", (latestValue) => {
1186					this.latestValues[key] = latestValue;
1187					this.props.onUpdate && frame.preRender(this.notifyUpdate);
1188					if (valueIsTransform && this.projection) this.projection.isTransformDirty = true;
1189					this.scheduleRender();
1190				});
1191				let removeSyncCheck;
1192				if (typeof window !== "undefined" && window.MotionCheckAppearSync) removeSyncCheck = window.MotionCheckAppearSync(this, key, value);
1193				this.valueSubscriptions.set(key, () => {
1194					removeOnChange();
1195					if (removeSyncCheck) removeSyncCheck();
1196				});
1197			}
1198			sortNodePosition(other) {
1199				/**
1200				* If these nodes aren't even of the same type we can't compare their depth.
1201				*/
1202				if (!this.current || !this.sortInstanceNodePosition || this.type !== other.type) return 0;
1203				return this.sortInstanceNodePosition(this.current, other.current);
1204			}
1205			updateFeatures() {
1206				let key = "animation";
1207				for (key in featureDefinitions) {
1208					const featureDefinition = featureDefinitions[key];
1209					if (!featureDefinition) continue;
1210					const { isEnabled, Feature: FeatureConstructor } = featureDefinition;
1211					/**
1212					* If this feature is enabled but not active, make a new instance.
1213					*/
1214					if (!this.features[key] && FeatureConstructor && isEnabled(this.props)) this.features[key] = new FeatureConstructor(this);
1215					/**
1216					* If we have a feature, mount or update it.
1217					*/
1218					if (this.features[key]) {
1219						const feature = this.features[key];
1220						if (feature.isMounted) feature.update();
1221						else {
1222							feature.mount();
1223							feature.isMounted = true;
1224						}
1225					}
1226				}
1227			}
1228			triggerBuild() {
1229				this.build(this.renderState, this.latestValues, this.props);
1230			}
1231			/**
1232			* Measure the current viewport box with or without transforms.
1233			* Only measures axis-aligned boxes, rotate and skew must be manually
1234			* removed with a re-render to work.
1235			*/
1236			measureViewportBox() {
1237				return this.current ? this.measureInstanceViewportBox(this.current, this.props) : createBox();
1238			}
1239			getStaticValue(key) {
1240				return this.latestValues[key];
1241			}
1242			setStaticValue(key, value) {
1243				this.latestValues[key] = value;
1244			}
1245			/**
1246			* Update the provided props. Ensure any newly-added motion values are
1247			* added to our map, old ones removed, and listeners updated.
1248			*/
1249			update(props, presenceContext) {
1250				if (props.transformTemplate || this.props.transformTemplate) this.scheduleRender();
1251				this.prevProps = this.props;
1252				this.props = props;
1253				this.prevPresenceContext = this.presenceContext;
1254				this.presenceContext = presenceContext;
1255				/**
1256				* Update prop event handlers ie onAnimationStart, onAnimationComplete
1257				*/
1258				for (let i = 0; i < propEventHandlers.length; i++) {

1259					const key = propEventHandlers[i];
1260					if (this.propEventSubscriptions[key]) {
1261						this.propEventSubscriptions[key]();
1262						delete this.propEventSubscriptions[key];
1263					}
1264					const listener = props["on" + key];
1265					if (listener) this.propEventSubscriptions[key] = this.on(key, listener);
1266				}
1267				this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps || {}, this), this.prevMotionValues);
1268				if (this.handleChildMotionValue) this.handleChildMotionValue();
1269			}
1270			getProps() {
1271				return this.props;
1272			}
1273			/**
1274			* Returns the variant definition with a given name.
1275			*/
1276			getVariant(name) {
1277				return this.props.variants ? this.props.variants[name] : void 0;
1278			}
1279			/**
1280			* Returns the defined default transition on this component.
1281			*/
1282			getDefaultTransition() {
1283				return this.props.transition;
1284			}
1285			getTransformPagePoint() {
1286				return this.props.transformPagePoint;
1287			}
1288			getClosestVariantNode() {
1289				return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
1290			}
1291			/**
1292			* Add a child visual element to our set of children.
1293			*/
1294			addVariantChild(child) {
1295				const closestVariantNode = this.getClosestVariantNode();
1296				if (closestVariantNode) {
1297					closestVariantNode.variantChildren && closestVariantNode.variantChildren.add(child);
1298					return () => closestVariantNode.variantChildren.delete(child);
1299				}
1300			}
1301			/**
1302			* Add a motion value and bind it to this visual element.
1303			*/
1304			addValue(key, value) {
1305				const existingValue = this.values.get(key);
1306				if (value !== existingValue) {
1307					if (existingValue) this.removeValue(key);
1308					this.bindToMotionValue(key, value);
1309					this.values.set(key, value);
1310					this.latestValues[key] = value.get();
1311				}
1312			}
1313			/**
1314			* Remove a motion value and unbind any active subscriptions.
1315			*/
1316			removeValue(key) {
1317				this.values.delete(key);
1318				const unsubscribe = this.valueSubscriptions.get(key);
1319				if (unsubscribe) {
1320					unsubscribe();
1321					this.valueSubscriptions.delete(key);
1322				}
1323				delete this.latestValues[key];
1324				this.removeValueFromRenderState(key, this.renderState);
1325			}
1326			/**
1327			* Check whether we have a motion value for this key
1328			*/
1329			hasValue(key) {
1330				return this.values.has(key);
1331			}
1332			getValue(key, defaultValue) {
1333				if (this.props.values && this.props.values[key]) return this.props.values[key];
1334				let value = this.values.get(key);
1335				if (value === void 0 && defaultValue !== void 0) {
1336					value = motionValue(defaultValue === null ? void 0 : defaultValue, { owner: this });
1337					this.addValue(key, value);
1338				}
1339				return value;
1340			}
1341			/**
1342			* If we're trying to animate to a previously unencountered value,
1343			* we need to check for it in our state and as a last resort read it
1344			* directly from the instance (which might have performance implications).
1345			*/
1346			readValue(key, target) {
1347				let value = this.latestValues[key] !== void 0 || !this.current ? this.latestValues[key] : this.getBaseTargetFromProps(this.props, key) ?? this.readValueFromInstance(this.current, key, this.options);
1348				if (value !== void 0 && value !== null) {
1349					if (typeof value === "string" && (isNumericalString(value) || isZeroValueString(value))) value = parseFloat(value);
1350					else if (typeof value !== "number" && !complex.test(value) && complex.test(target)) value = getAnimatableNone(key, target);
1351					this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);
1352				}
1353				return isMotionValue(value) ? value.get() : value;
1354			}
1355			/**
1356			* Set the base target to later animate back to. This is currently
1357			* only hydrated on creation and when we first read a value.
1358			*/
1359			setBaseTarget(key, value) {
1360				this.baseTarget[key] = value;
1361			}
1362			/**
1363			* Find the base target for a value thats been removed from all animation
1364			* props.
1365			*/
1366			getBaseTarget(key) {
1367				const { initial } = this.props;
1368				let valueFromInitial;
1369				if (typeof initial === "string" || typeof initial === "object") {
1370					const variant = resolveVariantFromProps(this.props, initial, this.presenceContext?.custom);
1371					if (variant) valueFromInitial = variant[key];
1372				}
1373				/**
1374				* If this value still exists in the current initial variant, read that.
1375				*/
1376				if (initial && valueFromInitial !== void 0) return valueFromInitial;
1377				/**
1378				* Alternatively, if this VisualElement config has defined a getBaseTarget
1379				* so we can read the value from an alternative source, try that.
1380				*/
1381				const target = this.getBaseTargetFromProps(this.props, key);
1382				if (target !== void 0 && !isMotionValue(target)) return target;
1383				/**
1384				* If the value was initially defined on initial, but it doesn't any more,
1385				* return undefined. Otherwise return the value as initially read from the DOM.
1386				*/
1387				return this.initialValues[key] !== void 0 && valueFromInitial === void 0 ? void 0 : this.baseTarget[key];
1388			}
1389			on(eventName, callback) {
1390				if (!this.events[eventName]) this.events[eventName] = new SubscriptionManager();
1391				return this.events[eventName].add(callback);
1392			}
1393			notify(eventName, ...args) {
1394				if (this.events[eventName]) this.events[eventName].notify(...args);
1395			}
1396			scheduleRenderMicrotask() {
1397				microtask.render(this.render);
1398			}
1399		};
1400	})))();
1401}
1402//#endregion
1403//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/dom/DOMVisualElement.mjs
1404var DOMVisualElement;
1405function init_DOMVisualElement() {
1406	return (init_DOMVisualElement = __esmMin((() => {
1407		init_is_motion_value();
1408		init_DOMKeyframesResolver();
1409		init_VisualElement();
1410		DOMVisualElement = class extends VisualElement {
1411			constructor() {
1412				super(...arguments);
1413				this.KeyframeResolver = DOMKeyframesResolver;
1414			}
1415			sortInstanceNodePosition(a, b) {
1416				/**
1417				* compareDocumentPosition returns a bitmask, by using the bitwise &
1418				* we're returning true if 2 in that bitmask is set to true. 2 is set
1419				* to true if b preceeds a.
1420				*/
1421				return a.compareDocumentPosition(b) & 2 ? 1 : -1;
1422			}
1423			getBaseTargetFromProps(props, key) {
1424				const style = props.style;
1425				return style ? style[key] : void 0;
1426			}
1427			removeValueFromRenderState(key, { vars, style }) {
1428				delete vars[key];
1429				delete style[key];
1430			}
1431			handleChildMotionValue() {
1432				if (this.childSubscription) {
1433					this.childSubscription();
1434					delete this.childSubscription;
1435				}
1436				const { children } = this.props;
1437				if (isMotionValue(children)) this.childSubscription = children.on("change", (latest) => {
1438					if (this.current) this.current.textContent = `${latest}`;
1439				});
1440			}
1441		};
1442	})))();
1443}
1444//#endregion
1445//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/Feature.mjs
1446var Feature;

1447function init_Feature() {
1448	return (init_Feature = __esmMin((() => {
1449		Feature = class {
1450			constructor(node) {
1451				this.isMounted = false;
1452				this.node = node;
1453			}
1454			update() {}
1455		};
1456	})))();
1457}
1458//#endregion
1459//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/html/utils/render.mjs
1460function renderHTML(element, { style, vars }, styleProp, projection) {
1461	const elementStyle = element.style;
1462	let key;
1463	for (key in style) elementStyle[key] = style[key];
1464	projection?.applyProjectionStyles(elementStyle, styleProp);
1465	for (key in vars) elementStyle.setProperty(key, vars[key]);
1466}
1467//#endregion
1468//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/styles/scale-border-radius.mjs
1469function pixelsToPercent(pixels, axis) {
1470	if (axis.max === axis.min) return 0;
1471	return pixels / (axis.max - axis.min) * 100;
1472}
1473var correctBorderRadius;
1474function init_scale_border_radius() {
1475	return (init_scale_border_radius = __esmMin((() => {
1476		init_units();
1477		correctBorderRadius = { correct: (latest, node) => {
1478			if (!node.target) return latest;
1479			/**
1480			* If latest is a string, if it's a percentage we can return immediately as it's
1481			* going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.
1482			*/
1483			if (typeof latest === "string") {
1484				if (px.test(latest)) latest = parseFloat(latest);
1485				else return latest;
1486			}
1487			return `${pixelsToPercent(latest, node.target.x)}% ${pixelsToPercent(latest, node.target.y)}%`;
1488		} };
1489	})))();
1490}
1491//#endregion
1492//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/styles/scale-box-shadow.mjs
1493var correctBoxShadow;
1494function init_scale_box_shadow() {
1495	return (init_scale_box_shadow = __esmMin((() => {
1496		init_complex();
1497		init_number();
1498		correctBoxShadow = { correct: (latest, { treeScale, projectionDelta }) => {
1499			const original = latest;
1500			const shadow = complex.parse(latest);
1501			if (shadow.length > 5) return original;
1502			const template = complex.createTransformer(latest);
1503			const offset = typeof shadow[0] !== "number" ? 1 : 0;
1504			const xScale = projectionDelta.x.scale * treeScale.x;
1505			const yScale = projectionDelta.y.scale * treeScale.y;
1506			shadow[0 + offset] /= xScale;
1507			shadow[1 + offset] /= yScale;
1508			/**
1509			* Ideally we'd correct x and y scales individually, but because blur and
1510			* spread apply to both we have to take a scale average and apply that instead.
1511			* We could potentially improve the outcome of this by incorporating the ratio between
1512			* the two scales.
1513			*/
1514			const averageScale = mixNumber(xScale, yScale, .5);
1515			if (typeof shadow[2 + offset] === "number") shadow[2 + offset] /= averageScale;
1516			if (typeof shadow[3 + offset] === "number") shadow[3 + offset] /= averageScale;
1517			return template(shadow);
1518		} };
1519	})))();
1520}
1521//#endregion
1522//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/styles/scale-correction.mjs
1523var scaleCorrectors;
1524function init_scale_correction() {
1525	return (init_scale_correction = __esmMin((() => {
1526		init_border_radius();
1527		init_scale_border_radius();
1528		init_scale_box_shadow();
1529		scaleCorrectors = {
1530			borderRadius: {
1531				...correctBorderRadius,
1532				applyTo: [...cornerRadiusProps]
1533			},
1534			borderTopLeftRadius: correctBorderRadius,
1535			borderTopRightRadius: correctBorderRadius,
1536			borderBottomLeftRadius: correctBorderRadius,
1537			borderBottomRightRadius: correctBorderRadius,
1538			boxShadow: correctBoxShadow
1539		};
1540	})))();
1541}
1542//#endregion
1543//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/is-forced-motion-value.mjs
1544function isForcedMotionValue(key, { layout, layoutId }) {
1545	return transformProps.has(key) || key.startsWith("origin") || (layout || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
1546}
1547function init_is_forced_motion_value() {
1548	return (init_is_forced_motion_value = __esmMin((() => {
1549		init_keys_transform();
1550		init_scale_correction();
1551	})))();
1552}
1553//#endregion
1554//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/html/utils/scrape-motion-values.mjs
1555function scrapeMotionValuesFromProps$1(props, prevProps, visualElement) {
1556	const style = props.style;
1557	const prevStyle = prevProps?.style;
1558	const newValues = {};
1559	if (!style) return newValues;
1560	for (const key in style) if (isMotionValue(style[key]) || prevStyle && isMotionValue(prevStyle[key]) || isForcedMotionValue(key, props) || visualElement?.getValue(key)?.liveStyle !== void 0) newValues[key] = style[key];
1561	return newValues;
1562}
1563function init_scrape_motion_values() {
1564	return (init_scrape_motion_values = __esmMin((() => {
1565		init_is_motion_value();
1566		init_is_forced_motion_value();
1567	})))();
1568}
1569//#endregion
1570//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/html/HTMLVisualElement.mjs
1571function getComputedStyle$1(element) {
1572	return window.getComputedStyle(element);
1573}
1574var HTMLVisualElement;
1575function init_HTMLVisualElement() {
1576	return (init_HTMLVisualElement = __esmMin((() => {
1577		init_errors();
1578		init_is_css_variable();
1579		init_keys_transform();
1580		init_parse_transform();
1581		init_measure();
1582		init_DOMVisualElement();
1583		init_build_styles();
1584		init_scrape_motion_values();
1585		HTMLVisualElement = class extends DOMVisualElement {
1586			constructor() {
1587				super(...arguments);
1588				this.type = "html";
1589				this.renderInstance = renderHTML;
1590			}
1591			mount(instance) {
1592				/**
1593				* If a custom component forwards its ref to something other than a
1594				* HTML/SVG element (a class instance, an imperative handle) there's
1595				* nothing for Motion to style, measure or attach gestures to. #2777
1596				*/
1597				invariant(Boolean(instance.style), "motion.create() components must forward their ref to a HTML or SVG element", "custom-component-ref");
1598				super.mount(instance);
1599			}
1600			readValueFromInstance(instance, key) {
1601				if (transformProps.has(key)) return this.projection?.isProjecting ? defaultTransformValue(key) : readTransformValue(instance, key);
1602				else {
1603					const computedStyle = getComputedStyle$1(instance);
1604					const value = (isCSSVariableName(key) ? computedStyle.getPropertyValue(key) : computedStyle[key]) || 0;
1605					return typeof value === "string" ? value.trim() : value;
1606				}
1607			}
1608			measureInstanceViewportBox(instance, { transformPagePoint }) {
1609				return measureViewportBox(instance, transformPagePoint);
1610			}
1611			build(renderState, latestValues, props) {
1612				buildHTMLStyles(renderState, latestValues, props.transformTemplate);
1613			}
1614			scrapeMotionValuesFromProps(props, prevProps, visualElement) {
1615				return scrapeMotionValuesFromProps$1(props, prevProps, visualElement);
1616			}
1617		};
1618	})))();
1619}
1620//#endregion
1621//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/svg/utils/camel-case-attrs.mjs

1622var camelCaseAttributes;
1623function init_camel_case_attrs() {
1624	return (init_camel_case_attrs = __esmMin((() => {
1625		camelCaseAttributes = /* @__PURE__ */ new Set([
1626			"baseFrequency",
1627			"diffuseConstant",
1628			"kernelMatrix",
1629			"kernelUnitLength",
1630			"keySplines",
1631			"keyTimes",
1632			"limitingConeAngle",
1633			"markerHeight",
1634			"markerWidth",
1635			"numOctaves",
1636			"targetX",
1637			"targetY",
1638			"surfaceScale",
1639			"specularConstant",
1640			"specularExponent",
1641			"stdDeviation",
1642			"tableValues",
1643			"viewBox",
1644			"gradientTransform",
1645			"pathLength",
1646			"startOffset",
1647			"textLength",
1648			"lengthAdjust"
1649		]);
1650	})))();
1651}
1652//#endregion
1653//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/svg/utils/is-svg-tag.mjs
1654var isSVGTag;
1655function init_is_svg_tag() {
1656	return (init_is_svg_tag = __esmMin((() => {
1657		isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";
1658	})))();
1659}
1660//#endregion
1661//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/svg/utils/render.mjs

1662function renderSVG(element, renderState, _styleProp, projection) {
1663	renderHTML(element, renderState, void 0, projection);
1664	for (const key in renderState.attrs) element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
1665}
1666function init_render$1() {
1667	return (init_render$1 = __esmMin((() => {
1668		init_camel_case_attrs();
1669	})))();
1670}
1671//#endregion
1672//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/svg/utils/scrape-motion-values.mjs
1673function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
1674	const newValues = scrapeMotionValuesFromProps$1(props, prevProps, visualElement);
1675	for (const key in props) if (isMotionValue(props[key]) || isMotionValue(prevProps[key])) {
1676		const targetKey = transformPropOrder.indexOf(key) !== -1 ? "attr" + key.charAt(0).toUpperCase() + key.substring(1) : key;
1677		newValues[targetKey] = props[key];
1678	}
1679	return newValues;
1680}
1681function init_scrape_motion_values$1() {
1682	return (init_scrape_motion_values$1 = __esmMin((() => {
1683		init_is_motion_value();
1684		init_keys_transform();
1685		init_scrape_motion_values();
1686	})))();
1687}
1688//#endregion
1689//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/svg/SVGVisualElement.mjs
1690var SVGVisualElement;
1691function init_SVGVisualElement() {
1692	return (init_SVGVisualElement = __esmMin((() => {
1693		init_keys_transform();
1694		init_defaults();
1695		init_models();
1696		init_DOMVisualElement();
1697		init_build_attrs();
1698		init_camel_case_attrs();
1699		init_is_svg_tag();
1700		init_render$1();
1701		init_scrape_motion_values$1();
1702		SVGVisualElement = class extends DOMVisualElement {
1703			constructor() {
1704				super(...arguments);
1705				this.type = "svg";
1706				this.isSVGTag = false;
1707				this.measureInstanceViewportBox = createBox;
1708			}
1709			getBaseTargetFromProps(props, key) {
1710				return props[key];
1711			}
1712			readValueFromInstance(instance, key) {
1713				if (transformProps.has(key)) {
1714					const defaultType = getDefaultValueType(key);
1715					return defaultType ? defaultType.default || 0 : 0;
1716				}
1717				if (cssStyleProperties.includes(key)) {
1718					const value = getComputedStyle(instance)[key];
1719					if (typeof value === "string" && value) return value.trim();
1720				}
1721				key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
1722				return instance.getAttribute(key);
1723			}
1724			scrapeMotionValuesFromProps(props, prevProps, visualElement) {
1725				return scrapeMotionValuesFromProps(props, prevProps, visualElement);
1726			}
1727			build(renderState, latestValues, props) {
1728				buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate, props.style);
1729			}
1730			renderInstance(instance, renderState, styleProp, projection) {
1731				renderSVG(instance, renderState, styleProp, projection);
1732			}
1733			mount(instance) {
1734				this.isSVGTag = isSVGTag(instance.tagName);
1735				super.mount(instance);
1736			}
1737		};
1738	})))();
1739}
1740//#endregion
1741//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/get-variant-context.mjs
1742/**
1743* Get variant context from a visual element's parent chain.
1744* Uses `any` type for visualElement to avoid circular dependencies.
1745*/
1746function getVariantContext(visualElement) {
1747	if (!visualElement) return void 0;
1748	if (!visualElement.isControllingVariants) {
1749		const context = visualElement.parent ? getVariantContext(visualElement.parent) || {} : {};
1750		if (visualElement.props.initial !== void 0) context.initial = visualElement.props.initial;
1751		return context;
1752	}
1753	const context = {};
1754	for (let i = 0; i < numVariantProps; i++) {
1755		const name = variantProps[i];
1756		const prop = visualElement.props[name];
1757		if (isVariantLabel(prop) || prop === false) context[name] = prop;
1758	}
1759	return context;
1760}
1761var numVariantProps;
1762function init_get_variant_context() {
1763	return (init_get_variant_context = __esmMin((() => {
1764		init_variant_props();
1765		numVariantProps = variantProps.length;
1766	})))();
1767}
1768//#endregion
1769//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/shallow-compare.mjs
1770function shallowCompare(next, prev) {
1771	if (!Array.isArray(prev)) return false;
1772	const prevLength = prev.length;
1773	if (prevLength !== next.length) return false;

1774	for (let i = 0; i < prevLength; i++) if (prev[i] !== next[i]) return false;
1775	return true;
1776}
1777//#endregion
1778//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/render/utils/animation-state.mjs
1779function createAnimateFunction(visualElement) {
1780	return (animations) => {
1781		return Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
1782	};
1783}
1784function createAnimationState(visualElement) {
1785	let animate = createAnimateFunction(visualElement);
1786	let state = createState();
1787	let isInitialRender = true;
1788	/**
1789	* Track whether the animation state has been reset (e.g. via StrictMode
1790	* double-invocation or Suspense unmount/remount). On the first
1791	* animateChanges() call after a reset we need to behave like the initial
1792	* render for variant-inheritance checks, even though isInitialRender is
1793	* already false.
1794	*/
1795	let wasReset = false;
1796	/**
1797	* This function will be used to reduce the animation definitions for
1798	* each active animation type into an object of resolved values for it.
1799	*/
1800	const buildResolvedTypeValues = (type) => (acc, definition) => {
1801		const resolved = resolveVariant(visualElement, definition, type === "exit" ? visualElement.presenceContext?.custom : void 0);
1802		if (resolved) {
1803			const { transition, transitionEnd, ...target } = resolved;
1804			acc = {
1805				...acc,
1806				...target,
1807				...transitionEnd
1808			};
1809		}
1810		return acc;
1811	};
1812	/**
1813	* This just allows us to inject mocked animation functions
1814	* @internal
1815	*/
1816	function setAnimateFunction(makeAnimator) {
1817		animate = makeAnimator(visualElement);
1818	}
1819	/**
1820	* When we receive new props, we need to:
1821	* 1. Create a list of protected keys for each type. This is a directory of
1822	*    value keys that are currently being "handled" by types of a higher priority
1823	*    so that whenever an animation is played of a given type, these values are
1824	*    protected from being animated.
1825	* 2. Determine if an animation type needs animating.
1826	* 3. Determine if any values have been removed from a type and figure out
1827	*    what to animate those to.
1828	*/
1829	function animateChanges(changedActiveType) {
1830		const { props } = visualElement;
1831		const context = getVariantContext(visualElement.parent) || {};
1832		/**
1833		* A list of animations that we'll build into as we iterate through the animation
1834		* types. This will get executed at the end of the function.
1835		*/
1836		const animations = [];
1837		/**
1838		* Keep track of which values have been removed. Then, as we hit lower priority
1839		* animation types, we can check if they contain removed values and animate to that.
1840		*/
1841		const removedKeys = /* @__PURE__ */ new Set();
1842		/**
1843		* A dictionary of all encountered keys. This is an object to let us build into and
1844		* copy it without iteration. Each time we hit an animation type we set its protected
1845		* keys - the keys its not allowed to animate - to the latest version of this object.
1846		*/
1847		let encounteredKeys = {};
1848		/**
1849		* If a variant has been removed at a given index, and this component is controlling
1850		* variant animations, we want to ensure lower-priority variants are forced to animate.
1851		*/
1852		let removedVariantIndex = Infinity;
1853		/**
1854		* Iterate through all animation types in reverse priority order. For each, we want to
1855		* detect which values it's handling and whether or not they've changed (and therefore
1856		* need to be animated). If any values have been removed, we want to detect those in
1857		* lower priority props and flag for animation.
1858		*/
1859		for (let i = 0; i < numAnimationTypes; i++) {
1860			const type = reversePriorityOrder[i];
1861			const typeState = state[type];
1862			const prop = props[type] !== void 0 ? props[type] : context[type];
1863			const propIsVariant = isVariantLabel(prop);
1864			/**
1865			* If this type has *just* changed isActive status, set activeDelta
1866			* to that status. Otherwise set to null.
1867			*/
1868			const activeDelta = type === changedActiveType ? typeState.isActive : null;
1869			if (activeDelta === false) removedVariantIndex = i;
1870			/**
1871			* If this prop is an inherited variant, rather than been set directly on the
1872			* component itself, we want to make sure we allow the parent to trigger animations.
1873			*
1874			* TODO: Can probably change this to a !isControllingVariants check
1875			*/
1876			let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;
1877			if (isInherited && (isInitialRender || wasReset) && visualElement.manuallyAnimateOnMount) isInherited = false;

1878			/**
1879			* Set all encountered keys so far as the protected keys for this type. This will
1880			* be any key that has been animated or otherwise handled by active, higher-priortiy types.
1881			*/
1882			typeState.protectedKeys = { ...encounteredKeys };
1883			if (!typeState.isActive && activeDelta === null || !prop && !typeState.prevProp || isAnimationControls(prop) || typeof prop === "boolean") continue;
1884			/**
1885			* If exit is already active and wasn't just activated, skip
1886			* re-processing to prevent interrupting running exit animations.
1887			* Re-resolving exit with a changed custom value can start new
1888			* value animations that stop the originals, leaving the exit
1889			* animation promise unresolved and the component stuck in the DOM.
1890			*/
1891			if (type === "exit" && typeState.isActive && activeDelta !== true) {
1892				if (typeState.prevResolvedValues) encounteredKeys = {
1893					...encounteredKeys,
1894					...typeState.prevResolvedValues
1895				};
1896				continue;
1897			}
1898			/**
1899			* As we go look through the values defined on this type, if we detect
1900			* a changed value or a value that was removed in a higher priority, we set
1901			* this to true and add this prop to the animation list.
1902			*/
1903			const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
1904			let shouldAnimateType = variantDidChange || type === changedActiveType && typeState.isActive && !isInherited && propIsVariant || i > removedVariantIndex && propIsVariant;
1905			let handledRemovedValues = false;
1906			/**
1907			* As animations can be set as variant lists, variants or target objects, we
1908			* coerce everything to an array if it isn't one already
1909			*/
1910			const definitionList = Array.isArray(prop) ? prop : [prop];
1911			/**
1912			* Build an object of all the resolved values. We'll use this in the subsequent
1913			* animateChanges calls to determine whether a value has changed.
1914			*/
1915			let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
1916			if (activeDelta === false) resolvedValues = {};
1917			/**
1918			* Now we need to loop through all the keys in the prev prop and this prop,
1919			* and decide:
1920			* 1. If the value has changed, and needs animating
1921			* 2. If it has been removed, and needs adding to the removedKeys set
1922			* 3. If it has been removed in a higher priority type and needs animating
1923			* 4. If it hasn't been removed in a higher priority but hasn't changed, and
1924			*    needs adding to the type's protectedKeys list.
1925			*/
1926			const { prevResolvedValues = {} } = typeState;
1927			const allKeys = {
1928				...prevResolvedValues,
1929				...resolvedValues
1930			};
1931			const markToAnimate = (key) => {
1932				shouldAnimateType = true;
1933				if (removedKeys.has(key)) {
1934					handledRemovedValues = true;
1935					removedKeys.delete(key);
1936				}
1937				typeState.needsAnimating[key] = true;
1938				const motionValue = visualElement.getValue(key);
1939				if (motionValue) motionValue.liveStyle = false;
1940			};
1941			for (const key in allKeys) {
1942				const next = resolvedValues[key];
1943				const prev = prevResolvedValues[key];
1944				if (encounteredKeys.hasOwnProperty(key)) continue;
1945				/**
1946				* If the value has changed, we probably want to animate it.
1947				*/
1948				let valueHasChanged = false;
1949				if (isKeyframesTarget(next) && isKeyframesTarget(prev)) valueHasChanged = !shallowCompare(next, prev) || variantDidChange;
1950				else valueHasChanged = next !== prev;
1951				if (valueHasChanged) {
1952					if (next !== void 0 && next !== null) markToAnimate(key);
1953					else removedKeys.add(key);
1954				} else if (next !== void 0 && removedKeys.has(key))
1955 /**
1956				* If next hasn't changed and it isn't undefined, we want to check if it's
1957				* been removed by a higher priority
1958				*/
1959				markToAnimate(key);
1960				else
1961 /**
1962				* If it hasn't changed, we add it to the list of protected values
1963				* to ensure it doesn't get animated.
1964				*/
1965				typeState.protectedKeys[key] = true;
1966			}
1967			/**
1968			* Update the typeState so next time animateChanges is called we can compare the
1969			* latest prop and resolvedValues to these.
1970			*/
1971			typeState.prevProp = prop;
1972			typeState.prevResolvedValues = resolvedValues;
1973			if (typeState.isActive) encounteredKeys = {
1974				...encounteredKeys,
1975				...resolvedValues
1976			};
1977			if ((isInitialRender || wasReset) && visualElement.blockInitialAnimation) shouldAnimateType = false;

1978			/**
1979			* If this is an inherited prop we want to skip this animation
1980			* unless the inherited variants haven't changed on this render.
1981			*/
1982			const willAnimateViaParent = isInherited && variantDidChange;
1983			if (shouldAnimateType && (!willAnimateViaParent || handledRemovedValues)) animations.push(...definitionList.map((animation) => {
1984				const options = { type };
1985				/**
1986				* If we're performing the initial animation, but we're not
1987				* rendering at the same time as the variant-controlling parent,
1988				* we want to use the parent's transition to calculate the stagger.
1989				*/
1990				if (typeof animation === "string" && (isInitialRender || wasReset) && !willAnimateViaParent && visualElement.manuallyAnimateOnMount && visualElement.parent) {
1991					const { parent } = visualElement;
1992					const parentVariant = resolveVariant(parent, animation);
1993					if (parent.enteringChildren && parentVariant) {
1994						const { delayChildren } = parentVariant.transition || {};
1995						options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);
1996					}
1997				}
1998				return {
1999					animation,
2000					options
2001				};
2002			}));
2003		}
2004		/**
2005		* If there are some removed value that haven't been dealt with,
2006		* we need to create a new animation that falls back either to the value
2007		* defined in the style prop, or the last read value.
2008		*/
2009		if (removedKeys.size) {
2010			const fallbackAnimation = {};
2011			/**
2012			* If the initial prop contains a transition we can use that, otherwise
2013			* allow the animation function to use the visual element's default.
2014			*/
2015			if (typeof props.initial !== "boolean") {
2016				const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial) ? props.initial[0] : props.initial);
2017				if (initialTransition && initialTransition.transition) fallbackAnimation.transition = initialTransition.transition;
2018			}
2019			removedKeys.forEach((key) => {
2020				const fallbackTarget = visualElement.getBaseTarget(key);
2021				const motionValue = visualElement.getValue(key);
2022				if (motionValue) motionValue.liveStyle = true;
2023				fallbackAnimation[key] = fallbackTarget ?? null;
2024			});
2025			animations.push({ animation: fallbackAnimation });
2026		}
2027		let shouldAnimate = Boolean(animations.length);
2028		if (isInitialRender && (props.initial === false || props.initial === props.animate) && !visualElement.manuallyAnimateOnMount) shouldAnimate = false;
2029		isInitialRender = false;

2030		wasReset = false;
2031		return shouldAnimate ? animate(animations) : Promise.resolve();
2032	}
2033	/**
2034	* Change whether a certain animation type is active.
2035	*/
2036	function setActive(type, isActive) {
2037		if (state[type].isActive === isActive) return Promise.resolve();
2038		visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));
2039		state[type].isActive = isActive;
2040		const animations = animateChanges(type);
2041		for (const key in state) state[key].protectedKeys = {};
2042		return animations;
2043	}
2044	return {
2045		animateChanges,
2046		setActive,
2047		setAnimateFunction,
2048		getState: () => state,
2049		reset: () => {
2050			state = createState();
2051			wasReset = true;
2052		}
2053	};
2054}
2055function checkVariantsDidChange(prev, next) {
2056	if (typeof next === "string") return next !== prev;
2057	else if (Array.isArray(next)) return !shallowCompare(next, prev);
2058	return false;
2059}
2060function createTypeState(isActive = false) {
2061	return {
2062		isActive,
2063		protectedKeys: {},
2064		needsAnimating: {},
2065		prevResolvedValues: {}
2066	};
2067}
2068function createState() {
2069	return {
2070		animate: createTypeState(true),
2071		whileInView: createTypeState(),
2072		whileHover: createTypeState(),
2073		whileTap: createTypeState(),
2074		whileDrag: createTypeState(),
2075		whileFocus: createTypeState(),
2076		exit: createTypeState()
2077	};
2078}
2079var reversePriorityOrder, numAnimationTypes;
2080function init_animation_state() {
2081	return (init_animation_state = __esmMin((() => {
2082		init_visual_element();
2083		init_get_variant_context();
2084		init_is_keyframes_target();
2085		init_resolve_dynamic_variants();
2086		init_variant_props();
2087		reversePriorityOrder = [...variantPriorityOrder].reverse();
2088		numAnimationTypes = variantPriorityOrder.length;
2089	})))();
2090}
2091//#endregion
2092//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/geometry/copy.mjs
2093/**
2094* Reset an axis to the provided origin box.
2095*
2096* This is a mutative operation.
2097*/
2098function copyAxisInto(axis, originAxis) {
2099	axis.min = originAxis.min;
2100	axis.max = originAxis.max;
2101}
2102/**
2103* Reset a box to the provided origin box.
2104*
2105* This is a mutative operation.
2106*/
2107function copyBoxInto(box, originBox) {
2108	copyAxisInto(box.x, originBox.x);
2109	copyAxisInto(box.y, originBox.y);
2110}
2111/**
2112* Reset a delta to the provided origin box.
2113*
2114* This is a mutative operation.
2115*/
2116function copyAxisDeltaInto(delta, originDelta) {
2117	delta.translate = originDelta.translate;
2118	delta.scale = originDelta.scale;
2119	delta.originPoint = originDelta.originPoint;
2120	delta.origin = originDelta.origin;
2121}
2122//#endregion
2123//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/geometry/delta-calc.mjs
2124function calcLength(axis) {
2125	return axis.max - axis.min;
2126}
2127function isNear(value, target, maxDistance) {
2128	return Math.abs(value - target) <= maxDistance;
2129}
2130function calcAxisDelta(delta, source, target, origin = .5) {
2131	delta.origin = origin;
2132	delta.originPoint = mixNumber(source.min, source.max, delta.origin);
2133	delta.scale = calcLength(target) / calcLength(source);
2134	delta.translate = mixNumber(target.min, target.max, delta.origin) - delta.originPoint;
2135	if (delta.scale >= SCALE_MIN && delta.scale <= SCALE_MAX || isNaN(delta.scale)) delta.scale = 1;
2136	if (delta.translate >= TRANSLATE_MIN && delta.translate <= TRANSLATE_MAX || isNaN(delta.translate)) delta.translate = 0;
2137}
2138function calcBoxDelta(delta, source, target, origin) {
2139	calcAxisDelta(delta.x, source.x, target.x, origin ? origin.originX : void 0);
2140	calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : void 0);
2141}
2142function calcRelativeAxis(target, relative, parent, anchor = 0) {
2143	target.min = (anchor ? mixNumber(parent.min, parent.max, anchor) : parent.min) + relative.min;
2144	target.max = target.min + calcLength(relative);
2145}
2146function calcRelativeBox(target, relative, parent, anchor) {
2147	calcRelativeAxis(target.x, relative.x, parent.x, anchor?.x);
2148	calcRelativeAxis(target.y, relative.y, parent.y, anchor?.y);
2149}
2150function calcRelativeAxisPosition(target, layout, parent, anchor = 0) {
2151	const anchorPoint = anchor ? mixNumber(parent.min, parent.max, anchor) : parent.min;
2152	target.min = layout.min - anchorPoint;
2153	target.max = target.min + calcLength(layout);
2154}

2155function calcRelativePosition(target, layout, parent, anchor) {
2156	calcRelativeAxisPosition(target.x, layout.x, parent.x, anchor?.x);
2157	calcRelativeAxisPosition(target.y, layout.y, parent.y, anchor?.y);
2158}
2159var SCALE_MIN, SCALE_MAX, TRANSLATE_MIN, TRANSLATE_MAX;
2160function init_delta_calc() {
2161	return (init_delta_calc = __esmMin((() => {
2162		init_number();
2163		SCALE_MIN = .9999;
2164		SCALE_MAX = 1.0001;
2165		TRANSLATE_MIN = -.01;
2166		TRANSLATE_MAX = .01;
2167	})))();
2168}
2169//#endregion
2170//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/geometry/delta-remove.mjs
2171/**
2172* Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse
2173*/
2174function removePointDelta(point, translate, scale, originPoint, boxScale) {
2175	point -= translate;
2176	point = scalePoint(point, 1 / scale, originPoint);
2177	if (boxScale !== void 0) point = scalePoint(point, 1 / boxScale, originPoint);
2178	return point;
2179}
2180/**
2181* Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse
2182*/
2183function removeAxisDelta(axis, translate = 0, scale = 1, origin = .5, boxScale, originAxis = axis, sourceAxis = axis) {
2184	if (percent.test(translate)) {
2185		translate = parseFloat(translate);
2186		translate = mixNumber(sourceAxis.min, sourceAxis.max, translate / 100) - sourceAxis.min;
2187	}
2188	if (typeof translate !== "number") return;
2189	let originPoint = mixNumber(originAxis.min, originAxis.max, origin);
2190	if (axis === originAxis) originPoint -= translate;
2191	axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);
2192	axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);
2193}
2194/**
2195* Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse
2196* and acts as a bridge between motion values and removeAxisDelta
2197*/
2198function removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {
2199	removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);
2200}
2201/**
2202* Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse
2203* and acts as a bridge between motion values and removeAxisDelta
2204*/
2205function removeBoxTransforms(box, transforms, originBox, sourceBox) {
2206	removeAxisTransforms(box.x, transforms, xKeys, originBox ? originBox.x : void 0, sourceBox ? sourceBox.x : void 0);
2207	removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : void 0, sourceBox ? sourceBox.y : void 0);
2208}
2209var xKeys, yKeys;
2210function init_delta_remove() {
2211	return (init_delta_remove = __esmMin((() => {
2212		init_number();
2213		init_units();
2214		init_delta_apply();
2215		xKeys = [
2216			"x",
2217			"scaleX",
2218			"originX"
2219		];
2220		yKeys = [
2221			"y",
2222			"scaleY",
2223			"originY"
2224		];
2225	})))();
2226}
2227//#endregion
2228//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/geometry/utils.mjs
2229function isAxisDeltaZero(delta) {
2230	return delta.translate === 0 && delta.scale === 1;
2231}
2232function isDeltaZero(delta) {
2233	return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);
2234}
2235function axisEquals(a, b) {
2236	return a.min === b.min && a.max === b.max;
2237}
2238function boxEquals(a, b) {
2239	return axisEquals(a.x, b.x) && axisEquals(a.y, b.y);
2240}
2241function axisEqualsRounded(a, b) {
2242	return Math.round(a.min) === Math.round(b.min) && Math.round(a.max) === Math.round(b.max);
2243}
2244function boxEqualsRounded(a, b) {
2245	return axisEqualsRounded(a.x, b.x) && axisEqualsRounded(a.y, b.y);
2246}
2247function aspectRatio(box) {
2248	return calcLength(box.x) / calcLength(box.y);
2249}
2250function axisDeltaEquals(a, b) {
2251	return a.translate === b.translate && a.scale === b.scale && a.originPoint === b.originPoint;
2252}
2253function init_utils() {
2254	return (init_utils = __esmMin((() => {
2255		init_delta_calc();
2256	})))();
2257}
2258//#endregion
2259//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/utils/each-axis.mjs
2260function eachAxis(callback) {
2261	return [callback("x"), callback("y")];
2262}
2263//#endregion
2264//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/styles/transform.mjs
2265function buildProjectionTransform(delta, treeScale, latestTransform) {
2266	let transform = "";
2267	/**
2268	* The translations we use to calculate are always relative to the viewport coordinate space.
2269	* But when we apply scales, we also scale the coordinate space of an element and its children.
2270	* For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need
2271	* to move an element 100 pixels, we actually need to move it 200 in within that scaled space.
2272	*/
2273	const xTranslate = delta.x.translate / treeScale.x;
2274	const yTranslate = delta.y.translate / treeScale.y;
2275	const zTranslate = latestTransform?.z || 0;
2276	if (xTranslate || yTranslate || zTranslate) transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;
2277	/**
2278	* Apply scale correction for the tree transform.
2279	* This will apply scale to the screen-orientated axes.
2280	*/
2281	if (treeScale.x !== 1 || treeScale.y !== 1) transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
2282	if (latestTransform) {
2283		const { transformPerspective, rotate, pathRotation, rotateX, rotateY, skewX, skewY } = latestTransform;
2284		if (transformPerspective) transform = `perspective(${transformPerspective}px) ${transform}`;
2285		if (rotate) transform += `rotate(${rotate}deg) `;
2286		if (pathRotation) transform += `rotate(${pathRotation}deg) `;
2287		if (rotateX) transform += `rotateX(${rotateX}deg) `;
2288		if (rotateY) transform += `rotateY(${rotateY}deg) `;

2289		if (skewX) transform += `skewX(${skewX}deg) `;
2290		if (skewY) transform += `skewY(${skewY}deg) `;
2291	}
2292	/**
2293	* Apply scale to match the size of the element to the size we want it.
2294	* This will apply scale to the element-orientated axes.
2295	*/
2296	const elementScaleX = delta.x.scale * treeScale.x;
2297	const elementScaleY = delta.y.scale * treeScale.y;
2298	if (elementScaleX !== 1 || elementScaleY !== 1) transform += `scale(${elementScaleX}, ${elementScaleY})`;
2299	return transform || "none";
2300}
2301//#endregion
2302//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/animation/mix-values.mjs
2303function mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {
2304	if (shouldCrossfadeOpacity) {
2305		target.opacity = mixNumber(0, lead.opacity ?? 1, easeCrossfadeIn(progress));
2306		target.opacityExit = mixNumber(follow.opacity ?? 1, 0, easeCrossfadeOut(progress));
2307	} else if (isOnlyMember) target.opacity = mixNumber(follow.opacity ?? 1, lead.opacity ?? 1, progress);
2308	/**
2309	* Mix border radius
2310	*/
2311	for (let i = 0; i < numBorders; i++) {
2312		const borderLabel = cornerRadiusProps[i];
2313		let followRadius = getRadius(follow, borderLabel);
2314		let leadRadius = getRadius(lead, borderLabel);
2315		if (followRadius === void 0 && leadRadius === void 0) continue;
2316		followRadius || (followRadius = 0);
2317		leadRadius || (leadRadius = 0);
2318		if (followRadius === 0 || leadRadius === 0 || isPx(followRadius) === isPx(leadRadius)) {
2319			target[borderLabel] = Math.max(mixNumber(asNumber(followRadius), asNumber(leadRadius), progress), 0);
2320			if (percent.test(leadRadius) || percent.test(followRadius)) target[borderLabel] += "%";
2321		} else target[borderLabel] = leadRadius;
2322	}
2323	/**
2324	* Mix rotation
2325	*/
2326	if (follow.rotate || lead.rotate) target.rotate = mixNumber(follow.rotate || 0, lead.rotate || 0, progress);
2327}
2328function getRadius(values, radiusName) {
2329	return values[radiusName] !== void 0 ? values[radiusName] : values.borderRadius;
2330}
2331function compress(min, max, easing) {
2332	return (p) => {
2333		if (p < min) return 0;
2334		if (p > max) return 1;
2335		return easing(progress(min, max, p));
2336	};
2337}
2338var numBorders, asNumber, isPx, easeCrossfadeIn, easeCrossfadeOut;
2339function init_mix_values() {
2340	return (init_mix_values = __esmMin((() => {
2341		init_number();
2342		init_units();
2343		init_progress(), init_circ(), init_noop();
2344		init_border_radius();
2345		numBorders = cornerRadiusProps.length;
2346		asNumber = (value) => typeof value === "string" ? parseFloat(value) : value;
2347		isPx = (value) => typeof value === "number" || px.test(value);
2348		easeCrossfadeIn = /*@__PURE__*/ compress(0, .5, circOut);
2349		easeCrossfadeOut = /*@__PURE__*/ compress(.5, .95, noop);
2350	})))();
2351}
2352//#endregion
2353//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/events/add-dom-event.mjs
2354function addDomEvent(target, eventName, handler, options = { passive: true }) {
2355	target.addEventListener(eventName, handler, options);
2356	return () => target.removeEventListener(eventName, handler, options);
2357}
2358//#endregion
2359//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/utils/compare-by-depth.mjs
2360var compareByDepth;
2361function init_compare_by_depth() {
2362	return (init_compare_by_depth = __esmMin((() => {
2363		compareByDepth = (a, b) => a.depth - b.depth;
2364	})))();
2365}
2366//#endregion
2367//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/utils/flat-tree.mjs
2368var FlatTree;
2369function init_flat_tree() {
2370	return (init_flat_tree = __esmMin((() => {
2371		init_compare_by_depth();
2372		FlatTree = class {
2373			constructor() {
2374				this.children = [];
2375				this.isDirty = false;
2376			}
2377			add(child) {
2378				addUniqueItem(this.children, child);
2379				this.isDirty = true;
2380			}
2381			remove(child) {
2382				removeItem(this.children, child);
2383				this.isDirty = true;
2384			}
2385			forEach(callback) {
2386				this.isDirty && this.children.sort(compareByDepth);
2387				this.isDirty = false;
2388				this.children.forEach(callback);
2389			}
2390		};
2391	})))();
2392}
2393//#endregion
2394//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/utils/delay.mjs
2395/**
2396* Timeout defined in ms
2397*/
2398function delay(callback, timeout) {
2399	const start = time.now();
2400	const checkElapsed = ({ timestamp }) => {

2401		const elapsed = timestamp - start;
2402		if (elapsed >= timeout) {
2403			cancelFrame(checkElapsed);
2404			callback(elapsed - timeout);
2405		}
2406	};
2407	frame.setup(checkElapsed, true);
2408	return () => cancelFrame(checkElapsed);
2409}
2410function init_delay() {
2411	return (init_delay = __esmMin((() => {
2412		init_sync_time();
2413		init_frame();
2414	})))();
2415}
2416//#endregion
2417//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/value/utils/resolve-motion-value.mjs
2418/**
2419* If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself
2420*/
2421function resolveMotionValue(value) {
2422	return isMotionValue(value) ? value.get() : value;
2423}
2424function init_resolve_motion_value() {
2425	return (init_resolve_motion_value = __esmMin((() => {
2426		init_is_motion_value();
2427	})))();
2428}
2429//#endregion
2430//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/shared/stack.mjs
2431var NodeStack;
2432function init_stack() {
2433	return (init_stack = __esmMin((() => {
2434		NodeStack = class {
2435			constructor() {
2436				this.members = [];
2437			}
2438			add(node) {
2439				addUniqueItem(this.members, node);
2440				for (let i = this.members.length - 1; i >= 0; i--) {
2441					const member = this.members[i];
2442					if (member === node || member === this.lead || member === this.prevLead) continue;
2443					const inst = member.instance;
2444					if ((!inst || inst.isConnected === false) && !member.snapshot) {
2445						removeItem(this.members, member);
2446						member.unmount();
2447					}
2448				}
2449				node.scheduleRender();
2450			}
2451			remove(node) {
2452				removeItem(this.members, node);
2453				if (node === this.prevLead) this.prevLead = void 0;
2454				if (node === this.lead) {
2455					const prevLead = this.members[this.members.length - 1];
2456					if (prevLead) this.promote(prevLead);
2457				}
2458			}
2459			relegate(node) {
2460				for (let i = this.members.indexOf(node) - 1; i >= 0; i--) {
2461					const member = this.members[i];
2462					if (member.isPresent !== false && member.instance?.isConnected !== false) {
2463						this.promote(member);
2464						return true;
2465					}
2466				}
2467				return false;
2468			}
2469			promote(node, preserveFollowOpacity) {
2470				const prevLead = this.lead;
2471				if (node === prevLead) return;
2472				this.prevLead = prevLead;
2473				this.lead = node;
2474				node.show();
2475				if (prevLead) {
2476					prevLead.updateSnapshot();
2477					node.scheduleRender();
2478					const { layoutDependency: prevDep } = prevLead.options;
2479					const { layoutDependency: nextDep } = node.options;
2480					if (prevDep === void 0 || prevDep !== nextDep) {
2481						node.resumeFrom = prevLead;
2482						if (preserveFollowOpacity) prevLead.preserveOpacity = true;
2483						if (prevLead.snapshot) {
2484							node.snapshot = prevLead.snapshot;
2485							node.snapshot.latestValues = prevLead.animationValues || prevLead.latestValues;
2486						}
2487						if (node.root?.isUpdating) node.isLayoutDirty = true;
2488					}
2489					if (node.options.crossfade === false) prevLead.hide();
2490				}
2491			}
2492			exitAnimationComplete() {
2493				this.members.forEach((member) => {
2494					member.options.onExitComplete?.();
2495					member.resumingFrom?.options.onExitComplete?.();
2496				});
2497			}
2498			scheduleRender() {
2499				this.members.forEach((member) => member.instance && member.scheduleRender(false));
2500			}
2501			removeLeadSnapshot() {
2502				if (this.lead?.snapshot) this.lead.snapshot = void 0;
2503			}
2504		};
2505	})))();
2506}
2507//#endregion
2508//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/node/state.mjs
2509var globalProjectionState;
2510function init_state$2() {
2511	return (init_state$2 = __esmMin((() => {
2512		globalProjectionState = {
2513			/**
2514			* Global flag as to whether the tree has animated since the last time
2515			* we resized the window
2516			*/
2517			hasAnimatedSinceResize: true,
2518			/**
2519			* We set this to true once, on the first update. Any nodes added to the tree beyond that
2520			* update will be given a `data-projection-id` attribute.
2521			*/
2522			hasEverUpdated: false
2523		};
2524	})))();
2525}
2526//#endregion
2527//#region node_modules/.pnpm/[email protected]/node_modules/motion-dom/dist/es/projection/node/create-projection-node.mjs
2528function resetDistortingTransform(key, visualElement, values, sharedAnimationValues) {
2529	const { latestValues } = visualElement;
2530	if (latestValues[key]) {
2531		values[key] = latestValues[key];
2532		visualElement.setStaticValue(key, 0);
2533		if (sharedAnimationValues) sharedAnimationValues[key] = 0;
2534	}
2535}
2536function cancelTreeOptimisedTransformAnimations(projectionNode) {
2537	projectionNode.hasCheckedOptimisedAppear = true;
2538	if (projectionNode.root === projectionNode) return;
2539	const { visualElement } = projectionNode.options;
2540	if (!visualElement) return;
2541	const appearId = getOptimisedAppearId(visualElement);
2542	if (window.MotionHasOptimisedAnimation(appearId, "transform")) {
2543		const { layout, layoutId } = projectionNode.options;
2544		window.MotionCancelOptimisedAnimation(appearId, "transform", frame, !(layout || layoutId));
2545	}
2546	const { parent } = projectionNode;
2547	if (parent && !parent.hasCheckedOptimisedAppear) cancelTreeOptimisedTransformAnimations(parent);
2548}
2549function createProjectionNode$1({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform }) {
2550	return class ProjectionNode {
2551		constructor(latestValues = {}, parent = defaultParent?.()) {
2552			/**
2553			* A unique ID generated for every projection node.
2554			*/
2555			this.id = id$1++;
2556			/**
2557			* An id that represents a unique session instigated by startUpd

2557ate.
2558			*/
2559			this.animationId = 0;
2560			this.animationCommitId = 0;
2561			/**
2562			* A Set containing all this component's children. This is used to iterate
2563			* through the children.
2564			*
2565			* TODO: This could be faster to iterate as a flat array stored on the root node.
2566			*/
2567			this.children = /* @__PURE__ */ new Set();
2568			/**
2569			* Options for the node. We use this to configure what kind of layout animations
2570			* we should perform (if any).
2571			*/
2572			this.options = {};
2573			/**
2574			* We use this to detect when its safe to shut down part of a projection tree.
2575			* We have to keep projecting children for scale correction and relative projection
2576			* until all their parents stop performing layout animations.
2577			*/
2578			this.isTreeAnimating = false;
2579			this.isAnimationBlocked = false;
2580			/**
2581			* Flag to true if we think this layout has been changed. We can't always know this,
2582			* currently we set it to true every time a component renders, or if it has a layoutDependency
2583			* if that has changed between renders. Additionally, components can be grouped by LayoutGroup
2584			* and if one node is dirtied, they all are.
2585			*/
2586			this.isLayoutDirty = false;
2587			/**
2588			* Flag to true if we think the projection calculations for this node needs
2589			* recalculating as a result of an updated transform or layout animation.
2590			*/
2591			this.isProjectionDirty = false;
2592			/**
2593			* Flag to true if the layout *or* transform has changed. This then gets propagated
2594			* throughout the projection tree, forcing any element below to recalculate on the next frame.
2595			*/
2596			this.isSharedProjectionDirty = false;
2597			/**
2598			* Flag transform dirty. This gets propagated throughout the whole tree but is only
2599			* respected by shared nodes.
2600			*/
2601			this.isTransformDirty = false;
2602			/**
2603			* Block layout updates for instant layout transitions throughout the tree.
2604			*/
2605			this.updateManuallyBlocked = false;
2606			this.updateBlockedByResize = false;
2607			/**
2608			* Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`
2609			* call.
2610			*/
2611			this.isUpdating = false;
2612			/**
2613			* If this is an SVG element we currently disable projection transforms
2614			*/
2615			this.isSVG = false;
2616			/**
2617			* Flag to true (during promotion) if a node doing an instant layout transition needs to reset
2618			* its projection styles.
2619			*/
2620			this.needsReset = false;
2621			/**
2622			* Flags whether this node should have its transform reset prior to measuring.
2623			*/
2624			this.shouldResetTransform = false;
2625			/**
2626			* Store whether this node has been checked for optimised appear animations. As
2627			* effects fire bottom-up, and we want to look up the tree for appear animations,
2628			* this makes sure we only check each path once, stopping at nodes that
2629			* have already been checked.
2630			*/
2631			this.hasCheckedOptimisedAppear = false;
2632			/**
2633			* An object representing the calculated contextual/accumulated/tree scale.
2634			* This will be used to scale calculcated projection transforms, as these are
2635			* calculated in screen-space but need to be scaled for elements to layoutly
2636			* make it to their calculated destinations.
2637			*
2638			* TODO: Lazy-init
2639			*/
2640			this.treeScale = {
2641				x: 1,
2642				y: 1
2643			};
2644			/**
2645			*
2646			*/
2647			this.eventHandlers = /* @__PURE__ */ new Map();
2648			this.hasTreeAnimated = false;
2649			this.layoutVersion = 0;
2650			this.updateScheduled = false;
2651			this.scheduleUpdate = () => this.update();
2652			this.projectionUpdateScheduled = false;
2653			this.checkUpdateFailed = () => {
2654				if (this.isUpdating) {
2655					this.isUpdating = false;
2656					this.clearAllSnapshots();
2657				}
2658			};
2659			/**
2660			* This is a multi-step process as shared nodes might be of different depths. Nodes
2661			* are sorted by depth order, so we need to resolve the entire tree before moving to
2662			* the next step.
2663			*/
2664			this.updateProjection = () => {
2665				this.projectionUpdateScheduled = false;
2666				/**
2667				* Reset debug counts. Manually resetting rather than creating a new
2668				* object each frame.
2669				*/
2670				if (statsBuffer.value) metrics.nodes = metrics.calculatedTargetDeltas = metrics.calculatedProjections = 0;