@loczer/storefront-sdk 0.181.0 → 0.183.0

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation-BP9WTp3S.js

@@ -0,0 +1,107 @@
+import { noop as e } from "../../../../motion-utils/dist/es/noop-DYtO-mQc.js";
+import { MotionGlobalConfig as t } from "../../../../motion-utils/dist/es/global-config-Enkm8IYK.js";
+import { time as n } from "../frameloop/sync-time-Csr7zKS1.js";
+import { KeyframeResolver as r, flushKeyframeResolvers as i } from "./keyframes/KeyframesResolver-BsqYA1rL.js";
+import { getFinalKeyframe as a } from "./keyframes/get-final-CWJZQtB4.js";
+import { WithPromise as o } from "./utils/WithPromise-Cgc9goXq.js";
+import { JSAnimation as s } from "./JSAnimation-BDvXel6c.js";
+import { makeAnimationInstant as c } from "./utils/make-animation-instant-U5cXt8Kq.js";
+import { NativeAnimationExtended as l } from "./NativeAnimationExtended-BiOr5CR4.js";
+import { canAnimate as u } from "./utils/can-animate-CADmGQOl.js";
+import { supportsBrowserAnimation as d } from "./waapi/supports/waapi-Dl4IhSkD.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.js
+var f = 40, p = class extends o {
+	constructor({ autoplay: e = !0, delay: t = 0, type: i = "keyframes", repeat: a = 0, repeatDelay: o = 0, repeatType: s = "loop", keyframes: c, name: l, motionValue: u, element: d, ...f }) {
+		super(), this.stop = () => {
+			this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+		}, this.createdAt = n.now();
+		let p = {
+			autoplay: e,
+			delay: t,
+			type: i,
+			repeat: a,
+			repeatDelay: o,
+			repeatType: s,
+			name: l,
+			motionValue: u,
+			element: d,
+			...f
+		}, m = d?.KeyframeResolver || r;
+		this.keyframeResolver = new m(c, (e, t, n) => this.onKeyframesResolved(e, t, p, !n), l, u, d), this.keyframeResolver?.scheduleResolve();
+	}
+	onKeyframesResolved(r, i, o, p) {
+		this.keyframeResolver = void 0;
+		let { name: m, type: h, velocity: g, delay: _, isHandoff: v, onUpdate: y } = o;
+		this.resolvedAt = n.now();
+		let b = !0;
+		u(r, m, h, g) || (b = !1, (t.instantAnimations || !_) && y?.(a(r, o, i)), r[0] = r[r.length - 1], c(o), o.repeat = 0);
+		let x = {
+			startTime: p ? this.resolvedAt && this.resolvedAt - this.createdAt > f ? this.resolvedAt : this.createdAt : void 0,
+			finalKeyframe: i,
+			...o,
+			keyframes: r
+		}, S = b && !v && d(x), C = x.motionValue?.owner?.current, w;
+		if (S) try {
+			w = new l({
+				...x,
+				element: C
+			});
+		} catch {
+			w = new s(x);
+		}
+		else w = new s(x);
+		w.finished.then(() => {
+			this.notifyFinished();
+		}).catch(e), this.pendingTimeline &&= (this.stopTimeline = w.attachTimeline(this.pendingTimeline), void 0), this._animation = w;
+	}
+	get finished() {
+		return this._animation ? this.animation.finished : this._finished;
+	}
+	then(e, t) {
+		return this.finished.finally(e).then(() => {});
+	}
+	get animation() {
+		return this._animation || (this.keyframeResolver?.resume(), i()), this._animation;
+	}
+	get duration() {
+		return this.animation.duration;
+	}
+	get iterationDuration() {
+		return this.animation.iterationDuration;
+	}
+	get time() {
+		return this.animation.time;
+	}
+	set time(e) {
+		this.animation.time = e;
+	}
+	get speed() {
+		return this.animation.speed;
+	}
+	get state() {
+		return this.animation.state;
+	}
+	set speed(e) {
+		this.animation.speed = e;
+	}
+	get startTime() {
+		return this.animation.startTime;
+	}
+	attachTimeline(e) {
+		return this._animation ? this.stopTimeline = this.animation.attachTimeline(e) : this.pendingTimeline = e, () => this.stop();
+	}
+	play() {
+		this.animation.play();
+	}
+	pause() {
+		this.animation.pause();
+	}
+	complete() {
+		this.animation.complete();
+	}
+	cancel() {
+		this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
+	}
+};
+//#endregion
+export { p as AsyncMotionValueAnimation };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/JSAnimation-BDvXel6c.js

