@snowbomb1/nova-ui 1.0.8

package/dist/chunks/Box-ByLjqYJZ.js

@@ -0,0 +1,4670 @@
+import { Component, Fragment, createContext, createElement, forwardRef, useCallback, useContext, useEffect, useId, useInsertionEffect, useLayoutEffect, useMemo, useRef } from "react";
+var __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __hasOwnProp = Object.prototype.hasOwnProperty, __esmMin = (e, g) => () => (e && (g = e(e = 0)), g), __commonJSMin = (e, g) => () => (g || e((g = { exports: {} }).exports, g), g.exports), __export = (e) => {
+	let g = {};
+	for (var _ in e) __defProp(g, _, {
+		get: e[_],
+		enumerable: !0
+	});
+	return g;
+}, __copyProps = (e, g, _, v) => {
+	if (g && typeof g == "object" || typeof g == "function") for (var y = __getOwnPropNames(g), b = 0, x = y.length, S; b < x; b++) S = y[b], !__hasOwnProp.call(e, S) && S !== _ && __defProp(e, S, {
+		get: ((e) => g[e]).bind(null, S),
+		enumerable: !(v = __getOwnPropDesc(g, S)) || v.enumerable
+	});
+	return e;
+}, __toCommonJS = (e) => __copyProps(__defProp({}, "__esModule", { value: !0 }), e), __require = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, g) => (typeof require < "u" ? require : e)[g] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function.");
+}), require_react_jsx_runtime_production = /* @__PURE__ */ __commonJSMin(((e) => {
+	var g = Symbol.for("react.transitional.element"), _ = Symbol.for("react.fragment");
+	function v(e, _, v) {
+		var y = null;
+		if (v !== void 0 && (y = "" + v), _.key !== void 0 && (y = "" + _.key), "key" in _) for (var b in v = {}, _) b !== "key" && (v[b] = _[b]);
+		else v = _;
+		return _ = v.ref, {
+			$$typeof: g,
+			type: e,
+			key: y,
+			ref: _ === void 0 ? null : _,
+			props: v
+		};
+	}
+	e.Fragment = _, e.jsx = v, e.jsxs = v;
+})), require_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((e) => {
+	process.env.NODE_ENV !== "production" && (function() {
+		function g(e) {
+			if (e == null) return null;
+			if (typeof e == "function") return e.$$typeof === W ? null : e.displayName || e.name || null;
+			if (typeof e == "string") return e;
+			switch (e) {
+				case M: return "Fragment";
+				case P: return "Profiler";
+				case N: return "StrictMode";
+				case z: return "Suspense";
+				case B: return "SuspenseList";
+				case U: return "Activity";
+			}
+			if (typeof e == "object") switch (typeof e.tag == "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), e.$$typeof) {
+				case j: return "Portal";
+				case I: return e.displayName || "Context";
+				case F: return (e._context.displayName || "Context") + ".Consumer";
+				case R:
+					var _ = e.render;
+					return e = e.displayName, e ||= (e = _.displayName || _.name || "", e === "" ? "ForwardRef" : "ForwardRef(" + e + ")"), e;
+				case V: return _ = e.displayName || null, _ === null ? g(e.type) || "Memo" : _;
+				case H:
+					_ = e._payload, e = e._init;
+					try {
+						return g(e(_));
+					} catch {}
+			}
+			return null;
+		}
+		function _(e) {
+			return "" + e;
+		}
+		function v(e) {
+			try {
+				_(e);
+				var g = !1;
+			} catch {
+				g = !0;
+			}
+			if (g) {
+				g = console;
+				var v = g.error, y = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+				return v.call(g, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", y), _(e);
+			}
+		}
+		function y(e) {
+			if (e === M) return "<>";
+			if (typeof e == "object" && e && e.$$typeof === H) return "<...>";
+			try {
+				var _ = g(e);
+				return _ ? "<" + _ + ">" : "<...>";
+			} catch {
+				return "<...>";
+			}
+		}
+		function b() {
+			var e = G.A;
+			return e === null ? null : e.getOwner();
+		}
+		function x() {
+			return Error("react-stack-top-frame");
+		}
+		function S(e) {
+			if (K.call(e, "key")) {
+				var g = Object.getOwnPropertyDescriptor(e, "key").get;
+				if (g && g.isReactWarning) return !1;
+			}
+			return e.key !== void 0;
+		}
+		function C(e, g) {
+			function _() {
+				Y || (Y = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", g));
+			}
+			_.isReactWarning = !0, Object.defineProperty(e, "key", {
+				get: _,
+				configurable: !0
+			});
+		}
+		function w() {
+			var e = g(this.type);
+			return X[e] || (X[e] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release.")), e = this.props.ref, e === void 0 ? null : e;
+		}
+		function T(e, g, _, v, y, b) {
+			var x = _.ref;
+			return e = {
+				$$typeof: A,
+				type: e,
+				key: g,
+				props: _,
+				_owner: v
+			}, (x === void 0 ? null : x) === null ? Object.defineProperty(e, "ref", {
+				enumerable: !1,
+				value: null
+			}) : Object.defineProperty(e, "ref", {
+				enumerable: !1,
+				get: w
+			}), e._store = {}, Object.defineProperty(e._store, "validated", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: 0
+			}), Object.defineProperty(e, "_debugInfo", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: null
+			}), Object.defineProperty(e, "_debugStack", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: y
+			}), Object.defineProperty(e, "_debugTask", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: b
+			}), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+		}
+		function E(e, _, y, x, w, E) {
+			var O = _.children;
+			if (O !== void 0) if (x) if (q(O)) {
+				for (x = 0; x < O.length; x++) D(O[x]);
+				Object.freeze && Object.freeze(O);
+			} else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+			else D(O);
+			if (K.call(_, "key")) {
+				O = g(e);
+				var k = Object.keys(_).filter(function(e) {
+					return e !== "key";
+				});
+				x = 0 < k.length ? "{key: someKey, " + k.join(": ..., ") + ": ...}" : "{key: someKey}", $[O + x] || (k = 0 < k.length ? "{" + k.join(": ..., ") + ": ...}" : "{}", console.error("A props object containing a \"key\" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />", x, O, k, O), $[O + x] = !0);
+			}
+			if (O = null, y !== void 0 && (v(y), O = "" + y), S(_) && (v(_.key), O = "" + _.key), "key" in _) for (var A in y = {}, _) A !== "key" && (y[A] = _[A]);
+			else y = _;
+			return O && C(y, typeof e == "function" ? e.displayName || e.name || "Unknown" : e), T(e, O, y, b(), w, E);
+		}
+		function D(e) {
+			O(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e && e.$$typeof === H && (e._payload.status === "fulfilled" ? O(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+		}
+		function O(e) {
+			return typeof e == "object" && !!e && e.$$typeof === A;
+		}
+		var k = __require("react"), A = Symbol.for("react.transitional.element"), j = Symbol.for("react.portal"), M = Symbol.for("react.fragment"), N = Symbol.for("react.strict_mode"), P = Symbol.for("react.profiler"), F = Symbol.for("react.consumer"), I = Symbol.for("react.context"), R = Symbol.for("react.forward_ref"), z = Symbol.for("react.suspense"), B = Symbol.for("react.suspense_list"), V = Symbol.for("react.memo"), H = Symbol.for("react.lazy"), U = Symbol.for("react.activity"), W = Symbol.for("react.client.reference"), G = k.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, K = Object.prototype.hasOwnProperty, q = Array.isArray, J = console.createTask ? console.createTask : function() {
+			return null;
+		};
+		k = { react_stack_bottom_frame: function(e) {
+			return e();
+		} };
+		var Y, X = {}, Z = k.react_stack_bottom_frame.bind(k, x)(), Q = J(y(x)), $ = {};
+		e.Fragment = M, e.jsx = function(e, g, _) {
+			var v = 1e4 > G.recentlyCreatedOwnerStacks++;
+			return E(e, g, _, !1, v ? Error("react-stack-top-frame") : Z, v ? J(y(e)) : Q);
+		}, e.jsxs = function(e, g, _) {
+			var v = 1e4 > G.recentlyCreatedOwnerStacks++;
+			return E(e, g, _, !0, v ? Error("react-stack-top-frame") : Z, v ? J(y(e)) : Q);
+		};
+	})();
+})), require_jsx_runtime = /* @__PURE__ */ __commonJSMin(((e, g) => {
+	process.env.NODE_ENV === "production" ? g.exports = require_react_jsx_runtime_production() : g.exports = require_react_jsx_runtime_development();
+})), LayoutGroupContext = createContext({});
+function useConstant(e) {
+	let g = useRef(null);
+	return g.current === null && (g.current = e()), g.current;
+}
+var isBrowser = typeof window < "u", useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect, PresenceContext = /* @__PURE__ */ createContext(null);
+function addUniqueItem(e, g) {
+	e.indexOf(g) === -1 && e.push(g);
+}
+function removeItem(e, g) {
+	let _ = e.indexOf(g);
+	_ > -1 && e.splice(_, 1);
+}
+var clamp = (e, g, _) => _ > g ? g : _ < e ? e : _;
+function formatErrorMessage(e, g) {
+	return g ? `${e}. For more information and steps for solving, visit https://motion.dev/troubleshooting/${g}` : e;
+}
+var warning = () => {}, invariant = () => {};
+typeof process < "u" && process.env.NODE_ENV !== "production" && (warning = (e, g, _) => {
+	!e && typeof console < "u" && console.warn(formatErrorMessage(g, _));
+}, invariant = (e, g, _) => {
+	if (!e) throw Error(formatErrorMessage(g, _));
+});
+var MotionGlobalConfig = {}, isNumericalString = (e) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(e);
+function isObject(e) {
+	return typeof e == "object" && !!e;
+}
+var isZeroValueString = (e) => /^0[^.\s]+$/u.test(e);
+/* @__NO_SIDE_EFFECTS__ */
+function memo(e) {
+	let g;
+	return () => (g === void 0 && (g = e()), g);
+}
+var noop = /* @__NO_SIDE_EFFECTS__ */ (e) => e, combineFunctions = (e, g) => (_) => g(e(_)), pipe = (...e) => e.reduce(combineFunctions), progress = /* @__NO_SIDE_EFFECTS__ */ (e, g, _) => {
+	let v = g - e;
+	return v === 0 ? 1 : (_ - e) / v;
+}, SubscriptionManager = class {
+	constructor() {
+		this.subscriptions = [];
+	}
+	add(e) {
+		return addUniqueItem(this.subscriptions, e), () => removeItem(this.subscriptions, e);
+	}
+	notify(e, g, _) {
+		let v = this.subscriptions.length;
+		if (v) if (v === 1) this.subscriptions[0](e, g, _);
+		else for (let y = 0; y < v; y++) {
+			let v = this.subscriptions[y];
+			v && v(e, g, _);
+		}
+	}
+	getSize() {
+		return this.subscriptions.length;
+	}
+	clear() {
+		this.subscriptions.length = 0;
+	}
+}, secondsToMilliseconds = /* @__NO_SIDE_EFFECTS__ */ (e) => e * 1e3, millisecondsToSeconds = /* @__NO_SIDE_EFFECTS__ */ (e) => e / 1e3;
+function velocityPerSecond(e, g) {
+	return g ? e * (1e3 / g) : 0;
+}
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(e, g, _) {
+	e || warned.has(g) || (console.warn(formatErrorMessage(g, _)), warned.add(g));
+}
+var calcBezier = (e, g, _) => (((1 - 3 * _ + 3 * g) * e + (3 * _ - 6 * g)) * e + 3 * g) * e, subdivisionPrecision = 1e-7, subdivisionMaxIterations = 12;
+function binarySubdivide(e, g, _, v, y) {
+	let b, x, S = 0;
+	do
+		x = g + (_ - g) / 2, b = calcBezier(x, v, y) - e, b > 0 ? _ = x : g = x;
+	while (Math.abs(b) > subdivisionPrecision && ++S < subdivisionMaxIterations);
+	return x;
+}
+function cubicBezier(e, g, _, v) {
+	if (e === g && _ === v) return noop;
+	let y = (g) => binarySubdivide(g, 0, 1, e, _);
+	return (e) => e === 0 || e === 1 ? e : calcBezier(y(e), g, v);
+}
+var mirrorEasing = (e) => (g) => g <= .5 ? e(2 * g) / 2 : (2 - e(2 * (1 - g))) / 2, reverseEasing = (e) => (g) => 1 - e(1 - g), backOut = /* @__PURE__ */ cubicBezier(.33, 1.53, .69, .99), backIn = /* @__PURE__ */ reverseEasing(backOut), backInOut = /* @__PURE__ */ mirrorEasing(backIn), anticipate = (e) => (e *= 2) < 1 ? .5 * backIn(e) : .5 * (2 - 2 ** (-10 * (e - 1))), circIn = (e) => 1 - Math.sin(Math.acos(e)), circOut = reverseEasing(circIn), circInOut = mirrorEasing(circIn), easeIn = /* @__PURE__ */ cubicBezier(.42, 0, 1, 1), easeOut = /* @__PURE__ */ cubicBezier(0, 0, .58, 1), easeInOut = /* @__PURE__ */ cubicBezier(.42, 0, .58, 1), isEasingArray = (e) => Array.isArray(e) && typeof e[0] != "number", isBezierDefinition = (e) => Array.isArray(e) && typeof e[0] == "number", easingLookup = {
+	linear: noop,
+	easeIn,
+	easeInOut,
+	easeOut,
+	circIn,
+	circInOut,
+	circOut,
+	backIn,
+	backInOut,
+	backOut,
+	anticipate
+}, isValidEasing = (e) => typeof e == "string", easingDefinitionToFunction = (e) => {
+	if (isBezierDefinition(e)) {
+		invariant(e.length === 4, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
+		let [g, _, v, y] = e;
+		return cubicBezier(g, _, v, y);
+	} else if (isValidEasing(e)) return invariant(easingLookup[e] !== void 0, `Invalid easing type '${e}'`, "invalid-easing-type"), easingLookup[e];
+	return e;
+}, stepsOrder = [
+	"setup",
+	"read",
+	"resolveKeyframes",
+	"preUpdate",
+	"update",
+	"preRender",
+	"render",
+	"postRender"
+], statsBuffer = {
+	value: null,
+	addProjectionMetrics: null
+};
+function createRenderStep(e, g) {
+	let _ = /* @__PURE__ */ new Set(), v = /* @__PURE__ */ new Set(), y = !1, b = !1, x = /* @__PURE__ */ new WeakSet(), S = {
+		delta: 0,
+		timestamp: 0,
+		isProcessing: !1
+	}, C = 0;
+	function w(g) {
+		x.has(g) && (T.schedule(g), e()), C++, g(S);
+	}
+	let T = {
+		schedule: (e, g = !1, b = !1) => {
+			let S = b && y ? _ : v;
+			return g && x.add(e), S.has(e) || S.add(e), e;
+		},
+		cancel: (e) => {
+			v.delete(e), x.delete(e);
+		},
+		process: (e) => {
+			if (S = e, y) {
+				b = !0;
+				return;
+			}
+			y = !0, [_, v] = [v, _], _.forEach(w), g && statsBuffer.value && statsBuffer.value.frameloop[g].push(C), C = 0, _.clear(), y = !1, b && (b = !1, T.process(e));
+		}
+	};
+	return T;
+}
+var maxElapsed = 40;
+function createRenderBatcher(e, g) {
+	let _ = !1, v = !0, y = {
+		delta: 0,
+		timestamp: 0,
+		isProcessing: !1
+	}, b = () => _ = !0, x = stepsOrder.reduce((e, _) => (e[_] = createRenderStep(b, g ? _ : void 0), e), {}), { setup: S, read: C, resolveKeyframes: w, preUpdate: T, update: E, preRender: D, render: O, postRender: k } = x, A = () => {
+		let b = MotionGlobalConfig.useManualTiming ? y.timestamp : performance.now();
+		_ = !1, MotionGlobalConfig.useManualTiming || (y.delta = v ? 1e3 / 60 : Math.max(Math.min(b - y.timestamp, maxElapsed), 1)), y.timestamp = b, y.isProcessing = !0, S.process(y), C.process(y), w.process(y), T.process(y), E.process(y), D.process(y), O.process(y), k.process(y), y.isProcessing = !1, _ && g && (v = !1, e(A));
+	}, j = () => {
+		_ = !0, v = !0, y.isProcessing || e(A);
+	};
+	return {
+		schedule: stepsOrder.reduce((e, g) => {
+			let v = x[g];
+			return e[g] = (e, g = !1, y = !1) => (_ || j(), v.schedule(e, g, y)), e;
+		}, {}),
+		cancel: (e) => {
+			for (let g = 0; g < stepsOrder.length; g++) x[stepsOrder[g]].cancel(e);
+		},
+		state: y,
+		steps: x
+	};
+}
+var { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = /* @__PURE__ */ createRenderBatcher(typeof requestAnimationFrame < "u" ? requestAnimationFrame : noop, !0), now;
+function clearTime() {
+	now = void 0;
+}
+var time = {
+	now: () => (now === void 0 && time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now()), now),
+	set: (e) => {
+		now = e, queueMicrotask(clearTime);
+	}
+}, activeAnimations = {
+	layout: 0,
+	mainThread: 0,
+	waapi: 0
+}, checkStringStartsWith = (e) => (g) => typeof g == "string" && g.startsWith(e), isCSSVariableName = /* @__PURE__ */ checkStringStartsWith("--"), startsAsVariableToken = /* @__PURE__ */ checkStringStartsWith("var(--"), isCSSVariableToken = (e) => startsAsVariableToken(e) ? singleCssVariableRegex.test(e.split("/*")[0].trim()) : !1, singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+function containsCSSVariable(e) {
+	return typeof e == "string" ? e.split("/*")[0].includes("var(--") : !1;
+}
+var number = {
+	test: (e) => typeof e == "number",
+	parse: parseFloat,
+	transform: (e) => e
+}, alpha = {
+	...number,
+	transform: (e) => clamp(0, 1, e)
+}, scale = {
+	...number,
+	default: 1
+}, sanitize = (e) => Math.round(e * 1e5) / 1e5, floatRegex = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+function isNullish(e) {
+	return e == null;
+}
+var singleColorRegex = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu, isColorString = (e, g) => (_) => !!(typeof _ == "string" && singleColorRegex.test(_) && _.startsWith(e) || g && !isNullish(_) && Object.prototype.hasOwnProperty.call(_, g)), splitColor = (e, g, _) => (v) => {
+	if (typeof v != "string") return v;
+	let [y, b, x, S] = v.match(floatRegex);
+	return {
+		[e]: parseFloat(y),
+		[g]: parseFloat(b),
+		[_]: parseFloat(x),
+		alpha: S === void 0 ? 1 : parseFloat(S)
+	};
+}, clampRgbUnit = (e) => clamp(0, 255, e), rgbUnit = {
+	...number,
+	transform: (e) => Math.round(clampRgbUnit(e))
+}, rgba = {
+	test: /* @__PURE__ */ isColorString("rgb", "red"),
+	parse: /* @__PURE__ */ splitColor("red", "green", "blue"),
+	transform: ({ red: e, green: g, blue: _, alpha: v = 1 }) => "rgba(" + rgbUnit.transform(e) + ", " + rgbUnit.transform(g) + ", " + rgbUnit.transform(_) + ", " + sanitize(alpha.transform(v)) + ")"
+};
+function parseHex(e) {
+	let g = "", _ = "", v = "", y = "";
+	return e.length > 5 ? (g = e.substring(1, 3), _ = e.substring(3, 5), v = e.substring(5, 7), y = e.substring(7, 9)) : (g = e.substring(1, 2), _ = e.substring(2, 3), v = e.substring(3, 4), y = e.substring(4, 5), g += g, _ += _, v += v, y += y), {
+		red: parseInt(g, 16),
+		green: parseInt(_, 16),
+		blue: parseInt(v, 16),
+		alpha: y ? parseInt(y, 16) / 255 : 1
+	};
+}
+var hex = {
+	test: /* @__PURE__ */ isColorString("#"),
+	parse: parseHex,
+	transform: rgba.transform
+}, createUnitType = /* @__NO_SIDE_EFFECTS__ */ (e) => ({
+	test: (g) => typeof g == "string" && g.endsWith(e) && g.split(" ").length === 1,
+	parse: parseFloat,
+	transform: (g) => `${g}${e}`
+}), degrees = /* @__PURE__ */ createUnitType("deg"), percent = /* @__PURE__ */ createUnitType("%"), px = /* @__PURE__ */ createUnitType("px"), vh = /* @__PURE__ */ createUnitType("vh"), vw = /* @__PURE__ */ createUnitType("vw"), progressPercentage = /* @__PURE__ */ (() => ({
+	...percent,
+	parse: (e) => percent.parse(e) / 100,
+	transform: (e) => percent.transform(e * 100)
+}))(), hsla = {
+	test: /* @__PURE__ */ isColorString("hsl", "hue"),
+	parse: /* @__PURE__ */ splitColor("hue", "saturation", "lightness"),
+	transform: ({ hue: e, saturation: g, lightness: _, alpha: v = 1 }) => "hsla(" + Math.round(e) + ", " + percent.transform(sanitize(g)) + ", " + percent.transform(sanitize(_)) + ", " + sanitize(alpha.transform(v)) + ")"
+}, color = {
+	test: (e) => rgba.test(e) || hex.test(e) || hsla.test(e),
+	parse: (e) => rgba.test(e) ? rgba.parse(e) : hsla.test(e) ? hsla.parse(e) : hex.parse(e),
+	transform: (e) => typeof e == "string" ? e : e.hasOwnProperty("red") ? rgba.transform(e) : hsla.transform(e),
+	getAnimatableNone: (e) => {
+		let g = color.parse(e);
+		return g.alpha = 0, color.transform(g);
+	}
+}, colorRegex = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
+function test(e) {
+	return isNaN(e) && typeof e == "string" && (e.match(floatRegex)?.length || 0) + (e.match(colorRegex)?.length || 0) > 0;
+}
+var NUMBER_TOKEN = "number", COLOR_TOKEN = "color", VAR_TOKEN = "var", VAR_FUNCTION_TOKEN = "var(", SPLIT_TOKEN = "${}", complexRegex = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function analyseComplexValue(e) {
+	let g = e.toString(), _ = [], v = {
+		color: [],
+		number: [],
+		var: []
+	}, y = [], b = 0;
+	return {
+		values: _,
+		split: g.replace(complexRegex, (e) => (color.test(e) ? (v.color.push(b), y.push(COLOR_TOKEN), _.push(color.parse(e))) : e.startsWith(VAR_FUNCTION_TOKEN) ? (v.var.push(b), y.push(VAR_TOKEN), _.push(e)) : (v.number.push(b), y.push(NUMBER_TOKEN), _.push(parseFloat(e))), ++b, SPLIT_TOKEN)).split(SPLIT_TOKEN),
+		indexes: v,
+		types: y
+	};
+}
+function parseComplexValue(e) {
+	return analyseComplexValue(e).values;
+}
+function createTransformer(e) {
+	let { split: g, types: _ } = analyseComplexValue(e), v = g.length;
+	return (e) => {
+		let y = "";
+		for (let b = 0; b < v; b++) if (y += g[b], e[b] !== void 0) {
+			let g = _[b];
+			g === NUMBER_TOKEN ? y += sanitize(e[b]) : g === COLOR_TOKEN ? y += color.transform(e[b]) : y += e[b];
+		}
+		return y;
+	};
+}
+var convertNumbersToZero = (e) => typeof e == "number" ? 0 : color.test(e) ? color.getAnimatableNone(e) : e;
+function getAnimatableNone$1(e) {
+	let g = parseComplexValue(e);
+	return createTransformer(e)(g.map(convertNumbersToZero));
+}
+var complex = {
+	test,
+	parse: parseComplexValue,
+	createTransformer,
+	getAnimatableNone: getAnimatableNone$1
+};
+function hueToRgb(e, g, _) {
+	return _ < 0 && (_ += 1), _ > 1 && --_, _ < 1 / 6 ? e + (g - e) * 6 * _ : _ < 1 / 2 ? g : _ < 2 / 3 ? e + (g - e) * (2 / 3 - _) * 6 : e;
+}
+function hslaToRgba({ hue: e, saturation: g, lightness: _, alpha: v }) {
+	e /= 360, g /= 100, _ /= 100;
+	let y = 0, b = 0, x = 0;
+	if (!g) y = b = x = _;
+	else {
+		let v = _ < .5 ? _ * (1 + g) : _ + g - _ * g, S = 2 * _ - v;
+		y = hueToRgb(S, v, e + 1 / 3), b = hueToRgb(S, v, e), x = hueToRgb(S, v, e - 1 / 3);
+	}
+	return {
+		red: Math.round(y * 255),
+		green: Math.round(b * 255),
+		blue: Math.round(x * 255),
+		alpha: v
+	};
+}
+function mixImmediate(e, g) {
+	return (_) => _ > 0 ? g : e;
+}
+var mixNumber = (e, g, _) => e + (g - e) * _, mixLinearColor = (e, g, _) => {
+	let v = e * e, y = _ * (g * g - v) + v;
+	return y < 0 ? 0 : Math.sqrt(y);
+}, colorTypes = [
+	hex,
+	rgba,
+	hsla
+], getColorType = (e) => colorTypes.find((g) => g.test(e));
+function asRGBA(e) {
+	let g = getColorType(e);
+	if (warning(!!g, `'${e}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable"), !g) return !1;
+	let _ = g.parse(e);
+	return g === hsla && (_ = hslaToRgba(_)), _;
+}
+var mixColor = (e, g) => {
+	let _ = asRGBA(e), v = asRGBA(g);
+	if (!_ || !v) return mixImmediate(e, g);
+	let y = { ..._ };
+	return (e) => (y.red = mixLinearColor(_.red, v.red, e), y.green = mixLinearColor(_.green, v.green, e), y.blue = mixLinearColor(_.blue, v.blue, e), y.alpha = mixNumber(_.alpha, v.alpha, e), rgba.transform(y));
+}, invisibleValues = new Set(["none", "hidden"]);
+function mixVisibility(e, g) {
+	return invisibleValues.has(e) ? (_) => _ <= 0 ? e : g : (_) => _ >= 1 ? g : e;
+}
+function mixNumber$1(e, g) {
+	return (_) => mixNumber(e, g, _);
+}
+function getMixer(e) {
+	return typeof e == "number" ? mixNumber$1 : typeof e == "string" ? isCSSVariableToken(e) ? mixImmediate : color.test(e) ? mixColor : mixComplex : Array.isArray(e) ? mixArray : typeof e == "object" ? color.test(e) ? mixColor : mixObject : mixImmediate;
+}
+function mixArray(e, g) {
+	let _ = [...e], v = _.length, y = e.map((e, _) => getMixer(e)(e, g[_]));
+	return (e) => {
+		for (let g = 0; g < v; g++) _[g] = y[g](e);
+		return _;
+	};
+}
+function mixObject(e, g) {
+	let _ = {
+		...e,
+		...g
+	}, v = {};
+	for (let y in _) e[y] !== void 0 && g[y] !== void 0 && (v[y] = getMixer(e[y])(e[y], g[y]));
+	return (e) => {
+		for (let g in v) _[g] = v[g](e);
+		return _;
+	};
+}
+function matchOrder(e, g) {
+	let _ = [], v = {
+		color: 0,
+		var: 0,
+		number: 0
+	};
+	for (let y = 0; y < g.values.length; y++) {
+		let b = g.types[y], x = e.indexes[b][v[b]];
+		_[y] = e.values[x] ?? 0, v[b]++;
+	}
+	return _;
+}
+var mixComplex = (e, g) => {
+	let _ = complex.createTransformer(g), v = analyseComplexValue(e), y = analyseComplexValue(g);
+	return v.indexes.var.length === y.indexes.var.length && v.indexes.color.length === y.indexes.color.length && v.indexes.number.length >= y.indexes.number.length ? invisibleValues.has(e) && !y.values.length || invisibleValues.has(g) && !v.values.length ? mixVisibility(e, g) : pipe(mixArray(matchOrder(v, y), y.values), _) : (warning(!0, `Complex values '${e}' and '${g}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different"), mixImmediate(e, g));
+};
+function mix(e, g, _) {
+	return typeof e == "number" && typeof g == "number" && typeof _ == "number" ? mixNumber(e, g, _) : getMixer(e)(e, g);
+}
+var frameloopDriver = (e) => {
+	let g = ({ timestamp: g }) => e(g);
+	return {
+		start: (e = !0) => frame.update(g, e),
+		stop: () => cancelFrame(g),
+		now: () => frameData.isProcessing ? frameData.timestamp : time.now()
+	};
+}, generateLinearEasing = (e, g, _ = 10) => {
+	let v = "", y = Math.max(Math.round(g / _), 2);
+	for (let g = 0; g < y; g++) v += Math.round(e(g / (y - 1)) * 1e4) / 1e4 + ", ";
+	return `linear(${v.substring(0, v.length - 2)})`;
+}, maxGeneratorDuration = 2e4;
+function calcGeneratorDuration(e) {
+	let g = 0, _ = e.next(g);
+	for (; !_.done && g < 2e4;) g += 50, _ = e.next(g);
+	return g >= 2e4 ? Infinity : g;
+}
+function createGeneratorEasing(e, g = 100, _) {
+	let v = _({
+		...e,
+		keyframes: [0, g]
+	}), y = Math.min(calcGeneratorDuration(v), maxGeneratorDuration);
+	return {
+		type: "keyframes",
+		ease: (e) => v.next(y * e).value / g,
+		duration: /* @__PURE__ */ millisecondsToSeconds(y)
+	};
+}
+var velocitySampleDuration = 5;
+function calcGeneratorVelocity(e, g, _) {
+	let v = Math.max(g - velocitySampleDuration, 0);
+	return velocityPerSecond(_ - e(v), g - v);
+}
+var springDefaults = {
+	stiffness: 100,
+	damping: 10,
+	mass: 1,
+	velocity: 0,
+	duration: 800,
+	bounce: .3,
+	visualDuration: .3,
+	restSpeed: {
+		granular: .01,
+		default: 2
+	},
+	restDelta: {
+		granular: .005,
+		default: .5
+	},
+	minDuration: .01,
+	maxDuration: 10,
+	minDamping: .05,
+	maxDamping: 1
+}, safeMin = .001;
+function findSpring({ duration: e = springDefaults.duration, bounce: g = springDefaults.bounce, velocity: _ = springDefaults.velocity, mass: v = springDefaults.mass }) {
+	let y, b;
+	warning(e <= /* @__PURE__ */ secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+	let x = 1 - g;
+	x = clamp(springDefaults.minDamping, springDefaults.maxDamping, x), e = clamp(springDefaults.minDuration, springDefaults.maxDuration, /* @__PURE__ */ millisecondsToSeconds(e)), x < 1 ? (y = (g) => {
+		let v = g * x, y = v * e, b = v - _, S = calcAngularFreq(g, x), C = Math.exp(-y);
+		return safeMin - b / S * C;
+	}, b = (g) => {
+		let v = g * x * e, b = v * _ + _, S = x ** 2 * g ** 2 * e, C = Math.exp(-v), w = calcAngularFreq(g ** 2, x);
+		return (-y(g) + safeMin > 0 ? -1 : 1) * ((b - S) * C) / w;
+	}) : (y = (g) => {
+		let v = Math.exp(-g * e), y = (g - _) * e + 1;
+		return -safeMin + v * y;
+	}, b = (g) => Math.exp(-g * e) * ((_ - g) * (e * e)));
+	let S = 5 / e, C = approximateRoot(y, b, S);
+	if (e = /* @__PURE__ */ secondsToMilliseconds(e), isNaN(C)) return {
+		stiffness: springDefaults.stiffness,
+		damping: springDefaults.damping,
+		duration: e
+	};
+	{
+		let g = C ** 2 * v;
+		return {
+			stiffness: g,
+			damping: x * 2 * Math.sqrt(v * g),
+			duration: e
+		};
+	}
+}
+var rootIterations = 12;
+function approximateRoot(e, g, _) {
+	let v = _;
+	for (let _ = 1; _ < rootIterations; _++) v -= e(v) / g(v);
+	return v;
+}
+function calcAngularFreq(e, g) {
+	return e * Math.sqrt(1 - g * g);
+}
+var durationKeys = ["duration", "bounce"], physicsKeys = [
+	"stiffness",
+	"damping",
+	"mass"
+];
+function isSpringType(e, g) {
+	return g.some((g) => e[g] !== void 0);
+}
+function getSpringOptions(e) {
+	let g = {
+		velocity: springDefaults.velocity,
+		stiffness: springDefaults.stiffness,
+		damping: springDefaults.damping,
+		mass: springDefaults.mass,
+		isResolvedFromDuration: !1,
+		...e
+	};
+	if (!isSpringType(e, physicsKeys) && isSpringType(e, durationKeys)) if (e.visualDuration) {
+		let _ = e.visualDuration, v = 2 * Math.PI / (_ * 1.2), y = v * v, b = 2 * clamp(.05, 1, 1 - (e.bounce || 0)) * Math.sqrt(y);
+		g = {
+			...g,
+			mass: springDefaults.mass,
+			stiffness: y,
+			damping: b
+		};
+	} else {
+		let _ = findSpring(e);
+		g = {
+			...g,
+			..._,
+			mass: springDefaults.mass
+		}, g.isResolvedFromDuration = !0;
+	}
+	return g;
+}
+function spring(e = springDefaults.visualDuration, g = springDefaults.bounce) {
+	let _ = typeof e == "object" ? e : {
+		visualDuration: e,
+		keyframes: [0, 1],
+		bounce: g
+	}, { restSpeed: v, restDelta: y } = _, b = _.keyframes[0], x = _.keyframes[_.keyframes.length - 1], S = {
+		done: !1,
+		value: b
+	}, { stiffness: C, damping: w, mass: T, duration: E, velocity: D, isResolvedFromDuration: O } = getSpringOptions({
+		..._,
+		velocity: -/* @__PURE__ */ millisecondsToSeconds(_.velocity || 0)
+	}), k = D || 0, A = w / (2 * Math.sqrt(C * T)), j = x - b, M = /* @__PURE__ */ millisecondsToSeconds(Math.sqrt(C / T)), N = Math.abs(j) < 5;
+	v ||= N ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default, y ||= N ? springDefaults.restDelta.granular : springDefaults.restDelta.default;
+	let P;
+	if (A < 1) {
+		let e = calcAngularFreq(M, A);
+		P = (g) => x - Math.exp(-A * M * g) * ((k + A * M * j) / e * Math.sin(e * g) + j * Math.cos(e * g));
+	} else if (A === 1) P = (e) => x - Math.exp(-M * e) * (j + (k + M * j) * e);
+	else {
+		let e = M * Math.sqrt(A * A - 1);
+		P = (g) => {
+			let _ = Math.exp(-A * M * g), v = Math.min(e * g, 300);
+			return x - _ * ((k + A * M * j) * Math.sinh(v) + e * j * Math.cosh(v)) / e;
+		};
+	}
+	let F = {
+		calculatedDuration: O && E || null,
+		next: (e) => {
+			let g = P(e);
+			if (O) S.done = e >= E;
+			else {
+				let _ = e === 0 ? k : 0;
+				A < 1 && (_ = e === 0 ? /* @__PURE__ */ secondsToMilliseconds(k) : calcGeneratorVelocity(P, e, g));
+				let b = Math.abs(_) <= v, C = Math.abs(x - g) <= y;
+				S.done = b && C;
+			}
+			return S.value = S.done ? x : g, S;
+		},
+		toString: () => {
+			let e = Math.min(calcGeneratorDuration(F), maxGeneratorDuration), g = generateLinearEasing((g) => F.next(e * g).value, e, 30);
+			return e + "ms " + g;
+		},
+		toTransition: () => {}
+	};
+	return F;
+}
+spring.applyToOptions = (e) => {
+	let g = createGeneratorEasing(e, 100, spring);
+	return e.ease = g.ease, e.duration = /* @__PURE__ */ secondsToMilliseconds(g.duration), e.type = "keyframes", e;
+};
+function inertia({ keyframes: e, velocity: g = 0, power: _ = .8, timeConstant: v = 325, bounceDamping: y = 10, bounceStiffness: b = 500, modifyTarget: x, min: S, max: C, restDelta: w = .5, restSpeed: T }) {
+	let E = e[0], D = {
+		done: !1,
+		value: E
+	}, O = (e) => S !== void 0 && e < S || C !== void 0 && e > C, k = (e) => S === void 0 ? C : C === void 0 || Math.abs(S - e) < Math.abs(C - e) ? S : C, A = _ * g, j = E + A, M = x === void 0 ? j : x(j);
+	M !== j && (A = M - E);
+	let N = (e) => -A * Math.exp(-e / v), P = (e) => M + N(e), F = (e) => {
+		let g = N(e), _ = P(e);
+		D.done = Math.abs(g) <= w, D.value = D.done ? M : _;
+	}, I, L, R = (e) => {
+		O(D.value) && (I = e, L = spring({
+			keyframes: [D.value, k(D.value)],
+			velocity: calcGeneratorVelocity(P, e, D.value),
+			damping: y,
+			stiffness: b,
+			restDelta: w,
+			restSpeed: T
+		}));
+	};
+	return R(0), {
+		calculatedDuration: null,
+		next: (e) => {
+			let g = !1;
+			return !L && I === void 0 && (g = !0, F(e), R(e)), I !== void 0 && e >= I ? L.next(e - I) : (!g && F(e), D);
+		}
+	};
+}
+function createMixers(e, g, _) {
+	let v = [], y = _ || MotionGlobalConfig.mix || mix, b = e.length - 1;
+	for (let _ = 0; _ < b; _++) {
+		let b = y(e[_], e[_ + 1]);
+		g && (b = pipe(Array.isArray(g) ? g[_] || noop : g, b)), v.push(b);
+	}
+	return v;
+}
+function interpolate(e, g, { clamp: _ = !0, ease: v, mixer: y } = {}) {
+	let b = e.length;
+	if (invariant(b === g.length, "Both input and output ranges must be the same length", "range-length"), b === 1) return () => g[0];
+	if (b === 2 && g[0] === g[1]) return () => g[1];
+	let x = e[0] === e[1];
+	e[0] > e[b - 1] && (e = [...e].reverse(), g = [...g].reverse());
+	let S = createMixers(g, v, y), C = S.length, w = (_) => {
+		if (x && _ < e[0]) return g[0];
+		let v = 0;
+		if (C > 1) for (; v < e.length - 2 && !(_ < e[v + 1]); v++);
+		let y = /* @__PURE__ */ progress(e[v], e[v + 1], _);
+		return S[v](y);
+	};
+	return _ ? (g) => w(clamp(e[0], e[b - 1], g)) : w;
+}
+function fillOffset(e, g) {
+	let _ = e[e.length - 1];
+	for (let v = 1; v <= g; v++) {
+		let y = /* @__PURE__ */ progress(0, g, v);
+		e.push(mixNumber(_, 1, y));
+	}
+}
+function defaultOffset(e) {
+	let g = [0];
+	return fillOffset(g, e.length - 1), g;
+}
+function convertOffsetToTimes(e, g) {
+	return e.map((e) => e * g);
+}
+function defaultEasing(e, g) {
+	return e.map(() => g || easeInOut).splice(0, e.length - 1);
+}
+function keyframes({ duration: e = 300, keyframes: g, times: _, ease: v = "easeInOut" }) {
+	let y = isEasingArray(v) ? v.map(easingDefinitionToFunction) : easingDefinitionToFunction(v), b = {
+		done: !1,
+		value: g[0]
+	}, x = interpolate(convertOffsetToTimes(_ && _.length === g.length ? _ : defaultOffset(g), e), g, { ease: Array.isArray(y) ? y : defaultEasing(g, y) });
+	return {
+		calculatedDuration: e,
+		next: (g) => (b.value = x(g), b.done = g >= e, b)
+	};
+}
+var isNotNull$1 = (e) => e !== null;
+function getFinalKeyframe$1(e, { repeat: g, repeatType: _ = "loop" }, v, y = 1) {
+	let b = e.filter(isNotNull$1), x = y < 0 || g && _ !== "loop" && g % 2 == 1 ? 0 : b.length - 1;
+	return !x || v === void 0 ? b[x] : v;
+}
+var transitionTypeMap = {
+	decay: inertia,
+	inertia,
+	tween: keyframes,
+	keyframes,
+	spring
+};
+function replaceTransitionType(e) {
+	typeof e.type == "string" && (e.type = transitionTypeMap[e.type]);
+}
+var WithPromise = class {
+	constructor() {
+		this.updateFinished();
+	}
+	get finished() {
+		return this._finished;
+	}
+	updateFinished() {
+		this._finished = new Promise((e) => {
+			this.resolve = e;
+		});
+	}
+	notifyFinished() {
+		this.resolve();
+	}
+	then(e, g) {
+		return this.finished.then(e, g);
+	}
+}, percentToProgress = (e) => e / 100, JSAnimation = class extends WithPromise {
+	constructor(e) {
+		super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
+			let { motionValue: e } = this.options;
+			e && e.updatedAt !== time.now() && this.tick(time.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+		}, activeAnimations.mainThread++, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
+	}
+	initAnimation() {
+		let { options: e } = this;
+		replaceTransitionType(e);
+		let { type: g = keyframes, repeat: _ = 0, repeatDelay: v = 0, repeatType: y, velocity: b = 0 } = e, { keyframes: x } = e, S = g || keyframes;
+		process.env.NODE_ENV !== "production" && S !== keyframes && invariant(x.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${x}`, "spring-two-frames"), S !== keyframes && typeof x[0] != "number" && (this.mixKeyframes = pipe(percentToProgress, mix(x[0], x[1])), x = [0, 100]);
+		let C = S({
+			...e,
+			keyframes: x
+		});
+		y === "mirror" && (this.mirroredGenerator = S({
+			...e,
+			keyframes: [...x].reverse(),
+			velocity: -b
+		})), C.calculatedDuration === null && (C.calculatedDuration = calcGeneratorDuration(C));
+		let { calculatedDuration: w } = C;
+		this.calculatedDuration = w, this.resolvedDuration = w + v, this.totalDuration = this.resolvedDuration * (_ + 1) - v, this.generator = C;
+	}
+	updateTime(e) {
+		let g = Math.round(e - this.startTime) * this.playbackSpeed;
+		this.holdTime === null ? this.currentTime = g : this.currentTime = this.holdTime;
+	}
+	tick(e, g = !1) {
+		let { generator: _, totalDuration: v, mixKeyframes: y, mirroredGenerator: b, resolvedDuration: x, calculatedDuration: S } = this;
+		if (this.startTime === null) return _.next(0);
+		let { delay: C = 0, keyframes: w, repeat: T, repeatType: E, repeatDelay: D, type: O, onUpdate: k, finalKeyframe: A } = this.options;
+		this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - v / this.speed, this.startTime)), g ? this.currentTime = e : this.updateTime(e);
+		let j = this.currentTime - C * (this.playbackSpeed >= 0 ? 1 : -1), M = this.playbackSpeed >= 0 ? j < 0 : j > v;
+		this.currentTime = Math.max(j, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = v);
+		let N = this.currentTime, P = _;
+		if (T) {
+			let e = Math.min(this.currentTime, v) / x, g = Math.floor(e), _ = e % 1;
+			!_ && e >= 1 && (_ = 1), _ === 1 && g--, g = Math.min(g, T + 1), g % 2 && (E === "reverse" ? (_ = 1 - _, D && (_ -= D / x)) : E === "mirror" && (P = b)), N = clamp(0, 1, _) * x;
+		}
+		let F = M ? {
+			done: !1,
+			value: w[0]
+		} : P.next(N);
+		y && (F.value = y(F.value));
+		let { done: I } = F;
+		!M && S !== null && (I = this.playbackSpeed >= 0 ? this.currentTime >= v : this.currentTime <= 0);
+		let L = this.holdTime === null && (this.state === "finished" || this.state === "running" && I);
+		return L && O !== inertia && (F.value = getFinalKeyframe$1(w, this.options, A, this.speed)), k && k(F.value), L && this.finish(), F;
+	}
+	then(e, g) {
+		return this.finished.then(e, g);
+	}
+	get duration() {
+		return /* @__PURE__ */ millisecondsToSeconds(this.calculatedDuration);
+	}
+	get iterationDuration() {
+		let { delay: e = 0 } = this.options || {};
+		return this.duration + /* @__PURE__ */ millisecondsToSeconds(e);
+	}
+	get time() {
+		return /* @__PURE__ */ millisecondsToSeconds(this.currentTime);
+	}
+	set time(e) {
+		e = /* @__PURE__ */ secondsToMilliseconds(e), this.currentTime = e, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = e : this.driver && (this.startTime = this.driver.now() - e / this.playbackSpeed), this.driver?.start(!1);
+	}
+	get speed() {
+		return this.playbackSpeed;
+	}
+	set speed(e) {
+		this.updateTime(time.now());
+		let g = this.playbackSpeed !== e;
+		this.playbackSpeed = e, g && (this.time = /* @__PURE__ */ millisecondsToSeconds(this.currentTime));
+	}
+	play() {
+		if (this.isStopped) return;
+		let { driver: e = frameloopDriver, startTime: g } = this.options;
+		this.driver ||= e((e) => this.tick(e)), this.options.onPlay?.();
+		let _ = this.driver.now();
+		this.state === "finished" ? (this.updateFinished(), this.startTime = _) : this.holdTime === null ? this.startTime ||= g ?? _ : this.startTime = _ - this.holdTime, this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+	}
+	pause() {
+		this.state = "paused", this.updateTime(time.now()), this.holdTime = this.currentTime;
+	}
+	complete() {
+		this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+	}
+	finish() {
+		this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+	}
+	cancel() {
+		this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+	}
+	teardown() {
+		this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null, activeAnimations.mainThread--;
+	}
+	stopDriver() {
+		this.driver &&= (this.driver.stop(), void 0);
+	}
+	sample(e) {
+		return this.startTime = 0, this.tick(e, !0);
+	}
+	attachTimeline(e) {
+		return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), e.observe(this);
+	}
+};
+function fillWildcards(e) {
+	for (let g = 1; g < e.length; g++) e[g] ?? (e[g] = e[g - 1]);
+}
+var radToDeg = (e) => e * 180 / Math.PI, rotate = (e) => rebaseAngle(radToDeg(Math.atan2(e[1], e[0]))), matrix2dParsers = {
+	x: 4,
+	y: 5,
+	translateX: 4,
+	translateY: 5,
+	scaleX: 0,
+	scaleY: 3,
+	scale: (e) => (Math.abs(e[0]) + Math.abs(e[3])) / 2,
+	rotate,
+	rotateZ: rotate,
+	skewX: (e) => radToDeg(Math.atan(e[1])),
+	skewY: (e) => radToDeg(Math.atan(e[2])),
+	skew: (e) => (Math.abs(e[1]) + Math.abs(e[2])) / 2
+}, rebaseAngle = (e) => (e %= 360, e < 0 && (e += 360), e), rotateZ = rotate, scaleX = (e) => Math.sqrt(e[0] * e[0] + e[1] * e[1]), scaleY = (e) => Math.sqrt(e[4] * e[4] + e[5] * e[5]), matrix3dParsers = {
+	x: 12,
+	y: 13,
+	z: 14,
+	translateX: 12,
+	translateY: 13,
+	translateZ: 14,
+	scaleX,
+	scaleY,
+	scale: (e) => (scaleX(e) + scaleY(e)) / 2,
+	rotateX: (e) => rebaseAngle(radToDeg(Math.atan2(e[6], e[5]))),
+	rotateY: (e) => rebaseAngle(radToDeg(Math.atan2(-e[2], e[0]))),
+	rotateZ,
+	rotate: rotateZ,
+	skewX: (e) => radToDeg(Math.atan(e[4])),
+	skewY: (e) => radToDeg(Math.atan(e[1])),
+	skew: (e) => (Math.abs(e[1]) + Math.abs(e[4])) / 2
+};
+function defaultTransformValue(e) {
+	return e.includes("scale") ? 1 : 0;
+}
+function parseValueFromTransform(e, g) {
+	if (!e || e === "none") return defaultTransformValue(g);
+	let _ = e.match(/^matrix3d\(([-\d.e\s,]+)\)$/u), v, y;
+	if (_) v = matrix3dParsers, y = _;
+	else {
+		let g = e.match(/^matrix\(([-\d.e\s,]+)\)$/u);
+		v = matrix2dParsers, y = g;
+	}
+	if (!y) return defaultTransformValue(g);
+	let b = v[g], x = y[1].split(",").map(convertTransformToNumber);
+	return typeof b == "function" ? b(x) : x[b];
+}
+var readTransformValue = (e, g) => {
+	let { transform: _ = "none" } = getComputedStyle(e);
+	return parseValueFromTransform(_, g);
+};
+function convertTransformToNumber(e) {
+	return parseFloat(e.trim());
+}
+var transformPropOrder = [
+	"transformPerspective",
+	"x",
+	"y",
+	"z",
+	"translateX",
+	"translateY",
+	"translateZ",
+	"scale",
+	"scaleX",
+	"scaleY",
+	"rotate",
+	"rotateX",
+	"rotateY",
+	"rotateZ",
+	"skew",
+	"skewX",
+	"skewY"
+], transformProps = /* @__PURE__ */ (() => new Set(transformPropOrder))(), isNumOrPxType = (e) => e === number || e === px, transformKeys = new Set([
+	"x",
+	"y",
+	"z"
+]), nonTranslationalTransformKeys = transformPropOrder.filter((e) => !transformKeys.has(e));
+function removeNonTranslationalTransform(e) {
+	let g = [];
+	return nonTranslationalTransformKeys.forEach((_) => {
+		let v = e.getValue(_);
+		v !== void 0 && (g.push([_, v.get()]), v.set(_.startsWith("scale") ? 1 : 0));
+	}), g;
+}
+var positionalValues = {
+	width: ({ x: e }, { paddingLeft: g = "0", paddingRight: _ = "0" }) => e.max - e.min - parseFloat(g) - parseFloat(_),
+	height: ({ y: e }, { paddingTop: g = "0", paddingBottom: _ = "0" }) => e.max - e.min - parseFloat(g) - parseFloat(_),
+	top: (e, { top: g }) => parseFloat(g),
+	left: (e, { left: g }) => parseFloat(g),
+	bottom: ({ y: e }, { top: g }) => parseFloat(g) + (e.max - e.min),
+	right: ({ x: e }, { left: g }) => parseFloat(g) + (e.max - e.min),
+	x: (e, { transform: g }) => parseValueFromTransform(g, "x"),
+	y: (e, { transform: g }) => parseValueFromTransform(g, "y")
+};
+positionalValues.translateX = positionalValues.x, positionalValues.translateY = positionalValues.y;
+var toResolve = /* @__PURE__ */ new Set(), isScheduled = !1, anyNeedsMeasurement = !1, isForced = !1;
+function measureAllKeyframes() {
+	if (anyNeedsMeasurement) {
+		let e = Array.from(toResolve).filter((e) => e.needsMeasurement), g = new Set(e.map((e) => e.element)), _ = /* @__PURE__ */ new Map();
+		g.forEach((e) => {
+			let g = removeNonTranslationalTransform(e);
+			g.length && (_.set(e, g), e.render());
+		}), e.forEach((e) => e.measureInitialState()), g.forEach((e) => {
+			e.render();
+			let g = _.get(e);
+			g && g.forEach(([g, _]) => {
+				e.getValue(g)?.set(_);
+			});
+		}), e.forEach((e) => e.measureEndState()), e.forEach((e) => {
+			e.suspendedScrollY !== void 0 && window.scrollTo(0, e.suspendedScrollY);
+		});
+	}
+	anyNeedsMeasurement = !1, isScheduled = !1, toResolve.forEach((e) => e.complete(isForced)), toResolve.clear();
+}
+function readAllKeyframes() {
+	toResolve.forEach((e) => {
+		e.readKeyframes(), e.needsMeasurement && (anyNeedsMeasurement = !0);
+	});
+}
+function flushKeyframeResolvers() {
+	isForced = !0, readAllKeyframes(), measureAllKeyframes(), isForced = !1;
+}
+var KeyframeResolver = class {
+	constructor(e, g, _, v, y, b = !1) {
+		this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...e], this.onComplete = g, this.name = _, this.motionValue = v, this.element = y, this.isAsync = b;
+	}
+	scheduleResolve() {
+		this.state = "scheduled", this.isAsync ? (toResolve.add(this), isScheduled || (isScheduled = !0, frame.read(readAllKeyframes), frame.resolveKeyframes(measureAllKeyframes))) : (this.readKeyframes(), this.complete());
+	}
+	readKeyframes() {
+		let { unresolvedKeyframes: e, name: g, element: _, motionValue: v } = this;
+		if (e[0] === null) {
+			let y = v?.get(), b = e[e.length - 1];
+			if (y !== void 0) e[0] = y;
+			else if (_ && g) {
+				let v = _.readValue(g, b);
+				v != null && (e[0] = v);
+			}
+			e[0] === void 0 && (e[0] = b), v && y === void 0 && v.set(e[0]);
+		}
+		fillWildcards(e);
+	}
+	setFinalKeyframe() {}
+	measureInitialState() {}
+	renderEndStyles() {}
+	measureEndState() {}
+	complete(e = !1) {
+		this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, e), toResolve.delete(this);
+	}
+	cancel() {
+		this.state === "scheduled" && (toResolve.delete(this), this.state = "pending");
+	}
+	resume() {
+		this.state === "pending" && this.scheduleResolve();
+	}
+}, isCSSVar = (e) => e.startsWith("--");
+function setStyle(e, g, _) {
+	isCSSVar(g) ? e.style.setProperty(g, _) : e.style[g] = _;
+}
+var supportsScrollTimeline = /* @__PURE__ */ memo(() => window.ScrollTimeline !== void 0), supportsFlags = {};
+function memoSupports(e, g) {
+	let _ = /* @__PURE__ */ memo(e);
+	return () => supportsFlags[g] ?? _();
+}
+var supportsLinearEasing = /* @__PURE__ */ memoSupports(() => {
+	try {
+		document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+	} catch {
+		return !1;
+	}
+	return !0;
+}, "linearEasing"), cubicBezierAsString = ([e, g, _, v]) => `cubic-bezier(${e}, ${g}, ${_}, ${v})`, supportedWaapiEasing = {
+	linear: "linear",
+	ease: "ease",
+	easeIn: "ease-in",
+	easeOut: "ease-out",
+	easeInOut: "ease-in-out",
+	circIn: /* @__PURE__ */ cubicBezierAsString([
+		0,
+		.65,
+		.55,
+		1
+	]),
+	circOut: /* @__PURE__ */ cubicBezierAsString([
+		.55,
+		0,
+		1,
+		.45
+	]),
+	backIn: /* @__PURE__ */ cubicBezierAsString([
+		.31,
+		.01,
+		.66,
+		-.59
+	]),
+	backOut: /* @__PURE__ */ cubicBezierAsString([
+		.33,
+		1.53,
+		.69,
+		.99
+	])
+};
+function mapEasingToNativeEasing(e, g) {
+	if (e) return typeof e == "function" ? supportsLinearEasing() ? generateLinearEasing(e, g) : "ease-out" : isBezierDefinition(e) ? cubicBezierAsString(e) : Array.isArray(e) ? e.map((e) => mapEasingToNativeEasing(e, g) || supportedWaapiEasing.easeOut) : supportedWaapiEasing[e];
+}
+function startWaapiAnimation(e, g, _, { delay: v = 0, duration: y = 300, repeat: b = 0, repeatType: x = "loop", ease: S = "easeOut", times: C } = {}, w = void 0) {
+	let T = { [g]: _ };
+	C && (T.offset = C);
+	let E = mapEasingToNativeEasing(S, y);
+	Array.isArray(E) && (T.easing = E), statsBuffer.value && activeAnimations.waapi++;
+	let D = {
+		delay: v,
+		duration: y,
+		easing: Array.isArray(E) ? "linear" : E,
+		fill: "both",
+		iterations: b + 1,
+		direction: x === "reverse" ? "alternate" : "normal"
+	};
+	w && (D.pseudoElement = w);
+	let O = e.animate(T, D);
+	return statsBuffer.value && O.finished.finally(() => {
+		activeAnimations.waapi--;
+	}), O;
+}
+function isGenerator(e) {
+	return typeof e == "function" && "applyToOptions" in e;
+}
+function applyGeneratorOptions({ type: e, ...g }) {
+	return isGenerator(e) && supportsLinearEasing() ? e.applyToOptions(g) : (g.duration ??= 300, g.ease ??= "easeOut", g);
+}
+var NativeAnimation = class extends WithPromise {
+	constructor(e) {
+		if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !e) return;
+		let { element: g, name: _, keyframes: v, pseudoElement: y, allowFlatten: b = !1, finalKeyframe: x, onComplete: S } = e;
+		this.isPseudoElement = !!y, this.allowFlatten = b, this.options = e, invariant(typeof e.type != "string", "Mini animate() doesn't support \"type\" as a string.", "mini-spring");
+		let C = applyGeneratorOptions(e);
+		this.animation = startWaapiAnimation(g, _, v, C, y), C.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+			if (this.finishedTime = this.time, !y) {
+				let e = getFinalKeyframe$1(v, this.options, x, this.speed);
+				this.updateMotionValue ? this.updateMotionValue(e) : setStyle(g, _, e), this.animation.cancel();
+			}
+			S?.(), this.notifyFinished();
+		};
+	}
+	play() {
+		this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+	}
+	pause() {
+		this.animation.pause();
+	}
+	complete() {
+		this.animation.finish?.();
+	}
+	cancel() {
+		try {
+			this.animation.cancel();
+		} catch {}
+	}
+	stop() {
+		if (this.isStopped) return;
+		this.isStopped = !0;
+		let { state: e } = this;
+		e === "idle" || e === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+	}
+	commitStyles() {
+		let e = this.options?.element;
+		!this.isPseudoElement && e?.isConnected && this.animation.commitStyles?.();
+	}
+	get duration() {
+		let e = this.animation.effect?.getComputedTiming?.().duration || 0;
+		return /* @__PURE__ */ millisecondsToSeconds(Number(e));
+	}
+	get iterationDuration() {
+		let { delay: e = 0 } = this.options || {};
+		return this.duration + /* @__PURE__ */ millisecondsToSeconds(e);
+	}
+	get time() {
+		return /* @__PURE__ */ millisecondsToSeconds(Number(this.animation.currentTime) || 0);
+	}
+	set time(e) {
+		this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ secondsToMilliseconds(e);
+	}
+	get speed() {
+		return this.animation.playbackRate;
+	}
+	set speed(e) {
+		e < 0 && (this.finishedTime = null), this.animation.playbackRate = e;
+	}
+	get state() {
+		return this.finishedTime === null ? this.animation.playState : "finished";
+	}
+	get startTime() {
+		return this.manualStartTime ?? Number(this.animation.startTime);
+	}
+	set startTime(e) {
+		this.manualStartTime = this.animation.startTime = e;
+	}
+	attachTimeline({ timeline: e, observe: g }) {
+		return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, e && supportsScrollTimeline() ? (this.animation.timeline = e, noop) : g(this);
+	}
+}, unsupportedEasingFunctions = {
+	anticipate,
+	backInOut,
+	circInOut
+};
+function isUnsupportedEase(e) {
+	return e in unsupportedEasingFunctions;
+}
+function replaceStringEasing(e) {
+	typeof e.ease == "string" && isUnsupportedEase(e.ease) && (e.ease = unsupportedEasingFunctions[e.ease]);
+}
+var sampleDelta = 10, NativeAnimationExtended = class extends NativeAnimation {
+	constructor(e) {
+		replaceStringEasing(e), replaceTransitionType(e), super(e), e.startTime !== void 0 && (this.startTime = e.startTime), this.options = e;
+	}
+	updateMotionValue(e) {
+		let { motionValue: g, onUpdate: _, onComplete: v, element: y, ...b } = this.options;
+		if (!g) return;
+		if (e !== void 0) {
+			g.set(e);
+			return;
+		}
+		let x = new JSAnimation({
+			...b,
+			autoplay: !1
+		}), S = Math.max(sampleDelta, time.now() - this.startTime), C = clamp(0, sampleDelta, S - sampleDelta);
+		g.setWithVelocity(x.sample(Math.max(0, S - C)).value, x.sample(S).value, C), x.stop();
+	}
+}, isAnimatable = (e, g) => g === "zIndex" ? !1 : !!(typeof e == "number" || Array.isArray(e) || typeof e == "string" && (complex.test(e) || e === "0") && !e.startsWith("url("));
+function hasKeyframesChanged(e) {
+	let g = e[0];
+	if (e.length === 1) return !0;
+	for (let _ = 0; _ < e.length; _++) if (e[_] !== g) return !0;
+}
+function canAnimate(e, g, _, v) {
+	let y = e[0];
+	if (y === null) return !1;
+	if (g === "display" || g === "visibility") return !0;
+	let b = e[e.length - 1], x = isAnimatable(y, g), S = isAnimatable(b, g);
+	return warning(x === S, `You are trying to animate ${g} from "${y}" to "${b}". "${x ? b : y}" is not an animatable value.`, "value-not-animatable"), !x || !S ? !1 : hasKeyframesChanged(e) || (_ === "spring" || isGenerator(_)) && v;
+}
+function makeAnimationInstant(e) {
+	e.duration = 0, e.type = "keyframes";
+}
+var acceleratedValues$1 = new Set([
+	"opacity",
+	"clipPath",
+	"filter",
+	"transform"
+]), supportsWaapi = /* @__PURE__ */ memo(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function supportsBrowserAnimation(e) {
+	let { motionValue: g, name: _, repeatDelay: v, repeatType: y, damping: b, type: x } = e;
+	if (!(g?.owner?.current instanceof HTMLElement)) return !1;
+	let { onUpdate: S, transformTemplate: C } = g.owner.getProps();
+	return supportsWaapi() && _ && acceleratedValues$1.has(_) && (_ !== "transform" || !C) && !S && !v && y !== "mirror" && b !== 0 && x !== "inertia";
+}
+var MAX_RESOLVE_DELAY = 40, AsyncMotionValueAnimation = class extends WithPromise {
+	constructor({ autoplay: e = !0, delay: g = 0, type: _ = "keyframes", repeat: v = 0, repeatDelay: y = 0, repeatType: b = "loop", keyframes: x, name: S, motionValue: C, element: w, ...T }) {
+		super(), this.stop = () => {
+			this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+		}, this.createdAt = time.now();
+		let E = {
+			autoplay: e,
+			delay: g,
+			type: _,
+			repeat: v,
+			repeatDelay: y,
+			repeatType: b,
+			name: S,
+			motionValue: C,
+			element: w,
+			...T
+		};
+		this.keyframeResolver = new (w?.KeyframeResolver || KeyframeResolver)(x, (e, g, _) => this.onKeyframesResolved(e, g, E, !_), S, C, w), this.keyframeResolver?.scheduleResolve();
+	}
+	onKeyframesResolved(e, g, _, v) {
+		this.keyframeResolver = void 0;
+		let { name: y, type: b, velocity: x, delay: S, isHandoff: C, onUpdate: w } = _;
+		this.resolvedAt = time.now(), canAnimate(e, y, b, x) || ((MotionGlobalConfig.instantAnimations || !S) && w?.(getFinalKeyframe$1(e, _, g)), e[0] = e[e.length - 1], makeAnimationInstant(_), _.repeat = 0);
+		let T = {
+			startTime: v ? this.resolvedAt && this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY ? this.resolvedAt : this.createdAt : void 0,
+			finalKeyframe: g,
+			..._,
+			keyframes: e
+		}, E = !C && supportsBrowserAnimation(T), D = T.motionValue?.owner?.current, O = E ? new NativeAnimationExtended({
+			...T,
+			element: D
+		}) : new JSAnimation(T);
+		O.finished.then(() => {
+			this.notifyFinished();
+		}).catch(noop), this.pendingTimeline &&= (this.stopTimeline = O.attachTimeline(this.pendingTimeline), void 0), this._animation = O;
+	}
+	get finished() {
+		return this._animation ? this.animation.finished : this._finished;
+	}
+	then(e, g) {
+		return this.finished.finally(e).then(() => {});
+	}
+	get animation() {
+		return this._animation || (this.keyframeResolver?.resume(), flushKeyframeResolvers()), this._animation;
+	}
+	get duration() {
+		return this.animation.duration;
+	}
+	get iterationDuration() {
+		return this.animation.iterationDuration;
+	}
+	get time() {
+		return this.animation.time;
+	}
+	set time(e) {
+		this.animation.time = e;
+	}
+	get speed() {
+		return this.animation.speed;
+	}
+	get state() {
+		return this.animation.state;
+	}
+	set speed(e) {
+		this.animation.speed = e;
+	}
+	get startTime() {
+		return this.animation.startTime;
+	}
+	attachTimeline(e) {
+		return this._animation ? this.stopTimeline = this.animation.attachTimeline(e) : this.pendingTimeline = e, () => this.stop();
+	}
+	play() {
+		this.animation.play();
+	}
+	pause() {
+		this.animation.pause();
+	}
+	complete() {
+		this.animation.complete();
+	}
+	cancel() {
+		this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
+	}
+};
+function calcChildStagger(e, g, _, v = 0, y = 1) {
+	let b = Array.from(e).sort((e, g) => e.sortNodePosition(g)).indexOf(g), x = e.size, S = (x - 1) * v;
+	return typeof _ == "function" ? _(b, x) : y === 1 ? b * v : S - b * v;
+}
+var splitCSSVariableRegex = /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u;
+function parseCSSVariable(e) {
+	let g = splitCSSVariableRegex.exec(e);
+	if (!g) return [,];
+	let [, _, v, y] = g;
+	return [`--${_ ?? v}`, y];
+}
+var maxDepth = 4;
+function getVariableValue(e, g, _ = 1) {
+	invariant(_ <= maxDepth, `Max CSS variable fallback depth detected in property "${e}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+	let [v, y] = parseCSSVariable(e);
+	if (!v) return;
+	let b = window.getComputedStyle(g).getPropertyValue(v);
+	if (b) {
+		let e = b.trim();
+		return isNumericalString(e) ? parseFloat(e) : e;
+	}
+	return isCSSVariableToken(y) ? getVariableValue(y, g, _ + 1) : y;
+}
+var underDampedSpring = {
+	type: "spring",
+	stiffness: 500,
+	damping: 25,
+	restSpeed: 10
+}, criticallyDampedSpring = (e) => ({
+	type: "spring",
+	stiffness: 550,
+	damping: e === 0 ? 2 * Math.sqrt(550) : 30,
+	restSpeed: 10
+}), keyframesTransition = {
+	type: "keyframes",
+	duration: .8
+}, ease = {
+	type: "keyframes",
+	ease: [
+		.25,
+		.1,
+		.35,
+		1
+	],
+	duration: .3
+}, getDefaultTransition = (e, { keyframes: g }) => g.length > 2 ? keyframesTransition : transformProps.has(e) ? e.startsWith("scale") ? criticallyDampedSpring(g[1]) : underDampedSpring : ease, isNotNull = (e) => e !== null;
+function getFinalKeyframe(e, { repeat: g, repeatType: _ = "loop" }, v) {
+	let y = e.filter(isNotNull), b = g && _ !== "loop" && g % 2 == 1 ? 0 : y.length - 1;
+	return !b || v === void 0 ? y[b] : v;
+}
+function resolveTransition(e, g) {
+	if (e?.inherit && g) {
+		let { inherit: _, ...v } = e;
+		return {
+			...g,
+			...v
+		};
+	}
+	return e;
+}
+function getValueTransition(e, g) {
+	let _ = e?.[g] ?? e?.default ?? e;
+	return _ === e ? _ : resolveTransition(_, e);
+}
+function isTransitionDefined({ when: e, delay: g, delayChildren: _, staggerChildren: v, staggerDirection: y, repeat: b, repeatType: x, repeatDelay: S, from: C, elapsed: w, ...T }) {
+	return !!Object.keys(T).length;
+}
+var animateMotionValue = (e, g, _, v = {}, y, b) => (x) => {
+	let S = getValueTransition(v, e) || {}, C = S.delay || v.delay || 0, { elapsed: w = 0 } = v;
+	w -= /* @__PURE__ */ secondsToMilliseconds(C);
+	let T = {
+		keyframes: Array.isArray(_) ? _ : [null, _],
+		ease: "easeOut",
+		velocity: g.getVelocity(),
+		...S,
+		delay: -w,
+		onUpdate: (e) => {
+			g.set(e), S.onUpdate && S.onUpdate(e);
+		},
+		onComplete: () => {
+			x(), S.onComplete && S.onComplete();
+		},
+		name: e,
+		motionValue: g,
+		element: b ? void 0 : y
+	};
+	isTransitionDefined(S) || Object.assign(T, getDefaultTransition(e, T)), T.duration &&= /* @__PURE__ */ secondsToMilliseconds(T.duration), T.repeatDelay &&= /* @__PURE__ */ secondsToMilliseconds(T.repeatDelay), T.from !== void 0 && (T.keyframes[0] = T.from);
+	let E = !1;
+	if ((T.type === !1 || T.duration === 0 && !T.repeatDelay) && (makeAnimationInstant(T), T.delay === 0 && (E = !0)), (MotionGlobalConfig.instantAnimations || MotionGlobalConfig.skipAnimations || y?.shouldSkipAnimations) && (E = !0, makeAnimationInstant(T), T.delay = 0), T.allowFlatten = !S.type && !S.ease, E && !b && g.get() !== void 0) {
+		let e = getFinalKeyframe(T.keyframes, S);
+		if (e !== void 0) {
+			frame.update(() => {
+				T.onUpdate(e), T.onComplete();
+			});
+			return;
+		}
+	}
+	return S.isSync ? new JSAnimation(T) : new AsyncMotionValueAnimation(T);
+};
+function getValueState(e) {
+	let g = [{}, {}];
+	return e?.values.forEach((e, _) => {
+		g[0][_] = e.get(), g[1][_] = e.getVelocity();
+	}), g;
+}
+function resolveVariantFromProps(e, g, _, v) {
+	if (typeof g == "function") {
+		let [y, b] = getValueState(v);
+		g = g(_ === void 0 ? e.custom : _, y, b);
+	}
+	if (typeof g == "string" && (g = e.variants && e.variants[g]), typeof g == "function") {
+		let [y, b] = getValueState(v);
+		g = g(_ === void 0 ? e.custom : _, y, b);
+	}
+	return g;
+}
+function resolveVariant(e, g, _) {
+	let v = e.getProps();
+	return resolveVariantFromProps(v, g, _ === void 0 ? v.custom : _, e);
+}
+var positionalKeys = new Set([
+	"width",
+	"height",
+	"top",
+	"left",
+	"right",
+	"bottom",
+	...transformPropOrder
+]), MAX_VELOCITY_DELTA = 30, isFloat = (e) => !isNaN(parseFloat(e)), collectMotionValues = { current: void 0 }, MotionValue = class {
+	constructor(e, g = {}) {
+		this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (e) => {
+			let g = time.now();
+			if (this.updatedAt !== g && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(e), this.current !== this.prev && (this.events.change?.notify(this.current), this.dependents)) for (let e of this.dependents) e.dirty();
+		}, this.hasAnimated = !1, this.setCurrent(e), this.owner = g.owner;
+	}
+	setCurrent(e) {
+		this.current = e, this.updatedAt = time.now(), this.canTrackVelocity === null && e !== void 0 && (this.canTrackVelocity = isFloat(this.current));
+	}
+	setPrevFrameValue(e = this.current) {
+		this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt;
+	}
+	onChange(e) {
+		return process.env.NODE_ENV !== "production" && warnOnce(!1, "value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback)."), this.on("change", e);
+	}
+	on(e, g) {
+		this.events[e] || (this.events[e] = new SubscriptionManager());
+		let _ = this.events[e].add(g);
+		return e === "change" ? () => {
+			_(), frame.read(() => {
+				this.events.change.getSize() || this.stop();
+			});
+		} : _;
+	}
+	clearListeners() {
+		for (let e in this.events) this.events[e].clear();
+	}
+	attach(e, g) {
+		this.passiveEffect = e, this.stopPassiveEffect = g;
+	}
+	set(e) {
+		this.passiveEffect ? this.passiveEffect(e, this.updateAndNotify) : this.updateAndNotify(e);
+	}
+	setWithVelocity(e, g, _) {
+		this.set(g), this.prev = void 0, this.prevFrameValue = e, this.prevUpdatedAt = this.updatedAt - _;
+	}
+	jump(e, g = !0) {
+		this.updateAndNotify(e), this.prev = e, this.prevUpdatedAt = this.prevFrameValue = void 0, g && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+	}
+	dirty() {
+		this.events.change?.notify(this.current);
+	}
+	addDependent(e) {
+		this.dependents ||= /* @__PURE__ */ new Set(), this.dependents.add(e);
+	}
+	removeDependent(e) {
+		this.dependents && this.dependents.delete(e);
+	}
+	get() {
+		return collectMotionValues.current && collectMotionValues.current.push(this), this.current;
+	}
+	getPrevious() {
+		return this.prev;
+	}
+	getVelocity() {
+		let e = time.now();
+		if (!this.canTrackVelocity || this.prevFrameValue === void 0 || e - this.updatedAt > MAX_VELOCITY_DELTA) return 0;
+		let g = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);
+		return velocityPerSecond(parseFloat(this.current) - parseFloat(this.prevFrameValue), g);
+	}
+	start(e) {
+		return this.stop(), new Promise((g) => {
+			this.hasAnimated = !0, this.animation = e(g), this.events.animationStart && this.events.animationStart.notify();
+		}).then(() => {
+			this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+		});
+	}
+	stop() {
+		this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+	}
+	isAnimating() {
+		return !!this.animation;
+	}
+	clearAnimation() {
+		delete this.animation;
+	}
+	destroy() {
+		this.dependents?.clear(), this.events.destroy?.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+	}
+};
+function motionValue(e, g) {
+	return new MotionValue(e, g);
+}
+var isKeyframesTarget = (e) => Array.isArray(e);
+function setMotionValue(e, g, _) {
+	e.hasValue(g) ? e.getValue(g).set(_) : e.addValue(g, motionValue(_));
+}
+function resolveFinalValueInKeyframes(e) {
+	return isKeyframesTarget(e) ? e[e.length - 1] || 0 : e;
+}
+function setTarget(e, g) {
+	let { transitionEnd: _ = {}, transition: v = {}, ...y } = resolveVariant(e, g) || {};
+	for (let g in y = {
+		...y,
+		..._
+	}, y) setMotionValue(e, g, resolveFinalValueInKeyframes(y[g]));
+}
+var isMotionValue = (e) => !!(e && e.getVelocity);
+function isWillChangeMotionValue(e) {
+	return !!(isMotionValue(e) && e.add);
+}
+function addValueToWillChange(e, g) {
+	let _ = e.getValue("willChange");
+	if (isWillChangeMotionValue(_)) return _.add(g);
+	if (!_ && MotionGlobalConfig.WillChange) {
+		let _ = new MotionGlobalConfig.WillChange("auto");
+		e.addValue("willChange", _), _.add(g);
+	}
+}
+function camelToDash(e) {
+	return e.replace(/([A-Z])/g, (e) => `-${e.toLowerCase()}`);
+}
+var optimizedAppearDataAttribute = "data-" + camelToDash("framerAppearId");
+function getOptimisedAppearId(e) {
+	return e.props[optimizedAppearDataAttribute];
+}
+function shouldBlockAnimation({ protectedKeys: e, needsAnimating: g }, _) {
+	let v = e.hasOwnProperty(_) && g[_] !== !0;
+	return g[_] = !1, v;
+}
+function animateTarget(e, g, { delay: _ = 0, transitionOverride: v, type: y } = {}) {
+	let { transition: b, transitionEnd: x, ...S } = g, C = e.getDefaultTransition();
+	b = b ? resolveTransition(b, C) : C;
+	let w = b?.reduceMotion;
+	v && (b = v);
+	let T = [], E = y && e.animationState && e.animationState.getState()[y];
+	for (let g in S) {
+		let v = e.getValue(g, e.latestValues[g] ?? null), y = S[g];
+		if (y === void 0 || E && shouldBlockAnimation(E, g)) continue;
+		let x = {
+			delay: _,
+			...getValueTransition(b || {}, g)
+		}, C = v.get();
+		if (C !== void 0 && !v.isAnimating && !Array.isArray(y) && y === C && !x.velocity) continue;
+		let D = !1;
+		if (window.MotionHandoffAnimation) {
+			let _ = getOptimisedAppearId(e);
+			if (_) {
+				let e = window.MotionHandoffAnimation(_, g, frame);
+				e !== null && (x.startTime = e, D = !0);
+			}
+		}
+		addValueToWillChange(e, g);
+		let O = w ?? e.shouldReduceMotion;
+		v.start(animateMotionValue(g, v, y, O && positionalKeys.has(g) ? { type: !1 } : x, e, D));
+		let k = v.animation;
+		k && T.push(k);
+	}
+	if (x) {
+		let g = () => frame.update(() => {
+			x && setTarget(e, x);
+		});
+		T.length ? Promise.all(T).then(g) : g();
+	}
+	return T;
+}
+function animateVariant(e, g, _ = {}) {
+	let v = resolveVariant(e, g, _.type === "exit" ? e.presenceContext?.custom : void 0), { transition: y = e.getDefaultTransition() || {} } = v || {};
+	_.transitionOverride && (y = _.transitionOverride);
+	let b = v ? () => Promise.all(animateTarget(e, v, _)) : () => Promise.resolve(), x = e.variantChildren && e.variantChildren.size ? (v = 0) => {
+		let { delayChildren: b = 0, staggerChildren: x, staggerDirection: S } = y;
+		return animateChildren(e, g, v, b, x, S, _);
+	} : () => Promise.resolve(), { when: S } = y;
+	if (S) {
+		let [e, g] = S === "beforeChildren" ? [b, x] : [x, b];
+		return e().then(() => g());
+	} else return Promise.all([b(), x(_.delay)]);
+}
+function animateChildren(e, g, _ = 0, v = 0, y = 0, b = 1, x) {
+	let S = [];
+	for (let C of e.variantChildren) C.notify("AnimationStart", g), S.push(animateVariant(C, g, {
+		...x,
+		delay: _ + (typeof v == "function" ? 0 : v) + calcChildStagger(e.variantChildren, C, v, y, b)
+	}).then(() => C.notify("AnimationComplete", g)));
+	return Promise.all(S);
+}
+function animateVisualElement(e, g, _ = {}) {
+	e.notify("AnimationStart", g);
+	let v;
+	if (Array.isArray(g)) {
+		let y = g.map((g) => animateVariant(e, g, _));
+		v = Promise.all(y);
+	} else if (typeof g == "string") v = animateVariant(e, g, _);
+	else {
+		let y = typeof g == "function" ? resolveVariant(e, g, _.custom) : g;
+		v = Promise.all(animateTarget(e, y, _));
+	}
+	return v.then(() => {
+		e.notify("AnimationComplete", g);
+	});
+}
+var auto = {
+	test: (e) => e === "auto",
+	parse: (e) => e
+}, testValueType = (e) => (g) => g.test(e), dimensionValueTypes = [
+	number,
+	px,
+	percent,
+	degrees,
+	vw,
+	vh,
+	auto
+], findDimensionValueType = (e) => dimensionValueTypes.find(testValueType(e));
+function isNone(e) {
+	return typeof e == "number" ? e === 0 : e === null ? !0 : e === "none" || e === "0" || isZeroValueString(e);
+}
+var maxDefaults = new Set([
+	"brightness",
+	"contrast",
+	"saturate",
+	"opacity"
+]);
+function applyDefaultFilter(e) {
+	let [g, _] = e.slice(0, -1).split("(");
+	if (g === "drop-shadow") return e;
+	let [v] = _.match(floatRegex) || [];
+	if (!v) return e;
+	let y = _.replace(v, ""), b = maxDefaults.has(g) ? 1 : 0;
+	return v !== _ && (b *= 100), g + "(" + b + y + ")";
+}
+var functionRegex = /\b([a-z-]*)\(.*?\)/gu, filter = {
+	...complex,
+	getAnimatableNone: (e) => {
+		let g = e.match(functionRegex);
+		return g ? g.map(applyDefaultFilter).join(" ") : e;
+	}
+}, int = {
+	...number,
+	transform: Math.round
+}, numberValueTypes = {
+	borderWidth: px,
+	borderTopWidth: px,
+	borderRightWidth: px,
+	borderBottomWidth: px,
+	borderLeftWidth: px,
+	borderRadius: px,
+	borderTopLeftRadius: px,
+	borderTopRightRadius: px,
+	borderBottomRightRadius: px,
+	borderBottomLeftRadius: px,
+	width: px,
+	maxWidth: px,
+	height: px,
+	maxHeight: px,
+	top: px,
+	right: px,
+	bottom: px,
+	left: px,
+	inset: px,
+	insetBlock: px,
+	insetBlockStart: px,
+	insetBlockEnd: px,
+	insetInline: px,
+	insetInlineStart: px,
+	insetInlineEnd: px,
+	padding: px,
+	paddingTop: px,
+	paddingRight: px,
+	paddingBottom: px,
+	paddingLeft: px,
+	paddingBlock: px,
+	paddingBlockStart: px,
+	paddingBlockEnd: px,
+	paddingInline: px,
+	paddingInlineStart: px,
+	paddingInlineEnd: px,
+	margin: px,
+	marginTop: px,
+	marginRight: px,
+	marginBottom: px,
+	marginLeft: px,
+	marginBlock: px,
+	marginBlockStart: px,
+	marginBlockEnd: px,
+	marginInline: px,
+	marginInlineStart: px,
+	marginInlineEnd: px,
+	fontSize: px,
+	backgroundPositionX: px,
+	backgroundPositionY: px,
+	rotate: degrees,
+	rotateX: degrees,
+	rotateY: degrees,
+	rotateZ: degrees,
+	scale,
+	scaleX: scale,
+	scaleY: scale,
+	scaleZ: scale,
+	skew: degrees,
+	skewX: degrees,
+	skewY: degrees,
+	distance: px,
+	translateX: px,
+	translateY: px,
+	translateZ: px,
+	x: px,
+	y: px,
+	z: px,
+	perspective: px,
+	transformPerspective: px,
+	opacity: alpha,
+	originX: progressPercentage,
+	originY: progressPercentage,
+	originZ: px,
+	zIndex: int,
+	fillOpacity: alpha,
+	strokeOpacity: alpha,
+	numOctaves: int
+}, defaultValueTypes = {
+	...numberValueTypes,
+	color,
+	backgroundColor: color,
+	outlineColor: color,
+	fill: color,
+	stroke: color,
+	borderColor: color,
+	borderTopColor: color,
+	borderRightColor: color,
+	borderBottomColor: color,
+	borderLeftColor: color,
+	filter,
+	WebkitFilter: filter
+}, getDefaultValueType = (e) => defaultValueTypes[e];
+function getAnimatableNone(e, g) {
+	let _ = getDefaultValueType(e);
+	return _ !== filter && (_ = complex), _.getAnimatableNone ? _.getAnimatableNone(g) : void 0;
+}
+var invalidTemplates = new Set([
+	"auto",
+	"none",
+	"0"
+]);
+function makeNoneKeyframesAnimatable(e, g, _) {
+	let v = 0, y;
+	for (; v < e.length && !y;) {
+		let g = e[v];
+		typeof g == "string" && !invalidTemplates.has(g) && analyseComplexValue(g).values.length && (y = e[v]), v++;
+	}
+	if (y && _) for (let v of g) e[v] = getAnimatableNone(_, y);
+}
+var DOMKeyframesResolver = class extends KeyframeResolver {
+	constructor(e, g, _, v, y) {
+		super(e, g, _, v, y, !0);
+	}
+	readKeyframes() {
+		let { unresolvedKeyframes: e, element: g, name: _ } = this;
+		if (!g || !g.current) return;
+		super.readKeyframes();
+		for (let _ = 0; _ < e.length; _++) {
+			let v = e[_];
+			if (typeof v == "string" && (v = v.trim(), isCSSVariableToken(v))) {
+				let y = getVariableValue(v, g.current);
+				y !== void 0 && (e[_] = y), _ === e.length - 1 && (this.finalKeyframe = v);
+			}
+		}
+		if (this.resolveNoneKeyframes(), !positionalKeys.has(_) || e.length !== 2) return;
+		let [v, y] = e, b = findDimensionValueType(v), x = findDimensionValueType(y);
+		if (containsCSSVariable(v) !== containsCSSVariable(y) && positionalValues[_]) {
+			this.needsMeasurement = !0;
+			return;
+		}
+		if (b !== x) if (isNumOrPxType(b) && isNumOrPxType(x)) for (let g = 0; g < e.length; g++) {
+			let _ = e[g];
+			typeof _ == "string" && (e[g] = parseFloat(_));
+		}
+		else positionalValues[_] && (this.needsMeasurement = !0);
+	}
+	resolveNoneKeyframes() {
+		let { unresolvedKeyframes: e, name: g } = this, _ = [];
+		for (let g = 0; g < e.length; g++) (e[g] === null || isNone(e[g])) && _.push(g);
+		_.length && makeNoneKeyframesAnimatable(e, _, g);
+	}
+	measureInitialState() {
+		let { element: e, unresolvedKeyframes: g, name: _ } = this;
+		if (!e || !e.current) return;
+		_ === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = positionalValues[_](e.measureViewportBox(), window.getComputedStyle(e.current)), g[0] = this.measuredOrigin;
+		let v = g[g.length - 1];
+		v !== void 0 && e.getValue(_, v).jump(v, !1);
+	}
+	measureEndState() {
+		let { element: e, name: g, unresolvedKeyframes: _ } = this;
+		if (!e || !e.current) return;
+		let v = e.getValue(g);
+		v && v.jump(this.measuredOrigin, !1);
+		let y = _.length - 1, b = _[y];
+		_[y] = positionalValues[g](e.measureViewportBox(), window.getComputedStyle(e.current)), b !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = b), this.removedTransforms?.length && this.removedTransforms.forEach(([g, _]) => {
+			e.getValue(g).set(_);
+		}), this.resolveNoneKeyframes();
+	}
+}, acceleratedValues = new Set([
+	"opacity",
+	"clipPath",
+	"filter",
+	"transform"
+]);
+function resolveElements(e, g, _) {
+	if (e == null) return [];
+	if (e instanceof EventTarget) return [e];
+	if (typeof e == "string") {
+		let v = document;
+		g && (v = g.current);
+		let y = _?.[e] ?? v.querySelectorAll(e);
+		return y ? Array.from(y) : [];
+	}
+	return Array.from(e).filter((e) => e != null);
+}
+var getValueAsType = (e, g) => g && typeof e == "number" ? g.transform(e) : e;
+function isHTMLElement(e) {
+	return isObject(e) && "offsetHeight" in e;
+}
+var { schedule: microtask, cancel: cancelMicrotask } = /* @__PURE__ */ createRenderBatcher(queueMicrotask, !1), isDragging = {
+	x: !1,
+	y: !1
+};
+function isDragActive() {
+	return isDragging.x || isDragging.y;
+}
+function setDragLock(e) {
+	return e === "x" || e === "y" ? isDragging[e] ? null : (isDragging[e] = !0, () => {
+		isDragging[e] = !1;
+	}) : isDragging.x || isDragging.y ? null : (isDragging.x = isDragging.y = !0, () => {
+		isDragging.x = isDragging.y = !1;
+	});
+}
+function setupGesture(e, g) {
+	let _ = resolveElements(e), v = new AbortController();
+	return [
+		_,
+		{
+			passive: !0,
+			...g,
+			signal: v.signal
+		},
+		() => v.abort()
+	];
+}
+function isValidHover(e) {
+	return !(e.pointerType === "touch" || isDragActive());
+}
+function hover(e, g, _ = {}) {
+	let [v, y, b] = setupGesture(e, _);
+	return v.forEach((e) => {
+		let _ = !1, v = !1, b, x = () => {
+			e.removeEventListener("pointerleave", T);
+		}, S = (e) => {
+			b &&= (b(e), void 0), x();
+		}, C = (e) => {
+			_ = !1, window.removeEventListener("pointerup", C), window.removeEventListener("pointercancel", C), v && (v = !1, S(e));
+		}, w = () => {
+			_ = !0, window.addEventListener("pointerup", C, y), window.addEventListener("pointercancel", C, y);
+		}, T = (e) => {
+			if (e.pointerType !== "touch") {
+				if (_) {
+					v = !0;
+					return;
+				}
+				S(e);
+			}
+		};
+		e.addEventListener("pointerenter", (_) => {
+			if (!isValidHover(_)) return;
+			v = !1;
+			let x = g(e, _);
+			typeof x == "function" && (b = x, e.addEventListener("pointerleave", T, y));
+		}, y), e.addEventListener("pointerdown", w, y);
+	}), b;
+}
+var isNodeOrChild = (e, g) => g ? e === g ? !0 : isNodeOrChild(e, g.parentElement) : !1, isPrimaryPointer = (e) => e.pointerType === "mouse" ? typeof e.button != "number" || e.button <= 0 : e.isPrimary !== !1, keyboardAccessibleElements = new Set([
+	"BUTTON",
+	"INPUT",
+	"SELECT",
+	"TEXTAREA",
+	"A"
+]);
+function isElementKeyboardAccessible(e) {
+	return keyboardAccessibleElements.has(e.tagName) || e.isContentEditable === !0;
+}
+var textInputElements = new Set([
+	"INPUT",
+	"SELECT",
+	"TEXTAREA"
+]);
+function isElementTextInput(e) {
+	return textInputElements.has(e.tagName) || e.isContentEditable === !0;
+}
+var isPressing = /* @__PURE__ */ new WeakSet();
+function filterEvents(e) {
+	return (g) => {
+		g.key === "Enter" && e(g);
+	};
+}
+function firePointerEvent(e, g) {
+	e.dispatchEvent(new PointerEvent("pointer" + g, {
+		isPrimary: !0,
+		bubbles: !0
+	}));
+}
+var enableKeyboardPress = (e, g) => {
+	let _ = e.currentTarget;
+	if (!_) return;
+	let v = filterEvents(() => {
+		if (isPressing.has(_)) return;
+		firePointerEvent(_, "down");
+		let e = filterEvents(() => {
+			firePointerEvent(_, "up");
+		});
+		_.addEventListener("keyup", e, g), _.addEventListener("blur", () => firePointerEvent(_, "cancel"), g);
+	});
+	_.addEventListener("keydown", v, g), _.addEventListener("blur", () => _.removeEventListener("keydown", v), g);
+};
+function isValidPressEvent(e) {
+	return isPrimaryPointer(e) && !isDragActive();
+}
+var claimedPointerDownEvents = /* @__PURE__ */ new WeakSet();
+function press(e, g, _ = {}) {
+	let [v, y, b] = setupGesture(e, _), x = (e) => {
+		let v = e.currentTarget;
+		if (!isValidPressEvent(e) || claimedPointerDownEvents.has(e)) return;
+		isPressing.add(v), _.stopPropagation && claimedPointerDownEvents.add(e);
+		let b = g(v, e), x = (e, g) => {
+			window.removeEventListener("pointerup", S), window.removeEventListener("pointercancel", C), isPressing.has(v) && isPressing.delete(v), isValidPressEvent(e) && typeof b == "function" && b(e, { success: g });
+		}, S = (e) => {
+			x(e, v === window || v === document || _.useGlobalTarget || isNodeOrChild(v, e.target));
+		}, C = (e) => {
+			x(e, !1);
+		};
+		window.addEventListener("pointerup", S, y), window.addEventListener("pointercancel", C, y);
+	};
+	return v.forEach((e) => {
+		(_.useGlobalTarget ? window : e).addEventListener("pointerdown", x, y), isHTMLElement(e) && (e.addEventListener("focus", (e) => enableKeyboardPress(e, y)), !isElementKeyboardAccessible(e) && !e.hasAttribute("tabindex") && (e.tabIndex = 0));
+	}), b;
+}
+function isSVGElement(e) {
+	return isObject(e) && "ownerSVGElement" in e;
+}
+var resizeHandlers = /* @__PURE__ */ new WeakMap(), observer, getSize = (e, g, _) => (v, y) => y && y[0] ? y[0][e + "Size"] : isSVGElement(v) && "getBBox" in v ? v.getBBox()[g] : v[_], getWidth = /* @__PURE__ */ getSize("inline", "width", "offsetWidth"), getHeight = /* @__PURE__ */ getSize("block", "height", "offsetHeight");
+function notifyTarget({ target: e, borderBoxSize: g }) {
+	resizeHandlers.get(e)?.forEach((_) => {
+		_(e, {
+			get width() {
+				return getWidth(e, g);
+			},
+			get height() {
+				return getHeight(e, g);
+			}
+		});
+	});
+}
+function notifyAll(e) {
+	e.forEach(notifyTarget);
+}
+function createResizeObserver() {
+	typeof ResizeObserver > "u" || (observer = new ResizeObserver(notifyAll));
+}
+function resizeElement(e, g) {
+	observer || createResizeObserver();
+	let _ = resolveElements(e);
+	return _.forEach((e) => {
+		let _ = resizeHandlers.get(e);
+		_ || (_ = /* @__PURE__ */ new Set(), resizeHandlers.set(e, _)), _.add(g), observer?.observe(e);
+	}), () => {
+		_.forEach((e) => {
+			let _ = resizeHandlers.get(e);
+			_?.delete(g), _?.size || observer?.unobserve(e);
+		});
+	};
+}
+var windowCallbacks = /* @__PURE__ */ new Set(), windowResizeHandler;
+function createWindowResizeHandler() {
+	windowResizeHandler = () => {
+		let e = {
+			get width() {
+				return window.innerWidth;
+			},
+			get height() {
+				return window.innerHeight;
+			}
+		};
+		windowCallbacks.forEach((g) => g(e));
+	}, window.addEventListener("resize", windowResizeHandler);
+}
+function resizeWindow(e) {
+	return windowCallbacks.add(e), windowResizeHandler || createWindowResizeHandler(), () => {
+		windowCallbacks.delete(e), !windowCallbacks.size && typeof windowResizeHandler == "function" && (window.removeEventListener("resize", windowResizeHandler), windowResizeHandler = void 0);
+	};
+}
+function resize(e, g) {
+	return typeof e == "function" ? resizeWindow(e) : resizeElement(e, g);
+}
+function isSVGSVGElement(e) {
+	return isSVGElement(e) && e.tagName === "svg";
+}
+var valueTypes = [
+	...dimensionValueTypes,
+	color,
+	complex
+], findValueType = (e) => valueTypes.find(testValueType(e)), createAxisDelta = () => ({
+	translate: 0,
+	scale: 1,
+	origin: 0,
+	originPoint: 0
+}), createDelta = () => ({
+	x: createAxisDelta(),
+	y: createAxisDelta()
+}), createAxis = () => ({
+	min: 0,
+	max: 0
+}), createBox = () => ({
+	x: createAxis(),
+	y: createAxis()
+}), visualElementStore = /* @__PURE__ */ new WeakMap();
+function isAnimationControls(e) {
+	return typeof e == "object" && !!e && typeof e.start == "function";
+}
+function isVariantLabel(e) {
+	return typeof e == "string" || Array.isArray(e);
+}
+var variantPriorityOrder = [
+	"animate",
+	"whileInView",
+	"whileFocus",
+	"whileHover",
+	"whileTap",
+	"whileDrag",
+	"exit"
+], variantProps = ["initial", ...variantPriorityOrder];
+function isControllingVariants(e) {
+	return isAnimationControls(e.animate) || variantProps.some((g) => isVariantLabel(e[g]));
+}
+function isVariantNode(e) {
+	return !!(isControllingVariants(e) || e.variants);
+}
+function updateMotionValuesFromProps(e, g, _) {
+	for (let v in g) {
+		let y = g[v], b = _[v];
+		if (isMotionValue(y)) e.addValue(v, y);
+		else if (isMotionValue(b)) e.addValue(v, motionValue(y, { owner: e }));
+		else if (b !== y) if (e.hasValue(v)) {
+			let g = e.getValue(v);
+			g.liveStyle === !0 ? g.jump(y) : g.hasAnimated || g.set(y);
+		} else {
+			let g = e.getStaticValue(v);
+			e.addValue(v, motionValue(g === void 0 ? y : g, { owner: e }));
+		}
+	}
+	for (let v in _) g[v] === void 0 && e.removeValue(v);
+	return g;
+}
+var prefersReducedMotion = { current: null }, hasReducedMotionListener = { current: !1 }, isBrowser$1 = typeof window < "u";
+function initPrefersReducedMotion() {
+	if (hasReducedMotionListener.current = !0, isBrowser$1) if (window.matchMedia) {
+		let e = window.matchMedia("(prefers-reduced-motion)"), g = () => prefersReducedMotion.current = e.matches;
+		e.addEventListener("change", g), g();
+	} else prefersReducedMotion.current = !1;
+}
+var propEventHandlers = [
+	"AnimationStart",
+	"AnimationComplete",
+	"Update",
+	"BeforeLayoutMeasure",
+	"LayoutMeasure",
+	"LayoutAnimationStart",
+	"LayoutAnimationComplete"
+], featureDefinitions = {};
+function setFeatureDefinitions(e) {
+	featureDefinitions = e;
+}
+function getFeatureDefinitions() {
+	return featureDefinitions;
+}
+var VisualElement = class {
+	scrapeMotionValuesFromProps(e, g, _) {
+		return {};
+	}
+	constructor({ parent: e, props: g, presenceContext: _, reducedMotionConfig: v, skipAnimations: y, blockInitialAnimation: b, visualState: x }, S = {}) {
+		this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.shouldSkipAnimations = !1, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = KeyframeResolver, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.hasBeenMounted = !1, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+			this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+		}, this.renderScheduledAt = 0, this.scheduleRender = () => {
+			let e = time.now();
+			this.renderScheduledAt < e && (this.renderScheduledAt = e, frame.render(this.render, !1, !0));
+		};
+		let { latestValues: C, renderState: w } = x;
+		this.latestValues = C, this.baseTarget = { ...C }, this.initialValues = g.initial ? { ...C } : {}, this.renderState = w, this.parent = e, this.props = g, this.presenceContext = _, this.depth = e ? e.depth + 1 : 0, this.reducedMotionConfig = v, this.skipAnimationsConfig = y, this.options = S, this.blockInitialAnimation = !!b, this.isControllingVariants = isControllingVariants(g), this.isVariantNode = isVariantNode(g), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(e && e.current);
+		let { willChange: T, ...E } = this.scrapeMotionValuesFromProps(g, {}, this);
+		for (let e in E) {
+			let g = E[e];
+			C[e] !== void 0 && isMotionValue(g) && g.set(C[e]);
+		}
+	}
+	mount(e) {
+		if (this.hasBeenMounted) for (let e in this.initialValues) this.values.get(e)?.jump(this.initialValues[e]), this.latestValues[e] = this.initialValues[e];
+		this.current = e, visualElementStore.set(e, this), this.projection && !this.projection.instance && this.projection.mount(e), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((e, g) => this.bindToMotionValue(g, e)), this.reducedMotionConfig === "never" ? this.shouldReduceMotion = !1 : this.reducedMotionConfig === "always" ? this.shouldReduceMotion = !0 : (hasReducedMotionListener.current || initPrefersReducedMotion(), this.shouldReduceMotion = prefersReducedMotion.current), process.env.NODE_ENV !== "production" && warnOnce(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled"), this.shouldSkipAnimations = this.skipAnimationsConfig ?? !1, this.parent?.addChild(this), this.update(this.props, this.presenceContext), this.hasBeenMounted = !0;
+	}
+	unmount() {
+		for (let e in this.projection && this.projection.unmount(), cancelFrame(this.notifyUpdate), cancelFrame(this.render), this.valueSubscriptions.forEach((e) => e()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent?.removeChild(this), this.events) this.events[e].clear();
+		for (let e in this.features) {
+			let g = this.features[e];
+			g && (g.unmount(), g.isMounted = !1);
+		}
+		this.current = null;
+	}
+	addChild(e) {
+		this.children.add(e), this.enteringChildren ??= /* @__PURE__ */ new Set(), this.enteringChildren.add(e);
+	}
+	removeChild(e) {
+		this.children.delete(e), this.enteringChildren && this.enteringChildren.delete(e);
+	}
+	bindToMotionValue(e, g) {
+		if (this.valueSubscriptions.has(e) && this.valueSubscriptions.get(e)(), g.accelerate && acceleratedValues.has(e) && this.current instanceof HTMLElement) {
+			let { factory: _, keyframes: v, times: y, ease: b, duration: x } = g.accelerate, S = new NativeAnimation({
+				element: this.current,
+				name: e,
+				keyframes: v,
+				times: y,
+				ease: b,
+				duration: /* @__PURE__ */ secondsToMilliseconds(x)
+			}), C = _(S);
+			this.valueSubscriptions.set(e, () => {
+				C(), S.cancel();
+			});
+			return;
+		}
+		let _ = transformProps.has(e);
+		_ && this.onBindTransform && this.onBindTransform();
+		let v = g.on("change", (g) => {
+			this.latestValues[e] = g, this.props.onUpdate && frame.preRender(this.notifyUpdate), _ && this.projection && (this.projection.isTransformDirty = !0), this.scheduleRender();
+		}), y;
+		typeof window < "u" && window.MotionCheckAppearSync && (y = window.MotionCheckAppearSync(this, e, g)), this.valueSubscriptions.set(e, () => {
+			v(), y && y(), g.owner && g.stop();
+		});
+	}
+	sortNodePosition(e) {
+		return !this.current || !this.sortInstanceNodePosition || this.type !== e.type ? 0 : this.sortInstanceNodePosition(this.current, e.current);
+	}
+	updateFeatures() {
+		let e = "animation";
+		for (e in featureDefinitions) {
+			let g = featureDefinitions[e];
+			if (!g) continue;
+			let { isEnabled: _, Feature: v } = g;
+			if (!this.features[e] && v && _(this.props) && (this.features[e] = new v(this)), this.features[e]) {
+				let g = this.features[e];
+				g.isMounted ? g.update() : (g.mount(), g.isMounted = !0);
+			}
+		}
+	}
+	triggerBuild() {
+		this.build(this.renderState, this.latestValues, this.props);
+	}
+	measureViewportBox() {
+		return this.current ? this.measureInstanceViewportBox(this.current, this.props) : createBox();
+	}
+	getStaticValue(e) {
+		return this.latestValues[e];
+	}
+	setStaticValue(e, g) {
+		this.latestValues[e] = g;
+	}
+	update(e, g) {
+		(e.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = e, this.prevPresenceContext = this.presenceContext, this.presenceContext = g;
+		for (let g = 0; g < propEventHandlers.length; g++) {
+			let _ = propEventHandlers[g];
+			this.propEventSubscriptions[_] && (this.propEventSubscriptions[_](), delete this.propEventSubscriptions[_]);
+			let v = e["on" + _];
+			v && (this.propEventSubscriptions[_] = this.on(_, v));
+		}
+		this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(e, this.prevProps || {}, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+	}
+	getProps() {
+		return this.props;
+	}
+	getVariant(e) {
+		return this.props.variants ? this.props.variants[e] : void 0;
+	}
+	getDefaultTransition() {
+		return this.props.transition;
+	}
+	getTransformPagePoint() {
+		return this.props.transformPagePoint;
+	}
+	getClosestVariantNode() {
+		return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+	}
+	addVariantChild(e) {
+		let g = this.getClosestVariantNode();
+		if (g) return g.variantChildren && g.variantChildren.add(e), () => g.variantChildren.delete(e);
+	}
+	addValue(e, g) {
+		let _ = this.values.get(e);
+		g !== _ && (_ && this.removeValue(e), this.bindToMotionValue(e, g), this.values.set(e, g), this.latestValues[e] = g.get());
+	}
+	removeValue(e) {
+		this.values.delete(e);
+		let g = this.valueSubscriptions.get(e);
+		g && (g(), this.valueSubscriptions.delete(e)), delete this.latestValues[e], this.removeValueFromRenderState(e, this.renderState);
+	}
+	hasValue(e) {
+		return this.values.has(e);
+	}
+	getValue(e, g) {
+		if (this.props.values && this.props.values[e]) return this.props.values[e];
+		let _ = this.values.get(e);
+		return _ === void 0 && g !== void 0 && (_ = motionValue(g === null ? void 0 : g, { owner: this }), this.addValue(e, _)), _;
+	}
+	readValue(e, g) {
+		let _ = this.latestValues[e] !== void 0 || !this.current ? this.latestValues[e] : this.getBaseTargetFromProps(this.props, e) ?? this.readValueFromInstance(this.current, e, this.options);
+		return _ != null && (typeof _ == "string" && (isNumericalString(_) || isZeroValueString(_)) ? _ = parseFloat(_) : !findValueType(_) && complex.test(g) && (_ = getAnimatableNone(e, g)), this.setBaseTarget(e, isMotionValue(_) ? _.get() : _)), isMotionValue(_) ? _.get() : _;
+	}
+	setBaseTarget(e, g) {
+		this.baseTarget[e] = g;
+	}
+	getBaseTarget(e) {
+		let { initial: g } = this.props, _;
+		if (typeof g == "string" || typeof g == "object") {
+			let v = resolveVariantFromProps(this.props, g, this.presenceContext?.custom);
+			v && (_ = v[e]);
+		}
+		if (g && _ !== void 0) return _;
+		let v = this.getBaseTargetFromProps(this.props, e);
+		return v !== void 0 && !isMotionValue(v) ? v : this.initialValues[e] !== void 0 && _ === void 0 ? void 0 : this.baseTarget[e];
+	}
+	on(e, g) {
+		return this.events[e] || (this.events[e] = new SubscriptionManager()), this.events[e].add(g);
+	}
+	notify(e, ...g) {
+		this.events[e] && this.events[e].notify(...g);
+	}
+	scheduleRenderMicrotask() {
+		microtask.render(this.render);
+	}
+}, DOMVisualElement = class extends VisualElement {
+	constructor() {
+		super(...arguments), this.KeyframeResolver = DOMKeyframesResolver;
+	}
+	sortInstanceNodePosition(e, g) {
+		return e.compareDocumentPosition(g) & 2 ? 1 : -1;
+	}
+	getBaseTargetFromProps(e, g) {
+		let _ = e.style;
+		return _ ? _[g] : void 0;
+	}
+	removeValueFromRenderState(e, { vars: g, style: _ }) {
+		delete g[e], delete _[e];
+	}
+	handleChildMotionValue() {
+		this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+		let { children: e } = this.props;
+		isMotionValue(e) && (this.childSubscription = e.on("change", (e) => {
+			this.current && (this.current.textContent = `${e}`);
+		}));
+	}
+}, Feature = class {
+	constructor(e) {
+		this.isMounted = !1, this.node = e;
+	}
+	update() {}
+};
+function convertBoundingBoxToBox({ top: e, left: g, right: _, bottom: v }) {
+	return {
+		x: {
+			min: g,
+			max: _
+		},
+		y: {
+			min: e,
+			max: v
+		}
+	};
+}
+function convertBoxToBoundingBox({ x: e, y: g }) {
+	return {
+		top: g.min,
+		right: e.max,
+		bottom: g.max,
+		left: e.min
+	};
+}
+function transformBoxPoints(e, g) {
+	if (!g) return e;
+	let _ = g({
+		x: e.left,
+		y: e.top
+	}), v = g({
+		x: e.right,
+		y: e.bottom
+	});
+	return {
+		top: _.y,
+		left: _.x,
+		bottom: v.y,
+		right: v.x
+	};
+}
+function isIdentityScale(e) {
+	return e === void 0 || e === 1;
+}
+function hasScale({ scale: e, scaleX: g, scaleY: _ }) {
+	return !isIdentityScale(e) || !isIdentityScale(g) || !isIdentityScale(_);
+}
+function hasTransform(e) {
+	return hasScale(e) || has2DTranslate(e) || e.z || e.rotate || e.rotateX || e.rotateY || e.skewX || e.skewY;
+}
+function has2DTranslate(e) {
+	return is2DTranslate(e.x) || is2DTranslate(e.y);
+}
+function is2DTranslate(e) {
+	return e && e !== "0%";
+}
+function scalePoint(e, g, _) {
+	return _ + g * (e - _);
+}
+function applyPointDelta(e, g, _, v, y) {
+	return y !== void 0 && (e = scalePoint(e, y, v)), scalePoint(e, _, v) + g;
+}
+function applyAxisDelta(e, g = 0, _ = 1, v, y) {
+	e.min = applyPointDelta(e.min, g, _, v, y), e.max = applyPointDelta(e.max, g, _, v, y);
+}
+function applyBoxDelta(e, { x: g, y: _ }) {
+	applyAxisDelta(e.x, g.translate, g.scale, g.originPoint), applyAxisDelta(e.y, _.translate, _.scale, _.originPoint);
+}
+var TREE_SCALE_SNAP_MIN = .999999999999, TREE_SCALE_SNAP_MAX = 1.0000000000001;
+function applyTreeDeltas(e, g, _, v = !1) {
+	let y = _.length;
+	if (!y) return;
+	g.x = g.y = 1;
+	let b, x;
+	for (let S = 0; S < y; S++) {
+		b = _[S], x = b.projectionDelta;
+		let { visualElement: y } = b.options;
+		y && y.props.style && y.props.style.display === "contents" || (v && b.options.layoutScroll && b.scroll && b !== b.root && transformBox(e, {
+			x: -b.scroll.offset.x,
+			y: -b.scroll.offset.y
+		}), x && (g.x *= x.x.scale, g.y *= x.y.scale, applyBoxDelta(e, x)), v && hasTransform(b.latestValues) && transformBox(e, b.latestValues));
+	}
+	g.x < TREE_SCALE_SNAP_MAX && g.x > TREE_SCALE_SNAP_MIN && (g.x = 1), g.y < TREE_SCALE_SNAP_MAX && g.y > TREE_SCALE_SNAP_MIN && (g.y = 1);
+}
+function translateAxis(e, g) {
+	e.min += g, e.max += g;
+}
+function transformAxis(e, g, _, v, y = .5) {
+	applyAxisDelta(e, g, _, mixNumber(e.min, e.max, y), v);
+}
+function transformBox(e, g) {
+	transformAxis(e.x, g.x, g.scaleX, g.scale, g.originX), transformAxis(e.y, g.y, g.scaleY, g.scale, g.originY);
+}
+function measureViewportBox(e, g) {
+	return convertBoundingBoxToBox(transformBoxPoints(e.getBoundingClientRect(), g));
+}
+function measurePageBox(e, g, _) {
+	let v = measureViewportBox(e, _), { scroll: y } = g;
+	return y && (translateAxis(v.x, y.offset.x), translateAxis(v.y, y.offset.y)), v;
+}
+var translateAlias = {
+	x: "translateX",
+	y: "translateY",
+	z: "translateZ",
+	transformPerspective: "perspective"
+}, numTransforms = transformPropOrder.length;
+function buildTransform(e, g, _) {
+	let v = "", y = !0;
+	for (let b = 0; b < numTransforms; b++) {
+		let x = transformPropOrder[b], S = e[x];
+		if (S === void 0) continue;
+		let C = !0;
+		if (typeof S == "number") C = S === (x.startsWith("scale") ? 1 : 0);
+		else {
+			let e = parseFloat(S);
+			C = x.startsWith("scale") ? e === 1 : e === 0;
+		}
+		if (!C || _) {
+			let e = getValueAsType(S, numberValueTypes[x]);
+			if (!C) {
+				y = !1;
+				let g = translateAlias[x] || x;
+				v += `${g}(${e}) `;
+			}
+			_ && (g[x] = e);
+		}
+	}
+	return v = v.trim(), _ ? v = _(g, y ? "" : v) : y && (v = "none"), v;
+}
+function buildHTMLStyles(e, g, _) {
+	let { style: v, vars: y, transformOrigin: b } = e, x = !1, S = !1;
+	for (let e in g) {
+		let _ = g[e];
+		if (transformProps.has(e)) {
+			x = !0;
+			continue;
+		} else if (isCSSVariableName(e)) {
+			y[e] = _;
+			continue;
+		} else {
+			let g = getValueAsType(_, numberValueTypes[e]);
+			e.startsWith("origin") ? (S = !0, b[e] = g) : v[e] = g;
+		}
+	}
+	if (g.transform || (x || _ ? v.transform = buildTransform(g, e.transform, _) : v.transform &&= "none"), S) {
+		let { originX: e = "50%", originY: g = "50%", originZ: _ = 0 } = b;
+		v.transformOrigin = `${e} ${g} ${_}`;
+	}
+}
+function renderHTML(e, { style: g, vars: _ }, v, y) {
+	let b = e.style, x;
+	for (x in g) b[x] = g[x];
+	for (x in y?.applyProjectionStyles(b, v), _) b.setProperty(x, _[x]);
+}
+function pixelsToPercent(e, g) {
+	return g.max === g.min ? 0 : e / (g.max - g.min) * 100;
+}
+var correctBorderRadius = { correct: (e, g) => {
+	if (!g.target) return e;
+	if (typeof e == "string") if (px.test(e)) e = parseFloat(e);
+	else return e;
+	return `${pixelsToPercent(e, g.target.x)}% ${pixelsToPercent(e, g.target.y)}%`;
+} }, correctBoxShadow = { correct: (e, { treeScale: g, projectionDelta: _ }) => {
+	let v = e, y = complex.parse(e);
+	if (y.length > 5) return v;
+	let b = complex.createTransformer(e), x = typeof y[0] == "number" ? 0 : 1, S = _.x.scale * g.x, C = _.y.scale * g.y;
+	y[0 + x] /= S, y[1 + x] /= C;
+	let w = mixNumber(S, C, .5);
+	return typeof y[2 + x] == "number" && (y[2 + x] /= w), typeof y[3 + x] == "number" && (y[3 + x] /= w), b(y);
+} }, scaleCorrectors = {
+	borderRadius: {
+		...correctBorderRadius,
+		applyTo: [
+			"borderTopLeftRadius",
+			"borderTopRightRadius",
+			"borderBottomLeftRadius",
+			"borderBottomRightRadius"
+		]
+	},
+	borderTopLeftRadius: correctBorderRadius,
+	borderTopRightRadius: correctBorderRadius,
+	borderBottomLeftRadius: correctBorderRadius,
+	borderBottomRightRadius: correctBorderRadius,
+	boxShadow: correctBoxShadow
+};
+function isForcedMotionValue(e, { layout: g, layoutId: _ }) {
+	return transformProps.has(e) || e.startsWith("origin") || (g || _ !== void 0) && (!!scaleCorrectors[e] || e === "opacity");
+}
+function scrapeMotionValuesFromProps$1(e, g, _) {
+	let v = e.style, y = g?.style, b = {};
+	if (!v) return b;
+	for (let g in v) (isMotionValue(v[g]) || y && isMotionValue(y[g]) || isForcedMotionValue(g, e) || _?.getValue(g)?.liveStyle !== void 0) && (b[g] = v[g]);
+	return b;
+}
+function getComputedStyle$1(e) {
+	return window.getComputedStyle(e);
+}
+var HTMLVisualElement = class extends DOMVisualElement {
+	constructor() {
+		super(...arguments), this.type = "html", this.renderInstance = renderHTML;
+	}
+	readValueFromInstance(e, g) {
+		if (transformProps.has(g)) return this.projection?.isProjecting ? defaultTransformValue(g) : readTransformValue(e, g);
+		{
+			let _ = getComputedStyle$1(e), v = (isCSSVariableName(g) ? _.getPropertyValue(g) : _[g]) || 0;
+			return typeof v == "string" ? v.trim() : v;
+		}
+	}
+	measureInstanceViewportBox(e, { transformPagePoint: g }) {
+		return measureViewportBox(e, g);
+	}
+	build(e, g, _) {
+		buildHTMLStyles(e, g, _.transformTemplate);
+	}
+	scrapeMotionValuesFromProps(e, g, _) {
+		return scrapeMotionValuesFromProps$1(e, g, _);
+	}
+}, dashKeys = {
+	offset: "stroke-dashoffset",
+	array: "stroke-dasharray"
+}, camelKeys = {
+	offset: "strokeDashoffset",
+	array: "strokeDasharray"
+};
+function buildSVGPath(e, g, _ = 1, v = 0, y = !0) {
+	e.pathLength = 1;
+	let b = y ? dashKeys : camelKeys;
+	e[b.offset] = `${-v}`, e[b.array] = `${g} ${_}`;
+}
+var cssMotionPathProperties = [
+	"offsetDistance",
+	"offsetPath",
+	"offsetRotate",
+	"offsetAnchor"
+];
+function buildSVGAttrs(e, { attrX: g, attrY: _, attrScale: v, pathLength: y, pathSpacing: b = 1, pathOffset: x = 0, ...S }, C, w, T) {
+	if (buildHTMLStyles(e, S, w), C) {
+		e.style.viewBox && (e.attrs.viewBox = e.style.viewBox);
+		return;
+	}
+	e.attrs = e.style, e.style = {};
+	let { attrs: E, style: D } = e;
+	E.transform && (D.transform = E.transform, delete E.transform), (D.transform || E.transformOrigin) && (D.transformOrigin = E.transformOrigin ?? "50% 50%", delete E.transformOrigin), D.transform && (D.transformBox = T?.transformBox ?? "fill-box", delete E.transformBox);
+	for (let e of cssMotionPathProperties) E[e] !== void 0 && (D[e] = E[e], delete E[e]);
+	g !== void 0 && (E.x = g), _ !== void 0 && (E.y = _), v !== void 0 && (E.scale = v), y !== void 0 && buildSVGPath(E, y, b, x, !1);
+}
+var camelCaseAttributes = new Set([
+	"baseFrequency",
+	"diffuseConstant",
+	"kernelMatrix",
+	"kernelUnitLength",
+	"keySplines",
+	"keyTimes",
+	"limitingConeAngle",
+	"markerHeight",
+	"markerWidth",
+	"numOctaves",
+	"targetX",
+	"targetY",
+	"surfaceScale",
+	"specularConstant",
+	"specularExponent",
+	"stdDeviation",
+	"tableValues",
+	"viewBox",
+	"gradientTransform",
+	"pathLength",
+	"startOffset",
+	"textLength",
+	"lengthAdjust"
+]), isSVGTag = (e) => typeof e == "string" && e.toLowerCase() === "svg";
+function renderSVG(e, g, _, v) {
+	for (let _ in renderHTML(e, g, void 0, v), g.attrs) e.setAttribute(camelCaseAttributes.has(_) ? _ : camelToDash(_), g.attrs[_]);
+}
+function scrapeMotionValuesFromProps(e, g, _) {
+	let v = scrapeMotionValuesFromProps$1(e, g, _);
+	for (let _ in e) if (isMotionValue(e[_]) || isMotionValue(g[_])) {
+		let g = transformPropOrder.indexOf(_) === -1 ? _ : "attr" + _.charAt(0).toUpperCase() + _.substring(1);
+		v[g] = e[_];
+	}
+	return v;
+}
+var SVGVisualElement = class extends DOMVisualElement {
+	constructor() {
+		super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = createBox;
+	}
+	getBaseTargetFromProps(e, g) {
+		return e[g];
+	}
+	readValueFromInstance(e, g) {
+		if (transformProps.has(g)) {
+			let e = getDefaultValueType(g);
+			return e && e.default || 0;
+		}
+		return g = camelCaseAttributes.has(g) ? g : camelToDash(g), e.getAttribute(g);
+	}
+	scrapeMotionValuesFromProps(e, g, _) {
+		return scrapeMotionValuesFromProps(e, g, _);
+	}
+	build(e, g, _) {
+		buildSVGAttrs(e, g, this.isSVGTag, _.transformTemplate, _.style);
+	}
+	renderInstance(e, g, _, v) {
+		renderSVG(e, g, _, v);
+	}
+	mount(e) {
+		this.isSVGTag = isSVGTag(e.tagName), super.mount(e);
+	}
+}, numVariantProps = variantProps.length;
+function getVariantContext(e) {
+	if (!e) return;
+	if (!e.isControllingVariants) {
+		let g = e.parent && getVariantContext(e.parent) || {};
+		return e.props.initial !== void 0 && (g.initial = e.props.initial), g;
+	}
+	let g = {};
+	for (let _ = 0; _ < numVariantProps; _++) {
+		let v = variantProps[_], y = e.props[v];
+		(isVariantLabel(y) || y === !1) && (g[v] = y);
+	}
+	return g;
+}
+function shallowCompare(e, g) {
+	if (!Array.isArray(g)) return !1;
+	let _ = g.length;
+	if (_ !== e.length) return !1;
+	for (let v = 0; v < _; v++) if (g[v] !== e[v]) return !1;
+	return !0;
+}
+var reversePriorityOrder = [...variantPriorityOrder].reverse(), numAnimationTypes = variantPriorityOrder.length;
+function createAnimateFunction(e) {
+	return (g) => Promise.all(g.map(({ animation: g, options: _ }) => animateVisualElement(e, g, _)));
+}
+function createAnimationState(e) {
+	let g = createAnimateFunction(e), _ = createState(), v = !0, y = (g) => (_, v) => {
+		let y = resolveVariant(e, v, g === "exit" ? e.presenceContext?.custom : void 0);
+		if (y) {
+			let { transition: e, transitionEnd: g, ...v } = y;
+			_ = {
+				..._,
+				...v,
+				...g
+			};
+		}
+		return _;
+	};
+	function b(_) {
+		g = _(e);
+	}
+	function x(b) {
+		let { props: x } = e, S = getVariantContext(e.parent) || {}, C = [], w = /* @__PURE__ */ new Set(), T = {}, E = Infinity;
+		for (let g = 0; g < numAnimationTypes; g++) {
+			let D = reversePriorityOrder[g], O = _[D], k = x[D] === void 0 ? S[D] : x[D], A = isVariantLabel(k), j = D === b ? O.isActive : null;
+			j === !1 && (E = g);
+			let M = k === S[D] && k !== x[D] && A;
+			if (M && v && e.manuallyAnimateOnMount && (M = !1), O.protectedKeys = { ...T }, !O.isActive && j === null || !k && !O.prevProp || isAnimationControls(k) || typeof k == "boolean") continue;
+			if (D === "exit" && O.isActive && j !== !0) {
+				O.prevResolvedValues && (T = {
+					...T,
+					...O.prevResolvedValues
+				});
+				continue;
+			}
+			let N = checkVariantsDidChange(O.prevProp, k), P = N || D === b && O.isActive && !M && A || g > E && A, F = !1, I = Array.isArray(k) ? k : [k], L = I.reduce(y(D), {});
+			j === !1 && (L = {});
+			let { prevResolvedValues: R = {} } = O, z = {
+				...R,
+				...L
+			}, B = (g) => {
+				P = !0, w.has(g) && (F = !0, w.delete(g)), O.needsAnimating[g] = !0;
+				let _ = e.getValue(g);
+				_ && (_.liveStyle = !1);
+			};
+			for (let e in z) {
+				let g = L[e], _ = R[e];
+				if (T.hasOwnProperty(e)) continue;
+				let v = !1;
+				v = isKeyframesTarget(g) && isKeyframesTarget(_) ? !shallowCompare(g, _) : g !== _, v ? g == null ? w.add(e) : B(e) : g !== void 0 && w.has(e) ? B(e) : O.protectedKeys[e] = !0;
+			}
+			O.prevProp = k, O.prevResolvedValues = L, O.isActive && (T = {
+				...T,
+				...L
+			}), v && e.blockInitialAnimation && (P = !1);
+			let V = M && N;
+			P && (!V || F) && C.push(...I.map((g) => {
+				let _ = { type: D };
+				if (typeof g == "string" && v && !V && e.manuallyAnimateOnMount && e.parent) {
+					let { parent: v } = e, y = resolveVariant(v, g);
+					if (v.enteringChildren && y) {
+						let { delayChildren: g } = y.transition || {};
+						_.delay = calcChildStagger(v.enteringChildren, e, g);
+					}
+				}
+				return {
+					animation: g,
+					options: _
+				};
+			}));
+		}
+		if (w.size) {
+			let g = {};
+			if (typeof x.initial != "boolean") {
+				let _ = resolveVariant(e, Array.isArray(x.initial) ? x.initial[0] : x.initial);
+				_ && _.transition && (g.transition = _.transition);
+			}
+			w.forEach((_) => {
+				let v = e.getBaseTarget(_), y = e.getValue(_);
+				y && (y.liveStyle = !0), g[_] = v ?? null;
+			}), C.push({ animation: g });
+		}
+		let D = !!C.length;
+		return v && (x.initial === !1 || x.initial === x.animate) && !e.manuallyAnimateOnMount && (D = !1), v = !1, D ? g(C) : Promise.resolve();
+	}
+	function S(g, v) {
+		if (_[g].isActive === v) return Promise.resolve();
+		e.variantChildren?.forEach((e) => e.animationState?.setActive(g, v)), _[g].isActive = v;
+		let y = x(g);
+		for (let e in _) _[e].protectedKeys = {};
+		return y;
+	}
+	return {
+		animateChanges: x,
+		setActive: S,
+		setAnimateFunction: b,
+		getState: () => _,
+		reset: () => {
+			_ = createState();
+		}
+	};
+}
+function checkVariantsDidChange(e, g) {
+	return typeof g == "string" ? g !== e : Array.isArray(g) ? !shallowCompare(g, e) : !1;
+}
+function createTypeState(e = !1) {
+	return {
+		isActive: e,
+		protectedKeys: {},
+		needsAnimating: {},
+		prevResolvedValues: {}
+	};
+}
+function createState() {
+	return {
+		animate: createTypeState(!0),
+		whileInView: createTypeState(),
+		whileHover: createTypeState(),
+		whileTap: createTypeState(),
+		whileDrag: createTypeState(),
+		whileFocus: createTypeState(),
+		exit: createTypeState()
+	};
+}
+function copyAxisInto(e, g) {
+	e.min = g.min, e.max = g.max;
+}
+function copyBoxInto(e, g) {
+	copyAxisInto(e.x, g.x), copyAxisInto(e.y, g.y);
+}
+function copyAxisDeltaInto(e, g) {
+	e.translate = g.translate, e.scale = g.scale, e.originPoint = g.originPoint, e.origin = g.origin;
+}
+var SCALE_PRECISION = 1e-4, SCALE_MIN = 1 - SCALE_PRECISION, SCALE_MAX = 1 + SCALE_PRECISION, TRANSLATE_PRECISION = .01, TRANSLATE_MIN = 0 - TRANSLATE_PRECISION, TRANSLATE_MAX = 0 + TRANSLATE_PRECISION;
+function calcLength(e) {
+	return e.max - e.min;
+}
+function isNear(e, g, _) {
+	return Math.abs(e - g) <= _;
+}
+function calcAxisDelta(e, g, _, v = .5) {
+	e.origin = v, e.originPoint = mixNumber(g.min, g.max, e.origin), e.scale = calcLength(_) / calcLength(g), e.translate = mixNumber(_.min, _.max, e.origin) - e.originPoint, (e.scale >= SCALE_MIN && e.scale <= SCALE_MAX || isNaN(e.scale)) && (e.scale = 1), (e.translate >= TRANSLATE_MIN && e.translate <= TRANSLATE_MAX || isNaN(e.translate)) && (e.translate = 0);
+}
+function calcBoxDelta(e, g, _, v) {
+	calcAxisDelta(e.x, g.x, _.x, v ? v.originX : void 0), calcAxisDelta(e.y, g.y, _.y, v ? v.originY : void 0);
+}
+function calcRelativeAxis(e, g, _) {
+	e.min = _.min + g.min, e.max = e.min + calcLength(g);
+}
+function calcRelativeBox(e, g, _) {
+	calcRelativeAxis(e.x, g.x, _.x), calcRelativeAxis(e.y, g.y, _.y);
+}
+function calcRelativeAxisPosition(e, g, _) {
+	e.min = g.min - _.min, e.max = e.min + calcLength(g);
+}
+function calcRelativePosition(e, g, _) {
+	calcRelativeAxisPosition(e.x, g.x, _.x), calcRelativeAxisPosition(e.y, g.y, _.y);
+}
+function removePointDelta(e, g, _, v, y) {
+	return e -= g, e = scalePoint(e, 1 / _, v), y !== void 0 && (e = scalePoint(e, 1 / y, v)), e;
+}
+function removeAxisDelta(e, g = 0, _ = 1, v = .5, y, b = e, x = e) {
+	if (percent.test(g) && (g = parseFloat(g), g = mixNumber(x.min, x.max, g / 100) - x.min), typeof g != "number") return;
+	let S = mixNumber(b.min, b.max, v);
+	e === b && (S -= g), e.min = removePointDelta(e.min, g, _, S, y), e.max = removePointDelta(e.max, g, _, S, y);
+}
+function removeAxisTransforms(e, g, [_, v, y], b, x) {
+	removeAxisDelta(e, g[_], g[v], g[y], g.scale, b, x);
+}
+var xKeys = [
+	"x",
+	"scaleX",
+	"originX"
+], yKeys = [
+	"y",
+	"scaleY",
+	"originY"
+];
+function removeBoxTransforms(e, g, _, v) {
+	removeAxisTransforms(e.x, g, xKeys, _ ? _.x : void 0, v ? v.x : void 0), removeAxisTransforms(e.y, g, yKeys, _ ? _.y : void 0, v ? v.y : void 0);
+}
+function isAxisDeltaZero(e) {
+	return e.translate === 0 && e.scale === 1;
+}
+function isDeltaZero(e) {
+	return isAxisDeltaZero(e.x) && isAxisDeltaZero(e.y);
+}
+function axisEquals(e, g) {
+	return e.min === g.min && e.max === g.max;
+}
+function boxEquals(e, g) {
+	return axisEquals(e.x, g.x) && axisEquals(e.y, g.y);
+}
+function axisEqualsRounded(e, g) {
+	return Math.round(e.min) === Math.round(g.min) && Math.round(e.max) === Math.round(g.max);
+}
+function boxEqualsRounded(e, g) {
+	return axisEqualsRounded(e.x, g.x) && axisEqualsRounded(e.y, g.y);
+}
+function aspectRatio(e) {
+	return calcLength(e.x) / calcLength(e.y);
+}
+function axisDeltaEquals(e, g) {
+	return e.translate === g.translate && e.scale === g.scale && e.originPoint === g.originPoint;
+}
+function eachAxis(e) {
+	return [e("x"), e("y")];
+}
+function buildProjectionTransform(e, g, _) {
+	let v = "", y = e.x.translate / g.x, b = e.y.translate / g.y, x = _?.z || 0;
+	if ((y || b || x) && (v = `translate3d(${y}px, ${b}px, ${x}px) `), (g.x !== 1 || g.y !== 1) && (v += `scale(${1 / g.x}, ${1 / g.y}) `), _) {
+		let { transformPerspective: e, rotate: g, rotateX: y, rotateY: b, skewX: x, skewY: S } = _;
+		e && (v = `perspective(${e}px) ${v}`), g && (v += `rotate(${g}deg) `), y && (v += `rotateX(${y}deg) `), b && (v += `rotateY(${b}deg) `), x && (v += `skewX(${x}deg) `), S && (v += `skewY(${S}deg) `);
+	}
+	let S = e.x.scale * g.x, C = e.y.scale * g.y;
+	return (S !== 1 || C !== 1) && (v += `scale(${S}, ${C})`), v || "none";
+}
+var borders = [
+	"TopLeft",
+	"TopRight",
+	"BottomLeft",
+	"BottomRight"
+], numBorders = borders.length, asNumber = (e) => typeof e == "string" ? parseFloat(e) : e, isPx = (e) => typeof e == "number" || px.test(e);
+function mixValues(e, g, _, v, y, b) {
+	y ? (e.opacity = mixNumber(0, _.opacity ?? 1, easeCrossfadeIn(v)), e.opacityExit = mixNumber(g.opacity ?? 1, 0, easeCrossfadeOut(v))) : b && (e.opacity = mixNumber(g.opacity ?? 1, _.opacity ?? 1, v));
+	for (let y = 0; y < numBorders; y++) {
+		let b = `border${borders[y]}Radius`, x = getRadius(g, b), S = getRadius(_, b);
+		x === void 0 && S === void 0 || (x ||= 0, S ||= 0, x === 0 || S === 0 || isPx(x) === isPx(S) ? (e[b] = Math.max(mixNumber(asNumber(x), asNumber(S), v), 0), (percent.test(S) || percent.test(x)) && (e[b] += "%")) : e[b] = S);
+	}
+	(g.rotate || _.rotate) && (e.rotate = mixNumber(g.rotate || 0, _.rotate || 0, v));
+}
+function getRadius(e, g) {
+	return e[g] === void 0 ? e.borderRadius : e[g];
+}
+var easeCrossfadeIn = /* @__PURE__ */ compress(0, .5, circOut), easeCrossfadeOut = /* @__PURE__ */ compress(.5, .95, noop);
+function compress(e, g, _) {
+	return (v) => v < e ? 0 : v > g ? 1 : _(/* @__PURE__ */ progress(e, g, v));
+}
+function animateSingleValue(e, g, _) {
+	let v = isMotionValue(e) ? e : motionValue(e);
+	return v.start(animateMotionValue("", v, g, _)), v.animation;
+}
+function addDomEvent(e, g, _, v = { passive: !0 }) {
+	return e.addEventListener(g, _, v), () => e.removeEventListener(g, _);
+}
+var compareByDepth = (e, g) => e.depth - g.depth, FlatTree = class {
+	constructor() {
+		this.children = [], this.isDirty = !1;
+	}
+	add(e) {
+		addUniqueItem(this.children, e), this.isDirty = !0;
+	}
+	remove(e) {
+		removeItem(this.children, e), this.isDirty = !0;
+	}
+	forEach(e) {
+		this.isDirty && this.children.sort(compareByDepth), this.isDirty = !1, this.children.forEach(e);
+	}
+};
+function delay(e, g) {
+	let _ = time.now(), v = ({ timestamp: y }) => {
+		let b = y - _;
+		b >= g && (cancelFrame(v), e(b - g));
+	};
+	return frame.setup(v, !0), () => cancelFrame(v);
+}
+function resolveMotionValue(e) {
+	return isMotionValue(e) ? e.get() : e;
+}
+var NodeStack = class {
+	constructor() {
+		this.members = [];
+	}
+	add(e) {
+		addUniqueItem(this.members, e);
+		for (let g = this.members.length - 1; g >= 0; g--) {
+			let _ = this.members[g];
+			if (_ === e || _ === this.lead || _ === this.prevLead) continue;
+			let v = _.instance;
+			v && v.isConnected === !1 && _.isPresent !== !1 && !_.snapshot && removeItem(this.members, _);
+		}
+		e.scheduleRender();
+	}
+	remove(e) {
+		if (removeItem(this.members, e), e === this.prevLead && (this.prevLead = void 0), e === this.lead) {
+			let e = this.members[this.members.length - 1];
+			e && this.promote(e);
+		}
+	}
+	relegate(e) {
+		let g = this.members.findIndex((g) => e === g);
+		if (g === 0) return !1;
+		let _;
+		for (let e = g; e >= 0; e--) {
+			let g = this.members[e], v = g.instance;
+			if (g.isPresent !== !1 && (!v || v.isConnected !== !1)) {
+				_ = g;
+				break;
+			}
+		}
+		return _ ? (this.promote(_), !0) : !1;
+	}
+	promote(e, g) {
+		let _ = this.lead;
+		if (e !== _ && (this.prevLead = _, this.lead = e, e.show(), _)) {
+			_.instance && _.scheduleRender(), e.scheduleRender();
+			let v = _.options.layoutDependency, y = e.options.layoutDependency;
+			if (!(v !== void 0 && y !== void 0 && v === y)) {
+				let v = _.instance;
+				v && v.isConnected === !1 && !_.snapshot || (e.resumeFrom = _, g && (e.resumeFrom.preserveOpacity = !0), _.snapshot && (e.snapshot = _.snapshot, e.snapshot.latestValues = _.animationValues || _.latestValues), e.root && e.root.isUpdating && (e.isLayoutDirty = !0));
+			}
+			let { crossfade: b } = e.options;
+			b === !1 && _.hide();
+		}
+	}
+	exitAnimationComplete() {
+		this.members.forEach((e) => {
+			let { options: g, resumingFrom: _ } = e;
+			g.onExitComplete && g.onExitComplete(), _ && _.options.onExitComplete && _.options.onExitComplete();
+		});
+	}
+	scheduleRender() {
+		this.members.forEach((e) => {
+			e.instance && e.scheduleRender(!1);
+		});
+	}
+	removeLeadSnapshot() {
+		this.lead && this.lead.snapshot && (this.lead.snapshot = void 0);
+	}
+}, globalProjectionState = {
+	hasAnimatedSinceResize: !0,
+	hasEverUpdated: !1
+}, metrics = {
+	nodes: 0,
+	calculatedTargetDeltas: 0,
+	calculatedProjections: 0
+}, transformAxes = [
+	"",
+	"X",
+	"Y",
+	"Z"
+], animationTarget = 1e3, id$1 = 0;
+function resetDistortingTransform(e, g, _, v) {
+	let { latestValues: y } = g;
+	y[e] && (_[e] = y[e], g.setStaticValue(e, 0), v && (v[e] = 0));
+}
+function cancelTreeOptimisedTransformAnimations(e) {
+	if (e.hasCheckedOptimisedAppear = !0, e.root === e) return;
+	let { visualElement: g } = e.options;
+	if (!g) return;
+	let _ = getOptimisedAppearId(g);
+	if (window.MotionHasOptimisedAnimation(_, "transform")) {
+		let { layout: g, layoutId: v } = e.options;
+		window.MotionCancelOptimisedAnimation(_, "transform", frame, !(g || v));
+	}
+	let { parent: v } = e;
+	v && !v.hasCheckedOptimisedAppear && cancelTreeOptimisedTransformAnimations(v);
+}
+function createProjectionNode$1({ attachResizeListener: e, defaultParent: g, measureScroll: _, checkIsScrollRoot: v, resetTransform: y }) {
+	return class {
+		constructor(e = {}, _ = g?.()) {
+			this.id = id$1++, this.animationId = 0, this.animationCommitId = 0, this.children = /* @__PURE__ */ new Set(), this.options = {}, this.isTreeAnimating = !1, this.isAnimationBlocked = !1, this.isLayoutDirty = !1, this.isProjectionDirty = !1, this.isSharedProjectionDirty = !1, this.isTransformDirty = !1, this.updateManuallyBlocked = !1, this.updateBlockedByResize = !1, this.isUpdating = !1, this.isSVG = !1, this.needsReset = !1, this.shouldResetTransform = !1, this.hasCheckedOptimisedAppear = !1, this.treeScale = {
+				x: 1,
+				y: 1
+			}, this.eventHandlers = /* @__PURE__ */ new Map(), this.hasTreeAnimated = !1, this.layoutVersion = 0, this.updateScheduled = !1, this.scheduleUpdate = () => this.update(), this.projectionUpdateScheduled = !1, this.checkUpdateFailed = () => {
+				this.isUpdating && (this.isUpdating = !1, this.clearAllSnapshots());
+			}, this.updateProjection = () => {
+				this.projectionUpdateScheduled = !1, statsBuffer.value && (metrics.nodes = metrics.calculatedTargetDeltas = metrics.calculatedProjections = 0), this.nodes.forEach(propagateDirtyNodes), this.nodes.forEach(resolveTargetDelta), this.nodes.forEach(calcProjection), this.nodes.forEach(cleanDirtyNodes), statsBuffer.addProjectionMetrics && statsBuffer.addProjectionMetrics(metrics);
+			}, this.resolvedRelativeTargetAt = 0, this.linkedParentVersion = 0, this.hasProjected = !1, this.isVisible = !0, this.animationProgress = 0, this.sharedNodes = /* @__PURE__ */ new Map(), this.latestValues = e, this.root = _ ? _.root || _ : this, this.path = _ ? [..._.path, _] : [], this.parent = _, this.depth = _ ? _.depth + 1 : 0;
+			for (let e = 0; e < this.path.length; e++) this.path[e].shouldResetTransform = !0;
+			this.root === this && (this.nodes = new FlatTree());
+		}
+		addEventListener(e, g) {
+			return this.eventHandlers.has(e) || this.eventHandlers.set(e, new SubscriptionManager()), this.eventHandlers.get(e).add(g);
+		}
+		notifyListeners(e, ...g) {
+			let _ = this.eventHandlers.get(e);
+			_ && _.notify(...g);
+		}
+		hasListeners(e) {
+			return this.eventHandlers.has(e);
+		}
+		mount(g) {
+			if (this.instance) return;
+			this.isSVG = isSVGElement(g) && !isSVGSVGElement(g), this.instance = g;
+			let { layoutId: _, layout: v, visualElement: y } = this.options;
+			if (y && !y.current && y.mount(g), this.root.nodes.add(this), this.parent && this.parent.children.add(this), this.root.hasTreeAnimated && (v || _) && (this.isLayoutDirty = !0), e) {
+				let _, v = 0, y = () => this.root.updateBlockedByResize = !1;
+				frame.read(() => {
+					v = window.innerWidth;
+				}), e(g, () => {
+					let e = window.innerWidth;
+					e !== v && (v = e, this.root.updateBlockedByResize = !0, _ && _(), _ = delay(y, 250), globalProjectionState.hasAnimatedSinceResize && (globalProjectionState.hasAnimatedSinceResize = !1, this.nodes.forEach(finishAnimation)));
+				});
+			}
+			_ && this.root.registerSharedNode(_, this), this.options.animate !== !1 && y && (_ || v) && this.addEventListener("didUpdate", ({ delta: e, hasLayoutChanged: g, hasRelativeLayoutChanged: _, layout: v }) => {
+				if (this.isTreeAnimationBlocked()) {
+					this.target = void 0, this.relativeTarget = void 0;
+					return;
+				}
+				let b = this.options.transition || y.getDefaultTransition() || defaultLayoutTransition, { onLayoutAnimationStart: x, onLayoutAnimationComplete: S } = y.getProps(), C = !this.targetLayout || !boxEqualsRounded(this.targetLayout, v), w = !g && _;
+				if (this.options.layoutRoot || this.resumeFrom || w || g && (C || !this.currentAnimation)) {
+					this.resumeFrom && (this.resumingFrom = this.resumeFrom, this.resumingFrom.resumingFrom = void 0);
+					let g = {
+						...getValueTransition(b, "layout"),
+						onPlay: x,
+						onComplete: S
+					};
+					(y.shouldReduceMotion || this.options.layoutRoot) && (g.delay = 0, g.type = !1), this.startAnimation(g), this.setAnimationOrigin(e, w);
+				} else g || finishAnimation(this), this.isLead() && this.options.onExitComplete && this.options.onExitComplete();
+				this.targetLayout = v;
+			});
+		}
+		unmount() {
+			this.options.layoutId && this.willUpdate(), this.root.nodes.remove(this);
+			let e = this.getStack();
+			e && e.remove(this), this.parent && this.parent.children.delete(this), this.instance = void 0, this.eventHandlers.clear(), cancelFrame(this.updateProjection);
+		}
+		blockUpdate() {
+			this.updateManuallyBlocked = !0;
+		}
+		unblockUpdate() {
+			this.updateManuallyBlocked = !1;
+		}
+		isUpdateBlocked() {
+			return this.updateManuallyBlocked || this.updateBlockedByResize;
+		}
+		isTreeAnimationBlocked() {
+			return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || !1;
+		}
+		startUpdate() {
+			this.isUpdateBlocked() || (this.isUpdating = !0, this.nodes && this.nodes.forEach(resetSkewAndRotation), this.animationId++);
+		}
+		getTransformTemplate() {
+			let { visualElement: e } = this.options;
+			return e && e.getProps().transformTemplate;
+		}
+		willUpdate(e = !0) {
+			if (this.root.hasTreeAnimated = !0, this.root.isUpdateBlocked()) {
+				this.options.onExitComplete && this.options.onExitComplete();
+				return;
+			}
+			if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear && cancelTreeOptimisedTransformAnimations(this), !this.root.isUpdating && this.root.startUpdate(), this.isLayoutDirty) return;
+			this.isLayoutDirty = !0;
+			for (let e = 0; e < this.path.length; e++) {
+				let g = this.path[e];
+				g.shouldResetTransform = !0, g.updateScroll("snapshot"), g.options.layoutRoot && g.willUpdate(!1);
+			}
+			let { layoutId: g, layout: _ } = this.options;
+			if (g === void 0 && !_) return;
+			let v = this.getTransformTemplate();
+			this.prevTransformTemplateValue = v ? v(this.latestValues, "") : void 0, this.updateSnapshot(), e && this.notifyListeners("willUpdate");
+		}
+		update() {
+			if (this.updateScheduled = !1, this.isUpdateBlocked()) {
+				this.unblockUpdate(), this.clearAllSnapshots(), this.nodes.forEach(clearMeasurements);
+				return;
+			}
+			if (this.animationId <= this.animationCommitId) {
+				this.nodes.forEach(clearIsLayoutDirty);
+				return;
+			}
+			this.animationCommitId = this.animationId, this.isUpdating ? (this.isUpdating = !1, this.nodes.forEach(resetTransformStyle), this.nodes.forEach(updateLayout), this.nodes.forEach(notifyLayoutUpdate)) : this.nodes.forEach(clearIsLayoutDirty), this.clearAllSnapshots();
+			let e = time.now();
+			frameData.delta = clamp(0, 1e3 / 60, e - frameData.timestamp), frameData.timestamp = e, frameData.isProcessing = !0, frameSteps.update.process(frameData), frameSteps.preRender.process(frameData), frameSteps.render.process(frameData), frameData.isProcessing = !1;
+		}
+		didUpdate() {
+			this.updateScheduled || (this.updateScheduled = !0, microtask.read(this.scheduleUpdate));
+		}
+		clearAllSnapshots() {
+			this.nodes.forEach(clearSnapshot), this.sharedNodes.forEach(removeLeadSnapshots);
+		}
+		scheduleUpdateProjection() {
+			this.projectionUpdateScheduled || (this.projectionUpdateScheduled = !0, frame.preRender(this.updateProjection, !1, !0));
+		}
+		scheduleCheckAfterUnmount() {
+			frame.postRender(() => {
+				this.isLayoutDirty ? this.root.didUpdate() : this.root.checkUpdateFailed();
+			});
+		}
+		updateSnapshot() {
+			this.snapshot || !this.instance || (this.snapshot = this.measure(), this.snapshot && !calcLength(this.snapshot.measuredBox.x) && !calcLength(this.snapshot.measuredBox.y) && (this.snapshot = void 0));
+		}
+		updateLayout() {
+			if (!this.instance || (this.updateScroll(), !(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty)) return;
+			if (this.resumeFrom && !this.resumeFrom.instance) for (let e = 0; e < this.path.length; e++) this.path[e].updateScroll();
+			let e = this.layout;
+			this.layout = this.measure(!1), this.layoutVersion++, this.layoutCorrected = createBox(), this.isLayoutDirty = !1, this.projectionDelta = void 0, this.notifyListeners("measure", this.layout.layoutBox);
+			let { visualElement: g } = this.options;
+			g && g.notify("LayoutMeasure", this.layout.layoutBox, e ? e.layoutBox : void 0);
+		}
+		updateScroll(e = "measure") {
+			let g = !!(this.options.layoutScroll && this.instance);
+			if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === e && (g = !1), g && this.instance) {
+				let g = v(this.instance);
+				this.scroll = {
+					animationId: this.root.animationId,
+					phase: e,
+					isRoot: g,
+					offset: _(this.instance),
+					wasRoot: this.scroll ? this.scroll.isRoot : g
+				};
+			}
+		}
+		resetTransform() {
+			if (!y) return;
+			let e = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout, g = this.projectionDelta && !isDeltaZero(this.projectionDelta), _ = this.getTransformTemplate(), v = _ ? _(this.latestValues, "") : void 0, b = v !== this.prevTransformTemplateValue;
+			e && this.instance && (g || hasTransform(this.latestValues) || b) && (y(this.instance, v), this.shouldResetTransform = !1, this.scheduleRender());
+		}
+		measure(e = !0) {
+			let g = this.measurePageBox(), _ = this.removeElementScroll(g);
+			return e && (_ = this.removeTransform(_)), roundBox(_), {
+				animationId: this.root.animationId,
+				measuredBox: g,
+				layoutBox: _,
+				latestValues: {},
+				source: this.id
+			};
+		}
+		measurePageBox() {
+			let { visualElement: e } = this.options;
+			if (!e) return createBox();
+			let g = e.measureViewportBox();
+			if (!(this.scroll?.wasRoot || this.path.some(checkNodeWasScrollRoot))) {
+				let { scroll: e } = this.root;
+				e && (translateAxis(g.x, e.offset.x), translateAxis(g.y, e.offset.y));
+			}
+			return g;
+		}
+		removeElementScroll(e) {
+			let g = createBox();
+			if (copyBoxInto(g, e), this.scroll?.wasRoot) return g;
+			for (let _ = 0; _ < this.path.length; _++) {
+				let v = this.path[_], { scroll: y, options: b } = v;
+				v !== this.root && y && b.layoutScroll && (y.wasRoot && copyBoxInto(g, e), translateAxis(g.x, y.offset.x), translateAxis(g.y, y.offset.y));
+			}
+			return g;
+		}
+		applyTransform(e, g = !1) {
+			let _ = createBox();
+			copyBoxInto(_, e);
+			for (let e = 0; e < this.path.length; e++) {
+				let v = this.path[e];
+				!g && v.options.layoutScroll && v.scroll && v !== v.root && transformBox(_, {
+					x: -v.scroll.offset.x,
+					y: -v.scroll.offset.y
+				}), hasTransform(v.latestValues) && transformBox(_, v.latestValues);
+			}
+			return hasTransform(this.latestValues) && transformBox(_, this.latestValues), _;
+		}
+		removeTransform(e) {
+			let g = createBox();
+			copyBoxInto(g, e);
+			for (let e = 0; e < this.path.length; e++) {
+				let _ = this.path[e];
+				if (!_.instance || !hasTransform(_.latestValues)) continue;
+				hasScale(_.latestValues) && _.updateSnapshot();
+				let v = createBox();
+				copyBoxInto(v, _.measurePageBox()), removeBoxTransforms(g, _.latestValues, _.snapshot ? _.snapshot.layoutBox : void 0, v);
+			}
+			return hasTransform(this.latestValues) && removeBoxTransforms(g, this.latestValues), g;
+		}
+		setTargetDelta(e) {
+			this.targetDelta = e, this.root.scheduleUpdateProjection(), this.isProjectionDirty = !0;
+		}
+		setOptions(e) {
+			this.options = {
+				...this.options,
+				...e,
+				crossfade: e.crossfade === void 0 ? !0 : e.crossfade
+			};
+		}
+		clearMeasurements() {
+			this.scroll = void 0, this.layout = void 0, this.snapshot = void 0, this.prevTransformTemplateValue = void 0, this.targetDelta = void 0, this.target = void 0, this.isLayoutDirty = !1;
+		}
+		forceRelativeParentToResolveTarget() {
+			this.relativeParent && this.relativeParent.resolvedRelativeTargetAt !== frameData.timestamp && this.relativeParent.resolveTargetDelta(!0);
+		}
+		resolveTargetDelta(e = !1) {
+			let g = this.getLead();
+			this.isProjectionDirty ||= g.isProjectionDirty, this.isTransformDirty ||= g.isTransformDirty, this.isSharedProjectionDirty ||= g.isSharedProjectionDirty;
+			let _ = !!this.resumingFrom || this !== g;
+			if (!(e || _ && this.isSharedProjectionDirty || this.isProjectionDirty || this.parent?.isProjectionDirty || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize)) return;
+			let { layout: v, layoutId: y } = this.options;
+			if (!this.layout || !(v || y)) return;
+			this.resolvedRelativeTargetAt = frameData.timestamp;
+			let b = this.getClosestProjectingParent();
+			b && this.linkedParentVersion !== b.layoutVersion && !b.options.layoutRoot && this.removeRelativeTarget(), !this.targetDelta && !this.relativeTarget && (b && b.layout ? this.createRelativeTarget(b, this.layout.layoutBox, b.layout.layoutBox) : this.removeRelativeTarget()), !(!this.relativeTarget && !this.targetDelta) && (this.target || (this.target = createBox(), this.targetWithTransforms = createBox()), this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target ? (this.forceRelativeParentToResolveTarget(), calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target)) : this.targetDelta ? (this.resumingFrom ? this.target = this.applyTransform(this.layout.layoutBox) : copyBoxInto(this.target, this.layout.layoutBox), applyBoxDelta(this.target, this.targetDelta)) : copyBoxInto(this.target, this.layout.layoutBox), this.attemptToResolveRelativeTarget && (this.attemptToResolveRelativeTarget = !1, b && !!b.resumingFrom == !!this.resumingFrom && !b.options.layoutScroll && b.target && this.animationProgress !== 1 ? this.createRelativeTarget(b, this.target, b.target) : this.relativeParent = this.relativeTarget = void 0), statsBuffer.value && metrics.calculatedTargetDeltas++);
+		}
+		getClosestProjectingParent() {
+			if (!(!this.parent || hasScale(this.parent.latestValues) || has2DTranslate(this.parent.latestValues))) return this.parent.isProjecting() ? this.parent : this.parent.getClosestProjectingParent();
+		}
+		isProjecting() {
+			return !!((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
+		}
+		createRelativeTarget(e, g, _) {
+			this.relativeParent = e, this.linkedParentVersion = e.layoutVersion, this.forceRelativeParentToResolveTarget(), this.relativeTarget = createBox(), this.relativeTargetOrigin = createBox(), calcRelativePosition(this.relativeTargetOrigin, g, _), copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);
+		}
+		removeRelativeTarget() {
+			this.relativeParent = this.relativeTarget = void 0;
+		}
+		calcProjection() {
+			let e = this.getLead(), g = !!this.resumingFrom || this !== e, _ = !0;
+			if ((this.isProjectionDirty || this.parent?.isProjectionDirty) && (_ = !1), g && (this.isSharedProjectionDirty || this.isTransformDirty) && (_ = !1), this.resolvedRelativeTargetAt === frameData.timestamp && (_ = !1), _) return;
+			let { layout: v, layoutId: y } = this.options;
+			if (this.isTreeAnimating = !!(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation), this.isTreeAnimating || (this.targetDelta = this.relativeTarget = void 0), !this.layout || !(v || y)) return;
+			copyBoxInto(this.layoutCorrected, this.layout.layoutBox);
+			let b = this.treeScale.x, x = this.treeScale.y;
+			applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, g), e.layout && !e.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1) && (e.target = e.layout.layoutBox, e.targetWithTransforms = createBox());
+			let { target: S } = e;
+			if (!S) {
+				this.prevProjectionDelta && (this.createProjectionDeltas(), this.scheduleRender());
+				return;
+			}
+			!this.projectionDelta || !this.prevProjectionDelta ? this.createProjectionDeltas() : (copyAxisDeltaInto(this.prevProjectionDelta.x, this.projectionDelta.x), copyAxisDeltaInto(this.prevProjectionDelta.y, this.projectionDelta.y)), calcBoxDelta(this.projectionDelta, this.layoutCorrected, S, this.latestValues), (this.treeScale.x !== b || this.treeScale.y !== x || !axisDeltaEquals(this.projectionDelta.x, this.prevProjectionDelta.x) || !axisDeltaEquals(this.projectionDelta.y, this.prevProjectionDelta.y)) && (this.hasProjected = !0, this.scheduleRender(), this.notifyListeners("projectionUpdate", S)), statsBuffer.value && metrics.calculatedProjections++;
+		}
+		hide() {
+			this.isVisible = !1;
+		}
+		show() {
+			this.isVisible = !0;
+		}
+		scheduleRender(e = !0) {
+			if (this.options.visualElement?.scheduleRender(), e) {
+				let e = this.getStack();
+				e && e.scheduleRender();
+			}
+			this.resumingFrom && !this.resumingFrom.instance && (this.resumingFrom = void 0);
+		}
+		createProjectionDeltas() {
+			this.prevProjectionDelta = createDelta(), this.projectionDelta = createDelta(), this.projectionDeltaWithTransform = createDelta();
+		}
+		setAnimationOrigin(e, g = !1) {
+			let _ = this.snapshot, v = _ ? _.latestValues : {}, y = { ...this.latestValues }, b = createDelta();
+			(!this.relativeParent || !this.relativeParent.options.layoutRoot) && (this.relativeTarget = this.relativeTargetOrigin = void 0), this.attemptToResolveRelativeTarget = !g;
+			let x = createBox(), S = (_ ? _.source : void 0) !== (this.layout ? this.layout.source : void 0), C = this.getStack(), w = !C || C.members.length <= 1, T = !!(S && !w && this.options.crossfade === !0 && !this.path.some(hasOpacityCrossfade));
+			this.animationProgress = 0;
+			let E;
+			this.mixTargetDelta = (g) => {
+				let _ = g / 1e3;
+				mixAxisDelta(b.x, e.x, _), mixAxisDelta(b.y, e.y, _), this.setTargetDelta(b), this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout && (calcRelativePosition(x, this.layout.layoutBox, this.relativeParent.layout.layoutBox), mixBox(this.relativeTarget, this.relativeTargetOrigin, x, _), E && boxEquals(this.relativeTarget, E) && (this.isProjectionDirty = !1), E ||= createBox(), copyBoxInto(E, this.relativeTarget)), S && (this.animationValues = y, mixValues(y, v, this.latestValues, _, T, w)), this.root.scheduleUpdateProjection(), this.scheduleRender(), this.animationProgress = _;
+			}, this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
+		}
+		startAnimation(e) {
+			this.notifyListeners("animationStart"), this.currentAnimation?.stop(), this.resumingFrom?.currentAnimation?.stop(), this.pendingAnimation &&= (cancelFrame(this.pendingAnimation), void 0), this.pendingAnimation = frame.update(() => {
+				globalProjectionState.hasAnimatedSinceResize = !0, activeAnimations.layout++, this.motionValue ||= motionValue(0), this.currentAnimation = animateSingleValue(this.motionValue, [0, 1e3], {
+					...e,
+					velocity: 0,
+					isSync: !0,
+					onUpdate: (g) => {
+						this.mixTargetDelta(g), e.onUpdate && e.onUpdate(g);
+					},
+					onStop: () => {
+						activeAnimations.layout--;
+					},
+					onComplete: () => {
+						activeAnimations.layout--, e.onComplete && e.onComplete(), this.completeAnimation();
+					}
+				}), this.resumingFrom && (this.resumingFrom.currentAnimation = this.currentAnimation), this.pendingAnimation = void 0;
+			});
+		}
+		completeAnimation() {
+			this.resumingFrom && (this.resumingFrom.currentAnimation = void 0, this.resumingFrom.preserveOpacity = void 0);
+			let e = this.getStack();
+			e && e.exitAnimationComplete(), this.resumingFrom = this.currentAnimation = this.animationValues = void 0, this.notifyListeners("animationComplete");
+		}
+		finishAnimation() {
+			this.currentAnimation && (this.mixTargetDelta && this.mixTargetDelta(animationTarget), this.currentAnimation.stop()), this.completeAnimation();
+		}
+		applyTransformsToTarget() {
+			let e = this.getLead(), { targetWithTransforms: g, target: _, layout: v, latestValues: y } = e;
+			if (!(!g || !_ || !v)) {
+				if (this !== e && this.layout && v && shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, v.layoutBox)) {
+					_ = this.target || createBox();
+					let g = calcLength(this.layout.layoutBox.x);
+					_.x.min = e.target.x.min, _.x.max = _.x.min + g;
+					let v = calcLength(this.layout.layoutBox.y);
+					_.y.min = e.target.y.min, _.y.max = _.y.min + v;
+				}
+				copyBoxInto(g, _), transformBox(g, y), calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, g, y);
+			}
+		}
+		registerSharedNode(e, g) {
+			this.sharedNodes.has(e) || this.sharedNodes.set(e, new NodeStack()), this.sharedNodes.get(e).add(g);
+			let _ = g.options.initialPromotionConfig;
+			g.promote({
+				transition: _ ? _.transition : void 0,
+				preserveFollowOpacity: _ && _.shouldPreserveFollowOpacity ? _.shouldPreserveFollowOpacity(g) : void 0
+			});
+		}
+		isLead() {
+			let e = this.getStack();
+			return e ? e.lead === this : !0;
+		}
+		getLead() {
+			let { layoutId: e } = this.options;
+			return e && this.getStack()?.lead || this;
+		}
+		getPrevLead() {
+			let { layoutId: e } = this.options;
+			return e ? this.getStack()?.prevLead : void 0;
+		}
+		getStack() {
+			let { layoutId: e } = this.options;
+			if (e) return this.root.sharedNodes.get(e);
+		}
+		promote({ needsReset: e, transition: g, preserveFollowOpacity: _ } = {}) {
+			let v = this.getStack();
+			v && v.promote(this, _), e && (this.projectionDelta = void 0, this.needsReset = !0), g && this.setOptions({ transition: g });
+		}
+		relegate() {
+			let e = this.getStack();
+			return e ? e.relegate(this) : !1;
+		}
+		resetSkewAndRotation() {
+			let { visualElement: e } = this.options;
+			if (!e) return;
+			let g = !1, { latestValues: _ } = e;
+			if ((_.z || _.rotate || _.rotateX || _.rotateY || _.rotateZ || _.skewX || _.skewY) && (g = !0), !g) return;
+			let v = {};
+			_.z && resetDistortingTransform("z", e, v, this.animationValues);
+			for (let g = 0; g < transformAxes.length; g++) resetDistortingTransform(`rotate${transformAxes[g]}`, e, v, this.animationValues), resetDistortingTransform(`skew${transformAxes[g]}`, e, v, this.animationValues);
+			for (let g in e.render(), v) e.setStaticValue(g, v[g]), this.animationValues && (this.animationValues[g] = v[g]);
+			e.scheduleRender();
+		}
+		applyProjectionStyles(e, g) {
+			if (!this.instance || this.isSVG) return;
+			if (!this.isVisible) {
+				e.visibility = "hidden";
+				return;
+			}
+			let _ = this.getTransformTemplate();
+			if (this.needsReset) {
+				this.needsReset = !1, e.visibility = "", e.opacity = "", e.pointerEvents = resolveMotionValue(g?.pointerEvents) || "", e.transform = _ ? _(this.latestValues, "") : "none";
+				return;
+			}
+			let v = this.getLead();
+			if (!this.projectionDelta || !this.layout || !v.target) {
+				this.options.layoutId && (e.opacity = this.latestValues.opacity === void 0 ? 1 : this.latestValues.opacity, e.pointerEvents = resolveMotionValue(g?.pointerEvents) || ""), this.hasProjected && !hasTransform(this.latestValues) && (e.transform = _ ? _({}, "") : "none", this.hasProjected = !1);
+				return;
+			}
+			e.visibility = "";
+			let y = v.animationValues || v.latestValues;
+			this.applyTransformsToTarget();
+			let b = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, y);
+			_ && (b = _(y, b)), e.transform = b;
+			let { x, y: S } = this.projectionDelta;
+			for (let g in e.transformOrigin = `${x.origin * 100}% ${S.origin * 100}% 0`, v.animationValues ? e.opacity = v === this ? y.opacity ?? this.latestValues.opacity ?? 1 : this.preserveOpacity ? this.latestValues.opacity : y.opacityExit : e.opacity = v === this ? y.opacity === void 0 ? "" : y.opacity : y.opacityExit === void 0 ? 0 : y.opacityExit, scaleCorrectors) {
+				if (y[g] === void 0) continue;
+				let { correct: _, applyTo: x, isCSSVariable: S } = scaleCorrectors[g], C = b === "none" ? y[g] : _(y[g], v);
+				if (x) {
+					let g = x.length;
+					for (let _ = 0; _ < g; _++) e[x[_]] = C;
+				} else S ? this.options.visualElement.renderState.vars[g] = C : e[g] = C;
+			}
+			this.options.layoutId && (e.pointerEvents = v === this ? resolveMotionValue(g?.pointerEvents) || "" : "none");
+		}
+		clearSnapshot() {
+			this.resumeFrom = this.snapshot = void 0;
+		}
+		resetTree() {
+			this.root.nodes.forEach((e) => e.currentAnimation?.stop()), this.root.nodes.forEach(clearMeasurements), this.root.sharedNodes.clear();
+		}
+	};
+}
+function updateLayout(e) {
+	e.updateLayout();
+}
+function notifyLayoutUpdate(e) {
+	let g = e.resumeFrom?.snapshot || e.snapshot;
+	if (e.isLead() && e.layout && g && e.hasListeners("didUpdate")) {
+		let { layoutBox: _, measuredBox: v } = e.layout, { animationType: y } = e.options, b = g.source !== e.layout.source;
+		y === "size" ? eachAxis((e) => {
+			let v = b ? g.measuredBox[e] : g.layoutBox[e], y = calcLength(v);
+			v.min = _[e].min, v.max = v.min + y;
+		}) : shouldAnimatePositionOnly(y, g.layoutBox, _) && eachAxis((v) => {
+			let y = b ? g.measuredBox[v] : g.layoutBox[v], x = calcLength(_[v]);
+			y.max = y.min + x, e.relativeTarget && !e.currentAnimation && (e.isProjectionDirty = !0, e.relativeTarget[v].max = e.relativeTarget[v].min + x);
+		});
+		let x = createDelta();
+		calcBoxDelta(x, _, g.layoutBox);
+		let S = createDelta();
+		b ? calcBoxDelta(S, e.applyTransform(v, !0), g.measuredBox) : calcBoxDelta(S, _, g.layoutBox);
+		let C = !isDeltaZero(x), w = !1;
+		if (!e.resumeFrom) {
+			let v = e.getClosestProjectingParent();
+			if (v && !v.resumeFrom) {
+				let { snapshot: y, layout: b } = v;
+				if (y && b) {
+					let x = createBox();
+					calcRelativePosition(x, g.layoutBox, y.layoutBox);
+					let S = createBox();
+					calcRelativePosition(S, _, b.layoutBox), boxEqualsRounded(x, S) || (w = !0), v.options.layoutRoot && (e.relativeTarget = S, e.relativeTargetOrigin = x, e.relativeParent = v);
+				}
+			}
+		}
+		e.notifyListeners("didUpdate", {
+			layout: _,
+			snapshot: g,
+			delta: S,
+			layoutDelta: x,
+			hasLayoutChanged: C,
+			hasRelativeLayoutChanged: w
+		});
+	} else if (e.isLead()) {
+		let { onExitComplete: g } = e.options;
+		g && g();
+	}
+	e.options.transition = void 0;
+}
+function propagateDirtyNodes(e) {
+	statsBuffer.value && metrics.nodes++, e.parent && (e.isProjecting() || (e.isProjectionDirty = e.parent.isProjectionDirty), e.isSharedProjectionDirty ||= !!(e.isProjectionDirty || e.parent.isProjectionDirty || e.parent.isSharedProjectionDirty), e.isTransformDirty ||= e.parent.isTransformDirty);
+}
+function cleanDirtyNodes(e) {
+	e.isProjectionDirty = e.isSharedProjectionDirty = e.isTransformDirty = !1;
+}
+function clearSnapshot(e) {
+	e.clearSnapshot();
+}
+function clearMeasurements(e) {
+	e.clearMeasurements();
+}
+function clearIsLayoutDirty(e) {
+	e.isLayoutDirty = !1;
+}
+function resetTransformStyle(e) {
+	let { visualElement: g } = e.options;
+	g && g.getProps().onBeforeLayoutMeasure && g.notify("BeforeLayoutMeasure"), e.resetTransform();
+}
+function finishAnimation(e) {
+	e.finishAnimation(), e.targetDelta = e.relativeTarget = e.target = void 0, e.isProjectionDirty = !0;
+}
+function resolveTargetDelta(e) {
+	e.resolveTargetDelta();
+}
+function calcProjection(e) {
+	e.calcProjection();
+}
+function resetSkewAndRotation(e) {
+	e.resetSkewAndRotation();
+}
+function removeLeadSnapshots(e) {
+	e.removeLeadSnapshot();
+}
+function mixAxisDelta(e, g, _) {
+	e.translate = mixNumber(g.translate, 0, _), e.scale = mixNumber(g.scale, 1, _), e.origin = g.origin, e.originPoint = g.originPoint;
+}
+function mixAxis(e, g, _, v) {
+	e.min = mixNumber(g.min, _.min, v), e.max = mixNumber(g.max, _.max, v);
+}
+function mixBox(e, g, _, v) {
+	mixAxis(e.x, g.x, _.x, v), mixAxis(e.y, g.y, _.y, v);
+}
+function hasOpacityCrossfade(e) {
+	return e.animationValues && e.animationValues.opacityExit !== void 0;
+}
+var defaultLayoutTransition = {
+	duration: .45,
+	ease: [
+		.4,
+		0,
+		.1,
+		1
+	]
+}, userAgentContains = (e) => typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().includes(e), roundPoint = userAgentContains("applewebkit/") && !userAgentContains("chrome/") ? Math.round : noop;
+function roundAxis(e) {
+	e.min = roundPoint(e.min), e.max = roundPoint(e.max);
+}
+function roundBox(e) {
+	roundAxis(e.x), roundAxis(e.y);
+}
+function shouldAnimatePositionOnly(e, g, _) {
+	return e === "position" || e === "preserve-aspect" && !isNear(aspectRatio(g), aspectRatio(_), .2);
+}
+function checkNodeWasScrollRoot(e) {
+	return e !== e.root && e.scroll?.wasRoot;
+}
+var DocumentProjectionNode = createProjectionNode$1({
+	attachResizeListener: (e, g) => addDomEvent(e, "resize", g),
+	measureScroll: () => ({
+		x: document.documentElement.scrollLeft || document.body?.scrollLeft || 0,
+		y: document.documentElement.scrollTop || document.body?.scrollTop || 0
+	}),
+	checkIsScrollRoot: () => !0
+}), rootProjectionNode = { current: void 0 }, HTMLProjectionNode = createProjectionNode$1({
+	measureScroll: (e) => ({
+		x: e.scrollLeft,
+		y: e.scrollTop
+	}),
+	defaultParent: () => {
+		if (!rootProjectionNode.current) {
+			let e = new DocumentProjectionNode({});
+			e.mount(window), e.setOptions({ layoutScroll: !0 }), rootProjectionNode.current = e;
+		}
+		return rootProjectionNode.current;
+	},
+	resetTransform: (e, g) => {
+		e.style.transform = g === void 0 ? "none" : g;
+	},
+	checkIsScrollRoot: (e) => window.getComputedStyle(e).position === "fixed"
+}), MotionConfigContext = createContext({
+	transformPagePoint: (e) => e,
+	isStatic: !1,
+	reducedMotion: "never"
+});
+function usePresence(e = !0) {
+	let g = useContext(PresenceContext);
+	if (g === null) return [!0, null];
+	let { isPresent: _, onExitComplete: v, register: y } = g, w = useId();
+	useEffect(() => {
+		if (e) return y(w);
+	}, [e]);
+	let T = useCallback(() => e && v && v(w), [
+		w,
+		v,
+		e
+	]);
+	return !_ && v ? [!1, T] : [!0];
+}
+var LazyContext = createContext({ strict: !1 }), featureProps = {
+	animation: [
+		"animate",
+		"variants",
+		"whileHover",
+		"whileTap",
+		"exit",
+		"whileInView",
+		"whileFocus",
+		"whileDrag"
+	],
+	exit: ["exit"],
+	drag: ["drag", "dragControls"],
+	focus: ["whileFocus"],
+	hover: [
+		"whileHover",
+		"onHoverStart",
+		"onHoverEnd"
+	],
+	tap: [
+		"whileTap",
+		"onTap",
+		"onTapStart",
+		"onTapCancel"
+	],
+	pan: [
+		"onPan",
+		"onPanStart",
+		"onPanSessionStart",
+		"onPanEnd"
+	],
+	inView: [
+		"whileInView",
+		"onViewportEnter",
+		"onViewportLeave"
+	],
+	layout: ["layout", "layoutId"]
+}, isInitialized = !1;
+function initFeatureDefinitions() {
+	if (isInitialized) return;
+	let e = {};
+	for (let g in featureProps) e[g] = { isEnabled: (e) => featureProps[g].some((g) => !!e[g]) };
+	setFeatureDefinitions(e), isInitialized = !0;
+}
+function getInitializedFeatureDefinitions() {
+	return initFeatureDefinitions(), getFeatureDefinitions();
+}
+function loadFeatures(e) {
+	let g = getInitializedFeatureDefinitions();
+	for (let _ in e) g[_] = {
+		...g[_],
+		...e[_]
+	};
+	setFeatureDefinitions(g);
+}
+var validMotionProps = new Set(/* @__PURE__ */ "animate.exit.variants.initial.style.values.variants.transition.transformTemplate.custom.inherit.onBeforeLayoutMeasure.onAnimationStart.onAnimationComplete.onUpdate.onDragStart.onDrag.onDragEnd.onMeasureDragConstraints.onDirectionLock.onDragTransitionEnd._dragX._dragY.onHoverStart.onHoverEnd.onViewportEnter.onViewportLeave.globalTapTarget.propagate.ignoreStrict.viewport".split("."));
+function isValidMotionProp(e) {
+	return e.startsWith("while") || e.startsWith("drag") && e !== "draggable" || e.startsWith("layout") || e.startsWith("onTap") || e.startsWith("onPan") || e.startsWith("onLayout") || validMotionProps.has(e);
+}
+var is_prop_valid_framer_motion_exports = /* @__PURE__ */ __export({ default: () => is_prop_valid_framer_motion_default }), is_prop_valid_framer_motion_default, init_is_prop_valid_framer_motion = __esmMin((() => {
+	throw is_prop_valid_framer_motion_default = {}, Error("Could not resolve \"@emotion/is-prop-valid\" imported by \"framer-motion\". Is it installed?");
+})), shouldForward = (e) => !isValidMotionProp(e);
+function loadExternalIsValidProp(e) {
+	typeof e == "function" && (shouldForward = (g) => g.startsWith("on") ? !isValidMotionProp(g) : e(g));
+}
+try {
+	loadExternalIsValidProp((init_is_prop_valid_framer_motion(), __toCommonJS(is_prop_valid_framer_motion_exports)).default);
+} catch {}
+function filterProps(e, g, _) {
+	let v = {};
+	for (let y in e) y === "values" && typeof e.values == "object" || (shouldForward(y) || _ === !0 && isValidMotionProp(y) || !g && !isValidMotionProp(y) || e.draggable && y.startsWith("onDrag")) && (v[y] = e[y]);
+	return v;
+}
+var MotionContext = /* @__PURE__ */ createContext({});
+function getCurrentTreeVariants(e, g) {
+	if (isControllingVariants(e)) {
+		let { initial: g, animate: _ } = e;
+		return {
+			initial: g === !1 || isVariantLabel(g) ? g : void 0,
+			animate: isVariantLabel(_) ? _ : void 0
+		};
+	}
+	return e.inherit === !1 ? {} : g;
+}
+function useCreateMotionContext(e) {
+	let { initial: g, animate: _ } = getCurrentTreeVariants(e, useContext(MotionContext));
+	return useMemo(() => ({
+		initial: g,
+		animate: _
+	}), [variantLabelsAsDependency(g), variantLabelsAsDependency(_)]);
+}
+function variantLabelsAsDependency(e) {
+	return Array.isArray(e) ? e.join(" ") : e;
+}
+var createHtmlRenderState = () => ({
+	style: {},
+	transform: {},
+	transformOrigin: {},
+	vars: {}
+});
+function copyRawValuesOnly(e, g, _) {
+	for (let v in g) !isMotionValue(g[v]) && !isForcedMotionValue(v, _) && (e[v] = g[v]);
+}
+function useInitialMotionValues({ transformTemplate: e }, g) {
+	return useMemo(() => {
+		let _ = createHtmlRenderState();
+		return buildHTMLStyles(_, g, e), Object.assign({}, _.vars, _.style);
+	}, [g]);
+}
+function useStyle(e, g) {
+	let _ = e.style || {}, v = {};
+	return copyRawValuesOnly(v, _, e), Object.assign(v, useInitialMotionValues(e, g)), v;
+}
+function useHTMLProps(e, g) {
+	let _ = {}, v = useStyle(e, g);
+	return e.drag && e.dragListener !== !1 && (_.draggable = !1, v.userSelect = v.WebkitUserSelect = v.WebkitTouchCallout = "none", v.touchAction = e.drag === !0 ? "none" : `pan-${e.drag === "x" ? "y" : "x"}`), e.tabIndex === void 0 && (e.onTap || e.onTapStart || e.whileTap) && (_.tabIndex = 0), _.style = v, _;
+}
+var createSvgRenderState = () => ({
+	...createHtmlRenderState(),
+	attrs: {}
+});
+function useSVGProps(e, g, _, v) {
+	let y = useMemo(() => {
+		let _ = createSvgRenderState();
+		return buildSVGAttrs(_, g, isSVGTag(v), e.transformTemplate, e.style), {
+			..._.attrs,
+			style: { ..._.style }
+		};
+	}, [g]);
+	if (e.style) {
+		let g = {};
+		copyRawValuesOnly(g, e.style, e), y.style = {
+			...g,
+			...y.style
+		};
+	}
+	return y;
+}
+var lowercaseSVGElements = [
+	"animate",
+	"circle",
+	"defs",
+	"desc",
+	"ellipse",
+	"g",
+	"image",
+	"line",
+	"filter",
+	"marker",
+	"mask",
+	"metadata",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"rect",
+	"stop",
+	"switch",
+	"symbol",
+	"svg",
+	"text",
+	"tspan",
+	"use",
+	"view"
+];
+function isSVGComponent(e) {
+	return typeof e != "string" || e.includes("-") ? !1 : !!(lowercaseSVGElements.indexOf(e) > -1 || /[A-Z]/u.test(e));
+}
+function useRender(e, _, y, { latestValues: b }, x, S = !1, C) {
+	let w = (C ?? isSVGComponent(e) ? useSVGProps : useHTMLProps)(_, b, x, e), T = filterProps(_, typeof e == "string", S), D = e === Fragment ? {} : {
+		...T,
+		...w,
+		ref: y
+	}, { children: O } = _, k = useMemo(() => isMotionValue(O) ? O.get() : O, [O]);
+	return createElement(e, {
+		...D,
+		children: k
+	});
+}
+function makeState({ scrapeMotionValuesFromProps: e, createRenderState: g }, _, v, y) {
+	return {
+		latestValues: makeLatestValues(_, v, y, e),
+		renderState: g()
+	};
+}
+function makeLatestValues(e, g, _, v) {
+	let y = {}, b = v(e, {});
+	for (let e in b) y[e] = resolveMotionValue(b[e]);
+	let { initial: x, animate: S } = e, C = isControllingVariants(e), w = isVariantNode(e);
+	g && w && !C && e.inherit !== !1 && (x === void 0 && (x = g.initial), S === void 0 && (S = g.animate));
+	let T = _ ? _.initial === !1 : !1;
+	T ||= x === !1;
+	let E = T ? S : x;
+	if (E && typeof E != "boolean" && !isAnimationControls(E)) {
+		let g = Array.isArray(E) ? E : [E];
+		for (let _ = 0; _ < g.length; _++) {
+			let v = resolveVariantFromProps(e, g[_]);
+			if (v) {
+				let { transitionEnd: e, transition: g, ..._ } = v;
+				for (let e in _) {
+					let g = _[e];
+					if (Array.isArray(g)) {
+						let e = T ? g.length - 1 : 0;
+						g = g[e];
+					}
+					g !== null && (y[e] = g);
+				}
+				for (let g in e) y[g] = e[g];
+			}
+		}
+	}
+	return y;
+}
+var makeUseVisualState = (e) => (g, _) => {
+	let v = useContext(MotionContext), y = useContext(PresenceContext), b = () => makeState(e, g, v, y);
+	return _ ? b() : useConstant(b);
+}, useHTMLVisualState = /* @__PURE__ */ makeUseVisualState({
+	scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,
+	createRenderState: createHtmlRenderState
+}), useSVGVisualState = /* @__PURE__ */ makeUseVisualState({
+	scrapeMotionValuesFromProps,
+	createRenderState: createSvgRenderState
+}), motionComponentSymbol = Symbol.for("motionComponentSymbol");
+function useMotionRef(e, g, _) {
+	let v = useRef(_);
+	useInsertionEffect(() => {
+		v.current = _;
+	});
+	let y = useRef(null);
+	return useCallback((_) => {
+		_ && e.onMount?.(_), g && (_ ? g.mount(_) : g.unmount());
+		let b = v.current;
+		if (typeof b == "function") if (_) {
+			let e = b(_);
+			typeof e == "function" && (y.current = e);
+		} else y.current ? (y.current(), y.current = null) : b(_);
+		else b && (b.current = _);
+	}, [g]);
+}
+var SwitchLayoutGroupContext = createContext({});
+function isRefObject(e) {
+	return e && typeof e == "object" && Object.prototype.hasOwnProperty.call(e, "current");
+}
+function useVisualElement(e, g, _, v, y, b) {
+	let { visualElement: C } = useContext(MotionContext), T = useContext(LazyContext), E = useContext(PresenceContext), O = useContext(MotionConfigContext), k = O.reducedMotion, A = O.skipAnimations, j = useRef(null), M = useRef(!1);
+	v ||= T.renderer, !j.current && v && (j.current = v(e, {
+		visualState: g,
+		parent: C,
+		props: _,
+		presenceContext: E,
+		blockInitialAnimation: E ? E.initial === !1 : !1,
+		reducedMotionConfig: k,
+		skipAnimations: A,
+		isSVG: b
+	}), M.current && j.current && (j.current.manuallyAnimateOnMount = !0));
+	let N = j.current, P = useContext(SwitchLayoutGroupContext);
+	N && !N.projection && y && (N.type === "html" || N.type === "svg") && createProjectionNode(j.current, _, y, P);
+	let F = useRef(!1);
+	useInsertionEffect(() => {
+		N && F.current && N.update(_, E);
+	});
+	let I = _[optimizedAppearDataAttribute], L = useRef(!!I && !window.MotionHandoffIsComplete?.(I) && window.MotionHasOptimisedAnimation?.(I));
+	return useIsomorphicLayoutEffect(() => {
+		M.current = !0, N && (F.current = !0, window.MotionIsMounted = !0, N.updateFeatures(), N.scheduleRenderMicrotask(), L.current && N.animationState && N.animationState.animateChanges());
+	}), useEffect(() => {
+		N && (!L.current && N.animationState && N.animationState.animateChanges(), L.current &&= (queueMicrotask(() => {
+			window.MotionHandoffMarkAsComplete?.(I);
+		}), !1), N.enteringChildren = void 0);
+	}), N;
+}
+function createProjectionNode(e, g, _, v) {
+	let { layoutId: y, layout: b, drag: x, dragConstraints: S, layoutScroll: C, layoutRoot: w, layoutCrossfade: T } = g;
+	e.projection = new _(e.latestValues, g["data-framer-portal-id"] ? void 0 : getClosestProjectingNode(e.parent)), e.projection.setOptions({
+		layoutId: y,
+		layout: b,
+		alwaysMeasureLayout: !!x || S && isRefObject(S),
+		visualElement: e,
+		animationType: typeof b == "string" ? b : "both",
+		initialPromotionConfig: v,
+		crossfade: T,
+		layoutScroll: C,
+		layoutRoot: w
+	});
+}
+function getClosestProjectingNode(e) {
+	if (e) return e.options.allowProjection === !1 ? getClosestProjectingNode(e.parent) : e.projection;
+}
+var import_jsx_runtime = require_jsx_runtime();
+function createMotionComponent(e, { forwardMotionProps: g = !1, type: _ } = {}, v, b) {
+	v && loadFeatures(v);
+	let S = _ ? _ === "svg" : isSVGComponent(e), C = S ? useSVGVisualState : useHTMLVisualState;
+	function w(_, y) {
+		let w, T = {
+			...useContext(MotionConfigContext),
+			..._,
+			layoutId: useLayoutId(_)
+		}, { isStatic: E } = T, D = useCreateMotionContext(_), O = C(_, E);
+		if (!E && isBrowser) {
+			useStrictMode(T, v);
+			let g = getProjectionFunctionality(T);
+			w = g.MeasureLayout, D.visualElement = useVisualElement(e, O, T, b, g.ProjectionNode, S);
+		}
+		return (0, import_jsx_runtime.jsxs)(MotionContext.Provider, {
+			value: D,
+			children: [w && D.visualElement ? (0, import_jsx_runtime.jsx)(w, {
+				visualElement: D.visualElement,
+				...T
+			}) : null, useRender(e, _, useMotionRef(O, D.visualElement, y), O, E, g, S)]
+		});
+	}
+	w.displayName = `motion.${typeof e == "string" ? e : `create(${e.displayName ?? e.name ?? ""})`}`;
+	let T = forwardRef(w);
+	return T[motionComponentSymbol] = e, T;
+}
+function useLayoutId({ layoutId: e }) {
+	let g = useContext(LayoutGroupContext).id;
+	return g && e !== void 0 ? g + "-" + e : e;
+}
+function useStrictMode(e, g) {
+	let _ = useContext(LazyContext).strict;
+	if (process.env.NODE_ENV !== "production" && g && _) {
+		let g = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+		e.ignoreStrict ? warning(!1, g, "lazy-strict-mode") : invariant(!1, g, "lazy-strict-mode");
+	}
+}
+function getProjectionFunctionality(e) {
+	let { drag: g, layout: _ } = getInitializedFeatureDefinitions();
+	if (!g && !_) return {};
+	let v = {
+		...g,
+		..._
+	};
+	return {
+		MeasureLayout: g?.isEnabled(e) || _?.isEnabled(e) ? v.MeasureLayout : void 0,
+		ProjectionNode: v.ProjectionNode
+	};
+}
+function createMotionProxy(e, g) {
+	if (typeof Proxy > "u") return createMotionComponent;
+	let _ = /* @__PURE__ */ new Map(), v = (_, v) => createMotionComponent(_, v, e, g);
+	return new Proxy((e, g) => (process.env.NODE_ENV !== "production" && warnOnce(!1, "motion() is deprecated. Use motion.create() instead."), v(e, g)), { get: (y, b) => b === "create" ? v : (_.has(b) || _.set(b, createMotionComponent(b, void 0, e, g)), _.get(b)) });
+}
+var createDomVisualElement = (e, _) => _.isSVG ?? isSVGComponent(e) ? new SVGVisualElement(_) : new HTMLVisualElement(_, { allowProjection: e !== Fragment }), AnimationFeature = class extends Feature {
+	constructor(e) {
+		super(e), e.animationState ||= createAnimationState(e);
+	}
+	updateAnimationControlsSubscription() {
+		let { animate: e } = this.node.getProps();
+		isAnimationControls(e) && (this.unmountControls = e.subscribe(this.node));
+	}
+	mount() {
+		this.updateAnimationControlsSubscription();
+	}
+	update() {
+		let { animate: e } = this.node.getProps(), { animate: g } = this.node.prevProps || {};
+		e !== g && this.updateAnimationControlsSubscription();
+	}
+	unmount() {
+		this.node.animationState.reset(), this.unmountControls?.();
+	}
+}, id = 0, animations = {
+	animation: { Feature: AnimationFeature },
+	exit: { Feature: class extends Feature {
+		constructor() {
+			super(...arguments), this.id = id++;
+		}
+		update() {
+			if (!this.node.presenceContext) return;
+			let { isPresent: e, onExitComplete: g } = this.node.presenceContext, { isPresent: _ } = this.node.prevPresenceContext || {};
+			if (!this.node.animationState || e === _) return;
+			let v = this.node.animationState.setActive("exit", !e);
+			g && !e && v.then(() => {
+				g(this.id);
+			});
+		}
+		mount() {
+			let { register: e, onExitComplete: g } = this.node.presenceContext || {};
+			g && g(this.id), e && (this.unmount = e(this.id));
+		}
+		unmount() {}
+	} }
+};
+function extractEventInfo(e) {
+	return { point: {
+		x: e.pageX,
+		y: e.pageY
+	} };
+}
+var addPointerInfo = (e) => (g) => isPrimaryPointer(g) && e(g, extractEventInfo(g));
+function addPointerEvent(e, g, _, v) {
+	return addDomEvent(e, g, addPointerInfo(_), v);
+}
+var getContextWindow = ({ current: e }) => e ? e.ownerDocument.defaultView : null, distance = (e, g) => Math.abs(e - g);
+function distance2D(e, g) {
+	let _ = distance(e.x, g.x), v = distance(e.y, g.y);
+	return Math.sqrt(_ ** 2 + v ** 2);
+}
+var overflowStyles = /* @__PURE__ */ new Set(["auto", "scroll"]), PanSession = class {
+	constructor(e, g, { transformPagePoint: _, contextWindow: v = window, dragSnapToOrigin: y = !1, distanceThreshold: b = 3, element: x } = {}) {
+		if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.scrollPositions = /* @__PURE__ */ new Map(), this.removeScrollListeners = null, this.onElementScroll = (e) => {
+			this.handleScroll(e.target);
+		}, this.onWindowScroll = () => {
+			this.handleScroll(window);
+		}, this.updatePoint = () => {
+			if (!(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+			let e = getPanInfo(this.lastMoveEventInfo, this.history), g = this.startEvent !== null, _ = distance2D(e.offset, {
+				x: 0,
+				y: 0
+			}) >= this.distanceThreshold;
+			if (!g && !_) return;
+			let { point: v } = e, { timestamp: y } = frameData;
+			this.history.push({
+				...v,
+				timestamp: y
+			});
+			let { onStart: b, onMove: x } = this.handlers;
+			g || (b && b(this.lastMoveEvent, e), this.startEvent = this.lastMoveEvent), x && x(this.lastMoveEvent, e);
+		}, this.handlePointerMove = (e, g) => {
+			this.lastMoveEvent = e, this.lastMoveEventInfo = transformPoint(g, this.transformPagePoint), frame.update(this.updatePoint, !0);
+		}, this.handlePointerUp = (e, g) => {
+			this.end();
+			let { onEnd: _, onSessionEnd: v, resumeAnimation: y } = this.handlers;
+			if ((this.dragSnapToOrigin || !this.startEvent) && y && y(), !(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+			let b = getPanInfo(e.type === "pointercancel" ? this.lastMoveEventInfo : transformPoint(g, this.transformPagePoint), this.history);
+			this.startEvent && _ && _(e, b), v && v(e, b);
+		}, !isPrimaryPointer(e)) return;
+		this.dragSnapToOrigin = y, this.handlers = g, this.transformPagePoint = _, this.distanceThreshold = b, this.contextWindow = v || window;
+		let S = transformPoint(extractEventInfo(e), this.transformPagePoint), { point: C } = S, { timestamp: w } = frameData;
+		this.history = [{
+			...C,
+			timestamp: w
+		}];
+		let { onSessionStart: T } = g;
+		T && T(e, getPanInfo(S, this.history)), this.removeListeners = pipe(addPointerEvent(this.contextWindow, "pointermove", this.handlePointerMove), addPointerEvent(this.contextWindow, "pointerup", this.handlePointerUp), addPointerEvent(this.contextWindow, "pointercancel", this.handlePointerUp)), x && this.startScrollTracking(x);
+	}
+	startScrollTracking(e) {
+		let g = e.parentElement;
+		for (; g;) {
+			let e = getComputedStyle(g);
+			(overflowStyles.has(e.overflowX) || overflowStyles.has(e.overflowY)) && this.scrollPositions.set(g, {
+				x: g.scrollLeft,
+				y: g.scrollTop
+			}), g = g.parentElement;
+		}
+		this.scrollPositions.set(window, {
+			x: window.scrollX,
+			y: window.scrollY
+		}), window.addEventListener("scroll", this.onElementScroll, {
+			capture: !0,
+			passive: !0
+		}), window.addEventListener("scroll", this.onWindowScroll, { passive: !0 }), this.removeScrollListeners = () => {
+			window.removeEventListener("scroll", this.onElementScroll, { capture: !0 }), window.removeEventListener("scroll", this.onWindowScroll);
+		};
+	}
+	handleScroll(e) {
+		let g = this.scrollPositions.get(e);
+		if (!g) return;
+		let _ = e === window, v = _ ? {
+			x: window.scrollX,
+			y: window.scrollY
+		} : {
+			x: e.scrollLeft,
+			y: e.scrollTop
+		}, y = {
+			x: v.x - g.x,
+			y: v.y - g.y
+		};
+		y.x === 0 && y.y === 0 || (_ ? this.lastMoveEventInfo && (this.lastMoveEventInfo.point.x += y.x, this.lastMoveEventInfo.point.y += y.y) : this.history.length > 0 && (this.history[0].x -= y.x, this.history[0].y -= y.y), this.scrollPositions.set(e, v), frame.update(this.updatePoint, !0));
+	}
+	updateHandlers(e) {
+		this.handlers = e;
+	}
+	end() {
+		this.removeListeners && this.removeListeners(), this.removeScrollListeners && this.removeScrollListeners(), this.scrollPositions.clear(), cancelFrame(this.updatePoint);
+	}
+};
+function transformPoint(e, g) {
+	return g ? { point: g(e.point) } : e;
+}
+function subtractPoint(e, g) {
+	return {
+		x: e.x - g.x,
+		y: e.y - g.y
+	};
+}
+function getPanInfo({ point: e }, g) {
+	return {
+		point: e,
+		delta: subtractPoint(e, lastDevicePoint(g)),
+		offset: subtractPoint(e, startDevicePoint(g)),
+		velocity: getVelocity(g, .1)
+	};
+}
+function startDevicePoint(e) {
+	return e[0];
+}
+function lastDevicePoint(e) {
+	return e[e.length - 1];
+}
+function getVelocity(e, g) {
+	if (e.length < 2) return {
+		x: 0,
+		y: 0
+	};
+	let _ = e.length - 1, v = null, y = lastDevicePoint(e);
+	for (; _ >= 0 && (v = e[_], !(y.timestamp - v.timestamp > /* @__PURE__ */ secondsToMilliseconds(g)));) _--;
+	if (!v) return {
+		x: 0,
+		y: 0
+	};
+	v === e[0] && e.length > 2 && y.timestamp - v.timestamp > /* @__PURE__ */ secondsToMilliseconds(g) * 2 && (v = e[1]);
+	let b = /* @__PURE__ */ millisecondsToSeconds(y.timestamp - v.timestamp);
+	if (b === 0) return {
+		x: 0,
+		y: 0
+	};
+	let x = {
+		x: (y.x - v.x) / b,
+		y: (y.y - v.y) / b
+	};
+	return x.x === Infinity && (x.x = 0), x.y === Infinity && (x.y = 0), x;
+}
+function applyConstraints(e, { min: g, max: _ }, v) {
+	return g !== void 0 && e < g ? e = v ? mixNumber(g, e, v.min) : Math.max(e, g) : _ !== void 0 && e > _ && (e = v ? mixNumber(_, e, v.max) : Math.min(e, _)), e;
+}
+function calcRelativeAxisConstraints(e, g, _) {
+	return {
+		min: g === void 0 ? void 0 : e.min + g,
+		max: _ === void 0 ? void 0 : e.max + _ - (e.max - e.min)
+	};
+}
+function calcRelativeConstraints(e, { top: g, left: _, bottom: v, right: y }) {
+	return {
+		x: calcRelativeAxisConstraints(e.x, _, y),
+		y: calcRelativeAxisConstraints(e.y, g, v)
+	};
+}
+function calcViewportAxisConstraints(e, g) {
+	let _ = g.min - e.min, v = g.max - e.max;
+	return g.max - g.min < e.max - e.min && ([_, v] = [v, _]), {
+		min: _,
+		max: v
+	};
+}
+function calcViewportConstraints(e, g) {
+	return {
+		x: calcViewportAxisConstraints(e.x, g.x),
+		y: calcViewportAxisConstraints(e.y, g.y)
+	};
+}
+function calcOrigin(e, g) {
+	let _ = .5, v = calcLength(e), y = calcLength(g);
+	return y > v ? _ = /* @__PURE__ */ progress(g.min, g.max - v, e.min) : v > y && (_ = /* @__PURE__ */ progress(e.min, e.max - y, g.min)), clamp(0, 1, _);
+}
+function rebaseAxisConstraints(e, g) {
+	let _ = {};
+	return g.min !== void 0 && (_.min = g.min - e.min), g.max !== void 0 && (_.max = g.max - e.min), _;
+}
+var defaultElastic = .35;
+function resolveDragElastic(e = defaultElastic) {
+	return e === !1 ? e = 0 : e === !0 && (e = defaultElastic), {
+		x: resolveAxisElastic(e, "left", "right"),
+		y: resolveAxisElastic(e, "top", "bottom")
+	};
+}
+function resolveAxisElastic(e, g, _) {
+	return {
+		min: resolvePointElastic(e, g),
+		max: resolvePointElastic(e, _)
+	};
+}
+function resolvePointElastic(e, g) {
+	return typeof e == "number" ? e : e[g] || 0;
+}
+var elementDragControls = /* @__PURE__ */ new WeakMap(), VisualElementDragControls = class {
+	constructor(e) {
+		this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = {
+			x: 0,
+			y: 0
+		}, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = createBox(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = e;
+	}
+	start(e, { snapToCursor: g = !1, distanceThreshold: _ } = {}) {
+		let { presenceContext: v } = this.visualElement;
+		if (v && v.isPresent === !1) return;
+		let y = (e) => {
+			g && this.snapToCursor(extractEventInfo(e).point), this.stopAnimation();
+		}, b = (e, g) => {
+			let { drag: _, dragPropagation: v, onDragStart: y } = this.getProps();
+			if (_ && !v && (this.openDragLock && this.openDragLock(), this.openDragLock = setDragLock(_), !this.openDragLock)) return;
+			this.latestPointerEvent = e, this.latestPanInfo = g, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), eachAxis((e) => {
+				let g = this.getAxisMotionValue(e).get() || 0;
+				if (percent.test(g)) {
+					let { projection: _ } = this.visualElement;
+					if (_ && _.layout) {
+						let v = _.layout.layoutBox[e];
+						v && (g = calcLength(v) * (parseFloat(g) / 100));
+					}
+				}
+				this.originPoint[e] = g;
+			}), y && frame.update(() => y(e, g), !1, !0), addValueToWillChange(this.visualElement, "transform");
+			let { animationState: b } = this.visualElement;
+			b && b.setActive("whileDrag", !0);
+		}, x = (e, g) => {
+			this.latestPointerEvent = e, this.latestPanInfo = g;
+			let { dragPropagation: _, dragDirectionLock: v, onDirectionLock: y, onDrag: b } = this.getProps();
+			if (!_ && !this.openDragLock) return;
+			let { offset: x } = g;
+			if (v && this.currentDirection === null) {
+				this.currentDirection = getCurrentDirection(x), this.currentDirection !== null && y && y(this.currentDirection);
+				return;
+			}
+			this.updateAxis("x", g.point, x), this.updateAxis("y", g.point, x), this.visualElement.render(), b && frame.update(() => b(e, g), !1, !0);
+		}, S = (e, g) => {
+			this.latestPointerEvent = e, this.latestPanInfo = g, this.stop(e, g), this.latestPointerEvent = null, this.latestPanInfo = null;
+		}, C = () => {
+			let { dragSnapToOrigin: e } = this.getProps();
+			(e || this.constraints) && this.startAnimation({
+				x: 0,
+				y: 0
+			});
+		}, { dragSnapToOrigin: w } = this.getProps();
+		this.panSession = new PanSession(e, {
+			onSessionStart: y,
+			onStart: b,
+			onMove: x,
+			onSessionEnd: S,
+			resumeAnimation: C
+		}, {
+			transformPagePoint: this.visualElement.getTransformPagePoint(),
+			dragSnapToOrigin: w,
+			distanceThreshold: _,
+			contextWindow: getContextWindow(this.visualElement),
+			element: this.visualElement.current
+		});
+	}
+	stop(e, g) {
+		let _ = e || this.latestPointerEvent, v = g || this.latestPanInfo, y = this.isDragging;
+		if (this.cancel(), !y || !v || !_) return;
+		let { velocity: b } = v;
+		this.startAnimation(b);
+		let { onDragEnd: x } = this.getProps();
+		x && frame.postRender(() => x(_, v));
+	}
+	cancel() {
+		this.isDragging = !1;
+		let { projection: e, animationState: g } = this.visualElement;
+		e && (e.isAnimationBlocked = !1), this.endPanSession();
+		let { dragPropagation: _ } = this.getProps();
+		!_ && this.openDragLock && (this.openDragLock(), this.openDragLock = null), g && g.setActive("whileDrag", !1);
+	}
+	endPanSession() {
+		this.panSession && this.panSession.end(), this.panSession = void 0;
+	}
+	updateAxis(e, g, _) {
+		let { drag: v } = this.getProps();
+		if (!_ || !shouldDrag(e, v, this.currentDirection)) return;
+		let y = this.getAxisMotionValue(e), b = this.originPoint[e] + _[e];
+		this.constraints && this.constraints[e] && (b = applyConstraints(b, this.constraints[e], this.elastic[e])), y.set(b);
+	}
+	resolveConstraints() {
+		let { dragConstraints: e, dragElastic: g } = this.getProps(), _ = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : this.visualElement.projection?.layout, v = this.constraints;
+		e && isRefObject(e) ? this.constraints ||= this.resolveRefConstraints() : e && _ ? this.constraints = calcRelativeConstraints(_.layoutBox, e) : this.constraints = !1, this.elastic = resolveDragElastic(g), v !== this.constraints && !isRefObject(e) && _ && this.constraints && !this.hasMutatedConstraints && eachAxis((e) => {
+			this.constraints !== !1 && this.getAxisMotionValue(e) && (this.constraints[e] = rebaseAxisConstraints(_.layoutBox[e], this.constraints[e]));
+		});
+	}
+	resolveRefConstraints() {
+		let { dragConstraints: e, onMeasureDragConstraints: g } = this.getProps();
+		if (!e || !isRefObject(e)) return !1;
+		let _ = e.current;
+		invariant(_ !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+		let { projection: v } = this.visualElement;
+		if (!v || !v.layout) return !1;
+		let y = measurePageBox(_, v.root, this.visualElement.getTransformPagePoint()), b = calcViewportConstraints(v.layout.layoutBox, y);
+		if (g) {
+			let e = g(convertBoxToBoundingBox(b));
+			this.hasMutatedConstraints = !!e, e && (b = convertBoundingBoxToBox(e));
+		}
+		return b;
+	}
+	startAnimation(e) {
+		let { drag: g, dragMomentum: _, dragElastic: v, dragTransition: y, dragSnapToOrigin: b, onDragTransitionEnd: x } = this.getProps(), S = this.constraints || {}, C = eachAxis((x) => {
+			if (!shouldDrag(x, g, this.currentDirection)) return;
+			let C = S && S[x] || {};
+			b && (C = {
+				min: 0,
+				max: 0
+			});
+			let w = v ? 200 : 1e6, T = v ? 40 : 1e7, E = {
+				type: "inertia",
+				velocity: _ ? e[x] : 0,
+				bounceStiffness: w,
+				bounceDamping: T,
+				timeConstant: 750,
+				restDelta: 1,
+				restSpeed: 10,
+				...y,
+				...C
+			};
+			return this.startAxisValueAnimation(x, E);
+		});
+		return Promise.all(C).then(x);
+	}
+	startAxisValueAnimation(e, g) {
+		let _ = this.getAxisMotionValue(e);
+		return addValueToWillChange(this.visualElement, e), _.start(animateMotionValue(e, _, 0, g, this.visualElement, !1));
+	}
+	stopAnimation() {
+		eachAxis((e) => this.getAxisMotionValue(e).stop());
+	}
+	getAxisMotionValue(e) {
+		let g = `_drag${e.toUpperCase()}`, _ = this.visualElement.getProps();
+		return _[g] || this.visualElement.getValue(e, (_.initial ? _.initial[e] : void 0) || 0);
+	}
+	snapToCursor(e) {
+		eachAxis((g) => {
+			let { drag: _ } = this.getProps();
+			if (!shouldDrag(g, _, this.currentDirection)) return;
+			let { projection: v } = this.visualElement, y = this.getAxisMotionValue(g);
+			if (v && v.layout) {
+				let { min: _, max: b } = v.layout.layoutBox[g], x = y.get() || 0;
+				y.set(e[g] - mixNumber(_, b, .5) + x);
+			}
+		});
+	}
+	scalePositionWithinConstraints() {
+		if (!this.visualElement.current) return;
+		let { drag: e, dragConstraints: g } = this.getProps(), { projection: _ } = this.visualElement;
+		if (!isRefObject(g) || !_ || !this.constraints) return;
+		this.stopAnimation();
+		let v = {
+			x: 0,
+			y: 0
+		};
+		eachAxis((e) => {
+			let g = this.getAxisMotionValue(e);
+			if (g && this.constraints !== !1) {
+				let _ = g.get();
+				v[e] = calcOrigin({
+					min: _,
+					max: _
+				}, this.constraints[e]);
+			}
+		});
+		let { transformTemplate: y } = this.visualElement.getProps();
+		this.visualElement.current.style.transform = y ? y({}, "") : "none", _.root && _.root.updateScroll(), _.updateLayout(), this.constraints = !1, this.resolveConstraints(), eachAxis((g) => {
+			if (!shouldDrag(g, e, null)) return;
+			let _ = this.getAxisMotionValue(g), { min: y, max: b } = this.constraints[g];
+			_.set(mixNumber(y, b, v[g]));
+		}), this.visualElement.render();
+	}
+	addListeners() {
+		if (!this.visualElement.current) return;
+		elementDragControls.set(this.visualElement, this);
+		let e = this.visualElement.current, g = addPointerEvent(e, "pointerdown", (g) => {
+			let { drag: _, dragListener: v = !0 } = this.getProps(), y = g.target, b = y !== e && isElementTextInput(y);
+			_ && v && !b && this.start(g);
+		}), _, v = () => {
+			let { dragConstraints: g } = this.getProps();
+			isRefObject(g) && g.current && (this.constraints = this.resolveRefConstraints(), _ ||= startResizeObservers(e, g.current, () => this.scalePositionWithinConstraints()));
+		}, { projection: y } = this.visualElement, b = y.addEventListener("measure", v);
+		y && !y.layout && (y.root && y.root.updateScroll(), y.updateLayout()), frame.read(v);
+		let x = addDomEvent(window, "resize", () => this.scalePositionWithinConstraints()), S = y.addEventListener("didUpdate", (({ delta: e, hasLayoutChanged: g }) => {
+			this.isDragging && g && (eachAxis((g) => {
+				let _ = this.getAxisMotionValue(g);
+				_ && (this.originPoint[g] += e[g].translate, _.set(_.get() + e[g].translate));
+			}), this.visualElement.render());
+		}));
+		return () => {
+			x(), g(), b(), S && S(), _ && _();
+		};
+	}
+	getProps() {
+		let e = this.visualElement.getProps(), { drag: g = !1, dragDirectionLock: _ = !1, dragPropagation: v = !1, dragConstraints: y = !1, dragElastic: b = defaultElastic, dragMomentum: x = !0 } = e;
+		return {
+			...e,
+			drag: g,
+			dragDirectionLock: _,
+			dragPropagation: v,
+			dragConstraints: y,
+			dragElastic: b,
+			dragMomentum: x
+		};
+	}
+};
+function skipFirstCall(e) {
+	let g = !0;
+	return () => {
+		if (g) {
+			g = !1;
+			return;
+		}
+		e();
+	};
+}
+function startResizeObservers(e, g, _) {
+	let v = resize(e, skipFirstCall(_)), y = resize(g, skipFirstCall(_));
+	return () => {
+		v(), y();
+	};
+}
+function shouldDrag(e, g, _) {
+	return (g === !0 || g === e) && (_ === null || _ === e);
+}
+function getCurrentDirection(e, g = 10) {
+	let _ = null;
+	return Math.abs(e.y) > g ? _ = "y" : Math.abs(e.x) > g && (_ = "x"), _;
+}
+var DragGesture = class extends Feature {
+	constructor(e) {
+		super(e), this.removeGroupControls = noop, this.removeListeners = noop, this.controls = new VisualElementDragControls(e);
+	}
+	mount() {
+		let { dragControls: e } = this.node.getProps();
+		e && (this.removeGroupControls = e.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || noop;
+	}
+	update() {
+		let { dragControls: e } = this.node.getProps(), { dragControls: g } = this.node.prevProps || {};
+		e !== g && (this.removeGroupControls(), e && (this.removeGroupControls = e.subscribe(this.controls)));
+	}
+	unmount() {
+		this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession();
+	}
+}, asyncHandler = (e) => (g, _) => {
+	e && frame.update(() => e(g, _), !1, !0);
+}, PanGesture = class extends Feature {
+	constructor() {
+		super(...arguments), this.removePointerDownListener = noop;
+	}
+	onPointerDown(e) {
+		this.session = new PanSession(e, this.createPanHandlers(), {
+			transformPagePoint: this.node.getTransformPagePoint(),
+			contextWindow: getContextWindow(this.node)
+		});
+	}
+	createPanHandlers() {
+		let { onPanSessionStart: e, onPanStart: g, onPan: _, onPanEnd: v } = this.node.getProps();
+		return {
+			onSessionStart: asyncHandler(e),
+			onStart: asyncHandler(g),
+			onMove: asyncHandler(_),
+			onEnd: (e, g) => {
+				delete this.session, v && frame.postRender(() => v(e, g));
+			}
+		};
+	}
+	mount() {
+		this.removePointerDownListener = addPointerEvent(this.node.current, "pointerdown", (e) => this.onPointerDown(e));
+	}
+	update() {
+		this.session && this.session.updateHandlers(this.createPanHandlers());
+	}
+	unmount() {
+		this.removePointerDownListener(), this.session && this.session.end();
+	}
+}, hasTakenAnySnapshot = !1, MeasureLayoutWithContext = class extends Component {
+	componentDidMount() {
+		let { visualElement: e, layoutGroup: g, switchLayoutGroup: _, layoutId: v } = this.props, { projection: y } = e;
+		y && (g.group && g.group.add(y), _ && _.register && v && _.register(y), hasTakenAnySnapshot && y.root.didUpdate(), y.addEventListener("animationComplete", () => {
+			this.safeToRemove();
+		}), y.setOptions({
+			...y.options,
+			layoutDependency: this.props.layoutDependency,
+			onExitComplete: () => this.safeToRemove()
+		})), globalProjectionState.hasEverUpdated = !0;
+	}
+	getSnapshotBeforeUpdate(e) {
+		let { layoutDependency: g, visualElement: _, drag: v, isPresent: y } = this.props, { projection: b } = _;
+		return b ? (b.isPresent = y, e.layoutDependency !== g && b.setOptions({
+			...b.options,
+			layoutDependency: g
+		}), hasTakenAnySnapshot = !0, v || e.layoutDependency !== g || g === void 0 || e.isPresent !== y ? b.willUpdate() : this.safeToRemove(), e.isPresent !== y && (y ? b.promote() : b.relegate() || frame.postRender(() => {
+			let e = b.getStack();
+			(!e || !e.members.length) && this.safeToRemove();
+		})), null) : null;
+	}
+	componentDidUpdate() {
+		let { projection: e } = this.props.visualElement;
+		e && (e.root.didUpdate(), microtask.postRender(() => {
+			!e.currentAnimation && e.isLead() && this.safeToRemove();
+		}));
+	}
+	componentWillUnmount() {
+		let { visualElement: e, layoutGroup: g, switchLayoutGroup: _ } = this.props, { projection: v } = e;
+		hasTakenAnySnapshot = !0, v && (v.scheduleCheckAfterUnmount(), g && g.group && g.group.remove(v), _ && _.deregister && _.deregister(v));
+	}
+	safeToRemove() {
+		let { safeToRemove: e } = this.props;
+		e && e();
+	}
+	render() {
+		return null;
+	}
+};
+function MeasureLayout(e) {
+	let [g, _] = usePresence(), v = useContext(LayoutGroupContext);
+	return (0, import_jsx_runtime.jsx)(MeasureLayoutWithContext, {
+		...e,
+		layoutGroup: v,
+		switchLayoutGroup: useContext(SwitchLayoutGroupContext),
+		isPresent: g,
+		safeToRemove: _
+	});
+}
+var drag = {
+	pan: { Feature: PanGesture },
+	drag: {
+		Feature: DragGesture,
+		ProjectionNode: HTMLProjectionNode,
+		MeasureLayout
+	}
+};
+function handleHoverEvent(e, g, _) {
+	let { props: v } = e;
+	e.animationState && v.whileHover && e.animationState.setActive("whileHover", _ === "Start");
+	let y = v["onHover" + _];
+	y && frame.postRender(() => y(g, extractEventInfo(g)));
+}
+var HoverGesture = class extends Feature {
+	mount() {
+		let { current: e } = this.node;
+		e && (this.unmount = hover(e, (e, g) => (handleHoverEvent(this.node, g, "Start"), (e) => handleHoverEvent(this.node, e, "End"))));
+	}
+	unmount() {}
+}, FocusGesture = class extends Feature {
+	constructor() {
+		super(...arguments), this.isActive = !1;
+	}
+	onFocus() {
+		let e = !1;
+		try {
+			e = this.node.current.matches(":focus-visible");
+		} catch {
+			e = !0;
+		}
+		!e || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+	}
+	onBlur() {
+		!this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+	}
+	mount() {
+		this.unmount = pipe(addDomEvent(this.node.current, "focus", () => this.onFocus()), addDomEvent(this.node.current, "blur", () => this.onBlur()));
+	}
+	unmount() {}
+};
+function handlePressEvent(e, g, _) {
+	let { props: v } = e;
+	if (e.current instanceof HTMLButtonElement && e.current.disabled) return;
+	e.animationState && v.whileTap && e.animationState.setActive("whileTap", _ === "Start");
+	let y = v["onTap" + (_ === "End" ? "" : _)];
+	y && frame.postRender(() => y(g, extractEventInfo(g)));
+}
+var PressGesture = class extends Feature {
+	mount() {
+		let { current: e } = this.node;
+		if (!e) return;
+		let { globalTapTarget: g, propagate: _ } = this.node.props;
+		this.unmount = press(e, (e, g) => (handlePressEvent(this.node, g, "Start"), (e, { success: g }) => handlePressEvent(this.node, e, g ? "End" : "Cancel")), {
+			useGlobalTarget: g,
+			stopPropagation: _?.tap === !1
+		});
+	}
+	unmount() {}
+}, observerCallbacks = /* @__PURE__ */ new WeakMap(), observers = /* @__PURE__ */ new WeakMap(), fireObserverCallback = (e) => {
+	let g = observerCallbacks.get(e.target);
+	g && g(e);
+}, fireAllObserverCallbacks = (e) => {
+	e.forEach(fireObserverCallback);
+};
+function initIntersectionObserver({ root: e, ...g }) {
+	let _ = e || document;
+	observers.has(_) || observers.set(_, {});
+	let v = observers.get(_), y = JSON.stringify(g);
+	return v[y] || (v[y] = new IntersectionObserver(fireAllObserverCallbacks, {
+		root: e,
+		...g
+	})), v[y];
+}
+function observeIntersection(e, g, _) {
+	let v = initIntersectionObserver(g);
+	return observerCallbacks.set(e, _), v.observe(e), () => {
+		observerCallbacks.delete(e), v.unobserve(e);
+	};
+}
+var thresholdNames = {
+	some: 0,
+	all: 1
+}, InViewFeature = class extends Feature {
+	constructor() {
+		super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+	}
+	startObserver() {
+		this.unmount();
+		let { viewport: e = {} } = this.node.getProps(), { root: g, margin: _, amount: v = "some", once: y } = e, b = {
+			root: g ? g.current : void 0,
+			rootMargin: _,
+			threshold: typeof v == "number" ? v : thresholdNames[v]
+		};
+		return observeIntersection(this.node.current, b, (e) => {
+			let { isIntersecting: g } = e;
+			if (this.isInView === g || (this.isInView = g, y && !g && this.hasEnteredView)) return;
+			g && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", g);
+			let { onViewportEnter: _, onViewportLeave: v } = this.node.getProps(), b = g ? _ : v;
+			b && b(e);
+		});
+	}
+	mount() {
+		this.startObserver();
+	}
+	update() {
+		if (typeof IntersectionObserver > "u") return;
+		let { props: e, prevProps: g } = this.node;
+		[
+			"amount",
+			"margin",
+			"root"
+		].some(hasViewportOptionChanged(e, g)) && this.startObserver();
+	}
+	unmount() {}
+};
+function hasViewportOptionChanged({ viewport: e = {} }, { viewport: g = {} } = {}) {
+	return (_) => e[_] !== g[_];
+}
+var gestureAnimations = {
+	inView: { Feature: InViewFeature },
+	tap: { Feature: PressGesture },
+	focus: { Feature: FocusGesture },
+	hover: { Feature: HoverGesture }
+}, layout = { layout: {
+	ProjectionNode: HTMLProjectionNode,
+	MeasureLayout
+} }, motion = /* @__PURE__ */ createMotionProxy({
+	...animations,
+	...gestureAnimations,
+	...drag,
+	...layout
+}, createDomVisualElement), box_module_default = { box: "box-module__box___FP5Js" };
+const Box = ({ children: e, position: g }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(motion.div, {
+	className: box_module_default.box,
+	"data-position": g,
+	children: e
+});
+export { isHTMLElement as a, useConstant as c, MotionConfigContext as i, LayoutGroupContext as l, motion as n, PresenceContext as o, usePresence as r, useIsomorphicLayoutEffect as s, Box as t, require_jsx_runtime as u };