gclass-anims 1.0.0-beta.21 → 1.0.0-beta.22

package/dist/gclass.cjs

@@ -0,0 +1,3268 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let gsap = require("gsap");
+let gsap_all = require("gsap/all");
+//#region Config.js
+var defaults = {
+	orderDivide: 5,
+	spawnDelayMultiplier: .2,
+	spawnOffset: 20,
+	clickOffset: 10,
+	clickExpandOffset: 15,
+	clickDuration: .2,
+	ease: "back",
+	effectDelay: .5,
+	effectDuration: 1,
+	effectOffset: 20,
+	progressStart: "top bottom",
+	progressEnd: "center center",
+	textStagger: .03,
+	typewriterSplitCharDuration: .05,
+	minTextPartDuration: .3,
+	revealDelay: 0,
+	characterlist: "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz",
+	bootTime: 5,
+	breakpoints: {
+		xs: 475,
+		s: 640,
+		m: 768,
+		l: 1024,
+		xl: 1280
+	}
+};
+var animations = [
+	{
+		sel: ".spawn-down",
+		from: {
+			opacity: 0,
+			y: -defaults.spawnOffset
+		},
+		play: (el, delay, dur, ease) => SpawnV(el, delay, -defaults.spawnOffset, dur, ease)
+	},
+	{
+		sel: ".spawn-up",
+		from: {
+			opacity: 0,
+			y: defaults.spawnOffset
+		},
+		play: (el, delay, dur, ease) => SpawnV(el, delay, defaults.spawnOffset, dur, ease)
+	},
+	{
+		sel: ".spawn-left",
+		from: {
+			opacity: 0,
+			x: -defaults.spawnOffset
+		},
+		play: (el, delay, dur, ease) => SpawnH(el, delay, -defaults.spawnOffset, dur, ease)
+	},
+	{
+		sel: ".spawn-right",
+		from: {
+			opacity: 0,
+			x: defaults.spawnOffset
+		},
+		play: (el, delay, dur, ease) => SpawnH(el, delay, defaults.spawnOffset, dur, ease)
+	},
+	{
+		sel: ".spawn-cw",
+		from: {
+			scale: 0,
+			rotation: -360
+		},
+		play: (el, delay, dur, ease) => spawnSpinCW(el, delay, dur, ease)
+	},
+	{
+		sel: ".spawn-ccw",
+		from: {
+			scale: 0,
+			rotation: 360
+		},
+		play: (el, delay, dur, ease) => spawnSpinCCW(el, delay, dur, ease)
+	},
+	{
+		sel: ".spawn-fade",
+		from: { opacity: 0 },
+		play: (el, delay, dur, ease) => spawnFade(el, delay, dur, ease)
+	},
+	{
+		sel: ".spawn-blur",
+		from: {
+			opacity: 0,
+			filter: "blur(20px)"
+		},
+		play: (el, delay, dur, ease) => spawnBlur(el, delay, dur, ease)
+	},
+	{
+		sel: ".spawn-x-down",
+		from: {
+			scale: 0,
+			rotationX: -360
+		},
+		play: (el, delay, dur, ease) => spawnXDown(el, delay, dur, ease)
+	},
+	{
+		sel: ".spawn-x-up",
+		from: {
+			scale: 0,
+			rotationX: 360
+		},
+		play: (el, delay, dur, ease) => spawnXUp(el, delay, dur, ease)
+	},
+	{
+		sel: ".spawn-y-right",
+		from: {
+			scale: 0,
+			rotationY: -360
+		},
+		play: (el, delay, dur, ease) => spawnYRight(el, delay, dur, ease)
+	},
+	{
+		sel: ".spawn-y-left",
+		from: {
+			scale: 0,
+			rotationY: 360
+		},
+		play: (el, delay, dur, ease) => spawnYLeft(el, delay, dur, ease)
+	},
+	{
+		sel: ".expand-vertical",
+		from: {
+			opacity: 0,
+			scaleY: 0
+		},
+		play: (el, delay, dur, ease) => expandV(el, delay, dur, ease)
+	},
+	{
+		sel: ".expand-horizontal",
+		from: {
+			opacity: 0,
+			scaleX: 0
+		},
+		play: (el, delay, dur, ease) => expandH(el, delay, dur, ease)
+	},
+	{
+		sel: ".expand-right",
+		from: {
+			opacity: 0,
+			scaleX: 0
+		},
+		play: (el, delay, dur, ease) => expandRight(el, delay, dur, ease)
+	},
+	{
+		sel: ".expand-left",
+		from: {
+			opacity: 0,
+			scaleX: 0
+		},
+		play: (el, delay, dur, ease) => expandLeft(el, delay, dur, ease)
+	},
+	{
+		sel: ".expand-up",
+		from: {
+			opacity: 0,
+			scaleY: 0
+		},
+		play: (el, delay, dur, ease) => expandUp(el, delay, dur, ease)
+	},
+	{
+		sel: ".expand-down",
+		from: {
+			opacity: 0,
+			scaleY: 0
+		},
+		play: (el, delay, dur, ease) => expandDown(el, delay, dur, ease)
+	},
+	{
+		sel: ".expand-all",
+		from: {
+			opacity: 0,
+			scale: 0
+		},
+		play: (el, delay, dur, ease) => expandA(el, delay, dur, ease)
+	},
+	{
+		sel: ".typewriter",
+		typewriter: true,
+		from: { text: "" },
+		play: (el, delay, dur, ease) => typewriter(el, stashText(el), dur, delay, ease)
+	},
+	{
+		sel: ".typewriter-split",
+		typewriter: true,
+		typewriterSplit: true,
+		from: { opacity: 0 },
+		play: (el, delay, dur, ease) => null
+	},
+	{
+		sel: ".scramble",
+		scramble: true,
+		text: false,
+		play: (el, delay, dur, ease) => scramble(el, delay, dur, ease)
+	},
+	{
+		sel: ".scramble-all",
+		scramble: true,
+		text: false,
+		play: (el, delay, dur, ease) => scramble(el, delay, dur, ease)
+	},
+	{
+		sel: ".count",
+		count: true,
+		text: false,
+		from: { opacity: 0 },
+		play: (el, delay, dur, ease) => countUp(el, delay, dur, ease)
+	},
+	{
+		sel: ".clip-reveal-up",
+		text: false,
+		from: { clipPath: "inset(0% 0% 100% 0%)" },
+		play: (el, delay, dur, ease) => spawnClipReveal(el, delay, dur, ease, "up")
+	},
+	{
+		sel: ".clip-reveal-down",
+		text: false,
+		from: { clipPath: "inset(100% 0% 0% 0%)" },
+		play: (el, delay, dur, ease) => spawnClipReveal(el, delay, dur, ease, "down")
+	},
+	{
+		sel: ".clip-reveal-left",
+		text: false,
+		from: { clipPath: "inset(0% 0% 0% 100%)" },
+		play: (el, delay, dur, ease) => spawnClipReveal(el, delay, dur, ease, "left")
+	},
+	{
+		sel: ".clip-reveal-right",
+		text: false,
+		from: { clipPath: "inset(0% 100% 0% 0%)" },
+		play: (el, delay, dur, ease) => spawnClipReveal(el, delay, dur, ease, "right")
+	},
+	{
+		sel: ".clip-reveal",
+		text: false,
+		from: { clipPath: "inset(0% 0% 100% 0%)" },
+		play: (el, delay, dur, ease) => spawnClipReveal(el, delay, dur, ease, "up")
+	},
+	{
+		sel: ".curtain-horizontal",
+		text: false,
+		from: { clipPath: "inset(0% 50% 0% 50%)" },
+		play: (el, delay, dur, ease) => curtainHorizontal(el, delay, dur, ease)
+	},
+	{
+		sel: ".curtain-vertical",
+		text: false,
+		from: { clipPath: "inset(50% 0% 50% 0%)" },
+		play: (el, delay, dur, ease) => curtainVertical(el, delay, dur, ease)
+	},
+	{
+		sel: ".draw",
+		text: false,
+		from: { drawSVG: "0%" },
+		play: (el, delay, dur, ease) => drawsvg(el, delay, dur, ease)
+	},
+	{
+		sel: ".draw-split",
+		text: false,
+		from: { drawSVG: "0%" },
+		play: (el, delay, dur, ease) => drawsvgSplit(el, delay, dur, ease)
+	},
+	{
+		sel: ".shake",
+		build: (el, { edelay, amount, etime, ease }) => shake(edelay, el, amount, etime, ease),
+		key: "shakeanim"
+	},
+	{
+		sel: ".spin-cw",
+		build: (el, { edelay, etime, ease }) => spinCW(el, edelay, etime, ease),
+		key: "spinCW"
+	},
+	{
+		sel: ".spin-ccw",
+		build: (el, { edelay, etime, ease }) => spinCCW(el, edelay, etime, ease),
+		key: "spinCW"
+	},
+	{
+		sel: ".bounce",
+		build: (el, { edelay, amount, etime, ease }) => bounce(edelay, el, amount, etime, ease),
+		key: "bounce"
+	},
+	{
+		sel: ".bell",
+		build: (el, { edelay, amount, etime, ease }) => bell(edelay, el, amount, etime, ease),
+		key: "bell"
+	},
+	{
+		sel: ".pulse",
+		build: (el, { edelay, amount, etime, ease }) => pulse(edelay, el, amount, etime, ease),
+		key: "pulse"
+	},
+	{
+		sel: ".radiate",
+		build: (el, { edelay, amount, etime, ease, radiateZ }) => radiate(edelay, el, amount, etime, ease, radiateZ),
+		key: "radiate"
+	},
+	{
+		sel: ".float",
+		build: (el, { edelay, amount, etime, ease }) => hover(edelay, el, amount, etime, ease),
+		key: "float"
+	},
+	{
+		sel: ".marquee-left",
+		build: (el, ctx) => marquee(el, "left", ctx.time, ctx.mH, ctx.mV, el.classList.contains("marquee-no-repeat")),
+		key: "marquee"
+	},
+	{
+		sel: ".marquee-right",
+		build: (el, ctx) => marquee(el, "right", ctx.time, ctx.mH, ctx.mV, el.classList.contains("marquee-no-repeat")),
+		key: "marquee"
+	},
+	{
+		sel: ".marquee-up",
+		build: (el, ctx) => marquee(el, "up", ctx.time, ctx.mH, ctx.mV, el.classList.contains("marquee-no-repeat")),
+		key: "marquee"
+	},
+	{
+		sel: ".marquee-down",
+		build: (el, ctx) => marquee(el, "down", ctx.time, ctx.mH, ctx.mV, el.classList.contains("marquee-no-repeat")),
+		key: "marquee"
+	}
+];
+function normalize(extra = []) {
+	const all = animations.concat(extra);
+	return {
+		all,
+		spawnConfigs: all.filter((a) => a.play).map((a) => ({
+			sel: a.sel,
+			from: a.from,
+			play: a.play,
+			typewriter: a.typewriter,
+			typewriterSplit: a.typewriterSplit,
+			text: a.text !== false,
+			count: a.count,
+			scramble: a.scramble
+		})),
+		loopConfigs: all.filter((a) => a.build).map((a) => ({
+			sel: a.sel,
+			build: a.build,
+			key: a.key || a.sel.slice(1),
+			loop: a.loop !== false
+		}))
+	};
+}
+//#endregion
+//#region Animations.js
+gsap.gsap.registerPlugin(gsap_all.Flip);
+gsap.gsap.registerPlugin(gsap_all.SplitText);
+gsap.gsap.registerPlugin(gsap_all.TextPlugin);
+gsap.gsap.registerPlugin(gsap_all.DrawSVGPlugin);
+gsap.gsap.registerPlugin(gsap_all.MotionPathPlugin);
+gsap.gsap.registerPlugin(gsap_all.ScrambleTextPlugin);
+var getBpDataMod = () => {
+	const entries = Object.entries(defaults.breakpoints || {}).sort((a, b) => a[1] - b[1]);
+	const names = entries.map(([k]) => k);
+	return {
+		entries,
+		names,
+		map: Object.fromEntries(entries),
+		re: names.length ? new RegExp(`^(${names.join("|")}):(.+)$`) : /^$^/
+	};
+};
+var isBreakpointActiveMod = (bp) => {
+	if (!bp) return true;
+	const { map } = getBpDataMod();
+	const px = map[bp];
+	if (px == null) return true;
+	if (typeof window === "undefined" || !window.matchMedia) return true;
+	return window.matchMedia(`(min-width: ${px}px)`).matches;
+};
+var hasGClassMod = (el, name) => {
+	if (el.classList.contains(name)) return true;
+	const { names } = getBpDataMod();
+	for (const bp of names) if (el.classList.contains(`${bp}:${name}`) && isBreakpointActiveMod(bp)) return true;
+	return false;
+};
+var getActivePrefixedClassMod = (el, prefix) => {
+	const { names, map, re } = getBpDataMod();
+	let best = null, bestPx = -2;
+	for (const c of el.classList) {
+		let bp = null, core = c;
+		const m = c.match(re);
+		if (m) {
+			bp = m[1];
+			core = m[2];
+		}
+		if (!core.startsWith(prefix)) continue;
+		if (bp && !isBreakpointActiveMod(bp)) continue;
+		const px = bp ? map[bp] : -1;
+		if (px > bestPx) {
+			best = c;
+			bestPx = px;
+		}
+	}
+	return best;
+};
+var DEFAULT_EASE = "power3.out";
+var easeOf = (e) => e || DEFAULT_EASE;
+var finalOpacity = (target) => {
+	const had = target.style.opacity;
+	target.style.removeProperty("opacity");
+	const v = parseFloat(getComputedStyle(target).opacity);
+	if (had !== "") target.style.opacity = had;
+	return isNaN(v) ? 1 : v;
+};
+var stashText = (el) => {
+	const busy = (el.typewriter || el._spawnTween || el._scrollTween)?.isActive?.();
+	const html = el.innerHTML;
+	if (!busy && html && html.trim()) el._gcText = html;
+	return el._gcText !== void 0 ? el._gcText : html;
+};
+function SpawnV(target, delay, dir, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		opacity: 0,
+		y: dir,
+		scale: .97
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		y: 0,
+		opacity: finalOpacity(target),
+		scale: 1
+	});
+}
+function SpawnH(target, delay, dir, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		opacity: 0,
+		x: dir,
+		scale: .97
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		x: 0,
+		opacity: finalOpacity(target),
+		scale: 1
+	});
+}
+function expandV(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		opacity: 1,
+		scaleY: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scaleY: 1,
+		opacity: finalOpacity(target),
+		transformOrigin: "50% 50%"
+	});
+}
+function expandH(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		opacity: 1,
+		scaleX: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scaleX: 1,
+		opacity: finalOpacity(target),
+		transformOrigin: "50% 50%"
+	});
+}
+function expandA(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		opacity: 1,
+		scale: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scale: 1,
+		opacity: finalOpacity(target),
+		transformOrigin: "50% 50%"
+	});
+}
+function typewriter(target, text, dur, delay, ease) {
+	gsap.gsap.utils.toArray(target).forEach((el) => {
+		if (el.style) el.style.whiteSpace = "pre-wrap";
+	});
+	const value = String(text).replace(/\n/g, "<br>");
+	return gsap.gsap.fromTo(target, { text: "" }, {
+		ease: easeOf(ease),
+		duration: dur,
+		delay,
+		text: { value }
+	});
+}
+function spawnSpinCCW(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		scale: 0,
+		rotation: -90
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scale: 1,
+		rotation: 0,
+		transformOrigin: "50% 50%"
+	});
+}
+function spawnSpinCW(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		scale: 0,
+		rotation: 90
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scale: 1,
+		rotation: 0,
+		transformOrigin: "50% 50%"
+	});
+}
+function spawnFade(target, delay, dur, ease) {
+	return gsap.gsap.fromTo(target, { opacity: 0 }, {
+		ease: easeOf(ease),
+		duration: dur,
+		delay,
+		opacity: finalOpacity(target)
+	});
+}
+function spawnBlur(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		opacity: 0,
+		filter: "blur(20px)"
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		opacity: finalOpacity(target),
+		filter: "blur(0px)"
+	});
+}
+var CLIP_FROM = {
+	up: "inset(0% 0% 100% 0%)",
+	down: "inset(100% 0% 0% 0%)",
+	left: "inset(0% 0% 0% 100%)",
+	right: "inset(0% 100% 0% 0%)"
+};
+function spawnClipReveal(target, delay, dur, ease, dir = "up") {
+	const from = CLIP_FROM[dir] || CLIP_FROM.up;
+	return gsap.gsap.fromTo(target, { clipPath: from }, {
+		clipPath: "inset(0% 0% 0% 0%)",
+		ease: easeOf(ease),
+		duration: dur,
+		delay
+	});
+}
+function curtainHorizontal(target, delay, dur, ease) {
+	return gsap.gsap.fromTo(target, { clipPath: "inset(0% 50% 0% 50%)" }, {
+		clipPath: "inset(0% 0% 0% 0%)",
+		ease: easeOf(ease),
+		duration: dur,
+		delay
+	});
+}
+function curtainVertical(target, delay, dur, ease) {
+	return gsap.gsap.fromTo(target, { clipPath: "inset(50% 0% 50% 0%)" }, {
+		clipPath: "inset(0% 0% 0% 0%)",
+		ease: easeOf(ease),
+		duration: dur,
+		delay
+	});
+}
+function spawnXUp(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		scale: 0,
+		rotationX: 360,
+		opacity: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scale: 1,
+		rotationX: 0,
+		opacity: finalOpacity(target),
+		transformOrigin: "50% 50%"
+	});
+}
+function spawnXDown(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		scale: 0,
+		rotationX: -360,
+		opacity: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scale: 1,
+		rotationX: 0,
+		opacity: finalOpacity(target),
+		transformOrigin: "50% 50%"
+	});
+}
+function spawnYRight(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		scale: 0,
+		rotationY: 360,
+		opacity: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scale: 1,
+		rotationY: 0,
+		opacity: finalOpacity(target),
+		transformOrigin: "50% 50%"
+	});
+}
+function spawnYLeft(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.fromTo(target, {
+		scale: 0,
+		rotationY: -360,
+		opacity: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scale: 1,
+		rotationY: 0,
+		opacity: finalOpacity(target),
+		transformOrigin: "50% 50%"
+	});
+}
+function expandRight(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.set(target, { transformOrigin: "100% 50%" }).fromTo(target, {
+		opacity: 1,
+		scaleX: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scaleX: 1,
+		opacity: finalOpacity(target)
+	});
+	return tl;
+}
+function expandLeft(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.set(target, { transformOrigin: "0% 50%" }).fromTo(target, {
+		opacity: 1,
+		scaleX: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scaleX: 1,
+		opacity: finalOpacity(target)
+	});
+	return tl;
+}
+function expandUp(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.set(target, { transformOrigin: "50% 100%" }).fromTo(target, {
+		opacity: 1,
+		scaleY: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scaleY: 1,
+		opacity: finalOpacity(target)
+	});
+	return tl;
+}
+function expandDown(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.set(target, { transformOrigin: "50% 0%" }).fromTo(target, {
+		opacity: 1,
+		scaleY: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		scaleY: 1,
+		opacity: finalOpacity(target)
+	});
+	return tl;
+}
+function countTargetVars(target) {
+	if (target._countTarget) return target._countTarget;
+	const match = (target.textContent || "0").replace(/,/g, "").match(/-?\d+(?:\.\d+)?/);
+	const end = match ? parseFloat(match[0]) : 0;
+	const decimals = match?.[0].includes(".") ? (match[0].split(".")[1] || "").length : 0;
+	const startCls = getActivePrefixedClassMod(target, "spawn-num-");
+	return target._countTarget = {
+		start: startCls ? parseFloat(startCls.slice(startCls.indexOf("spawn-num-") + 10)) : 0,
+		end,
+		decimals
+	};
+}
+function countUp(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const { start, end, decimals } = countTargetVars(target);
+	const obj = { n: start };
+	return gsap.gsap.timeline({ delay }).fromTo(obj, { n: start }, {
+		n: end,
+		duration: dur,
+		ease: e,
+		onUpdate: () => {
+			target.textContent = obj.n.toFixed(decimals);
+		}
+	}, 0);
+}
+var fillTimeOf = (el, fallback) => {
+	const m = getActivePrefixedClassMod(el, "fill-time-");
+	return m ? Number(m.slice(m.indexOf("fill-time-") + 10)) : fallback * .5;
+};
+var fillEaseOf = (el, fallbackEase) => {
+	const m = getActivePrefixedClassMod(el, "fill-ease-");
+	return m ? m.slice(m.indexOf("fill-ease-") + 10) : fallbackEase;
+};
+function drawsvg(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const first = gsap.gsap.utils.toArray(target)[0];
+	if (!(!!first && hasGClassMod(first, "fill-svg"))) return gsap.gsap.fromTo(target, { drawSVG: "0%" }, {
+		ease: e,
+		duration: dur,
+		delay,
+		drawSVG: "100%"
+	});
+	const fillDur = fillTimeOf(first, dur);
+	const fillEase = fillEaseOf(first, ease);
+	const fillTargets = gsap.gsap.utils.toArray(target).filter((el) => hasGClassMod(el, "fill-svg"));
+	const tl = gsap.gsap.timeline({ delay });
+	if (fillTargets.length) gsap.gsap.set(fillTargets, { fillOpacity: 0 });
+	tl.fromTo(target, { drawSVG: "0%" }, {
+		ease: e,
+		duration: dur,
+		drawSVG: "100%"
+	});
+	if (fillTargets.length) tl.fromTo(fillTargets, { fillOpacity: 0 }, {
+		ease: easeOf(fillEase),
+		duration: fillDur,
+		fillOpacity: 1
+	});
+	return tl;
+}
+function splitPaths(paths) {
+	const toSplit = gsap.gsap.utils.toArray(paths);
+	let newPaths = [];
+	if (toSplit.length > 1) {
+		toSplit.forEach((path) => newPaths.push(...splitPaths(path)));
+		return newPaths;
+	}
+	const path = toSplit[0];
+	if (!path) return newPaths;
+	if (path._gcSplitPaths?.[0]?.isConnected) return path._gcSplitPaths;
+	const rawPath = gsap_all.MotionPathPlugin.getRawPath(path);
+	const parent = path.parentNode;
+	const attributes = [...path.attributes];
+	newPaths = rawPath.map((segment) => {
+		const newPath = document.createElementNS("http://www.w3.org/2000/svg", "path");
+		let i = attributes.length;
+		while (i--) {
+			const attr = attributes[i];
+			if (attr.nodeName === "class") {
+				const filtered = attr.nodeValue.split(/\s+/).filter((c) => c && c !== "appear" && c !== "scroll" && c !== "scroll-progress" && c !== "draw" && c !== "draw-split").join(" ");
+				if (filtered) newPath.setAttributeNS(null, "class", filtered);
+				continue;
+			}
+			if (attr.nodeName.startsWith("data-gsap")) continue;
+			newPath.setAttributeNS(null, attr.nodeName, attr.nodeValue);
+		}
+		newPath.setAttributeNS(null, "d", "M" + segment[0] + "," + segment[1] + "C" + segment.slice(2).join(",") + (segment.closed ? "z" : ""));
+		newPath.dataset.gsapSplit = "1";
+		newPath.style.contain = "paint";
+		newPath.style.willChange = "transform";
+		parent.insertBefore(newPath, path);
+		return newPath;
+	});
+	parent.removeChild(path);
+	return path._gcSplitPaths = newPaths;
+}
+function drawsvgSplit(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const first = gsap.gsap.utils.toArray(target)[0];
+	const hasFill = !!first && hasGClassMod(first, "fill-svg");
+	const fillDur = hasFill ? fillTimeOf(first, dur) : 0;
+	const fillEase = hasFill ? fillEaseOf(first, ease) : ease;
+	const tl = gsap.gsap.timeline({ delay });
+	const paths = splitPaths(target);
+	let distance = 0;
+	paths.forEach((segment) => distance += segment.getTotalLength());
+	if (!distance) return tl;
+	if (hasFill && paths.length) gsap.gsap.set(paths, { fillOpacity: 0 });
+	paths.forEach((segment) => {
+		tl.fromTo(segment, { drawSVG: "0%" }, {
+			ease: e,
+			duration: dur * (segment.getTotalLength() / distance),
+			drawSVG: "100%"
+		});
+	});
+	if (hasFill && paths.length) tl.fromTo(paths, { fillOpacity: 0 }, {
+		ease: easeOf(fillEase),
+		duration: fillDur,
+		fillOpacity: 1
+	});
+	return tl;
+}
+var scrambleSegments = (target) => {
+	let wraps = target._gcScrambleSegs;
+	if (!wraps || !wraps.length || !wraps.every((w) => w.parentNode === target)) {
+		wraps = [];
+		[...target.childNodes].forEach((node) => {
+			if (node.nodeType !== 3 || !node.textContent.trim()) return;
+			const raw = node.textContent;
+			const core = raw.trim();
+			const leadIdx = raw.indexOf(core[0]);
+			const trailStart = leadIdx + core.length;
+			const frag = document.createDocumentFragment();
+			if (leadIdx > 0) frag.appendChild(document.createTextNode(raw.slice(0, leadIdx)));
+			const span = document.createElement("span");
+			span.textContent = core;
+			frag.appendChild(span);
+			if (trailStart < raw.length) frag.appendChild(document.createTextNode(raw.slice(trailStart)));
+			target.insertBefore(frag, node);
+			target.removeChild(node);
+			wraps.push(span);
+		});
+		target._gcScrambleSegs = wraps;
+	}
+	return wraps.map((w) => ({
+		t: w,
+		text: w.textContent
+	}));
+};
+function scrambleVars(target) {
+	const num = (prefix, fallback) => {
+		const c = getActivePrefixedClassMod(target, prefix);
+		if (!c) return fallback;
+		const idx = c.indexOf(prefix);
+		const n = Number(c.slice(idx + prefix.length));
+		return Number.isNaN(n) ? fallback : n;
+	};
+	let charsCls = null;
+	let bestPx = -2;
+	const { re: reChars, map: mapChars } = getBpDataMod();
+	for (const c of target.classList) {
+		let bp = null, core = c;
+		const m = c.match(reChars);
+		if (m) {
+			bp = m[1];
+			core = m[2];
+		}
+		if (!/^chars-\[(.*)\]$/.test(core)) continue;
+		if (bp && !isBreakpointActiveMod(bp)) continue;
+		const px = bp ? mapChars[bp] : -1;
+		if (px > bestPx) {
+			charsCls = core;
+			bestPx = px;
+		}
+	}
+	return {
+		segs: scrambleSegments(target),
+		chars: charsCls ? charsCls.slice(7, -1) : defaults.characterlist,
+		speed: num("amount-", 1),
+		revealDelay: num("reveal-delay-", defaults.revealDelay),
+		rtl: hasGClassMod(target, "scramble-rtl")
+	};
+}
+function scramble(target, delay, dur, ease) {
+	const e = getActivePrefixedClassMod(target, "ease-") ? easeOf(ease) : "none";
+	const { segs, chars, speed, revealDelay, rtl } = scrambleVars(target);
+	const all = hasGClassMod(target, "scramble-all");
+	const tl = gsap.gsap.timeline({ delay });
+	segs.forEach(({ t, text }) => {
+		if (all) tl.to(t, {
+			scrambleText: {
+				text,
+				chars,
+				speed,
+				revealDelay,
+				rightToLeft: rtl
+			},
+			ease: e,
+			duration: dur
+		}, 0);
+		else tl.fromTo(t, { scrambleText: {
+			text: "",
+			chars
+		} }, {
+			scrambleText: {
+				text,
+				chars,
+				speed,
+				revealDelay,
+				rightToLeft: rtl
+			},
+			ease: e,
+			duration: dur
+		}, 0);
+	});
+	return tl;
+}
+function verticalmove(target, amount, dur, ease) {
+	const e = easeOf(ease);
+	return gsap.gsap.to(target, {
+		y: amount,
+		scale: 1 + amount / 1e3,
+		duration: dur,
+		ease: e
+	});
+}
+function expandmove(target, amount, dur, ease) {
+	return gsap.gsap.to(target, {
+		scale: amount / 10,
+		duration: dur,
+		ease: easeOf(ease)
+	});
+}
+function magnet(target, x, y, scale, dur, ease) {
+	return gsap.gsap.to(target, {
+		x,
+		y,
+		scale,
+		duration: dur,
+		ease: easeOf(ease),
+		overwrite: "auto"
+	});
+}
+function magnet3d(target, x, y, scale, rotX, rotY, dur, ease) {
+	return gsap.gsap.to(target, {
+		x,
+		y,
+		scale,
+		rotationX: rotX,
+		rotationY: rotY,
+		transformOrigin: "50% 50%",
+		transformPerspective: 600,
+		duration: dur,
+		ease: easeOf(ease),
+		overwrite: "auto"
+	});
+}
+function reset(target, dur, ease) {
+	gsap.gsap.to(target, {
+		x: 0,
+		y: 0,
+		scale: 1,
+		duration: dur / 2,
+		ease
+	});
+}
+function spinCW(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.fromTo(target, {
+		scale: 1,
+		rotation: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		rotation: 360
+	}).to(target, {
+		scale: 1,
+		duration: delay
+	});
+	return tl;
+}
+function spinCCW(target, delay, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.fromTo(target, {
+		scale: 1,
+		rotation: 0
+	}, {
+		ease: e,
+		duration: dur,
+		delay,
+		rotation: -360
+	}).to(target, {
+		scale: 1,
+		duration: delay
+	});
+	return tl;
+}
+function bounce(delay, target, amount, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.set(target, { transformOrigin: "50% 100%" }).to(target, {
+		y: -amount - amount * .25,
+		scaleX: .97,
+		scaleY: 1.03,
+		duration: dur * .48,
+		ease: "power1.out"
+	}).to(target, {
+		y: 0,
+		scaleX: 1.08,
+		scaleY: .88,
+		duration: dur * .3,
+		ease: "power2.in"
+	}).to(target, {
+		y: 0,
+		scaleX: 1,
+		scaleY: 1,
+		duration: dur * .12,
+		ease: e
+	}).to(target, {
+		x: 0,
+		duration: delay
+	});
+	return tl;
+}
+function shake(delay, target, amount, dur, ease) {
+	const tl = gsap.gsap.timeline();
+	tl.to(target, {
+		x: amount,
+		duration: dur * .1,
+		ease: "power2.out"
+	}).to(target, {
+		x: -amount * .8,
+		duration: dur * .15,
+		ease: "power2.inOut"
+	}).to(target, {
+		x: amount * .5,
+		duration: dur * .2,
+		ease: "power2.inOut"
+	}).to(target, {
+		x: -amount * .25,
+		duration: dur * .2,
+		ease: "power2.inOut"
+	}).to(target, {
+		x: 0,
+		duration: dur * .2,
+		ease: easeOf(ease)
+	}).to(target, {
+		x: 0,
+		duration: delay
+	});
+	return tl;
+}
+function bell(delay, target, amount, dur, ease) {
+	const tl = gsap.gsap.timeline();
+	tl.set(target, { transformOrigin: "50% 0%" }).to(target, {
+		rotate: amount,
+		duration: dur * .12,
+		ease: "power2.out"
+	}).to(target, {
+		rotate: -amount * .7,
+		duration: dur * .18,
+		ease: "power2.inOut"
+	}).to(target, {
+		rotate: amount * .4,
+		duration: dur * .22,
+		ease: "power2.inOut"
+	}).to(target, {
+		rotate: -amount * .15,
+		duration: dur * .22,
+		ease: "power2.inOut"
+	}).to(target, {
+		rotate: 0,
+		duration: dur * .2,
+		ease: easeOf(ease)
+	}).to(target, {
+		rotate: 0,
+		duration: delay
+	});
+	return tl;
+}
+function pulse(delay, target, amount, dur, ease) {
+	const e = easeOf(ease);
+	const tl = gsap.gsap.timeline();
+	tl.to(target, {
+		scale: amount / 10 * 1.05,
+		duration: dur * .35,
+		ease: "power2.out"
+	}).to(target, {
+		scale: 1,
+		duration: dur * .45,
+		ease: e
+	}).to(target, {
+		scale: 1,
+		duration: delay
+	});
+	return tl;
+}
+function radiate(delay, target, amount, dur, ease, zIndex) {
+	const clone = target.cloneNode(true);
+	clone.setAttribute("data-gsap-radiate", "1");
+	clone.style.cssText = `position:fixed;left:0;top:0;right:auto;bottom:auto;margin:0;pointer-events:none;transform-origin:50% 50%;${zIndex != null ? `z-index:${zIndex};` : ""}`;
+	let tick = false;
+	const applyRect = () => {
+		const r = target.getBoundingClientRect();
+		clone.style.left = `${r.left}px`;
+		clone.style.top = `${r.top}px`;
+		clone.style.width = `${r.width}px`;
+		clone.style.height = `${r.height}px`;
+	};
+	const schedule = () => {
+		if (tick) return;
+		tick = true;
+		requestAnimationFrame(() => {
+			tick = false;
+			applyRect();
+		});
+	};
+	if (!target.isConnected) return gsap.gsap.fromTo(clone, {}, { duration: 0 });
+	document.body.appendChild(clone);
+	applyRect();
+	window.addEventListener("scroll", schedule, { passive: true });
+	window.addEventListener("resize", schedule, { passive: true });
+	let tween = null;
+	const cleanup = () => {
+		clone.remove();
+		window.removeEventListener("scroll", schedule);
+		window.removeEventListener("resize", schedule);
+		if (observer) observer.disconnect();
+	};
+	const observer = new MutationObserver(() => {
+		if (!target.isConnected) {
+			if (tween) tween.kill();
+			cleanup();
+		}
+	});
+	observer.observe(document.body, {
+		childList: true,
+		subtree: true
+	});
+	tween = gsap.gsap.fromTo(clone, {
+		scale: 1,
+		opacity: 1
+	}, {
+		scale: amount / 10,
+		opacity: 0,
+		duration: dur,
+		delay,
+		ease: easeOf(ease),
+		onComplete: () => {
+			observer.disconnect();
+			cleanup();
+		},
+		onInterrupt: () => {
+			observer.disconnect();
+			cleanup();
+		}
+	});
+	return tween;
+}
+function hover(delay, target, amount, dur, ease) {
+	const tl = gsap.gsap.timeline();
+	tl.set(target, { transformOrigin: "50% 50%" }).to(target, {
+		y: -amount,
+		scaleX: .98,
+		scaleY: 1.02,
+		duration: dur / 2,
+		ease: "sine.inOut"
+	}).to(target, {
+		y: 0,
+		scaleX: 1,
+		scaleY: 1,
+		duration: dur / 2,
+		ease: "sine.inOut"
+	});
+	return tl;
+}
+function marquee(target, dir, duration, xOffset = 0, yOffset = 0, noRepeat = false) {
+	const horizontal = dir === "left" || dir === "right";
+	target.style.position = "relative";
+	target.style.overflow = "hidden";
+	let track = target._gcTrack;
+	if (!track || !track.isConnected) {
+		track = document.createElement("div");
+		track.style.cssText = `position:absolute;top:${yOffset}px;left:${xOffset}px;display:flex;flex-direction:${horizontal ? "row" : "column"};width:max-content;will-change:transform;`;
+		while (target.firstChild) track.appendChild(target.firstChild);
+		target.appendChild(track);
+		while (track.children.length && [...track.children].every((c) => c.style.position === "absolute" && c.style.display === "flex")) {
+			const inner = track.firstElementChild;
+			while (inner.firstChild) track.insertBefore(inner.firstChild, inner);
+			track.removeChild(inner);
+		}
+		target._gcUnitHtml = track.innerHTML;
+	}
+	track.style.flexDirection = horizontal ? "row" : "column";
+	const unitHtml = target._gcUnitHtml;
+	const measurer = document.createElement("div");
+	measurer.style.cssText = track.style.cssText + "visibility:hidden;";
+	measurer.innerHTML = unitHtml;
+	target.appendChild(measurer);
+	const unitSize = horizontal ? measurer.scrollWidth : measurer.scrollHeight;
+	measurer.remove();
+	if (!unitSize) return gsap.gsap.fromTo(track, {}, { duration: 0 });
+	if (target.offsetHeight === 0 && track.offsetHeight > 0) target.style.height = track.offsetHeight + "px";
+	let copies;
+	if (noRepeat) copies = 2;
+	else {
+		const viewport = horizontal ? target.offsetWidth : target.offsetHeight;
+		copies = Math.max(2, Math.ceil(viewport / unitSize) + 1);
+	}
+	track.innerHTML = unitHtml.repeat(copies);
+	const dist = unitSize;
+	const vars = {
+		duration,
+		ease: "none"
+	};
+	if (dir === "right") return gsap.gsap.fromTo(track, { x: -dist }, {
+		x: 0,
+		...vars
+	});
+	if (dir === "up") return gsap.gsap.fromTo(track, { y: 0 }, {
+		y: -dist,
+		...vars
+	});
+	if (dir === "down") return gsap.gsap.fromTo(track, { y: -dist }, {
+		y: 0,
+		...vars
+	});
+	return gsap.gsap.fromTo(track, { x: 0 }, {
+		x: -dist,
+		...vars
+	});
+}
+function flip(state, ease, dur) {
+	gsap_all.Flip.from(state, {
+		duration: dur,
+		ease: ease || DEFAULT_EASE
+	});
+}
+function animatecss(target, dur, delay, ease, propertyS, propertySValue, propertyE, propertyEValue) {
+	return gsap.gsap.fromTo(target, { [propertyS]: propertySValue }, {
+		[propertyE]: propertyEValue,
+		ease,
+		duration: dur,
+		delay
+	});
+}
+//#endregion
+//#region CustomAnims.js
+var customAnims = [{
+	sel: ".whirl",
+	from: {
+		opacity: 0,
+		rotation: 90,
+		scale: .7
+	},
+	play: (el, delay, dur, ease) => gsap.gsap.fromTo(el, {
+		opacity: 0,
+		rotation: 90,
+		scale: .7
+	}, {
+		ease,
+		duration: dur,
+		delay,
+		rotation: 0,
+		scale: 1,
+		opacity: 1,
+		transformOrigin: "center"
+	})
+}, {
+	sel: ".bounce-in",
+	from: {
+		opacity: 0,
+		scale: 0
+	},
+	play: (el, delay, dur, ease) => {
+		const tl = gsap.gsap.timeline({
+			delay,
+			defaults: {
+				ease,
+				duration: dur / 3
+			}
+		});
+		tl.fromTo(el, {
+			scale: 0,
+			opacity: 0
+		}, {
+			scale: 1.1,
+			opacity: 1
+		}).to(el, { scale: .95 }).to(el, { scale: 1 });
+		return tl;
+	}
+}];
+//#endregion
+//#region Listeners.js
+var TEXT_PREFIX = "spawn-text-";
+var TEXT_PREFIX_LEN = 11;
+var bpEntries = Object.entries(defaults.breakpoints || {}).sort((a, b) => a[1] - b[1]);
+var bpNames = bpEntries.map(([k]) => k);
+var bpMap = Object.fromEntries(bpEntries);
+var bpPrefixRE = bpNames.length ? new RegExp(`^(${bpNames.join("|")}):(.+)$`) : /^$^/;
+var isBreakpointActive = (bp) => {
+	if (!bp) return true;
+	const px = bpMap[bp];
+	if (px == null) return true;
+	if (typeof window === "undefined" || !window.matchMedia) return true;
+	return window.matchMedia(`(min-width: ${px}px)`).matches;
+};
+var mqForBp = (bp) => `(min-width: ${bpMap[bp]}px)`;
+var elementMatchesSel = (el, sel) => {
+	const base = sel.slice(1);
+	if (el.classList.contains(base)) return true;
+	for (const bp of bpNames) if (el.classList.contains(`${bp}:${base}`) && isBreakpointActive(bp)) return true;
+	return false;
+};
+var hasGClass = (el, name) => {
+	if (el.classList.contains(name)) return true;
+	for (const bp of bpNames) if (el.classList.contains(`${bp}:${name}`) && isBreakpointActive(bp)) return true;
+	return false;
+};
+var wrapQAll = (qAll) => (sel) => {
+	if (sel.includes(",")) {
+		const parts = sel.split(",").map((s) => s.trim()).filter(Boolean);
+		const set = /* @__PURE__ */ new Set();
+		parts.forEach((p) => wrapQAll(qAll)(p).forEach((e) => set.add(e)));
+		return [...set];
+	}
+	if (sel === "body *") return qAll(sel);
+	if (bpNames.some((bp) => sel.includes(`${bp}:`))) return qAll("body *").filter((el) => sel.split(",").some((s) => elementMatchesSel(el, s.trim())));
+	try {
+		const baseEls = qAll(sel);
+		const variantEls = qAll("body *").filter((el) => {
+			for (const bp of bpNames) if (el.classList.contains(`${bp}:${sel.slice(1)}`) && isBreakpointActive(bp)) return true;
+			return false;
+		});
+		return [.../* @__PURE__ */ new Set([...baseEls, ...variantEls])];
+	} catch {
+		return qAll(sel);
+	}
+};
+var completeHandlers = /* @__PURE__ */ new Map();
+function registerComplete(name, fn) {
+	if (typeof fn === "function") completeHandlers.set(name, fn);
+	return fn;
+}
+function resolveHandler(name) {
+	if (completeHandlers.has(name)) return completeHandlers.get(name);
+	if (typeof window !== "undefined" && typeof window[name] === "function") return window[name];
+	return null;
+}
+var RANDOMIZE_RE = /^randomize-(\w+)-\[(-?[\d.]+)\]-\[(-?[\d.]+)\]$/;
+var hasRandom = (el) => typeof el.className === "string" && /\brandomize-/.test(el.className);
+var randomVars = (el) => {
+	const rnd = {};
+	for (const c of el.classList) {
+		const m = c.match(RANDOMIZE_RE);
+		if (m) rnd[m[1]] = () => gsap.gsap.utils.random(Number(m[2]), Number(m[3]));
+	}
+	return rnd;
+};
+var randomEnds = (keys) => Object.fromEntries(keys.map((k) => [k, k === "opacity" ? 1 : k === "filter" ? "blur(0px)" : k === "clipPath" ? "inset(0% 0% 0% 0%)" : k === "drawSVG" ? "100%" : k.startsWith("scale") ? 1 : 0]));
+var invokePlay = (config, el, delay, dur, ease) => {
+	if (!hasRandom(el)) return config.play(el, delay, dur, ease);
+	const rnd = randomVars(el);
+	const keys = Object.keys(rnd);
+	if (!keys.length) return config.play(el, delay, dur, ease);
+	const ends = randomEnds(keys);
+	const origFromTo = gsap.gsap.fromTo;
+	gsap.gsap.fromTo = (t, from, to) => origFromTo(t, {
+		...from,
+		...rnd
+	}, {
+		...ends,
+		...to
+	});
+	try {
+		return config.play(el, delay, dur, ease);
+	} finally {
+		gsap.gsap.fromTo = origFromTo;
+	}
+};
+function initListeners(root = document, throttlePerFrame) {
+	if (typeof root === "number") {
+		throttlePerFrame = root;
+		root = document;
+	}
+	throttlePerFrame = Number(throttlePerFrame) || 0;
+	gsap.gsap.registerPlugin(gsap_all.TextPlugin, gsap_all.ScrollTrigger, gsap_all.SplitText);
+	const { all: animAll, spawnConfigs, loopConfigs } = normalize(customAnims);
+	const qAll = (sel) => {
+		if (root === document || root === document.documentElement || root === document.body) return gsap.gsap.utils.toArray(sel);
+		if (sel === "body *") return gsap.gsap.utils.toArray(root.querySelectorAll("*"));
+		try {
+			const els = [...root.querySelectorAll ? root.querySelectorAll(sel) : []];
+			if (root.matches?.(sel)) els.unshift(root);
+			return els;
+		} catch {
+			return gsap.gsap.utils.toArray(sel);
+		}
+	};
+	const mm = gsap.gsap.matchMedia();
+	const breakpointContexts = [];
+	const getGateBpForSel = (el, sel) => {
+		const base = sel.slice(1);
+		for (const bp of bpNames) if (el.classList.contains(`${bp}:${base}`)) return bp;
+		return null;
+	};
+	const getElGateBp = (el) => {
+		for (const c of el.classList) {
+			const m = c.match(bpPrefixRE);
+			if (m) return m[1];
+		}
+		return null;
+	};
+	const runWithBreakpoint = (el, fn) => {
+		const bp = getElGateBp(el);
+		if (!bp) {
+			fn();
+			return;
+		}
+		const mq = mqForBp(bp);
+		const ret = mm.add(mq, fn);
+		breakpointContexts.push(ret);
+	};
+	const runWithBreakpointForSel = (el, sel, fn) => {
+		const bp = getGateBpForSel(el, sel);
+		if (!bp) {
+			fn();
+			return;
+		}
+		const mq = mqForBp(bp);
+		const ret = mm.add(mq, fn);
+		breakpointContexts.push(ret);
+	};
+	const qAllAllVariants = (sel) => {
+		const base = sel.slice(1);
+		return qAll("body *").filter((el) => el.classList.contains(base) || bpNames.some((bp) => el.classList.contains(`${bp}:${base}`)));
+	};
+	const qAllActive = wrapQAll(qAll);
+	const registeredListeners = [];
+	const onCompleteTweens = [];
+	const addListener = (el, type, fn) => {
+		el.addEventListener(type, fn);
+		registeredListeners.push({
+			el,
+			type,
+			fn
+		});
+	};
+	const getActivePrefixedClass = (el, prefix) => {
+		let best = null;
+		let bestPx = -2;
+		for (const c of el.classList) {
+			let bp = null;
+			let core = c;
+			const m = c.match(bpPrefixRE);
+			if (m) {
+				bp = m[1];
+				core = m[2];
+			}
+			if (!core.startsWith(prefix)) continue;
+			if (bp && !isBreakpointActive(bp)) continue;
+			const px = bp ? bpMap[bp] : -1;
+			if (px > bestPx) {
+				best = c;
+				bestPx = px;
+			}
+		}
+		return best;
+	};
+	const extractNumber = (cls, prefix) => {
+		const idx = cls.indexOf(prefix);
+		if (idx === -1) return NaN;
+		return Number(cls.slice(idx + prefix.length));
+	};
+	const readClassNumber = (el, prefix, fallback) => {
+		const match = getActivePrefixedClass(el, prefix);
+		if (!match) return fallback;
+		const n = extractNumber(match, prefix);
+		return Number.isNaN(n) ? fallback : n;
+	};
+	const getEase = (el) => {
+		const match = getActivePrefixedClass(el, "ease-");
+		if (!match) return defaults.ease;
+		const idx = match.indexOf("ease-");
+		return match.slice(idx + 5) || defaults.ease;
+	};
+	const reducedMotion = () => (typeof window !== "undefined" && window.matchMedia?.(`(prefers-reduced-motion: reduce)`)?.matches) ?? false;
+	const isReduced = (el) => reducedMotion() && hasGClass(el, "reduced");
+	const isPreserved = (el) => {
+		if (!el.dataset.gsapWired) return false;
+		for (let node = el; node && node.nodeType === 1; node = node.parentElement) if (node.classList.contains("preserve") && node.dataset.gsapPreserved) return true;
+		return false;
+	};
+	const markPreserved = (el) => {
+		for (let node = el; node && node.nodeType === 1; node = node.parentElement) if (node.classList.contains("preserve")) node.dataset.gsapPreserved = "1";
+	};
+	const underPreservedRoot = (el) => {
+		for (let node = el; node && node.nodeType === 1; node = node.parentElement) if (node.classList.contains("preserve") && node.dataset.gsapPreserved) return true;
+		return false;
+	};
+	const findSpawn = (el) => {
+		const direct = spawnConfigs.find(({ sel }) => elementMatchesSel(el, sel));
+		if (direct) return direct;
+		for (const c of el.classList) {
+			let base = c;
+			let bp = null;
+			const m = c.match(bpPrefixRE);
+			if (m) {
+				bp = m[1];
+				base = m[2];
+			}
+			if (!base.startsWith(TEXT_PREFIX)) continue;
+			if (bp && !isBreakpointActive(bp)) continue;
+			const found = spawnConfigs.find(({ sel }) => sel === "." + base.slice(TEXT_PREFIX_LEN));
+			if (found) return found;
+		}
+		return null;
+	};
+	const leaveStates = /* @__PURE__ */ new WeakMap();
+	const captureLeave = (node) => {
+		if (!hasGClass(node, "leave")) return;
+		const config = findSpawn(node);
+		if (!config || config.typewriter) return;
+		leaveStates.set(node, {
+			html: node.outerHTML,
+			rect: node.getBoundingClientRect(),
+			tween: node._spawnTween || node._scrollTween,
+			from: config.from,
+			ease: getEase(node),
+			parent: node.parentNode,
+			next: node.nextElementSibling,
+			margin: getComputedStyle(node).margin,
+			zIndex: getComputedStyle(node).zIndex
+		});
+	};
+	const flipStates = /* @__PURE__ */ new WeakMap();
+	const flipping = /* @__PURE__ */ new WeakSet();
+	const flipPos = (node) => {
+		const r = node.getBoundingClientRect();
+		return {
+			x: r.x + window.scrollX,
+			y: r.y + window.scrollY,
+			w: r.width,
+			h: r.height
+		};
+	};
+	const captureFlip = (node) => {
+		if (!hasGClass(node, "flip")) return;
+		const config = findSpawn(node);
+		if (!config || config.typewriter) return;
+		if (flipping.has(node)) return;
+		flipStates.set(node, flipPos(node));
+	};
+	const playFlip = (node) => {
+		if (node._flipTween) {
+			node._flipTween.kill();
+			node._flipTween = null;
+			gsap.gsap.set(node, { clearProps: "transform" });
+			flipping.delete(node);
+		}
+		const old = flipStates.get(node);
+		const cur = flipPos(node);
+		flipStates.set(node, cur);
+		if (!old) return;
+		const dx = Math.round(old.x - cur.x);
+		const dy = Math.round(old.y - cur.y);
+		if (!dx && !dy) return;
+		flipping.add(node);
+		node._flipTween = gsap.gsap.fromTo(node, {
+			x: dx,
+			y: dy
+		}, {
+			x: 0,
+			y: 0,
+			duration: readClassNumber(node, "time-", defaults.effectDuration),
+			ease: getEase(node),
+			onComplete: () => {
+				flipping.delete(node);
+				node._flipTween = null;
+			}
+		});
+	};
+	const playLeave = (node) => {
+		const snap = leaveStates.get(node);
+		leaveStates.delete(node);
+		if (!snap || node._leaving) return;
+		node._leaving = true;
+		const placeSpacer = (snap) => {
+			if (!snap.parent || snap.parent.nodeType !== 1) return null;
+			const spacer = document.createElement("div");
+			spacer.style.cssText = `box-sizing:border-box;width:${snap.rect.width}px;height:${snap.rect.height}px;`;
+			if (snap.margin) spacer.style.margin = snap.margin;
+			const next = snap.next && snap.next.parentNode === snap.parent ? snap.next : null;
+			snap.parent.insertBefore(spacer, next);
+			return spacer;
+		};
+		if (snap.tween) {
+			const reattached = !node.isConnected;
+			const spacer = reattached ? placeSpacer(snap) : null;
+			if (reattached) {
+				node.classList.remove("leave", "appear", "scroll", "scroll-progress");
+				node.style.cssText = `position:fixed;z-index:${snap.zIndex};left:${snap.rect.left}px;top:${snap.rect.top}px;
+                        width:${snap.rect.width}px;height:${snap.rect.height}px;margin:0;`;
+				document.body.appendChild(node);
+			}
+			snap.tween.reverse();
+			snap.tween.eventCallback("onReverseComplete", () => {
+				if (reattached) node.remove();
+				else node.style.display = "none";
+				spacer?.remove();
+			});
+			return;
+		}
+		const ghost = document.createElement("div");
+		ghost.innerHTML = snap.html;
+		const g = ghost.firstElementChild;
+		g.classList.remove("leave", "appear", "scroll", "scroll-progress");
+		g.style.cssText = `position:fixed;z-index:${snap.zIndex};left:${snap.rect.left}px;top:${snap.rect.top}px;
+                width:${snap.rect.width}px;height:${snap.rect.height}px;margin:0;`;
+		document.body.appendChild(g);
+		const spacer = placeSpacer(snap);
+		gsap.gsap.to(g, {
+			...snap.from,
+			duration: defaults.effectDuration,
+			ease: snap.ease || defaults.ease,
+			onComplete: () => {
+				g.remove();
+				spacer?.remove();
+			}
+		});
+	};
+	const collectLeave = (node) => {
+		if (!node || node.nodeType !== 1) return [];
+		if (node.classList && hasGClass(node, "leave")) return [node];
+		const found = gsap.gsap.utils.toArray(node.querySelectorAll?.(".leave") || []);
+		qAll("body *").filter((el) => hasGClass(el, "leave") && node.contains?.(el) && !found.includes(el)).forEach((el) => found.push(el));
+		if (hasGClass(node, "leave") && !found.includes(node)) found.unshift(node);
+		return found;
+	};
+	const refreshLeaveRect = (el) => {
+		const s = leaveStates.get(el);
+		if (s) {
+			s.rect = el.getBoundingClientRect();
+			s.tween = el._spawnTween || el._scrollTween || s.tween;
+		}
+	};
+	const orderSelector = () => spawnConfigs.map(({ sel }) => sel).join(",") + "," + spawnConfigs.map(({ sel }) => ".spawn-text-" + sel.slice(1)).join(",");
+	const getOrderDelay = (el, priority) => {
+		const samepri = qAllActive(orderSelector()).filter((e) => {
+			if (!hasGClass(e, "order")) return false;
+			const match = [...e.classList].find((p) => p.startsWith("priority-"));
+			return (match ? Number(match.split("-")[1]) : 0) === priority;
+		});
+		let order = samepri.indexOf(el);
+		if (hasGClass(el, "reverse")) order = samepri.length - 1 - order;
+		return order / defaults.orderDivide;
+	};
+	const readTiming = (el) => {
+		const priority = readClassNumber(el, "priority-", 0);
+		return {
+			delay: hasGClass(el, "order") ? getOrderDelay(el, priority) : priority * defaults.spawnDelayMultiplier,
+			duration: readClassNumber(el, "time-", 1),
+			ease: getEase(el)
+		};
+	};
+	const playNamed = (el, name) => {
+		const entry = animAll.find((a) => a.sel === "." + name);
+		if (!entry) return;
+		const delay = readClassNumber(el, "complete-delay-", 0);
+		const dur = readClassNumber(el, "complete-time-", 1);
+		const tween = entry.play ? invokePlay(entry, el, delay, dur, getEase(el)) : entry.build(el, readLoopCtx(el));
+		if (!tween) return;
+		if (!entry.play) tween.delay(delay);
+		el[name] = tween;
+		onCompleteTweens.push(tween);
+	};
+	const fireOnComplete = (el, kind) => {
+		const prefix = `on-${kind}-complete-`;
+		const cls = [...el.classList].find((c) => c.startsWith(prefix));
+		if (!cls) return;
+		const val = cls.slice(prefix.length);
+		if (val.startsWith("anim-")) playNamed(el, val.slice(5));
+		else {
+			const fn = resolveHandler(val);
+			if (fn) fn(el);
+		}
+	};
+	const scrollTriggers = [];
+	const computeTo = (from) => {
+		const to = {};
+		for (const [key] of Object.entries(from || {})) if (key === "opacity") to[key] = 1;
+		else if (key === "filter") to[key] = "blur(0px)";
+		else if (key === "clipPath") to[key] = "inset(0% 0% 0% 0%)";
+		else if (key === "drawSVG") to[key] = "100%";
+		else to[key] = key.startsWith("scale") ? 1 : 0;
+		return to;
+	};
+	const textSplits = [];
+	const splitCache = /* @__PURE__ */ new WeakMap();
+	const RTL_RE = /[\u0590-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/;
+	const isRTLText = (el) => RTL_RE.test(el.textContent || "");
+	const getGranularity = (el) => {
+		if (hasGClass(el, "lines")) return "lines";
+		if (hasGClass(el, "words")) return "words";
+		if (hasGClass(el, "letter")) return "chars";
+		return "words";
+	};
+	const RTL_NON_JOINABLE = /[اأإآدذرزوؤءة]/;
+	const RTL_DIACRITICS = /[\u064B-\u065F\u0670]/g;
+	const RTL_JOIN_BREAK = /[\u200C\u200D\s]/;
+	const RTL_LETTER = /[\u0621-\u064A\u066E-\u06D5\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/;
+	const getRTLCharSplit = (el) => new gsap_all.SplitText(el, {
+		type: "words",
+		linesClass: "gsap-line",
+		wordsClass: "gsap-word",
+		charsClass: "gsap-char",
+		onSplit(self) {
+			const ZWJ = "‍";
+			const connects = (s) => !RTL_NON_JOINABLE.test(s.replace(RTL_DIACRITICS, "").slice(-1));
+			self.chars.length = 0;
+			self.words.forEach((wordEl) => {
+				const chars = Array.from(wordEl.textContent);
+				const segs = [];
+				let i = 0;
+				while (i < chars.length) {
+					const c = chars[i];
+					if (RTL_JOIN_BREAK.test(c)) {
+						segs.push({
+							text: c,
+							brk: true
+						});
+						i++;
+						continue;
+					}
+					if (!RTL_LETTER.test(c)) {
+						segs.push({
+							text: c,
+							brk: false,
+							letter: false
+						});
+						i++;
+						continue;
+					}
+					let g = c;
+					if (c === "ل" && i + 1 < chars.length) {
+						let j = i + 1;
+						let d = "";
+						while (j < chars.length && RTL_DIACRITICS.test(chars[j])) d += chars[j++];
+						if (j < chars.length && /[\u0622\u0623\u0625\u0627]/.test(chars[j])) {
+							g += d + chars[j];
+							i = j;
+						}
+					}
+					while (i + 1 < chars.length && RTL_DIACRITICS.test(chars[i + 1])) {
+						g += chars[i + 1];
+						i++;
+					}
+					i++;
+					segs.push({
+						text: g,
+						brk: false,
+						letter: true
+					});
+				}
+				wordEl.textContent = "";
+				let prevConnectable = false;
+				segs.forEach((seg, si) => {
+					if (seg.brk) {
+						wordEl.appendChild(document.createTextNode(seg.text));
+						prevConnectable = false;
+						return;
+					}
+					if (!seg.letter) {
+						const pEl = document.createElement("div");
+						pEl.style.display = "inline-block";
+						pEl.className = "gsap-char";
+						pEl.textContent = seg.text;
+						wordEl.appendChild(pEl);
+						self.chars.push(pEl);
+						prevConnectable = false;
+						return;
+					}
+					const connectable = connects(seg.text);
+					let s = seg.text;
+					if (prevConnectable) s = ZWJ + s;
+					if (si + 1 < segs.length && segs[si + 1].letter && connectable) s += ZWJ;
+					const charEl = document.createElement("div");
+					charEl.style.display = "inline-block";
+					charEl.className = "gsap-char";
+					charEl.textContent = s;
+					wordEl.appendChild(charEl);
+					self.chars.push(charEl);
+					prevConnectable = connectable;
+				});
+			});
+			self.words.forEach((w) => w.replaceWith(...w.childNodes));
+			self.words.length = 0;
+		}
+	});
+	const wrapFlexTarget = (el) => {
+		if (!/^(inline-)?flex$/.test(getComputedStyle(el).display)) return null;
+		const wrappers = [];
+		let run = [];
+		const flush = () => {
+			if (!run.length) return;
+			const w = document.createElement("div");
+			el.insertBefore(w, run[0]);
+			run.forEach((n) => w.appendChild(n));
+			wrappers.push(w);
+			run = [];
+		};
+		[...el.childNodes].forEach((n) => {
+			if (n.nodeType === 3 && n.textContent.trim()) run.push(n);
+			else flush();
+		});
+		flush();
+		if (!wrappers.length) return null;
+		return () => wrappers.forEach((w) => {
+			while (w.firstChild) el.insertBefore(w.firstChild, w);
+			w.remove();
+		});
+	};
+	const revertSplitInstance = (s) => {
+		s.revert();
+		s._gcFlexUnwrap?.();
+	};
+	const getSplit = (el, gran) => {
+		let s = splitCache.get(el);
+		const rtlChars = gran === "chars" && isRTLText(el);
+		const key = rtlChars ? "rtl-chars" : gran;
+		if (!s || s.granularity !== key) {
+			if (s) revertSplitInstance(s);
+			const hasN = el.textContent.includes("\n");
+			if (hasN && el.style) el.style.whiteSpace = "pre-wrap";
+			s = rtlChars ? getRTLCharSplit(el) : new gsap_all.SplitText(el, {
+				type: gran,
+				reduceWhiteSpace: hasN ? false : void 0,
+				linesClass: "gsap-line",
+				wordsClass: "gsap-word",
+				charsClass: "gsap-char",
+				onSplit(self) {
+					for (const c of self.chars || []) if (c.textContent === "\n") {
+						c.textContent = "";
+						c.style.display = "block";
+						c.style.width = "100%";
+						c.style.height = "0";
+					}
+					for (const w of self.words || []) if (w.textContent.includes("\n")) w.style.whiteSpace = "pre-wrap";
+				}
+			});
+			s._gcFlexUnwrap = wrapFlexTarget(el);
+			s.granularity = key;
+			splitCache.set(el, s);
+			textSplits.push(s);
+		}
+		return s;
+	};
+	const getParts = (el, gran) => {
+		const s = getSplit(el, gran);
+		const parts = gran === "chars" && isRTLText(el) ? s.chars || [] : s[gran] || [];
+		for (let i = 0; i < parts.length; i++) {
+			parts[i].style.willChange = "transform, opacity";
+			if (gran === "chars" || gran === "words") parts[i].style.display = "inline-block";
+		}
+		return parts;
+	};
+	const revertSplit = (el) => {
+		if (hasGClass(el, "no-revert")) return;
+		const s = splitCache.get(el);
+		if (!s) return;
+		splitCache.delete(el);
+		const idx = textSplits.indexOf(s);
+		if (idx !== -1) textSplits.splice(idx, 1);
+		revertSplitInstance(s);
+	};
+	const playText = (el, from, delay, dur, ease) => {
+		const gran = getGranularity(el);
+		const parts = getParts(el, gran);
+		if (!parts.length) return;
+		const requestedStagger = readClassNumber(el, "stagger-", null);
+		let stagger, duration;
+		if (requestedStagger != null) {
+			stagger = requestedStagger;
+			duration = Math.max(dur - stagger * (parts.length - 1), defaults.minTextPartDuration);
+		} else {
+			duration = Math.min(dur, Math.max(dur / 3, defaults.minTextPartDuration));
+			stagger = parts.length > 1 ? (dur - duration) / (parts.length - 1) : 0;
+		}
+		let rnd = null;
+		if (hasRandom(el)) {
+			rnd = randomVars(el);
+			if (!Object.keys(rnd).length) rnd = null;
+		}
+		const effFrom = {
+			...from,
+			...rnd
+		};
+		return gsap.gsap.fromTo(parts, effFrom, {
+			...computeTo(effFrom),
+			ease,
+			duration,
+			delay,
+			stagger,
+			onComplete: () => {
+				if (hasGClass(el, "leave")) refreshLeaveRect(el);
+				revertSplit(el);
+				fireOnComplete(el, "spawn");
+			}
+		});
+	};
+	const playTypewriterSplit = (el, delay, dur, ease) => {
+		const gran = getGranularity(el);
+		const parts = getParts(el, gran);
+		if (!parts.length) return;
+		const perChar = dur / Math.max(parts.length, 1);
+		return gsap.gsap.fromTo(parts, { opacity: 0 }, {
+			opacity: 1,
+			ease,
+			duration: Math.min(defaults.typewriterSplitCharDuration, perChar),
+			delay,
+			stagger: perChar,
+			onComplete: () => revertSplit(el)
+		});
+	};
+	const textClsFor = (el) => [...el.classList].find((c) => c.startsWith(TEXT_PREFIX));
+	const isTextElement = (el) => {
+		const cls = textClsFor(el);
+		if (!cls) return false;
+		return !!spawnConfigs.find(({ sel }) => sel === "." + cls.slice(TEXT_PREFIX_LEN));
+	};
+	const setupPin = (el) => {
+		if (!hasGClass(el, "pin") || el.dataset.gsapPinned) return;
+		const clamp = (n) => Math.min(100, Math.max(0, n));
+		const startClass = readClassNumber(el, "progress-start-", null);
+		const endClass = readClassNumber(el, "progress-end-", null);
+		const start = startClass != null ? `top ${clamp(100 - startClass)}%` : "top top";
+		const end = endClass != null ? `top ${clamp(100 - endClass)}%` : "bottom top";
+		const t = gsap_all.ScrollTrigger.create({
+			trigger: el,
+			start,
+			end,
+			pin: true,
+			pinSpacing: true,
+			anticipatePin: 1
+		});
+		el.dataset.gsapPinned = "1";
+		scrollTriggers.push(t);
+	};
+	qAllAllVariants(".pin").forEach((el) => runWithBreakpointForSel(el, ".pin", () => setupPin(el)));
+	const setupScrollDriven = (el) => {
+		if (el.dataset?.gsapScrollDriven) return;
+		el.dataset.gsapScrollDriven = "1";
+		if (isReduced(el)) return;
+		[...el.classList];
+		const clamp = (n) => Math.min(100, Math.max(0, n));
+		const parallaxCls = getActivePrefixedClass(el, "parallax-");
+		if (parallaxCls) {
+			const factor = parseFloat(parallaxCls.slice(parallaxCls.indexOf("parallax-") + 9)) || 1;
+			if (factor === 1) return;
+			const amt = (factor - 1) * 50;
+			const t = gsap.gsap.fromTo(el, { yPercent: -amt }, {
+				yPercent: amt,
+				ease: "none",
+				scrollTrigger: {
+					trigger: el,
+					start: "top bottom",
+					end: "bottom top",
+					scrub: true
+				}
+			});
+			scrollTriggers.push(t.scrollTrigger);
+			return;
+		}
+		if (hasGClass(el, "progress-bar") || hasGClass(el, "scroll-fill")) {
+			const startClass = readClassNumber(el, "progress-start-", null);
+			const endClass = readClassNumber(el, "progress-end-", null);
+			const reverse = hasGClass(el, "progress-reverse");
+			const t = gsap.gsap.fromTo(el, { scaleX: reverse ? 1 : 0 }, {
+				scaleX: reverse ? 0 : 1,
+				ease: "none",
+				transformOrigin: "left center",
+				scrollTrigger: {
+					trigger: el,
+					start: startClass != null ? `top ${clamp(100 - startClass)}%` : "top bottom",
+					end: endClass != null ? `top ${clamp(100 - endClass)}%` : "bottom top",
+					scrub: true
+				}
+			});
+			scrollTriggers.push(t.scrollTrigger);
+			return;
+		}
+		if (hasGClass(el, "scroll-fade-bg")) {
+			const t = gsap.gsap.fromTo(el, { backgroundPosition: "0% 0%" }, {
+				backgroundPosition: "100% 100%",
+				ease: "none",
+				scrollTrigger: {
+					trigger: el,
+					start: "top bottom",
+					end: "bottom top",
+					scrub: true
+				}
+			});
+			scrollTriggers.push(t.scrollTrigger);
+			return;
+		}
+		if (hasGClass(el, "scroll-horizontal")) {
+			const track = el.querySelector(".scroll-track");
+			if (!track) return;
+			const getAmount = () => track.scrollWidth - el.clientWidth;
+			const t = gsap.gsap.to(track, {
+				x: () => -getAmount(),
+				ease: "none",
+				scrollTrigger: {
+					trigger: el,
+					start: "top top",
+					end: () => `+=${getAmount()}`,
+					pin: true,
+					scrub: 1,
+					anticipatePin: 1,
+					invalidateOnRefresh: true
+				}
+			});
+			scrollTriggers.push(t.scrollTrigger);
+		}
+	};
+	qAll("body *").filter((el) => hasGClass(el, "progress-bar") || hasGClass(el, "scroll-fill") || hasGClass(el, "scroll-fade-bg") || hasGClass(el, "scroll-horizontal") || [...el.classList].some((c) => c.startsWith("parallax-") || bpNames.some((bp) => c.startsWith(`${bp}:parallax-`)))).forEach((el) => setupScrollDriven(el));
+	const getScroller = (el) => {
+		const frame = el.closest?.(".scroll-frame");
+		return frame && frame !== el ? frame : void 0;
+	};
+	const setupScroll = (el) => {
+		if (el.dataset?.gsapScroll) return;
+		if (isTextElement(el)) return;
+		if (isReduced(el)) return;
+		el.dataset.gsapScroll = "1";
+		const config = findSpawn(el);
+		if (!config) return;
+		const { from, typewriter: isTypewriter, typewriterSplit, play } = config;
+		if (hasGClass(el, "scroll-progress")) {
+			const ease = isTypewriter ? [...el.classList].find((c) => c.startsWith("ease-"))?.split("-")[1] ?? "none" : getEase(el);
+			const to = {};
+			for (const [key] of Object.entries(from || {})) if (key === "opacity") to[key] = 1;
+			else if (key === "filter") to[key] = "blur(0px)";
+			else if (key === "text") to[key] = stashText(el);
+			else if (key === "clipPath") to[key] = "inset(0% 0% 0% 0%)";
+			else if (key === "drawSVG") to[key] = "100%";
+			else to[key] = key.startsWith("scale") ? 1 : 0;
+			const startClass = readClassNumber(el, "progress-start-", null);
+			const endClass = readClassNumber(el, "progress-end-", null);
+			const clamp = (n) => Math.min(100, Math.max(0, n));
+			const reverse = hasGClass(el, "progress-reverse");
+			const rnd = !reverse && hasRandom(el) ? randomVars(el) : null;
+			const rndEnds = rnd ? randomEnds(Object.keys(rnd)) : null;
+			const tl = gsap.gsap.timeline({ scrollTrigger: {
+				trigger: el,
+				scroller: getScroller(el),
+				start: startClass != null ? `top ${clamp(100 - startClass)}%` : defaults.progressStart,
+				end: endClass != null ? `top ${clamp(100 - endClass)}%` : defaults.progressEnd,
+				scrub: true
+			} });
+			if (config.count) {
+				const { start, end, decimals } = countTargetVars(el);
+				const obj = { n: reverse ? end : start };
+				tl.fromTo(obj, { n: reverse ? end : start }, {
+					n: reverse ? start : end,
+					ease,
+					onUpdate: () => {
+						el.textContent = obj.n.toFixed(decimals);
+					}
+				}, 0);
+			} else if (config.scramble) {
+				const { segs, chars, speed, revealDelay, rtl } = scrambleVars(el);
+				const all = el.classList.contains("scramble-all");
+				segs.forEach(({ t, text }) => {
+					if (all) tl.to(t, {
+						scrambleText: {
+							text,
+							chars,
+							speed,
+							revealDelay,
+							rightToLeft: rtl
+						},
+						ease
+					}, 0);
+					else tl.fromTo(t, { scrambleText: {
+						text: reverse ? text : "",
+						chars
+					} }, {
+						scrambleText: {
+							text: reverse ? "" : text,
+							chars,
+							speed,
+							revealDelay,
+							rightToLeft: rtl
+						},
+						ease
+					}, 0);
+				});
+			} else if (typewriterSplit) {
+				const parts = getParts(el, getGranularity(el));
+				if (parts.length) tl.fromTo(parts, { opacity: reverse ? 1 : 0 }, {
+					opacity: reverse ? 0 : 1,
+					ease
+				});
+			} else if (hasGClass(el, "fill-svg") && (hasGClass(el, "draw") || hasGClass(el, "draw-split"))) {
+				const fillEaseCls = [...el.classList].find((c) => c.startsWith("fill-ease-"));
+				const fillEase = fillEaseCls ? fillEaseCls.slice(10) : ease;
+				const fillTimeCls = [...el.classList].find((c) => c.startsWith("fill-time-"));
+				const fillDur = fillTimeCls ? Number(fillTimeCls.slice(10)) : .5;
+				const drawDur = 1;
+				gsap.gsap.set(el, { fillOpacity: reverse ? 1 : 0 });
+				if (!reverse) {
+					tl.fromTo(el, {
+						drawSVG: "0%",
+						...rnd
+					}, {
+						drawSVG: "100%",
+						...rndEnds,
+						ease,
+						duration: drawDur
+					});
+					tl.fromTo(el, { fillOpacity: 0 }, {
+						fillOpacity: 1,
+						ease: fillEase,
+						duration: fillDur
+					});
+				} else {
+					tl.fromTo(el, { fillOpacity: 1 }, {
+						fillOpacity: 0,
+						ease: fillEase,
+						duration: fillDur
+					});
+					tl.fromTo(el, {
+						drawSVG: "100%",
+						...rndEnds
+					}, {
+						drawSVG: "0%",
+						...rnd,
+						ease,
+						duration: drawDur
+					});
+				}
+			} else tl.fromTo(el, {
+				...reverse ? to : from,
+				...rnd
+			}, {
+				...rndEnds,
+				...reverse ? from : to,
+				ease
+			});
+			scrollTriggers.push(tl.scrollTrigger);
+			return;
+		}
+		if (!hasGClass(el, "scroll")) return;
+		const { delay, duration } = readTiming(el);
+		const ease = isTypewriter ? [...el.classList].find((c) => c.startsWith("ease-"))?.split("-")[1] ?? "none" : getEase(el);
+		const fullText = stashText(el);
+		const enter = () => {
+			if (el._scrollTween) el._scrollTween.kill();
+			el._scrollTween = isTypewriter ? typewriterSplit ? playTypewriterSplit(el, delay, duration, ease) : typewriter(el, fullText, duration, delay, ease) : invokePlay(config, el, delay, duration, ease);
+			el._scrollTween.eventCallback("onComplete", () => fireOnComplete(el, "spawn"));
+		};
+		const reverseToStart = () => {
+			if (config.count) {
+				const t = el._scrollTween;
+				if (t && t.progress() > 0 && !t.reversed()) t.reverse();
+				return;
+			}
+			el._scrollTween?.kill();
+			if (isTypewriter && !typewriterSplit) {
+				el.innerHTML = fullText;
+				return;
+			}
+			if (typewriterSplit) {
+				const parts = getParts(el, getGranularity(el));
+				if (parts.length) gsap.gsap.to(parts, {
+					opacity: 0,
+					ease,
+					duration: .3
+				});
+				return;
+			}
+			el._scrollTween = gsap.gsap.to(el, {
+				...from,
+				ease,
+				duration: .3
+			});
+		};
+		const st = gsap_all.ScrollTrigger.create({
+			trigger: el,
+			scroller: getScroller(el),
+			start: "top bottom",
+			end: "bottom top",
+			onEnter: enter,
+			onEnterBack: enter,
+			onLeave: reverseToStart,
+			onLeaveBack: reverseToStart
+		});
+		scrollTriggers.push(st);
+	};
+	qAll("body *").filter((el) => hasGClass(el, "scroll") || hasGClass(el, "scroll-progress")).forEach((el) => runWithBreakpoint(el, () => setupScroll(el)));
+	spawnConfigs.forEach(({ sel, from, typewriter: isTypewriter, text }) => {
+		if (isTypewriter || text === false) return;
+		const tSel = ".spawn-text-" + sel.slice(1);
+		qAll("body *").filter((el) => elementMatchesSel(el, tSel) && hasGClass(el, "scroll") && !hasGClass(el, "scroll-progress")).forEach((el) => {
+			const run = () => {
+				if (isReduced(el)) return;
+				const { delay, duration } = readTiming(el);
+				const ease = getEase(el);
+				const enter = () => {
+					el._scrollTween?.kill();
+					el._scrollTween = playText(el, from, delay, duration, ease);
+				};
+				const reverseToStart = () => {
+					el._scrollTween?.kill();
+					const parts = getParts(el, getGranularity(el));
+					if (parts.length) gsap.gsap.to(parts, {
+						...from,
+						ease,
+						duration: .3
+					});
+				};
+				scrollTriggers.push(gsap_all.ScrollTrigger.create({
+					trigger: el,
+					scroller: getScroller(el),
+					start: "top bottom",
+					end: "top top",
+					onEnter: enter,
+					onEnterBack: enter,
+					onLeave: reverseToStart,
+					onLeaveBack: reverseToStart
+				}));
+			};
+			runWithBreakpoint(el, run);
+		});
+		qAll("body *").filter((el) => elementMatchesSel(el, tSel) && hasGClass(el, "scroll-progress")).forEach((el) => {
+			const run = () => {
+				if (isReduced(el)) return;
+				const ease = getEase(el);
+				const parts = getParts(el, getGranularity(el));
+				if (!parts.length) return;
+				const to = computeTo(from);
+				const startClass = readClassNumber(el, "progress-start-", null);
+				const endClass = readClassNumber(el, "progress-end-", null);
+				const clamp = (n) => Math.min(100, Math.max(0, n));
+				const tl = gsap.gsap.timeline({ scrollTrigger: {
+					trigger: el,
+					scroller: getScroller(el),
+					start: startClass != null ? `top ${clamp(100 - startClass)}%` : defaults.progressStart,
+					end: endClass != null ? `top ${clamp(100 - endClass)}%` : defaults.progressEnd,
+					scrub: true
+				} });
+				const reverse = hasGClass(el, "progress-reverse");
+				const rnd = !reverse && hasRandom(el) ? randomVars(el) : null;
+				tl.fromTo(parts, {
+					...reverse ? to : from,
+					...rnd
+				}, {
+					...rnd ? randomEnds(Object.keys(rnd)) : null,
+					...reverse ? from : to,
+					ease
+				});
+				scrollTriggers.push(tl.scrollTrigger);
+			};
+			runWithBreakpoint(el, run);
+		});
+	});
+	gsap_all.ScrollTrigger.refresh();
+	window.addEventListener("load", gsap_all.ScrollTrigger.refresh);
+	let refreshTimer = null;
+	const scheduleRefresh = () => {
+		clearTimeout(refreshTimer);
+		refreshTimer = setTimeout(() => {
+			refreshTimer = null;
+			gsap_all.ScrollTrigger.refresh();
+		}, 60);
+	};
+	setTimeout(scheduleRefresh, 400);
+	setTimeout(scheduleRefresh, 1200);
+	spawnConfigs.forEach((config) => {
+		const { sel, typewriter: isTypewriter, typewriterSplit } = config;
+		qAllAllVariants(sel).forEach((el) => {
+			const run = () => {
+				if (hasGClass(el, "scroll") || hasGClass(el, "scroll-progress")) return;
+				if (isPreserved(el)) return;
+				if (isReduced(el)) return;
+				if (!elementMatchesSel(el, sel)) return;
+				const { delay, duration } = readTiming(el);
+				if (isTypewriter) {
+					const easeClass = getActivePrefixedClass(el, "ease-") || [...el.classList].find((c) => c.startsWith("ease-"));
+					const elEase = easeClass ? easeClass.slice(easeClass.indexOf("ease-") + 5) : "none";
+					if (typewriterSplit) el._spawnTween = playTypewriterSplit(el, delay, duration, elEase);
+					else {
+						el.typewriter?.kill();
+						el.typewriter = typewriter(el, stashText(el), duration, delay, elEase);
+					}
+				} else {
+					el._spawnTween = invokePlay(config, el, delay, duration, getEase(el));
+					el._spawnTween.eventCallback("onComplete", () => {
+						if (hasGClass(el, "leave")) refreshLeaveRect(el);
+						if (hasGClass(el, "flip")) captureFlip(el);
+						if (isCompatibility(el)) resumeCompatLoops(el);
+						scheduleRefresh();
+						fireOnComplete(el, "spawn");
+					});
+				}
+				markPreserved(el);
+				el.dataset.gsapWired = "1";
+			};
+			runWithBreakpointForSel(el, sel, run);
+		});
+	});
+	spawnConfigs.forEach(({ sel, from, typewriter: isTypewriter, text }) => {
+		if (isTypewriter || text === false) return;
+		const tSel = ".spawn-text-" + sel.slice(1);
+		qAllAllVariants(tSel).forEach((el) => {
+			const run = () => {
+				if (hasGClass(el, "scroll") || hasGClass(el, "scroll-progress")) return;
+				if (isPreserved(el)) return;
+				if (isReduced(el)) return;
+				if (!elementMatchesSel(el, tSel)) return;
+				const { delay, duration } = readTiming(el);
+				el._spawnTween = playText(el, from, delay, duration, getEase(el));
+				markPreserved(el);
+				el.dataset.gsapWired = "1";
+			};
+			runWithBreakpointForSel(el, tSel, run);
+		});
+	});
+	const magnetQuery = typeof window !== "undefined" ? window.matchMedia("(hover: none)") : null;
+	const magnetState = [];
+	const magnetListeners = [];
+	const magnetOnMove = (el, pull, grow, duration, elEase) => (ev) => {
+		const r = el.getBoundingClientRect();
+		const dx = ev.clientX - (r.left + r.width / 2);
+		const dy = ev.clientY - (r.top + r.height / 2);
+		magnet(el, dx * pull, dy * pull, grow, duration, elEase);
+	};
+	const magnetOnLeave = (el, duration, elEase) => () => magnet(el, 0, 0, 1, duration, elEase);
+	const magnet3dOnMove = (el, pull, grow, tilt, duration, elEase) => (ev) => {
+		const r = el.getBoundingClientRect();
+		const dx = ev.clientX - (r.left + r.width / 2);
+		const dy = ev.clientY - (r.top + r.height / 2);
+		const relX = r.width ? (ev.clientX - r.left) / r.width - .5 : 0;
+		const relY = r.height ? (ev.clientY - r.top) / r.height - .5 : 0;
+		magnet3d(el, dx * pull, dy * pull, grow, -relY * tilt, relX * tilt, duration, elEase);
+	};
+	const magnet3dOnLeave = (el, duration, elEase) => () => magnet3d(el, 0, 0, 1, 0, 0, duration, elEase);
+	const applyMagnet = () => {
+		if (!magnetQuery) return;
+		const touch = magnetQuery.matches;
+		magnetListeners.forEach(({ el, type, fn }) => el.removeEventListener(type, fn));
+		magnetListeners.length = 0;
+		if (touch) return;
+		magnetState.forEach(({ el, onMove, onLeave }) => {
+			el.addEventListener("mousemove", onMove);
+			el.addEventListener("mouseleave", onLeave);
+			magnetListeners.push({
+				el,
+				type: "mousemove",
+				fn: onMove
+			}, {
+				el,
+				type: "mouseleave",
+				fn: onLeave
+			});
+		});
+	};
+	const setupMagnet = (el) => {
+		if (!hasGClass(el, "magnet") && !hasGClass(el, "magnet3d")) return;
+		const threeD = hasGClass(el, "magnet3d");
+		const duration = readClassNumber(el, "mtime-", .4);
+		const pull = readClassNumber(el, "amount-", .3);
+		const grow = readClassNumber(el, "mgrow-", 1.1);
+		const tilt = readClassNumber(el, "mtilt-", 12);
+		const elEase = getEase(el);
+		const onMove = threeD ? magnet3dOnMove(el, pull, grow, tilt, duration, elEase) : magnetOnMove(el, pull, grow, duration, elEase);
+		const onLeave = threeD ? magnet3dOnLeave(el, duration, elEase) : magnetOnLeave(el, duration, elEase);
+		magnetState.push({
+			el,
+			onMove,
+			onLeave
+		});
+	};
+	if (magnetQuery) magnetQuery.addEventListener("change", applyMagnet);
+	const isCompatibility = (el) => hasGClass(el, "compatibility");
+	const compatLoopsOf = (el) => {
+		if (!el._gsapCompatLoops) el._gsapCompatLoops = [];
+		return el._gsapCompatLoops;
+	};
+	const trackCompatLoop = (el, tween) => {
+		if (tween && isCompatibility(el)) compatLoopsOf(el).push(tween);
+		return tween;
+	};
+	const pauseCompatLoops = (el) => compatLoopsOf(el).forEach((t) => t.pause());
+	const resumeCompatLoops = (el) => compatLoopsOf(el).forEach((t) => t.resume());
+	const setupClicks = (el) => {
+		if (isReduced(el)) return;
+		setupMagnet(el);
+		if (hasGClass(el, "click-hover")) {
+			const area = wrapTarget(el);
+			let touch = false;
+			const duration = readClassNumber(el, "ctime-", defaults.clickDuration);
+			const lift = readClassNumber(el, "amount-", defaults.clickOffset);
+			const elEase = getEase(el);
+			addListener(area, "mousedown", () => {
+				if (!touch) {
+					pauseCompatLoops(el);
+					verticalmove(el, -lift / 2, duration, elEase);
+				}
+			});
+			addListener(area, "mouseover", () => {
+				if (!touch) {
+					pauseCompatLoops(el);
+					verticalmove(el, -lift, duration, elEase);
+				}
+			});
+			addListener(area, "mouseleave", () => {
+				if (!touch) {
+					verticalmove(el, 0, duration, elEase);
+					resumeCompatLoops(el);
+				}
+			});
+			addListener(area, "mouseup", () => {
+				if (!touch) verticalmove(el, -lift, duration, elEase);
+			});
+			addListener(area, "touchstart", () => {
+				touch = true, pauseCompatLoops(el), verticalmove(el, lift / 2, duration, elEase);
+			});
+			addListener(area, "touchend", () => {
+				touch = true, verticalmove(el, 0, duration, elEase), setTimeout(() => {
+					touch = false;
+				}, 0);
+			});
+		}
+		if (hasGClass(el, "click-expand")) {
+			let touch = false;
+			const duration = readClassNumber(el, "ctime-", defaults.clickDuration);
+			const lift = readClassNumber(el, "amount-", defaults.clickExpandOffset);
+			const elEase = getEase(el);
+			addListener(el, "mousedown", () => {
+				if (!touch) {
+					pauseCompatLoops(el);
+					expandmove(el, 10, duration, elEase).eventCallback("onComplete", () => fireOnComplete(el, "click"));
+				}
+			});
+			addListener(el, "mouseover", () => {
+				if (!touch) {
+					pauseCompatLoops(el);
+					expandmove(el, lift, duration, elEase);
+				}
+			});
+			addListener(el, "mouseleave", () => {
+				if (!touch) {
+					expandmove(el, 10, duration, elEase);
+					resumeCompatLoops(el);
+				}
+			});
+			addListener(el, "mouseup", () => {
+				if (!touch) expandmove(el, lift, duration, elEase);
+			});
+			addListener(el, "touchstart", () => {
+				touch = true, pauseCompatLoops(el), expandmove(el, lift, duration, elEase);
+			});
+			addListener(el, "touchend", () => {
+				touch = true, expandmove(el, 10, duration, elEase).eventCallback("onComplete", () => fireOnComplete(el, "click")), setTimeout(() => {
+					touch = false;
+				}, 0);
+			});
+		}
+	};
+	const readLoopCtx = (el) => ({
+		edelay: readClassNumber(el, "edelay-", defaults.effectDelay),
+		amount: readClassNumber(el, "amount-", defaults.effectOffset),
+		etime: readClassNumber(el, "etime-", defaults.effectDuration),
+		ease: getEase(el),
+		time: readClassNumber(el, "time-", 20),
+		mH: readClassNumber(el, "marquee-horizontal-offset-", 0),
+		mV: readClassNumber(el, "marquee-vertical-offset-", 0),
+		radiateZ: readClassNumber(el, "radiate-z-", null)
+	});
+	const loopEls = [];
+	const buildLoops = (el) => {
+		if (isReduced(el)) return;
+		const ctx = readLoopCtx(el);
+		loopConfigs.forEach(({ sel, build, key, loop }) => {
+			if (elementMatchesSel(el, sel)) {
+				el[key]?.kill();
+				el[key] = trackCompatLoop(el, build(el, ctx));
+				if (loop) el[key].repeat(-1);
+				if (!loopEls.some((l) => l.el === el && l.key === key)) loopEls.push({
+					el,
+					key
+				});
+				el[key].eventCallback(el[key].repeat() === -1 ? "onRepeat" : "onComplete", () => fireOnComplete(el, "loop"));
+			}
+		});
+	};
+	const findSpawnTween = (el) => {
+		for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
+			const t = node._spawnTween;
+			if (t && t.progress() < 1) return t;
+		}
+		return null;
+	};
+	const deferLoopBuild = (el, tween) => {
+		if (!tween.__gsapPendingLoops) tween.__gsapPendingLoops = /* @__PURE__ */ new Set();
+		tween.__gsapPendingLoops.add(el);
+		if (tween.__gsapPendingHooked) return;
+		tween.__gsapPendingHooked = true;
+		const existing = tween.eventCallback("onComplete");
+		tween.eventCallback("onComplete", function() {
+			existing && existing.call(this);
+			const pending = tween.__gsapPendingLoops;
+			tween.__gsapPendingLoops = /* @__PURE__ */ new Set();
+			tween.__gsapPendingHooked = false;
+			pending.forEach((e) => buildLoops(e));
+		});
+	};
+	const setupLoops = (el) => {
+		const spawnTween = isCompatibility(el) ? findSpawnTween(el) : null;
+		if (spawnTween) {
+			deferLoopBuild(el, spawnTween);
+			return;
+		}
+		buildLoops(el);
+	};
+	const wrapTarget = (el) => {
+		if (!hasGClass(el, "wrapdiv")) return el;
+		if (el._gsapWrap) return el._gsapWrap;
+		const area = document.createElement("div");
+		el.before(area);
+		area.appendChild(el);
+		el._gsapWrap = area;
+		return area;
+	};
+	const setupHoverClick = (el) => {
+		if (isReduced(el)) return;
+		const ctx = readLoopCtx(el);
+		loopConfigs.forEach(({ sel, build, key }) => {
+			if (sel.startsWith(".marquee")) return;
+			const name = sel.slice(1);
+			if (hasGClass(el, "hover-" + name)) {
+				const area = wrapTarget(el);
+				addListener(area, "mouseenter", () => {
+					pauseCompatLoops(el);
+					el[key]?.kill();
+					el[key] = build(el, ctx).repeat(-1);
+					el[key].eventCallback("onRepeat", () => fireOnComplete(el, "loop"));
+				});
+				addListener(area, "mouseleave", () => {
+					el[key]?.kill();
+					el[key] = reset(el, readClassNumber(el, "etime-", defaults.effectDuration), getEase(el));
+					resumeCompatLoops(el);
+				});
+			} else if (hasGClass(el, "click-" + name)) {
+				const area = wrapTarget(el);
+				addListener(area, "mousedown", () => {
+					pauseCompatLoops(el);
+					el[key]?.kill();
+					el[key] = build(el, ctx);
+					el[key].eventCallback("onComplete", () => fireOnComplete(el, "click"));
+				});
+				addListener(area, "mouseleave", () => {
+					resumeCompatLoops(el);
+				});
+			}
+		});
+	};
+	const CSS_VAL = "(-?\\d+(?:\\.\\d+)?|#[0-9a-fA-F]{3,8})";
+	const CSS_ANIM_RE = new RegExp(`^((spawn|hover|click)-)?css-([a-zA-Z]+)-${CSS_VAL}-${CSS_VAL}$`);
+	const CSS_SINGLE_RE = new RegExp(`^((hover|click)-)css-([a-zA-Z]+)-${CSS_VAL}$`);
+	const parseCssVal = (s) => /^#/.test(s) ? s : Number(s);
+	const parseCssAnim = (el) => {
+		for (const c of el.classList) {
+			let m = c.match(CSS_ANIM_RE);
+			if (m) return {
+				mode: m[2] || "loop",
+				prop: m[3],
+				from: parseCssVal(m[4]),
+				to: parseCssVal(m[5])
+			};
+			m = c.match(CSS_SINGLE_RE);
+			if (m) return {
+				mode: m[2],
+				prop: m[3],
+				to: parseCssVal(m[4]),
+				single: true
+			};
+		}
+		return null;
+	};
+	const cssTweens = [];
+	const setupCssAnims = (el) => {
+		if (isReduced(el)) return;
+		const anim = parseCssAnim(el);
+		if (!anim) return;
+		const dur = readClassNumber(el, "time-", 1);
+		const ease = getEase(el);
+		const key = "_cssAnim";
+		const loopVars = {
+			[anim.prop]: anim.to,
+			duration: dur,
+			ease,
+			yoyo: true,
+			repeat: -1
+		};
+		if (anim.mode === "loop") {
+			el[key]?.kill();
+			el[key] = gsap.gsap.fromTo(el, { [anim.prop]: anim.from }, loopVars);
+			cssTweens.push(el[key]);
+		} else if (anim.mode === "spawn") {
+			el[key]?.kill();
+			el[key] = gsap.gsap.fromTo(el, { [anim.prop]: anim.from }, {
+				[anim.prop]: anim.to,
+				duration: dur,
+				ease
+			});
+			cssTweens.push(el[key]);
+		} else if (anim.mode === "hover") {
+			const area = wrapTarget(el);
+			if (anim.single) {
+				const original = gsap.gsap.getProperty(el, anim.prop);
+				addListener(area, "mouseenter", () => {
+					el[key]?.kill();
+					el[key] = gsap.gsap.to(el, {
+						[anim.prop]: anim.to,
+						duration: dur,
+						ease
+					});
+					cssTweens.push(el[key]);
+				});
+				addListener(area, "mouseleave", () => {
+					el[key]?.kill();
+					el[key] = gsap.gsap.to(el, {
+						[anim.prop]: original,
+						duration: dur,
+						ease
+					});
+					cssTweens.push(el[key]);
+				});
+			} else {
+				addListener(area, "mouseenter", () => {
+					el[key]?.kill();
+					el[key] = gsap.gsap.fromTo(el, { [anim.prop]: anim.from }, { ...loopVars });
+					cssTweens.push(el[key]);
+				});
+				addListener(area, "mouseleave", () => {
+					el[key]?.kill();
+					el[key] = gsap.gsap.to(el, {
+						[anim.prop]: anim.from,
+						duration: dur,
+						ease
+					});
+					cssTweens.push(el[key]);
+				});
+			}
+		} else if (anim.mode === "click") {
+			const area = wrapTarget(el);
+			if (anim.single) {
+				const original = gsap.gsap.getProperty(el, anim.prop);
+				addListener(area, "mousedown", () => {
+					el[key]?.kill();
+					el[key] = gsap.gsap.to(el, {
+						[anim.prop]: anim.to,
+						duration: dur,
+						ease
+					});
+					el[key].eventCallback("onComplete", () => fireOnComplete(el, "click"));
+					cssTweens.push(el[key]);
+				});
+				addListener(area, "mouseup", () => {
+					el[key]?.kill();
+					el[key] = gsap.gsap.to(el, {
+						[anim.prop]: original,
+						duration: dur,
+						ease
+					});
+					cssTweens.push(el[key]);
+				});
+			} else addListener(area, "mousedown", () => {
+				el[key]?.kill();
+				el[key] = gsap.gsap.fromTo(el, { [anim.prop]: anim.from }, {
+					[anim.prop]: anim.to,
+					duration: dur,
+					ease,
+					yoyo: true,
+					repeat: 1
+				});
+				el[key].eventCallback("onComplete", () => fireOnComplete(el, "click"));
+				cssTweens.push(el[key]);
+			});
+		}
+	};
+	const setupTeardowns = [];
+	const runSetup = (el) => {
+		if (isReduced(el)) return;
+		const ctx = readLoopCtx(el);
+		animAll.forEach((a) => {
+			if (a.setup && elementMatchesSel(el, a.sel)) {
+				const teardown = a.setup(el, ctx);
+				if (typeof teardown === "function") setupTeardowns.push(teardown);
+			}
+		});
+	};
+	qAll("body *").forEach((el) => {
+		if (el.dataset?.gsapSetup) return;
+		el.dataset.gsapSetup = "1";
+		setupClicks(el);
+		setupLoops(el);
+		setupHoverClick(el);
+		setupCssAnims(el);
+		runSetup(el);
+	});
+	applyMagnet();
+	let flipRoots = /* @__PURE__ */ new Set();
+	let flipPendingRaf = null;
+	const flushFlipRoots = () => {
+		if (!flipRoots.size) return;
+		const toFlip = /* @__PURE__ */ new Set();
+		flipRoots.forEach((scope) => {
+			if (!scope) return;
+			gsap.gsap.utils.toArray(scope.querySelectorAll?.(".flip") || []).forEach((el) => {
+				if (el.isConnected) toFlip.add(el);
+			});
+		});
+		toFlip.forEach(playFlip);
+		gsap.gsap.utils.toArray(document.body.querySelectorAll?.(".flip") || []).forEach(captureFlip);
+		flipRoots = /* @__PURE__ */ new Set();
+	};
+	let flipObserver = null;
+	const animateAppear = (el) => {
+		if (!hasGClass(el, "appear") || el._appeared) return;
+		if (!isTextElement(el) && (hasGClass(el, "scroll") || hasGClass(el, "scroll-progress"))) return;
+		if (isReduced(el)) return;
+		el._appeared = true;
+		const { delay, duration, ease } = readTiming(el);
+		const config = findSpawn(el);
+		if (isTextElement(el)) {
+			el._spawnTween = playText(el, config.from, delay, duration, ease);
+			return;
+		}
+		if (!config) return el._spawnTween = SpawnV(el, delay, -defaults.spawnOffset, duration, ease);
+		if (config.typewriter) {
+			const easeClass = [...el.classList].find((c) => c.startsWith("ease-"));
+			const elEase = easeClass ? easeClass.split("-")[1] : "none";
+			el._spawnTween = config.typewriterSplit ? playTypewriterSplit(el, delay, duration, elEase) : invokePlay(config, el, delay, duration, elEase);
+		} else {
+			el._spawnTween = invokePlay(config, el, delay, duration, ease);
+			el._spawnTween.eventCallback("onComplete", () => {
+				if (hasGClass(el, "leave")) refreshLeaveRect(el);
+				if (hasGClass(el, "flip")) captureFlip(el);
+				fireOnComplete(el, "spawn");
+			});
+		}
+	};
+	let appearObserver = null;
+	let leaveObserver = null;
+	let hubObserver = null;
+	let hubRaf = null;
+	let hubQueue = [];
+	let hubCurrentBatch = null;
+	let hubCursor = 0;
+	const handleFlipBatch = (mutations) => {
+		for (const mutation of mutations) {
+			if (mutation.type !== "childList") continue;
+			const target = mutation.target;
+			if (target.nodeType !== 1) continue;
+			flipRoots.add(target);
+		}
+	};
+	const handleAppearBatch = (mutations) => {
+		mutations.forEach((mutation) => {
+			mutation.addedNodes.forEach((node) => {
+				if (node.nodeType !== 1) return;
+				const els = node.querySelectorAll?.("*") ? [node, ...node.querySelectorAll("*")] : [node];
+				let pinned = false;
+				els.forEach((el) => {
+					if (!hasGClass(el, "appear")) return;
+					animateAppear(el);
+					setupScroll(el);
+					setupScrollDriven(el);
+					if (el.dataset?.gsapSetup) return;
+					el.dataset.gsapSetup = "1";
+					setupClicks(el);
+					setupLoops(el);
+					setupHoverClick(el);
+					setupCssAnims(el);
+					runSetup(el);
+					const wasPinned = el.dataset.gsapPinned;
+					setupPin(el);
+					if (!wasPinned && el.dataset.gsapPinned) pinned = true;
+				});
+				applyMagnet();
+				if (pinned) gsap_all.ScrollTrigger.refresh();
+			});
+		});
+	};
+	const handleLeaveBatch = (mutations) => {
+		mutations.forEach((mutation) => {
+			if (mutation.type !== "childList") return;
+			mutation.addedNodes.forEach((n) => collectLeave(n).forEach(captureLeave));
+			mutation.removedNodes.forEach((n) => collectLeave(n).forEach(playLeave));
+		});
+	};
+	const hubHandlers = [
+		handleFlipBatch,
+		handleAppearBatch,
+		handleLeaveBatch
+	];
+	const hubDrain = () => {
+		hubRaf = null;
+		if (!hubCurrentBatch) {
+			if (!hubQueue.length) return;
+			hubCurrentBatch = hubQueue.splice(0, hubQueue.length);
+			hubCursor = 0;
+		}
+		const end = Math.min(hubCursor + throttlePerFrame, hubHandlers.length);
+		for (let i = hubCursor; i < end; i++) {
+			hubHandlers[i](hubCurrentBatch);
+			if (hubHandlers[i] === handleFlipBatch) flushFlipRoots();
+		}
+		hubCursor = end;
+		if (hubCursor < hubHandlers.length) hubRaf = requestAnimationFrame(hubDrain);
+		else {
+			hubCurrentBatch = null;
+			hubCursor = 0;
+			if (hubQueue.length) hubRaf = requestAnimationFrame(hubDrain);
+		}
+	};
+	const scheduleHub = () => {
+		if (hubRaf) return;
+		hubRaf = requestAnimationFrame(hubDrain);
+	};
+	if (throttlePerFrame > 0) {
+		hubObserver = new MutationObserver((mutations) => {
+			hubQueue.push(...mutations);
+			scheduleHub();
+		});
+		hubObserver.observe(document.body, {
+			childList: true,
+			subtree: true
+		});
+	} else {
+		flipObserver = new MutationObserver((mutations) => {
+			handleFlipBatch(mutations);
+			if (!flipPendingRaf) flipPendingRaf = requestAnimationFrame(() => {
+				flipPendingRaf = null;
+				flushFlipRoots();
+			});
+		});
+		flipObserver.observe(document.body, {
+			childList: true,
+			subtree: true
+		});
+		appearObserver = new MutationObserver((mutations) => {
+			handleAppearBatch(mutations);
+		});
+		appearObserver.observe(document.body, {
+			childList: true,
+			subtree: true
+		});
+		qAll("body *").filter((el) => hasGClass(el, "leave")).forEach(captureLeave);
+		leaveObserver = new MutationObserver((mutations) => {
+			handleLeaveBatch(mutations);
+		});
+		leaveObserver.observe(document.body, {
+			childList: true,
+			subtree: true
+		});
+	}
+	if (throttlePerFrame > 0) qAll("body *").filter((el) => hasGClass(el, "leave")).forEach(captureLeave);
+	const qAllLeaves = () => qAll("body *").filter((el) => hasGClass(el, "leave"));
+	let positionTick = false;
+	const refreshLeavePositions = () => {
+		if (positionTick) return;
+		positionTick = true;
+		requestAnimationFrame(() => {
+			qAllLeaves().forEach((el) => {
+				const s = leaveStates.get(el);
+				if (s) s.rect = el.getBoundingClientRect();
+			});
+			positionTick = false;
+		});
+	};
+	window.addEventListener("scroll", refreshLeavePositions, { passive: true });
+	window.addEventListener("resize", refreshLeavePositions, { passive: true });
+	const bpMqls = bpEntries.map(([bp, px]) => {
+		const mql = typeof window !== "undefined" && window.matchMedia ? window.matchMedia(`(min-width: ${px}px)`) : null;
+		if (!mql) return null;
+		const fn = () => gsap_all.ScrollTrigger.refresh();
+		mql.addEventListener?.("change", fn);
+		return {
+			mql,
+			fn
+		};
+	}).filter(Boolean);
+	return () => {
+		appearObserver?.disconnect();
+		leaveObserver?.disconnect();
+		flipObserver?.disconnect();
+		if (hubObserver) hubObserver.disconnect();
+		if (hubRaf) cancelAnimationFrame(hubRaf);
+		if (flipPendingRaf) cancelAnimationFrame(flipPendingRaf);
+		window.removeEventListener("scroll", refreshLeavePositions);
+		window.removeEventListener("resize", refreshLeavePositions);
+		bpMqls.forEach(({ mql, fn }) => mql.removeEventListener?.("change", fn));
+		mm.revert();
+		window.removeEventListener("load", gsap_all.ScrollTrigger.refresh);
+		clearTimeout(refreshTimer);
+		scrollTriggers.forEach((t) => {
+			const tw = t.trigger._scrollTween;
+			const cls = t.trigger.classList;
+			if (tw && !tw.reversed() && (cls?.contains("typewriter") || cls?.contains("scramble"))) tw.progress(1);
+			t.kill(true);
+			t.trigger._scrollTween?.kill();
+			delete t.trigger._scrollTween;
+		});
+		gsap_all.ScrollTrigger.refresh();
+		qAll("[data-gsap-scroll],[data-gsap-setup],[data-gsap-pinned],[data-gsap-scroll-driven]").forEach((el) => {
+			delete el.dataset.gsapScroll;
+			delete el.dataset.gsapSetup;
+			delete el.dataset.gsapPinned;
+			delete el.dataset.gsapScrollDriven;
+			delete el._appeared;
+		});
+		registeredListeners.forEach(({ el, type, fn }) => el.removeEventListener(type, fn));
+		magnetListeners.forEach(({ el, type, fn }) => el.removeEventListener(type, fn));
+		magnetQuery?.removeEventListener("change", applyMagnet);
+		loopEls.forEach(({ el, key }) => el[key]?.kill());
+		document.querySelectorAll("[data-gsap-radiate]").forEach((n) => n.remove());
+		cssTweens.forEach((t) => t?.kill());
+		cssTweens.length = 0;
+		qAll(".typewriter, .scramble").forEach((el) => {
+			const keep = el.isConnected && underPreservedRoot(el);
+			const tw = el.typewriter || el._spawnTween || el._scrollTween;
+			if (!keep && tw && !tw.reversed()) tw.progress(1);
+			tw?.kill();
+		});
+		textSplits.forEach((s) => {
+			if (!(s.elements || []).some((e) => e.isConnected && underPreservedRoot(e))) {
+				(s.elements || []).forEach((e) => splitCache.delete(e));
+				revertSplitInstance(s);
+			}
+		});
+		textSplits.length = 0;
+		onCompleteTweens.forEach((t) => t?.kill());
+		onCompleteTweens.length = 0;
+		setupTeardowns.forEach((fn) => {
+			try {
+				fn();
+			} catch {}
+		});
+		setupTeardowns.length = 0;
+	};
+}
+//#endregion
+//#region AnimToggle.js
+var STORAGE_KEY = "gclass-animations-enabled";
+var REDUCED_KEY = "gclass-reduced-motion";
+var reducedMotionQuery = typeof window !== "undefined" ? window.matchMedia("(prefers-reduced-motion: reduce)") : null;
+var stored = readStored();
+var reduced = reducedMotionQuery?.matches ?? false;
+var forcedReduced = readReducedOverride();
+var subscribers = /* @__PURE__ */ new Set();
+function readStored() {
+	if (typeof window === "undefined") return null;
+	try {
+		const raw = localStorage.getItem(STORAGE_KEY);
+		return raw === null ? null : raw === "true";
+	} catch {
+		return null;
+	}
+}
+function readReducedOverride() {
+	if (typeof window === "undefined") return false;
+	try {
+		return localStorage.getItem(REDUCED_KEY) === "true";
+	} catch {
+		return false;
+	}
+}
+function getEnabled() {
+	if (forcedReduced) return false;
+	return stored === null ? !reduced : stored;
+}
+function emit() {
+	subscribers.forEach((fn) => fn(getEnabled()));
+}
+if (reducedMotionQuery) reducedMotionQuery.addEventListener("change", () => {
+	reduced = reducedMotionQuery.matches;
+	emit();
+});
+function toggleAnimations() {
+	stored = !getEnabled();
+	try {
+		localStorage.setItem(STORAGE_KEY, String(stored));
+	} catch {}
+	emit();
+	if (typeof window !== "undefined") window.location.reload();
+}
+function enableReducedMotion() {
+	forcedReduced = true;
+	try {
+		localStorage.setItem(REDUCED_KEY, "true");
+	} catch {}
+	emit();
+	if (typeof window !== "undefined") window.location.reload();
+}
+function disableReducedMotion() {
+	forcedReduced = false;
+	try {
+		localStorage.removeItem(REDUCED_KEY);
+	} catch {}
+	emit();
+	if (typeof window !== "undefined") window.location.reload();
+}
+var cleanup = null;
+var bootCleanup = null;
+var bootTimeout = null;
+var bootStyle = null;
+var hasBooted = false;
+var currentThrottle = 0;
+var currentFps = 0;
+var configSubscribers = /* @__PURE__ */ new Set();
+function getConfigSnapshot() {
+	return {
+		throttlePerFrame: currentThrottle,
+		fps: currentFps
+	};
+}
+function emitConfig() {
+	configSubscribers.forEach((fn) => fn(getConfigSnapshot()));
+}
+function applyFps(fps) {
+	const v = Number(fps) || 0;
+	currentFps = v;
+	if (v > 0) gsap.gsap.ticker.fps(v);
+	else gsap.gsap.ticker.fps(0);
+	emitConfig();
+}
+function normalizeGclassArgs(throttlePerFrame, fps) {
+	if (typeof throttlePerFrame === "object" && throttlePerFrame !== null) {
+		fps = throttlePerFrame.fps;
+		throttlePerFrame = throttlePerFrame.throttlePerFrame;
+	}
+	return {
+		nextThrottle: throttlePerFrame == null ? 0 : Number(throttlePerFrame) || 0,
+		nextFps: fps == null ? 0 : Number(fps) || 0
+	};
+}
+/**
+* Change GClass runtime options on the fly without reload.
+* gclassOpts(throttlePerFrame, fps) — both optional numbers.
+* gclassOpts() or gclassOpts(undefined, undefined) resets to defaults (no throttle, default ticker).
+* Also accepts gclassOpts({throttlePerFrame, fps}).
+* Example low-end button: onClick={() => gclassOpts(1, 30)}
+* Example reset: onClick={() => gclassOpts()} // 0, 60fps rAF
+*/
+function gclassOpts(throttlePerFrame, fps) {
+	const { nextThrottle, nextFps } = normalizeGclassArgs(throttlePerFrame, fps);
+	currentThrottle = nextThrottle;
+	applyFps(nextFps);
+	if (typeof window !== "undefined" && cleanup && !bootTimeout) {
+		try {
+			cleanup();
+		} catch {}
+		cleanup = null;
+		if (getEnabled()) cleanup = initListeners(document, currentThrottle);
+	}
+	return getConfigSnapshot();
+}
+function getGClassConfig() {
+	return getConfigSnapshot();
+}
+function subscribeGClassConfig(cb) {
+	configSubscribers.add(cb);
+	return () => configSubscribers.delete(cb);
+}
+var readBootTime = (els, fallback) => {
+	let max = null;
+	for (const el of els) {
+		const cls = [...el.classList].find((c) => c.startsWith("boot-time-"));
+		if (cls) {
+			const n = Number(cls.slice(10));
+			if (!Number.isNaN(n)) max = max === null ? n : Math.max(max, n);
+		}
+	}
+	return max ?? fallback;
+};
+function initAnimations(throttlePerFrame, fps) {
+	let effThrottle = currentThrottle;
+	let effFps = currentFps;
+	if (throttlePerFrame !== void 0 || fps !== void 0) {
+		const { nextThrottle, nextFps } = normalizeGclassArgs(throttlePerFrame, fps);
+		effThrottle = nextThrottle;
+		effFps = nextFps;
+		currentThrottle = effThrottle;
+		currentFps = effFps;
+		if (effFps > 0) gsap.gsap.ticker.fps(effFps);
+		else gsap.gsap.ticker.fps(0);
+		emitConfig();
+	} else if (effFps > 0) gsap.gsap.ticker.fps(effFps);
+	else gsap.gsap.ticker.fps(0);
+	if (typeof window === "undefined" || !getEnabled()) return;
+	if (bootTimeout) {
+		console.log(`[initAnimations] boot already in progress - ignoring duplicate call`);
+		return;
+	}
+	if (cleanup) {
+		cleanup();
+		cleanup = null;
+	}
+	if (bootCleanup) {
+		bootCleanup();
+		bootCleanup = null;
+	}
+	if (bootStyle) {
+		bootStyle.remove();
+		bootStyle = null;
+		document.documentElement.classList.remove("gclass-booting");
+	}
+	const hideBootEls = (els) => {
+		els.forEach((el) => {
+			el.style.display = "none";
+			el.setAttribute("hidden", "");
+			el.setAttribute("data-gclass-boot-hidden", "1");
+		});
+	};
+	const bootEls = typeof document !== "undefined" ? [...document.querySelectorAll(".boot-up")].filter((el) => !el.hasAttribute("data-gclass-boot-hidden")) : [];
+	if (!bootEls.length) {} else if (bootEls.length > 1) {
+		console.error(`[initAnimations] Multiple .boot-up elements detected (${bootEls.length}) - skipping all boot animations`, bootEls);
+		hideBootEls(bootEls);
+		hasBooted = true;
+	} else if (hasBooted && !bootTimeout) {
+		console.log(`[initAnimations] skipping boot on path change (already booted)`, bootEls);
+		hideBootEls(bootEls);
+		hasBooted = true;
+	} else {
+		const bootEl = bootEls[0];
+		if (![...bootEl.classList].some((c) => c.startsWith("boot-end-"))) {}
+		const bootTime = readBootTime(bootEls, defaults.bootTime ?? 2);
+		console.log(`[initAnimations] .boot-up found: ${bootEls.length} - pausing DOM for ${bootTime}s`, bootEls);
+		hasBooted = true;
+		bootStyle = document.createElement("style");
+		bootStyle.id = "gclass-boot-style";
+		bootStyle.textContent = `html.gclass-booting{visibility:hidden} html.gclass-booting .boot-up,html.gclass-booting .boot-up *{visibility:visible} html.gclass-booting .boot-up{position:fixed;inset:0;z-index:9999;display:grid;place-items:center}`;
+		document.head.appendChild(bootStyle);
+		document.documentElement.classList.add("gclass-booting");
+		bootEls.forEach((el) => {
+			el.style.visibility = "visible";
+		});
+		bootCleanup = initListeners(bootEl, effThrottle);
+		bootTimeout = setTimeout(() => {
+			const bootEndCls = [...bootEl.classList].find((c) => c.startsWith("boot-end-"));
+			if (!bootEndCls) {
+				bootCleanup?.();
+				bootCleanup = null;
+				document.documentElement.classList.remove("gclass-booting");
+				bootStyle?.remove();
+				bootStyle = null;
+				hideBootEls(bootEls);
+				bootTimeout = null;
+				cleanup = initListeners(document, effThrottle);
+				return;
+			}
+			const name = bootEndCls.slice(9);
+			const cfg = animations.find((a) => a.sel === "." + name);
+			const from = cfg?.from;
+			const easeCl = [...bootEl.classList].find((c) => c.startsWith("ease-"));
+			const ease = easeCl ? easeCl.split("-")[1] : defaults.ease;
+			const dur = readBootTime([bootEl], defaults.effectDuration ?? 1);
+			const endTimeCls = [...bootEl.classList].find((c) => c.startsWith("boot-end-time-"));
+			const endDur = endTimeCls ? Number(endTimeCls.slice(14)) : dur;
+			const finish = () => {
+				bootCleanup?.();
+				bootCleanup = null;
+				document.documentElement.classList.remove("gclass-booting");
+				bootStyle?.remove();
+				bootStyle = null;
+				hideBootEls(bootEls);
+				bootTimeout = null;
+				cleanup = initListeners(document, effThrottle);
+			};
+			if (!cfg || !from) {
+				console.warn(`[initAnimations] boot-end-${name} has no from state - removing without animation`);
+				finish();
+				return;
+			}
+			gsap.gsap.to(bootEl, {
+				...from,
+				duration: endDur,
+				ease,
+				onComplete: finish
+			});
+		}, bootTime * 1e3);
+		return;
+	}
+	cleanup = initListeners(document, effThrottle);
+}
+//#endregion
+exports.SpawnH = SpawnH;
+exports.SpawnV = SpawnV;
+exports.animatecss = animatecss;
+exports.animations = animations;
+exports.bell = bell;
+exports.bounce = bounce;
+exports.countTargetVars = countTargetVars;
+exports.countUp = countUp;
+exports.curtainHorizontal = curtainHorizontal;
+exports.curtainVertical = curtainVertical;
+exports.customAnims = customAnims;
+exports.defaults = defaults;
+exports.disableReducedMotion = disableReducedMotion;
+exports.drawsvg = drawsvg;
+exports.drawsvgSplit = drawsvgSplit;
+exports.enableReducedMotion = enableReducedMotion;
+exports.expandA = expandA;
+exports.expandDown = expandDown;
+exports.expandH = expandH;
+exports.expandLeft = expandLeft;
+exports.expandRight = expandRight;
+exports.expandUp = expandUp;
+exports.expandV = expandV;
+exports.expandmove = expandmove;
+exports.finalOpacity = finalOpacity;
+exports.flip = flip;
+exports.gclassOpts = gclassOpts;
+exports.getGClassConfig = getGClassConfig;
+exports.hover = hover;
+exports.initAnimations = initAnimations;
+exports.initListeners = initListeners;
+exports.magnet = magnet;
+exports.magnet3d = magnet3d;
+exports.marquee = marquee;
+exports.normalize = normalize;
+exports.pulse = pulse;
+exports.radiate = radiate;
+exports.registerComplete = registerComplete;
+exports.reset = reset;
+exports.scramble = scramble;
+exports.scrambleSegments = scrambleSegments;
+exports.scrambleVars = scrambleVars;
+exports.shake = shake;
+exports.spawnBlur = spawnBlur;
+exports.spawnClipReveal = spawnClipReveal;
+exports.spawnFade = spawnFade;
+exports.spawnSpinCCW = spawnSpinCCW;
+exports.spawnSpinCW = spawnSpinCW;
+exports.spawnXDown = spawnXDown;
+exports.spawnXUp = spawnXUp;
+exports.spawnYLeft = spawnYLeft;
+exports.spawnYRight = spawnYRight;
+exports.spinCCW = spinCCW;
+exports.spinCW = spinCW;
+exports.splitPaths = splitPaths;
+exports.stashText = stashText;
+exports.subscribeGClassConfig = subscribeGClassConfig;
+exports.toggleAnimations = toggleAnimations;
+exports.typewriter = typewriter;
+exports.verticalmove = verticalmove;