@@ -0,0 +1,129 @@
+import { invariant as e } from "../../../../motion-utils/dist/es/errors-CeqOX87S.js";
+import { millisecondsToSeconds as t, secondsToMilliseconds as n } from "../../../../motion-utils/dist/es/time-conversion-DonUfQ-z.js";
+import { time as r } from "../frameloop/sync-time-Csr7zKS1.js";
+import { clamp as i } from "../../../../motion-utils/dist/es/clamp-oTrl-WQn.js";
+import { getFinalKeyframe as a } from "./keyframes/get-final-CWJZQtB4.js";
+import { WithPromise as o } from "./utils/WithPromise-Cgc9goXq.js";
+import { pipe as s } from "../../../../motion-utils/dist/es/pipe-kCgd5LWB.js";
+import { mix as c } from "../utils/mix/index-C-28MAlE.js";
+import { frameloopDriver as l } from "./drivers/frame-Djx0PNab.js";
+import { calcGeneratorDuration as u } from "./generators/utils/calc-duration-UXviOifF.js";
+import { getGeneratorVelocity as d } from "./generators/utils/velocity-Du7sddjq.js";
+import { inertia as f } from "./generators/inertia-CfnL1Tii.js";
+import { keyframes as p } from "./generators/keyframes-CCLQ_uXL.js";
+import { replaceTransitionType as m } from "./utils/replace-transition-type-DNXxPeoH.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/JSAnimation.js
+var h = (e) => e / 100, g = class extends o {
+	constructor(e) {
+		super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
+			done: !1,
+			value: void 0
+		}, this.stop = () => {
+			let { motionValue: e } = this.options;
+			e && e.updatedAt !== r.now() && this.tick(r.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+		}, this.options = e, this.initAnimation(), this.play(), e.autoplay === !1 && this.pause();
+	}
+	initAnimation() {
+		let { options: t } = this;
+		m(t);
+		let { type: n = p, repeat: r = 0, repeatDelay: i = 0, repeatType: a, velocity: o = 0 } = t, { keyframes: l } = t, d = n || p;
+		process.env.NODE_ENV !== "production" && d !== p && e(l.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${l}`, "spring-two-frames"), d !== p && typeof l[0] != "number" && (this.mixKeyframes = s(h, c(l[0], l[1])), l = [0, 100]);
+		let f = d({
+			...t,
+			keyframes: l
+		});
+		a === "mirror" && (this.mirroredGenerator = d({
+			...t,
+			keyframes: [...l].reverse(),
+			velocity: -o
+		})), f.calculatedDuration === null && (f.calculatedDuration = u(f));
+		let { calculatedDuration: g } = f;
+		this.calculatedDuration = g, this.resolvedDuration = g + i, this.totalDuration = this.resolvedDuration * (r + 1) - i, this.generator = f;
+	}
+	updateTime(e) {
+		let t = Math.round(e - this.startTime) * this.playbackSpeed;
+		this.holdTime === null ? this.currentTime = t : this.currentTime = this.holdTime;
+	}
+	tick(e, t = !1) {
+		let { generator: n, totalDuration: r, mixKeyframes: o, mirroredGenerator: s, resolvedDuration: c, calculatedDuration: l } = this;
+		if (this.startTime === null) return n.next(0);
+		let { delay: u = 0, keyframes: d, repeat: p, repeatType: m, repeatDelay: h, type: g, onUpdate: _, finalKeyframe: v } = this.options;
+		this.speed > 0 ? this.startTime = Math.min(this.startTime, e) : this.speed < 0 && (this.startTime = Math.min(e - r / this.speed, this.startTime)), t ? this.currentTime = e : this.updateTime(e);
+		let y = this.currentTime - u * (this.playbackSpeed >= 0 ? 1 : -1), b = this.playbackSpeed >= 0 ? y < 0 : y > r;
+		this.currentTime = Math.max(y, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = r);
+		let x = this.currentTime, S = n;
+		if (p) {
+			let e = Math.min(this.currentTime, r) / c, t = Math.floor(e), n = e % 1;
+			!n && e >= 1 && (n = 1), n === 1 && t--, t = Math.min(t, p + 1), t % 2 && (m === "reverse" ? (n = 1 - n, h && (n -= h / c)) : m === "mirror" && (S = s)), x = i(0, 1, n) * c;
+		}
+		let C;
+		b ? (this.delayState.value = d[0], C = this.delayState) : C = S.next(x), o && !b && (C.value = o(C.value));
+		let { done: w } = C;
+		!b && l !== null && (w = this.playbackSpeed >= 0 ? this.currentTime >= r : this.currentTime <= 0);
+		let T = this.holdTime === null && (this.state === "finished" || this.state === "running" && w);
+		return T && g !== f && (C.value = a(d, this.options, v, this.speed)), _ && _(C.value), T && this.finish(), C;
+	}
+	then(e, t) {
+		return this.finished.then(e, t);
+	}
+	get duration() {
+		return t(this.calculatedDuration);
+	}
+	get iterationDuration() {
+		let { delay: e = 0 } = this.options || {};
+		return this.duration + t(e);
+	}
+	get time() {
+		return t(this.currentTime);
+	}
+	set time(e) {
+		e = n(e), this.currentTime = e, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = e : this.driver && (this.startTime = this.driver.now() - e / this.playbackSpeed), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = e, this.tick(e));
+	}
+	getGeneratorVelocity() {
+		let e = this.currentTime;
+		if (e <= 0) return this.options.velocity || 0;
+		if (this.generator.velocity) return this.generator.velocity(e);
+		let t = this.generator.next(e).value;
+		return d((e) => this.generator.next(e).value, e, t);
+	}
+	get speed() {
+		return this.playbackSpeed;
+	}
+	set speed(e) {
+		let n = this.playbackSpeed !== e;
+		n && this.driver && this.updateTime(r.now()), this.playbackSpeed = e, n && this.driver && (this.time = t(this.currentTime));
+	}
+	play() {
+		if (this.isStopped) return;
+		let { driver: e = l, startTime: t } = this.options;
+		this.driver ||= e((e) => this.tick(e)), this.options.onPlay?.();
+		let n = this.driver.now();
+		this.state === "finished" ? (this.updateFinished(), this.startTime = n) : this.holdTime === null ? this.startTime ||= t ?? n : this.startTime = n - this.holdTime, this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+	}
+	pause() {
+		this.state = "paused", this.updateTime(r.now()), this.holdTime = this.currentTime;
+	}
+	complete() {
+		this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+	}
+	finish() {
+		this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+	}
+	cancel() {
+		this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+	}
+	teardown() {
+		this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+	}
+	stopDriver() {
+		this.driver &&= (this.driver.stop(), void 0);
+	}
+	sample(e) {
+		return this.startTime = 0, this.tick(e, !0);
+	}
+	attachTimeline(e) {
+		return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), e.observe(this);
+	}
+};
+//#endregion
+export { g as JSAnimation };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/NativeAnimation-ivvaBBQG.js

@@ -0,0 +1,84 @@
+import { invariant as e } from "../../../../motion-utils/dist/es/errors-CeqOX87S.js";
+import { millisecondsToSeconds as t, secondsToMilliseconds as n } from "../../../../motion-utils/dist/es/time-conversion-DonUfQ-z.js";
+import { noop as r } from "../../../../motion-utils/dist/es/noop-DYtO-mQc.js";
+import { getFinalKeyframe as i } from "./keyframes/get-final-CWJZQtB4.js";
+import { WithPromise as a } from "./utils/WithPromise-Cgc9goXq.js";
+import { setStyle as o } from "../render/dom/style-set-EkWJ2vSm.js";
+import { supportsScrollTimeline as s } from "../utils/supports/scroll-timeline-B8WiK9DT.js";
+import { startWaapiAnimation as c } from "./waapi/start-waapi-animation-B8kYQSUt.js";
+import { applyGeneratorOptions as l } from "./waapi/utils/apply-generator-FYhob63l.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/NativeAnimation.js
+var u = class extends a {
+	constructor(t) {
+		if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !t) return;
+		let { element: n, name: r, keyframes: a, pseudoElement: s, allowFlatten: u = !1, finalKeyframe: d, onComplete: f } = t;
+		this.isPseudoElement = !!s, this.allowFlatten = u, this.options = t, e(typeof t.type != "string", "Mini animate() doesn't support \"type\" as a string.", "mini-spring");
+		let p = l(t);
+		this.animation = c(n, r, a, p, s), p.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+			if (this.finishedTime = this.time, !s) {
+				let e = i(a, this.options, d, this.speed);
+				this.updateMotionValue && this.updateMotionValue(e), o(n, r, e), this.animation.cancel();
+			}
+			f?.(), this.notifyFinished();
+		};
+	}
+	play() {
+		this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+	}
+	pause() {
+		this.animation.pause();
+	}
+	complete() {
+		this.animation.finish?.();
+	}
+	cancel() {
+		try {
+			this.animation.cancel();
+		} catch {}
+	}
+	stop() {
+		if (this.isStopped) return;
+		this.isStopped = !0;
+		let { state: e } = this;
+		e === "idle" || e === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+	}
+	commitStyles() {
+		let e = this.options?.element;
+		!this.isPseudoElement && e?.isConnected && this.animation.commitStyles?.();
+	}
+	get duration() {
+		let e = this.animation.effect?.getComputedTiming?.().duration || 0;
+		return t(Number(e));
+	}
+	get iterationDuration() {
+		let { delay: e = 0 } = this.options || {};
+		return this.duration + t(e);
+	}
+	get time() {
+		return t(Number(this.animation.currentTime) || 0);
+	}
+	set time(e) {
+		let t = this.finishedTime !== null;
+		this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = n(e), t && this.animation.pause();
+	}
+	get speed() {
+		return this.animation.playbackRate;
+	}
+	set speed(e) {
+		e < 0 && (this.finishedTime = null), this.animation.playbackRate = e;
+	}
+	get state() {
+		return this.finishedTime === null ? this.animation.playState : "finished";
+	}
+	get startTime() {
+		return this.manualStartTime ?? Number(this.animation.startTime);
+	}
+	set startTime(e) {
+		this.manualStartTime = this.animation.startTime = e;
+	}
+	attachTimeline({ timeline: e, rangeStart: t, rangeEnd: n, observe: i }) {
+		return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, e && s() ? (this.animation.timeline = e, t && (this.animation.rangeStart = t), n && (this.animation.rangeEnd = n), r) : i(this);
+	}
+};
+//#endregion
+export { u as NativeAnimation };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended-BiOr5CR4.js

@@ -0,0 +1,28 @@
+import { time as e } from "../frameloop/sync-time-Csr7zKS1.js";
+import { clamp as t } from "../../../../motion-utils/dist/es/clamp-oTrl-WQn.js";
+import { setStyle as n } from "../render/dom/style-set-EkWJ2vSm.js";
+import { NativeAnimation as r } from "./NativeAnimation-ivvaBBQG.js";
+import { replaceTransitionType as i } from "./utils/replace-transition-type-DNXxPeoH.js";
+import { JSAnimation as a } from "./JSAnimation-BDvXel6c.js";
+import { replaceStringEasing as o } from "./waapi/utils/unsupported-easing-BTGtGcsc.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.js
+var s = 10, c = class extends r {
+	constructor(e) {
+		o(e), i(e), super(e), e.startTime !== void 0 && e.autoplay !== !1 && (this.startTime = e.startTime), this.options = e;
+	}
+	updateMotionValue(r) {
+		let { motionValue: i, onUpdate: o, onComplete: c, element: l, ...u } = this.options;
+		if (!i) return;
+		if (r !== void 0) {
+			i.set(r);
+			return;
+		}
+		let d = new a({
+			...u,
+			autoplay: !1
+		}), f = Math.max(s, e.now() - this.startTime), p = t(0, s, f - s), m = d.sample(f).value, { name: h } = this.options;
+		l && h && n(l, h, m), i.setWithVelocity(d.sample(Math.max(0, f - p)).value, m, p), d.stop();
+	}
+};
+//#endregion
+export { c as NativeAnimationExtended };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/animate/single-value-XURU5lW9.js

@@ -0,0 +1,10 @@
+import { motionValue as e } from "../../value/index-CNA9eaPX.js";
+import { isMotionValue as t } from "../../value/utils/is-motion-value-DK1-eYBh.js";
+import { animateMotionValue as n } from "../interfaces/motion-value-CFPGHF-L.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/animate/single-value.js
+function r(r, i, a) {
+	let o = t(r) ? r : e(r);
+	return o.start(n("", o, i, a)), o.animation;
+}
+//#endregion
+export { r as animateSingleValue };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/drivers/frame-Djx0PNab.js

@@ -0,0 +1,13 @@
+import { cancelFrame as e, frame as t, frameData as n } from "../../frameloop/frame-CrXEyJWa.js";
+import { time as r } from "../../frameloop/sync-time-Csr7zKS1.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/drivers/frame.js
+var i = (i) => {
+	let a = ({ timestamp: e }) => i(e);
+	return {
+		start: (e = !0) => t.update(a, e),
+		stop: () => e(a),
+		now: () => n.isProcessing ? n.timestamp : r.now()
+	};
+};
+//#endregion
+export { i as frameloopDriver };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/generators/inertia-CfnL1Tii.js

@@ -0,0 +1,32 @@
+import { getGeneratorVelocity as e } from "./utils/velocity-Du7sddjq.js";
+import { spring as t } from "./spring-CAPsNQnU.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/generators/inertia.js
+function n({ keyframes: n, velocity: r = 0, power: i = .8, timeConstant: a = 325, bounceDamping: o = 10, bounceStiffness: s = 500, modifyTarget: c, min: l, max: u, restDelta: d = .5, restSpeed: f }) {
+	let p = n[0], m = {
+		done: !1,
+		value: p
+	}, h = (e) => l !== void 0 && e < l || u !== void 0 && e > u, g = (e) => l === void 0 ? u : u === void 0 || Math.abs(l - e) < Math.abs(u - e) ? l : u, _ = i * r, v = p + _, y = c === void 0 ? v : c(v);
+	y !== v && (_ = y - p);
+	let b = (e) => -_ * Math.exp(-e / a), x = (e) => y + b(e), S = (e) => {
+		let t = b(e), n = x(e);
+		m.done = Math.abs(t) <= d, m.value = m.done ? y : n;
+	}, C, w, T = (n) => {
+		h(m.value) && (C = n, w = t({
+			keyframes: [m.value, g(m.value)],
+			velocity: e(x, n, m.value),
+			damping: o,
+			stiffness: s,
+			restDelta: d,
+			restSpeed: f
+		}));
+	};
+	return T(0), {
+		calculatedDuration: null,
+		next: (e) => {
+			let t = !1;
+			return !w && C === void 0 && (t = !0, S(e), T(e)), C !== void 0 && e >= C ? w.next(e - C) : (!t && S(e), m);
+		}
+	};
+}
+//#endregion
+export { n as inertia };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/generators/keyframes-CCLQ_uXL.js

@@ -0,0 +1,22 @@
+import { easeInOut as e } from "../../../../../motion-utils/dist/es/easing/ease-B7AEB2ps.js";
+import { isEasingArray as t } from "../../../../../motion-utils/dist/es/easing/utils/is-easing-array-C39l-cFn.js";
+import { easingDefinitionToFunction as n } from "../../../../../motion-utils/dist/es/easing/utils/map-PaPdBfqP.js";
+import { interpolate as r } from "../../utils/interpolate-ozWLmPFy.js";
+import { defaultOffset as i } from "../keyframes/offsets/default-DyX1tTJO.js";
+import { convertOffsetToTimes as a } from "../keyframes/offsets/time-CdAFAp4U.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/generators/keyframes.js
+function o(t, n) {
+	return t.map(() => n || e).splice(0, t.length - 1);
+}
+function s({ duration: e = 300, keyframes: s, times: c, ease: l = "easeInOut" }) {
+	let u = t(l) ? l.map(n) : n(l), d = {
+		done: !1,
+		value: s[0]
+	}, f = r(a(c && c.length === s.length ? c : i(s), e), s, { ease: Array.isArray(u) ? u : o(s, u) });
+	return {
+		calculatedDuration: e,
+		next: (t) => (d.value = f(t), d.done = t >= e, d)
+	};
+}
+//#endregion
+export { o as defaultEasing, s as keyframes };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/generators/spring-CAPsNQnU.js

@@ -0,0 +1,166 @@
+import { warning as e } from "../../../../../motion-utils/dist/es/errors-CeqOX87S.js";
+import { millisecondsToSeconds as t, secondsToMilliseconds as n } from "../../../../../motion-utils/dist/es/time-conversion-DonUfQ-z.js";
+import { clamp as r } from "../../../../../motion-utils/dist/es/clamp-oTrl-WQn.js";
+import { generateLinearEasing as i } from "../waapi/utils/linear-B9sSlv1-.js";
+import { calcGeneratorDuration as a, maxGeneratorDuration as o } from "./utils/calc-duration-UXviOifF.js";
+import { createGeneratorEasing as s } from "./utils/create-generator-easing-DrH9ekbE.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/generators/spring.js
+var c = {
+	stiffness: 100,
+	damping: 10,
+	mass: 1,
+	velocity: 0,
+	duration: 800,
+	bounce: .3,
+	visualDuration: .3,
+	restSpeed: {
+		granular: .01,
+		default: 2
+	},
+	restDelta: {
+		granular: .005,
+		default: .5
+	},
+	minDuration: .01,
+	maxDuration: 10,
+	minDamping: .05,
+	maxDamping: 1
+};
+function l(e, t) {
+	return e * Math.sqrt(1 - t * t);
+}
+var u = 12;
+function d(e, t, n) {
+	let r = n;
+	for (let n = 1; n < u; n++) r -= e(r) / t(r);
+	return r;
+}
+var f = .001;
+function p({ duration: i = c.duration, bounce: a = c.bounce, velocity: o = c.velocity, mass: s = c.mass }) {
+	let u, p;
+	e(i <= n(c.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+	let m = 1 - a;
+	m = r(c.minDamping, c.maxDamping, m), i = r(c.minDuration, c.maxDuration, t(i)), m < 1 ? (u = (e) => {
+		let t = e * m, n = t * i, r = t - o, a = l(e, m), s = Math.exp(-n);
+		return f - r / a * s;
+	}, p = (e) => {
+		let t = e * m * i, n = t * o + o, r = m ** 2 * e ** 2 * i, a = Math.exp(-t), s = l(e ** 2, m);
+		return (-u(e) + f > 0 ? -1 : 1) * ((n - r) * a) / s;
+	}) : (u = (e) => -.001 + Math.exp(-e * i) * ((e - o) * i + 1), p = (e) => Math.exp(-e * i) * ((o - e) * (i * i)));
+	let h = 5 / i, g = d(u, p, h);
+	if (i = n(i), isNaN(g)) return {
+		stiffness: c.stiffness,
+		damping: c.damping,
+		duration: i
+	};
+	{
+		let e = g ** 2 * s;
+		return {
+			stiffness: e,
+			damping: m * 2 * Math.sqrt(s * e),
+			duration: i
+		};
+	}
+}
+var m = ["duration", "bounce"], h = [
+	"stiffness",
+	"damping",
+	"mass"
+];
+function g(e, t) {
+	return t.some((t) => e[t] !== void 0);
+}
+function _(e) {
+	let t = {
+		velocity: c.velocity,
+		stiffness: c.stiffness,
+		damping: c.damping,
+		mass: c.mass,
+		isResolvedFromDuration: !1,
+		...e
+	};
+	if (!g(e, h) && g(e, m)) if (t.velocity = 0, e.visualDuration) {
+		let n = e.visualDuration, i = 2 * Math.PI / (n * 1.2), a = i * i, o = 2 * r(.05, 1, 1 - (e.bounce || 0)) * Math.sqrt(a);
+		t = {
+			...t,
+			mass: c.mass,
+			stiffness: a,
+			damping: o
+		};
+	} else {
+		let n = p({
+			...e,
+			velocity: 0
+		});
+		t = {
+			...t,
+			...n,
+			mass: c.mass
+		}, t.isResolvedFromDuration = !0;
+	}
+	return t;
+}
+function v(e = c.visualDuration, r = c.bounce) {
+	let s = typeof e == "object" ? e : {
+		visualDuration: e,
+		keyframes: [0, 1],
+		bounce: r
+	}, { restSpeed: u, restDelta: d } = s, f = s.keyframes[0], p = s.keyframes[s.keyframes.length - 1], m = {
+		done: !1,
+		value: f
+	}, { stiffness: h, damping: g, mass: v, duration: y, velocity: b, isResolvedFromDuration: x } = _({
+		...s,
+		velocity: -t(s.velocity || 0)
+	}), S = b || 0, C = g / (2 * Math.sqrt(h * v)), w = p - f, T = t(Math.sqrt(h / v)), E = Math.abs(w) < 5;
+	u ||= E ? c.restSpeed.granular : c.restSpeed.default, d ||= E ? c.restDelta.granular : c.restDelta.default;
+	let D, O, k, A, j, M;
+	if (C < 1) k = l(T, C), A = (S + C * T * w) / k, D = (e) => {
+		let t = Math.exp(-C * T * e);
+		return p - t * (A * Math.sin(k * e) + w * Math.cos(k * e));
+	}, j = C * T * A + w * k, M = C * T * w - A * k, O = (e) => Math.exp(-C * T * e) * (j * Math.sin(k * e) + M * Math.cos(k * e));
+	else if (C === 1) {
+		D = (e) => p - Math.exp(-T * e) * (w + (S + T * w) * e);
+		let e = S + T * w;
+		O = (t) => Math.exp(-T * t) * (T * e * t - S);
+	} else {
+		let e = T * Math.sqrt(C * C - 1);
+		D = (t) => {
+			let n = Math.exp(-C * T * t), r = Math.min(e * t, 300);
+			return p - n * ((S + C * T * w) * Math.sinh(r) + e * w * Math.cosh(r)) / e;
+		};
+		let t = (S + C * T * w) / e, n = C * T * t - w * e, r = C * T * w - t * e;
+		O = (t) => {
+			let i = Math.exp(-C * T * t), a = Math.min(e * t, 300);
+			return i * (n * Math.sinh(a) + r * Math.cosh(a));
+		};
+	}
+	let N = {
+		calculatedDuration: x && y || null,
+		velocity: (e) => n(O(e)),
+		next: (e) => {
+			if (!x && C < 1) {
+				let t = Math.exp(-C * T * e), r = Math.sin(k * e), i = Math.cos(k * e), a = p - t * (A * r + w * i), o = n(t * (j * r + M * i));
+				return m.done = Math.abs(o) <= u && Math.abs(p - a) <= d, m.value = m.done ? p : a, m;
+			}
+			let t = D(e);
+			if (x) m.done = e >= y;
+			else {
+				let r = n(O(e));
+				m.done = Math.abs(r) <= u && Math.abs(p - t) <= d;
+			}
+			return m.value = m.done ? p : t, m;
+		},
+		toString: () => {
+			let e = Math.min(a(N), o), t = i((t) => N.next(e * t).value, e, 30);
+			return e + "ms " + t;
+		},
+		toTransition: () => {}
+	};
+	return N;
+}
+v.applyToOptions = (e) => {
+	let t = s(e, 100, v);
+	return e.ease = t.ease, e.duration = n(t.duration), e.type = "keyframes", e;
+};
+//#endregion
+export { v as spring };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration-UXviOifF.js

@@ -0,0 +1,9 @@
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.js
+var e = 2e4;
+function t(e) {
+	let t = 0, n = e.next(t);
+	for (; !n.done && t < 2e4;) t += 50, n = e.next(t);
+	return t >= 2e4 ? Infinity : t;
+}
+//#endregion
+export { t as calcGeneratorDuration, e as maxGeneratorDuration };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing-DrH9ekbE.js

@@ -0,0 +1,16 @@
+import { millisecondsToSeconds as e } from "../../../../../../motion-utils/dist/es/time-conversion-DonUfQ-z.js";
+import { calcGeneratorDuration as t, maxGeneratorDuration as n } from "./calc-duration-UXviOifF.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.js
+function r(r, i = 100, a) {
+	let o = a({
+		...r,
+		keyframes: [0, i]
+	}), s = Math.min(t(o), n);
+	return {
+		type: "keyframes",
+		ease: (e) => o.next(s * e).value / i,
+		duration: e(s)
+	};
+}
+//#endregion
+export { r as createGeneratorEasing };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator-CYDWPPsC.js

@@ -0,0 +1,6 @@
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.js
+function e(e) {
+	return typeof e == "function" && "applyToOptions" in e;
+}
+//#endregion
+export { e as isGenerator };

package/dist/chunks/ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/velocity-Du7sddjq.js

@@ -0,0 +1,9 @@
+import { velocityPerSecond as e } from "../../../../../../motion-utils/dist/es/velocity-per-second-_sWOpbXy.js";
+//#region ../ui/dist/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.js
+var t = 5;
+function n(n, r, i) {
+	let a = Math.max(r - t, 0);
+	return e(i - n(a), r - a);
+}
+//#endregion
+export { n as getGeneratorVelocity };