@octane-xplat/motion 0.0.0 → 0.7.1

package/dist/native/index.js

@@ -0,0 +1,1747 @@
+import { createContext, defineUniversalComponent, hookSlots, universalChildren, universalComponent, universalContext, universalIf, universalPlan, universalProps, universalValue, useContext, useEffect, useLayoutEffect, useRef, useState, withSlot } from "@nativescript-community/octane";
+import { Pressable, Row, View } from "@octane-xplat/ui";
+import { Application, Utils } from "@nativescript/core";
+import { cancelAnimationFrame, requestAnimationFrame } from "@nativescript/core/animation-frame";
+//#region src/reduced-motion.ts
+function readReducedMotion() {
+	const platform = globalThis;
+	if (Application.ios) return Boolean(platform.UIAccessibilityIsReduceMotionEnabled?.());
+	const context = Utils.android.getApplicationContext();
+	return platform.android.provider.Settings.Global.getFloat(context.getContentResolver(), "animator_duration_scale", 1) === 0;
+}
+function observeReducedMotion(notify) {
+	let previous = readReducedMotion();
+	const check = () => {
+		const next = readReducedMotion();
+		if (next !== previous) {
+			previous = next;
+			notify();
+		}
+	};
+	const timer = setInterval(check, 500);
+	Application.on(Application.resumeEvent, check);
+	return () => {
+		clearInterval(timer);
+		Application.off(Application.resumeEvent, check);
+	};
+}
+//#endregion
+//#region src/config.tsrx
+var _hs$$3 = /* @__PURE__ */ hookSlots(2);
+var _h$0$3 = /* @__PURE__ */ Symbol(_hs$$3);
+var _h$1$3 = /* @__PURE__ */ Symbol(_hs$$3 + 1);
+var __octaneUniversalPlan0$2 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var ConfigContext = createContext({ reducedMotion: "never" });
+function useReducedMotion() {
+	const [reduced, setReduced] = useState(readReducedMotion, _h$0$3);
+	useEffect(() => {
+		const update = () => setReduced(readReducedMotion());
+		const off = observeReducedMotion(update);
+		update();
+		return off;
+	}, [], _h$1$3);
+	return reduced;
+}
+var MotionConfig = defineUniversalComponent("nativescript", function MotionConfig(props) {
+	const parent = useContext(ConfigContext);
+	const value = {
+		transition: props.transition ?? parent.transition,
+		reducedMotion: props.reducedMotion ?? parent.reducedMotion
+	};
+	return universalValue(__octaneUniversalPlan0$2, [((__octaneContextProps) => universalContext(ConfigContext, __octaneContextProps.value, props.children))({ "value": value })]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+//#region src/presence-state.ts
+var PresenceState = class {
+	present;
+	complete;
+	members = /* @__PURE__ */ new Set();
+	pending = /* @__PURE__ */ new Map();
+	sequence = 0;
+	generation = 0;
+	disposed = false;
+	removed = false;
+	constructor(present, complete) {
+		this.present = present;
+		this.complete = complete;
+	}
+	register(member) {
+		this.members.add(member);
+		if (!this.present) this.restart(member);
+		return () => {
+			this.members.delete(member);
+			this.pending.delete(member);
+			this.check();
+		};
+	}
+	setPresent(present) {
+		if (this.disposed || present === this.present) return;
+		this.present = present;
+		++this.generation;
+		this.removed = false;
+		this.pending.clear();
+		if (present) for (const member of this.members) member.enter();
+		else {
+			for (const member of this.members) this.restart(member);
+			this.check();
+		}
+	}
+	restart(member) {
+		if (this.disposed || this.present || !this.members.has(member)) return;
+		const token = ++this.sequence;
+		this.pending.set(member, token);
+		member.exit().then((result) => {
+			if (this.disposed || this.present || this.pending.get(member) !== token) return;
+			if (result !== "finished") return;
+			this.pending.delete(member);
+			this.check();
+		});
+	}
+	check() {
+		const generation = this.generation;
+		queueMicrotask(() => {
+			if (!this.disposed && !this.present && !this.removed && !this.pending.size && generation === this.generation) {
+				this.removed = true;
+				this.complete();
+			}
+		});
+	}
+	destroy() {
+		this.disposed = true;
+		++this.generation;
+		this.members.clear();
+		this.pending.clear();
+	}
+};
+//#endregion
+//#region src/presence-input.ts
+function blockInput(node) {
+	const enabled = node.isUserInteractionEnabled;
+	const iosHidden = node.ios?.accessibilityElementsHidden;
+	const androidImportance = node.android?.getImportantForAccessibility?.();
+	node.ios?.endEditing?.(true);
+	const focused = node.android?.findFocus?.();
+	if (focused) {
+		const platform = globalThis;
+		focused.getContext().getSystemService(platform.android.content.Context.INPUT_METHOD_SERVICE)?.hideSoftInputFromWindow(focused.getWindowToken(), 0);
+		focused.clearFocus();
+	}
+	node.isUserInteractionEnabled = false;
+	if (node.ios) node.ios.accessibilityElementsHidden = true;
+	node.android?.setImportantForAccessibility?.(4);
+	return () => {
+		node.isUserInteractionEnabled = enabled;
+		if (node.ios) node.ios.accessibilityElementsHidden = iosHidden;
+		if (androidImportance !== void 0) node.android?.setImportantForAccessibility?.(androidImportance);
+	};
+}
+//#endregion
+//#region src/presence.tsrx
+var _hs$$2 = /* @__PURE__ */ hookSlots(7);
+var _h$0$2 = /* @__PURE__ */ Symbol(_hs$$2);
+var _h$1$2 = /* @__PURE__ */ Symbol(_hs$$2 + 1);
+var _h$2$2 = /* @__PURE__ */ Symbol(_hs$$2 + 2);
+var _h$3$2 = /* @__PURE__ */ Symbol(_hs$$2 + 3);
+var _h$4$2 = /* @__PURE__ */ Symbol(_hs$$2 + 4);
+var _h$5$2 = /* @__PURE__ */ Symbol(_hs$$2 + 5);
+var _h$6$2 = /* @__PURE__ */ Symbol(_hs$$2 + 6);
+var __octaneUniversalPlan0$1 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan1$1 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan2$1 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var PresenceContext = createContext(null);
+var Presence = defineUniversalComponent("nativescript", function Presence(props) {
+	const [retained, setRetained] = useState(props.present, _h$0$2);
+	const latest = useRef(props, _h$1$2);
+	latest.current = props;
+	const ref = useRef(null, _h$2$2);
+	if (!ref.current) ref.current = new PresenceState(props.present, () => {
+		setRetained(false);
+		latest.current.onExitComplete?.();
+	});
+	const state = ref.current;
+	const host = useRef(null, _h$3$2);
+	const restoreInput = useRef(null, _h$4$2);
+	const syncInput = () => {
+		if (!props.present && host.current && !restoreInput.current) restoreInput.current = blockInput(host.current);
+		if (props.present && restoreInput.current) {
+			restoreInput.current();
+			restoreInput.current = null;
+		}
+	};
+	useLayoutEffect(() => {
+		if (props.present) setRetained(true);
+		syncInput();
+		state.setPresent(props.present);
+	}, [props.present], _h$5$2);
+	useLayoutEffect(() => () => {
+		state.destroy();
+		restoreInput.current?.();
+		restoreInput.current = null;
+		host.current = null;
+	}, [], _h$6$2);
+	const { present, onExitComplete, children, bind, ...viewProps } = props;
+	return universalValue(__octaneUniversalPlan2$1, [universalIf(props.present || retained, () => {
+		return universalValue(__octaneUniversalPlan1$1, [universalComponent("nativescript", View, universalProps([["spread", viewProps], [
+			"set",
+			"bind",
+			(node) => {
+				if (host.current !== node) {
+					restoreInput.current?.();
+					restoreInput.current = null;
+					host.current = node;
+				}
+				syncInput();
+				bind?.(node);
+			}
+		]], universalChildren("nativescript", () => {
+			return universalValue(__octaneUniversalPlan0$1, [((__octaneContextProps) => universalContext(PresenceContext, __octaneContextProps.value, children))({ "value": state })]);
+		})))]);
+	})]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+//#region src/clock.ts
+var clock = {
+	now: () => Date.now(),
+	request: requestAnimationFrame,
+	cancel: cancelAnimationFrame
+};
+//#endregion
+//#region src/host.ts
+function attachHost(node) {
+	const original = {
+		opacity: node.opacity ?? 1,
+		x: node.translateX ?? 0,
+		y: node.translateY ?? 0,
+		scaleX: node.scaleX ?? 1,
+		scaleY: node.scaleY ?? 1,
+		rotate: node.rotate ?? 0
+	};
+	if (original.x || original.y || original.rotate || original.scaleX !== 1 || original.scaleY !== 1) throw new Error("motion: put existing transforms on an outer container");
+	const write = (values) => {
+		if (values.opacity !== void 0) node.opacity = Math.min(1, Math.max(0, values.opacity));
+		if (values.x !== void 0) node.translateX = values.x;
+		if (values.y !== void 0) node.translateY = values.y;
+		if (values.rotate !== void 0) node.rotate = values.rotate;
+		if (values.scale !== void 0 || values.scaleX !== void 0) node.scaleX = (values.scale ?? 1) * (values.scaleX ?? 1);
+		if (values.scale !== void 0 || values.scaleY !== void 0) node.scaleY = (values.scale ?? 1) * (values.scaleY ?? 1);
+	};
+	return {
+		read: () => ({
+			...original,
+			scale: 1
+		}),
+		write,
+		restore: () => write(original)
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/clamp.mjs
+var clamp = (min, max, v) => {
+	if (v > max) return max;
+	if (v < min) return min;
+	return v;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/format-error-message.mjs
+function formatErrorMessage(message, errorCode) {
+	return errorCode ? `${message}. For more information and steps for solving, visit https://motion.dev/troubleshooting/${errorCode}` : message;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/errors.mjs
+var warning = () => {};
+var invariant = () => {};
+if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+	warning = (check, message, errorCode) => {
+		if (!check && typeof console !== "undefined") console.warn(formatErrorMessage(message, errorCode));
+	};
+	invariant = (check, message, errorCode) => {
+		if (!check) throw new Error(formatErrorMessage(message, errorCode));
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/global-config.mjs
+var MotionGlobalConfig = {};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/noop.mjs
+var noop = /* @__NO_SIDE_EFFECTS__ */ (any) => any;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/pipe.mjs
+/**
+* Pipe
+* Compose other transformers to run linearily
+* pipe(min(20), max(40))
+* @param  {...functions} transformers
+* @return {function}
+*/
+var pipe = (...transformers) => transformers.reduce((a, b) => (v) => b(a(v)));
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/progress.mjs
+var progress = /* @__NO_SIDE_EFFECTS__ */ (from, to, value) => {
+	const range = to - from;
+	return range ? (value - from) / range : 1;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.mjs
+/**
+* Converts seconds to milliseconds
+*
+* @param seconds - Time in seconds.
+* @return milliseconds - Converted time in milliseconds.
+*/
+var secondsToMilliseconds = /* @__NO_SIDE_EFFECTS__ */ (seconds) => seconds * 1e3;
+var millisecondsToSeconds = /* @__NO_SIDE_EFFECTS__ */ (milliseconds) => milliseconds / 1e3;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/cubic-bezier.mjs
+var calcBezier = (t, a1, a2) => (((1 - 3 * a2 + 3 * a1) * t + (3 * a2 - 6 * a1)) * t + 3 * a1) * t;
+var subdivisionPrecision = 1e-7;
+var subdivisionMaxIterations = 12;
+function binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {
+	let currentX;
+	let currentT;
+	let i = 0;
+	do {
+		currentT = lowerBound + (upperBound - lowerBound) / 2;
+		currentX = calcBezier(currentT, mX1, mX2) - x;
+		if (currentX > 0) upperBound = currentT;
+		else lowerBound = currentT;
+	} while (Math.abs(currentX) > subdivisionPrecision && ++i < subdivisionMaxIterations);
+	return currentT;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function cubicBezier(mX1, mY1, mX2, mY2) {
+	if (mX1 === mY1 && mX2 === mY2) return noop;
+	const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);
+	return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/modifiers/mirror.mjs
+var mirrorEasing = /* @__NO_SIDE_EFFECTS__ */ (easing) => (p) => p <= .5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/modifiers/reverse.mjs
+var reverseEasing = /* @__NO_SIDE_EFFECTS__ */ (easing) => (p) => 1 - easing(1 - p);
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/back.mjs
+var backOut = /*@__PURE__*/ cubicBezier(.33, 1.53, .69, .99);
+var backIn = /*@__PURE__*/ reverseEasing(backOut);
+var backInOut = /*@__PURE__*/ mirrorEasing(backIn);
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/anticipate.mjs
+var anticipate = (p) => p >= 1 ? 1 : (p *= 2) < 1 ? .5 * backIn(p) : .5 * (2 - Math.pow(2, -10 * (p - 1)));
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/circ.mjs
+var circIn = (p) => 1 - Math.sin(Math.acos(p));
+var circOut = /* @__PURE__ */ reverseEasing(circIn);
+var circInOut = /* @__PURE__ */ mirrorEasing(circIn);
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/ease.mjs
+var easeIn = /*@__PURE__*/ cubicBezier(.42, 0, 1, 1);
+var easeOut = /*@__PURE__*/ cubicBezier(0, 0, .58, 1);
+var easeInOut = /*@__PURE__*/ cubicBezier(.42, 0, .58, 1);
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/is-easing-array.mjs
+var isEasingArray = /* @__NO_SIDE_EFFECTS__ */ (ease) => {
+	return Array.isArray(ease) && typeof ease[0] !== "number";
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/is-bezier-definition.mjs
+var isBezierDefinition = /* @__NO_SIDE_EFFECTS__ */ (easing) => Array.isArray(easing) && typeof easing[0] === "number";
+//#endregion
+//#region ../../node_modules/.pnpm/motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/map.mjs
+var easingLookup = {
+	linear: noop,
+	easeIn,
+	easeInOut,
+	easeOut,
+	circIn,
+	circInOut,
+	circOut,
+	backIn,
+	backInOut,
+	backOut,
+	anticipate
+};
+var isValidEasing = (easing) => {
+	return typeof easing === "string";
+};
+var easingDefinitionToFunction = (definition) => {
+	if (/* @__PURE__ */ isBezierDefinition(definition)) {
+		invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`, "cubic-bezier-length");
+		const [x1, y1, x2, y2] = definition;
+		return /* @__PURE__ */ cubicBezier(x1, y1, x2, y2);
+	} else if (isValidEasing(definition)) {
+		invariant(easingLookup[definition] !== void 0, `Invalid easing type '${definition}'`, "invalid-easing-type");
+		return easingLookup[definition];
+	}
+	return definition;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/utils/is-css-variable.mjs
+var checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
+var startsAsVariableToken = /*@__PURE__*/ checkStringStartsWith("var(--");
+var isCSSVariableToken = (value) => {
+	if (!startsAsVariableToken(value)) return false;
+	return singleCssVariableRegex.test(value.split("/*")[0].trim());
+};
+var singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/numbers/index.mjs
+var number = {
+	test: (v) => typeof v === "number",
+	parse: parseFloat,
+	transform: (v) => v
+};
+var alpha = {
+	...number,
+	transform: (v) => clamp(0, 1, v)
+};
+({ ...number });
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/utils/sanitize.mjs
+var sanitize = (v) => Math.round(v * 1e5) / 1e5;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/utils/float-regex.mjs
+var floatRegex = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/utils/is-nullish.mjs
+function isNullish(v) {
+	return v == null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/utils/single-color-regex.mjs
+var singleColorRegex = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/color/utils.mjs
+/**
+* Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,
+* but false if a number or multiple colors
+*/
+var isColorString = (type, testProp) => (v) => {
+	return Boolean(typeof v === "string" && singleColorRegex.test(v) && v.startsWith(type) || testProp && !isNullish(v) && Object.prototype.hasOwnProperty.call(v, testProp));
+};
+var splitColor = (aName, bName, cName) => (v) => {
+	if (typeof v !== "string") return v;
+	const [a, b, c, alpha] = v.match(floatRegex);
+	return {
+		[aName]: parseFloat(a),
+		[bName]: parseFloat(b),
+		[cName]: parseFloat(c),
+		alpha: alpha !== void 0 ? parseFloat(alpha) : 1
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/color/rgba.mjs
+var clampRgbUnit = (v) => clamp(0, 255, v);
+var rgbUnit = {
+	...number,
+	transform: (v) => Math.round(clampRgbUnit(v))
+};
+var rgba = {
+	test: /*@__PURE__*/ isColorString("rgb", "red"),
+	parse: /*@__PURE__*/ splitColor("red", "green", "blue"),
+	transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => "rgba(" + rgbUnit.transform(red) + ", " + rgbUnit.transform(green) + ", " + rgbUnit.transform(blue) + ", " + sanitize(alpha.transform(alpha$1)) + ")"
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/color/hex.mjs
+function parseHex(v) {
+	let r = "";
+	let g = "";
+	let b = "";
+	let a = "";
+	if (v.length > 5) {
+		r = v.substring(1, 3);
+		g = v.substring(3, 5);
+		b = v.substring(5, 7);
+		a = v.substring(7, 9);
+	} else {
+		r = v.substring(1, 2);
+		g = v.substring(2, 3);
+		b = v.substring(3, 4);
+		a = v.substring(4, 5);
+		r += r;
+		g += g;
+		b += b;
+		a += a;
+	}
+	return {
+		red: parseInt(r, 16),
+		green: parseInt(g, 16),
+		blue: parseInt(b, 16),
+		alpha: a ? parseInt(a, 16) / 255 : 1
+	};
+}
+var hex = {
+	test: /*@__PURE__*/ isColorString("#"),
+	parse: parseHex,
+	transform: rgba.transform
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/numbers/units.mjs
+var createUnitType = /* @__NO_SIDE_EFFECTS__ */ (unit) => ({
+	test: (v) => typeof v === "string" && v.endsWith(unit) && v.split(" ").length === 1,
+	parse: parseFloat,
+	transform: (v) => `${v}${unit}`
+});
+var percent = /*@__PURE__*/ createUnitType("%");
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/color/hsla.mjs
+var hsla = {
+	test: /*@__PURE__*/ isColorString("hsl", "hue"),
+	parse: /*@__PURE__*/ splitColor("hue", "saturation", "lightness"),
+	transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {
+		return "hsla(" + Math.round(hue) + ", " + percent.transform(sanitize(saturation)) + ", " + percent.transform(sanitize(lightness)) + ", " + sanitize(alpha.transform(alpha$1)) + ")";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/color/index.mjs
+var color = {
+	test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),
+	parse: (v) => {
+		if (rgba.test(v)) return rgba.parse(v);
+		else if (hsla.test(v)) return hsla.parse(v);
+		else return hex.parse(v);
+	},
+	transform: (v) => {
+		return typeof v === "string" ? v : v.hasOwnProperty("red") ? rgba.transform(v) : hsla.transform(v);
+	},
+	getAnimatableNone: (v) => {
+		const parsed = color.parse(v);
+		parsed.alpha = 0;
+		return color.transform(parsed);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/utils/color-regex.mjs
+var colorRegex = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/complex/index.mjs
+function test(v) {
+	return isNaN(v) && typeof v === "string" && (v.match(floatRegex)?.length || 0) + (v.match(colorRegex)?.length || 0) > 0;
+}
+var NUMBER_TOKEN = "number";
+var COLOR_TOKEN = "color";
+var VAR_TOKEN = "var";
+var VAR_FUNCTION_TOKEN = "var(";
+var SPLIT_TOKEN = "${}";
+var complexRegex = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function analyseComplexValue(value) {
+	const originalValue = value.toString();
+	const values = [];
+	const indexes = {
+		color: [],
+		number: [],
+		var: []
+	};
+	const types = [];
+	let i = 0;
+	return {
+		values,
+		split: originalValue.replace(complexRegex, (parsedValue) => {
+			if (color.test(parsedValue)) {
+				indexes.color.push(i);
+				types.push(COLOR_TOKEN);
+				values.push(color.parse(parsedValue));
+			} else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
+				indexes.var.push(i);
+				types.push(VAR_TOKEN);
+				values.push(parsedValue);
+			} else {
+				indexes.number.push(i);
+				types.push(NUMBER_TOKEN);
+				values.push(parseFloat(parsedValue));
+			}
+			++i;
+			return SPLIT_TOKEN;
+		}).split(SPLIT_TOKEN),
+		indexes,
+		types
+	};
+}
+function parseComplexValue(v) {
+	return analyseComplexValue(v).values;
+}
+function buildTransformer({ split, types }) {
+	const numSections = split.length;
+	return (v) => {
+		let output = "";
+		for (let i = 0; i < numSections; i++) {
+			output += split[i];
+			if (v[i] !== void 0) {
+				const type = types[i];
+				if (type === NUMBER_TOKEN) output += sanitize(v[i]);
+				else if (type === COLOR_TOKEN) output += color.transform(v[i]);
+				else output += v[i];
+			}
+		}
+		return output;
+	};
+}
+function createTransformer(source) {
+	return buildTransformer(analyseComplexValue(source));
+}
+var convertNumbersToZero = (v) => typeof v === "number" ? 0 : color.test(v) ? color.getAnimatableNone(v) : v;
+/**
+* Convert a parsed value to its zero equivalent, but preserve numbers
+* that act as divisors in CSS calc() expressions.
+*
+* analyseComplexValue extracts numbers from CSS strings and puts the
+* surrounding text into a `split` template array. For example:
+*   "calc(var(--gap) / 5)"  →  values: [var(--gap), 5]
+*                               split:  ["calc(", " / ", ")"]
+*
+* When building a zero-equivalent for animation, naively zeroing all
+* numbers turns the divisor into 0 → "calc(var(--gap) / 0)" → NaN.
+* We detect this by checking whether the text preceding a number
+* (split[i]) ends with "/" — the CSS calc division operator.
+*/
+var convertToZero = (value, splitBefore) => {
+	if (typeof value === "number") return splitBefore?.trim().endsWith("/") ? value : 0;
+	return convertNumbersToZero(value);
+};
+function getAnimatableNone(v) {
+	const info = analyseComplexValue(v);
+	return buildTransformer(info)(info.values.map((value, i) => convertToZero(value, info.split[i])));
+}
+var complex = {
+	test,
+	parse: parseComplexValue,
+	createTransformer,
+	getAnimatableNone
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/value/types/color/hsla-to-rgba.mjs
+function hueToRgb(p, q, t) {
+	if (t < 0) t += 1;
+	if (t > 1) t -= 1;
+	if (t < 1 / 6) return p + (q - p) * 6 * t;
+	if (t < 1 / 2) return q;
+	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+	return p;
+}
+function hslaToRgba({ hue, saturation, lightness, alpha }) {
+	hue /= 360;
+	saturation /= 100;
+	lightness /= 100;
+	let red = 0;
+	let green = 0;
+	let blue = 0;
+	if (!saturation) red = green = blue = lightness;
+	else {
+		const q = lightness < .5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
+		const p = 2 * lightness - q;
+		red = hueToRgb(p, q, hue + 1 / 3);
+		green = hueToRgb(p, q, hue);
+		blue = hueToRgb(p, q, hue - 1 / 3);
+	}
+	return {
+		red: Math.round(red * 255),
+		green: Math.round(green * 255),
+		blue: Math.round(blue * 255),
+		alpha
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/utils/mix/immediate.mjs
+function mixImmediate(a, b) {
+	return (p) => p > 0 ? b : a;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/utils/mix/number.mjs
+var mixNumber$1 = (from, to, progress) => {
+	return from + (to - from) * progress;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/utils/mix/color.mjs
+var mixLinearColor = (from, to, v) => {
+	const fromExpo = from * from;
+	const expo = v * (to * to - fromExpo) + fromExpo;
+	return expo < 0 ? 0 : Math.sqrt(expo);
+};
+var colorTypes = [
+	hex,
+	rgba,
+	hsla
+];
+var getColorType = (v) => colorTypes.find((type) => type.test(v));
+function asRGBA(color) {
+	const type = getColorType(color);
+	warning(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable");
+	if (!Boolean(type)) return false;
+	let model = type.parse(color);
+	if (type === hsla) model = hslaToRgba(model);
+	return model;
+}
+var mixColor = (from, to) => {
+	const fromRGBA = asRGBA(from);
+	const toRGBA = asRGBA(to);
+	if (!fromRGBA || !toRGBA) return mixImmediate(from, to);
+	const blended = { ...fromRGBA };
+	return (v) => {
+		blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);
+		blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);
+		blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);
+		blended.alpha = mixNumber$1(fromRGBA.alpha, toRGBA.alpha, v);
+		return rgba.transform(blended);
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/utils/mix/visibility.mjs
+var invisibleValues = /* @__PURE__ */ new Set(["none", "hidden"]);
+/**
+* Returns a function that, when provided a progress value between 0 and 1,
+* will return the "none" or "hidden" string only when the progress is that of
+* the origin or target.
+*/
+function mixVisibility(origin, target) {
+	if (invisibleValues.has(origin)) return (p) => p <= 0 ? origin : target;
+	else return (p) => p >= 1 ? target : origin;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/utils/mix/complex.mjs
+function mixNumber(a, b) {
+	return (p) => mixNumber$1(a, b, p);
+}
+function getMixer(a) {
+	if (typeof a === "number") return mixNumber;
+	else if (typeof a === "string") return isCSSVariableToken(a) ? mixImmediate : color.test(a) ? mixColor : mixComplex;
+	else if (Array.isArray(a)) return mixArray;
+	else if (typeof a === "object") return color.test(a) ? mixColor : mixObject;
+	return mixImmediate;
+}
+function mixArray(a, b) {
+	const output = [...a];
+	const numValues = output.length;
+	const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));
+	return (p) => {
+		for (let i = 0; i < numValues; i++) output[i] = blendValue[i](p);
+		return output;
+	};
+}
+function mixObject(a, b) {
+	const output = {
+		...a,
+		...b
+	};
+	const blendValue = {};
+	for (const key in output) if (a[key] !== void 0 && b[key] !== void 0) blendValue[key] = getMixer(a[key])(a[key], b[key]);
+	return (v) => {
+		for (const key in blendValue) output[key] = blendValue[key](v);
+		return output;
+	};
+}
+function matchOrder(origin, target) {
+	const orderedOrigin = [];
+	const pointers = {
+		color: 0,
+		var: 0,
+		number: 0
+	};
+	for (let i = 0; i < target.values.length; i++) {
+		const type = target.types[i];
+		const originIndex = origin.indexes[type][pointers[type]];
+		const originValue = origin.values[originIndex] ?? 0;
+		orderedOrigin[i] = originValue;
+		pointers[type]++;
+	}
+	return orderedOrigin;
+}
+var mixComplex = (origin, target) => {
+	const template = complex.createTransformer(target);
+	const originStats = analyseComplexValue(origin);
+	const targetStats = analyseComplexValue(target);
+	if (originStats.indexes.var.length === targetStats.indexes.var.length && originStats.indexes.color.length === targetStats.indexes.color.length && originStats.indexes.number.length >= targetStats.indexes.number.length) {
+		if (invisibleValues.has(origin) && !targetStats.values.length || invisibleValues.has(target) && !originStats.values.length) return mixVisibility(origin, target);
+		return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);
+	} else {
+		warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different");
+		return mixImmediate(origin, target);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/utils/mix/index.mjs
+function mix(from, to, p) {
+	if (typeof from === "number" && typeof to === "number" && typeof p === "number") return mixNumber$1(from, to, p);
+	return getMixer(from)(from, to);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/waapi/utils/linear.mjs
+var generateLinearEasing = (easing, duration, resolution = 10) => {
+	let points = "";
+	const numPoints = Math.max(Math.round(duration / resolution), 2);
+	for (let i = 0; i < numPoints; i++) points += Math.round(easing(i / (numPoints - 1)) * 1e4) / 1e4 + ", ";
+	return `linear(${points.substring(0, points.length - 2)})`;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs
+/**
+* Implement a practical max duration for keyframe generation
+* to prevent infinite loops
+*/
+var maxGeneratorDuration = 2e4;
+function calcGeneratorDuration(generator) {
+	let duration = 0;
+	const timeStep = 50;
+	let state = generator.next(duration);
+	while (!state.done && duration < 2e4) {
+		duration += timeStep;
+		state = generator.next(duration);
+	}
+	return duration >= 2e4 ? Infinity : duration;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs
+/**
+* Create a progress => progress easing function from a generator.
+*/
+function createGeneratorEasing(options, scale = 100, createGenerator) {
+	const generator = createGenerator({
+		...options,
+		keyframes: [0, scale]
+	});
+	const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+	return {
+		type: "keyframes",
+		ease: (progress) => {
+			return generator.next(duration * progress).value / scale;
+		},
+		duration: /* @__PURE__ */ millisecondsToSeconds(duration)
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/spring.mjs
+var springDefaults = {
+	stiffness: 100,
+	damping: 10,
+	mass: 1,
+	velocity: 0,
+	duration: 800,
+	bounce: .3,
+	visualDuration: .3,
+	restSpeed: {
+		granular: .01,
+		default: 2
+	},
+	restDelta: {
+		granular: .005,
+		default: .5
+	},
+	minDuration: .01,
+	maxDuration: 10,
+	minDamping: .05,
+	maxDamping: 1
+};
+function calcAngularFreq(undampedFreq, dampingRatio) {
+	return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
+}
+var rootIterations = 12;
+function approximateRoot(envelope, derivative, initialGuess) {
+	let result = initialGuess;
+	for (let i = 1; i < rootIterations; i++) result = result - envelope(result) / derivative(result);
+	return result;
+}
+/**
+* This is ported from the Framer implementation of duration-based spring resolution.
+*/
+var safeMin = .001;
+function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
+	let envelope;
+	let derivative;
+	warning(duration <= /* @__PURE__ */ secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+	let dampingRatio = 1 - bounce;
+	/**
+	* Restrict dampingRatio and duration to within acceptable ranges.
+	*/
+	dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
+	duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, /* @__PURE__ */ millisecondsToSeconds(duration));
+	if (dampingRatio < 1) {
+		/**
+		* Underdamped spring
+		*/
+		envelope = (undampedFreq) => {
+			const exponentialDecay = undampedFreq * dampingRatio;
+			const delta = exponentialDecay * duration;
+			const a = exponentialDecay - velocity;
+			const b = calcAngularFreq(undampedFreq, dampingRatio);
+			const c = Math.exp(-delta);
+			return safeMin - a / b * c;
+		};
+		derivative = (undampedFreq) => {
+			const delta = undampedFreq * dampingRatio * duration;
+			const d = delta * velocity + velocity;
+			const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;
+			const f = Math.exp(-delta);
+			const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);
+			return (-envelope(undampedFreq) + safeMin > 0 ? -1 : 1) * ((d - e) * f) / g;
+		};
+	} else {
+		/**
+		* Critically-damped spring
+		*/
+		envelope = (undampedFreq) => {
+			return -.001 + Math.exp(-undampedFreq * duration) * ((undampedFreq - velocity) * duration + 1);
+		};
+		derivative = (undampedFreq) => {
+			return Math.exp(-undampedFreq * duration) * ((velocity - undampedFreq) * (duration * duration));
+		};
+	}
+	const initialGuess = 5 / duration;
+	const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
+	duration = /* @__PURE__ */ secondsToMilliseconds(duration);
+	if (isNaN(undampedFreq)) return {
+		stiffness: springDefaults.stiffness,
+		damping: springDefaults.damping,
+		duration
+	};
+	else {
+		const stiffness = Math.pow(undampedFreq, 2) * mass;
+		return {
+			stiffness,
+			damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
+			duration
+		};
+	}
+}
+var durationKeys = ["duration", "bounce"];
+var physicsKeys = [
+	"stiffness",
+	"damping",
+	"mass"
+];
+function isSpringType(options, keys) {
+	return keys.some((key) => options[key] !== void 0);
+}
+function getSpringOptions(options) {
+	let springOptions = {
+		velocity: springDefaults.velocity,
+		stiffness: springDefaults.stiffness,
+		damping: springDefaults.damping,
+		mass: springDefaults.mass,
+		isResolvedFromDuration: false,
+		...options
+	};
+	if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {
+		springOptions.velocity = 0;
+		if (options.visualDuration) {
+			const visualDuration = options.visualDuration;
+			const root = 2 * Math.PI / (visualDuration * 1.2);
+			const stiffness = root * root;
+			const damping = 2 * clamp(.05, 1, 1 - (options.bounce || 0)) * Math.sqrt(stiffness);
+			springOptions = {
+				...springOptions,
+				mass: springDefaults.mass,
+				stiffness,
+				damping
+			};
+		} else {
+			const derived = findSpring({
+				...options,
+				velocity: 0
+			});
+			springOptions = {
+				...springOptions,
+				...derived,
+				mass: springDefaults.mass
+			};
+			springOptions.isResolvedFromDuration = true;
+		}
+	}
+	return springOptions;
+}
+function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
+	const options = typeof optionsOrVisualDuration !== "object" ? {
+		visualDuration: optionsOrVisualDuration,
+		keyframes: [0, 1],
+		bounce
+	} : optionsOrVisualDuration;
+	let { restSpeed, restDelta } = options;
+	const origin = options.keyframes[0];
+	const target = options.keyframes[options.keyframes.length - 1];
+	/**
+	* This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
+	* to reduce GC during animation.
+	*/
+	const state = {
+		done: false,
+		value: origin
+	};
+	const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
+		...options,
+		velocity: -/* @__PURE__ */ millisecondsToSeconds(options.velocity || 0)
+	});
+	const initialVelocity = velocity || 0;
+	const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+	const initialDelta = target - origin;
+	const undampedAngularFreq = /* @__PURE__ */ millisecondsToSeconds(Math.sqrt(stiffness / mass));
+	/**
+	* If we're working on a granular scale, use smaller defaults for determining
+	* when the spring is finished.
+	*
+	* These defaults have been selected emprically based on what strikes a good
+	* ratio between feeling good and finishing as soon as changes are imperceptible.
+	*/
+	const isGranularScale = Math.abs(initialDelta) < 5;
+	restSpeed || (restSpeed = isGranularScale ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default);
+	restDelta || (restDelta = isGranularScale ? springDefaults.restDelta.granular : springDefaults.restDelta.default);
+	let resolveSpring;
+	let resolveVelocity;
+	let angularFreq;
+	let A;
+	let sinCoeff;
+	let cosCoeff;
+	if (dampingRatio < 1) {
+		angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
+		A = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq;
+		resolveSpring = (t) => {
+			const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+			return target - envelope * (A * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));
+		};
+		sinCoeff = dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;
+		cosCoeff = dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;
+		resolveVelocity = (t) => {
+			return Math.exp(-dampingRatio * undampedAngularFreq * t) * (sinCoeff * Math.sin(angularFreq * t) + cosCoeff * Math.cos(angularFreq * t));
+		};
+	} else if (dampingRatio === 1) {
+		resolveSpring = (t) => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);
+		const C = initialVelocity + undampedAngularFreq * initialDelta;
+		resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) * (undampedAngularFreq * C * t - initialVelocity);
+	} else {
+		const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
+		resolveSpring = (t) => {
+			const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+			const freqForT = Math.min(dampedAngularFreq * t, 300);
+			return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
+		};
+		const P = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / dampedAngularFreq;
+		const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;
+		const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;
+		resolveVelocity = (t) => {
+			const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+			const freqForT = Math.min(dampedAngularFreq * t, 300);
+			return envelope * (sinhCoeff * Math.sinh(freqForT) + coshCoeff * Math.cosh(freqForT));
+		};
+	}
+	const generator = {
+		calculatedDuration: isResolvedFromDuration ? duration || null : null,
+		velocity: (t) => /* @__PURE__ */ secondsToMilliseconds(resolveVelocity(t)),
+		next: (t) => {
+			/**
+			* For underdamped physics springs we need both position and
+			* velocity each tick. Compute shared trig values once to avoid
+			* duplicate Math.exp/sin/cos calls on the hot path.
+			*/
+			if (!isResolvedFromDuration && dampingRatio < 1) {
+				const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+				const sin = Math.sin(angularFreq * t);
+				const cos = Math.cos(angularFreq * t);
+				const current = target - envelope * (A * sin + initialDelta * cos);
+				const currentVelocity = /* @__PURE__ */ secondsToMilliseconds(envelope * (sinCoeff * sin + cosCoeff * cos));
+				state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current) <= restDelta;
+				state.value = state.done ? target : current;
+				return state;
+			}
+			const current = resolveSpring(t);
+			if (!isResolvedFromDuration) {
+				const currentVelocity = /* @__PURE__ */ secondsToMilliseconds(resolveVelocity(t));
+				state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current) <= restDelta;
+			} else state.done = t >= duration;
+			state.value = state.done ? target : current;
+			return state;
+		},
+		toString: () => {
+			const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+			const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);
+			return calculatedDuration + "ms " + easing;
+		},
+		toTransition: () => {}
+	};
+	return generator;
+}
+spring.applyToOptions = (options) => {
+	const generatorOptions = createGeneratorEasing(options, 100, spring);
+	options.ease = generatorOptions.ease;
+	options.duration = /* @__PURE__ */ secondsToMilliseconds(generatorOptions.duration);
+	options.type = "keyframes";
+	return options;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/utils/interpolate.mjs
+function createMixers(output, ease, customMixer) {
+	const mixers = [];
+	const mixerFactory = customMixer || MotionGlobalConfig.mix || mix;
+	const numMixers = output.length - 1;
+	for (let i = 0; i < numMixers; i++) {
+		let mixer = mixerFactory(output[i], output[i + 1]);
+		if (ease) mixer = pipe(Array.isArray(ease) ? ease[i] || noop : ease, mixer);
+		mixers.push(mixer);
+	}
+	return mixers;
+}
+/**
+* Create a function that maps from a numerical input array to a generic output array.
+*
+* Accepts:
+*   - Numbers
+*   - Colors (hex, hsl, hsla, rgb, rgba)
+*   - Complex (combinations of one or more numbers or strings)
+*
+* ```jsx
+* const mixColor = interpolate([0, 1], ['#fff', '#000'])
+*
+* mixColor(0.5) // 'rgba(128, 128, 128, 1)'
+* ```
+*
+* TODO Revisit this approach once we've moved to data models for values,
+* probably not needed to pregenerate mixer functions.
+*
+* @public
+*/
+function interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {
+	const inputLength = input.length;
+	invariant(inputLength === output.length, "Both input and output ranges must be the same length", "range-length");
+	/**
+	* If we're only provided a single input, we can just make a function
+	* that returns the output.
+	*/
+	if (inputLength === 1) return () => output[0];
+	if (inputLength === 2 && output[0] === output[1]) return () => output[1];
+	const isZeroDeltaRange = input[0] === input[1];
+	if (input[0] > input[inputLength - 1]) {
+		input = [...input].reverse();
+		output = [...output].reverse();
+	}
+	const mixers = createMixers(output, ease, mixer);
+	const numMixers = mixers.length;
+	const interpolator = (v) => {
+		if (isZeroDeltaRange && v < input[0]) return output[0];
+		let i = 0;
+		if (numMixers > 1) {
+			for (; i < input.length - 2; i++) if (v < input[i + 1]) break;
+		}
+		const progressInRange = /* @__PURE__ */ progress(input[i], input[i + 1], v);
+		return mixers[i](progressInRange);
+	};
+	return isClamp ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v)) : interpolator;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.mjs
+function fillOffset(offset, remaining) {
+	const min = offset[offset.length - 1];
+	for (let i = 1; i <= remaining; i++) {
+		const offsetProgress = /* @__PURE__ */ progress(0, remaining, i);
+		offset.push(mixNumber$1(min, 1, offsetProgress));
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.mjs
+function defaultOffset(arr) {
+	const offset = [0];
+	fillOffset(offset, arr.length - 1);
+	return offset;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.mjs
+function convertOffsetToTimes(offset, duration) {
+	return offset.map((o) => o * duration);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs
+function defaultEasing(values, easing) {
+	return values.map(() => easing || easeInOut).splice(0, values.length - 1);
+}
+function keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut" }) {
+	/**
+	* Easing functions can be externally defined as strings. Here we convert them
+	* into actual functions.
+	*/
+	const easingFunctions = /* @__PURE__ */ isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);
+	/**
+	* This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
+	* to reduce GC during animation.
+	*/
+	const state = {
+		done: false,
+		value: keyframeValues[0]
+	};
+	const mapTimeToKeyframe = interpolate(convertOffsetToTimes(times && times.length === keyframeValues.length ? times : defaultOffset(keyframeValues), duration), keyframeValues, { ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions) });
+	return {
+		calculatedDuration: duration,
+		next: (t) => {
+			state.value = mapTimeToKeyframe(t);
+			state.done = t >= duration;
+			return state;
+		}
+	};
+}
+//#endregion
+//#region src/engine.ts
+function validateTransition(t) {
+	if (t.type === "spring" && (t.duration !== void 0 || t.ease !== void 0)) throw new Error("motion: physical springs do not accept duration or ease");
+	const allowed = [
+		"type",
+		"duration",
+		"delay",
+		"ease",
+		"stiffness",
+		"damping",
+		"mass",
+		"velocity",
+		"restSpeed",
+		"restDelta"
+	];
+	for (const key of Object.keys(t)) if (!allowed.includes(key)) throw new Error(`motion: unsupported transition ${key}`);
+	if (t.type !== void 0 && t.type !== "tween" && t.type !== "spring") throw new Error("motion: unsupported transition type");
+	for (const key of [
+		"duration",
+		"delay",
+		"stiffness",
+		"damping",
+		"mass",
+		"velocity",
+		"restSpeed",
+		"restDelta"
+	]) {
+		const value = t[key];
+		if (value !== void 0 && (!Number.isFinite(value) || key !== "velocity" && value < 0)) throw new Error(`motion: invalid ${key}`);
+	}
+	for (const key of [
+		"mass",
+		"stiffness",
+		"damping",
+		"restSpeed",
+		"restDelta"
+	]) if (t[key] === 0) throw new Error(`motion: ${key} must be positive`);
+	if (t.ease !== void 0) {
+		if (Array.isArray(t.ease)) {
+			if (t.ease.length !== 4 || !t.ease.every(Number.isFinite) || t.ease[0] < 0 || t.ease[0] > 1 || t.ease[2] < 0 || t.ease[2] > 1) throw new Error("motion: invalid cubic Bezier");
+		} else if (![
+			"linear",
+			"easeIn",
+			"easeOut",
+			"easeInOut"
+		].includes(t.ease)) throw new Error("motion: unsupported easing");
+	}
+}
+function runAnimation(clock, from, to, transition, update, complete) {
+	validateTransition(transition);
+	let frame = 0;
+	let settled = false;
+	let resolve;
+	const finished = new Promise((done) => {
+		resolve = done;
+	});
+	const settle = (result) => {
+		if (settled) return;
+		settled = true;
+		clock.cancel(frame);
+		resolve(result);
+		if (result === "finished") complete?.();
+	};
+	const duration = transition.duration ?? .3;
+	const generator = transition.type === "spring" ? spring({
+		keyframes: [from, to],
+		stiffness: transition.stiffness ?? 100,
+		damping: transition.damping ?? 10,
+		mass: transition.mass ?? 1,
+		velocity: transition.velocity ?? 0,
+		restSpeed: transition.restSpeed,
+		restDelta: transition.restDelta
+	}) : keyframes({
+		keyframes: [from, to],
+		duration: duration * 1e3,
+		ease: transition.ease ?? "easeInOut"
+	});
+	const start = clock.now() + (transition.delay ?? 0) * 1e3;
+	const tick = () => {
+		if (settled) return;
+		const elapsed = Math.max(0, clock.now() - start);
+		if (clock.now() >= start) {
+			const state = generator.next(elapsed);
+			update(state.done ? to : state.value);
+			if (state.done) {
+				settle("finished");
+				return;
+			}
+		}
+		if (!settled) frame = clock.request(tick);
+	};
+	if (transition.type !== "spring" && duration === 0 && !transition.delay) {
+		update(to);
+		settle("finished");
+	} else frame = clock.request(tick);
+	return {
+		finished,
+		stop: (reason = "cancelled") => settle(reason)
+	};
+}
+//#endregion
+//#region src/value.ts
+/** Numeric value with direct subscriptions; it does not subscribe Octane renders. */
+var MotionValue = class {
+	clock;
+	current;
+	previous;
+	velocity = 0;
+	updated;
+	controls;
+	generation = 0;
+	listeners = /* @__PURE__ */ new Map();
+	passive;
+	disposed = false;
+	constructor(initial, clock) {
+		this.clock = clock;
+		this.assert(initial);
+		this.current = this.previous = initial;
+		this.updated = clock.now();
+	}
+	assert(value) {
+		if (!Number.isFinite(value)) throw new Error("motion: values must be finite numbers");
+	}
+	/** Read the current sample. */
+	get() {
+		return this.current;
+	}
+	/** Read the previous sample. */
+	getPrevious() {
+		return this.previous;
+	}
+	/** Velocity in units per second; stale samples have zero velocity. */
+	getVelocity() {
+		return this.clock.now() - this.updated > 30 ? 0 : this.velocity;
+	}
+	/** Set immediately, or animate when this is a useSpring value. */
+	set(value) {
+		this.assert(value);
+		if (this.disposed) return;
+		if (this.passive) this.passive(value);
+		else {
+			this.stop();
+			this.write(value);
+		}
+	}
+	/** Snap and stop current playback, resetting velocity. */
+	jump(value) {
+		this.assert(value);
+		this.stop();
+		this.write(value);
+		this.velocity = 0;
+	}
+	/** Subscribe without causing a component render. Returns an unsubscribe function. */
+	on(event, callback) {
+		let listeners = this.listeners.get(event);
+		if (!listeners) this.listeners.set(event, listeners = /* @__PURE__ */ new Set());
+		listeners.add(callback);
+		return () => {
+			listeners.delete(callback);
+		};
+	}
+	emit(event, value) {
+		for (const callback of [...this.listeners.get(event) ?? []]) callback(value);
+	}
+	write(value) {
+		if (this.disposed) return;
+		const now = this.clock.now();
+		const elapsed = now - this.updated;
+		if (elapsed > 0) this.velocity = elapsed > 30 ? 0 : (value - this.current) * 1e3 / elapsed;
+		this.previous = this.current;
+		this.current = value;
+		this.updated = now;
+		if (value !== this.previous) this.emit("change", value);
+	}
+	/** Animate to a destination. New playback replaces old playback. */
+	animate(target, transition = {}) {
+		this.assert(target);
+		validateTransition(transition);
+		if (this.disposed) return {
+			finished: Promise.resolve("cancelled"),
+			stop() {}
+		};
+		const velocity = transition.velocity ?? this.getVelocity();
+		this.stop("replaced");
+		const generation = ++this.generation;
+		this.emit("animationStart");
+		const controls = runAnimation(this.clock, this.current, target, {
+			...transition,
+			velocity
+		}, (value) => this.write(value));
+		this.controls = controls;
+		controls.finished.then((result) => {
+			if (generation !== this.generation || this.disposed) return;
+			this.controls = void 0;
+			if (result === "finished") this.emit("animationComplete");
+		});
+		return controls;
+	}
+	/** Stop playback at its current value. */
+	stop(reason = "cancelled") {
+		++this.generation;
+		if (this.controls) {
+			this.controls.stop(reason);
+			this.controls = void 0;
+			this.emit("animationCancel");
+		}
+	}
+	/** Release playback and listeners when the owning component unmounts. */
+	destroy() {
+		this.stop();
+		this.emit("destroy");
+		this.listeners.clear();
+		this.passive = void 0;
+		this.disposed = true;
+	}
+	/** @internal Install the useSpring setter interception. */
+	attach(setter) {
+		this.passive = setter;
+		return () => {
+			this.passive = void 0;
+			this.stop();
+		};
+	}
+};
+//#endregion
+//#region src/controller.ts
+var keys = [
+	"opacity",
+	"x",
+	"y",
+	"scale",
+	"scaleX",
+	"scaleY",
+	"rotate"
+];
+var defaults = {
+	opacity: 1,
+	x: 0,
+	y: 0,
+	scale: 1,
+	scaleX: 1,
+	scaleY: 1,
+	rotate: 0
+};
+function validateTarget(target) {
+	for (const [key, value] of Object.entries(target ?? {})) if (!keys.includes(key) || !Number.isFinite(value)) throw new Error(`motion: unsupported target ${key}; expected a finite numeric motion channel`);
+}
+var Controller = class {
+	clock;
+	values = /* @__PURE__ */ new Map();
+	write;
+	generation = 0;
+	constructor(clock) {
+		this.clock = clock;
+	}
+	value(key) {
+		let value = this.values.get(key);
+		if (!value) {
+			value = new MotionValue(defaults[key], this.clock);
+			this.values.set(key, value);
+			value.on("change", () => this.flush());
+		}
+		return value;
+	}
+	attach(write) {
+		this.write = write;
+		this.flush();
+	}
+	snapshot() {
+		return Object.fromEntries([...this.values].map(([key, value]) => [key, value.get()]));
+	}
+	flush() {
+		this.write?.(Object.fromEntries([...this.values].map(([key, value]) => [key, value.get()])));
+	}
+	set(key, next) {
+		this.value(key).jump(next);
+	}
+	seed(target) {
+		validateTarget(target);
+		for (const [key, value] of Object.entries(target)) this.set(key, value);
+	}
+	async animate(target, transition, reduced) {
+		validateTarget(target);
+		const generation = ++this.generation;
+		for (const value of this.values.values()) value.stop("replaced");
+		const jobs = Object.entries(target).map(([key, to]) => {
+			return this.value(key).animate(to, reduced && key !== "opacity" ? { duration: 0 } : transition).finished;
+		});
+		const results = await Promise.all(jobs);
+		if (generation !== this.generation) return "replaced";
+		return results.every((result) => result === "finished") ? "finished" : "cancelled";
+	}
+	stop() {
+		++this.generation;
+		for (const value of this.values.values()) value.stop();
+	}
+	destroy() {
+		this.stop();
+		for (const value of this.values.values()) value.destroy();
+		this.values.clear();
+		this.write = void 0;
+	}
+};
+//#endregion
+//#region src/components.tsrx
+var _hs$$1 = /* @__PURE__ */ hookSlots(19);
+var _h$0$1 = /* @__PURE__ */ Symbol(_hs$$1);
+var _h$1$1 = /* @__PURE__ */ Symbol(_hs$$1 + 1);
+var _h$2$1 = /* @__PURE__ */ Symbol(_hs$$1 + 2);
+var _h$3$1 = /* @__PURE__ */ Symbol(_hs$$1 + 3);
+var _h$4$1 = /* @__PURE__ */ Symbol(_hs$$1 + 4);
+var _h$5$1 = /* @__PURE__ */ Symbol(_hs$$1 + 5);
+var _h$6$1 = /* @__PURE__ */ Symbol(_hs$$1 + 6);
+var _h$7$1 = /* @__PURE__ */ Symbol(_hs$$1 + 7);
+var _h$8 = /* @__PURE__ */ Symbol(_hs$$1 + 8);
+var _h$9 = /* @__PURE__ */ Symbol(_hs$$1 + 9);
+var _h$10 = /* @__PURE__ */ Symbol(_hs$$1 + 10);
+var _h$11 = /* @__PURE__ */ Symbol(_hs$$1 + 11);
+var _h$12 = /* @__PURE__ */ Symbol(_hs$$1 + 12);
+var _h$13 = /* @__PURE__ */ Symbol(_hs$$1 + 13);
+var _h$14 = /* @__PURE__ */ Symbol(_hs$$1 + 14);
+var _h$15 = /* @__PURE__ */ Symbol(_hs$$1 + 15);
+var _h$16 = /* @__PURE__ */ Symbol(_hs$$1 + 16);
+var _h$17 = /* @__PURE__ */ Symbol(_hs$$1 + 17);
+var _h$18 = /* @__PURE__ */ Symbol(_hs$$1 + 18);
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan1 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan2 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+function useMotion(props) {
+	for (const name of [
+		"drag",
+		"layout",
+		"layoutId",
+		"variants",
+		"whileTap",
+		"whileHover",
+		"whileFocus",
+		"whileInView"
+	]) if (name in props) throw new Error(`motion: ${name} is outside the supported subset`);
+	const presence = useContext(PresenceContext);
+	if (props.exit && !presence) throw new Error("motion: exit requires a mounted Presence boundary");
+	const config = useContext(ConfigContext);
+	const systemReduced = withSlot(_h$0$1, useReducedMotion);
+	const reduced = config.reducedMotion === "always" || config.reducedMotion === "user" && systemReduced;
+	const transition = props.transition ?? config.transition ?? {};
+	validateTransition(transition);
+	validateTarget(props.animate);
+	validateTarget(props.exit);
+	if (props.initial !== false) validateTarget(props.initial);
+	const latest = useRef(props, _h$1$1);
+	latest.current = props;
+	const state = useRef(null, _h$2$1);
+	if (!state.current) state.current = {
+		controller: new Controller(clock),
+		initialized: false
+	};
+	const current = state.current;
+	const style = {};
+	const bindings = [];
+	for (const [key, value] of Object.entries(props.style ?? {})) if (keys.includes(key)) {
+		if (!(value instanceof MotionValue) && (typeof value !== "number" || !Number.isFinite(value))) throw new Error(`motion: invalid style ${key}`);
+		if (value instanceof MotionValue && (props.animate?.[key] !== void 0 || props.exit?.[key] !== void 0 || props.initial && props.initial[key] !== void 0)) throw new Error(`motion: ${key} has both an animate target and a MotionValue writer`);
+		bindings.push([key, value]);
+	} else {
+		if (value instanceof MotionValue || [
+			"transform",
+			"translateX",
+			"translateY",
+			"animation",
+			"transition"
+		].includes(key)) throw new Error(`motion: unsupported or conflicting style ${key}`);
+		style[key] = value;
+	}
+	const previous = useRef(bindings, _h$3$1);
+	const boundKeys = useRef([], _h$4$1);
+	const firstBinding = useRef(true, _h$5$1);
+	const firstAnimation = useRef(true, _h$6$1);
+	if (previous.current.length !== bindings.length || previous.current.some(([key, value], i) => key !== bindings[i][0] || value !== bindings[i][1])) previous.current = bindings;
+	const bind = useRef(() => {}, _h$7$1);
+	bind.current = (host) => {
+		if (!host) return;
+		if (current.host !== host) {
+			current.adapter?.restore();
+			current.host = host;
+			current.adapter = attachHost(host);
+			if (!current.initialized) {
+				const baseline = current.adapter.read();
+				for (const [key, value] of previous.current) baseline[key] = value instanceof MotionValue ? value.get() : value;
+				current.controller.seed(baseline);
+				current.controller.seed(props.initial === false ? props.animate ?? {} : props.initial ?? {});
+				current.initialized = true;
+			}
+			current.controller.attach(current.adapter.write);
+		}
+		current.controller.flush();
+		latest.current.bind?.(host);
+	};
+	const playback = useRef({
+		transition,
+		reduced
+	}, _h$8);
+	playback.current = {
+		transition,
+		reduced
+	};
+	const returning = useRef(null, _h$9);
+	const member = useRef(null, _h$10);
+	if (!member.current) member.current = {
+		exit() {
+			const snapshot = current.controller.snapshot();
+			returning.current ??= {};
+			for (const key of Object.keys(latest.current.exit ?? {})) if (!(key in returning.current)) returning.current[key] = snapshot[key];
+			return current.controller.animate(latest.current.exit ?? {}, playback.current.transition, playback.current.reduced);
+		},
+		enter() {
+			const target = {
+				...returning.current,
+				...latest.current.animate
+			};
+			returning.current = null;
+			current.controller.animate(target, playback.current.transition, playback.current.reduced).then((result) => {
+				if (result === "finished" && current.host && presence?.present) latest.current.onAnimationComplete?.();
+			});
+		}
+	};
+	useLayoutEffect(() => presence?.register(member.current), [presence], _h$11);
+	const stableBind = useRef((host) => bind.current(host), _h$12).current;
+	useLayoutEffect(() => () => {
+		current.controller.destroy();
+		current.host = void 0;
+		current.adapter = void 0;
+	}, [], _h$13);
+	useLayoutEffect(() => {
+		const off = [];
+		for (const key of boundKeys.current) if (!previous.current.some(([next]) => key === next)) current.controller.set(key, defaults[key]);
+		boundKeys.current = previous.current.map(([key]) => key);
+		for (const [key, value] of previous.current) {
+			if (!firstBinding.current) current.controller.set(key, value instanceof MotionValue ? value.get() : value);
+			if (value instanceof MotionValue) off.push(value.on("change", (next) => current.controller.set(key, next)));
+		}
+		firstBinding.current = false;
+		return () => off.forEach((unsubscribe) => unsubscribe());
+	}, [previous.current], _h$14);
+	useLayoutEffect(() => {
+		let active = true;
+		const skip = firstAnimation.current && props.initial === false;
+		firstAnimation.current = false;
+		if (presence && !presence.present) presence.restart(member.current);
+		else if (props.animate && !skip) current.controller.animate(props.animate, transition, reduced).then((result) => {
+			if (active && result === "finished") latest.current.onAnimationComplete?.();
+		});
+		return () => {
+			active = false;
+			current.controller.stop();
+		};
+	}, [
+		JSON.stringify(props.animate),
+		JSON.stringify(props.exit),
+		JSON.stringify(transition),
+		reduced
+	], _h$15);
+	const { initial, exit, animate, transition: ignoredTransition, onAnimationComplete, style: ignoredStyle, bind: ignoredBind, ...rest } = props;
+	return {
+		...rest,
+		style,
+		bind: stableBind
+	};
+}
+var MotionView = defineUniversalComponent("nativescript", function MotionView(props) {
+	return universalValue(__octaneUniversalPlan0, [universalComponent("nativescript", View, universalProps([["spread", withSlot(_h$16, useMotion, props)]], props.children))]);
+}, { "module": "@nativescript-community/octane" });
+var MotionRow = defineUniversalComponent("nativescript", function MotionRow(props) {
+	return universalValue(__octaneUniversalPlan1, [universalComponent("nativescript", Row, universalProps([["spread", withSlot(_h$17, useMotion, props)]], props.children))]);
+}, { "module": "@nativescript-community/octane" });
+var MotionPressable = defineUniversalComponent("nativescript", function MotionPressable(props) {
+	return universalValue(__octaneUniversalPlan2, [universalComponent("nativescript", Pressable, universalProps([["spread", withSlot(_h$18, useMotion, props)]], props.children))]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+//#region src/hooks.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(8);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
+var _h$3 = /* @__PURE__ */ Symbol(_hs$ + 3);
+var _h$4 = /* @__PURE__ */ Symbol(_hs$ + 4);
+var _h$5 = /* @__PURE__ */ Symbol(_hs$ + 5);
+var _h$6 = /* @__PURE__ */ Symbol(_hs$ + 6);
+var _h$7 = /* @__PURE__ */ Symbol(_hs$ + 7);
+function useMotionValue(initial) {
+	const ref = useRef(null, _h$0);
+	if (!ref.current) ref.current = new MotionValue(initial, clock);
+	const value = ref.current;
+	useLayoutEffect(() => () => value.destroy(), [], _h$1);
+	return value;
+}
+function useMotionValueEvent(value, event, callback) {
+	useLayoutEffect(() => value.on(event, callback), [
+		value,
+		event,
+		callback
+	], _h$2);
+}
+function useTransform(source, input, output, options) {
+	const sources = Array.isArray(source) ? source : [source];
+	if (Array.isArray(input) && (!output || input.length !== output.length || input.length < 2)) throw new Error("motion: transform ranges must have matching lengths >= 2");
+	const transform = typeof input === "function" ? input : interpolate(input, output, options);
+	const read = () => transform(Array.isArray(source) ? sources.map((value) => value.get()) : source.get());
+	const value = withSlot(_h$3, useMotionValue, read());
+	const previous = useRef(sources, _h$4);
+	if (previous.current.length !== sources.length || previous.current.some((value, i) => value !== sources[i])) previous.current = sources;
+	useLayoutEffect(() => {
+		const update = () => value.set(read());
+		const off = sources.map((source) => source.on("change", update));
+		update();
+		return () => off.forEach((unsubscribe) => unsubscribe());
+	}, [
+		previous.current,
+		input,
+		output,
+		options?.clamp
+	], _h$5);
+	return value;
+}
+function useSpring(source, options = {}) {
+	const value = withSlot(_h$6, useMotionValue, source instanceof MotionValue ? source.get() : source);
+	useLayoutEffect(() => {
+		const follow = (target) => {
+			value.animate(target, {
+				...options,
+				type: "spring"
+			});
+		};
+		const detach = value.attach(follow);
+		const unsubscribe = source instanceof MotionValue ? source.on("change", follow) : void 0;
+		if (source instanceof MotionValue && source.get() !== value.get()) follow(source.get());
+		return () => {
+			unsubscribe?.();
+			detach();
+		};
+	}, [source instanceof MotionValue ? source : null, JSON.stringify(options)], _h$7);
+	return value;
+}
+//#endregion
+//#region src/index.ts
+/** Bounded motion hosts for shared xplat UI primitives. */
+var motion = {
+	View: MotionView,
+	Row: MotionRow,
+	Pressable: MotionPressable
+};
+//#endregion
+export { MotionConfig, Presence, motion, useMotionValue, useMotionValueEvent, useReducedMotion, useSpring, useTransform };